commit 4146027cb7028d75a351ca9deeac2444eb1ffe4a
Author: zznty <94796179+zznty@users.noreply.github.com>
Date:   Thu May 30 16:04:19 2024 +0700

    1

diff --git a/parent_dir/node_modules/axios/lib/adapters/adapters.js b/parent_dir/node_modules/axios/lib/adapters/adapters.js
new file mode 100644
index 0000000..e31fca1
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/adapters/adapters.js
@@ -0,0 +1,59 @@
+import utils from '../utils.js';
+import httpAdapter from './http.js';
+import xhrAdapter from './xhr.js';
+import AxiosError from "../core/AxiosError.js";
+
+const knownAdapters = {
+  http: httpAdapter,
+  xhr: xhrAdapter
+}
+
+utils.forEach(knownAdapters, (fn, value) => {
+  if(fn) {
+    try {
+      Object.defineProperty(fn, 'name', {value});
+    } catch (e) {
+      // eslint-disable-next-line no-empty
+    }
+    Object.defineProperty(fn, 'adapterName', {value});
+  }
+});
+
+export default {
+  getAdapter: (adapters) => {
+    adapters = utils.isArray(adapters) ? adapters : [adapters];
+
+    const {length} = adapters;
+    let nameOrAdapter;
+    let adapter;
+
+    for (let i = 0; i < length; i++) {
+      nameOrAdapter = adapters[i];
+      if((adapter = utils.isString(nameOrAdapter) ? knownAdapters[nameOrAdapter.toLowerCase()] : nameOrAdapter)) {
+        break;
+      }
+    }
+
+    if (!adapter) {
+      if (adapter === false) {
+        throw new AxiosError(
+          `Adapter ${nameOrAdapter} is not supported by the environment`,
+          'ERR_NOT_SUPPORT'
+        );
+      }
+
+      throw new Error(
+        utils.hasOwnProp(knownAdapters, nameOrAdapter) ?
+          `Adapter '${nameOrAdapter}' is not available in the build` :
+          `Unknown adapter '${nameOrAdapter}'`
+      );
+    }
+
+    if (!utils.isFunction(adapter)) {
+      throw new TypeError('adapter is not a function');
+    }
+
+    return adapter;
+  },
+  adapters: knownAdapters
+}
diff --git a/parent_dir/node_modules/axios/lib/adapters/xhr.js b/parent_dir/node_modules/axios/lib/adapters/xhr.js
new file mode 100644
index 0000000..021da2a
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/adapters/xhr.js
@@ -0,0 +1,249 @@
+'use strict';
+
+import utils from './../utils.js';
+import settle from './../core/settle.js';
+import cookies from './../helpers/cookies.js';
+import buildURL from './../helpers/buildURL.js';
+import buildFullPath from '../core/buildFullPath.js';
+import isURLSameOrigin from './../helpers/isURLSameOrigin.js';
+import transitionalDefaults from '../defaults/transitional.js';
+import AxiosError from '../core/AxiosError.js';
+import CanceledError from '../cancel/CanceledError.js';
+import parseProtocol from '../helpers/parseProtocol.js';
+import platform from '../platform/index.js';
+import AxiosHeaders from '../core/AxiosHeaders.js';
+import speedometer from '../helpers/speedometer.js';
+
+function progressEventReducer(listener, isDownloadStream) {
+  let bytesNotified = 0;
+  const _speedometer = speedometer(50, 250);
+
+  return e => {
+    const loaded = e.loaded;
+    const total = e.lengthComputable ? e.total : undefined;
+    const progressBytes = loaded - bytesNotified;
+    const rate = _speedometer(progressBytes);
+    const inRange = loaded <= total;
+
+    bytesNotified = loaded;
+
+    const data = {
+      loaded,
+      total,
+      progress: total ? (loaded / total) : undefined,
+      bytes: progressBytes,
+      rate: rate ? rate : undefined,
+      estimated: rate && total && inRange ? (total - loaded) / rate : undefined,
+      event: e
+    };
+
+    data[isDownloadStream ? 'download' : 'upload'] = true;
+
+    listener(data);
+  };
+}
+
+const isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';
+
+export default isXHRAdapterSupported && function (config) {
+  return new Promise(function dispatchXhrRequest(resolve, reject) {
+    let requestData = config.data;
+    const requestHeaders = AxiosHeaders.from(config.headers).normalize();
+    const responseType = config.responseType;
+    let onCanceled;
+    function done() {
+      if (config.cancelToken) {
+        config.cancelToken.unsubscribe(onCanceled);
+      }
+
+      if (config.signal) {
+        config.signal.removeEventListener('abort', onCanceled);
+      }
+    }
+
+    if (utils.isFormData(requestData) && (platform.isStandardBrowserEnv || platform.isStandardBrowserWebWorkerEnv)) {
+      requestHeaders.setContentType(false); // Let the browser set it
+    }
+
+    let request = new XMLHttpRequest();
+
+    // HTTP basic authentication
+    if (config.auth) {
+      const username = config.auth.username || '';
+      const password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';
+      requestHeaders.set('Authorization', 'Basic ' + btoa(username + ':' + password));
+    }
+
+    const fullPath = buildFullPath(config.baseURL, config.url);
+
+    request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
+
+    // Set the request timeout in MS
+    request.timeout = config.timeout;
+
+    function onloadend() {
+      if (!request) {
+        return;
+      }
+      // Prepare the response
+      const responseHeaders = AxiosHeaders.from(
+        'getAllResponseHeaders' in request && request.getAllResponseHeaders()
+      );
+      const responseData = !responseType || responseType === 'text' || responseType === 'json' ?
+        request.responseText : request.response;
+      const response = {
+        data: responseData,
+        status: request.status,
+        statusText: request.statusText,
+        headers: responseHeaders,
+        config,
+        request
+      };
+
+      settle(function _resolve(value) {
+        resolve(value);
+        done();
+      }, function _reject(err) {
+        reject(err);
+        done();
+      }, response);
+
+      // Clean up request
+      request = null;
+    }
+
+    if ('onloadend' in request) {
+      // Use onloadend if available
+      request.onloadend = onloadend;
+    } else {
+      // Listen for ready state to emulate onloadend
+      request.onreadystatechange = function handleLoad() {
+        if (!request || request.readyState !== 4) {
+          return;
+        }
+
+        // The request errored out and we didn't get a response, this will be
+        // handled by onerror instead
+        // With one exception: request that using file: protocol, most browsers
+        // will return status as 0 even though it's a successful request
+        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
+          return;
+        }
+        // readystate handler is calling before onerror or ontimeout handlers,
+        // so we should call onloadend on the next 'tick'
+        setTimeout(onloadend);
+      };
+    }
+
+    // Handle browser request cancellation (as opposed to a manual cancellation)
+    request.onabort = function handleAbort() {
+      if (!request) {
+        return;
+      }
+
+      reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, config, request));
+
+      // Clean up request
+      request = null;
+    };
+
+    // Handle low level network errors
+    request.onerror = function handleError() {
+      // Real errors are hidden from us by the browser
+      // onerror should only fire if it's a network error
+      reject(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request));
+
+      // Clean up request
+      request = null;
+    };
+
+    // Handle timeout
+    request.ontimeout = function handleTimeout() {
+      let timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded';
+      const transitional = config.transitional || transitionalDefaults;
+      if (config.timeoutErrorMessage) {
+        timeoutErrorMessage = config.timeoutErrorMessage;
+      }
+      reject(new AxiosError(
+        timeoutErrorMessage,
+        transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,
+        config,
+        request));
+
+      // Clean up request
+      request = null;
+    };
+
+    // Add xsrf header
+    // This is only done if running in a standard browser environment.
+    // Specifically not if we're in a web worker, or react-native.
+    if (platform.isStandardBrowserEnv) {
+      // Add xsrf header
+      const xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath))
+        && config.xsrfCookieName && cookies.read(config.xsrfCookieName);
+
+      if (xsrfValue) {
+        requestHeaders.set(config.xsrfHeaderName, xsrfValue);
+      }
+    }
+
+    // Remove Content-Type if data is undefined
+    requestData === undefined && requestHeaders.setContentType(null);
+
+    // Add headers to the request
+    if ('setRequestHeader' in request) {
+      utils.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
+        request.setRequestHeader(key, val);
+      });
+    }
+
+    // Add withCredentials to request if needed
+    if (!utils.isUndefined(config.withCredentials)) {
+      request.withCredentials = !!config.withCredentials;
+    }
+
+    // Add responseType to request if needed
+    if (responseType && responseType !== 'json') {
+      request.responseType = config.responseType;
+    }
+
+    // Handle progress if needed
+    if (typeof config.onDownloadProgress === 'function') {
+      request.addEventListener('progress', progressEventReducer(config.onDownloadProgress, true));
+    }
+
+    // Not all browsers support upload events
+    if (typeof config.onUploadProgress === 'function' && request.upload) {
+      request.upload.addEventListener('progress', progressEventReducer(config.onUploadProgress));
+    }
+
+    if (config.cancelToken || config.signal) {
+      // Handle cancellation
+      // eslint-disable-next-line func-names
+      onCanceled = cancel => {
+        if (!request) {
+          return;
+        }
+        reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);
+        request.abort();
+        request = null;
+      };
+
+      config.cancelToken && config.cancelToken.subscribe(onCanceled);
+      if (config.signal) {
+        config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);
+      }
+    }
+
+    const protocol = parseProtocol(fullPath);
+
+    if (protocol && platform.protocols.indexOf(protocol) === -1) {
+      reject(new AxiosError('Unsupported protocol ' + protocol + ':', AxiosError.ERR_BAD_REQUEST, config));
+      return;
+    }
+
+
+    // Send the request
+    request.send(requestData || null);
+  });
+}
diff --git a/parent_dir/node_modules/axios/lib/axios.js b/parent_dir/node_modules/axios/lib/axios.js
new file mode 100644
index 0000000..c97e062
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/axios.js
@@ -0,0 +1,86 @@
+'use strict';
+
+import utils from './utils.js';
+import bind from './helpers/bind.js';
+import Axios from './core/Axios.js';
+import mergeConfig from './core/mergeConfig.js';
+import defaults from './defaults/index.js';
+import formDataToJSON from './helpers/formDataToJSON.js';
+import CanceledError from './cancel/CanceledError.js';
+import CancelToken from './cancel/CancelToken.js';
+import isCancel from './cancel/isCancel.js';
+import {VERSION} from './env/data.js';
+import toFormData from './helpers/toFormData.js';
+import AxiosError from './core/AxiosError.js';
+import spread from './helpers/spread.js';
+import isAxiosError from './helpers/isAxiosError.js';
+import AxiosHeaders from "./core/AxiosHeaders.js";
+import HttpStatusCode from './helpers/HttpStatusCode.js';
+
+/**
+ * Create an instance of Axios
+ *
+ * @param {Object} defaultConfig The default config for the instance
+ *
+ * @returns {Axios} A new instance of Axios
+ */
+function createInstance(defaultConfig) {
+  const context = new Axios(defaultConfig);
+  const instance = bind(Axios.prototype.request, context);
+
+  // Copy axios.prototype to instance
+  utils.extend(instance, Axios.prototype, context, {allOwnKeys: true});
+
+  // Copy context to instance
+  utils.extend(instance, context, null, {allOwnKeys: true});
+
+  // Factory for creating new instances
+  instance.create = function create(instanceConfig) {
+    return createInstance(mergeConfig(defaultConfig, instanceConfig));
+  };
+
+  return instance;
+}
+
+// Create the default instance to be exported
+const axios = createInstance(defaults);
+
+// Expose Axios class to allow class inheritance
+axios.Axios = Axios;
+
+// Expose Cancel & CancelToken
+axios.CanceledError = CanceledError;
+axios.CancelToken = CancelToken;
+axios.isCancel = isCancel;
+axios.VERSION = VERSION;
+axios.toFormData = toFormData;
+
+// Expose AxiosError class
+axios.AxiosError = AxiosError;
+
+// alias for CanceledError for backward compatibility
+axios.Cancel = axios.CanceledError;
+
+// Expose all/spread
+axios.all = function all(promises) {
+  return Promise.all(promises);
+};
+
+axios.spread = spread;
+
+// Expose isAxiosError
+axios.isAxiosError = isAxiosError;
+
+// Expose mergeConfig
+axios.mergeConfig = mergeConfig;
+
+axios.AxiosHeaders = AxiosHeaders;
+
+axios.formToJSON = thing => formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);
+
+axios.HttpStatusCode = HttpStatusCode;
+
+axios.default = axios;
+
+// this module should only have a default export
+export default axios
diff --git a/parent_dir/node_modules/axios/lib/cancel/CancelToken.js b/parent_dir/node_modules/axios/lib/cancel/CancelToken.js
new file mode 100644
index 0000000..20d8f68
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/cancel/CancelToken.js
@@ -0,0 +1,121 @@
+'use strict';
+
+import CanceledError from './CanceledError.js';
+
+/**
+ * A `CancelToken` is an object that can be used to request cancellation of an operation.
+ *
+ * @param {Function} executor The executor function.
+ *
+ * @returns {CancelToken}
+ */
+class CancelToken {
+  constructor(executor) {
+    if (typeof executor !== 'function') {
+      throw new TypeError('executor must be a function.');
+    }
+
+    let resolvePromise;
+
+    this.promise = new Promise(function promiseExecutor(resolve) {
+      resolvePromise = resolve;
+    });
+
+    const token = this;
+
+    // eslint-disable-next-line func-names
+    this.promise.then(cancel => {
+      if (!token._listeners) return;
+
+      let i = token._listeners.length;
+
+      while (i-- > 0) {
+        token._listeners[i](cancel);
+      }
+      token._listeners = null;
+    });
+
+    // eslint-disable-next-line func-names
+    this.promise.then = onfulfilled => {
+      let _resolve;
+      // eslint-disable-next-line func-names
+      const promise = new Promise(resolve => {
+        token.subscribe(resolve);
+        _resolve = resolve;
+      }).then(onfulfilled);
+
+      promise.cancel = function reject() {
+        token.unsubscribe(_resolve);
+      };
+
+      return promise;
+    };
+
+    executor(function cancel(message, config, request) {
+      if (token.reason) {
+        // Cancellation has already been requested
+        return;
+      }
+
+      token.reason = new CanceledError(message, config, request);
+      resolvePromise(token.reason);
+    });
+  }
+
+  /**
+   * Throws a `CanceledError` if cancellation has been requested.
+   */
+  throwIfRequested() {
+    if (this.reason) {
+      throw this.reason;
+    }
+  }
+
+  /**
+   * Subscribe to the cancel signal
+   */
+
+  subscribe(listener) {
+    if (this.reason) {
+      listener(this.reason);
+      return;
+    }
+
+    if (this._listeners) {
+      this._listeners.push(listener);
+    } else {
+      this._listeners = [listener];
+    }
+  }
+
+  /**
+   * Unsubscribe from the cancel signal
+   */
+
+  unsubscribe(listener) {
+    if (!this._listeners) {
+      return;
+    }
+    const index = this._listeners.indexOf(listener);
+    if (index !== -1) {
+      this._listeners.splice(index, 1);
+    }
+  }
+
+  /**
+   * Returns an object that contains a new `CancelToken` and a function that, when called,
+   * cancels the `CancelToken`.
+   */
+  static source() {
+    let cancel;
+    const token = new CancelToken(function executor(c) {
+      cancel = c;
+    });
+    return {
+      token,
+      cancel
+    };
+  }
+}
+
+export default CancelToken;
diff --git a/parent_dir/node_modules/axios/lib/cancel/CanceledError.js b/parent_dir/node_modules/axios/lib/cancel/CanceledError.js
new file mode 100644
index 0000000..880066e
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/cancel/CanceledError.js
@@ -0,0 +1,25 @@
+'use strict';
+
+import AxiosError from '../core/AxiosError.js';
+import utils from '../utils.js';
+
+/**
+ * A `CanceledError` is an object that is thrown when an operation is canceled.
+ *
+ * @param {string=} message The message.
+ * @param {Object=} config The config.
+ * @param {Object=} request The request.
+ *
+ * @returns {CanceledError} The created error.
+ */
+function CanceledError(message, config, request) {
+  // eslint-disable-next-line no-eq-null,eqeqeq
+  AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);
+  this.name = 'CanceledError';
+}
+
+utils.inherits(CanceledError, AxiosError, {
+  __CANCEL__: true
+});
+
+export default CanceledError;
diff --git a/parent_dir/node_modules/axios/lib/cancel/isCancel.js b/parent_dir/node_modules/axios/lib/cancel/isCancel.js
new file mode 100644
index 0000000..a444a12
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/cancel/isCancel.js
@@ -0,0 +1,5 @@
+'use strict';
+
+export default function isCancel(value) {
+  return !!(value && value.__CANCEL__);
+}
diff --git a/parent_dir/node_modules/axios/lib/core/Axios.js b/parent_dir/node_modules/axios/lib/core/Axios.js
new file mode 100644
index 0000000..7a6e6f5
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/core/Axios.js
@@ -0,0 +1,203 @@
+'use strict';
+
+import utils from './../utils.js';
+import buildURL from '../helpers/buildURL.js';
+import InterceptorManager from './InterceptorManager.js';
+import dispatchRequest from './dispatchRequest.js';
+import mergeConfig from './mergeConfig.js';
+import buildFullPath from './buildFullPath.js';
+import validator from '../helpers/validator.js';
+import AxiosHeaders from './AxiosHeaders.js';
+
+const validators = validator.validators;
+
+/**
+ * Create a new instance of Axios
+ *
+ * @param {Object} instanceConfig The default config for the instance
+ *
+ * @return {Axios} A new instance of Axios
+ */
+class Axios {
+  constructor(instanceConfig) {
+    this.defaults = instanceConfig;
+    this.interceptors = {
+      request: new InterceptorManager(),
+      response: new InterceptorManager()
+    };
+  }
+
+  /**
+   * Dispatch a request
+   *
+   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
+   * @param {?Object} config
+   *
+   * @returns {Promise} The Promise to be fulfilled
+   */
+  request(configOrUrl, config) {
+    /*eslint no-param-reassign:0*/
+    // Allow for axios('example/url'[, config]) a la fetch API
+    if (typeof configOrUrl === 'string') {
+      config = config || {};
+      config.url = configOrUrl;
+    } else {
+      config = configOrUrl || {};
+    }
+
+    config = mergeConfig(this.defaults, config);
+
+    const {transitional, paramsSerializer, headers} = config;
+
+    if (transitional !== undefined) {
+      validator.assertOptions(transitional, {
+        silentJSONParsing: validators.transitional(validators.boolean),
+        forcedJSONParsing: validators.transitional(validators.boolean),
+        clarifyTimeoutError: validators.transitional(validators.boolean)
+      }, false);
+    }
+
+    if (paramsSerializer != null) {
+      if (utils.isFunction(paramsSerializer)) {
+        config.paramsSerializer = {
+          serialize: paramsSerializer
+        }
+      } else {
+        validator.assertOptions(paramsSerializer, {
+          encode: validators.function,
+          serialize: validators.function
+        }, true);
+      }
+    }
+
+    // Set config.method
+    config.method = (config.method || this.defaults.method || 'get').toLowerCase();
+
+    let contextHeaders;
+
+    // Flatten headers
+    contextHeaders = headers && utils.merge(
+      headers.common,
+      headers[config.method]
+    );
+
+    contextHeaders && utils.forEach(
+      ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
+      (method) => {
+        delete headers[method];
+      }
+    );
+
+    config.headers = AxiosHeaders.concat(contextHeaders, headers);
+
+    // filter out skipped interceptors
+    const requestInterceptorChain = [];
+    let synchronousRequestInterceptors = true;
+    this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+      if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {
+        return;
+      }
+
+      synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
+
+      requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+    });
+
+    const responseInterceptorChain = [];
+    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+      responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+    });
+
+    let promise;
+    let i = 0;
+    let len;
+
+    if (!synchronousRequestInterceptors) {
+      const chain = [dispatchRequest.bind(this), undefined];
+      chain.unshift.apply(chain, requestInterceptorChain);
+      chain.push.apply(chain, responseInterceptorChain);
+      len = chain.length;
+
+      promise = Promise.resolve(config);
+
+      while (i < len) {
+        promise = promise.then(chain[i++], chain[i++]);
+      }
+
+      return promise;
+    }
+
+    len = requestInterceptorChain.length;
+
+    let newConfig = config;
+
+    i = 0;
+
+    while (i < len) {
+      const onFulfilled = requestInterceptorChain[i++];
+      const onRejected = requestInterceptorChain[i++];
+      try {
+        newConfig = onFulfilled(newConfig);
+      } catch (error) {
+        onRejected.call(this, error);
+        break;
+      }
+    }
+
+    try {
+      promise = dispatchRequest.call(this, newConfig);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+
+    i = 0;
+    len = responseInterceptorChain.length;
+
+    while (i < len) {
+      promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);
+    }
+
+    return promise;
+  }
+
+  getUri(config) {
+    config = mergeConfig(this.defaults, config);
+    const fullPath = buildFullPath(config.baseURL, config.url);
+    return buildURL(fullPath, config.params, config.paramsSerializer);
+  }
+}
+
+// Provide aliases for supported request methods
+utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
+  /*eslint func-names:0*/
+  Axios.prototype[method] = function(url, config) {
+    return this.request(mergeConfig(config || {}, {
+      method,
+      url,
+      data: (config || {}).data
+    }));
+  };
+});
+
+utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
+  /*eslint func-names:0*/
+
+  function generateHTTPMethod(isForm) {
+    return function httpMethod(url, data, config) {
+      return this.request(mergeConfig(config || {}, {
+        method,
+        headers: isForm ? {
+          'Content-Type': 'multipart/form-data'
+        } : {},
+        url,
+        data
+      }));
+    };
+  }
+
+  Axios.prototype[method] = generateHTTPMethod();
+
+  Axios.prototype[method + 'Form'] = generateHTTPMethod(true);
+});
+
+export default Axios;
diff --git a/parent_dir/node_modules/axios/lib/core/AxiosError.js b/parent_dir/node_modules/axios/lib/core/AxiosError.js
new file mode 100644
index 0000000..7141a8c
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/core/AxiosError.js
@@ -0,0 +1,100 @@
+'use strict';
+
+import utils from '../utils.js';
+
+/**
+ * Create an Error with the specified message, config, error code, request and response.
+ *
+ * @param {string} message The error message.
+ * @param {string} [code] The error code (for example, 'ECONNABORTED').
+ * @param {Object} [config] The config.
+ * @param {Object} [request] The request.
+ * @param {Object} [response] The response.
+ *
+ * @returns {Error} The created error.
+ */
+function AxiosError(message, code, config, request, response) {
+  Error.call(this);
+
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, this.constructor);
+  } else {
+    this.stack = (new Error()).stack;
+  }
+
+  this.message = message;
+  this.name = 'AxiosError';
+  code && (this.code = code);
+  config && (this.config = config);
+  request && (this.request = request);
+  response && (this.response = response);
+}
+
+utils.inherits(AxiosError, Error, {
+  toJSON: function toJSON() {
+    return {
+      // Standard
+      message: this.message,
+      name: this.name,
+      // Microsoft
+      description: this.description,
+      number: this.number,
+      // Mozilla
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      // Axios
+      config: utils.toJSONObject(this.config),
+      code: this.code,
+      status: this.response && this.response.status ? this.response.status : null
+    };
+  }
+});
+
+const prototype = AxiosError.prototype;
+const descriptors = {};
+
+[
+  'ERR_BAD_OPTION_VALUE',
+  'ERR_BAD_OPTION',
+  'ECONNABORTED',
+  'ETIMEDOUT',
+  'ERR_NETWORK',
+  'ERR_FR_TOO_MANY_REDIRECTS',
+  'ERR_DEPRECATED',
+  'ERR_BAD_RESPONSE',
+  'ERR_BAD_REQUEST',
+  'ERR_CANCELED',
+  'ERR_NOT_SUPPORT',
+  'ERR_INVALID_URL'
+// eslint-disable-next-line func-names
+].forEach(code => {
+  descriptors[code] = {value: code};
+});
+
+Object.defineProperties(AxiosError, descriptors);
+Object.defineProperty(prototype, 'isAxiosError', {value: true});
+
+// eslint-disable-next-line func-names
+AxiosError.from = (error, code, config, request, response, customProps) => {
+  const axiosError = Object.create(prototype);
+
+  utils.toFlatObject(error, axiosError, function filter(obj) {
+    return obj !== Error.prototype;
+  }, prop => {
+    return prop !== 'isAxiosError';
+  });
+
+  AxiosError.call(axiosError, error.message, code, config, request, response);
+
+  axiosError.cause = error;
+
+  axiosError.name = error.name;
+
+  customProps && Object.assign(axiosError, customProps);
+
+  return axiosError;
+};
+
+export default AxiosError;
diff --git a/parent_dir/node_modules/axios/lib/core/AxiosHeaders.js b/parent_dir/node_modules/axios/lib/core/AxiosHeaders.js
new file mode 100644
index 0000000..361d340
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/core/AxiosHeaders.js
@@ -0,0 +1,288 @@
+'use strict';
+
+import utils from '../utils.js';
+import parseHeaders from '../helpers/parseHeaders.js';
+
+const $internals = Symbol('internals');
+
+function normalizeHeader(header) {
+  return header && String(header).trim().toLowerCase();
+}
+
+function normalizeValue(value) {
+  if (value === false || value == null) {
+    return value;
+  }
+
+  return utils.isArray(value) ? value.map(normalizeValue) : String(value);
+}
+
+function parseTokens(str) {
+  const tokens = Object.create(null);
+  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
+  let match;
+
+  while ((match = tokensRE.exec(str))) {
+    tokens[match[1]] = match[2];
+  }
+
+  return tokens;
+}
+
+const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
+
+function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
+  if (utils.isFunction(filter)) {
+    return filter.call(this, value, header);
+  }
+
+  if (isHeaderNameFilter) {
+    value = header;
+  }
+
+  if (!utils.isString(value)) return;
+
+  if (utils.isString(filter)) {
+    return value.indexOf(filter) !== -1;
+  }
+
+  if (utils.isRegExp(filter)) {
+    return filter.test(value);
+  }
+}
+
+function formatHeader(header) {
+  return header.trim()
+    .toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
+      return char.toUpperCase() + str;
+    });
+}
+
+function buildAccessors(obj, header) {
+  const accessorName = utils.toCamelCase(' ' + header);
+
+  ['get', 'set', 'has'].forEach(methodName => {
+    Object.defineProperty(obj, methodName + accessorName, {
+      value: function(arg1, arg2, arg3) {
+        return this[methodName].call(this, header, arg1, arg2, arg3);
+      },
+      configurable: true
+    });
+  });
+}
+
+class AxiosHeaders {
+  constructor(headers) {
+    headers && this.set(headers);
+  }
+
+  set(header, valueOrRewrite, rewrite) {
+    const self = this;
+
+    function setHeader(_value, _header, _rewrite) {
+      const lHeader = normalizeHeader(_header);
+
+      if (!lHeader) {
+        throw new Error('header name must be a non-empty string');
+      }
+
+      const key = utils.findKey(self, lHeader);
+
+      if(!key || self[key] === undefined || _rewrite === true || (_rewrite === undefined && self[key] !== false)) {
+        self[key || _header] = normalizeValue(_value);
+      }
+    }
+
+    const setHeaders = (headers, _rewrite) =>
+      utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
+
+    if (utils.isPlainObject(header) || header instanceof this.constructor) {
+      setHeaders(header, valueOrRewrite)
+    } else if(utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
+      setHeaders(parseHeaders(header), valueOrRewrite);
+    } else {
+      header != null && setHeader(valueOrRewrite, header, rewrite);
+    }
+
+    return this;
+  }
+
+  get(header, parser) {
+    header = normalizeHeader(header);
+
+    if (header) {
+      const key = utils.findKey(this, header);
+
+      if (key) {
+        const value = this[key];
+
+        if (!parser) {
+          return value;
+        }
+
+        if (parser === true) {
+          return parseTokens(value);
+        }
+
+        if (utils.isFunction(parser)) {
+          return parser.call(this, value, key);
+        }
+
+        if (utils.isRegExp(parser)) {
+          return parser.exec(value);
+        }
+
+        throw new TypeError('parser must be boolean|regexp|function');
+      }
+    }
+  }
+
+  has(header, matcher) {
+    header = normalizeHeader(header);
+
+    if (header) {
+      const key = utils.findKey(this, header);
+
+      return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
+    }
+
+    return false;
+  }
+
+  delete(header, matcher) {
+    const self = this;
+    let deleted = false;
+
+    function deleteHeader(_header) {
+      _header = normalizeHeader(_header);
+
+      if (_header) {
+        const key = utils.findKey(self, _header);
+
+        if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {
+          delete self[key];
+
+          deleted = true;
+        }
+      }
+    }
+
+    if (utils.isArray(header)) {
+      header.forEach(deleteHeader);
+    } else {
+      deleteHeader(header);
+    }
+
+    return deleted;
+  }
+
+  clear(matcher) {
+    const keys = Object.keys(this);
+    let i = keys.length;
+    let deleted = false;
+
+    while (i--) {
+      const key = keys[i];
+      if(!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
+        delete this[key];
+        deleted = true;
+      }
+    }
+
+    return deleted;
+  }
+
+  normalize(format) {
+    const self = this;
+    const headers = {};
+
+    utils.forEach(this, (value, header) => {
+      const key = utils.findKey(headers, header);
+
+      if (key) {
+        self[key] = normalizeValue(value);
+        delete self[header];
+        return;
+      }
+
+      const normalized = format ? formatHeader(header) : String(header).trim();
+
+      if (normalized !== header) {
+        delete self[header];
+      }
+
+      self[normalized] = normalizeValue(value);
+
+      headers[normalized] = true;
+    });
+
+    return this;
+  }
+
+  concat(...targets) {
+    return this.constructor.concat(this, ...targets);
+  }
+
+  toJSON(asStrings) {
+    const obj = Object.create(null);
+
+    utils.forEach(this, (value, header) => {
+      value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value);
+    });
+
+    return obj;
+  }
+
+  [Symbol.iterator]() {
+    return Object.entries(this.toJSON())[Symbol.iterator]();
+  }
+
+  toString() {
+    return Object.entries(this.toJSON()).map(([header, value]) => header + ': ' + value).join('\n');
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'AxiosHeaders';
+  }
+
+  static from(thing) {
+    return thing instanceof this ? thing : new this(thing);
+  }
+
+  static concat(first, ...targets) {
+    const computed = new this(first);
+
+    targets.forEach((target) => computed.set(target));
+
+    return computed;
+  }
+
+  static accessor(header) {
+    const internals = this[$internals] = (this[$internals] = {
+      accessors: {}
+    });
+
+    const accessors = internals.accessors;
+    const prototype = this.prototype;
+
+    function defineAccessor(_header) {
+      const lHeader = normalizeHeader(_header);
+
+      if (!accessors[lHeader]) {
+        buildAccessors(prototype, _header);
+        accessors[lHeader] = true;
+      }
+    }
+
+    utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
+
+    return this;
+  }
+}
+
+AxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);
+
+utils.freezeMethods(AxiosHeaders.prototype);
+utils.freezeMethods(AxiosHeaders);
+
+export default AxiosHeaders;
diff --git a/parent_dir/node_modules/axios/lib/core/InterceptorManager.js b/parent_dir/node_modules/axios/lib/core/InterceptorManager.js
new file mode 100644
index 0000000..6657a9d
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/core/InterceptorManager.js
@@ -0,0 +1,71 @@
+'use strict';
+
+import utils from './../utils.js';
+
+class InterceptorManager {
+  constructor() {
+    this.handlers = [];
+  }
+
+  /**
+   * Add a new interceptor to the stack
+   *
+   * @param {Function} fulfilled The function to handle `then` for a `Promise`
+   * @param {Function} rejected The function to handle `reject` for a `Promise`
+   *
+   * @return {Number} An ID used to remove interceptor later
+   */
+  use(fulfilled, rejected, options) {
+    this.handlers.push({
+      fulfilled,
+      rejected,
+      synchronous: options ? options.synchronous : false,
+      runWhen: options ? options.runWhen : null
+    });
+    return this.handlers.length - 1;
+  }
+
+  /**
+   * Remove an interceptor from the stack
+   *
+   * @param {Number} id The ID that was returned by `use`
+   *
+   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
+   */
+  eject(id) {
+    if (this.handlers[id]) {
+      this.handlers[id] = null;
+    }
+  }
+
+  /**
+   * Clear all interceptors from the stack
+   *
+   * @returns {void}
+   */
+  clear() {
+    if (this.handlers) {
+      this.handlers = [];
+    }
+  }
+
+  /**
+   * Iterate over all the registered interceptors
+   *
+   * This method is particularly useful for skipping over any
+   * interceptors that may have become `null` calling `eject`.
+   *
+   * @param {Function} fn The function to call for each interceptor
+   *
+   * @returns {void}
+   */
+  forEach(fn) {
+    utils.forEach(this.handlers, function forEachHandler(h) {
+      if (h !== null) {
+        fn(h);
+      }
+    });
+  }
+}
+
+export default InterceptorManager;
diff --git a/parent_dir/node_modules/axios/lib/core/buildFullPath.js b/parent_dir/node_modules/axios/lib/core/buildFullPath.js
new file mode 100644
index 0000000..b60927c
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/core/buildFullPath.js
@@ -0,0 +1,21 @@
+'use strict';
+
+import isAbsoluteURL from '../helpers/isAbsoluteURL.js';
+import combineURLs from '../helpers/combineURLs.js';
+
+/**
+ * Creates a new URL by combining the baseURL with the requestedURL,
+ * only when the requestedURL is not already an absolute URL.
+ * If the requestURL is absolute, this function returns the requestedURL untouched.
+ *
+ * @param {string} baseURL The base URL
+ * @param {string} requestedURL Absolute or relative URL to combine
+ *
+ * @returns {string} The combined full path
+ */
+export default function buildFullPath(baseURL, requestedURL) {
+  if (baseURL && !isAbsoluteURL(requestedURL)) {
+    return combineURLs(baseURL, requestedURL);
+  }
+  return requestedURL;
+}
diff --git a/parent_dir/node_modules/axios/lib/core/dispatchRequest.js b/parent_dir/node_modules/axios/lib/core/dispatchRequest.js
new file mode 100644
index 0000000..9e306aa
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/core/dispatchRequest.js
@@ -0,0 +1,81 @@
+'use strict';
+
+import transformData from './transformData.js';
+import isCancel from '../cancel/isCancel.js';
+import defaults from '../defaults/index.js';
+import CanceledError from '../cancel/CanceledError.js';
+import AxiosHeaders from '../core/AxiosHeaders.js';
+import adapters from "../adapters/adapters.js";
+
+/**
+ * Throws a `CanceledError` if cancellation has been requested.
+ *
+ * @param {Object} config The config that is to be used for the request
+ *
+ * @returns {void}
+ */
+function throwIfCancellationRequested(config) {
+  if (config.cancelToken) {
+    config.cancelToken.throwIfRequested();
+  }
+
+  if (config.signal && config.signal.aborted) {
+    throw new CanceledError(null, config);
+  }
+}
+
+/**
+ * Dispatch a request to the server using the configured adapter.
+ *
+ * @param {object} config The config that is to be used for the request
+ *
+ * @returns {Promise} The Promise to be fulfilled
+ */
+export default function dispatchRequest(config) {
+  throwIfCancellationRequested(config);
+
+  config.headers = AxiosHeaders.from(config.headers);
+
+  // Transform request data
+  config.data = transformData.call(
+    config,
+    config.transformRequest
+  );
+
+  if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {
+    config.headers.setContentType('application/x-www-form-urlencoded', false);
+  }
+
+  const adapter = adapters.getAdapter(config.adapter || defaults.adapter);
+
+  return adapter(config).then(function onAdapterResolution(response) {
+    throwIfCancellationRequested(config);
+
+    // Transform response data
+    response.data = transformData.call(
+      config,
+      config.transformResponse,
+      response
+    );
+
+    response.headers = AxiosHeaders.from(response.headers);
+
+    return response;
+  }, function onAdapterRejection(reason) {
+    if (!isCancel(reason)) {
+      throwIfCancellationRequested(config);
+
+      // Transform response data
+      if (reason && reason.response) {
+        reason.response.data = transformData.call(
+          config,
+          config.transformResponse,
+          reason.response
+        );
+        reason.response.headers = AxiosHeaders.from(reason.response.headers);
+      }
+    }
+
+    return Promise.reject(reason);
+  });
+}
diff --git a/parent_dir/node_modules/axios/lib/core/mergeConfig.js b/parent_dir/node_modules/axios/lib/core/mergeConfig.js
new file mode 100644
index 0000000..2aee6b8
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/core/mergeConfig.js
@@ -0,0 +1,105 @@
+'use strict';
+
+import utils from '../utils.js';
+import AxiosHeaders from "./AxiosHeaders.js";
+
+const headersToObject = (thing) => thing instanceof AxiosHeaders ? thing.toJSON() : thing;
+
+/**
+ * Config-specific merge-function which creates a new config-object
+ * by merging two configuration objects together.
+ *
+ * @param {Object} config1
+ * @param {Object} config2
+ *
+ * @returns {Object} New object resulting from merging config2 to config1
+ */
+export default function mergeConfig(config1, config2) {
+  // eslint-disable-next-line no-param-reassign
+  config2 = config2 || {};
+  const config = {};
+
+  function getMergedValue(target, source, caseless) {
+    if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
+      return utils.merge.call({caseless}, target, source);
+    } else if (utils.isPlainObject(source)) {
+      return utils.merge({}, source);
+    } else if (utils.isArray(source)) {
+      return source.slice();
+    }
+    return source;
+  }
+
+  // eslint-disable-next-line consistent-return
+  function mergeDeepProperties(a, b, caseless) {
+    if (!utils.isUndefined(b)) {
+      return getMergedValue(a, b, caseless);
+    } else if (!utils.isUndefined(a)) {
+      return getMergedValue(undefined, a, caseless);
+    }
+  }
+
+  // eslint-disable-next-line consistent-return
+  function valueFromConfig2(a, b) {
+    if (!utils.isUndefined(b)) {
+      return getMergedValue(undefined, b);
+    }
+  }
+
+  // eslint-disable-next-line consistent-return
+  function defaultToConfig2(a, b) {
+    if (!utils.isUndefined(b)) {
+      return getMergedValue(undefined, b);
+    } else if (!utils.isUndefined(a)) {
+      return getMergedValue(undefined, a);
+    }
+  }
+
+  // eslint-disable-next-line consistent-return
+  function mergeDirectKeys(a, b, prop) {
+    if (prop in config2) {
+      return getMergedValue(a, b);
+    } else if (prop in config1) {
+      return getMergedValue(undefined, a);
+    }
+  }
+
+  const mergeMap = {
+    url: valueFromConfig2,
+    method: valueFromConfig2,
+    data: valueFromConfig2,
+    baseURL: defaultToConfig2,
+    transformRequest: defaultToConfig2,
+    transformResponse: defaultToConfig2,
+    paramsSerializer: defaultToConfig2,
+    timeout: defaultToConfig2,
+    timeoutMessage: defaultToConfig2,
+    withCredentials: defaultToConfig2,
+    adapter: defaultToConfig2,
+    responseType: defaultToConfig2,
+    xsrfCookieName: defaultToConfig2,
+    xsrfHeaderName: defaultToConfig2,
+    onUploadProgress: defaultToConfig2,
+    onDownloadProgress: defaultToConfig2,
+    decompress: defaultToConfig2,
+    maxContentLength: defaultToConfig2,
+    maxBodyLength: defaultToConfig2,
+    beforeRedirect: defaultToConfig2,
+    transport: defaultToConfig2,
+    httpAgent: defaultToConfig2,
+    httpsAgent: defaultToConfig2,
+    cancelToken: defaultToConfig2,
+    socketPath: defaultToConfig2,
+    responseEncoding: defaultToConfig2,
+    validateStatus: mergeDirectKeys,
+    headers: (a, b) => mergeDeepProperties(headersToObject(a), headersToObject(b), true)
+  };
+
+  utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
+    const merge = mergeMap[prop] || mergeDeepProperties;
+    const configValue = merge(config1[prop], config2[prop], prop);
+    (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
+  });
+
+  return config;
+}
diff --git a/parent_dir/node_modules/axios/lib/core/settle.js b/parent_dir/node_modules/axios/lib/core/settle.js
new file mode 100644
index 0000000..ac905c4
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/core/settle.js
@@ -0,0 +1,27 @@
+'use strict';
+
+import AxiosError from './AxiosError.js';
+
+/**
+ * Resolve or reject a Promise based on response status.
+ *
+ * @param {Function} resolve A function that resolves the promise.
+ * @param {Function} reject A function that rejects the promise.
+ * @param {object} response The response.
+ *
+ * @returns {object} The response.
+ */
+export default function settle(resolve, reject, response) {
+  const validateStatus = response.config.validateStatus;
+  if (!response.status || !validateStatus || validateStatus(response.status)) {
+    resolve(response);
+  } else {
+    reject(new AxiosError(
+      'Request failed with status code ' + response.status,
+      [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
+      response.config,
+      response.request,
+      response
+    ));
+  }
+}
diff --git a/parent_dir/node_modules/axios/lib/core/transformData.js b/parent_dir/node_modules/axios/lib/core/transformData.js
new file mode 100644
index 0000000..eeb5a8a
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/core/transformData.js
@@ -0,0 +1,28 @@
+'use strict';
+
+import utils from './../utils.js';
+import defaults from '../defaults/index.js';
+import AxiosHeaders from '../core/AxiosHeaders.js';
+
+/**
+ * Transform the data for a request or a response
+ *
+ * @param {Array|Function} fns A single function or Array of functions
+ * @param {?Object} response The response object
+ *
+ * @returns {*} The resulting transformed data
+ */
+export default function transformData(fns, response) {
+  const config = this || defaults;
+  const context = response || config;
+  const headers = AxiosHeaders.from(context.headers);
+  let data = context.data;
+
+  utils.forEach(fns, function transform(fn) {
+    data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);
+  });
+
+  headers.normalize();
+
+  return data;
+}
diff --git a/parent_dir/node_modules/axios/lib/defaults/index.js b/parent_dir/node_modules/axios/lib/defaults/index.js
new file mode 100644
index 0000000..0b47602
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/defaults/index.js
@@ -0,0 +1,166 @@
+'use strict';
+
+import utils from '../utils.js';
+import AxiosError from '../core/AxiosError.js';
+import transitionalDefaults from './transitional.js';
+import toFormData from '../helpers/toFormData.js';
+import toURLEncodedForm from '../helpers/toURLEncodedForm.js';
+import platform from '../platform/index.js';
+import formDataToJSON from '../helpers/formDataToJSON.js';
+
+const DEFAULT_CONTENT_TYPE = {
+  'Content-Type': undefined
+};
+
+/**
+ * It takes a string, tries to parse it, and if it fails, it returns the stringified version
+ * of the input
+ *
+ * @param {any} rawValue - The value to be stringified.
+ * @param {Function} parser - A function that parses a string into a JavaScript object.
+ * @param {Function} encoder - A function that takes a value and returns a string.
+ *
+ * @returns {string} A stringified version of the rawValue.
+ */
+function stringifySafely(rawValue, parser, encoder) {
+  if (utils.isString(rawValue)) {
+    try {
+      (parser || JSON.parse)(rawValue);
+      return utils.trim(rawValue);
+    } catch (e) {
+      if (e.name !== 'SyntaxError') {
+        throw e;
+      }
+    }
+  }
+
+  return (encoder || JSON.stringify)(rawValue);
+}
+
+const defaults = {
+
+  transitional: transitionalDefaults,
+
+  adapter: ['xhr', 'http'],
+
+  transformRequest: [function transformRequest(data, headers) {
+    const contentType = headers.getContentType() || '';
+    const hasJSONContentType = contentType.indexOf('application/json') > -1;
+    const isObjectPayload = utils.isObject(data);
+
+    if (isObjectPayload && utils.isHTMLForm(data)) {
+      data = new FormData(data);
+    }
+
+    const isFormData = utils.isFormData(data);
+
+    if (isFormData) {
+      if (!hasJSONContentType) {
+        return data;
+      }
+      return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
+    }
+
+    if (utils.isArrayBuffer(data) ||
+      utils.isBuffer(data) ||
+      utils.isStream(data) ||
+      utils.isFile(data) ||
+      utils.isBlob(data)
+    ) {
+      return data;
+    }
+    if (utils.isArrayBufferView(data)) {
+      return data.buffer;
+    }
+    if (utils.isURLSearchParams(data)) {
+      headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);
+      return data.toString();
+    }
+
+    let isFileList;
+
+    if (isObjectPayload) {
+      if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {
+        return toURLEncodedForm(data, this.formSerializer).toString();
+      }
+
+      if ((isFileList = utils.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {
+        const _FormData = this.env && this.env.FormData;
+
+        return toFormData(
+          isFileList ? {'files[]': data} : data,
+          _FormData && new _FormData(),
+          this.formSerializer
+        );
+      }
+    }
+
+    if (isObjectPayload || hasJSONContentType ) {
+      headers.setContentType('application/json', false);
+      return stringifySafely(data);
+    }
+
+    return data;
+  }],
+
+  transformResponse: [function transformResponse(data) {
+    const transitional = this.transitional || defaults.transitional;
+    const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
+    const JSONRequested = this.responseType === 'json';
+
+    if (data && utils.isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) {
+      const silentJSONParsing = transitional && transitional.silentJSONParsing;
+      const strictJSONParsing = !silentJSONParsing && JSONRequested;
+
+      try {
+        return JSON.parse(data);
+      } catch (e) {
+        if (strictJSONParsing) {
+          if (e.name === 'SyntaxError') {
+            throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);
+          }
+          throw e;
+        }
+      }
+    }
+
+    return data;
+  }],
+
+  /**
+   * A timeout in milliseconds to abort a request. If set to 0 (default) a
+   * timeout is not created.
+   */
+  timeout: 0,
+
+  xsrfCookieName: 'XSRF-TOKEN',
+  xsrfHeaderName: 'X-XSRF-TOKEN',
+
+  maxContentLength: -1,
+  maxBodyLength: -1,
+
+  env: {
+    FormData: platform.classes.FormData,
+    Blob: platform.classes.Blob
+  },
+
+  validateStatus: function validateStatus(status) {
+    return status >= 200 && status < 300;
+  },
+
+  headers: {
+    common: {
+      'Accept': 'application/json, text/plain, */*'
+    }
+  }
+};
+
+utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
+  defaults.headers[method] = {};
+});
+
+utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
+  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
+});
+
+export default defaults;
diff --git a/parent_dir/node_modules/axios/lib/defaults/transitional.js b/parent_dir/node_modules/axios/lib/defaults/transitional.js
new file mode 100644
index 0000000..f891331
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/defaults/transitional.js
@@ -0,0 +1,7 @@
+'use strict';
+
+export default {
+  silentJSONParsing: true,
+  forcedJSONParsing: true,
+  clarifyTimeoutError: false
+};
diff --git a/parent_dir/node_modules/axios/lib/env/data.js b/parent_dir/node_modules/axios/lib/env/data.js
new file mode 100644
index 0000000..dfce380
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/env/data.js
@@ -0,0 +1 @@
+export const VERSION = "1.3.5";
\ No newline at end of file
diff --git a/parent_dir/node_modules/axios/lib/helpers/AxiosURLSearchParams.js b/parent_dir/node_modules/axios/lib/helpers/AxiosURLSearchParams.js
new file mode 100644
index 0000000..b9aa9f0
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/AxiosURLSearchParams.js
@@ -0,0 +1,58 @@
+'use strict';
+
+import toFormData from './toFormData.js';
+
+/**
+ * It encodes a string by replacing all characters that are not in the unreserved set with
+ * their percent-encoded equivalents
+ *
+ * @param {string} str - The string to encode.
+ *
+ * @returns {string} The encoded string.
+ */
+function encode(str) {
+  const charMap = {
+    '!': '%21',
+    "'": '%27',
+    '(': '%28',
+    ')': '%29',
+    '~': '%7E',
+    '%20': '+',
+    '%00': '\x00'
+  };
+  return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
+    return charMap[match];
+  });
+}
+
+/**
+ * It takes a params object and converts it to a FormData object
+ *
+ * @param {Object<string, any>} params - The parameters to be converted to a FormData object.
+ * @param {Object<string, any>} options - The options object passed to the Axios constructor.
+ *
+ * @returns {void}
+ */
+function AxiosURLSearchParams(params, options) {
+  this._pairs = [];
+
+  params && toFormData(params, this, options);
+}
+
+const prototype = AxiosURLSearchParams.prototype;
+
+prototype.append = function append(name, value) {
+  this._pairs.push([name, value]);
+};
+
+prototype.toString = function toString(encoder) {
+  const _encode = encoder ? function(value) {
+    return encoder.call(this, value, encode);
+  } : encode;
+
+  return this._pairs.map(function each(pair) {
+    return _encode(pair[0]) + '=' + _encode(pair[1]);
+  }, '').join('&');
+};
+
+export default AxiosURLSearchParams;
diff --git a/parent_dir/node_modules/axios/lib/helpers/HttpStatusCode.js b/parent_dir/node_modules/axios/lib/helpers/HttpStatusCode.js
new file mode 100644
index 0000000..b3e7adc
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/HttpStatusCode.js
@@ -0,0 +1,71 @@
+const HttpStatusCode = {
+  Continue: 100,
+  SwitchingProtocols: 101,
+  Processing: 102,
+  EarlyHints: 103,
+  Ok: 200,
+  Created: 201,
+  Accepted: 202,
+  NonAuthoritativeInformation: 203,
+  NoContent: 204,
+  ResetContent: 205,
+  PartialContent: 206,
+  MultiStatus: 207,
+  AlreadyReported: 208,
+  ImUsed: 226,
+  MultipleChoices: 300,
+  MovedPermanently: 301,
+  Found: 302,
+  SeeOther: 303,
+  NotModified: 304,
+  UseProxy: 305,
+  Unused: 306,
+  TemporaryRedirect: 307,
+  PermanentRedirect: 308,
+  BadRequest: 400,
+  Unauthorized: 401,
+  PaymentRequired: 402,
+  Forbidden: 403,
+  NotFound: 404,
+  MethodNotAllowed: 405,
+  NotAcceptable: 406,
+  ProxyAuthenticationRequired: 407,
+  RequestTimeout: 408,
+  Conflict: 409,
+  Gone: 410,
+  LengthRequired: 411,
+  PreconditionFailed: 412,
+  PayloadTooLarge: 413,
+  UriTooLong: 414,
+  UnsupportedMediaType: 415,
+  RangeNotSatisfiable: 416,
+  ExpectationFailed: 417,
+  ImATeapot: 418,
+  MisdirectedRequest: 421,
+  UnprocessableEntity: 422,
+  Locked: 423,
+  FailedDependency: 424,
+  TooEarly: 425,
+  UpgradeRequired: 426,
+  PreconditionRequired: 428,
+  TooManyRequests: 429,
+  RequestHeaderFieldsTooLarge: 431,
+  UnavailableForLegalReasons: 451,
+  InternalServerError: 500,
+  NotImplemented: 501,
+  BadGateway: 502,
+  ServiceUnavailable: 503,
+  GatewayTimeout: 504,
+  HttpVersionNotSupported: 505,
+  VariantAlsoNegotiates: 506,
+  InsufficientStorage: 507,
+  LoopDetected: 508,
+  NotExtended: 510,
+  NetworkAuthenticationRequired: 511,
+};
+
+Object.entries(HttpStatusCode).forEach(([key, value]) => {
+  HttpStatusCode[value] = key;
+});
+
+export default HttpStatusCode;
diff --git a/parent_dir/node_modules/axios/lib/helpers/bind.js b/parent_dir/node_modules/axios/lib/helpers/bind.js
new file mode 100644
index 0000000..b3aa83b
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/bind.js
@@ -0,0 +1,7 @@
+'use strict';
+
+export default function bind(fn, thisArg) {
+  return function wrap() {
+    return fn.apply(thisArg, arguments);
+  };
+}
diff --git a/parent_dir/node_modules/axios/lib/helpers/buildURL.js b/parent_dir/node_modules/axios/lib/helpers/buildURL.js
new file mode 100644
index 0000000..d769fdf
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/buildURL.js
@@ -0,0 +1,63 @@
+'use strict';
+
+import utils from '../utils.js';
+import AxiosURLSearchParams from '../helpers/AxiosURLSearchParams.js';
+
+/**
+ * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their
+ * URI encoded counterparts
+ *
+ * @param {string} val The value to be encoded.
+ *
+ * @returns {string} The encoded value.
+ */
+function encode(val) {
+  return encodeURIComponent(val).
+    replace(/%3A/gi, ':').
+    replace(/%24/g, '$').
+    replace(/%2C/gi, ',').
+    replace(/%20/g, '+').
+    replace(/%5B/gi, '[').
+    replace(/%5D/gi, ']');
+}
+
+/**
+ * Build a URL by appending params to the end
+ *
+ * @param {string} url The base of the url (e.g., http://www.google.com)
+ * @param {object} [params] The params to be appended
+ * @param {?object} options
+ *
+ * @returns {string} The formatted url
+ */
+export default function buildURL(url, params, options) {
+  /*eslint no-param-reassign:0*/
+  if (!params) {
+    return url;
+  }
+  
+  const _encode = options && options.encode || encode;
+
+  const serializeFn = options && options.serialize;
+
+  let serializedParams;
+
+  if (serializeFn) {
+    serializedParams = serializeFn(params, options);
+  } else {
+    serializedParams = utils.isURLSearchParams(params) ?
+      params.toString() :
+      new AxiosURLSearchParams(params, options).toString(_encode);
+  }
+
+  if (serializedParams) {
+    const hashmarkIndex = url.indexOf("#");
+
+    if (hashmarkIndex !== -1) {
+      url = url.slice(0, hashmarkIndex);
+    }
+    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
+  }
+
+  return url;
+}
diff --git a/parent_dir/node_modules/axios/lib/helpers/combineURLs.js b/parent_dir/node_modules/axios/lib/helpers/combineURLs.js
new file mode 100644
index 0000000..cba9a23
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/combineURLs.js
@@ -0,0 +1,15 @@
+'use strict';
+
+/**
+ * Creates a new URL by combining the specified URLs
+ *
+ * @param {string} baseURL The base URL
+ * @param {string} relativeURL The relative URL
+ *
+ * @returns {string} The combined URL
+ */
+export default function combineURLs(baseURL, relativeURL) {
+  return relativeURL
+    ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
+    : baseURL;
+}
diff --git a/parent_dir/node_modules/axios/lib/helpers/cookies.js b/parent_dir/node_modules/axios/lib/helpers/cookies.js
new file mode 100644
index 0000000..361493a
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/cookies.js
@@ -0,0 +1,52 @@
+'use strict';
+
+import utils from './../utils.js';
+import platform from '../platform/index.js';
+
+export default platform.isStandardBrowserEnv ?
+
+// Standard browser envs support document.cookie
+  (function standardBrowserEnv() {
+    return {
+      write: function write(name, value, expires, path, domain, secure) {
+        const cookie = [];
+        cookie.push(name + '=' + encodeURIComponent(value));
+
+        if (utils.isNumber(expires)) {
+          cookie.push('expires=' + new Date(expires).toGMTString());
+        }
+
+        if (utils.isString(path)) {
+          cookie.push('path=' + path);
+        }
+
+        if (utils.isString(domain)) {
+          cookie.push('domain=' + domain);
+        }
+
+        if (secure === true) {
+          cookie.push('secure');
+        }
+
+        document.cookie = cookie.join('; ');
+      },
+
+      read: function read(name) {
+        const match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
+        return (match ? decodeURIComponent(match[3]) : null);
+      },
+
+      remove: function remove(name) {
+        this.write(name, '', Date.now() - 86400000);
+      }
+    };
+  })() :
+
+// Non standard browser env (web workers, react-native) lack needed support.
+  (function nonStandardBrowserEnv() {
+    return {
+      write: function write() {},
+      read: function read() { return null; },
+      remove: function remove() {}
+    };
+  })();
diff --git a/parent_dir/node_modules/axios/lib/helpers/formDataToJSON.js b/parent_dir/node_modules/axios/lib/helpers/formDataToJSON.js
new file mode 100644
index 0000000..f4581df
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/formDataToJSON.js
@@ -0,0 +1,92 @@
+'use strict';
+
+import utils from '../utils.js';
+
+/**
+ * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']
+ *
+ * @param {string} name - The name of the property to get.
+ *
+ * @returns An array of strings.
+ */
+function parsePropPath(name) {
+  // foo[x][y][z]
+  // foo.x.y.z
+  // foo-x-y-z
+  // foo x y z
+  return utils.matchAll(/\w+|\[(\w*)]/g, name).map(match => {
+    return match[0] === '[]' ? '' : match[1] || match[0];
+  });
+}
+
+/**
+ * Convert an array to an object.
+ *
+ * @param {Array<any>} arr - The array to convert to an object.
+ *
+ * @returns An object with the same keys and values as the array.
+ */
+function arrayToObject(arr) {
+  const obj = {};
+  const keys = Object.keys(arr);
+  let i;
+  const len = keys.length;
+  let key;
+  for (i = 0; i < len; i++) {
+    key = keys[i];
+    obj[key] = arr[key];
+  }
+  return obj;
+}
+
+/**
+ * It takes a FormData object and returns a JavaScript object
+ *
+ * @param {string} formData The FormData object to convert to JSON.
+ *
+ * @returns {Object<string, any> | null} The converted object.
+ */
+function formDataToJSON(formData) {
+  function buildPath(path, value, target, index) {
+    let name = path[index++];
+    const isNumericKey = Number.isFinite(+name);
+    const isLast = index >= path.length;
+    name = !name && utils.isArray(target) ? target.length : name;
+
+    if (isLast) {
+      if (utils.hasOwnProp(target, name)) {
+        target[name] = [target[name], value];
+      } else {
+        target[name] = value;
+      }
+
+      return !isNumericKey;
+    }
+
+    if (!target[name] || !utils.isObject(target[name])) {
+      target[name] = [];
+    }
+
+    const result = buildPath(path, value, target[name], index);
+
+    if (result && utils.isArray(target[name])) {
+      target[name] = arrayToObject(target[name]);
+    }
+
+    return !isNumericKey;
+  }
+
+  if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {
+    const obj = {};
+
+    utils.forEachEntry(formData, (name, value) => {
+      buildPath(parsePropPath(name), value, obj, 0);
+    });
+
+    return obj;
+  }
+
+  return null;
+}
+
+export default formDataToJSON;
diff --git a/parent_dir/node_modules/axios/lib/helpers/isAbsoluteURL.js b/parent_dir/node_modules/axios/lib/helpers/isAbsoluteURL.js
new file mode 100644
index 0000000..4747a45
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/isAbsoluteURL.js
@@ -0,0 +1,15 @@
+'use strict';
+
+/**
+ * Determines whether the specified URL is absolute
+ *
+ * @param {string} url The URL to test
+ *
+ * @returns {boolean} True if the specified URL is absolute, otherwise false
+ */
+export default function isAbsoluteURL(url) {
+  // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
+  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
+  // by any combination of letters, digits, plus, period, or hyphen.
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+}
diff --git a/parent_dir/node_modules/axios/lib/helpers/isAxiosError.js b/parent_dir/node_modules/axios/lib/helpers/isAxiosError.js
new file mode 100644
index 0000000..da6cd63
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/isAxiosError.js
@@ -0,0 +1,14 @@
+'use strict';
+
+import utils from './../utils.js';
+
+/**
+ * Determines whether the payload is an error thrown by Axios
+ *
+ * @param {*} payload The value to test
+ *
+ * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
+ */
+export default function isAxiosError(payload) {
+  return utils.isObject(payload) && (payload.isAxiosError === true);
+}
diff --git a/parent_dir/node_modules/axios/lib/helpers/isURLSameOrigin.js b/parent_dir/node_modules/axios/lib/helpers/isURLSameOrigin.js
new file mode 100644
index 0000000..18db03b
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/isURLSameOrigin.js
@@ -0,0 +1,67 @@
+'use strict';
+
+import utils from './../utils.js';
+import platform from '../platform/index.js';
+
+export default platform.isStandardBrowserEnv ?
+
+// Standard browser envs have full support of the APIs needed to test
+// whether the request URL is of the same origin as current location.
+  (function standardBrowserEnv() {
+    const msie = /(msie|trident)/i.test(navigator.userAgent);
+    const urlParsingNode = document.createElement('a');
+    let originURL;
+
+    /**
+    * Parse a URL to discover it's components
+    *
+    * @param {String} url The URL to be parsed
+    * @returns {Object}
+    */
+    function resolveURL(url) {
+      let href = url;
+
+      if (msie) {
+        // IE needs attribute set twice to normalize properties
+        urlParsingNode.setAttribute('href', href);
+        href = urlParsingNode.href;
+      }
+
+      urlParsingNode.setAttribute('href', href);
+
+      // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
+      return {
+        href: urlParsingNode.href,
+        protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
+        host: urlParsingNode.host,
+        search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
+        hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
+        hostname: urlParsingNode.hostname,
+        port: urlParsingNode.port,
+        pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
+          urlParsingNode.pathname :
+          '/' + urlParsingNode.pathname
+      };
+    }
+
+    originURL = resolveURL(window.location.href);
+
+    /**
+    * Determine if a URL shares the same origin as the current location
+    *
+    * @param {String} requestURL The URL to test
+    * @returns {boolean} True if URL shares the same origin, otherwise false
+    */
+    return function isURLSameOrigin(requestURL) {
+      const parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
+      return (parsed.protocol === originURL.protocol &&
+          parsed.host === originURL.host);
+    };
+  })() :
+
+  // Non standard browser envs (web workers, react-native) lack needed support.
+  (function nonStandardBrowserEnv() {
+    return function isURLSameOrigin() {
+      return true;
+    };
+  })();
diff --git a/parent_dir/node_modules/axios/lib/helpers/null.js b/parent_dir/node_modules/axios/lib/helpers/null.js
new file mode 100644
index 0000000..b9f82c4
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/null.js
@@ -0,0 +1,2 @@
+// eslint-disable-next-line strict
+export default null;
diff --git a/parent_dir/node_modules/axios/lib/helpers/parseHeaders.js b/parent_dir/node_modules/axios/lib/helpers/parseHeaders.js
new file mode 100644
index 0000000..50af948
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/parseHeaders.js
@@ -0,0 +1,55 @@
+'use strict';
+
+import utils from './../utils.js';
+
+// RawAxiosHeaders whose duplicates are ignored by node
+// c.f. https://nodejs.org/api/http.html#http_message_headers
+const ignoreDuplicateOf = utils.toObjectSet([
+  'age', 'authorization', 'content-length', 'content-type', 'etag',
+  'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
+  'last-modified', 'location', 'max-forwards', 'proxy-authorization',
+  'referer', 'retry-after', 'user-agent'
+]);
+
+/**
+ * Parse headers into an object
+ *
+ * ```
+ * Date: Wed, 27 Aug 2014 08:58:49 GMT
+ * Content-Type: application/json
+ * Connection: keep-alive
+ * Transfer-Encoding: chunked
+ * ```
+ *
+ * @param {String} rawHeaders Headers needing to be parsed
+ *
+ * @returns {Object} Headers parsed into an object
+ */
+export default rawHeaders => {
+  const parsed = {};
+  let key;
+  let val;
+  let i;
+
+  rawHeaders && rawHeaders.split('\n').forEach(function parser(line) {
+    i = line.indexOf(':');
+    key = line.substring(0, i).trim().toLowerCase();
+    val = line.substring(i + 1).trim();
+
+    if (!key || (parsed[key] && ignoreDuplicateOf[key])) {
+      return;
+    }
+
+    if (key === 'set-cookie') {
+      if (parsed[key]) {
+        parsed[key].push(val);
+      } else {
+        parsed[key] = [val];
+      }
+    } else {
+      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
+    }
+  });
+
+  return parsed;
+};
diff --git a/parent_dir/node_modules/axios/lib/helpers/parseProtocol.js b/parent_dir/node_modules/axios/lib/helpers/parseProtocol.js
new file mode 100644
index 0000000..586ec96
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/parseProtocol.js
@@ -0,0 +1,6 @@
+'use strict';
+
+export default function parseProtocol(url) {
+  const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
+  return match && match[1] || '';
+}
diff --git a/parent_dir/node_modules/axios/lib/helpers/speedometer.js b/parent_dir/node_modules/axios/lib/helpers/speedometer.js
new file mode 100644
index 0000000..3b3c666
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/speedometer.js
@@ -0,0 +1,55 @@
+'use strict';
+
+/**
+ * Calculate data maxRate
+ * @param {Number} [samplesCount= 10]
+ * @param {Number} [min= 1000]
+ * @returns {Function}
+ */
+function speedometer(samplesCount, min) {
+  samplesCount = samplesCount || 10;
+  const bytes = new Array(samplesCount);
+  const timestamps = new Array(samplesCount);
+  let head = 0;
+  let tail = 0;
+  let firstSampleTS;
+
+  min = min !== undefined ? min : 1000;
+
+  return function push(chunkLength) {
+    const now = Date.now();
+
+    const startedAt = timestamps[tail];
+
+    if (!firstSampleTS) {
+      firstSampleTS = now;
+    }
+
+    bytes[head] = chunkLength;
+    timestamps[head] = now;
+
+    let i = tail;
+    let bytesCount = 0;
+
+    while (i !== head) {
+      bytesCount += bytes[i++];
+      i = i % samplesCount;
+    }
+
+    head = (head + 1) % samplesCount;
+
+    if (head === tail) {
+      tail = (tail + 1) % samplesCount;
+    }
+
+    if (now - firstSampleTS < min) {
+      return;
+    }
+
+    const passed = startedAt && now - startedAt;
+
+    return passed ? Math.round(bytesCount * 1000 / passed) : undefined;
+  };
+}
+
+export default speedometer;
diff --git a/parent_dir/node_modules/axios/lib/helpers/spread.js b/parent_dir/node_modules/axios/lib/helpers/spread.js
new file mode 100644
index 0000000..13479cb
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/spread.js
@@ -0,0 +1,28 @@
+'use strict';
+
+/**
+ * Syntactic sugar for invoking a function and expanding an array for arguments.
+ *
+ * Common use case would be to use `Function.prototype.apply`.
+ *
+ *  ```js
+ *  function f(x, y, z) {}
+ *  var args = [1, 2, 3];
+ *  f.apply(null, args);
+ *  ```
+ *
+ * With `spread` this example can be re-written.
+ *
+ *  ```js
+ *  spread(function(x, y, z) {})([1, 2, 3]);
+ *  ```
+ *
+ * @param {Function} callback
+ *
+ * @returns {Function}
+ */
+export default function spread(callback) {
+  return function wrap(arr) {
+    return callback.apply(null, arr);
+  };
+}
diff --git a/parent_dir/node_modules/axios/lib/helpers/toFormData.js b/parent_dir/node_modules/axios/lib/helpers/toFormData.js
new file mode 100644
index 0000000..a41e966
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/toFormData.js
@@ -0,0 +1,219 @@
+'use strict';
+
+import utils from '../utils.js';
+import AxiosError from '../core/AxiosError.js';
+// temporary hotfix to avoid circular references until AxiosURLSearchParams is refactored
+import PlatformFormData from '../platform/node/classes/FormData.js';
+
+/**
+ * Determines if the given thing is a array or js object.
+ *
+ * @param {string} thing - The object or array to be visited.
+ *
+ * @returns {boolean}
+ */
+function isVisitable(thing) {
+  return utils.isPlainObject(thing) || utils.isArray(thing);
+}
+
+/**
+ * It removes the brackets from the end of a string
+ *
+ * @param {string} key - The key of the parameter.
+ *
+ * @returns {string} the key without the brackets.
+ */
+function removeBrackets(key) {
+  return utils.endsWith(key, '[]') ? key.slice(0, -2) : key;
+}
+
+/**
+ * It takes a path, a key, and a boolean, and returns a string
+ *
+ * @param {string} path - The path to the current key.
+ * @param {string} key - The key of the current object being iterated over.
+ * @param {string} dots - If true, the key will be rendered with dots instead of brackets.
+ *
+ * @returns {string} The path to the current key.
+ */
+function renderKey(path, key, dots) {
+  if (!path) return key;
+  return path.concat(key).map(function each(token, i) {
+    // eslint-disable-next-line no-param-reassign
+    token = removeBrackets(token);
+    return !dots && i ? '[' + token + ']' : token;
+  }).join(dots ? '.' : '');
+}
+
+/**
+ * If the array is an array and none of its elements are visitable, then it's a flat array.
+ *
+ * @param {Array<any>} arr - The array to check
+ *
+ * @returns {boolean}
+ */
+function isFlatArray(arr) {
+  return utils.isArray(arr) && !arr.some(isVisitable);
+}
+
+const predicates = utils.toFlatObject(utils, {}, null, function filter(prop) {
+  return /^is[A-Z]/.test(prop);
+});
+
+/**
+ * Convert a data object to FormData
+ *
+ * @param {Object} obj
+ * @param {?Object} [formData]
+ * @param {?Object} [options]
+ * @param {Function} [options.visitor]
+ * @param {Boolean} [options.metaTokens = true]
+ * @param {Boolean} [options.dots = false]
+ * @param {?Boolean} [options.indexes = false]
+ *
+ * @returns {Object}
+ **/
+
+/**
+ * It converts an object into a FormData object
+ *
+ * @param {Object<any, any>} obj - The object to convert to form data.
+ * @param {string} formData - The FormData object to append to.
+ * @param {Object<string, any>} options
+ *
+ * @returns
+ */
+function toFormData(obj, formData, options) {
+  if (!utils.isObject(obj)) {
+    throw new TypeError('target must be an object');
+  }
+
+  // eslint-disable-next-line no-param-reassign
+  formData = formData || new (PlatformFormData || FormData)();
+
+  // eslint-disable-next-line no-param-reassign
+  options = utils.toFlatObject(options, {
+    metaTokens: true,
+    dots: false,
+    indexes: false
+  }, false, function defined(option, source) {
+    // eslint-disable-next-line no-eq-null,eqeqeq
+    return !utils.isUndefined(source[option]);
+  });
+
+  const metaTokens = options.metaTokens;
+  // eslint-disable-next-line no-use-before-define
+  const visitor = options.visitor || defaultVisitor;
+  const dots = options.dots;
+  const indexes = options.indexes;
+  const _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;
+  const useBlob = _Blob && utils.isSpecCompliantForm(formData);
+
+  if (!utils.isFunction(visitor)) {
+    throw new TypeError('visitor must be a function');
+  }
+
+  function convertValue(value) {
+    if (value === null) return '';
+
+    if (utils.isDate(value)) {
+      return value.toISOString();
+    }
+
+    if (!useBlob && utils.isBlob(value)) {
+      throw new AxiosError('Blob is not supported. Use a Buffer instead.');
+    }
+
+    if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) {
+      return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);
+    }
+
+    return value;
+  }
+
+  /**
+   * Default visitor.
+   *
+   * @param {*} value
+   * @param {String|Number} key
+   * @param {Array<String|Number>} path
+   * @this {FormData}
+   *
+   * @returns {boolean} return true to visit the each prop of the value recursively
+   */
+  function defaultVisitor(value, key, path) {
+    let arr = value;
+
+    if (value && !path && typeof value === 'object') {
+      if (utils.endsWith(key, '{}')) {
+        // eslint-disable-next-line no-param-reassign
+        key = metaTokens ? key : key.slice(0, -2);
+        // eslint-disable-next-line no-param-reassign
+        value = JSON.stringify(value);
+      } else if (
+        (utils.isArray(value) && isFlatArray(value)) ||
+        ((utils.isFileList(value) || utils.endsWith(key, '[]')) && (arr = utils.toArray(value))
+        )) {
+        // eslint-disable-next-line no-param-reassign
+        key = removeBrackets(key);
+
+        arr.forEach(function each(el, index) {
+          !(utils.isUndefined(el) || el === null) && formData.append(
+            // eslint-disable-next-line no-nested-ternary
+            indexes === true ? renderKey([key], index, dots) : (indexes === null ? key : key + '[]'),
+            convertValue(el)
+          );
+        });
+        return false;
+      }
+    }
+
+    if (isVisitable(value)) {
+      return true;
+    }
+
+    formData.append(renderKey(path, key, dots), convertValue(value));
+
+    return false;
+  }
+
+  const stack = [];
+
+  const exposedHelpers = Object.assign(predicates, {
+    defaultVisitor,
+    convertValue,
+    isVisitable
+  });
+
+  function build(value, path) {
+    if (utils.isUndefined(value)) return;
+
+    if (stack.indexOf(value) !== -1) {
+      throw Error('Circular reference detected in ' + path.join('.'));
+    }
+
+    stack.push(value);
+
+    utils.forEach(value, function each(el, key) {
+      const result = !(utils.isUndefined(el) || el === null) && visitor.call(
+        formData, el, utils.isString(key) ? key.trim() : key, path, exposedHelpers
+      );
+
+      if (result === true) {
+        build(el, path ? path.concat(key) : [key]);
+      }
+    });
+
+    stack.pop();
+  }
+
+  if (!utils.isObject(obj)) {
+    throw new TypeError('data must be an object');
+  }
+
+  build(obj);
+
+  return formData;
+}
+
+export default toFormData;
diff --git a/parent_dir/node_modules/axios/lib/helpers/toURLEncodedForm.js b/parent_dir/node_modules/axios/lib/helpers/toURLEncodedForm.js
new file mode 100644
index 0000000..988a38a
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/toURLEncodedForm.js
@@ -0,0 +1,18 @@
+'use strict';
+
+import utils from '../utils.js';
+import toFormData from './toFormData.js';
+import platform from '../platform/index.js';
+
+export default function toURLEncodedForm(data, options) {
+  return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({
+    visitor: function(value, key, path, helpers) {
+      if (platform.isNode && utils.isBuffer(value)) {
+        this.append(key, value.toString('base64'));
+        return false;
+      }
+
+      return helpers.defaultVisitor.apply(this, arguments);
+    }
+  }, options));
+}
diff --git a/parent_dir/node_modules/axios/lib/helpers/validator.js b/parent_dir/node_modules/axios/lib/helpers/validator.js
new file mode 100644
index 0000000..14b4696
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/helpers/validator.js
@@ -0,0 +1,91 @@
+'use strict';
+
+import {VERSION} from '../env/data.js';
+import AxiosError from '../core/AxiosError.js';
+
+const validators = {};
+
+// eslint-disable-next-line func-names
+['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach((type, i) => {
+  validators[type] = function validator(thing) {
+    return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;
+  };
+});
+
+const deprecatedWarnings = {};
+
+/**
+ * Transitional option validator
+ *
+ * @param {function|boolean?} validator - set to false if the transitional option has been removed
+ * @param {string?} version - deprecated version / removed since version
+ * @param {string?} message - some message with additional info
+ *
+ * @returns {function}
+ */
+validators.transitional = function transitional(validator, version, message) {
+  function formatMessage(opt, desc) {
+    return '[Axios v' + VERSION + '] Transitional option \'' + opt + '\'' + desc + (message ? '. ' + message : '');
+  }
+
+  // eslint-disable-next-line func-names
+  return (value, opt, opts) => {
+    if (validator === false) {
+      throw new AxiosError(
+        formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),
+        AxiosError.ERR_DEPRECATED
+      );
+    }
+
+    if (version && !deprecatedWarnings[opt]) {
+      deprecatedWarnings[opt] = true;
+      // eslint-disable-next-line no-console
+      console.warn(
+        formatMessage(
+          opt,
+          ' has been deprecated since v' + version + ' and will be removed in the near future'
+        )
+      );
+    }
+
+    return validator ? validator(value, opt, opts) : true;
+  };
+};
+
+/**
+ * Assert object's properties type
+ *
+ * @param {object} options
+ * @param {object} schema
+ * @param {boolean?} allowUnknown
+ *
+ * @returns {object}
+ */
+
+function assertOptions(options, schema, allowUnknown) {
+  if (typeof options !== 'object') {
+    throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);
+  }
+  const keys = Object.keys(options);
+  let i = keys.length;
+  while (i-- > 0) {
+    const opt = keys[i];
+    const validator = schema[opt];
+    if (validator) {
+      const value = options[opt];
+      const result = value === undefined || validator(value, opt, options);
+      if (result !== true) {
+        throw new AxiosError('option ' + opt + ' must be ' + result, AxiosError.ERR_BAD_OPTION_VALUE);
+      }
+      continue;
+    }
+    if (allowUnknown !== true) {
+      throw new AxiosError('Unknown option ' + opt, AxiosError.ERR_BAD_OPTION);
+    }
+  }
+}
+
+export default {
+  assertOptions,
+  validators
+};
diff --git a/parent_dir/node_modules/axios/lib/platform/browser/classes/Blob.js b/parent_dir/node_modules/axios/lib/platform/browser/classes/Blob.js
new file mode 100644
index 0000000..6c506c4
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/platform/browser/classes/Blob.js
@@ -0,0 +1,3 @@
+'use strict'
+
+export default typeof Blob !== 'undefined' ? Blob : null
diff --git a/parent_dir/node_modules/axios/lib/platform/browser/classes/FormData.js b/parent_dir/node_modules/axios/lib/platform/browser/classes/FormData.js
new file mode 100644
index 0000000..f36d31b
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/platform/browser/classes/FormData.js
@@ -0,0 +1,3 @@
+'use strict';
+
+export default typeof FormData !== 'undefined' ? FormData : null;
diff --git a/parent_dir/node_modules/axios/lib/platform/browser/classes/URLSearchParams.js b/parent_dir/node_modules/axios/lib/platform/browser/classes/URLSearchParams.js
new file mode 100644
index 0000000..b7dae95
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/platform/browser/classes/URLSearchParams.js
@@ -0,0 +1,4 @@
+'use strict';
+
+import AxiosURLSearchParams from '../../../helpers/AxiosURLSearchParams.js';
+export default typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;
diff --git a/parent_dir/node_modules/axios/lib/platform/browser/index.js b/parent_dir/node_modules/axios/lib/platform/browser/index.js
new file mode 100644
index 0000000..4d2203f
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/platform/browser/index.js
@@ -0,0 +1,64 @@
+import URLSearchParams from './classes/URLSearchParams.js'
+import FormData from './classes/FormData.js'
+import Blob from './classes/Blob.js'
+
+/**
+ * Determine if we're running in a standard browser environment
+ *
+ * This allows axios to run in a web worker, and react-native.
+ * Both environments support XMLHttpRequest, but not fully standard globals.
+ *
+ * web workers:
+ *  typeof window -> undefined
+ *  typeof document -> undefined
+ *
+ * react-native:
+ *  navigator.product -> 'ReactNative'
+ * nativescript
+ *  navigator.product -> 'NativeScript' or 'NS'
+ *
+ * @returns {boolean}
+ */
+const isStandardBrowserEnv = (() => {
+  let product;
+  if (typeof navigator !== 'undefined' && (
+    (product = navigator.product) === 'ReactNative' ||
+    product === 'NativeScript' ||
+    product === 'NS')
+  ) {
+    return false;
+  }
+
+  return typeof window !== 'undefined' && typeof document !== 'undefined';
+})();
+
+/**
+ * Determine if we're running in a standard browser webWorker environment
+ *
+ * Although the `isStandardBrowserEnv` method indicates that
+ * `allows axios to run in a web worker`, the WebWorker will still be
+ * filtered out due to its judgment standard
+ * `typeof window !== 'undefined' && typeof document !== 'undefined'`.
+ * This leads to a problem when axios post `FormData` in webWorker
+ */
+ const isStandardBrowserWebWorkerEnv = (() => {
+  return (
+    typeof WorkerGlobalScope !== 'undefined' &&
+    // eslint-disable-next-line no-undef
+    self instanceof WorkerGlobalScope &&
+    typeof self.importScripts === 'function'
+  );
+})();
+
+
+export default {
+  isBrowser: true,
+  classes: {
+    URLSearchParams,
+    FormData,
+    Blob
+  },
+  isStandardBrowserEnv,
+  isStandardBrowserWebWorkerEnv,
+  protocols: ['http', 'https', 'file', 'blob', 'url', 'data']
+};
diff --git a/parent_dir/node_modules/axios/lib/utils.js b/parent_dir/node_modules/axios/lib/utils.js
new file mode 100644
index 0000000..6a38872
--- /dev/null
+++ b/parent_dir/node_modules/axios/lib/utils.js
@@ -0,0 +1,711 @@
+'use strict';
+
+import bind from './helpers/bind.js';
+
+// utils is a library of generic helper functions non-specific to axios
+
+const {toString} = Object.prototype;
+const {getPrototypeOf} = Object;
+
+const kindOf = (cache => thing => {
+    const str = toString.call(thing);
+    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
+})(Object.create(null));
+
+const kindOfTest = (type) => {
+  type = type.toLowerCase();
+  return (thing) => kindOf(thing) === type
+}
+
+const typeOfTest = type => thing => typeof thing === type;
+
+/**
+ * Determine if a value is an Array
+ *
+ * @param {Object} val The value to test
+ *
+ * @returns {boolean} True if value is an Array, otherwise false
+ */
+const {isArray} = Array;
+
+/**
+ * Determine if a value is undefined
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if the value is undefined, otherwise false
+ */
+const isUndefined = typeOfTest('undefined');
+
+/**
+ * Determine if a value is a Buffer
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a Buffer, otherwise false
+ */
+function isBuffer(val) {
+  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
+    && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
+}
+
+/**
+ * Determine if a value is an ArrayBuffer
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is an ArrayBuffer, otherwise false
+ */
+const isArrayBuffer = kindOfTest('ArrayBuffer');
+
+
+/**
+ * Determine if a value is a view on an ArrayBuffer
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
+ */
+function isArrayBufferView(val) {
+  let result;
+  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
+    result = ArrayBuffer.isView(val);
+  } else {
+    result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));
+  }
+  return result;
+}
+
+/**
+ * Determine if a value is a String
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a String, otherwise false
+ */
+const isString = typeOfTest('string');
+
+/**
+ * Determine if a value is a Function
+ *
+ * @param {*} val The value to test
+ * @returns {boolean} True if value is a Function, otherwise false
+ */
+const isFunction = typeOfTest('function');
+
+/**
+ * Determine if a value is a Number
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a Number, otherwise false
+ */
+const isNumber = typeOfTest('number');
+
+/**
+ * Determine if a value is an Object
+ *
+ * @param {*} thing The value to test
+ *
+ * @returns {boolean} True if value is an Object, otherwise false
+ */
+const isObject = (thing) => thing !== null && typeof thing === 'object';
+
+/**
+ * Determine if a value is a Boolean
+ *
+ * @param {*} thing The value to test
+ * @returns {boolean} True if value is a Boolean, otherwise false
+ */
+const isBoolean = thing => thing === true || thing === false;
+
+/**
+ * Determine if a value is a plain Object
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a plain Object, otherwise false
+ */
+const isPlainObject = (val) => {
+  if (kindOf(val) !== 'object') {
+    return false;
+  }
+
+  const prototype = getPrototypeOf(val);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in val) && !(Symbol.iterator in val);
+}
+
+/**
+ * Determine if a value is a Date
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a Date, otherwise false
+ */
+const isDate = kindOfTest('Date');
+
+/**
+ * Determine if a value is a File
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a File, otherwise false
+ */
+const isFile = kindOfTest('File');
+
+/**
+ * Determine if a value is a Blob
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a Blob, otherwise false
+ */
+const isBlob = kindOfTest('Blob');
+
+/**
+ * Determine if a value is a FileList
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a File, otherwise false
+ */
+const isFileList = kindOfTest('FileList');
+
+/**
+ * Determine if a value is a Stream
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a Stream, otherwise false
+ */
+const isStream = (val) => isObject(val) && isFunction(val.pipe);
+
+/**
+ * Determine if a value is a FormData
+ *
+ * @param {*} thing The value to test
+ *
+ * @returns {boolean} True if value is an FormData, otherwise false
+ */
+const isFormData = (thing) => {
+  const pattern = '[object FormData]';
+  return thing && (
+    (typeof FormData === 'function' && thing instanceof FormData) ||
+    toString.call(thing) === pattern ||
+    (isFunction(thing.toString) && thing.toString() === pattern)
+  );
+}
+
+/**
+ * Determine if a value is a URLSearchParams object
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a URLSearchParams object, otherwise false
+ */
+const isURLSearchParams = kindOfTest('URLSearchParams');
+
+/**
+ * Trim excess whitespace off the beginning and end of a string
+ *
+ * @param {String} str The String to trim
+ *
+ * @returns {String} The String freed of excess whitespace
+ */
+const trim = (str) => str.trim ?
+  str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
+
+/**
+ * Iterate over an Array or an Object invoking a function for each item.
+ *
+ * If `obj` is an Array callback will be called passing
+ * the value, index, and complete array for each item.
+ *
+ * If 'obj' is an Object callback will be called passing
+ * the value, key, and complete object for each property.
+ *
+ * @param {Object|Array} obj The object to iterate
+ * @param {Function} fn The callback to invoke for each item
+ *
+ * @param {Boolean} [allOwnKeys = false]
+ * @returns {any}
+ */
+function forEach(obj, fn, {allOwnKeys = false} = {}) {
+  // Don't bother if no value provided
+  if (obj === null || typeof obj === 'undefined') {
+    return;
+  }
+
+  let i;
+  let l;
+
+  // Force an array if not already something iterable
+  if (typeof obj !== 'object') {
+    /*eslint no-param-reassign:0*/
+    obj = [obj];
+  }
+
+  if (isArray(obj)) {
+    // Iterate over array values
+    for (i = 0, l = obj.length; i < l; i++) {
+      fn.call(null, obj[i], i, obj);
+    }
+  } else {
+    // Iterate over object keys
+    const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
+    const len = keys.length;
+    let key;
+
+    for (i = 0; i < len; i++) {
+      key = keys[i];
+      fn.call(null, obj[key], key, obj);
+    }
+  }
+}
+
+function findKey(obj, key) {
+  key = key.toLowerCase();
+  const keys = Object.keys(obj);
+  let i = keys.length;
+  let _key;
+  while (i-- > 0) {
+    _key = keys[i];
+    if (key === _key.toLowerCase()) {
+      return _key;
+    }
+  }
+  return null;
+}
+
+const _global = (() => {
+  /*eslint no-undef:0*/
+  if (typeof globalThis !== "undefined") return globalThis;
+  return typeof self !== "undefined" ? self : (typeof window !== 'undefined' ? window : global)
+})();
+
+const isContextDefined = (context) => !isUndefined(context) && context !== _global;
+
+/**
+ * Accepts varargs expecting each argument to be an object, then
+ * immutably merges the properties of each object and returns result.
+ *
+ * When multiple objects contain the same key the later object in
+ * the arguments list will take precedence.
+ *
+ * Example:
+ *
+ * ```js
+ * var result = merge({foo: 123}, {foo: 456});
+ * console.log(result.foo); // outputs 456
+ * ```
+ *
+ * @param {Object} obj1 Object to merge
+ *
+ * @returns {Object} Result of all merge properties
+ */
+function merge(/* obj1, obj2, obj3, ... */) {
+  const {caseless} = isContextDefined(this) && this || {};
+  const result = {};
+  const assignValue = (val, key) => {
+    const targetKey = caseless && findKey(result, key) || key;
+    if (isPlainObject(result[targetKey]) && isPlainObject(val)) {
+      result[targetKey] = merge(result[targetKey], val);
+    } else if (isPlainObject(val)) {
+      result[targetKey] = merge({}, val);
+    } else if (isArray(val)) {
+      result[targetKey] = val.slice();
+    } else {
+      result[targetKey] = val;
+    }
+  }
+
+  for (let i = 0, l = arguments.length; i < l; i++) {
+    arguments[i] && forEach(arguments[i], assignValue);
+  }
+  return result;
+}
+
+/**
+ * Extends object a by mutably adding to it the properties of object b.
+ *
+ * @param {Object} a The object to be extended
+ * @param {Object} b The object to copy properties from
+ * @param {Object} thisArg The object to bind function to
+ *
+ * @param {Boolean} [allOwnKeys]
+ * @returns {Object} The resulting value of object a
+ */
+const extend = (a, b, thisArg, {allOwnKeys}= {}) => {
+  forEach(b, (val, key) => {
+    if (thisArg && isFunction(val)) {
+      a[key] = bind(val, thisArg);
+    } else {
+      a[key] = val;
+    }
+  }, {allOwnKeys});
+  return a;
+}
+
+/**
+ * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
+ *
+ * @param {string} content with BOM
+ *
+ * @returns {string} content value without BOM
+ */
+const stripBOM = (content) => {
+  if (content.charCodeAt(0) === 0xFEFF) {
+    content = content.slice(1);
+  }
+  return content;
+}
+
+/**
+ * Inherit the prototype methods from one constructor into another
+ * @param {function} constructor
+ * @param {function} superConstructor
+ * @param {object} [props]
+ * @param {object} [descriptors]
+ *
+ * @returns {void}
+ */
+const inherits = (constructor, superConstructor, props, descriptors) => {
+  constructor.prototype = Object.create(superConstructor.prototype, descriptors);
+  constructor.prototype.constructor = constructor;
+  Object.defineProperty(constructor, 'super', {
+    value: superConstructor.prototype
+  });
+  props && Object.assign(constructor.prototype, props);
+}
+
+/**
+ * Resolve object with deep prototype chain to a flat object
+ * @param {Object} sourceObj source object
+ * @param {Object} [destObj]
+ * @param {Function|Boolean} [filter]
+ * @param {Function} [propFilter]
+ *
+ * @returns {Object}
+ */
+const toFlatObject = (sourceObj, destObj, filter, propFilter) => {
+  let props;
+  let i;
+  let prop;
+  const merged = {};
+
+  destObj = destObj || {};
+  // eslint-disable-next-line no-eq-null,eqeqeq
+  if (sourceObj == null) return destObj;
+
+  do {
+    props = Object.getOwnPropertyNames(sourceObj);
+    i = props.length;
+    while (i-- > 0) {
+      prop = props[i];
+      if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {
+        destObj[prop] = sourceObj[prop];
+        merged[prop] = true;
+      }
+    }
+    sourceObj = filter !== false && getPrototypeOf(sourceObj);
+  } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
+
+  return destObj;
+}
+
+/**
+ * Determines whether a string ends with the characters of a specified string
+ *
+ * @param {String} str
+ * @param {String} searchString
+ * @param {Number} [position= 0]
+ *
+ * @returns {boolean}
+ */
+const endsWith = (str, searchString, position) => {
+  str = String(str);
+  if (position === undefined || position > str.length) {
+    position = str.length;
+  }
+  position -= searchString.length;
+  const lastIndex = str.indexOf(searchString, position);
+  return lastIndex !== -1 && lastIndex === position;
+}
+
+
+/**
+ * Returns new array from array like object or null if failed
+ *
+ * @param {*} [thing]
+ *
+ * @returns {?Array}
+ */
+const toArray = (thing) => {
+  if (!thing) return null;
+  if (isArray(thing)) return thing;
+  let i = thing.length;
+  if (!isNumber(i)) return null;
+  const arr = new Array(i);
+  while (i-- > 0) {
+    arr[i] = thing[i];
+  }
+  return arr;
+}
+
+/**
+ * Checking if the Uint8Array exists and if it does, it returns a function that checks if the
+ * thing passed in is an instance of Uint8Array
+ *
+ * @param {TypedArray}
+ *
+ * @returns {Array}
+ */
+// eslint-disable-next-line func-names
+const isTypedArray = (TypedArray => {
+  // eslint-disable-next-line func-names
+  return thing => {
+    return TypedArray && thing instanceof TypedArray;
+  };
+})(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array));
+
+/**
+ * For each entry in the object, call the function with the key and value.
+ *
+ * @param {Object<any, any>} obj - The object to iterate over.
+ * @param {Function} fn - The function to call for each entry.
+ *
+ * @returns {void}
+ */
+const forEachEntry = (obj, fn) => {
+  const generator = obj && obj[Symbol.iterator];
+
+  const iterator = generator.call(obj);
+
+  let result;
+
+  while ((result = iterator.next()) && !result.done) {
+    const pair = result.value;
+    fn.call(obj, pair[0], pair[1]);
+  }
+}
+
+/**
+ * It takes a regular expression and a string, and returns an array of all the matches
+ *
+ * @param {string} regExp - The regular expression to match against.
+ * @param {string} str - The string to search.
+ *
+ * @returns {Array<boolean>}
+ */
+const matchAll = (regExp, str) => {
+  let matches;
+  const arr = [];
+
+  while ((matches = regExp.exec(str)) !== null) {
+    arr.push(matches);
+  }
+
+  return arr;
+}
+
+/* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */
+const isHTMLForm = kindOfTest('HTMLFormElement');
+
+const toCamelCase = str => {
+  return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g,
+    function replacer(m, p1, p2) {
+      return p1.toUpperCase() + p2;
+    }
+  );
+};
+
+/* Creating a function that will check if an object has a property. */
+const hasOwnProperty = (({hasOwnProperty}) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype);
+
+/**
+ * Determine if a value is a RegExp object
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a RegExp object, otherwise false
+ */
+const isRegExp = kindOfTest('RegExp');
+
+const reduceDescriptors = (obj, reducer) => {
+  const descriptors = Object.getOwnPropertyDescriptors(obj);
+  const reducedDescriptors = {};
+
+  forEach(descriptors, (descriptor, name) => {
+    if (reducer(descriptor, name, obj) !== false) {
+      reducedDescriptors[name] = descriptor;
+    }
+  });
+
+  Object.defineProperties(obj, reducedDescriptors);
+}
+
+/**
+ * Makes all methods read-only
+ * @param {Object} obj
+ */
+
+const freezeMethods = (obj) => {
+  reduceDescriptors(obj, (descriptor, name) => {
+    // skip restricted props in strict mode
+    if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
+      return false;
+    }
+
+    const value = obj[name];
+
+    if (!isFunction(value)) return;
+
+    descriptor.enumerable = false;
+
+    if ('writable' in descriptor) {
+      descriptor.writable = false;
+      return;
+    }
+
+    if (!descriptor.set) {
+      descriptor.set = () => {
+        throw Error('Can not rewrite read-only method \'' + name + '\'');
+      };
+    }
+  });
+}
+
+const toObjectSet = (arrayOrString, delimiter) => {
+  const obj = {};
+
+  const define = (arr) => {
+    arr.forEach(value => {
+      obj[value] = true;
+    });
+  }
+
+  isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));
+
+  return obj;
+}
+
+const noop = () => {}
+
+const toFiniteNumber = (value, defaultValue) => {
+  value = +value;
+  return Number.isFinite(value) ? value : defaultValue;
+}
+
+const ALPHA = 'abcdefghijklmnopqrstuvwxyz'
+
+const DIGIT = '0123456789';
+
+const ALPHABET = {
+  DIGIT,
+  ALPHA,
+  ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT
+}
+
+const generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {
+  let str = '';
+  const {length} = alphabet;
+  while (size--) {
+    str += alphabet[Math.random() * length|0]
+  }
+
+  return str;
+}
+
+/**
+ * If the thing is a FormData object, return true, otherwise return false.
+ *
+ * @param {unknown} thing - The thing to check.
+ *
+ * @returns {boolean}
+ */
+function isSpecCompliantForm(thing) {
+  return !!(thing && isFunction(thing.append) && thing[Symbol.toStringTag] === 'FormData' && thing[Symbol.iterator]);
+}
+
+const toJSONObject = (obj) => {
+  const stack = new Array(10);
+
+  const visit = (source, i) => {
+
+    if (isObject(source)) {
+      if (stack.indexOf(source) >= 0) {
+        return;
+      }
+
+      if(!('toJSON' in source)) {
+        stack[i] = source;
+        const target = isArray(source) ? [] : {};
+
+        forEach(source, (value, key) => {
+          const reducedValue = visit(value, i + 1);
+          !isUndefined(reducedValue) && (target[key] = reducedValue);
+        });
+
+        stack[i] = undefined;
+
+        return target;
+      }
+    }
+
+    return source;
+  }
+
+  return visit(obj, 0);
+}
+
+export default {
+  isArray,
+  isArrayBuffer,
+  isBuffer,
+  isFormData,
+  isArrayBufferView,
+  isString,
+  isNumber,
+  isBoolean,
+  isObject,
+  isPlainObject,
+  isUndefined,
+  isDate,
+  isFile,
+  isBlob,
+  isRegExp,
+  isFunction,
+  isStream,
+  isURLSearchParams,
+  isTypedArray,
+  isFileList,
+  forEach,
+  merge,
+  extend,
+  trim,
+  stripBOM,
+  inherits,
+  toFlatObject,
+  kindOf,
+  kindOfTest,
+  endsWith,
+  toArray,
+  forEachEntry,
+  matchAll,
+  isHTMLForm,
+  hasOwnProperty,
+  hasOwnProp: hasOwnProperty, // an alias to avoid ESLint no-prototype-builtins detection
+  reduceDescriptors,
+  freezeMethods,
+  toObjectSet,
+  toCamelCase,
+  noop,
+  toFiniteNumber,
+  findKey,
+  global: _global,
+  isContextDefined,
+  ALPHABET,
+  generateString,
+  isSpecCompliantForm,
+  toJSONObject
+};
diff --git a/parent_dir/node_modules/bowser/src/bowser.js b/parent_dir/node_modules/bowser/src/bowser.js
new file mode 100644
index 0000000..f79e6e0
--- /dev/null
+++ b/parent_dir/node_modules/bowser/src/bowser.js
@@ -0,0 +1,77 @@
+/*!
+ * Bowser - a browser detector
+ * https://github.com/lancedikson/bowser
+ * MIT License | (c) Dustin Diaz 2012-2015
+ * MIT License | (c) Denis Demchenko 2015-2019
+ */
+import Parser from './parser.js';
+import {
+  BROWSER_MAP,
+  ENGINE_MAP,
+  OS_MAP,
+  PLATFORMS_MAP,
+} from './constants.js';
+
+/**
+ * Bowser class.
+ * Keep it simple as much as it can be.
+ * It's supposed to work with collections of {@link Parser} instances
+ * rather then solve one-instance problems.
+ * All the one-instance stuff is located in Parser class.
+ *
+ * @class
+ * @classdesc Bowser is a static object, that provides an API to the Parsers
+ * @hideconstructor
+ */
+class Bowser {
+  /**
+   * Creates a {@link Parser} instance
+   *
+   * @param {String} UA UserAgent string
+   * @param {Boolean} [skipParsing=false] Will make the Parser postpone parsing until you ask it
+   * explicitly. Same as `skipParsing` for {@link Parser}.
+   * @returns {Parser}
+   * @throws {Error} when UA is not a String
+   *
+   * @example
+   * const parser = Bowser.getParser(window.navigator.userAgent);
+   * const result = parser.getResult();
+   */
+  static getParser(UA, skipParsing = false) {
+    if (typeof UA !== 'string') {
+      throw new Error('UserAgent should be a string');
+    }
+    return new Parser(UA, skipParsing);
+  }
+
+  /**
+   * Creates a {@link Parser} instance and runs {@link Parser.getResult} immediately
+   *
+   * @param UA
+   * @return {ParsedResult}
+   *
+   * @example
+   * const result = Bowser.parse(window.navigator.userAgent);
+   */
+  static parse(UA) {
+    return (new Parser(UA)).getResult();
+  }
+
+  static get BROWSER_MAP() {
+    return BROWSER_MAP;
+  }
+
+  static get ENGINE_MAP() {
+    return ENGINE_MAP;
+  }
+
+  static get OS_MAP() {
+    return OS_MAP;
+  }
+
+  static get PLATFORMS_MAP() {
+    return PLATFORMS_MAP;
+  }
+}
+
+export default Bowser;
diff --git a/parent_dir/node_modules/bowser/src/constants.js b/parent_dir/node_modules/bowser/src/constants.js
new file mode 100644
index 0000000..f335032
--- /dev/null
+++ b/parent_dir/node_modules/bowser/src/constants.js
@@ -0,0 +1,116 @@
+// NOTE: this list must be up-to-date with browsers listed in
+// test/acceptance/useragentstrings.yml
+export const BROWSER_ALIASES_MAP = {
+  'Amazon Silk': 'amazon_silk',
+  'Android Browser': 'android',
+  Bada: 'bada',
+  BlackBerry: 'blackberry',
+  Chrome: 'chrome',
+  Chromium: 'chromium',
+  Electron: 'electron',
+  Epiphany: 'epiphany',
+  Firefox: 'firefox',
+  Focus: 'focus',
+  Generic: 'generic',
+  'Google Search': 'google_search',
+  Googlebot: 'googlebot',
+  'Internet Explorer': 'ie',
+  'K-Meleon': 'k_meleon',
+  Maxthon: 'maxthon',
+  'Microsoft Edge': 'edge',
+  'MZ Browser': 'mz',
+  'NAVER Whale Browser': 'naver',
+  Opera: 'opera',
+  'Opera Coast': 'opera_coast',
+  PhantomJS: 'phantomjs',
+  Puffin: 'puffin',
+  QupZilla: 'qupzilla',
+  QQ: 'qq',
+  QQLite: 'qqlite',
+  Safari: 'safari',
+  Sailfish: 'sailfish',
+  'Samsung Internet for Android': 'samsung_internet',
+  SeaMonkey: 'seamonkey',
+  Sleipnir: 'sleipnir',
+  Swing: 'swing',
+  Tizen: 'tizen',
+  'UC Browser': 'uc',
+  Vivaldi: 'vivaldi',
+  'WebOS Browser': 'webos',
+  WeChat: 'wechat',
+  'Yandex Browser': 'yandex',
+  Roku: 'roku',
+};
+
+export const BROWSER_MAP = {
+  amazon_silk: 'Amazon Silk',
+  android: 'Android Browser',
+  bada: 'Bada',
+  blackberry: 'BlackBerry',
+  chrome: 'Chrome',
+  chromium: 'Chromium',
+  electron: 'Electron',
+  epiphany: 'Epiphany',
+  firefox: 'Firefox',
+  focus: 'Focus',
+  generic: 'Generic',
+  googlebot: 'Googlebot',
+  google_search: 'Google Search',
+  ie: 'Internet Explorer',
+  k_meleon: 'K-Meleon',
+  maxthon: 'Maxthon',
+  edge: 'Microsoft Edge',
+  mz: 'MZ Browser',
+  naver: 'NAVER Whale Browser',
+  opera: 'Opera',
+  opera_coast: 'Opera Coast',
+  phantomjs: 'PhantomJS',
+  puffin: 'Puffin',
+  qupzilla: 'QupZilla',
+  qq: 'QQ Browser',
+  qqlite: 'QQ Browser Lite',
+  safari: 'Safari',
+  sailfish: 'Sailfish',
+  samsung_internet: 'Samsung Internet for Android',
+  seamonkey: 'SeaMonkey',
+  sleipnir: 'Sleipnir',
+  swing: 'Swing',
+  tizen: 'Tizen',
+  uc: 'UC Browser',
+  vivaldi: 'Vivaldi',
+  webos: 'WebOS Browser',
+  wechat: 'WeChat',
+  yandex: 'Yandex Browser',
+};
+
+export const PLATFORMS_MAP = {
+  tablet: 'tablet',
+  mobile: 'mobile',
+  desktop: 'desktop',
+  tv: 'tv',
+};
+
+export const OS_MAP = {
+  WindowsPhone: 'Windows Phone',
+  Windows: 'Windows',
+  MacOS: 'macOS',
+  iOS: 'iOS',
+  Android: 'Android',
+  WebOS: 'WebOS',
+  BlackBerry: 'BlackBerry',
+  Bada: 'Bada',
+  Tizen: 'Tizen',
+  Linux: 'Linux',
+  ChromeOS: 'Chrome OS',
+  PlayStation4: 'PlayStation 4',
+  Roku: 'Roku',
+};
+
+export const ENGINE_MAP = {
+  EdgeHTML: 'EdgeHTML',
+  Blink: 'Blink',
+  Trident: 'Trident',
+  Presto: 'Presto',
+  Gecko: 'Gecko',
+  WebKit: 'WebKit',
+};
diff --git a/parent_dir/node_modules/bowser/src/parser-browsers.js b/parent_dir/node_modules/bowser/src/parser-browsers.js
new file mode 100644
index 0000000..ee7840c
--- /dev/null
+++ b/parent_dir/node_modules/bowser/src/parser-browsers.js
@@ -0,0 +1,700 @@
+/**
+ * Browsers' descriptors
+ *
+ * The idea of descriptors is simple. You should know about them two simple things:
+ * 1. Every descriptor has a method or property called `test` and a `describe` method.
+ * 2. Order of descriptors is important.
+ *
+ * More details:
+ * 1. Method or property `test` serves as a way to detect whether the UA string
+ * matches some certain browser or not. The `describe` method helps to make a result
+ * object with params that show some browser-specific things: name, version, etc.
+ * 2. Order of descriptors is important because a Parser goes through them one by one
+ * in course. For example, if you insert Chrome's descriptor as the first one,
+ * more then a half of browsers will be described as Chrome, because they will pass
+ * the Chrome descriptor's test.
+ *
+ * Descriptor's `test` could be a property with an array of RegExps, where every RegExp
+ * will be applied to a UA string to test it whether it matches or not.
+ * If a descriptor has two or more regexps in the `test` array it tests them one by one
+ * with a logical sum operation. Parser stops if it has found any RegExp that matches the UA.
+ *
+ * Or `test` could be a method. In that case it gets a Parser instance and should
+ * return true/false to get the Parser know if this browser descriptor matches the UA or not.
+ */
+
+import Utils from './utils.js';
+
+const commonVersionIdentifier = /version\/(\d+(\.?_?\d+)+)/i;
+
+const browsersList = [
+  /* Googlebot */
+  {
+    test: [/googlebot/i],
+    describe(ua) {
+      const browser = {
+        name: 'Googlebot',
+      };
+      const version = Utils.getFirstMatch(/googlebot\/(\d+(\.\d+))/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+
+  /* Opera < 13.0 */
+  {
+    test: [/opera/i],
+    describe(ua) {
+      const browser = {
+        name: 'Opera',
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:opera)[\s/](\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+
+  /* Opera > 13.0 */
+  {
+    test: [/opr\/|opios/i],
+    describe(ua) {
+      const browser = {
+        name: 'Opera',
+      };
+      const version = Utils.getFirstMatch(/(?:opr|opios)[\s/](\S+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/SamsungBrowser/i],
+    describe(ua) {
+      const browser = {
+        name: 'Samsung Internet for Android',
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:SamsungBrowser)[\s/](\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/Whale/i],
+    describe(ua) {
+      const browser = {
+        name: 'NAVER Whale Browser',
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:whale)[\s/](\d+(?:\.\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/MZBrowser/i],
+    describe(ua) {
+      const browser = {
+        name: 'MZ Browser',
+      };
+      const version = Utils.getFirstMatch(/(?:MZBrowser)[\s/](\d+(?:\.\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/focus/i],
+    describe(ua) {
+      const browser = {
+        name: 'Focus',
+      };
+      const version = Utils.getFirstMatch(/(?:focus)[\s/](\d+(?:\.\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/swing/i],
+    describe(ua) {
+      const browser = {
+        name: 'Swing',
+      };
+      const version = Utils.getFirstMatch(/(?:swing)[\s/](\d+(?:\.\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/coast/i],
+    describe(ua) {
+      const browser = {
+        name: 'Opera Coast',
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:coast)[\s/](\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/opt\/\d+(?:.?_?\d+)+/i],
+    describe(ua) {
+      const browser = {
+        name: 'Opera Touch',
+      };
+      const version = Utils.getFirstMatch(/(?:opt)[\s/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/yabrowser/i],
+    describe(ua) {
+      const browser = {
+        name: 'Yandex Browser',
+      };
+      const version = Utils.getFirstMatch(/(?:yabrowser)[\s/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/ucbrowser/i],
+    describe(ua) {
+      const browser = {
+        name: 'UC Browser',
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:ucbrowser)[\s/](\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/Maxthon|mxios/i],
+    describe(ua) {
+      const browser = {
+        name: 'Maxthon',
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:Maxthon|mxios)[\s/](\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/epiphany/i],
+    describe(ua) {
+      const browser = {
+        name: 'Epiphany',
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:epiphany)[\s/](\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/puffin/i],
+    describe(ua) {
+      const browser = {
+        name: 'Puffin',
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:puffin)[\s/](\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/sleipnir/i],
+    describe(ua) {
+      const browser = {
+        name: 'Sleipnir',
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:sleipnir)[\s/](\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/k-meleon/i],
+    describe(ua) {
+      const browser = {
+        name: 'K-Meleon',
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:k-meleon)[\s/](\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/micromessenger/i],
+    describe(ua) {
+      const browser = {
+        name: 'WeChat',
+      };
+      const version = Utils.getFirstMatch(/(?:micromessenger)[\s/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/qqbrowser/i],
+    describe(ua) {
+      const browser = {
+        name: (/qqbrowserlite/i).test(ua) ? 'QQ Browser Lite' : 'QQ Browser',
+      };
+      const version = Utils.getFirstMatch(/(?:qqbrowserlite|qqbrowser)[/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/msie|trident/i],
+    describe(ua) {
+      const browser = {
+        name: 'Internet Explorer',
+      };
+      const version = Utils.getFirstMatch(/(?:msie |rv:)(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/\sedg\//i],
+    describe(ua) {
+      const browser = {
+        name: 'Microsoft Edge',
+      };
+
+      const version = Utils.getFirstMatch(/\sedg\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/edg([ea]|ios)/i],
+    describe(ua) {
+      const browser = {
+        name: 'Microsoft Edge',
+      };
+
+      const version = Utils.getSecondMatch(/edg([ea]|ios)\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/vivaldi/i],
+    describe(ua) {
+      const browser = {
+        name: 'Vivaldi',
+      };
+      const version = Utils.getFirstMatch(/vivaldi\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/seamonkey/i],
+    describe(ua) {
+      const browser = {
+        name: 'SeaMonkey',
+      };
+      const version = Utils.getFirstMatch(/seamonkey\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/sailfish/i],
+    describe(ua) {
+      const browser = {
+        name: 'Sailfish',
+      };
+
+      const version = Utils.getFirstMatch(/sailfish\s?browser\/(\d+(\.\d+)?)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/silk/i],
+    describe(ua) {
+      const browser = {
+        name: 'Amazon Silk',
+      };
+      const version = Utils.getFirstMatch(/silk\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/phantom/i],
+    describe(ua) {
+      const browser = {
+        name: 'PhantomJS',
+      };
+      const version = Utils.getFirstMatch(/phantomjs\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/slimerjs/i],
+    describe(ua) {
+      const browser = {
+        name: 'SlimerJS',
+      };
+      const version = Utils.getFirstMatch(/slimerjs\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/blackberry|\bbb\d+/i, /rim\stablet/i],
+    describe(ua) {
+      const browser = {
+        name: 'BlackBerry',
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/blackberry[\d]+\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/(web|hpw)[o0]s/i],
+    describe(ua) {
+      const browser = {
+        name: 'WebOS Browser',
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/w(?:eb)?[o0]sbrowser\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/bada/i],
+    describe(ua) {
+      const browser = {
+        name: 'Bada',
+      };
+      const version = Utils.getFirstMatch(/dolfin\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/tizen/i],
+    describe(ua) {
+      const browser = {
+        name: 'Tizen',
+      };
+      const version = Utils.getFirstMatch(/(?:tizen\s?)?browser\/(\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/qupzilla/i],
+    describe(ua) {
+      const browser = {
+        name: 'QupZilla',
+      };
+      const version = Utils.getFirstMatch(/(?:qupzilla)[\s/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/firefox|iceweasel|fxios/i],
+    describe(ua) {
+      const browser = {
+        name: 'Firefox',
+      };
+      const version = Utils.getFirstMatch(/(?:firefox|iceweasel|fxios)[\s/](\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/electron/i],
+    describe(ua) {
+      const browser = {
+        name: 'Electron',
+      };
+      const version = Utils.getFirstMatch(/(?:electron)\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/MiuiBrowser/i],
+    describe(ua) {
+      const browser = {
+        name: 'Miui',
+      };
+      const version = Utils.getFirstMatch(/(?:MiuiBrowser)[\s/](\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/chromium/i],
+    describe(ua) {
+      const browser = {
+        name: 'Chromium',
+      };
+      const version = Utils.getFirstMatch(/(?:chromium)[\s/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/chrome|crios|crmo/i],
+    describe(ua) {
+      const browser = {
+        name: 'Chrome',
+      };
+      const version = Utils.getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+  {
+    test: [/GSA/i],
+    describe(ua) {
+      const browser = {
+        name: 'Google Search',
+      };
+      const version = Utils.getFirstMatch(/(?:GSA)\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+
+  /* Android Browser */
+  {
+    test(parser) {
+      const notLikeAndroid = !parser.test(/like android/i);
+      const butAndroid = parser.test(/android/i);
+      return notLikeAndroid && butAndroid;
+    },
+    describe(ua) {
+      const browser = {
+        name: 'Android Browser',
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+
+  /* PlayStation 4 */
+  {
+    test: [/playstation 4/i],
+    describe(ua) {
+      const browser = {
+        name: 'PlayStation 4',
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+
+  /* Safari */
+  {
+    test: [/safari|applewebkit/i],
+    describe(ua) {
+      const browser = {
+        name: 'Safari',
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua);
+
+      if (version) {
+        browser.version = version;
+      }
+
+      return browser;
+    },
+  },
+
+  /* Something else */
+  {
+    test: [/.*/i],
+    describe(ua) {
+      /* Here we try to make sure that there are explicit details about the device
+       * in order to decide what regexp exactly we want to apply
+       * (as there is a specific decision based on that conclusion)
+       */
+      const regexpWithoutDeviceSpec = /^(.*)\/(.*) /;
+      const regexpWithDeviceSpec = /^(.*)\/(.*)[ \t]\((.*)/;
+      const hasDeviceSpec = ua.search('\\(') !== -1;
+      const regexp = hasDeviceSpec ? regexpWithDeviceSpec : regexpWithoutDeviceSpec;
+      return {
+        name: Utils.getFirstMatch(regexp, ua),
+        version: Utils.getSecondMatch(regexp, ua),
+      };
+    },
+  },
+];
+
+export default browsersList;
diff --git a/parent_dir/node_modules/bowser/src/parser-engines.js b/parent_dir/node_modules/bowser/src/parser-engines.js
new file mode 100644
index 0000000..d46d0e5
--- /dev/null
+++ b/parent_dir/node_modules/bowser/src/parser-engines.js
@@ -0,0 +1,120 @@
+import Utils from './utils.js';
+import { ENGINE_MAP } from './constants.js';
+
+/*
+ * More specific goes first
+ */
+export default [
+  /* EdgeHTML */
+  {
+    test(parser) {
+      return parser.getBrowserName(true) === 'microsoft edge';
+    },
+    describe(ua) {
+      const isBlinkBased = /\sedg\//i.test(ua);
+
+      // return blink if it's blink-based one
+      if (isBlinkBased) {
+        return {
+          name: ENGINE_MAP.Blink,
+        };
+      }
+
+      // otherwise match the version and return EdgeHTML
+      const version = Utils.getFirstMatch(/edge\/(\d+(\.?_?\d+)+)/i, ua);
+
+      return {
+        name: ENGINE_MAP.EdgeHTML,
+        version,
+      };
+    },
+  },
+
+  /* Trident */
+  {
+    test: [/trident/i],
+    describe(ua) {
+      const engine = {
+        name: ENGINE_MAP.Trident,
+      };
+
+      const version = Utils.getFirstMatch(/trident\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        engine.version = version;
+      }
+
+      return engine;
+    },
+  },
+
+  /* Presto */
+  {
+    test(parser) {
+      return parser.test(/presto/i);
+    },
+    describe(ua) {
+      const engine = {
+        name: ENGINE_MAP.Presto,
+      };
+
+      const version = Utils.getFirstMatch(/presto\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        engine.version = version;
+      }
+
+      return engine;
+    },
+  },
+
+  /* Gecko */
+  {
+    test(parser) {
+      const isGecko = parser.test(/gecko/i);
+      const likeGecko = parser.test(/like gecko/i);
+      return isGecko && !likeGecko;
+    },
+    describe(ua) {
+      const engine = {
+        name: ENGINE_MAP.Gecko,
+      };
+
+      const version = Utils.getFirstMatch(/gecko\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        engine.version = version;
+      }
+
+      return engine;
+    },
+  },
+
+  /* Blink */
+  {
+    test: [/(apple)?webkit\/537\.36/i],
+    describe() {
+      return {
+        name: ENGINE_MAP.Blink,
+      };
+    },
+  },
+
+  /* WebKit */
+  {
+    test: [/(apple)?webkit/i],
+    describe(ua) {
+      const engine = {
+        name: ENGINE_MAP.WebKit,
+      };
+
+      const version = Utils.getFirstMatch(/webkit\/(\d+(\.?_?\d+)+)/i, ua);
+
+      if (version) {
+        engine.version = version;
+      }
+
+      return engine;
+    },
+  },
+];
diff --git a/parent_dir/node_modules/bowser/src/parser-os.js b/parent_dir/node_modules/bowser/src/parser-os.js
new file mode 100644
index 0000000..4c516dd
--- /dev/null
+++ b/parent_dir/node_modules/bowser/src/parser-os.js
@@ -0,0 +1,199 @@
+import Utils from './utils.js';
+import { OS_MAP } from './constants.js';
+
+export default [
+  /* Roku */
+  {
+    test: [/Roku\/DVP/],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/Roku\/DVP-(\d+\.\d+)/i, ua);
+      return {
+        name: OS_MAP.Roku,
+        version,
+      };
+    },
+  },
+
+  /* Windows Phone */
+  {
+    test: [/windows phone/i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i, ua);
+      return {
+        name: OS_MAP.WindowsPhone,
+        version,
+      };
+    },
+  },
+
+  /* Windows */
+  {
+    test: [/windows /i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/Windows ((NT|XP)( \d\d?.\d)?)/i, ua);
+      const versionName = Utils.getWindowsVersionName(version);
+
+      return {
+        name: OS_MAP.Windows,
+        version,
+        versionName,
+      };
+    },
+  },
+
+  /* Firefox on iPad */
+  {
+    test: [/Macintosh(.*?) FxiOS(.*?)\//],
+    describe(ua) {
+      const result = {
+        name: OS_MAP.iOS,
+      };
+      const version = Utils.getSecondMatch(/(Version\/)(\d[\d.]+)/, ua);
+      if (version) {
+        result.version = version;
+      }
+      return result;
+    },
+  },
+
+  /* macOS */
+  {
+    test: [/macintosh/i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/mac os x (\d+(\.?_?\d+)+)/i, ua).replace(/[_\s]/g, '.');
+      const versionName = Utils.getMacOSVersionName(version);
+
+      const os = {
+        name: OS_MAP.MacOS,
+        version,
+      };
+      if (versionName) {
+        os.versionName = versionName;
+      }
+      return os;
+    },
+  },
+
+  /* iOS */
+  {
+    test: [/(ipod|iphone|ipad)/i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/os (\d+([_\s]\d+)*) like mac os x/i, ua).replace(/[_\s]/g, '.');
+
+      return {
+        name: OS_MAP.iOS,
+        version,
+      };
+    },
+  },
+
+  /* Android */
+  {
+    test(parser) {
+      const notLikeAndroid = !parser.test(/like android/i);
+      const butAndroid = parser.test(/android/i);
+      return notLikeAndroid && butAndroid;
+    },
+    describe(ua) {
+      const version = Utils.getFirstMatch(/android[\s/-](\d+(\.\d+)*)/i, ua);
+      const versionName = Utils.getAndroidVersionName(version);
+      const os = {
+        name: OS_MAP.Android,
+        version,
+      };
+      if (versionName) {
+        os.versionName = versionName;
+      }
+      return os;
+    },
+  },
+
+  /* WebOS */
+  {
+    test: [/(web|hpw)[o0]s/i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/(?:web|hpw)[o0]s\/(\d+(\.\d+)*)/i, ua);
+      const os = {
+        name: OS_MAP.WebOS,
+      };
+
+      if (version && version.length) {
+        os.version = version;
+      }
+      return os;
+    },
+  },
+
+  /* BlackBerry */
+  {
+    test: [/blackberry|\bbb\d+/i, /rim\stablet/i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/rim\stablet\sos\s(\d+(\.\d+)*)/i, ua)
+        || Utils.getFirstMatch(/blackberry\d+\/(\d+([_\s]\d+)*)/i, ua)
+        || Utils.getFirstMatch(/\bbb(\d+)/i, ua);
+
+      return {
+        name: OS_MAP.BlackBerry,
+        version,
+      };
+    },
+  },
+
+  /* Bada */
+  {
+    test: [/bada/i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/bada\/(\d+(\.\d+)*)/i, ua);
+
+      return {
+        name: OS_MAP.Bada,
+        version,
+      };
+    },
+  },
+
+  /* Tizen */
+  {
+    test: [/tizen/i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/tizen[/\s](\d+(\.\d+)*)/i, ua);
+
+      return {
+        name: OS_MAP.Tizen,
+        version,
+      };
+    },
+  },
+
+  /* Linux */
+  {
+    test: [/linux/i],
+    describe() {
+      return {
+        name: OS_MAP.Linux,
+      };
+    },
+  },
+
+  /* Chrome OS */
+  {
+    test: [/CrOS/],
+    describe() {
+      return {
+        name: OS_MAP.ChromeOS,
+      };
+    },
+  },
+
+  /* Playstation 4 */
+  {
+    test: [/PlayStation 4/],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/PlayStation 4[/\s](\d+(\.\d+)*)/i, ua);
+      return {
+        name: OS_MAP.PlayStation4,
+        version,
+      };
+    },
+  },
+];
diff --git a/parent_dir/node_modules/bowser/src/parser-platforms.js b/parent_dir/node_modules/bowser/src/parser-platforms.js
new file mode 100644
index 0000000..48b1eb1
--- /dev/null
+++ b/parent_dir/node_modules/bowser/src/parser-platforms.js
@@ -0,0 +1,266 @@
+import Utils from './utils.js';
+import { PLATFORMS_MAP } from './constants.js';
+
+/*
+ * Tablets go first since usually they have more specific
+ * signs to detect.
+ */
+
+export default [
+  /* Googlebot */
+  {
+    test: [/googlebot/i],
+    describe() {
+      return {
+        type: 'bot',
+        vendor: 'Google',
+      };
+    },
+  },
+
+  /* Huawei */
+  {
+    test: [/huawei/i],
+    describe(ua) {
+      const model = Utils.getFirstMatch(/(can-l01)/i, ua) && 'Nova';
+      const platform = {
+        type: PLATFORMS_MAP.mobile,
+        vendor: 'Huawei',
+      };
+      if (model) {
+        platform.model = model;
+      }
+      return platform;
+    },
+  },
+
+  /* Nexus Tablet */
+  {
+    test: [/nexus\s*(?:7|8|9|10).*/i],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tablet,
+        vendor: 'Nexus',
+      };
+    },
+  },
+
+  /* iPad */
+  {
+    test: [/ipad/i],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tablet,
+        vendor: 'Apple',
+        model: 'iPad',
+      };
+    },
+  },
+
+  /* Firefox on iPad */
+  {
+    test: [/Macintosh(.*?) FxiOS(.*?)\//],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tablet,
+        vendor: 'Apple',
+        model: 'iPad',
+      };
+    },
+  },
+
+  /* Amazon Kindle Fire */
+  {
+    test: [/kftt build/i],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tablet,
+        vendor: 'Amazon',
+        model: 'Kindle Fire HD 7',
+      };
+    },
+  },
+
+  /* Another Amazon Tablet with Silk */
+  {
+    test: [/silk/i],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tablet,
+        vendor: 'Amazon',
+      };
+    },
+  },
+
+  /* Tablet */
+  {
+    test: [/tablet(?! pc)/i],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tablet,
+      };
+    },
+  },
+
+  /* iPod/iPhone */
+  {
+    test(parser) {
+      const iDevice = parser.test(/ipod|iphone/i);
+      const likeIDevice = parser.test(/like (ipod|iphone)/i);
+      return iDevice && !likeIDevice;
+    },
+    describe(ua) {
+      const model = Utils.getFirstMatch(/(ipod|iphone)/i, ua);
+      return {
+        type: PLATFORMS_MAP.mobile,
+        vendor: 'Apple',
+        model,
+      };
+    },
+  },
+
+  /* Nexus Mobile */
+  {
+    test: [/nexus\s*[0-6].*/i, /galaxy nexus/i],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.mobile,
+        vendor: 'Nexus',
+      };
+    },
+  },
+
+  /* Mobile */
+  {
+    test: [/[^-]mobi/i],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.mobile,
+      };
+    },
+  },
+
+  /* BlackBerry */
+  {
+    test(parser) {
+      return parser.getBrowserName(true) === 'blackberry';
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.mobile,
+        vendor: 'BlackBerry',
+      };
+    },
+  },
+
+  /* Bada */
+  {
+    test(parser) {
+      return parser.getBrowserName(true) === 'bada';
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.mobile,
+      };
+    },
+  },
+
+  /* Windows Phone */
+  {
+    test(parser) {
+      return parser.getBrowserName() === 'windows phone';
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.mobile,
+        vendor: 'Microsoft',
+      };
+    },
+  },
+
+  /* Android Tablet */
+  {
+    test(parser) {
+      const osMajorVersion = Number(String(parser.getOSVersion()).split('.')[0]);
+      return parser.getOSName(true) === 'android' && (osMajorVersion >= 3);
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tablet,
+      };
+    },
+  },
+
+  /* Android Mobile */
+  {
+    test(parser) {
+      return parser.getOSName(true) === 'android';
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.mobile,
+      };
+    },
+  },
+
+  /* desktop */
+  {
+    test(parser) {
+      return parser.getOSName(true) === 'macos';
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.desktop,
+        vendor: 'Apple',
+      };
+    },
+  },
+
+  /* Windows */
+  {
+    test(parser) {
+      return parser.getOSName(true) === 'windows';
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.desktop,
+      };
+    },
+  },
+
+  /* Linux */
+  {
+    test(parser) {
+      return parser.getOSName(true) === 'linux';
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.desktop,
+      };
+    },
+  },
+
+  /* PlayStation 4 */
+  {
+    test(parser) {
+      return parser.getOSName(true) === 'playstation 4';
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tv,
+      };
+    },
+  },
+
+  /* Roku */
+  {
+    test(parser) {
+      return parser.getOSName(true) === 'roku';
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tv,
+      };
+    },
+  },
+];
diff --git a/parent_dir/node_modules/bowser/src/parser.js b/parent_dir/node_modules/bowser/src/parser.js
new file mode 100644
index 0000000..c87d0e1
--- /dev/null
+++ b/parent_dir/node_modules/bowser/src/parser.js
@@ -0,0 +1,496 @@
+import browserParsersList from './parser-browsers.js';
+import osParsersList from './parser-os.js';
+import platformParsersList from './parser-platforms.js';
+import enginesParsersList from './parser-engines.js';
+import Utils from './utils.js';
+
+/**
+ * The main class that arranges the whole parsing process.
+ */
+class Parser {
+  /**
+   * Create instance of Parser
+   *
+   * @param {String} UA User-Agent string
+   * @param {Boolean} [skipParsing=false] parser can skip parsing in purpose of performance
+   * improvements if you need to make a more particular parsing
+   * like {@link Parser#parseBrowser} or {@link Parser#parsePlatform}
+   *
+   * @throw {Error} in case of empty UA String
+   *
+   * @constructor
+   */
+  constructor(UA, skipParsing = false) {
+    if (UA === void (0) || UA === null || UA === '') {
+      throw new Error("UserAgent parameter can't be empty");
+    }
+
+    this._ua = UA;
+
+    /**
+     * @typedef ParsedResult
+     * @property {Object} browser
+     * @property {String|undefined} [browser.name]
+     * Browser name, like `"Chrome"` or `"Internet Explorer"`
+     * @property {String|undefined} [browser.version] Browser version as a String `"12.01.45334.10"`
+     * @property {Object} os
+     * @property {String|undefined} [os.name] OS name, like `"Windows"` or `"macOS"`
+     * @property {String|undefined} [os.version] OS version, like `"NT 5.1"` or `"10.11.1"`
+     * @property {String|undefined} [os.versionName] OS name, like `"XP"` or `"High Sierra"`
+     * @property {Object} platform
+     * @property {String|undefined} [platform.type]
+     * platform type, can be either `"desktop"`, `"tablet"` or `"mobile"`
+     * @property {String|undefined} [platform.vendor] Vendor of the device,
+     * like `"Apple"` or `"Samsung"`
+     * @property {String|undefined} [platform.model] Device model,
+     * like `"iPhone"` or `"Kindle Fire HD 7"`
+     * @property {Object} engine
+     * @property {String|undefined} [engine.name]
+     * Can be any of this: `WebKit`, `Blink`, `Gecko`, `Trident`, `Presto`, `EdgeHTML`
+     * @property {String|undefined} [engine.version] String version of the engine
+     */
+    this.parsedResult = {};
+
+    if (skipParsing !== true) {
+      this.parse();
+    }
+  }
+
+  /**
+   * Get UserAgent string of current Parser instance
+   * @return {String} User-Agent String of the current <Parser> object
+   *
+   * @public
+   */
+  getUA() {
+    return this._ua;
+  }
+
+  /**
+   * Test a UA string for a regexp
+   * @param {RegExp} regex
+   * @return {Boolean}
+   */
+  test(regex) {
+    return regex.test(this._ua);
+  }
+
+  /**
+   * Get parsed browser object
+   * @return {Object}
+   */
+  parseBrowser() {
+    this.parsedResult.browser = {};
+
+    const browserDescriptor = Utils.find(browserParsersList, (_browser) => {
+      if (typeof _browser.test === 'function') {
+        return _browser.test(this);
+      }
+
+      if (_browser.test instanceof Array) {
+        return _browser.test.some(condition => this.test(condition));
+      }
+
+      throw new Error("Browser's test function is not valid");
+    });
+
+    if (browserDescriptor) {
+      this.parsedResult.browser = browserDescriptor.describe(this.getUA());
+    }
+
+    return this.parsedResult.browser;
+  }
+
+  /**
+   * Get parsed browser object
+   * @return {Object}
+   *
+   * @public
+   */
+  getBrowser() {
+    if (this.parsedResult.browser) {
+      return this.parsedResult.browser;
+    }
+
+    return this.parseBrowser();
+  }
+
+  /**
+   * Get browser's name
+   * @return {String} Browser's name or an empty string
+   *
+   * @public
+   */
+  getBrowserName(toLowerCase) {
+    if (toLowerCase) {
+      return String(this.getBrowser().name).toLowerCase() || '';
+    }
+    return this.getBrowser().name || '';
+  }
+
+
+  /**
+   * Get browser's version
+   * @return {String} version of browser
+   *
+   * @public
+   */
+  getBrowserVersion() {
+    return this.getBrowser().version;
+  }
+
+  /**
+   * Get OS
+   * @return {Object}
+   *
+   * @example
+   * this.getOS();
+   * {
+   *   name: 'macOS',
+   *   version: '10.11.12'
+   * }
+   */
+  getOS() {
+    if (this.parsedResult.os) {
+      return this.parsedResult.os;
+    }
+
+    return this.parseOS();
+  }
+
+  /**
+   * Parse OS and save it to this.parsedResult.os
+   * @return {*|{}}
+   */
+  parseOS() {
+    this.parsedResult.os = {};
+
+    const os = Utils.find(osParsersList, (_os) => {
+      if (typeof _os.test === 'function') {
+        return _os.test(this);
+      }
+
+      if (_os.test instanceof Array) {
+        return _os.test.some(condition => this.test(condition));
+      }
+
+      throw new Error("Browser's test function is not valid");
+    });
+
+    if (os) {
+      this.parsedResult.os = os.describe(this.getUA());
+    }
+
+    return this.parsedResult.os;
+  }
+
+  /**
+   * Get OS name
+   * @param {Boolean} [toLowerCase] return lower-cased value
+   * @return {String} name of the OS — macOS, Windows, Linux, etc.
+   */
+  getOSName(toLowerCase) {
+    const { name } = this.getOS();
+
+    if (toLowerCase) {
+      return String(name).toLowerCase() || '';
+    }
+
+    return name || '';
+  }
+
+  /**
+   * Get OS version
+   * @return {String} full version with dots ('10.11.12', '5.6', etc)
+   */
+  getOSVersion() {
+    return this.getOS().version;
+  }
+
+  /**
+   * Get parsed platform
+   * @return {{}}
+   */
+  getPlatform() {
+    if (this.parsedResult.platform) {
+      return this.parsedResult.platform;
+    }
+
+    return this.parsePlatform();
+  }
+
+  /**
+   * Get platform name
+   * @param {Boolean} [toLowerCase=false]
+   * @return {*}
+   */
+  getPlatformType(toLowerCase = false) {
+    const { type } = this.getPlatform();
+
+    if (toLowerCase) {
+      return String(type).toLowerCase() || '';
+    }
+
+    return type || '';
+  }
+
+  /**
+   * Get parsed platform
+   * @return {{}}
+   */
+  parsePlatform() {
+    this.parsedResult.platform = {};
+
+    const platform = Utils.find(platformParsersList, (_platform) => {
+      if (typeof _platform.test === 'function') {
+        return _platform.test(this);
+      }
+
+      if (_platform.test instanceof Array) {
+        return _platform.test.some(condition => this.test(condition));
+      }
+
+      throw new Error("Browser's test function is not valid");
+    });
+
+    if (platform) {
+      this.parsedResult.platform = platform.describe(this.getUA());
+    }
+
+    return this.parsedResult.platform;
+  }
+
+  /**
+   * Get parsed engine
+   * @return {{}}
+   */
+  getEngine() {
+    if (this.parsedResult.engine) {
+      return this.parsedResult.engine;
+    }
+
+    return this.parseEngine();
+  }
+
+  /**
+   * Get engines's name
+   * @return {String} Engines's name or an empty string
+   *
+   * @public
+   */
+  getEngineName(toLowerCase) {
+    if (toLowerCase) {
+      return String(this.getEngine().name).toLowerCase() || '';
+    }
+    return this.getEngine().name || '';
+  }
+
+  /**
+   * Get parsed platform
+   * @return {{}}
+   */
+  parseEngine() {
+    this.parsedResult.engine = {};
+
+    const engine = Utils.find(enginesParsersList, (_engine) => {
+      if (typeof _engine.test === 'function') {
+        return _engine.test(this);
+      }
+
+      if (_engine.test instanceof Array) {
+        return _engine.test.some(condition => this.test(condition));
+      }
+
+      throw new Error("Browser's test function is not valid");
+    });
+
+    if (engine) {
+      this.parsedResult.engine = engine.describe(this.getUA());
+    }
+
+    return this.parsedResult.engine;
+  }
+
+  /**
+   * Parse full information about the browser
+   * @returns {Parser}
+   */
+  parse() {
+    this.parseBrowser();
+    this.parseOS();
+    this.parsePlatform();
+    this.parseEngine();
+
+    return this;
+  }
+
+  /**
+   * Get parsed result
+   * @return {ParsedResult}
+   */
+  getResult() {
+    return Utils.assign({}, this.parsedResult);
+  }
+
+  /**
+   * Check if parsed browser matches certain conditions
+   *
+   * @param {Object} checkTree It's one or two layered object,
+   * which can include a platform or an OS on the first layer
+   * and should have browsers specs on the bottom-laying layer
+   *
+   * @returns {Boolean|undefined} Whether the browser satisfies the set conditions or not.
+   * Returns `undefined` when the browser is no described in the checkTree object.
+   *
+   * @example
+   * const browser = Bowser.getParser(window.navigator.userAgent);
+   * if (browser.satisfies({chrome: '>118.01.1322' }))
+   * // or with os
+   * if (browser.satisfies({windows: { chrome: '>118.01.1322' } }))
+   * // or with platforms
+   * if (browser.satisfies({desktop: { chrome: '>118.01.1322' } }))
+   */
+  satisfies(checkTree) {
+    const platformsAndOSes = {};
+    let platformsAndOSCounter = 0;
+    const browsers = {};
+    let browsersCounter = 0;
+
+    const allDefinitions = Object.keys(checkTree);
+
+    allDefinitions.forEach((key) => {
+      const currentDefinition = checkTree[key];
+      if (typeof currentDefinition === 'string') {
+        browsers[key] = currentDefinition;
+        browsersCounter += 1;
+      } else if (typeof currentDefinition === 'object') {
+        platformsAndOSes[key] = currentDefinition;
+        platformsAndOSCounter += 1;
+      }
+    });
+
+    if (platformsAndOSCounter > 0) {
+      const platformsAndOSNames = Object.keys(platformsAndOSes);
+      const OSMatchingDefinition = Utils.find(platformsAndOSNames, name => (this.isOS(name)));
+
+      if (OSMatchingDefinition) {
+        const osResult = this.satisfies(platformsAndOSes[OSMatchingDefinition]);
+
+        if (osResult !== void 0) {
+          return osResult;
+        }
+      }
+
+      const platformMatchingDefinition = Utils.find(
+        platformsAndOSNames,
+        name => (this.isPlatform(name)),
+      );
+      if (platformMatchingDefinition) {
+        const platformResult = this.satisfies(platformsAndOSes[platformMatchingDefinition]);
+
+        if (platformResult !== void 0) {
+          return platformResult;
+        }
+      }
+    }
+
+    if (browsersCounter > 0) {
+      const browserNames = Object.keys(browsers);
+      const matchingDefinition = Utils.find(browserNames, name => (this.isBrowser(name, true)));
+
+      if (matchingDefinition !== void 0) {
+        return this.compareVersion(browsers[matchingDefinition]);
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Check if the browser name equals the passed string
+   * @param browserName The string to compare with the browser name
+   * @param [includingAlias=false] The flag showing whether alias will be included into comparison
+   * @returns {boolean}
+   */
+  isBrowser(browserName, includingAlias = false) {
+    const defaultBrowserName = this.getBrowserName().toLowerCase();
+    let browserNameLower = browserName.toLowerCase();
+    const alias = Utils.getBrowserTypeByAlias(browserNameLower);
+
+    if (includingAlias && alias) {
+      browserNameLower = alias.toLowerCase();
+    }
+    return browserNameLower === defaultBrowserName;
+  }
+
+  compareVersion(version) {
+    let expectedResults = [0];
+    let comparableVersion = version;
+    let isLoose = false;
+
+    const currentBrowserVersion = this.getBrowserVersion();
+
+    if (typeof currentBrowserVersion !== 'string') {
+      return void 0;
+    }
+
+    if (version[0] === '>' || version[0] === '<') {
+      comparableVersion = version.substr(1);
+      if (version[1] === '=') {
+        isLoose = true;
+        comparableVersion = version.substr(2);
+      } else {
+        expectedResults = [];
+      }
+      if (version[0] === '>') {
+        expectedResults.push(1);
+      } else {
+        expectedResults.push(-1);
+      }
+    } else if (version[0] === '=') {
+      comparableVersion = version.substr(1);
+    } else if (version[0] === '~') {
+      isLoose = true;
+      comparableVersion = version.substr(1);
+    }
+
+    return expectedResults.indexOf(
+      Utils.compareVersions(currentBrowserVersion, comparableVersion, isLoose),
+    ) > -1;
+  }
+
+  isOS(osName) {
+    return this.getOSName(true) === String(osName).toLowerCase();
+  }
+
+  isPlatform(platformType) {
+    return this.getPlatformType(true) === String(platformType).toLowerCase();
+  }
+
+  isEngine(engineName) {
+    return this.getEngineName(true) === String(engineName).toLowerCase();
+  }
+
+  /**
+   * Is anything? Check if the browser is called "anything",
+   * the OS called "anything" or the platform called "anything"
+   * @param {String} anything
+   * @param [includingAlias=false] The flag showing whether alias will be included into comparison
+   * @returns {Boolean}
+   */
+  is(anything, includingAlias = false) {
+    return this.isBrowser(anything, includingAlias) || this.isOS(anything)
+      || this.isPlatform(anything);
+  }
+
+  /**
+   * Check if any of the given values satisfies this.is(anything)
+   * @param {String[]} anythings
+   * @returns {Boolean}
+   */
+  some(anythings = []) {
+    return anythings.some(anything => this.is(anything));
+  }
+}
+
+export default Parser;
diff --git a/parent_dir/node_modules/bowser/src/utils.js b/parent_dir/node_modules/bowser/src/utils.js
new file mode 100644
index 0000000..d1174bf
--- /dev/null
+++ b/parent_dir/node_modules/bowser/src/utils.js
@@ -0,0 +1,309 @@
+import { BROWSER_MAP, BROWSER_ALIASES_MAP } from './constants.js';
+
+export default class Utils {
+  /**
+   * Get first matched item for a string
+   * @param {RegExp} regexp
+   * @param {String} ua
+   * @return {Array|{index: number, input: string}|*|boolean|string}
+   */
+  static getFirstMatch(regexp, ua) {
+    const match = ua.match(regexp);
+    return (match && match.length > 0 && match[1]) || '';
+  }
+
+  /**
+   * Get second matched item for a string
+   * @param regexp
+   * @param {String} ua
+   * @return {Array|{index: number, input: string}|*|boolean|string}
+   */
+  static getSecondMatch(regexp, ua) {
+    const match = ua.match(regexp);
+    return (match && match.length > 1 && match[2]) || '';
+  }
+
+  /**
+   * Match a regexp and return a constant or undefined
+   * @param {RegExp} regexp
+   * @param {String} ua
+   * @param {*} _const Any const that will be returned if regexp matches the string
+   * @return {*}
+   */
+  static matchAndReturnConst(regexp, ua, _const) {
+    if (regexp.test(ua)) {
+      return _const;
+    }
+    return void (0);
+  }
+
+  static getWindowsVersionName(version) {
+    switch (version) {
+      case 'NT': return 'NT';
+      case 'XP': return 'XP';
+      case 'NT 5.0': return '2000';
+      case 'NT 5.1': return 'XP';
+      case 'NT 5.2': return '2003';
+      case 'NT 6.0': return 'Vista';
+      case 'NT 6.1': return '7';
+      case 'NT 6.2': return '8';
+      case 'NT 6.3': return '8.1';
+      case 'NT 10.0': return '10';
+      default: return undefined;
+    }
+  }
+
+  /**
+   * Get macOS version name
+   *    10.5 - Leopard
+   *    10.6 - Snow Leopard
+   *    10.7 - Lion
+   *    10.8 - Mountain Lion
+   *    10.9 - Mavericks
+   *    10.10 - Yosemite
+   *    10.11 - El Capitan
+   *    10.12 - Sierra
+   *    10.13 - High Sierra
+   *    10.14 - Mojave
+   *    10.15 - Catalina
+   *
+   * @example
+   *   getMacOSVersionName("10.14") // 'Mojave'
+   *
+   * @param  {string} version
+   * @return {string} versionName
+   */
+  static getMacOSVersionName(version) {
+    const v = version.split('.').splice(0, 2).map(s => parseInt(s, 10) || 0);
+    v.push(0);
+    if (v[0] !== 10) return undefined;
+    switch (v[1]) {
+      case 5: return 'Leopard';
+      case 6: return 'Snow Leopard';
+      case 7: return 'Lion';
+      case 8: return 'Mountain Lion';
+      case 9: return 'Mavericks';
+      case 10: return 'Yosemite';
+      case 11: return 'El Capitan';
+      case 12: return 'Sierra';
+      case 13: return 'High Sierra';
+      case 14: return 'Mojave';
+      case 15: return 'Catalina';
+      default: return undefined;
+    }
+  }
+
+  /**
+   * Get Android version name
+   *    1.5 - Cupcake
+   *    1.6 - Donut
+   *    2.0 - Eclair
+   *    2.1 - Eclair
+   *    2.2 - Froyo
+   *    2.x - Gingerbread
+   *    3.x - Honeycomb
+   *    4.0 - Ice Cream Sandwich
+   *    4.1 - Jelly Bean
+   *    4.4 - KitKat
+   *    5.x - Lollipop
+   *    6.x - Marshmallow
+   *    7.x - Nougat
+   *    8.x - Oreo
+   *    9.x - Pie
+   *
+   * @example
+   *   getAndroidVersionName("7.0") // 'Nougat'
+   *
+   * @param  {string} version
+   * @return {string} versionName
+   */
+  static getAndroidVersionName(version) {
+    const v = version.split('.').splice(0, 2).map(s => parseInt(s, 10) || 0);
+    v.push(0);
+    if (v[0] === 1 && v[1] < 5) return undefined;
+    if (v[0] === 1 && v[1] < 6) return 'Cupcake';
+    if (v[0] === 1 && v[1] >= 6) return 'Donut';
+    if (v[0] === 2 && v[1] < 2) return 'Eclair';
+    if (v[0] === 2 && v[1] === 2) return 'Froyo';
+    if (v[0] === 2 && v[1] > 2) return 'Gingerbread';
+    if (v[0] === 3) return 'Honeycomb';
+    if (v[0] === 4 && v[1] < 1) return 'Ice Cream Sandwich';
+    if (v[0] === 4 && v[1] < 4) return 'Jelly Bean';
+    if (v[0] === 4 && v[1] >= 4) return 'KitKat';
+    if (v[0] === 5) return 'Lollipop';
+    if (v[0] === 6) return 'Marshmallow';
+    if (v[0] === 7) return 'Nougat';
+    if (v[0] === 8) return 'Oreo';
+    if (v[0] === 9) return 'Pie';
+    return undefined;
+  }
+
+  /**
+   * Get version precisions count
+   *
+   * @example
+   *   getVersionPrecision("1.10.3") // 3
+   *
+   * @param  {string} version
+   * @return {number}
+   */
+  static getVersionPrecision(version) {
+    return version.split('.').length;
+  }
+
+  /**
+   * Calculate browser version weight
+   *
+   * @example
+   *   compareVersions('1.10.2.1',  '1.8.2.1.90')    // 1
+   *   compareVersions('1.010.2.1', '1.09.2.1.90');  // 1
+   *   compareVersions('1.10.2.1',  '1.10.2.1');     // 0
+   *   compareVersions('1.10.2.1',  '1.0800.2');     // -1
+   *   compareVersions('1.10.2.1',  '1.10',  true);  // 0
+   *
+   * @param {String} versionA versions versions to compare
+   * @param {String} versionB versions versions to compare
+   * @param {boolean} [isLoose] enable loose comparison
+   * @return {Number} comparison result: -1 when versionA is lower,
+   * 1 when versionA is bigger, 0 when both equal
+   */
+  /* eslint consistent-return: 1 */
+  static compareVersions(versionA, versionB, isLoose = false) {
+    // 1) get common precision for both versions, for example for "10.0" and "9" it should be 2
+    const versionAPrecision = Utils.getVersionPrecision(versionA);
+    const versionBPrecision = Utils.getVersionPrecision(versionB);
+
+    let precision = Math.max(versionAPrecision, versionBPrecision);
+    let lastPrecision = 0;
+
+    const chunks = Utils.map([versionA, versionB], (version) => {
+      const delta = precision - Utils.getVersionPrecision(version);
+
+      // 2) "9" -> "9.0" (for precision = 2)
+      const _version = version + new Array(delta + 1).join('.0');
+
+      // 3) "9.0" -> ["000000000"", "000000009"]
+      return Utils.map(_version.split('.'), chunk => new Array(20 - chunk.length).join('0') + chunk).reverse();
+    });
+
+    // adjust precision for loose comparison
+    if (isLoose) {
+      lastPrecision = precision - Math.min(versionAPrecision, versionBPrecision);
+    }
+
+    // iterate in reverse order by reversed chunks array
+    precision -= 1;
+    while (precision >= lastPrecision) {
+      // 4) compare: "000000009" > "000000010" = false (but "9" > "10" = true)
+      if (chunks[0][precision] > chunks[1][precision]) {
+        return 1;
+      }
+
+      if (chunks[0][precision] === chunks[1][precision]) {
+        if (precision === lastPrecision) {
+          // all version chunks are same
+          return 0;
+        }
+
+        precision -= 1;
+      } else if (chunks[0][precision] < chunks[1][precision]) {
+        return -1;
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Array::map polyfill
+   *
+   * @param  {Array} arr
+   * @param  {Function} iterator
+   * @return {Array}
+   */
+  static map(arr, iterator) {
+    const result = [];
+    let i;
+    if (Array.prototype.map) {
+      return Array.prototype.map.call(arr, iterator);
+    }
+    for (i = 0; i < arr.length; i += 1) {
+      result.push(iterator(arr[i]));
+    }
+    return result;
+  }
+
+  /**
+   * Array::find polyfill
+   *
+   * @param  {Array} arr
+   * @param  {Function} predicate
+   * @return {Array}
+   */
+  static find(arr, predicate) {
+    let i;
+    let l;
+    if (Array.prototype.find) {
+      return Array.prototype.find.call(arr, predicate);
+    }
+    for (i = 0, l = arr.length; i < l; i += 1) {
+      const value = arr[i];
+      if (predicate(value, i)) {
+        return value;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Object::assign polyfill
+   *
+   * @param  {Object} obj
+   * @param  {Object} ...objs
+   * @return {Object}
+   */
+  static assign(obj, ...assigners) {
+    const result = obj;
+    let i;
+    let l;
+    if (Object.assign) {
+      return Object.assign(obj, ...assigners);
+    }
+    for (i = 0, l = assigners.length; i < l; i += 1) {
+      const assigner = assigners[i];
+      if (typeof assigner === 'object' && assigner !== null) {
+        const keys = Object.keys(assigner);
+        keys.forEach((key) => {
+          result[key] = assigner[key];
+        });
+      }
+    }
+    return obj;
+  }
+
+  /**
+   * Get short version/alias for a browser name
+   *
+   * @example
+   *   getBrowserAlias('Microsoft Edge') // edge
+   *
+   * @param  {string} browserName
+   * @return {string}
+   */
+  static getBrowserAlias(browserName) {
+    return BROWSER_ALIASES_MAP[browserName];
+  }
+
+  /**
+   * Get short version/alias for a browser name
+   *
+   * @example
+   *   getBrowserAlias('edge') // Microsoft Edge
+   *
+   * @param  {string} browserAlias
+   * @return {string}
+   */
+  static getBrowserTypeByAlias(browserAlias) {
+    return BROWSER_MAP[browserAlias] || '';
+  }
+}
diff --git a/parent_dir/node_modules/brillout/json-serializer/dist/esm/parse.js b/parent_dir/node_modules/brillout/json-serializer/dist/esm/parse.js
new file mode 100644
index 0000000..9c9be60
--- /dev/null
+++ b/parent_dir/node_modules/brillout/json-serializer/dist/esm/parse.js
@@ -0,0 +1,27 @@
+export { parse };
+import { types } from './types';
+function parse(str) {
+    // We don't use the reviver option in `JSON.parse(str, reviver)` because it doesn't support `undefined` values
+    const value = JSON.parse(str);
+    return modifier(value);
+}
+function modifier(value) {
+    if (typeof value === 'string') {
+        return reviver(value);
+    }
+    if (typeof value === 'object' && value !== null) {
+        Object.entries(value).forEach(([key, val]) => {
+            ;
+            value[key] = modifier(val);
+        });
+    }
+    return value;
+}
+function reviver(value) {
+    for (const { match, deserialize } of types) {
+        if (match(value)) {
+            return deserialize(value, parse);
+        }
+    }
+    return value;
+}
diff --git a/parent_dir/node_modules/brillout/json-serializer/dist/esm/types.js b/parent_dir/node_modules/brillout/json-serializer/dist/esm/types.js
new file mode 100644
index 0000000..2c8f4b9
--- /dev/null
+++ b/parent_dir/node_modules/brillout/json-serializer/dist/esm/types.js
@@ -0,0 +1,80 @@
+export { types };
+const types = [
+    ts({
+        is: (val) => val === undefined,
+        match: (str) => str === '!undefined',
+        serialize: () => '!undefined',
+        deserialize: () => undefined
+    }),
+    ts({
+        is: (val) => val === Infinity,
+        match: (str) => str === '!Infinity',
+        serialize: () => '!Infinity',
+        deserialize: () => Infinity
+    }),
+    ts({
+        is: (val) => val === -Infinity,
+        match: (str) => str === '!-Infinity',
+        serialize: () => '!-Infinity',
+        deserialize: () => -Infinity
+    }),
+    ts({
+        is: (val) => typeof val === 'number' && isNaN(val),
+        match: (str) => str === '!NaN',
+        serialize: () => '!NaN',
+        deserialize: () => NaN
+    }),
+    ts({
+        is: (val) => val instanceof Date,
+        match: (str) => str.startsWith('!Date:'),
+        serialize: (val) => '!Date:' + val.toISOString(),
+        deserialize: (str) => new Date(str.slice('!Date:'.length))
+    }),
+    ts({
+        is: (val) => typeof val === 'bigint',
+        match: (str) => str.startsWith('!BigInt:'),
+        serialize: (val) => '!BigInt:' + val.toString(),
+        deserialize: (str) => {
+            if (typeof BigInt === 'undefined') {
+                throw new Error('Your JavaScript environement does not support BigInt. Consider adding a polyfill.');
+            }
+            return BigInt(str.slice('!BigInt:'.length));
+        }
+    }),
+    ts({
+        is: (val) => val instanceof RegExp,
+        match: (str) => str.startsWith('!RegExp:'),
+        serialize: (val) => '!RegExp:' + val.toString(),
+        deserialize: (str) => {
+            str = str.slice('!RegExp:'.length);
+            // const args: string[] = str.match(/\/(.*?)\/([gimy])?$/)!
+            const args = str.match(/\/(.*)\/(.*)?/);
+            const pattern = args[1];
+            const flags = args[2];
+            return new RegExp(pattern, flags);
+        }
+    }),
+    ts({
+        is: (val) => val instanceof Map,
+        match: (str) => str.startsWith('!Map:'),
+        serialize: (val, serializer) => '!Map:' + serializer(Array.from(val.entries())),
+        deserialize: (str, deserializer) => new Map(deserializer(str.slice('!Map:'.length)))
+    }),
+    ts({
+        is: (val) => val instanceof Set,
+        match: (str) => str.startsWith('!Set:'),
+        serialize: (val, serializer) => '!Set:' + serializer(Array.from(val.values())),
+        deserialize: (str, deserializer) => new Set(deserializer(str.slice('!Set:'.length)))
+    }),
+    // Avoid collisions with the special strings defined above
+    ts({
+        is: (val) => typeof val === 'string' && val.startsWith('!'),
+        match: (str) => str.startsWith('!'),
+        serialize: (val) => '!' + val,
+        deserialize: (str) => str.slice(1)
+    })
+];
+// Type check
+function ts(t) {
+    return t;
+}
diff --git a/parent_dir/node_modules/cdek-ui-kit/vue/dist/vue-ui-kit.es.js b/parent_dir/node_modules/cdek-ui-kit/vue/dist/vue-ui-kit.es.js
new file mode 100644
index 0000000..9e8b0d2
--- /dev/null
+++ b/parent_dir/node_modules/cdek-ui-kit/vue/dist/vue-ui-kit.es.js
@@ -0,0 +1,7181 @@
+var gg = Object.defineProperty;
+var mg = (r, o, i) => o in r ? gg(r, o, { enumerable: !0, configurable: !0, writable: !0, value: i }) : r[o] = i;
+var Ge = (r, o, i) => (mg(r, typeof o != "symbol" ? o + "" : o, i), i);
+import { openBlock as S, createElementBlock as R, createElementVNode as z, defineComponent as se, computed as B, normalizeClass as M, renderSlot as fe, createBlock as pe, resolveDynamicComponent as Xt, createTextVNode as lt, toDisplayString as we, normalizeStyle as Zs, createCommentVNode as ae, unref as ie, useSlots as cr, ref as oe, mergeProps as Qt, createVNode as ht, withDirectives as ci, vShow as zs, watch as Jt, onMounted as Dt, onBeforeUnmount as yg, createSlots as qs, renderList as pn, withCtx as ye, normalizeProps as fr, guardReactiveProps as fi, Transition as qa, Fragment as xt, createStaticVNode as bg, reactive as Ks, shallowRef as wg, watchEffect as di, cloneVNode as kg, h as lr, inject as hn, provide as Mn, onUnmounted as Ys, nextTick as Yt, toRaw as st, useCssVars as xg, withModifiers as Ka, toHandlers as $g, TransitionGroup as Ag, resolveComponent as Pa, createApp as Sg, getCurrentInstance as Tg } from "vue";
+const Cg = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "20",
+  height: "20",
+  fill: "none"
+}, Og = /* @__PURE__ */ z("path", {
+  stroke: "#F4A344",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "2",
+  d: "M10 7.5v1.667m0 3.333v.008m-5.833 3.325h11.666a1.667 1.667 0 0 0 1.534-2.291L11.45 3.333a1.666 1.666 0 0 0-2.917 0L2.617 13.542a1.666 1.666 0 0 0 1.458 2.291"
+}, null, -1), Eg = [
+  Og
+];
+function Ig(r, o) {
+  return S(), R("svg", Cg, Eg);
+}
+const Rg = { render: Ig }, Lg = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "20",
+  height: "20",
+  fill: "none"
+}, Mg = /* @__PURE__ */ z("path", {
+  stroke: "#17A000",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-opacity": ".7",
+  "stroke-width": "2",
+  d: "m4.167 10 4.167 4.167 8.333-8.334"
+}, null, -1), Bg = [
+  Mg
+];
+function Pg(r, o) {
+  return S(), R("svg", Lg, Bg);
+}
+const Dg = { render: Pg }, Fg = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "20",
+  height: "20",
+  fill: "none"
+}, Ng = /* @__PURE__ */ z("path", {
+  stroke: "#E40029",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-opacity": ".5",
+  "stroke-width": "2",
+  d: "m4.75 4.75 10.5 10.5M17.5 10a7.5 7.5 0 1 1-15 0 7.5 7.5 0 0 1 15 0Z"
+}, null, -1), Ug = [
+  Ng
+];
+function Wg(r, o) {
+  return S(), R("svg", Fg, Ug);
+}
+const Vg = { render: Wg }, Hg = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "20",
+  height: "20",
+  fill: "none"
+}, Gg = /* @__PURE__ */ z("path", {
+  stroke: "#4B3C87",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-opacity": ".5",
+  "stroke-width": "2",
+  d: "M10 6.667h.008M9.167 10H10v3.333h.833M17.5 10a7.5 7.5 0 1 1-15 0 7.5 7.5 0 0 1 15 0Z"
+}, null, -1), Zg = [
+  Gg
+];
+function zg(r, o) {
+  return S(), R("svg", Hg, Zg);
+}
+const qg = { render: zg }, Kg = /* @__PURE__ */ se({
+  __name: "BaseAlert",
+  props: {
+    title: {},
+    type: { default: "attention" },
+    style: { default: "surface" }
+  },
+  setup(r) {
+    const o = r, i = {
+      negative: Vg,
+      positive: Dg,
+      attention: Rg,
+      info: qg
+    }, c = B(() => i[o.type]);
+    return (a, p) => (S(), R("div", {
+      class: M([
+        a.$style["prefix-alert"],
+        a.$style[`prefix-alert--${a.type}`],
+        a.$style[`prefix-alert_${a.style}`]
+      ])
+    }, [
+      z("div", {
+        class: M(a.$style["prefix-alert__title"])
+      }, [
+        fe(a.$slots, "header", {}, () => [
+          (S(), pe(Xt(c.value))),
+          lt(" " + we(a.title), 1)
+        ], !0)
+      ], 2),
+      z("div", {
+        class: M(a.$style["prefix-alert__content"])
+      }, [
+        fe(a.$slots, "default", {}, void 0, !0)
+      ], 2)
+    ], 2));
+  }
+}), Yg = {
+  "prefix-alert": "cdek-alert",
+  "prefix-alert--attention": "cdek-alert--attention",
+  "prefix-alert--positive": "cdek-alert--positive",
+  "prefix-alert--negative": "cdek-alert--negative",
+  "prefix-alert--info": "cdek-alert--info",
+  "prefix-alert_surface": "cdek-alert_surface",
+  "prefix-alert_line": "cdek-alert_line",
+  "prefix-alert__title": "cdek-alert__title",
+  "prefix-alert__content": "cdek-alert__content"
+}, Ae = (r, o) => {
+  const i = r.__vccOpts || r;
+  for (const [c, a] of o)
+    i[c] = a;
+  return i;
+}, Xg = {
+  $style: Yg
+}, kw = /* @__PURE__ */ Ae(Kg, [["__cssModules", Xg], ["__scopeId", "data-v-6bd03bbf"]]);
+var ir = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, li = { exports: {} };
+/**
+ * @license
+ * Lodash <https://lodash.com/>
+ * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+li.exports;
+(function(r, o) {
+  (function() {
+    var i, c = "4.17.21", a = 200, p = "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.", y = "Expected a function", b = "Invalid `variable` option passed into `_.template`", T = "__lodash_hash_undefined__", g = 500, _ = "__lodash_placeholder__", C = 1, D = 2, Q = 4, ee = 1, O = 2, E = 1, W = 2, V = 4, F = 8, Z = 16, q = 32, ge = 64, Ee = 128, At = 256, Bn = 512, N = 30, Te = "...", vt = 800, St = 16, jt = 1, hi = 2, Su = 3, en = 1 / 0, Ft = 9007199254740991, Tu = 17976931348623157e292, pr = 0 / 0, gt = 4294967295, Cu = gt - 1, Ou = gt >>> 1, Eu = [
+      ["ary", Ee],
+      ["bind", E],
+      ["bindKey", W],
+      ["curry", F],
+      ["curryRight", Z],
+      ["flip", Bn],
+      ["partial", q],
+      ["partialRight", ge],
+      ["rearg", At]
+    ], vn = "[object Arguments]", hr = "[object Array]", Iu = "[object AsyncFunction]", Pn = "[object Boolean]", Dn = "[object Date]", Ru = "[object DOMException]", _r = "[object Error]", vr = "[object Function]", io = "[object GeneratorFunction]", at = "[object Map]", Fn = "[object Number]", Lu = "[object Null]", Tt = "[object Object]", so = "[object Promise]", Mu = "[object Proxy]", Nn = "[object RegExp]", ut = "[object Set]", Un = "[object String]", gr = "[object Symbol]", Bu = "[object Undefined]", Wn = "[object WeakMap]", Pu = "[object WeakSet]", Vn = "[object ArrayBuffer]", gn = "[object DataView]", _i = "[object Float32Array]", vi = "[object Float64Array]", gi = "[object Int8Array]", mi = "[object Int16Array]", yi = "[object Int32Array]", bi = "[object Uint8Array]", wi = "[object Uint8ClampedArray]", ki = "[object Uint16Array]", xi = "[object Uint32Array]", Du = /\b__p \+= '';/g, Fu = /\b(__p \+=) '' \+/g, Nu = /(__e\(.*?\)|\b__t\)) \+\n'';/g, oo = /&(?:amp|lt|gt|quot|#39);/g, lo = /[&<>"']/g, Uu = RegExp(oo.source), Wu = RegExp(lo.source), Vu = /<%-([\s\S]+?)%>/g, Hu = /<%([\s\S]+?)%>/g, ao = /<%=([\s\S]+?)%>/g, Gu = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, Zu = /^\w*$/, zu = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, $i = /[\\^$.*+?()[\]{}|]/g, qu = RegExp($i.source), Ai = /^\s+/, Ku = /\s/, Yu = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, Xu = /\{\n\/\* \[wrapped with (.+)\] \*/, Ju = /,? & /, Qu = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g, ju = /[()=,{}\[\]\/\s]/, ec = /\\(\\)?/g, tc = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g, uo = /\w*$/, nc = /^[-+]0x[0-9a-f]+$/i, rc = /^0b[01]+$/i, ic = /^\[object .+?Constructor\]$/, sc = /^0o[0-7]+$/i, oc = /^(?:0|[1-9]\d*)$/, lc = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g, mr = /($^)/, ac = /['\n\r\u2028\u2029\\]/g, yr = "\\ud800-\\udfff", uc = "\\u0300-\\u036f", cc = "\\ufe20-\\ufe2f", fc = "\\u20d0-\\u20ff", co = uc + cc + fc, fo = "\\u2700-\\u27bf", po = "a-z\\xdf-\\xf6\\xf8-\\xff", dc = "\\xac\\xb1\\xd7\\xf7", pc = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf", hc = "\\u2000-\\u206f", _c = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000", ho = "A-Z\\xc0-\\xd6\\xd8-\\xde", _o = "\\ufe0e\\ufe0f", vo = dc + pc + hc + _c, Si = "['’]", vc = "[" + yr + "]", go = "[" + vo + "]", br = "[" + co + "]", mo = "\\d+", gc = "[" + fo + "]", yo = "[" + po + "]", bo = "[^" + yr + vo + mo + fo + po + ho + "]", Ti = "\\ud83c[\\udffb-\\udfff]", mc = "(?:" + br + "|" + Ti + ")", wo = "[^" + yr + "]", Ci = "(?:\\ud83c[\\udde6-\\uddff]){2}", Oi = "[\\ud800-\\udbff][\\udc00-\\udfff]", mn = "[" + ho + "]", ko = "\\u200d", xo = "(?:" + yo + "|" + bo + ")", yc = "(?:" + mn + "|" + bo + ")", $o = "(?:" + Si + "(?:d|ll|m|re|s|t|ve))?", Ao = "(?:" + Si + "(?:D|LL|M|RE|S|T|VE))?", So = mc + "?", To = "[" + _o + "]?", bc = "(?:" + ko + "(?:" + [wo, Ci, Oi].join("|") + ")" + To + So + ")*", wc = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])", kc = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])", Co = To + So + bc, xc = "(?:" + [gc, Ci, Oi].join("|") + ")" + Co, $c = "(?:" + [wo + br + "?", br, Ci, Oi, vc].join("|") + ")", Ac = RegExp(Si, "g"), Sc = RegExp(br, "g"), Ei = RegExp(Ti + "(?=" + Ti + ")|" + $c + Co, "g"), Tc = RegExp([
+      mn + "?" + yo + "+" + $o + "(?=" + [go, mn, "$"].join("|") + ")",
+      yc + "+" + Ao + "(?=" + [go, mn + xo, "$"].join("|") + ")",
+      mn + "?" + xo + "+" + $o,
+      mn + "+" + Ao,
+      kc,
+      wc,
+      mo,
+      xc
+    ].join("|"), "g"), Cc = RegExp("[" + ko + yr + co + _o + "]"), Oc = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/, Ec = [
+      "Array",
+      "Buffer",
+      "DataView",
+      "Date",
+      "Error",
+      "Float32Array",
+      "Float64Array",
+      "Function",
+      "Int8Array",
+      "Int16Array",
+      "Int32Array",
+      "Map",
+      "Math",
+      "Object",
+      "Promise",
+      "RegExp",
+      "Set",
+      "String",
+      "Symbol",
+      "TypeError",
+      "Uint8Array",
+      "Uint8ClampedArray",
+      "Uint16Array",
+      "Uint32Array",
+      "WeakMap",
+      "_",
+      "clearTimeout",
+      "isFinite",
+      "parseInt",
+      "setTimeout"
+    ], Ic = -1, _e = {};
+    _e[_i] = _e[vi] = _e[gi] = _e[mi] = _e[yi] = _e[bi] = _e[wi] = _e[ki] = _e[xi] = !0, _e[vn] = _e[hr] = _e[Vn] = _e[Pn] = _e[gn] = _e[Dn] = _e[_r] = _e[vr] = _e[at] = _e[Fn] = _e[Tt] = _e[Nn] = _e[ut] = _e[Un] = _e[Wn] = !1;
+    var he = {};
+    he[vn] = he[hr] = he[Vn] = he[gn] = he[Pn] = he[Dn] = he[_i] = he[vi] = he[gi] = he[mi] = he[yi] = he[at] = he[Fn] = he[Tt] = he[Nn] = he[ut] = he[Un] = he[gr] = he[bi] = he[wi] = he[ki] = he[xi] = !0, he[_r] = he[vr] = he[Wn] = !1;
+    var Rc = {
+      // Latin-1 Supplement block.
+      À: "A",
+      Á: "A",
+      Â: "A",
+      Ã: "A",
+      Ä: "A",
+      Å: "A",
+      à: "a",
+      á: "a",
+      â: "a",
+      ã: "a",
+      ä: "a",
+      å: "a",
+      Ç: "C",
+      ç: "c",
+      Ð: "D",
+      ð: "d",
+      È: "E",
+      É: "E",
+      Ê: "E",
+      Ë: "E",
+      è: "e",
+      é: "e",
+      ê: "e",
+      ë: "e",
+      Ì: "I",
+      Í: "I",
+      Î: "I",
+      Ï: "I",
+      ì: "i",
+      í: "i",
+      î: "i",
+      ï: "i",
+      Ñ: "N",
+      ñ: "n",
+      Ò: "O",
+      Ó: "O",
+      Ô: "O",
+      Õ: "O",
+      Ö: "O",
+      Ø: "O",
+      ò: "o",
+      ó: "o",
+      ô: "o",
+      õ: "o",
+      ö: "o",
+      ø: "o",
+      Ù: "U",
+      Ú: "U",
+      Û: "U",
+      Ü: "U",
+      ù: "u",
+      ú: "u",
+      û: "u",
+      ü: "u",
+      Ý: "Y",
+      ý: "y",
+      ÿ: "y",
+      Æ: "Ae",
+      æ: "ae",
+      Þ: "Th",
+      þ: "th",
+      ß: "ss",
+      // Latin Extended-A block.
+      Ā: "A",
+      Ă: "A",
+      Ą: "A",
+      ā: "a",
+      ă: "a",
+      ą: "a",
+      Ć: "C",
+      Ĉ: "C",
+      Ċ: "C",
+      Č: "C",
+      ć: "c",
+      ĉ: "c",
+      ċ: "c",
+      č: "c",
+      Ď: "D",
+      Đ: "D",
+      ď: "d",
+      đ: "d",
+      Ē: "E",
+      Ĕ: "E",
+      Ė: "E",
+      Ę: "E",
+      Ě: "E",
+      ē: "e",
+      ĕ: "e",
+      ė: "e",
+      ę: "e",
+      ě: "e",
+      Ĝ: "G",
+      Ğ: "G",
+      Ġ: "G",
+      Ģ: "G",
+      ĝ: "g",
+      ğ: "g",
+      ġ: "g",
+      ģ: "g",
+      Ĥ: "H",
+      Ħ: "H",
+      ĥ: "h",
+      ħ: "h",
+      Ĩ: "I",
+      Ī: "I",
+      Ĭ: "I",
+      Į: "I",
+      İ: "I",
+      ĩ: "i",
+      ī: "i",
+      ĭ: "i",
+      į: "i",
+      ı: "i",
+      Ĵ: "J",
+      ĵ: "j",
+      Ķ: "K",
+      ķ: "k",
+      ĸ: "k",
+      Ĺ: "L",
+      Ļ: "L",
+      Ľ: "L",
+      Ŀ: "L",
+      Ł: "L",
+      ĺ: "l",
+      ļ: "l",
+      ľ: "l",
+      ŀ: "l",
+      ł: "l",
+      Ń: "N",
+      Ņ: "N",
+      Ň: "N",
+      Ŋ: "N",
+      ń: "n",
+      ņ: "n",
+      ň: "n",
+      ŋ: "n",
+      Ō: "O",
+      Ŏ: "O",
+      Ő: "O",
+      ō: "o",
+      ŏ: "o",
+      ő: "o",
+      Ŕ: "R",
+      Ŗ: "R",
+      Ř: "R",
+      ŕ: "r",
+      ŗ: "r",
+      ř: "r",
+      Ś: "S",
+      Ŝ: "S",
+      Ş: "S",
+      Š: "S",
+      ś: "s",
+      ŝ: "s",
+      ş: "s",
+      š: "s",
+      Ţ: "T",
+      Ť: "T",
+      Ŧ: "T",
+      ţ: "t",
+      ť: "t",
+      ŧ: "t",
+      Ũ: "U",
+      Ū: "U",
+      Ŭ: "U",
+      Ů: "U",
+      Ű: "U",
+      Ų: "U",
+      ũ: "u",
+      ū: "u",
+      ŭ: "u",
+      ů: "u",
+      ű: "u",
+      ų: "u",
+      Ŵ: "W",
+      ŵ: "w",
+      Ŷ: "Y",
+      ŷ: "y",
+      Ÿ: "Y",
+      Ź: "Z",
+      Ż: "Z",
+      Ž: "Z",
+      ź: "z",
+      ż: "z",
+      ž: "z",
+      IJ: "IJ",
+      ij: "ij",
+      Œ: "Oe",
+      œ: "oe",
+      ʼn: "'n",
+      ſ: "s"
+    }, Lc = {
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#39;"
+    }, Mc = {
+      "&amp;": "&",
+      "&lt;": "<",
+      "&gt;": ">",
+      "&quot;": '"',
+      "&#39;": "'"
+    }, Bc = {
+      "\\": "\\",
+      "'": "'",
+      "\n": "n",
+      "\r": "r",
+      "\u2028": "u2028",
+      "\u2029": "u2029"
+    }, Pc = parseFloat, Dc = parseInt, Oo = typeof ir == "object" && ir && ir.Object === Object && ir, Fc = typeof self == "object" && self && self.Object === Object && self, Re = Oo || Fc || Function("return this")(), Ii = o && !o.nodeType && o, tn = Ii && !0 && r && !r.nodeType && r, Eo = tn && tn.exports === Ii, Ri = Eo && Oo.process, Je = function() {
+      try {
+        var v = tn && tn.require && tn.require("util").types;
+        return v || Ri && Ri.binding && Ri.binding("util");
+      } catch {
+      }
+    }(), Io = Je && Je.isArrayBuffer, Ro = Je && Je.isDate, Lo = Je && Je.isMap, Mo = Je && Je.isRegExp, Bo = Je && Je.isSet, Po = Je && Je.isTypedArray;
+    function Ze(v, k, w) {
+      switch (w.length) {
+        case 0:
+          return v.call(k);
+        case 1:
+          return v.call(k, w[0]);
+        case 2:
+          return v.call(k, w[0], w[1]);
+        case 3:
+          return v.call(k, w[0], w[1], w[2]);
+      }
+      return v.apply(k, w);
+    }
+    function Nc(v, k, w, L) {
+      for (var K = -1, le = v == null ? 0 : v.length; ++K < le; ) {
+        var Ce = v[K];
+        k(L, Ce, w(Ce), v);
+      }
+      return L;
+    }
+    function Qe(v, k) {
+      for (var w = -1, L = v == null ? 0 : v.length; ++w < L && k(v[w], w, v) !== !1; )
+        ;
+      return v;
+    }
+    function Uc(v, k) {
+      for (var w = v == null ? 0 : v.length; w-- && k(v[w], w, v) !== !1; )
+        ;
+      return v;
+    }
+    function Do(v, k) {
+      for (var w = -1, L = v == null ? 0 : v.length; ++w < L; )
+        if (!k(v[w], w, v))
+          return !1;
+      return !0;
+    }
+    function Nt(v, k) {
+      for (var w = -1, L = v == null ? 0 : v.length, K = 0, le = []; ++w < L; ) {
+        var Ce = v[w];
+        k(Ce, w, v) && (le[K++] = Ce);
+      }
+      return le;
+    }
+    function wr(v, k) {
+      var w = v == null ? 0 : v.length;
+      return !!w && yn(v, k, 0) > -1;
+    }
+    function Li(v, k, w) {
+      for (var L = -1, K = v == null ? 0 : v.length; ++L < K; )
+        if (w(k, v[L]))
+          return !0;
+      return !1;
+    }
+    function ve(v, k) {
+      for (var w = -1, L = v == null ? 0 : v.length, K = Array(L); ++w < L; )
+        K[w] = k(v[w], w, v);
+      return K;
+    }
+    function Ut(v, k) {
+      for (var w = -1, L = k.length, K = v.length; ++w < L; )
+        v[K + w] = k[w];
+      return v;
+    }
+    function Mi(v, k, w, L) {
+      var K = -1, le = v == null ? 0 : v.length;
+      for (L && le && (w = v[++K]); ++K < le; )
+        w = k(w, v[K], K, v);
+      return w;
+    }
+    function Wc(v, k, w, L) {
+      var K = v == null ? 0 : v.length;
+      for (L && K && (w = v[--K]); K--; )
+        w = k(w, v[K], K, v);
+      return w;
+    }
+    function Bi(v, k) {
+      for (var w = -1, L = v == null ? 0 : v.length; ++w < L; )
+        if (k(v[w], w, v))
+          return !0;
+      return !1;
+    }
+    var Vc = Pi("length");
+    function Hc(v) {
+      return v.split("");
+    }
+    function Gc(v) {
+      return v.match(Qu) || [];
+    }
+    function Fo(v, k, w) {
+      var L;
+      return w(v, function(K, le, Ce) {
+        if (k(K, le, Ce))
+          return L = le, !1;
+      }), L;
+    }
+    function kr(v, k, w, L) {
+      for (var K = v.length, le = w + (L ? 1 : -1); L ? le-- : ++le < K; )
+        if (k(v[le], le, v))
+          return le;
+      return -1;
+    }
+    function yn(v, k, w) {
+      return k === k ? nf(v, k, w) : kr(v, No, w);
+    }
+    function Zc(v, k, w, L) {
+      for (var K = w - 1, le = v.length; ++K < le; )
+        if (L(v[K], k))
+          return K;
+      return -1;
+    }
+    function No(v) {
+      return v !== v;
+    }
+    function Uo(v, k) {
+      var w = v == null ? 0 : v.length;
+      return w ? Fi(v, k) / w : pr;
+    }
+    function Pi(v) {
+      return function(k) {
+        return k == null ? i : k[v];
+      };
+    }
+    function Di(v) {
+      return function(k) {
+        return v == null ? i : v[k];
+      };
+    }
+    function Wo(v, k, w, L, K) {
+      return K(v, function(le, Ce, de) {
+        w = L ? (L = !1, le) : k(w, le, Ce, de);
+      }), w;
+    }
+    function zc(v, k) {
+      var w = v.length;
+      for (v.sort(k); w--; )
+        v[w] = v[w].value;
+      return v;
+    }
+    function Fi(v, k) {
+      for (var w, L = -1, K = v.length; ++L < K; ) {
+        var le = k(v[L]);
+        le !== i && (w = w === i ? le : w + le);
+      }
+      return w;
+    }
+    function Ni(v, k) {
+      for (var w = -1, L = Array(v); ++w < v; )
+        L[w] = k(w);
+      return L;
+    }
+    function qc(v, k) {
+      return ve(k, function(w) {
+        return [w, v[w]];
+      });
+    }
+    function Vo(v) {
+      return v && v.slice(0, zo(v) + 1).replace(Ai, "");
+    }
+    function ze(v) {
+      return function(k) {
+        return v(k);
+      };
+    }
+    function Ui(v, k) {
+      return ve(k, function(w) {
+        return v[w];
+      });
+    }
+    function Hn(v, k) {
+      return v.has(k);
+    }
+    function Ho(v, k) {
+      for (var w = -1, L = v.length; ++w < L && yn(k, v[w], 0) > -1; )
+        ;
+      return w;
+    }
+    function Go(v, k) {
+      for (var w = v.length; w-- && yn(k, v[w], 0) > -1; )
+        ;
+      return w;
+    }
+    function Kc(v, k) {
+      for (var w = v.length, L = 0; w--; )
+        v[w] === k && ++L;
+      return L;
+    }
+    var Yc = Di(Rc), Xc = Di(Lc);
+    function Jc(v) {
+      return "\\" + Bc[v];
+    }
+    function Qc(v, k) {
+      return v == null ? i : v[k];
+    }
+    function bn(v) {
+      return Cc.test(v);
+    }
+    function jc(v) {
+      return Oc.test(v);
+    }
+    function ef(v) {
+      for (var k, w = []; !(k = v.next()).done; )
+        w.push(k.value);
+      return w;
+    }
+    function Wi(v) {
+      var k = -1, w = Array(v.size);
+      return v.forEach(function(L, K) {
+        w[++k] = [K, L];
+      }), w;
+    }
+    function Zo(v, k) {
+      return function(w) {
+        return v(k(w));
+      };
+    }
+    function Wt(v, k) {
+      for (var w = -1, L = v.length, K = 0, le = []; ++w < L; ) {
+        var Ce = v[w];
+        (Ce === k || Ce === _) && (v[w] = _, le[K++] = w);
+      }
+      return le;
+    }
+    function xr(v) {
+      var k = -1, w = Array(v.size);
+      return v.forEach(function(L) {
+        w[++k] = L;
+      }), w;
+    }
+    function tf(v) {
+      var k = -1, w = Array(v.size);
+      return v.forEach(function(L) {
+        w[++k] = [L, L];
+      }), w;
+    }
+    function nf(v, k, w) {
+      for (var L = w - 1, K = v.length; ++L < K; )
+        if (v[L] === k)
+          return L;
+      return -1;
+    }
+    function rf(v, k, w) {
+      for (var L = w + 1; L--; )
+        if (v[L] === k)
+          return L;
+      return L;
+    }
+    function wn(v) {
+      return bn(v) ? of(v) : Vc(v);
+    }
+    function ct(v) {
+      return bn(v) ? lf(v) : Hc(v);
+    }
+    function zo(v) {
+      for (var k = v.length; k-- && Ku.test(v.charAt(k)); )
+        ;
+      return k;
+    }
+    var sf = Di(Mc);
+    function of(v) {
+      for (var k = Ei.lastIndex = 0; Ei.test(v); )
+        ++k;
+      return k;
+    }
+    function lf(v) {
+      return v.match(Ei) || [];
+    }
+    function af(v) {
+      return v.match(Tc) || [];
+    }
+    var uf = function v(k) {
+      k = k == null ? Re : kn.defaults(Re.Object(), k, kn.pick(Re, Ec));
+      var w = k.Array, L = k.Date, K = k.Error, le = k.Function, Ce = k.Math, de = k.Object, Vi = k.RegExp, cf = k.String, je = k.TypeError, $r = w.prototype, ff = le.prototype, xn = de.prototype, Ar = k["__core-js_shared__"], Sr = ff.toString, ce = xn.hasOwnProperty, df = 0, qo = function() {
+        var e = /[^.]+$/.exec(Ar && Ar.keys && Ar.keys.IE_PROTO || "");
+        return e ? "Symbol(src)_1." + e : "";
+      }(), Tr = xn.toString, pf = Sr.call(de), hf = Re._, _f = Vi(
+        "^" + Sr.call(ce).replace($i, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+      ), Cr = Eo ? k.Buffer : i, Vt = k.Symbol, Or = k.Uint8Array, Ko = Cr ? Cr.allocUnsafe : i, Er = Zo(de.getPrototypeOf, de), Yo = de.create, Xo = xn.propertyIsEnumerable, Ir = $r.splice, Jo = Vt ? Vt.isConcatSpreadable : i, Gn = Vt ? Vt.iterator : i, nn = Vt ? Vt.toStringTag : i, Rr = function() {
+        try {
+          var e = an(de, "defineProperty");
+          return e({}, "", {}), e;
+        } catch {
+        }
+      }(), vf = k.clearTimeout !== Re.clearTimeout && k.clearTimeout, gf = L && L.now !== Re.Date.now && L.now, mf = k.setTimeout !== Re.setTimeout && k.setTimeout, Lr = Ce.ceil, Mr = Ce.floor, Hi = de.getOwnPropertySymbols, yf = Cr ? Cr.isBuffer : i, Qo = k.isFinite, bf = $r.join, wf = Zo(de.keys, de), Oe = Ce.max, Me = Ce.min, kf = L.now, xf = k.parseInt, jo = Ce.random, $f = $r.reverse, Gi = an(k, "DataView"), Zn = an(k, "Map"), Zi = an(k, "Promise"), $n = an(k, "Set"), zn = an(k, "WeakMap"), qn = an(de, "create"), Br = zn && new zn(), An = {}, Af = un(Gi), Sf = un(Zn), Tf = un(Zi), Cf = un($n), Of = un(zn), Pr = Vt ? Vt.prototype : i, Kn = Pr ? Pr.valueOf : i, el = Pr ? Pr.toString : i;
+      function u(e) {
+        if (ke(e) && !Y(e) && !(e instanceof ne)) {
+          if (e instanceof et)
+            return e;
+          if (ce.call(e, "__wrapped__"))
+            return ta(e);
+        }
+        return new et(e);
+      }
+      var Sn = function() {
+        function e() {
+        }
+        return function(t) {
+          if (!me(t))
+            return {};
+          if (Yo)
+            return Yo(t);
+          e.prototype = t;
+          var n = new e();
+          return e.prototype = i, n;
+        };
+      }();
+      function Dr() {
+      }
+      function et(e, t) {
+        this.__wrapped__ = e, this.__actions__ = [], this.__chain__ = !!t, this.__index__ = 0, this.__values__ = i;
+      }
+      u.templateSettings = {
+        /**
+         * Used to detect `data` property values to be HTML-escaped.
+         *
+         * @memberOf _.templateSettings
+         * @type {RegExp}
+         */
+        escape: Vu,
+        /**
+         * Used to detect code to be evaluated.
+         *
+         * @memberOf _.templateSettings
+         * @type {RegExp}
+         */
+        evaluate: Hu,
+        /**
+         * Used to detect `data` property values to inject.
+         *
+         * @memberOf _.templateSettings
+         * @type {RegExp}
+         */
+        interpolate: ao,
+        /**
+         * Used to reference the data object in the template text.
+         *
+         * @memberOf _.templateSettings
+         * @type {string}
+         */
+        variable: "",
+        /**
+         * Used to import variables into the compiled template.
+         *
+         * @memberOf _.templateSettings
+         * @type {Object}
+         */
+        imports: {
+          /**
+           * A reference to the `lodash` function.
+           *
+           * @memberOf _.templateSettings.imports
+           * @type {Function}
+           */
+          _: u
+        }
+      }, u.prototype = Dr.prototype, u.prototype.constructor = u, et.prototype = Sn(Dr.prototype), et.prototype.constructor = et;
+      function ne(e) {
+        this.__wrapped__ = e, this.__actions__ = [], this.__dir__ = 1, this.__filtered__ = !1, this.__iteratees__ = [], this.__takeCount__ = gt, this.__views__ = [];
+      }
+      function Ef() {
+        var e = new ne(this.__wrapped__);
+        return e.__actions__ = Ue(this.__actions__), e.__dir__ = this.__dir__, e.__filtered__ = this.__filtered__, e.__iteratees__ = Ue(this.__iteratees__), e.__takeCount__ = this.__takeCount__, e.__views__ = Ue(this.__views__), e;
+      }
+      function If() {
+        if (this.__filtered__) {
+          var e = new ne(this);
+          e.__dir__ = -1, e.__filtered__ = !0;
+        } else
+          e = this.clone(), e.__dir__ *= -1;
+        return e;
+      }
+      function Rf() {
+        var e = this.__wrapped__.value(), t = this.__dir__, n = Y(e), s = t < 0, l = n ? e.length : 0, f = Gd(0, l, this.__views__), d = f.start, h = f.end, m = h - d, x = s ? h : d - 1, $ = this.__iteratees__, A = $.length, I = 0, P = Me(m, this.__takeCount__);
+        if (!n || !s && l == m && P == m)
+          return $l(e, this.__actions__);
+        var H = [];
+        e:
+          for (; m-- && I < P; ) {
+            x += t;
+            for (var J = -1, G = e[x]; ++J < A; ) {
+              var te = $[J], re = te.iteratee, Ye = te.type, Fe = re(G);
+              if (Ye == hi)
+                G = Fe;
+              else if (!Fe) {
+                if (Ye == jt)
+                  continue e;
+                break e;
+              }
+            }
+            H[I++] = G;
+          }
+        return H;
+      }
+      ne.prototype = Sn(Dr.prototype), ne.prototype.constructor = ne;
+      function rn(e) {
+        var t = -1, n = e == null ? 0 : e.length;
+        for (this.clear(); ++t < n; ) {
+          var s = e[t];
+          this.set(s[0], s[1]);
+        }
+      }
+      function Lf() {
+        this.__data__ = qn ? qn(null) : {}, this.size = 0;
+      }
+      function Mf(e) {
+        var t = this.has(e) && delete this.__data__[e];
+        return this.size -= t ? 1 : 0, t;
+      }
+      function Bf(e) {
+        var t = this.__data__;
+        if (qn) {
+          var n = t[e];
+          return n === T ? i : n;
+        }
+        return ce.call(t, e) ? t[e] : i;
+      }
+      function Pf(e) {
+        var t = this.__data__;
+        return qn ? t[e] !== i : ce.call(t, e);
+      }
+      function Df(e, t) {
+        var n = this.__data__;
+        return this.size += this.has(e) ? 0 : 1, n[e] = qn && t === i ? T : t, this;
+      }
+      rn.prototype.clear = Lf, rn.prototype.delete = Mf, rn.prototype.get = Bf, rn.prototype.has = Pf, rn.prototype.set = Df;
+      function Ct(e) {
+        var t = -1, n = e == null ? 0 : e.length;
+        for (this.clear(); ++t < n; ) {
+          var s = e[t];
+          this.set(s[0], s[1]);
+        }
+      }
+      function Ff() {
+        this.__data__ = [], this.size = 0;
+      }
+      function Nf(e) {
+        var t = this.__data__, n = Fr(t, e);
+        if (n < 0)
+          return !1;
+        var s = t.length - 1;
+        return n == s ? t.pop() : Ir.call(t, n, 1), --this.size, !0;
+      }
+      function Uf(e) {
+        var t = this.__data__, n = Fr(t, e);
+        return n < 0 ? i : t[n][1];
+      }
+      function Wf(e) {
+        return Fr(this.__data__, e) > -1;
+      }
+      function Vf(e, t) {
+        var n = this.__data__, s = Fr(n, e);
+        return s < 0 ? (++this.size, n.push([e, t])) : n[s][1] = t, this;
+      }
+      Ct.prototype.clear = Ff, Ct.prototype.delete = Nf, Ct.prototype.get = Uf, Ct.prototype.has = Wf, Ct.prototype.set = Vf;
+      function Ot(e) {
+        var t = -1, n = e == null ? 0 : e.length;
+        for (this.clear(); ++t < n; ) {
+          var s = e[t];
+          this.set(s[0], s[1]);
+        }
+      }
+      function Hf() {
+        this.size = 0, this.__data__ = {
+          hash: new rn(),
+          map: new (Zn || Ct)(),
+          string: new rn()
+        };
+      }
+      function Gf(e) {
+        var t = Xr(this, e).delete(e);
+        return this.size -= t ? 1 : 0, t;
+      }
+      function Zf(e) {
+        return Xr(this, e).get(e);
+      }
+      function zf(e) {
+        return Xr(this, e).has(e);
+      }
+      function qf(e, t) {
+        var n = Xr(this, e), s = n.size;
+        return n.set(e, t), this.size += n.size == s ? 0 : 1, this;
+      }
+      Ot.prototype.clear = Hf, Ot.prototype.delete = Gf, Ot.prototype.get = Zf, Ot.prototype.has = zf, Ot.prototype.set = qf;
+      function sn(e) {
+        var t = -1, n = e == null ? 0 : e.length;
+        for (this.__data__ = new Ot(); ++t < n; )
+          this.add(e[t]);
+      }
+      function Kf(e) {
+        return this.__data__.set(e, T), this;
+      }
+      function Yf(e) {
+        return this.__data__.has(e);
+      }
+      sn.prototype.add = sn.prototype.push = Kf, sn.prototype.has = Yf;
+      function ft(e) {
+        var t = this.__data__ = new Ct(e);
+        this.size = t.size;
+      }
+      function Xf() {
+        this.__data__ = new Ct(), this.size = 0;
+      }
+      function Jf(e) {
+        var t = this.__data__, n = t.delete(e);
+        return this.size = t.size, n;
+      }
+      function Qf(e) {
+        return this.__data__.get(e);
+      }
+      function jf(e) {
+        return this.__data__.has(e);
+      }
+      function ed(e, t) {
+        var n = this.__data__;
+        if (n instanceof Ct) {
+          var s = n.__data__;
+          if (!Zn || s.length < a - 1)
+            return s.push([e, t]), this.size = ++n.size, this;
+          n = this.__data__ = new Ot(s);
+        }
+        return n.set(e, t), this.size = n.size, this;
+      }
+      ft.prototype.clear = Xf, ft.prototype.delete = Jf, ft.prototype.get = Qf, ft.prototype.has = jf, ft.prototype.set = ed;
+      function tl(e, t) {
+        var n = Y(e), s = !n && cn(e), l = !n && !s && qt(e), f = !n && !s && !l && En(e), d = n || s || l || f, h = d ? Ni(e.length, cf) : [], m = h.length;
+        for (var x in e)
+          (t || ce.call(e, x)) && !(d && // Safari 9 has enumerable `arguments.length` in strict mode.
+          (x == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+          l && (x == "offset" || x == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+          f && (x == "buffer" || x == "byteLength" || x == "byteOffset") || // Skip index properties.
+          Lt(x, m))) && h.push(x);
+        return h;
+      }
+      function nl(e) {
+        var t = e.length;
+        return t ? e[ns(0, t - 1)] : i;
+      }
+      function td(e, t) {
+        return Jr(Ue(e), on(t, 0, e.length));
+      }
+      function nd(e) {
+        return Jr(Ue(e));
+      }
+      function zi(e, t, n) {
+        (n !== i && !dt(e[t], n) || n === i && !(t in e)) && Et(e, t, n);
+      }
+      function Yn(e, t, n) {
+        var s = e[t];
+        (!(ce.call(e, t) && dt(s, n)) || n === i && !(t in e)) && Et(e, t, n);
+      }
+      function Fr(e, t) {
+        for (var n = e.length; n--; )
+          if (dt(e[n][0], t))
+            return n;
+        return -1;
+      }
+      function rd(e, t, n, s) {
+        return Ht(e, function(l, f, d) {
+          t(s, l, n(l), d);
+        }), s;
+      }
+      function rl(e, t) {
+        return e && yt(t, Ie(t), e);
+      }
+      function id(e, t) {
+        return e && yt(t, Ve(t), e);
+      }
+      function Et(e, t, n) {
+        t == "__proto__" && Rr ? Rr(e, t, {
+          configurable: !0,
+          enumerable: !0,
+          value: n,
+          writable: !0
+        }) : e[t] = n;
+      }
+      function qi(e, t) {
+        for (var n = -1, s = t.length, l = w(s), f = e == null; ++n < s; )
+          l[n] = f ? i : Ts(e, t[n]);
+        return l;
+      }
+      function on(e, t, n) {
+        return e === e && (n !== i && (e = e <= n ? e : n), t !== i && (e = e >= t ? e : t)), e;
+      }
+      function tt(e, t, n, s, l, f) {
+        var d, h = t & C, m = t & D, x = t & Q;
+        if (n && (d = l ? n(e, s, l, f) : n(e)), d !== i)
+          return d;
+        if (!me(e))
+          return e;
+        var $ = Y(e);
+        if ($) {
+          if (d = zd(e), !h)
+            return Ue(e, d);
+        } else {
+          var A = Be(e), I = A == vr || A == io;
+          if (qt(e))
+            return Tl(e, h);
+          if (A == Tt || A == vn || I && !l) {
+            if (d = m || I ? {} : zl(e), !h)
+              return m ? Bd(e, id(d, e)) : Md(e, rl(d, e));
+          } else {
+            if (!he[A])
+              return l ? e : {};
+            d = qd(e, A, h);
+          }
+        }
+        f || (f = new ft());
+        var P = f.get(e);
+        if (P)
+          return P;
+        f.set(e, d), wa(e) ? e.forEach(function(G) {
+          d.add(tt(G, t, n, G, e, f));
+        }) : ya(e) && e.forEach(function(G, te) {
+          d.set(te, tt(G, t, n, te, e, f));
+        });
+        var H = x ? m ? ps : ds : m ? Ve : Ie, J = $ ? i : H(e);
+        return Qe(J || e, function(G, te) {
+          J && (te = G, G = e[te]), Yn(d, te, tt(G, t, n, te, e, f));
+        }), d;
+      }
+      function sd(e) {
+        var t = Ie(e);
+        return function(n) {
+          return il(n, e, t);
+        };
+      }
+      function il(e, t, n) {
+        var s = n.length;
+        if (e == null)
+          return !s;
+        for (e = de(e); s--; ) {
+          var l = n[s], f = t[l], d = e[l];
+          if (d === i && !(l in e) || !f(d))
+            return !1;
+        }
+        return !0;
+      }
+      function sl(e, t, n) {
+        if (typeof e != "function")
+          throw new je(y);
+        return nr(function() {
+          e.apply(i, n);
+        }, t);
+      }
+      function Xn(e, t, n, s) {
+        var l = -1, f = wr, d = !0, h = e.length, m = [], x = t.length;
+        if (!h)
+          return m;
+        n && (t = ve(t, ze(n))), s ? (f = Li, d = !1) : t.length >= a && (f = Hn, d = !1, t = new sn(t));
+        e:
+          for (; ++l < h; ) {
+            var $ = e[l], A = n == null ? $ : n($);
+            if ($ = s || $ !== 0 ? $ : 0, d && A === A) {
+              for (var I = x; I--; )
+                if (t[I] === A)
+                  continue e;
+              m.push($);
+            } else
+              f(t, A, s) || m.push($);
+          }
+        return m;
+      }
+      var Ht = Rl(mt), ol = Rl(Yi, !0);
+      function od(e, t) {
+        var n = !0;
+        return Ht(e, function(s, l, f) {
+          return n = !!t(s, l, f), n;
+        }), n;
+      }
+      function Nr(e, t, n) {
+        for (var s = -1, l = e.length; ++s < l; ) {
+          var f = e[s], d = t(f);
+          if (d != null && (h === i ? d === d && !Ke(d) : n(d, h)))
+            var h = d, m = f;
+        }
+        return m;
+      }
+      function ld(e, t, n, s) {
+        var l = e.length;
+        for (n = X(n), n < 0 && (n = -n > l ? 0 : l + n), s = s === i || s > l ? l : X(s), s < 0 && (s += l), s = n > s ? 0 : xa(s); n < s; )
+          e[n++] = t;
+        return e;
+      }
+      function ll(e, t) {
+        var n = [];
+        return Ht(e, function(s, l, f) {
+          t(s, l, f) && n.push(s);
+        }), n;
+      }
+      function Le(e, t, n, s, l) {
+        var f = -1, d = e.length;
+        for (n || (n = Yd), l || (l = []); ++f < d; ) {
+          var h = e[f];
+          t > 0 && n(h) ? t > 1 ? Le(h, t - 1, n, s, l) : Ut(l, h) : s || (l[l.length] = h);
+        }
+        return l;
+      }
+      var Ki = Ll(), al = Ll(!0);
+      function mt(e, t) {
+        return e && Ki(e, t, Ie);
+      }
+      function Yi(e, t) {
+        return e && al(e, t, Ie);
+      }
+      function Ur(e, t) {
+        return Nt(t, function(n) {
+          return Mt(e[n]);
+        });
+      }
+      function ln(e, t) {
+        t = Zt(t, e);
+        for (var n = 0, s = t.length; e != null && n < s; )
+          e = e[bt(t[n++])];
+        return n && n == s ? e : i;
+      }
+      function ul(e, t, n) {
+        var s = t(e);
+        return Y(e) ? s : Ut(s, n(e));
+      }
+      function Pe(e) {
+        return e == null ? e === i ? Bu : Lu : nn && nn in de(e) ? Hd(e) : np(e);
+      }
+      function Xi(e, t) {
+        return e > t;
+      }
+      function ad(e, t) {
+        return e != null && ce.call(e, t);
+      }
+      function ud(e, t) {
+        return e != null && t in de(e);
+      }
+      function cd(e, t, n) {
+        return e >= Me(t, n) && e < Oe(t, n);
+      }
+      function Ji(e, t, n) {
+        for (var s = n ? Li : wr, l = e[0].length, f = e.length, d = f, h = w(f), m = 1 / 0, x = []; d--; ) {
+          var $ = e[d];
+          d && t && ($ = ve($, ze(t))), m = Me($.length, m), h[d] = !n && (t || l >= 120 && $.length >= 120) ? new sn(d && $) : i;
+        }
+        $ = e[0];
+        var A = -1, I = h[0];
+        e:
+          for (; ++A < l && x.length < m; ) {
+            var P = $[A], H = t ? t(P) : P;
+            if (P = n || P !== 0 ? P : 0, !(I ? Hn(I, H) : s(x, H, n))) {
+              for (d = f; --d; ) {
+                var J = h[d];
+                if (!(J ? Hn(J, H) : s(e[d], H, n)))
+                  continue e;
+              }
+              I && I.push(H), x.push(P);
+            }
+          }
+        return x;
+      }
+      function fd(e, t, n, s) {
+        return mt(e, function(l, f, d) {
+          t(s, n(l), f, d);
+        }), s;
+      }
+      function Jn(e, t, n) {
+        t = Zt(t, e), e = Xl(e, t);
+        var s = e == null ? e : e[bt(rt(t))];
+        return s == null ? i : Ze(s, e, n);
+      }
+      function cl(e) {
+        return ke(e) && Pe(e) == vn;
+      }
+      function dd(e) {
+        return ke(e) && Pe(e) == Vn;
+      }
+      function pd(e) {
+        return ke(e) && Pe(e) == Dn;
+      }
+      function Qn(e, t, n, s, l) {
+        return e === t ? !0 : e == null || t == null || !ke(e) && !ke(t) ? e !== e && t !== t : hd(e, t, n, s, Qn, l);
+      }
+      function hd(e, t, n, s, l, f) {
+        var d = Y(e), h = Y(t), m = d ? hr : Be(e), x = h ? hr : Be(t);
+        m = m == vn ? Tt : m, x = x == vn ? Tt : x;
+        var $ = m == Tt, A = x == Tt, I = m == x;
+        if (I && qt(e)) {
+          if (!qt(t))
+            return !1;
+          d = !0, $ = !1;
+        }
+        if (I && !$)
+          return f || (f = new ft()), d || En(e) ? Hl(e, t, n, s, l, f) : Wd(e, t, m, n, s, l, f);
+        if (!(n & ee)) {
+          var P = $ && ce.call(e, "__wrapped__"), H = A && ce.call(t, "__wrapped__");
+          if (P || H) {
+            var J = P ? e.value() : e, G = H ? t.value() : t;
+            return f || (f = new ft()), l(J, G, n, s, f);
+          }
+        }
+        return I ? (f || (f = new ft()), Vd(e, t, n, s, l, f)) : !1;
+      }
+      function _d(e) {
+        return ke(e) && Be(e) == at;
+      }
+      function Qi(e, t, n, s) {
+        var l = n.length, f = l, d = !s;
+        if (e == null)
+          return !f;
+        for (e = de(e); l--; ) {
+          var h = n[l];
+          if (d && h[2] ? h[1] !== e[h[0]] : !(h[0] in e))
+            return !1;
+        }
+        for (; ++l < f; ) {
+          h = n[l];
+          var m = h[0], x = e[m], $ = h[1];
+          if (d && h[2]) {
+            if (x === i && !(m in e))
+              return !1;
+          } else {
+            var A = new ft();
+            if (s)
+              var I = s(x, $, m, e, t, A);
+            if (!(I === i ? Qn($, x, ee | O, s, A) : I))
+              return !1;
+          }
+        }
+        return !0;
+      }
+      function fl(e) {
+        if (!me(e) || Jd(e))
+          return !1;
+        var t = Mt(e) ? _f : ic;
+        return t.test(un(e));
+      }
+      function vd(e) {
+        return ke(e) && Pe(e) == Nn;
+      }
+      function gd(e) {
+        return ke(e) && Be(e) == ut;
+      }
+      function md(e) {
+        return ke(e) && ri(e.length) && !!_e[Pe(e)];
+      }
+      function dl(e) {
+        return typeof e == "function" ? e : e == null ? He : typeof e == "object" ? Y(e) ? _l(e[0], e[1]) : hl(e) : Ma(e);
+      }
+      function ji(e) {
+        if (!tr(e))
+          return wf(e);
+        var t = [];
+        for (var n in de(e))
+          ce.call(e, n) && n != "constructor" && t.push(n);
+        return t;
+      }
+      function yd(e) {
+        if (!me(e))
+          return tp(e);
+        var t = tr(e), n = [];
+        for (var s in e)
+          s == "constructor" && (t || !ce.call(e, s)) || n.push(s);
+        return n;
+      }
+      function es(e, t) {
+        return e < t;
+      }
+      function pl(e, t) {
+        var n = -1, s = We(e) ? w(e.length) : [];
+        return Ht(e, function(l, f, d) {
+          s[++n] = t(l, f, d);
+        }), s;
+      }
+      function hl(e) {
+        var t = _s(e);
+        return t.length == 1 && t[0][2] ? Kl(t[0][0], t[0][1]) : function(n) {
+          return n === e || Qi(n, e, t);
+        };
+      }
+      function _l(e, t) {
+        return gs(e) && ql(t) ? Kl(bt(e), t) : function(n) {
+          var s = Ts(n, e);
+          return s === i && s === t ? Cs(n, e) : Qn(t, s, ee | O);
+        };
+      }
+      function Wr(e, t, n, s, l) {
+        e !== t && Ki(t, function(f, d) {
+          if (l || (l = new ft()), me(f))
+            bd(e, t, d, n, Wr, s, l);
+          else {
+            var h = s ? s(ys(e, d), f, d + "", e, t, l) : i;
+            h === i && (h = f), zi(e, d, h);
+          }
+        }, Ve);
+      }
+      function bd(e, t, n, s, l, f, d) {
+        var h = ys(e, n), m = ys(t, n), x = d.get(m);
+        if (x) {
+          zi(e, n, x);
+          return;
+        }
+        var $ = f ? f(h, m, n + "", e, t, d) : i, A = $ === i;
+        if (A) {
+          var I = Y(m), P = !I && qt(m), H = !I && !P && En(m);
+          $ = m, I || P || H ? Y(h) ? $ = h : xe(h) ? $ = Ue(h) : P ? (A = !1, $ = Tl(m, !0)) : H ? (A = !1, $ = Cl(m, !0)) : $ = [] : rr(m) || cn(m) ? ($ = h, cn(h) ? $ = $a(h) : (!me(h) || Mt(h)) && ($ = zl(m))) : A = !1;
+        }
+        A && (d.set(m, $), l($, m, s, f, d), d.delete(m)), zi(e, n, $);
+      }
+      function vl(e, t) {
+        var n = e.length;
+        if (n)
+          return t += t < 0 ? n : 0, Lt(t, n) ? e[t] : i;
+      }
+      function gl(e, t, n) {
+        t.length ? t = ve(t, function(f) {
+          return Y(f) ? function(d) {
+            return ln(d, f.length === 1 ? f[0] : f);
+          } : f;
+        }) : t = [He];
+        var s = -1;
+        t = ve(t, ze(U()));
+        var l = pl(e, function(f, d, h) {
+          var m = ve(t, function(x) {
+            return x(f);
+          });
+          return { criteria: m, index: ++s, value: f };
+        });
+        return zc(l, function(f, d) {
+          return Ld(f, d, n);
+        });
+      }
+      function wd(e, t) {
+        return ml(e, t, function(n, s) {
+          return Cs(e, s);
+        });
+      }
+      function ml(e, t, n) {
+        for (var s = -1, l = t.length, f = {}; ++s < l; ) {
+          var d = t[s], h = ln(e, d);
+          n(h, d) && jn(f, Zt(d, e), h);
+        }
+        return f;
+      }
+      function kd(e) {
+        return function(t) {
+          return ln(t, e);
+        };
+      }
+      function ts(e, t, n, s) {
+        var l = s ? Zc : yn, f = -1, d = t.length, h = e;
+        for (e === t && (t = Ue(t)), n && (h = ve(e, ze(n))); ++f < d; )
+          for (var m = 0, x = t[f], $ = n ? n(x) : x; (m = l(h, $, m, s)) > -1; )
+            h !== e && Ir.call(h, m, 1), Ir.call(e, m, 1);
+        return e;
+      }
+      function yl(e, t) {
+        for (var n = e ? t.length : 0, s = n - 1; n--; ) {
+          var l = t[n];
+          if (n == s || l !== f) {
+            var f = l;
+            Lt(l) ? Ir.call(e, l, 1) : ss(e, l);
+          }
+        }
+        return e;
+      }
+      function ns(e, t) {
+        return e + Mr(jo() * (t - e + 1));
+      }
+      function xd(e, t, n, s) {
+        for (var l = -1, f = Oe(Lr((t - e) / (n || 1)), 0), d = w(f); f--; )
+          d[s ? f : ++l] = e, e += n;
+        return d;
+      }
+      function rs(e, t) {
+        var n = "";
+        if (!e || t < 1 || t > Ft)
+          return n;
+        do
+          t % 2 && (n += e), t = Mr(t / 2), t && (e += e);
+        while (t);
+        return n;
+      }
+      function j(e, t) {
+        return bs(Yl(e, t, He), e + "");
+      }
+      function $d(e) {
+        return nl(In(e));
+      }
+      function Ad(e, t) {
+        var n = In(e);
+        return Jr(n, on(t, 0, n.length));
+      }
+      function jn(e, t, n, s) {
+        if (!me(e))
+          return e;
+        t = Zt(t, e);
+        for (var l = -1, f = t.length, d = f - 1, h = e; h != null && ++l < f; ) {
+          var m = bt(t[l]), x = n;
+          if (m === "__proto__" || m === "constructor" || m === "prototype")
+            return e;
+          if (l != d) {
+            var $ = h[m];
+            x = s ? s($, m, h) : i, x === i && (x = me($) ? $ : Lt(t[l + 1]) ? [] : {});
+          }
+          Yn(h, m, x), h = h[m];
+        }
+        return e;
+      }
+      var bl = Br ? function(e, t) {
+        return Br.set(e, t), e;
+      } : He, Sd = Rr ? function(e, t) {
+        return Rr(e, "toString", {
+          configurable: !0,
+          enumerable: !1,
+          value: Es(t),
+          writable: !0
+        });
+      } : He;
+      function Td(e) {
+        return Jr(In(e));
+      }
+      function nt(e, t, n) {
+        var s = -1, l = e.length;
+        t < 0 && (t = -t > l ? 0 : l + t), n = n > l ? l : n, n < 0 && (n += l), l = t > n ? 0 : n - t >>> 0, t >>>= 0;
+        for (var f = w(l); ++s < l; )
+          f[s] = e[s + t];
+        return f;
+      }
+      function Cd(e, t) {
+        var n;
+        return Ht(e, function(s, l, f) {
+          return n = t(s, l, f), !n;
+        }), !!n;
+      }
+      function Vr(e, t, n) {
+        var s = 0, l = e == null ? s : e.length;
+        if (typeof t == "number" && t === t && l <= Ou) {
+          for (; s < l; ) {
+            var f = s + l >>> 1, d = e[f];
+            d !== null && !Ke(d) && (n ? d <= t : d < t) ? s = f + 1 : l = f;
+          }
+          return l;
+        }
+        return is(e, t, He, n);
+      }
+      function is(e, t, n, s) {
+        var l = 0, f = e == null ? 0 : e.length;
+        if (f === 0)
+          return 0;
+        t = n(t);
+        for (var d = t !== t, h = t === null, m = Ke(t), x = t === i; l < f; ) {
+          var $ = Mr((l + f) / 2), A = n(e[$]), I = A !== i, P = A === null, H = A === A, J = Ke(A);
+          if (d)
+            var G = s || H;
+          else
+            x ? G = H && (s || I) : h ? G = H && I && (s || !P) : m ? G = H && I && !P && (s || !J) : P || J ? G = !1 : G = s ? A <= t : A < t;
+          G ? l = $ + 1 : f = $;
+        }
+        return Me(f, Cu);
+      }
+      function wl(e, t) {
+        for (var n = -1, s = e.length, l = 0, f = []; ++n < s; ) {
+          var d = e[n], h = t ? t(d) : d;
+          if (!n || !dt(h, m)) {
+            var m = h;
+            f[l++] = d === 0 ? 0 : d;
+          }
+        }
+        return f;
+      }
+      function kl(e) {
+        return typeof e == "number" ? e : Ke(e) ? pr : +e;
+      }
+      function qe(e) {
+        if (typeof e == "string")
+          return e;
+        if (Y(e))
+          return ve(e, qe) + "";
+        if (Ke(e))
+          return el ? el.call(e) : "";
+        var t = e + "";
+        return t == "0" && 1 / e == -en ? "-0" : t;
+      }
+      function Gt(e, t, n) {
+        var s = -1, l = wr, f = e.length, d = !0, h = [], m = h;
+        if (n)
+          d = !1, l = Li;
+        else if (f >= a) {
+          var x = t ? null : Nd(e);
+          if (x)
+            return xr(x);
+          d = !1, l = Hn, m = new sn();
+        } else
+          m = t ? [] : h;
+        e:
+          for (; ++s < f; ) {
+            var $ = e[s], A = t ? t($) : $;
+            if ($ = n || $ !== 0 ? $ : 0, d && A === A) {
+              for (var I = m.length; I--; )
+                if (m[I] === A)
+                  continue e;
+              t && m.push(A), h.push($);
+            } else
+              l(m, A, n) || (m !== h && m.push(A), h.push($));
+          }
+        return h;
+      }
+      function ss(e, t) {
+        return t = Zt(t, e), e = Xl(e, t), e == null || delete e[bt(rt(t))];
+      }
+      function xl(e, t, n, s) {
+        return jn(e, t, n(ln(e, t)), s);
+      }
+      function Hr(e, t, n, s) {
+        for (var l = e.length, f = s ? l : -1; (s ? f-- : ++f < l) && t(e[f], f, e); )
+          ;
+        return n ? nt(e, s ? 0 : f, s ? f + 1 : l) : nt(e, s ? f + 1 : 0, s ? l : f);
+      }
+      function $l(e, t) {
+        var n = e;
+        return n instanceof ne && (n = n.value()), Mi(t, function(s, l) {
+          return l.func.apply(l.thisArg, Ut([s], l.args));
+        }, n);
+      }
+      function os(e, t, n) {
+        var s = e.length;
+        if (s < 2)
+          return s ? Gt(e[0]) : [];
+        for (var l = -1, f = w(s); ++l < s; )
+          for (var d = e[l], h = -1; ++h < s; )
+            h != l && (f[l] = Xn(f[l] || d, e[h], t, n));
+        return Gt(Le(f, 1), t, n);
+      }
+      function Al(e, t, n) {
+        for (var s = -1, l = e.length, f = t.length, d = {}; ++s < l; ) {
+          var h = s < f ? t[s] : i;
+          n(d, e[s], h);
+        }
+        return d;
+      }
+      function ls(e) {
+        return xe(e) ? e : [];
+      }
+      function as(e) {
+        return typeof e == "function" ? e : He;
+      }
+      function Zt(e, t) {
+        return Y(e) ? e : gs(e, t) ? [e] : ea(ue(e));
+      }
+      var Od = j;
+      function zt(e, t, n) {
+        var s = e.length;
+        return n = n === i ? s : n, !t && n >= s ? e : nt(e, t, n);
+      }
+      var Sl = vf || function(e) {
+        return Re.clearTimeout(e);
+      };
+      function Tl(e, t) {
+        if (t)
+          return e.slice();
+        var n = e.length, s = Ko ? Ko(n) : new e.constructor(n);
+        return e.copy(s), s;
+      }
+      function us(e) {
+        var t = new e.constructor(e.byteLength);
+        return new Or(t).set(new Or(e)), t;
+      }
+      function Ed(e, t) {
+        var n = t ? us(e.buffer) : e.buffer;
+        return new e.constructor(n, e.byteOffset, e.byteLength);
+      }
+      function Id(e) {
+        var t = new e.constructor(e.source, uo.exec(e));
+        return t.lastIndex = e.lastIndex, t;
+      }
+      function Rd(e) {
+        return Kn ? de(Kn.call(e)) : {};
+      }
+      function Cl(e, t) {
+        var n = t ? us(e.buffer) : e.buffer;
+        return new e.constructor(n, e.byteOffset, e.length);
+      }
+      function Ol(e, t) {
+        if (e !== t) {
+          var n = e !== i, s = e === null, l = e === e, f = Ke(e), d = t !== i, h = t === null, m = t === t, x = Ke(t);
+          if (!h && !x && !f && e > t || f && d && m && !h && !x || s && d && m || !n && m || !l)
+            return 1;
+          if (!s && !f && !x && e < t || x && n && l && !s && !f || h && n && l || !d && l || !m)
+            return -1;
+        }
+        return 0;
+      }
+      function Ld(e, t, n) {
+        for (var s = -1, l = e.criteria, f = t.criteria, d = l.length, h = n.length; ++s < d; ) {
+          var m = Ol(l[s], f[s]);
+          if (m) {
+            if (s >= h)
+              return m;
+            var x = n[s];
+            return m * (x == "desc" ? -1 : 1);
+          }
+        }
+        return e.index - t.index;
+      }
+      function El(e, t, n, s) {
+        for (var l = -1, f = e.length, d = n.length, h = -1, m = t.length, x = Oe(f - d, 0), $ = w(m + x), A = !s; ++h < m; )
+          $[h] = t[h];
+        for (; ++l < d; )
+          (A || l < f) && ($[n[l]] = e[l]);
+        for (; x--; )
+          $[h++] = e[l++];
+        return $;
+      }
+      function Il(e, t, n, s) {
+        for (var l = -1, f = e.length, d = -1, h = n.length, m = -1, x = t.length, $ = Oe(f - h, 0), A = w($ + x), I = !s; ++l < $; )
+          A[l] = e[l];
+        for (var P = l; ++m < x; )
+          A[P + m] = t[m];
+        for (; ++d < h; )
+          (I || l < f) && (A[P + n[d]] = e[l++]);
+        return A;
+      }
+      function Ue(e, t) {
+        var n = -1, s = e.length;
+        for (t || (t = w(s)); ++n < s; )
+          t[n] = e[n];
+        return t;
+      }
+      function yt(e, t, n, s) {
+        var l = !n;
+        n || (n = {});
+        for (var f = -1, d = t.length; ++f < d; ) {
+          var h = t[f], m = s ? s(n[h], e[h], h, n, e) : i;
+          m === i && (m = e[h]), l ? Et(n, h, m) : Yn(n, h, m);
+        }
+        return n;
+      }
+      function Md(e, t) {
+        return yt(e, vs(e), t);
+      }
+      function Bd(e, t) {
+        return yt(e, Gl(e), t);
+      }
+      function Gr(e, t) {
+        return function(n, s) {
+          var l = Y(n) ? Nc : rd, f = t ? t() : {};
+          return l(n, e, U(s, 2), f);
+        };
+      }
+      function Tn(e) {
+        return j(function(t, n) {
+          var s = -1, l = n.length, f = l > 1 ? n[l - 1] : i, d = l > 2 ? n[2] : i;
+          for (f = e.length > 3 && typeof f == "function" ? (l--, f) : i, d && De(n[0], n[1], d) && (f = l < 3 ? i : f, l = 1), t = de(t); ++s < l; ) {
+            var h = n[s];
+            h && e(t, h, s, f);
+          }
+          return t;
+        });
+      }
+      function Rl(e, t) {
+        return function(n, s) {
+          if (n == null)
+            return n;
+          if (!We(n))
+            return e(n, s);
+          for (var l = n.length, f = t ? l : -1, d = de(n); (t ? f-- : ++f < l) && s(d[f], f, d) !== !1; )
+            ;
+          return n;
+        };
+      }
+      function Ll(e) {
+        return function(t, n, s) {
+          for (var l = -1, f = de(t), d = s(t), h = d.length; h--; ) {
+            var m = d[e ? h : ++l];
+            if (n(f[m], m, f) === !1)
+              break;
+          }
+          return t;
+        };
+      }
+      function Pd(e, t, n) {
+        var s = t & E, l = er(e);
+        function f() {
+          var d = this && this !== Re && this instanceof f ? l : e;
+          return d.apply(s ? n : this, arguments);
+        }
+        return f;
+      }
+      function Ml(e) {
+        return function(t) {
+          t = ue(t);
+          var n = bn(t) ? ct(t) : i, s = n ? n[0] : t.charAt(0), l = n ? zt(n, 1).join("") : t.slice(1);
+          return s[e]() + l;
+        };
+      }
+      function Cn(e) {
+        return function(t) {
+          return Mi(Ra(Ia(t).replace(Ac, "")), e, "");
+        };
+      }
+      function er(e) {
+        return function() {
+          var t = arguments;
+          switch (t.length) {
+            case 0:
+              return new e();
+            case 1:
+              return new e(t[0]);
+            case 2:
+              return new e(t[0], t[1]);
+            case 3:
+              return new e(t[0], t[1], t[2]);
+            case 4:
+              return new e(t[0], t[1], t[2], t[3]);
+            case 5:
+              return new e(t[0], t[1], t[2], t[3], t[4]);
+            case 6:
+              return new e(t[0], t[1], t[2], t[3], t[4], t[5]);
+            case 7:
+              return new e(t[0], t[1], t[2], t[3], t[4], t[5], t[6]);
+          }
+          var n = Sn(e.prototype), s = e.apply(n, t);
+          return me(s) ? s : n;
+        };
+      }
+      function Dd(e, t, n) {
+        var s = er(e);
+        function l() {
+          for (var f = arguments.length, d = w(f), h = f, m = On(l); h--; )
+            d[h] = arguments[h];
+          var x = f < 3 && d[0] !== m && d[f - 1] !== m ? [] : Wt(d, m);
+          if (f -= x.length, f < n)
+            return Nl(
+              e,
+              t,
+              Zr,
+              l.placeholder,
+              i,
+              d,
+              x,
+              i,
+              i,
+              n - f
+            );
+          var $ = this && this !== Re && this instanceof l ? s : e;
+          return Ze($, this, d);
+        }
+        return l;
+      }
+      function Bl(e) {
+        return function(t, n, s) {
+          var l = de(t);
+          if (!We(t)) {
+            var f = U(n, 3);
+            t = Ie(t), n = function(h) {
+              return f(l[h], h, l);
+            };
+          }
+          var d = e(t, n, s);
+          return d > -1 ? l[f ? t[d] : d] : i;
+        };
+      }
+      function Pl(e) {
+        return Rt(function(t) {
+          var n = t.length, s = n, l = et.prototype.thru;
+          for (e && t.reverse(); s--; ) {
+            var f = t[s];
+            if (typeof f != "function")
+              throw new je(y);
+            if (l && !d && Yr(f) == "wrapper")
+              var d = new et([], !0);
+          }
+          for (s = d ? s : n; ++s < n; ) {
+            f = t[s];
+            var h = Yr(f), m = h == "wrapper" ? hs(f) : i;
+            m && ms(m[0]) && m[1] == (Ee | F | q | At) && !m[4].length && m[9] == 1 ? d = d[Yr(m[0])].apply(d, m[3]) : d = f.length == 1 && ms(f) ? d[h]() : d.thru(f);
+          }
+          return function() {
+            var x = arguments, $ = x[0];
+            if (d && x.length == 1 && Y($))
+              return d.plant($).value();
+            for (var A = 0, I = n ? t[A].apply(this, x) : $; ++A < n; )
+              I = t[A].call(this, I);
+            return I;
+          };
+        });
+      }
+      function Zr(e, t, n, s, l, f, d, h, m, x) {
+        var $ = t & Ee, A = t & E, I = t & W, P = t & (F | Z), H = t & Bn, J = I ? i : er(e);
+        function G() {
+          for (var te = arguments.length, re = w(te), Ye = te; Ye--; )
+            re[Ye] = arguments[Ye];
+          if (P)
+            var Fe = On(G), Xe = Kc(re, Fe);
+          if (s && (re = El(re, s, l, P)), f && (re = Il(re, f, d, P)), te -= Xe, P && te < x) {
+            var $e = Wt(re, Fe);
+            return Nl(
+              e,
+              t,
+              Zr,
+              G.placeholder,
+              n,
+              re,
+              $e,
+              h,
+              m,
+              x - te
+            );
+          }
+          var pt = A ? n : this, Pt = I ? pt[e] : e;
+          return te = re.length, h ? re = rp(re, h) : H && te > 1 && re.reverse(), $ && m < te && (re.length = m), this && this !== Re && this instanceof G && (Pt = J || er(Pt)), Pt.apply(pt, re);
+        }
+        return G;
+      }
+      function Dl(e, t) {
+        return function(n, s) {
+          return fd(n, e, t(s), {});
+        };
+      }
+      function zr(e, t) {
+        return function(n, s) {
+          var l;
+          if (n === i && s === i)
+            return t;
+          if (n !== i && (l = n), s !== i) {
+            if (l === i)
+              return s;
+            typeof n == "string" || typeof s == "string" ? (n = qe(n), s = qe(s)) : (n = kl(n), s = kl(s)), l = e(n, s);
+          }
+          return l;
+        };
+      }
+      function cs(e) {
+        return Rt(function(t) {
+          return t = ve(t, ze(U())), j(function(n) {
+            var s = this;
+            return e(t, function(l) {
+              return Ze(l, s, n);
+            });
+          });
+        });
+      }
+      function qr(e, t) {
+        t = t === i ? " " : qe(t);
+        var n = t.length;
+        if (n < 2)
+          return n ? rs(t, e) : t;
+        var s = rs(t, Lr(e / wn(t)));
+        return bn(t) ? zt(ct(s), 0, e).join("") : s.slice(0, e);
+      }
+      function Fd(e, t, n, s) {
+        var l = t & E, f = er(e);
+        function d() {
+          for (var h = -1, m = arguments.length, x = -1, $ = s.length, A = w($ + m), I = this && this !== Re && this instanceof d ? f : e; ++x < $; )
+            A[x] = s[x];
+          for (; m--; )
+            A[x++] = arguments[++h];
+          return Ze(I, l ? n : this, A);
+        }
+        return d;
+      }
+      function Fl(e) {
+        return function(t, n, s) {
+          return s && typeof s != "number" && De(t, n, s) && (n = s = i), t = Bt(t), n === i ? (n = t, t = 0) : n = Bt(n), s = s === i ? t < n ? 1 : -1 : Bt(s), xd(t, n, s, e);
+        };
+      }
+      function Kr(e) {
+        return function(t, n) {
+          return typeof t == "string" && typeof n == "string" || (t = it(t), n = it(n)), e(t, n);
+        };
+      }
+      function Nl(e, t, n, s, l, f, d, h, m, x) {
+        var $ = t & F, A = $ ? d : i, I = $ ? i : d, P = $ ? f : i, H = $ ? i : f;
+        t |= $ ? q : ge, t &= ~($ ? ge : q), t & V || (t &= ~(E | W));
+        var J = [
+          e,
+          t,
+          l,
+          P,
+          A,
+          H,
+          I,
+          h,
+          m,
+          x
+        ], G = n.apply(i, J);
+        return ms(e) && Jl(G, J), G.placeholder = s, Ql(G, e, t);
+      }
+      function fs(e) {
+        var t = Ce[e];
+        return function(n, s) {
+          if (n = it(n), s = s == null ? 0 : Me(X(s), 292), s && Qo(n)) {
+            var l = (ue(n) + "e").split("e"), f = t(l[0] + "e" + (+l[1] + s));
+            return l = (ue(f) + "e").split("e"), +(l[0] + "e" + (+l[1] - s));
+          }
+          return t(n);
+        };
+      }
+      var Nd = $n && 1 / xr(new $n([, -0]))[1] == en ? function(e) {
+        return new $n(e);
+      } : Ls;
+      function Ul(e) {
+        return function(t) {
+          var n = Be(t);
+          return n == at ? Wi(t) : n == ut ? tf(t) : qc(t, e(t));
+        };
+      }
+      function It(e, t, n, s, l, f, d, h) {
+        var m = t & W;
+        if (!m && typeof e != "function")
+          throw new je(y);
+        var x = s ? s.length : 0;
+        if (x || (t &= ~(q | ge), s = l = i), d = d === i ? d : Oe(X(d), 0), h = h === i ? h : X(h), x -= l ? l.length : 0, t & ge) {
+          var $ = s, A = l;
+          s = l = i;
+        }
+        var I = m ? i : hs(e), P = [
+          e,
+          t,
+          n,
+          s,
+          l,
+          $,
+          A,
+          f,
+          d,
+          h
+        ];
+        if (I && ep(P, I), e = P[0], t = P[1], n = P[2], s = P[3], l = P[4], h = P[9] = P[9] === i ? m ? 0 : e.length : Oe(P[9] - x, 0), !h && t & (F | Z) && (t &= ~(F | Z)), !t || t == E)
+          var H = Pd(e, t, n);
+        else
+          t == F || t == Z ? H = Dd(e, t, h) : (t == q || t == (E | q)) && !l.length ? H = Fd(e, t, n, s) : H = Zr.apply(i, P);
+        var J = I ? bl : Jl;
+        return Ql(J(H, P), e, t);
+      }
+      function Wl(e, t, n, s) {
+        return e === i || dt(e, xn[n]) && !ce.call(s, n) ? t : e;
+      }
+      function Vl(e, t, n, s, l, f) {
+        return me(e) && me(t) && (f.set(t, e), Wr(e, t, i, Vl, f), f.delete(t)), e;
+      }
+      function Ud(e) {
+        return rr(e) ? i : e;
+      }
+      function Hl(e, t, n, s, l, f) {
+        var d = n & ee, h = e.length, m = t.length;
+        if (h != m && !(d && m > h))
+          return !1;
+        var x = f.get(e), $ = f.get(t);
+        if (x && $)
+          return x == t && $ == e;
+        var A = -1, I = !0, P = n & O ? new sn() : i;
+        for (f.set(e, t), f.set(t, e); ++A < h; ) {
+          var H = e[A], J = t[A];
+          if (s)
+            var G = d ? s(J, H, A, t, e, f) : s(H, J, A, e, t, f);
+          if (G !== i) {
+            if (G)
+              continue;
+            I = !1;
+            break;
+          }
+          if (P) {
+            if (!Bi(t, function(te, re) {
+              if (!Hn(P, re) && (H === te || l(H, te, n, s, f)))
+                return P.push(re);
+            })) {
+              I = !1;
+              break;
+            }
+          } else if (!(H === J || l(H, J, n, s, f))) {
+            I = !1;
+            break;
+          }
+        }
+        return f.delete(e), f.delete(t), I;
+      }
+      function Wd(e, t, n, s, l, f, d) {
+        switch (n) {
+          case gn:
+            if (e.byteLength != t.byteLength || e.byteOffset != t.byteOffset)
+              return !1;
+            e = e.buffer, t = t.buffer;
+          case Vn:
+            return !(e.byteLength != t.byteLength || !f(new Or(e), new Or(t)));
+          case Pn:
+          case Dn:
+          case Fn:
+            return dt(+e, +t);
+          case _r:
+            return e.name == t.name && e.message == t.message;
+          case Nn:
+          case Un:
+            return e == t + "";
+          case at:
+            var h = Wi;
+          case ut:
+            var m = s & ee;
+            if (h || (h = xr), e.size != t.size && !m)
+              return !1;
+            var x = d.get(e);
+            if (x)
+              return x == t;
+            s |= O, d.set(e, t);
+            var $ = Hl(h(e), h(t), s, l, f, d);
+            return d.delete(e), $;
+          case gr:
+            if (Kn)
+              return Kn.call(e) == Kn.call(t);
+        }
+        return !1;
+      }
+      function Vd(e, t, n, s, l, f) {
+        var d = n & ee, h = ds(e), m = h.length, x = ds(t), $ = x.length;
+        if (m != $ && !d)
+          return !1;
+        for (var A = m; A--; ) {
+          var I = h[A];
+          if (!(d ? I in t : ce.call(t, I)))
+            return !1;
+        }
+        var P = f.get(e), H = f.get(t);
+        if (P && H)
+          return P == t && H == e;
+        var J = !0;
+        f.set(e, t), f.set(t, e);
+        for (var G = d; ++A < m; ) {
+          I = h[A];
+          var te = e[I], re = t[I];
+          if (s)
+            var Ye = d ? s(re, te, I, t, e, f) : s(te, re, I, e, t, f);
+          if (!(Ye === i ? te === re || l(te, re, n, s, f) : Ye)) {
+            J = !1;
+            break;
+          }
+          G || (G = I == "constructor");
+        }
+        if (J && !G) {
+          var Fe = e.constructor, Xe = t.constructor;
+          Fe != Xe && "constructor" in e && "constructor" in t && !(typeof Fe == "function" && Fe instanceof Fe && typeof Xe == "function" && Xe instanceof Xe) && (J = !1);
+        }
+        return f.delete(e), f.delete(t), J;
+      }
+      function Rt(e) {
+        return bs(Yl(e, i, ia), e + "");
+      }
+      function ds(e) {
+        return ul(e, Ie, vs);
+      }
+      function ps(e) {
+        return ul(e, Ve, Gl);
+      }
+      var hs = Br ? function(e) {
+        return Br.get(e);
+      } : Ls;
+      function Yr(e) {
+        for (var t = e.name + "", n = An[t], s = ce.call(An, t) ? n.length : 0; s--; ) {
+          var l = n[s], f = l.func;
+          if (f == null || f == e)
+            return l.name;
+        }
+        return t;
+      }
+      function On(e) {
+        var t = ce.call(u, "placeholder") ? u : e;
+        return t.placeholder;
+      }
+      function U() {
+        var e = u.iteratee || Is;
+        return e = e === Is ? dl : e, arguments.length ? e(arguments[0], arguments[1]) : e;
+      }
+      function Xr(e, t) {
+        var n = e.__data__;
+        return Xd(t) ? n[typeof t == "string" ? "string" : "hash"] : n.map;
+      }
+      function _s(e) {
+        for (var t = Ie(e), n = t.length; n--; ) {
+          var s = t[n], l = e[s];
+          t[n] = [s, l, ql(l)];
+        }
+        return t;
+      }
+      function an(e, t) {
+        var n = Qc(e, t);
+        return fl(n) ? n : i;
+      }
+      function Hd(e) {
+        var t = ce.call(e, nn), n = e[nn];
+        try {
+          e[nn] = i;
+          var s = !0;
+        } catch {
+        }
+        var l = Tr.call(e);
+        return s && (t ? e[nn] = n : delete e[nn]), l;
+      }
+      var vs = Hi ? function(e) {
+        return e == null ? [] : (e = de(e), Nt(Hi(e), function(t) {
+          return Xo.call(e, t);
+        }));
+      } : Ms, Gl = Hi ? function(e) {
+        for (var t = []; e; )
+          Ut(t, vs(e)), e = Er(e);
+        return t;
+      } : Ms, Be = Pe;
+      (Gi && Be(new Gi(new ArrayBuffer(1))) != gn || Zn && Be(new Zn()) != at || Zi && Be(Zi.resolve()) != so || $n && Be(new $n()) != ut || zn && Be(new zn()) != Wn) && (Be = function(e) {
+        var t = Pe(e), n = t == Tt ? e.constructor : i, s = n ? un(n) : "";
+        if (s)
+          switch (s) {
+            case Af:
+              return gn;
+            case Sf:
+              return at;
+            case Tf:
+              return so;
+            case Cf:
+              return ut;
+            case Of:
+              return Wn;
+          }
+        return t;
+      });
+      function Gd(e, t, n) {
+        for (var s = -1, l = n.length; ++s < l; ) {
+          var f = n[s], d = f.size;
+          switch (f.type) {
+            case "drop":
+              e += d;
+              break;
+            case "dropRight":
+              t -= d;
+              break;
+            case "take":
+              t = Me(t, e + d);
+              break;
+            case "takeRight":
+              e = Oe(e, t - d);
+              break;
+          }
+        }
+        return { start: e, end: t };
+      }
+      function Zd(e) {
+        var t = e.match(Xu);
+        return t ? t[1].split(Ju) : [];
+      }
+      function Zl(e, t, n) {
+        t = Zt(t, e);
+        for (var s = -1, l = t.length, f = !1; ++s < l; ) {
+          var d = bt(t[s]);
+          if (!(f = e != null && n(e, d)))
+            break;
+          e = e[d];
+        }
+        return f || ++s != l ? f : (l = e == null ? 0 : e.length, !!l && ri(l) && Lt(d, l) && (Y(e) || cn(e)));
+      }
+      function zd(e) {
+        var t = e.length, n = new e.constructor(t);
+        return t && typeof e[0] == "string" && ce.call(e, "index") && (n.index = e.index, n.input = e.input), n;
+      }
+      function zl(e) {
+        return typeof e.constructor == "function" && !tr(e) ? Sn(Er(e)) : {};
+      }
+      function qd(e, t, n) {
+        var s = e.constructor;
+        switch (t) {
+          case Vn:
+            return us(e);
+          case Pn:
+          case Dn:
+            return new s(+e);
+          case gn:
+            return Ed(e, n);
+          case _i:
+          case vi:
+          case gi:
+          case mi:
+          case yi:
+          case bi:
+          case wi:
+          case ki:
+          case xi:
+            return Cl(e, n);
+          case at:
+            return new s();
+          case Fn:
+          case Un:
+            return new s(e);
+          case Nn:
+            return Id(e);
+          case ut:
+            return new s();
+          case gr:
+            return Rd(e);
+        }
+      }
+      function Kd(e, t) {
+        var n = t.length;
+        if (!n)
+          return e;
+        var s = n - 1;
+        return t[s] = (n > 1 ? "& " : "") + t[s], t = t.join(n > 2 ? ", " : " "), e.replace(Yu, `{
+/* [wrapped with ` + t + `] */
+`);
+      }
+      function Yd(e) {
+        return Y(e) || cn(e) || !!(Jo && e && e[Jo]);
+      }
+      function Lt(e, t) {
+        var n = typeof e;
+        return t = t ?? Ft, !!t && (n == "number" || n != "symbol" && oc.test(e)) && e > -1 && e % 1 == 0 && e < t;
+      }
+      function De(e, t, n) {
+        if (!me(n))
+          return !1;
+        var s = typeof t;
+        return (s == "number" ? We(n) && Lt(t, n.length) : s == "string" && t in n) ? dt(n[t], e) : !1;
+      }
+      function gs(e, t) {
+        if (Y(e))
+          return !1;
+        var n = typeof e;
+        return n == "number" || n == "symbol" || n == "boolean" || e == null || Ke(e) ? !0 : Zu.test(e) || !Gu.test(e) || t != null && e in de(t);
+      }
+      function Xd(e) {
+        var t = typeof e;
+        return t == "string" || t == "number" || t == "symbol" || t == "boolean" ? e !== "__proto__" : e === null;
+      }
+      function ms(e) {
+        var t = Yr(e), n = u[t];
+        if (typeof n != "function" || !(t in ne.prototype))
+          return !1;
+        if (e === n)
+          return !0;
+        var s = hs(n);
+        return !!s && e === s[0];
+      }
+      function Jd(e) {
+        return !!qo && qo in e;
+      }
+      var Qd = Ar ? Mt : Bs;
+      function tr(e) {
+        var t = e && e.constructor, n = typeof t == "function" && t.prototype || xn;
+        return e === n;
+      }
+      function ql(e) {
+        return e === e && !me(e);
+      }
+      function Kl(e, t) {
+        return function(n) {
+          return n == null ? !1 : n[e] === t && (t !== i || e in de(n));
+        };
+      }
+      function jd(e) {
+        var t = ti(e, function(s) {
+          return n.size === g && n.clear(), s;
+        }), n = t.cache;
+        return t;
+      }
+      function ep(e, t) {
+        var n = e[1], s = t[1], l = n | s, f = l < (E | W | Ee), d = s == Ee && n == F || s == Ee && n == At && e[7].length <= t[8] || s == (Ee | At) && t[7].length <= t[8] && n == F;
+        if (!(f || d))
+          return e;
+        s & E && (e[2] = t[2], l |= n & E ? 0 : V);
+        var h = t[3];
+        if (h) {
+          var m = e[3];
+          e[3] = m ? El(m, h, t[4]) : h, e[4] = m ? Wt(e[3], _) : t[4];
+        }
+        return h = t[5], h && (m = e[5], e[5] = m ? Il(m, h, t[6]) : h, e[6] = m ? Wt(e[5], _) : t[6]), h = t[7], h && (e[7] = h), s & Ee && (e[8] = e[8] == null ? t[8] : Me(e[8], t[8])), e[9] == null && (e[9] = t[9]), e[0] = t[0], e[1] = l, e;
+      }
+      function tp(e) {
+        var t = [];
+        if (e != null)
+          for (var n in de(e))
+            t.push(n);
+        return t;
+      }
+      function np(e) {
+        return Tr.call(e);
+      }
+      function Yl(e, t, n) {
+        return t = Oe(t === i ? e.length - 1 : t, 0), function() {
+          for (var s = arguments, l = -1, f = Oe(s.length - t, 0), d = w(f); ++l < f; )
+            d[l] = s[t + l];
+          l = -1;
+          for (var h = w(t + 1); ++l < t; )
+            h[l] = s[l];
+          return h[t] = n(d), Ze(e, this, h);
+        };
+      }
+      function Xl(e, t) {
+        return t.length < 2 ? e : ln(e, nt(t, 0, -1));
+      }
+      function rp(e, t) {
+        for (var n = e.length, s = Me(t.length, n), l = Ue(e); s--; ) {
+          var f = t[s];
+          e[s] = Lt(f, n) ? l[f] : i;
+        }
+        return e;
+      }
+      function ys(e, t) {
+        if (!(t === "constructor" && typeof e[t] == "function") && t != "__proto__")
+          return e[t];
+      }
+      var Jl = jl(bl), nr = mf || function(e, t) {
+        return Re.setTimeout(e, t);
+      }, bs = jl(Sd);
+      function Ql(e, t, n) {
+        var s = t + "";
+        return bs(e, Kd(s, ip(Zd(s), n)));
+      }
+      function jl(e) {
+        var t = 0, n = 0;
+        return function() {
+          var s = kf(), l = St - (s - n);
+          if (n = s, l > 0) {
+            if (++t >= vt)
+              return arguments[0];
+          } else
+            t = 0;
+          return e.apply(i, arguments);
+        };
+      }
+      function Jr(e, t) {
+        var n = -1, s = e.length, l = s - 1;
+        for (t = t === i ? s : t; ++n < t; ) {
+          var f = ns(n, l), d = e[f];
+          e[f] = e[n], e[n] = d;
+        }
+        return e.length = t, e;
+      }
+      var ea = jd(function(e) {
+        var t = [];
+        return e.charCodeAt(0) === 46 && t.push(""), e.replace(zu, function(n, s, l, f) {
+          t.push(l ? f.replace(ec, "$1") : s || n);
+        }), t;
+      });
+      function bt(e) {
+        if (typeof e == "string" || Ke(e))
+          return e;
+        var t = e + "";
+        return t == "0" && 1 / e == -en ? "-0" : t;
+      }
+      function un(e) {
+        if (e != null) {
+          try {
+            return Sr.call(e);
+          } catch {
+          }
+          try {
+            return e + "";
+          } catch {
+          }
+        }
+        return "";
+      }
+      function ip(e, t) {
+        return Qe(Eu, function(n) {
+          var s = "_." + n[0];
+          t & n[1] && !wr(e, s) && e.push(s);
+        }), e.sort();
+      }
+      function ta(e) {
+        if (e instanceof ne)
+          return e.clone();
+        var t = new et(e.__wrapped__, e.__chain__);
+        return t.__actions__ = Ue(e.__actions__), t.__index__ = e.__index__, t.__values__ = e.__values__, t;
+      }
+      function sp(e, t, n) {
+        (n ? De(e, t, n) : t === i) ? t = 1 : t = Oe(X(t), 0);
+        var s = e == null ? 0 : e.length;
+        if (!s || t < 1)
+          return [];
+        for (var l = 0, f = 0, d = w(Lr(s / t)); l < s; )
+          d[f++] = nt(e, l, l += t);
+        return d;
+      }
+      function op(e) {
+        for (var t = -1, n = e == null ? 0 : e.length, s = 0, l = []; ++t < n; ) {
+          var f = e[t];
+          f && (l[s++] = f);
+        }
+        return l;
+      }
+      function lp() {
+        var e = arguments.length;
+        if (!e)
+          return [];
+        for (var t = w(e - 1), n = arguments[0], s = e; s--; )
+          t[s - 1] = arguments[s];
+        return Ut(Y(n) ? Ue(n) : [n], Le(t, 1));
+      }
+      var ap = j(function(e, t) {
+        return xe(e) ? Xn(e, Le(t, 1, xe, !0)) : [];
+      }), up = j(function(e, t) {
+        var n = rt(t);
+        return xe(n) && (n = i), xe(e) ? Xn(e, Le(t, 1, xe, !0), U(n, 2)) : [];
+      }), cp = j(function(e, t) {
+        var n = rt(t);
+        return xe(n) && (n = i), xe(e) ? Xn(e, Le(t, 1, xe, !0), i, n) : [];
+      });
+      function fp(e, t, n) {
+        var s = e == null ? 0 : e.length;
+        return s ? (t = n || t === i ? 1 : X(t), nt(e, t < 0 ? 0 : t, s)) : [];
+      }
+      function dp(e, t, n) {
+        var s = e == null ? 0 : e.length;
+        return s ? (t = n || t === i ? 1 : X(t), t = s - t, nt(e, 0, t < 0 ? 0 : t)) : [];
+      }
+      function pp(e, t) {
+        return e && e.length ? Hr(e, U(t, 3), !0, !0) : [];
+      }
+      function hp(e, t) {
+        return e && e.length ? Hr(e, U(t, 3), !0) : [];
+      }
+      function _p(e, t, n, s) {
+        var l = e == null ? 0 : e.length;
+        return l ? (n && typeof n != "number" && De(e, t, n) && (n = 0, s = l), ld(e, t, n, s)) : [];
+      }
+      function na(e, t, n) {
+        var s = e == null ? 0 : e.length;
+        if (!s)
+          return -1;
+        var l = n == null ? 0 : X(n);
+        return l < 0 && (l = Oe(s + l, 0)), kr(e, U(t, 3), l);
+      }
+      function ra(e, t, n) {
+        var s = e == null ? 0 : e.length;
+        if (!s)
+          return -1;
+        var l = s - 1;
+        return n !== i && (l = X(n), l = n < 0 ? Oe(s + l, 0) : Me(l, s - 1)), kr(e, U(t, 3), l, !0);
+      }
+      function ia(e) {
+        var t = e == null ? 0 : e.length;
+        return t ? Le(e, 1) : [];
+      }
+      function vp(e) {
+        var t = e == null ? 0 : e.length;
+        return t ? Le(e, en) : [];
+      }
+      function gp(e, t) {
+        var n = e == null ? 0 : e.length;
+        return n ? (t = t === i ? 1 : X(t), Le(e, t)) : [];
+      }
+      function mp(e) {
+        for (var t = -1, n = e == null ? 0 : e.length, s = {}; ++t < n; ) {
+          var l = e[t];
+          s[l[0]] = l[1];
+        }
+        return s;
+      }
+      function sa(e) {
+        return e && e.length ? e[0] : i;
+      }
+      function yp(e, t, n) {
+        var s = e == null ? 0 : e.length;
+        if (!s)
+          return -1;
+        var l = n == null ? 0 : X(n);
+        return l < 0 && (l = Oe(s + l, 0)), yn(e, t, l);
+      }
+      function bp(e) {
+        var t = e == null ? 0 : e.length;
+        return t ? nt(e, 0, -1) : [];
+      }
+      var wp = j(function(e) {
+        var t = ve(e, ls);
+        return t.length && t[0] === e[0] ? Ji(t) : [];
+      }), kp = j(function(e) {
+        var t = rt(e), n = ve(e, ls);
+        return t === rt(n) ? t = i : n.pop(), n.length && n[0] === e[0] ? Ji(n, U(t, 2)) : [];
+      }), xp = j(function(e) {
+        var t = rt(e), n = ve(e, ls);
+        return t = typeof t == "function" ? t : i, t && n.pop(), n.length && n[0] === e[0] ? Ji(n, i, t) : [];
+      });
+      function $p(e, t) {
+        return e == null ? "" : bf.call(e, t);
+      }
+      function rt(e) {
+        var t = e == null ? 0 : e.length;
+        return t ? e[t - 1] : i;
+      }
+      function Ap(e, t, n) {
+        var s = e == null ? 0 : e.length;
+        if (!s)
+          return -1;
+        var l = s;
+        return n !== i && (l = X(n), l = l < 0 ? Oe(s + l, 0) : Me(l, s - 1)), t === t ? rf(e, t, l) : kr(e, No, l, !0);
+      }
+      function Sp(e, t) {
+        return e && e.length ? vl(e, X(t)) : i;
+      }
+      var Tp = j(oa);
+      function oa(e, t) {
+        return e && e.length && t && t.length ? ts(e, t) : e;
+      }
+      function Cp(e, t, n) {
+        return e && e.length && t && t.length ? ts(e, t, U(n, 2)) : e;
+      }
+      function Op(e, t, n) {
+        return e && e.length && t && t.length ? ts(e, t, i, n) : e;
+      }
+      var Ep = Rt(function(e, t) {
+        var n = e == null ? 0 : e.length, s = qi(e, t);
+        return yl(e, ve(t, function(l) {
+          return Lt(l, n) ? +l : l;
+        }).sort(Ol)), s;
+      });
+      function Ip(e, t) {
+        var n = [];
+        if (!(e && e.length))
+          return n;
+        var s = -1, l = [], f = e.length;
+        for (t = U(t, 3); ++s < f; ) {
+          var d = e[s];
+          t(d, s, e) && (n.push(d), l.push(s));
+        }
+        return yl(e, l), n;
+      }
+      function ws(e) {
+        return e == null ? e : $f.call(e);
+      }
+      function Rp(e, t, n) {
+        var s = e == null ? 0 : e.length;
+        return s ? (n && typeof n != "number" && De(e, t, n) ? (t = 0, n = s) : (t = t == null ? 0 : X(t), n = n === i ? s : X(n)), nt(e, t, n)) : [];
+      }
+      function Lp(e, t) {
+        return Vr(e, t);
+      }
+      function Mp(e, t, n) {
+        return is(e, t, U(n, 2));
+      }
+      function Bp(e, t) {
+        var n = e == null ? 0 : e.length;
+        if (n) {
+          var s = Vr(e, t);
+          if (s < n && dt(e[s], t))
+            return s;
+        }
+        return -1;
+      }
+      function Pp(e, t) {
+        return Vr(e, t, !0);
+      }
+      function Dp(e, t, n) {
+        return is(e, t, U(n, 2), !0);
+      }
+      function Fp(e, t) {
+        var n = e == null ? 0 : e.length;
+        if (n) {
+          var s = Vr(e, t, !0) - 1;
+          if (dt(e[s], t))
+            return s;
+        }
+        return -1;
+      }
+      function Np(e) {
+        return e && e.length ? wl(e) : [];
+      }
+      function Up(e, t) {
+        return e && e.length ? wl(e, U(t, 2)) : [];
+      }
+      function Wp(e) {
+        var t = e == null ? 0 : e.length;
+        return t ? nt(e, 1, t) : [];
+      }
+      function Vp(e, t, n) {
+        return e && e.length ? (t = n || t === i ? 1 : X(t), nt(e, 0, t < 0 ? 0 : t)) : [];
+      }
+      function Hp(e, t, n) {
+        var s = e == null ? 0 : e.length;
+        return s ? (t = n || t === i ? 1 : X(t), t = s - t, nt(e, t < 0 ? 0 : t, s)) : [];
+      }
+      function Gp(e, t) {
+        return e && e.length ? Hr(e, U(t, 3), !1, !0) : [];
+      }
+      function Zp(e, t) {
+        return e && e.length ? Hr(e, U(t, 3)) : [];
+      }
+      var zp = j(function(e) {
+        return Gt(Le(e, 1, xe, !0));
+      }), qp = j(function(e) {
+        var t = rt(e);
+        return xe(t) && (t = i), Gt(Le(e, 1, xe, !0), U(t, 2));
+      }), Kp = j(function(e) {
+        var t = rt(e);
+        return t = typeof t == "function" ? t : i, Gt(Le(e, 1, xe, !0), i, t);
+      });
+      function Yp(e) {
+        return e && e.length ? Gt(e) : [];
+      }
+      function Xp(e, t) {
+        return e && e.length ? Gt(e, U(t, 2)) : [];
+      }
+      function Jp(e, t) {
+        return t = typeof t == "function" ? t : i, e && e.length ? Gt(e, i, t) : [];
+      }
+      function ks(e) {
+        if (!(e && e.length))
+          return [];
+        var t = 0;
+        return e = Nt(e, function(n) {
+          if (xe(n))
+            return t = Oe(n.length, t), !0;
+        }), Ni(t, function(n) {
+          return ve(e, Pi(n));
+        });
+      }
+      function la(e, t) {
+        if (!(e && e.length))
+          return [];
+        var n = ks(e);
+        return t == null ? n : ve(n, function(s) {
+          return Ze(t, i, s);
+        });
+      }
+      var Qp = j(function(e, t) {
+        return xe(e) ? Xn(e, t) : [];
+      }), jp = j(function(e) {
+        return os(Nt(e, xe));
+      }), eh = j(function(e) {
+        var t = rt(e);
+        return xe(t) && (t = i), os(Nt(e, xe), U(t, 2));
+      }), th = j(function(e) {
+        var t = rt(e);
+        return t = typeof t == "function" ? t : i, os(Nt(e, xe), i, t);
+      }), nh = j(ks);
+      function rh(e, t) {
+        return Al(e || [], t || [], Yn);
+      }
+      function ih(e, t) {
+        return Al(e || [], t || [], jn);
+      }
+      var sh = j(function(e) {
+        var t = e.length, n = t > 1 ? e[t - 1] : i;
+        return n = typeof n == "function" ? (e.pop(), n) : i, la(e, n);
+      });
+      function aa(e) {
+        var t = u(e);
+        return t.__chain__ = !0, t;
+      }
+      function oh(e, t) {
+        return t(e), e;
+      }
+      function Qr(e, t) {
+        return t(e);
+      }
+      var lh = Rt(function(e) {
+        var t = e.length, n = t ? e[0] : 0, s = this.__wrapped__, l = function(f) {
+          return qi(f, e);
+        };
+        return t > 1 || this.__actions__.length || !(s instanceof ne) || !Lt(n) ? this.thru(l) : (s = s.slice(n, +n + (t ? 1 : 0)), s.__actions__.push({
+          func: Qr,
+          args: [l],
+          thisArg: i
+        }), new et(s, this.__chain__).thru(function(f) {
+          return t && !f.length && f.push(i), f;
+        }));
+      });
+      function ah() {
+        return aa(this);
+      }
+      function uh() {
+        return new et(this.value(), this.__chain__);
+      }
+      function ch() {
+        this.__values__ === i && (this.__values__ = ka(this.value()));
+        var e = this.__index__ >= this.__values__.length, t = e ? i : this.__values__[this.__index__++];
+        return { done: e, value: t };
+      }
+      function fh() {
+        return this;
+      }
+      function dh(e) {
+        for (var t, n = this; n instanceof Dr; ) {
+          var s = ta(n);
+          s.__index__ = 0, s.__values__ = i, t ? l.__wrapped__ = s : t = s;
+          var l = s;
+          n = n.__wrapped__;
+        }
+        return l.__wrapped__ = e, t;
+      }
+      function ph() {
+        var e = this.__wrapped__;
+        if (e instanceof ne) {
+          var t = e;
+          return this.__actions__.length && (t = new ne(this)), t = t.reverse(), t.__actions__.push({
+            func: Qr,
+            args: [ws],
+            thisArg: i
+          }), new et(t, this.__chain__);
+        }
+        return this.thru(ws);
+      }
+      function hh() {
+        return $l(this.__wrapped__, this.__actions__);
+      }
+      var _h = Gr(function(e, t, n) {
+        ce.call(e, n) ? ++e[n] : Et(e, n, 1);
+      });
+      function vh(e, t, n) {
+        var s = Y(e) ? Do : od;
+        return n && De(e, t, n) && (t = i), s(e, U(t, 3));
+      }
+      function gh(e, t) {
+        var n = Y(e) ? Nt : ll;
+        return n(e, U(t, 3));
+      }
+      var mh = Bl(na), yh = Bl(ra);
+      function bh(e, t) {
+        return Le(jr(e, t), 1);
+      }
+      function wh(e, t) {
+        return Le(jr(e, t), en);
+      }
+      function kh(e, t, n) {
+        return n = n === i ? 1 : X(n), Le(jr(e, t), n);
+      }
+      function ua(e, t) {
+        var n = Y(e) ? Qe : Ht;
+        return n(e, U(t, 3));
+      }
+      function ca(e, t) {
+        var n = Y(e) ? Uc : ol;
+        return n(e, U(t, 3));
+      }
+      var xh = Gr(function(e, t, n) {
+        ce.call(e, n) ? e[n].push(t) : Et(e, n, [t]);
+      });
+      function $h(e, t, n, s) {
+        e = We(e) ? e : In(e), n = n && !s ? X(n) : 0;
+        var l = e.length;
+        return n < 0 && (n = Oe(l + n, 0)), ii(e) ? n <= l && e.indexOf(t, n) > -1 : !!l && yn(e, t, n) > -1;
+      }
+      var Ah = j(function(e, t, n) {
+        var s = -1, l = typeof t == "function", f = We(e) ? w(e.length) : [];
+        return Ht(e, function(d) {
+          f[++s] = l ? Ze(t, d, n) : Jn(d, t, n);
+        }), f;
+      }), Sh = Gr(function(e, t, n) {
+        Et(e, n, t);
+      });
+      function jr(e, t) {
+        var n = Y(e) ? ve : pl;
+        return n(e, U(t, 3));
+      }
+      function Th(e, t, n, s) {
+        return e == null ? [] : (Y(t) || (t = t == null ? [] : [t]), n = s ? i : n, Y(n) || (n = n == null ? [] : [n]), gl(e, t, n));
+      }
+      var Ch = Gr(function(e, t, n) {
+        e[n ? 0 : 1].push(t);
+      }, function() {
+        return [[], []];
+      });
+      function Oh(e, t, n) {
+        var s = Y(e) ? Mi : Wo, l = arguments.length < 3;
+        return s(e, U(t, 4), n, l, Ht);
+      }
+      function Eh(e, t, n) {
+        var s = Y(e) ? Wc : Wo, l = arguments.length < 3;
+        return s(e, U(t, 4), n, l, ol);
+      }
+      function Ih(e, t) {
+        var n = Y(e) ? Nt : ll;
+        return n(e, ni(U(t, 3)));
+      }
+      function Rh(e) {
+        var t = Y(e) ? nl : $d;
+        return t(e);
+      }
+      function Lh(e, t, n) {
+        (n ? De(e, t, n) : t === i) ? t = 1 : t = X(t);
+        var s = Y(e) ? td : Ad;
+        return s(e, t);
+      }
+      function Mh(e) {
+        var t = Y(e) ? nd : Td;
+        return t(e);
+      }
+      function Bh(e) {
+        if (e == null)
+          return 0;
+        if (We(e))
+          return ii(e) ? wn(e) : e.length;
+        var t = Be(e);
+        return t == at || t == ut ? e.size : ji(e).length;
+      }
+      function Ph(e, t, n) {
+        var s = Y(e) ? Bi : Cd;
+        return n && De(e, t, n) && (t = i), s(e, U(t, 3));
+      }
+      var Dh = j(function(e, t) {
+        if (e == null)
+          return [];
+        var n = t.length;
+        return n > 1 && De(e, t[0], t[1]) ? t = [] : n > 2 && De(t[0], t[1], t[2]) && (t = [t[0]]), gl(e, Le(t, 1), []);
+      }), ei = gf || function() {
+        return Re.Date.now();
+      };
+      function Fh(e, t) {
+        if (typeof t != "function")
+          throw new je(y);
+        return e = X(e), function() {
+          if (--e < 1)
+            return t.apply(this, arguments);
+        };
+      }
+      function fa(e, t, n) {
+        return t = n ? i : t, t = e && t == null ? e.length : t, It(e, Ee, i, i, i, i, t);
+      }
+      function da(e, t) {
+        var n;
+        if (typeof t != "function")
+          throw new je(y);
+        return e = X(e), function() {
+          return --e > 0 && (n = t.apply(this, arguments)), e <= 1 && (t = i), n;
+        };
+      }
+      var xs = j(function(e, t, n) {
+        var s = E;
+        if (n.length) {
+          var l = Wt(n, On(xs));
+          s |= q;
+        }
+        return It(e, s, t, n, l);
+      }), pa = j(function(e, t, n) {
+        var s = E | W;
+        if (n.length) {
+          var l = Wt(n, On(pa));
+          s |= q;
+        }
+        return It(t, s, e, n, l);
+      });
+      function ha(e, t, n) {
+        t = n ? i : t;
+        var s = It(e, F, i, i, i, i, i, t);
+        return s.placeholder = ha.placeholder, s;
+      }
+      function _a(e, t, n) {
+        t = n ? i : t;
+        var s = It(e, Z, i, i, i, i, i, t);
+        return s.placeholder = _a.placeholder, s;
+      }
+      function va(e, t, n) {
+        var s, l, f, d, h, m, x = 0, $ = !1, A = !1, I = !0;
+        if (typeof e != "function")
+          throw new je(y);
+        t = it(t) || 0, me(n) && ($ = !!n.leading, A = "maxWait" in n, f = A ? Oe(it(n.maxWait) || 0, t) : f, I = "trailing" in n ? !!n.trailing : I);
+        function P($e) {
+          var pt = s, Pt = l;
+          return s = l = i, x = $e, d = e.apply(Pt, pt), d;
+        }
+        function H($e) {
+          return x = $e, h = nr(te, t), $ ? P($e) : d;
+        }
+        function J($e) {
+          var pt = $e - m, Pt = $e - x, Ba = t - pt;
+          return A ? Me(Ba, f - Pt) : Ba;
+        }
+        function G($e) {
+          var pt = $e - m, Pt = $e - x;
+          return m === i || pt >= t || pt < 0 || A && Pt >= f;
+        }
+        function te() {
+          var $e = ei();
+          if (G($e))
+            return re($e);
+          h = nr(te, J($e));
+        }
+        function re($e) {
+          return h = i, I && s ? P($e) : (s = l = i, d);
+        }
+        function Ye() {
+          h !== i && Sl(h), x = 0, s = m = l = h = i;
+        }
+        function Fe() {
+          return h === i ? d : re(ei());
+        }
+        function Xe() {
+          var $e = ei(), pt = G($e);
+          if (s = arguments, l = this, m = $e, pt) {
+            if (h === i)
+              return H(m);
+            if (A)
+              return Sl(h), h = nr(te, t), P(m);
+          }
+          return h === i && (h = nr(te, t)), d;
+        }
+        return Xe.cancel = Ye, Xe.flush = Fe, Xe;
+      }
+      var Nh = j(function(e, t) {
+        return sl(e, 1, t);
+      }), Uh = j(function(e, t, n) {
+        return sl(e, it(t) || 0, n);
+      });
+      function Wh(e) {
+        return It(e, Bn);
+      }
+      function ti(e, t) {
+        if (typeof e != "function" || t != null && typeof t != "function")
+          throw new je(y);
+        var n = function() {
+          var s = arguments, l = t ? t.apply(this, s) : s[0], f = n.cache;
+          if (f.has(l))
+            return f.get(l);
+          var d = e.apply(this, s);
+          return n.cache = f.set(l, d) || f, d;
+        };
+        return n.cache = new (ti.Cache || Ot)(), n;
+      }
+      ti.Cache = Ot;
+      function ni(e) {
+        if (typeof e != "function")
+          throw new je(y);
+        return function() {
+          var t = arguments;
+          switch (t.length) {
+            case 0:
+              return !e.call(this);
+            case 1:
+              return !e.call(this, t[0]);
+            case 2:
+              return !e.call(this, t[0], t[1]);
+            case 3:
+              return !e.call(this, t[0], t[1], t[2]);
+          }
+          return !e.apply(this, t);
+        };
+      }
+      function Vh(e) {
+        return da(2, e);
+      }
+      var Hh = Od(function(e, t) {
+        t = t.length == 1 && Y(t[0]) ? ve(t[0], ze(U())) : ve(Le(t, 1), ze(U()));
+        var n = t.length;
+        return j(function(s) {
+          for (var l = -1, f = Me(s.length, n); ++l < f; )
+            s[l] = t[l].call(this, s[l]);
+          return Ze(e, this, s);
+        });
+      }), $s = j(function(e, t) {
+        var n = Wt(t, On($s));
+        return It(e, q, i, t, n);
+      }), ga = j(function(e, t) {
+        var n = Wt(t, On(ga));
+        return It(e, ge, i, t, n);
+      }), Gh = Rt(function(e, t) {
+        return It(e, At, i, i, i, t);
+      });
+      function Zh(e, t) {
+        if (typeof e != "function")
+          throw new je(y);
+        return t = t === i ? t : X(t), j(e, t);
+      }
+      function zh(e, t) {
+        if (typeof e != "function")
+          throw new je(y);
+        return t = t == null ? 0 : Oe(X(t), 0), j(function(n) {
+          var s = n[t], l = zt(n, 0, t);
+          return s && Ut(l, s), Ze(e, this, l);
+        });
+      }
+      function qh(e, t, n) {
+        var s = !0, l = !0;
+        if (typeof e != "function")
+          throw new je(y);
+        return me(n) && (s = "leading" in n ? !!n.leading : s, l = "trailing" in n ? !!n.trailing : l), va(e, t, {
+          leading: s,
+          maxWait: t,
+          trailing: l
+        });
+      }
+      function Kh(e) {
+        return fa(e, 1);
+      }
+      function Yh(e, t) {
+        return $s(as(t), e);
+      }
+      function Xh() {
+        if (!arguments.length)
+          return [];
+        var e = arguments[0];
+        return Y(e) ? e : [e];
+      }
+      function Jh(e) {
+        return tt(e, Q);
+      }
+      function Qh(e, t) {
+        return t = typeof t == "function" ? t : i, tt(e, Q, t);
+      }
+      function jh(e) {
+        return tt(e, C | Q);
+      }
+      function e_(e, t) {
+        return t = typeof t == "function" ? t : i, tt(e, C | Q, t);
+      }
+      function t_(e, t) {
+        return t == null || il(e, t, Ie(t));
+      }
+      function dt(e, t) {
+        return e === t || e !== e && t !== t;
+      }
+      var n_ = Kr(Xi), r_ = Kr(function(e, t) {
+        return e >= t;
+      }), cn = cl(function() {
+        return arguments;
+      }()) ? cl : function(e) {
+        return ke(e) && ce.call(e, "callee") && !Xo.call(e, "callee");
+      }, Y = w.isArray, i_ = Io ? ze(Io) : dd;
+      function We(e) {
+        return e != null && ri(e.length) && !Mt(e);
+      }
+      function xe(e) {
+        return ke(e) && We(e);
+      }
+      function s_(e) {
+        return e === !0 || e === !1 || ke(e) && Pe(e) == Pn;
+      }
+      var qt = yf || Bs, o_ = Ro ? ze(Ro) : pd;
+      function l_(e) {
+        return ke(e) && e.nodeType === 1 && !rr(e);
+      }
+      function a_(e) {
+        if (e == null)
+          return !0;
+        if (We(e) && (Y(e) || typeof e == "string" || typeof e.splice == "function" || qt(e) || En(e) || cn(e)))
+          return !e.length;
+        var t = Be(e);
+        if (t == at || t == ut)
+          return !e.size;
+        if (tr(e))
+          return !ji(e).length;
+        for (var n in e)
+          if (ce.call(e, n))
+            return !1;
+        return !0;
+      }
+      function u_(e, t) {
+        return Qn(e, t);
+      }
+      function c_(e, t, n) {
+        n = typeof n == "function" ? n : i;
+        var s = n ? n(e, t) : i;
+        return s === i ? Qn(e, t, i, n) : !!s;
+      }
+      function As(e) {
+        if (!ke(e))
+          return !1;
+        var t = Pe(e);
+        return t == _r || t == Ru || typeof e.message == "string" && typeof e.name == "string" && !rr(e);
+      }
+      function f_(e) {
+        return typeof e == "number" && Qo(e);
+      }
+      function Mt(e) {
+        if (!me(e))
+          return !1;
+        var t = Pe(e);
+        return t == vr || t == io || t == Iu || t == Mu;
+      }
+      function ma(e) {
+        return typeof e == "number" && e == X(e);
+      }
+      function ri(e) {
+        return typeof e == "number" && e > -1 && e % 1 == 0 && e <= Ft;
+      }
+      function me(e) {
+        var t = typeof e;
+        return e != null && (t == "object" || t == "function");
+      }
+      function ke(e) {
+        return e != null && typeof e == "object";
+      }
+      var ya = Lo ? ze(Lo) : _d;
+      function d_(e, t) {
+        return e === t || Qi(e, t, _s(t));
+      }
+      function p_(e, t, n) {
+        return n = typeof n == "function" ? n : i, Qi(e, t, _s(t), n);
+      }
+      function h_(e) {
+        return ba(e) && e != +e;
+      }
+      function __(e) {
+        if (Qd(e))
+          throw new K(p);
+        return fl(e);
+      }
+      function v_(e) {
+        return e === null;
+      }
+      function g_(e) {
+        return e == null;
+      }
+      function ba(e) {
+        return typeof e == "number" || ke(e) && Pe(e) == Fn;
+      }
+      function rr(e) {
+        if (!ke(e) || Pe(e) != Tt)
+          return !1;
+        var t = Er(e);
+        if (t === null)
+          return !0;
+        var n = ce.call(t, "constructor") && t.constructor;
+        return typeof n == "function" && n instanceof n && Sr.call(n) == pf;
+      }
+      var Ss = Mo ? ze(Mo) : vd;
+      function m_(e) {
+        return ma(e) && e >= -Ft && e <= Ft;
+      }
+      var wa = Bo ? ze(Bo) : gd;
+      function ii(e) {
+        return typeof e == "string" || !Y(e) && ke(e) && Pe(e) == Un;
+      }
+      function Ke(e) {
+        return typeof e == "symbol" || ke(e) && Pe(e) == gr;
+      }
+      var En = Po ? ze(Po) : md;
+      function y_(e) {
+        return e === i;
+      }
+      function b_(e) {
+        return ke(e) && Be(e) == Wn;
+      }
+      function w_(e) {
+        return ke(e) && Pe(e) == Pu;
+      }
+      var k_ = Kr(es), x_ = Kr(function(e, t) {
+        return e <= t;
+      });
+      function ka(e) {
+        if (!e)
+          return [];
+        if (We(e))
+          return ii(e) ? ct(e) : Ue(e);
+        if (Gn && e[Gn])
+          return ef(e[Gn]());
+        var t = Be(e), n = t == at ? Wi : t == ut ? xr : In;
+        return n(e);
+      }
+      function Bt(e) {
+        if (!e)
+          return e === 0 ? e : 0;
+        if (e = it(e), e === en || e === -en) {
+          var t = e < 0 ? -1 : 1;
+          return t * Tu;
+        }
+        return e === e ? e : 0;
+      }
+      function X(e) {
+        var t = Bt(e), n = t % 1;
+        return t === t ? n ? t - n : t : 0;
+      }
+      function xa(e) {
+        return e ? on(X(e), 0, gt) : 0;
+      }
+      function it(e) {
+        if (typeof e == "number")
+          return e;
+        if (Ke(e))
+          return pr;
+        if (me(e)) {
+          var t = typeof e.valueOf == "function" ? e.valueOf() : e;
+          e = me(t) ? t + "" : t;
+        }
+        if (typeof e != "string")
+          return e === 0 ? e : +e;
+        e = Vo(e);
+        var n = rc.test(e);
+        return n || sc.test(e) ? Dc(e.slice(2), n ? 2 : 8) : nc.test(e) ? pr : +e;
+      }
+      function $a(e) {
+        return yt(e, Ve(e));
+      }
+      function $_(e) {
+        return e ? on(X(e), -Ft, Ft) : e === 0 ? e : 0;
+      }
+      function ue(e) {
+        return e == null ? "" : qe(e);
+      }
+      var A_ = Tn(function(e, t) {
+        if (tr(t) || We(t)) {
+          yt(t, Ie(t), e);
+          return;
+        }
+        for (var n in t)
+          ce.call(t, n) && Yn(e, n, t[n]);
+      }), Aa = Tn(function(e, t) {
+        yt(t, Ve(t), e);
+      }), si = Tn(function(e, t, n, s) {
+        yt(t, Ve(t), e, s);
+      }), S_ = Tn(function(e, t, n, s) {
+        yt(t, Ie(t), e, s);
+      }), T_ = Rt(qi);
+      function C_(e, t) {
+        var n = Sn(e);
+        return t == null ? n : rl(n, t);
+      }
+      var O_ = j(function(e, t) {
+        e = de(e);
+        var n = -1, s = t.length, l = s > 2 ? t[2] : i;
+        for (l && De(t[0], t[1], l) && (s = 1); ++n < s; )
+          for (var f = t[n], d = Ve(f), h = -1, m = d.length; ++h < m; ) {
+            var x = d[h], $ = e[x];
+            ($ === i || dt($, xn[x]) && !ce.call(e, x)) && (e[x] = f[x]);
+          }
+        return e;
+      }), E_ = j(function(e) {
+        return e.push(i, Vl), Ze(Sa, i, e);
+      });
+      function I_(e, t) {
+        return Fo(e, U(t, 3), mt);
+      }
+      function R_(e, t) {
+        return Fo(e, U(t, 3), Yi);
+      }
+      function L_(e, t) {
+        return e == null ? e : Ki(e, U(t, 3), Ve);
+      }
+      function M_(e, t) {
+        return e == null ? e : al(e, U(t, 3), Ve);
+      }
+      function B_(e, t) {
+        return e && mt(e, U(t, 3));
+      }
+      function P_(e, t) {
+        return e && Yi(e, U(t, 3));
+      }
+      function D_(e) {
+        return e == null ? [] : Ur(e, Ie(e));
+      }
+      function F_(e) {
+        return e == null ? [] : Ur(e, Ve(e));
+      }
+      function Ts(e, t, n) {
+        var s = e == null ? i : ln(e, t);
+        return s === i ? n : s;
+      }
+      function N_(e, t) {
+        return e != null && Zl(e, t, ad);
+      }
+      function Cs(e, t) {
+        return e != null && Zl(e, t, ud);
+      }
+      var U_ = Dl(function(e, t, n) {
+        t != null && typeof t.toString != "function" && (t = Tr.call(t)), e[t] = n;
+      }, Es(He)), W_ = Dl(function(e, t, n) {
+        t != null && typeof t.toString != "function" && (t = Tr.call(t)), ce.call(e, t) ? e[t].push(n) : e[t] = [n];
+      }, U), V_ = j(Jn);
+      function Ie(e) {
+        return We(e) ? tl(e) : ji(e);
+      }
+      function Ve(e) {
+        return We(e) ? tl(e, !0) : yd(e);
+      }
+      function H_(e, t) {
+        var n = {};
+        return t = U(t, 3), mt(e, function(s, l, f) {
+          Et(n, t(s, l, f), s);
+        }), n;
+      }
+      function G_(e, t) {
+        var n = {};
+        return t = U(t, 3), mt(e, function(s, l, f) {
+          Et(n, l, t(s, l, f));
+        }), n;
+      }
+      var Z_ = Tn(function(e, t, n) {
+        Wr(e, t, n);
+      }), Sa = Tn(function(e, t, n, s) {
+        Wr(e, t, n, s);
+      }), z_ = Rt(function(e, t) {
+        var n = {};
+        if (e == null)
+          return n;
+        var s = !1;
+        t = ve(t, function(f) {
+          return f = Zt(f, e), s || (s = f.length > 1), f;
+        }), yt(e, ps(e), n), s && (n = tt(n, C | D | Q, Ud));
+        for (var l = t.length; l--; )
+          ss(n, t[l]);
+        return n;
+      });
+      function q_(e, t) {
+        return Ta(e, ni(U(t)));
+      }
+      var K_ = Rt(function(e, t) {
+        return e == null ? {} : wd(e, t);
+      });
+      function Ta(e, t) {
+        if (e == null)
+          return {};
+        var n = ve(ps(e), function(s) {
+          return [s];
+        });
+        return t = U(t), ml(e, n, function(s, l) {
+          return t(s, l[0]);
+        });
+      }
+      function Y_(e, t, n) {
+        t = Zt(t, e);
+        var s = -1, l = t.length;
+        for (l || (l = 1, e = i); ++s < l; ) {
+          var f = e == null ? i : e[bt(t[s])];
+          f === i && (s = l, f = n), e = Mt(f) ? f.call(e) : f;
+        }
+        return e;
+      }
+      function X_(e, t, n) {
+        return e == null ? e : jn(e, t, n);
+      }
+      function J_(e, t, n, s) {
+        return s = typeof s == "function" ? s : i, e == null ? e : jn(e, t, n, s);
+      }
+      var Ca = Ul(Ie), Oa = Ul(Ve);
+      function Q_(e, t, n) {
+        var s = Y(e), l = s || qt(e) || En(e);
+        if (t = U(t, 4), n == null) {
+          var f = e && e.constructor;
+          l ? n = s ? new f() : [] : me(e) ? n = Mt(f) ? Sn(Er(e)) : {} : n = {};
+        }
+        return (l ? Qe : mt)(e, function(d, h, m) {
+          return t(n, d, h, m);
+        }), n;
+      }
+      function j_(e, t) {
+        return e == null ? !0 : ss(e, t);
+      }
+      function ev(e, t, n) {
+        return e == null ? e : xl(e, t, as(n));
+      }
+      function tv(e, t, n, s) {
+        return s = typeof s == "function" ? s : i, e == null ? e : xl(e, t, as(n), s);
+      }
+      function In(e) {
+        return e == null ? [] : Ui(e, Ie(e));
+      }
+      function nv(e) {
+        return e == null ? [] : Ui(e, Ve(e));
+      }
+      function rv(e, t, n) {
+        return n === i && (n = t, t = i), n !== i && (n = it(n), n = n === n ? n : 0), t !== i && (t = it(t), t = t === t ? t : 0), on(it(e), t, n);
+      }
+      function iv(e, t, n) {
+        return t = Bt(t), n === i ? (n = t, t = 0) : n = Bt(n), e = it(e), cd(e, t, n);
+      }
+      function sv(e, t, n) {
+        if (n && typeof n != "boolean" && De(e, t, n) && (t = n = i), n === i && (typeof t == "boolean" ? (n = t, t = i) : typeof e == "boolean" && (n = e, e = i)), e === i && t === i ? (e = 0, t = 1) : (e = Bt(e), t === i ? (t = e, e = 0) : t = Bt(t)), e > t) {
+          var s = e;
+          e = t, t = s;
+        }
+        if (n || e % 1 || t % 1) {
+          var l = jo();
+          return Me(e + l * (t - e + Pc("1e-" + ((l + "").length - 1))), t);
+        }
+        return ns(e, t);
+      }
+      var ov = Cn(function(e, t, n) {
+        return t = t.toLowerCase(), e + (n ? Ea(t) : t);
+      });
+      function Ea(e) {
+        return Os(ue(e).toLowerCase());
+      }
+      function Ia(e) {
+        return e = ue(e), e && e.replace(lc, Yc).replace(Sc, "");
+      }
+      function lv(e, t, n) {
+        e = ue(e), t = qe(t);
+        var s = e.length;
+        n = n === i ? s : on(X(n), 0, s);
+        var l = n;
+        return n -= t.length, n >= 0 && e.slice(n, l) == t;
+      }
+      function av(e) {
+        return e = ue(e), e && Wu.test(e) ? e.replace(lo, Xc) : e;
+      }
+      function uv(e) {
+        return e = ue(e), e && qu.test(e) ? e.replace($i, "\\$&") : e;
+      }
+      var cv = Cn(function(e, t, n) {
+        return e + (n ? "-" : "") + t.toLowerCase();
+      }), fv = Cn(function(e, t, n) {
+        return e + (n ? " " : "") + t.toLowerCase();
+      }), dv = Ml("toLowerCase");
+      function pv(e, t, n) {
+        e = ue(e), t = X(t);
+        var s = t ? wn(e) : 0;
+        if (!t || s >= t)
+          return e;
+        var l = (t - s) / 2;
+        return qr(Mr(l), n) + e + qr(Lr(l), n);
+      }
+      function hv(e, t, n) {
+        e = ue(e), t = X(t);
+        var s = t ? wn(e) : 0;
+        return t && s < t ? e + qr(t - s, n) : e;
+      }
+      function _v(e, t, n) {
+        e = ue(e), t = X(t);
+        var s = t ? wn(e) : 0;
+        return t && s < t ? qr(t - s, n) + e : e;
+      }
+      function vv(e, t, n) {
+        return n || t == null ? t = 0 : t && (t = +t), xf(ue(e).replace(Ai, ""), t || 0);
+      }
+      function gv(e, t, n) {
+        return (n ? De(e, t, n) : t === i) ? t = 1 : t = X(t), rs(ue(e), t);
+      }
+      function mv() {
+        var e = arguments, t = ue(e[0]);
+        return e.length < 3 ? t : t.replace(e[1], e[2]);
+      }
+      var yv = Cn(function(e, t, n) {
+        return e + (n ? "_" : "") + t.toLowerCase();
+      });
+      function bv(e, t, n) {
+        return n && typeof n != "number" && De(e, t, n) && (t = n = i), n = n === i ? gt : n >>> 0, n ? (e = ue(e), e && (typeof t == "string" || t != null && !Ss(t)) && (t = qe(t), !t && bn(e)) ? zt(ct(e), 0, n) : e.split(t, n)) : [];
+      }
+      var wv = Cn(function(e, t, n) {
+        return e + (n ? " " : "") + Os(t);
+      });
+      function kv(e, t, n) {
+        return e = ue(e), n = n == null ? 0 : on(X(n), 0, e.length), t = qe(t), e.slice(n, n + t.length) == t;
+      }
+      function xv(e, t, n) {
+        var s = u.templateSettings;
+        n && De(e, t, n) && (t = i), e = ue(e), t = si({}, t, s, Wl);
+        var l = si({}, t.imports, s.imports, Wl), f = Ie(l), d = Ui(l, f), h, m, x = 0, $ = t.interpolate || mr, A = "__p += '", I = Vi(
+          (t.escape || mr).source + "|" + $.source + "|" + ($ === ao ? tc : mr).source + "|" + (t.evaluate || mr).source + "|$",
+          "g"
+        ), P = "//# sourceURL=" + (ce.call(t, "sourceURL") ? (t.sourceURL + "").replace(/\s/g, " ") : "lodash.templateSources[" + ++Ic + "]") + `
+`;
+        e.replace(I, function(G, te, re, Ye, Fe, Xe) {
+          return re || (re = Ye), A += e.slice(x, Xe).replace(ac, Jc), te && (h = !0, A += `' +
+__e(` + te + `) +
+'`), Fe && (m = !0, A += `';
+` + Fe + `;
+__p += '`), re && (A += `' +
+((__t = (` + re + `)) == null ? '' : __t) +
+'`), x = Xe + G.length, G;
+        }), A += `';
+`;
+        var H = ce.call(t, "variable") && t.variable;
+        if (!H)
+          A = `with (obj) {
+` + A + `
+}
+`;
+        else if (ju.test(H))
+          throw new K(b);
+        A = (m ? A.replace(Du, "") : A).replace(Fu, "$1").replace(Nu, "$1;"), A = "function(" + (H || "obj") + `) {
+` + (H ? "" : `obj || (obj = {});
+`) + "var __t, __p = ''" + (h ? ", __e = _.escape" : "") + (m ? `, __j = Array.prototype.join;
+function print() { __p += __j.call(arguments, '') }
+` : `;
+`) + A + `return __p
+}`;
+        var J = La(function() {
+          return le(f, P + "return " + A).apply(i, d);
+        });
+        if (J.source = A, As(J))
+          throw J;
+        return J;
+      }
+      function $v(e) {
+        return ue(e).toLowerCase();
+      }
+      function Av(e) {
+        return ue(e).toUpperCase();
+      }
+      function Sv(e, t, n) {
+        if (e = ue(e), e && (n || t === i))
+          return Vo(e);
+        if (!e || !(t = qe(t)))
+          return e;
+        var s = ct(e), l = ct(t), f = Ho(s, l), d = Go(s, l) + 1;
+        return zt(s, f, d).join("");
+      }
+      function Tv(e, t, n) {
+        if (e = ue(e), e && (n || t === i))
+          return e.slice(0, zo(e) + 1);
+        if (!e || !(t = qe(t)))
+          return e;
+        var s = ct(e), l = Go(s, ct(t)) + 1;
+        return zt(s, 0, l).join("");
+      }
+      function Cv(e, t, n) {
+        if (e = ue(e), e && (n || t === i))
+          return e.replace(Ai, "");
+        if (!e || !(t = qe(t)))
+          return e;
+        var s = ct(e), l = Ho(s, ct(t));
+        return zt(s, l).join("");
+      }
+      function Ov(e, t) {
+        var n = N, s = Te;
+        if (me(t)) {
+          var l = "separator" in t ? t.separator : l;
+          n = "length" in t ? X(t.length) : n, s = "omission" in t ? qe(t.omission) : s;
+        }
+        e = ue(e);
+        var f = e.length;
+        if (bn(e)) {
+          var d = ct(e);
+          f = d.length;
+        }
+        if (n >= f)
+          return e;
+        var h = n - wn(s);
+        if (h < 1)
+          return s;
+        var m = d ? zt(d, 0, h).join("") : e.slice(0, h);
+        if (l === i)
+          return m + s;
+        if (d && (h += m.length - h), Ss(l)) {
+          if (e.slice(h).search(l)) {
+            var x, $ = m;
+            for (l.global || (l = Vi(l.source, ue(uo.exec(l)) + "g")), l.lastIndex = 0; x = l.exec($); )
+              var A = x.index;
+            m = m.slice(0, A === i ? h : A);
+          }
+        } else if (e.indexOf(qe(l), h) != h) {
+          var I = m.lastIndexOf(l);
+          I > -1 && (m = m.slice(0, I));
+        }
+        return m + s;
+      }
+      function Ev(e) {
+        return e = ue(e), e && Uu.test(e) ? e.replace(oo, sf) : e;
+      }
+      var Iv = Cn(function(e, t, n) {
+        return e + (n ? " " : "") + t.toUpperCase();
+      }), Os = Ml("toUpperCase");
+      function Ra(e, t, n) {
+        return e = ue(e), t = n ? i : t, t === i ? jc(e) ? af(e) : Gc(e) : e.match(t) || [];
+      }
+      var La = j(function(e, t) {
+        try {
+          return Ze(e, i, t);
+        } catch (n) {
+          return As(n) ? n : new K(n);
+        }
+      }), Rv = Rt(function(e, t) {
+        return Qe(t, function(n) {
+          n = bt(n), Et(e, n, xs(e[n], e));
+        }), e;
+      });
+      function Lv(e) {
+        var t = e == null ? 0 : e.length, n = U();
+        return e = t ? ve(e, function(s) {
+          if (typeof s[1] != "function")
+            throw new je(y);
+          return [n(s[0]), s[1]];
+        }) : [], j(function(s) {
+          for (var l = -1; ++l < t; ) {
+            var f = e[l];
+            if (Ze(f[0], this, s))
+              return Ze(f[1], this, s);
+          }
+        });
+      }
+      function Mv(e) {
+        return sd(tt(e, C));
+      }
+      function Es(e) {
+        return function() {
+          return e;
+        };
+      }
+      function Bv(e, t) {
+        return e == null || e !== e ? t : e;
+      }
+      var Pv = Pl(), Dv = Pl(!0);
+      function He(e) {
+        return e;
+      }
+      function Is(e) {
+        return dl(typeof e == "function" ? e : tt(e, C));
+      }
+      function Fv(e) {
+        return hl(tt(e, C));
+      }
+      function Nv(e, t) {
+        return _l(e, tt(t, C));
+      }
+      var Uv = j(function(e, t) {
+        return function(n) {
+          return Jn(n, e, t);
+        };
+      }), Wv = j(function(e, t) {
+        return function(n) {
+          return Jn(e, n, t);
+        };
+      });
+      function Rs(e, t, n) {
+        var s = Ie(t), l = Ur(t, s);
+        n == null && !(me(t) && (l.length || !s.length)) && (n = t, t = e, e = this, l = Ur(t, Ie(t)));
+        var f = !(me(n) && "chain" in n) || !!n.chain, d = Mt(e);
+        return Qe(l, function(h) {
+          var m = t[h];
+          e[h] = m, d && (e.prototype[h] = function() {
+            var x = this.__chain__;
+            if (f || x) {
+              var $ = e(this.__wrapped__), A = $.__actions__ = Ue(this.__actions__);
+              return A.push({ func: m, args: arguments, thisArg: e }), $.__chain__ = x, $;
+            }
+            return m.apply(e, Ut([this.value()], arguments));
+          });
+        }), e;
+      }
+      function Vv() {
+        return Re._ === this && (Re._ = hf), this;
+      }
+      function Ls() {
+      }
+      function Hv(e) {
+        return e = X(e), j(function(t) {
+          return vl(t, e);
+        });
+      }
+      var Gv = cs(ve), Zv = cs(Do), zv = cs(Bi);
+      function Ma(e) {
+        return gs(e) ? Pi(bt(e)) : kd(e);
+      }
+      function qv(e) {
+        return function(t) {
+          return e == null ? i : ln(e, t);
+        };
+      }
+      var Kv = Fl(), Yv = Fl(!0);
+      function Ms() {
+        return [];
+      }
+      function Bs() {
+        return !1;
+      }
+      function Xv() {
+        return {};
+      }
+      function Jv() {
+        return "";
+      }
+      function Qv() {
+        return !0;
+      }
+      function jv(e, t) {
+        if (e = X(e), e < 1 || e > Ft)
+          return [];
+        var n = gt, s = Me(e, gt);
+        t = U(t), e -= gt;
+        for (var l = Ni(s, t); ++n < e; )
+          t(n);
+        return l;
+      }
+      function eg(e) {
+        return Y(e) ? ve(e, bt) : Ke(e) ? [e] : Ue(ea(ue(e)));
+      }
+      function tg(e) {
+        var t = ++df;
+        return ue(e) + t;
+      }
+      var ng = zr(function(e, t) {
+        return e + t;
+      }, 0), rg = fs("ceil"), ig = zr(function(e, t) {
+        return e / t;
+      }, 1), sg = fs("floor");
+      function og(e) {
+        return e && e.length ? Nr(e, He, Xi) : i;
+      }
+      function lg(e, t) {
+        return e && e.length ? Nr(e, U(t, 2), Xi) : i;
+      }
+      function ag(e) {
+        return Uo(e, He);
+      }
+      function ug(e, t) {
+        return Uo(e, U(t, 2));
+      }
+      function cg(e) {
+        return e && e.length ? Nr(e, He, es) : i;
+      }
+      function fg(e, t) {
+        return e && e.length ? Nr(e, U(t, 2), es) : i;
+      }
+      var dg = zr(function(e, t) {
+        return e * t;
+      }, 1), pg = fs("round"), hg = zr(function(e, t) {
+        return e - t;
+      }, 0);
+      function _g(e) {
+        return e && e.length ? Fi(e, He) : 0;
+      }
+      function vg(e, t) {
+        return e && e.length ? Fi(e, U(t, 2)) : 0;
+      }
+      return u.after = Fh, u.ary = fa, u.assign = A_, u.assignIn = Aa, u.assignInWith = si, u.assignWith = S_, u.at = T_, u.before = da, u.bind = xs, u.bindAll = Rv, u.bindKey = pa, u.castArray = Xh, u.chain = aa, u.chunk = sp, u.compact = op, u.concat = lp, u.cond = Lv, u.conforms = Mv, u.constant = Es, u.countBy = _h, u.create = C_, u.curry = ha, u.curryRight = _a, u.debounce = va, u.defaults = O_, u.defaultsDeep = E_, u.defer = Nh, u.delay = Uh, u.difference = ap, u.differenceBy = up, u.differenceWith = cp, u.drop = fp, u.dropRight = dp, u.dropRightWhile = pp, u.dropWhile = hp, u.fill = _p, u.filter = gh, u.flatMap = bh, u.flatMapDeep = wh, u.flatMapDepth = kh, u.flatten = ia, u.flattenDeep = vp, u.flattenDepth = gp, u.flip = Wh, u.flow = Pv, u.flowRight = Dv, u.fromPairs = mp, u.functions = D_, u.functionsIn = F_, u.groupBy = xh, u.initial = bp, u.intersection = wp, u.intersectionBy = kp, u.intersectionWith = xp, u.invert = U_, u.invertBy = W_, u.invokeMap = Ah, u.iteratee = Is, u.keyBy = Sh, u.keys = Ie, u.keysIn = Ve, u.map = jr, u.mapKeys = H_, u.mapValues = G_, u.matches = Fv, u.matchesProperty = Nv, u.memoize = ti, u.merge = Z_, u.mergeWith = Sa, u.method = Uv, u.methodOf = Wv, u.mixin = Rs, u.negate = ni, u.nthArg = Hv, u.omit = z_, u.omitBy = q_, u.once = Vh, u.orderBy = Th, u.over = Gv, u.overArgs = Hh, u.overEvery = Zv, u.overSome = zv, u.partial = $s, u.partialRight = ga, u.partition = Ch, u.pick = K_, u.pickBy = Ta, u.property = Ma, u.propertyOf = qv, u.pull = Tp, u.pullAll = oa, u.pullAllBy = Cp, u.pullAllWith = Op, u.pullAt = Ep, u.range = Kv, u.rangeRight = Yv, u.rearg = Gh, u.reject = Ih, u.remove = Ip, u.rest = Zh, u.reverse = ws, u.sampleSize = Lh, u.set = X_, u.setWith = J_, u.shuffle = Mh, u.slice = Rp, u.sortBy = Dh, u.sortedUniq = Np, u.sortedUniqBy = Up, u.split = bv, u.spread = zh, u.tail = Wp, u.take = Vp, u.takeRight = Hp, u.takeRightWhile = Gp, u.takeWhile = Zp, u.tap = oh, u.throttle = qh, u.thru = Qr, u.toArray = ka, u.toPairs = Ca, u.toPairsIn = Oa, u.toPath = eg, u.toPlainObject = $a, u.transform = Q_, u.unary = Kh, u.union = zp, u.unionBy = qp, u.unionWith = Kp, u.uniq = Yp, u.uniqBy = Xp, u.uniqWith = Jp, u.unset = j_, u.unzip = ks, u.unzipWith = la, u.update = ev, u.updateWith = tv, u.values = In, u.valuesIn = nv, u.without = Qp, u.words = Ra, u.wrap = Yh, u.xor = jp, u.xorBy = eh, u.xorWith = th, u.zip = nh, u.zipObject = rh, u.zipObjectDeep = ih, u.zipWith = sh, u.entries = Ca, u.entriesIn = Oa, u.extend = Aa, u.extendWith = si, Rs(u, u), u.add = ng, u.attempt = La, u.camelCase = ov, u.capitalize = Ea, u.ceil = rg, u.clamp = rv, u.clone = Jh, u.cloneDeep = jh, u.cloneDeepWith = e_, u.cloneWith = Qh, u.conformsTo = t_, u.deburr = Ia, u.defaultTo = Bv, u.divide = ig, u.endsWith = lv, u.eq = dt, u.escape = av, u.escapeRegExp = uv, u.every = vh, u.find = mh, u.findIndex = na, u.findKey = I_, u.findLast = yh, u.findLastIndex = ra, u.findLastKey = R_, u.floor = sg, u.forEach = ua, u.forEachRight = ca, u.forIn = L_, u.forInRight = M_, u.forOwn = B_, u.forOwnRight = P_, u.get = Ts, u.gt = n_, u.gte = r_, u.has = N_, u.hasIn = Cs, u.head = sa, u.identity = He, u.includes = $h, u.indexOf = yp, u.inRange = iv, u.invoke = V_, u.isArguments = cn, u.isArray = Y, u.isArrayBuffer = i_, u.isArrayLike = We, u.isArrayLikeObject = xe, u.isBoolean = s_, u.isBuffer = qt, u.isDate = o_, u.isElement = l_, u.isEmpty = a_, u.isEqual = u_, u.isEqualWith = c_, u.isError = As, u.isFinite = f_, u.isFunction = Mt, u.isInteger = ma, u.isLength = ri, u.isMap = ya, u.isMatch = d_, u.isMatchWith = p_, u.isNaN = h_, u.isNative = __, u.isNil = g_, u.isNull = v_, u.isNumber = ba, u.isObject = me, u.isObjectLike = ke, u.isPlainObject = rr, u.isRegExp = Ss, u.isSafeInteger = m_, u.isSet = wa, u.isString = ii, u.isSymbol = Ke, u.isTypedArray = En, u.isUndefined = y_, u.isWeakMap = b_, u.isWeakSet = w_, u.join = $p, u.kebabCase = cv, u.last = rt, u.lastIndexOf = Ap, u.lowerCase = fv, u.lowerFirst = dv, u.lt = k_, u.lte = x_, u.max = og, u.maxBy = lg, u.mean = ag, u.meanBy = ug, u.min = cg, u.minBy = fg, u.stubArray = Ms, u.stubFalse = Bs, u.stubObject = Xv, u.stubString = Jv, u.stubTrue = Qv, u.multiply = dg, u.nth = Sp, u.noConflict = Vv, u.noop = Ls, u.now = ei, u.pad = pv, u.padEnd = hv, u.padStart = _v, u.parseInt = vv, u.random = sv, u.reduce = Oh, u.reduceRight = Eh, u.repeat = gv, u.replace = mv, u.result = Y_, u.round = pg, u.runInContext = v, u.sample = Rh, u.size = Bh, u.snakeCase = yv, u.some = Ph, u.sortedIndex = Lp, u.sortedIndexBy = Mp, u.sortedIndexOf = Bp, u.sortedLastIndex = Pp, u.sortedLastIndexBy = Dp, u.sortedLastIndexOf = Fp, u.startCase = wv, u.startsWith = kv, u.subtract = hg, u.sum = _g, u.sumBy = vg, u.template = xv, u.times = jv, u.toFinite = Bt, u.toInteger = X, u.toLength = xa, u.toLower = $v, u.toNumber = it, u.toSafeInteger = $_, u.toString = ue, u.toUpper = Av, u.trim = Sv, u.trimEnd = Tv, u.trimStart = Cv, u.truncate = Ov, u.unescape = Ev, u.uniqueId = tg, u.upperCase = Iv, u.upperFirst = Os, u.each = ua, u.eachRight = ca, u.first = sa, Rs(u, function() {
+        var e = {};
+        return mt(u, function(t, n) {
+          ce.call(u.prototype, n) || (e[n] = t);
+        }), e;
+      }(), { chain: !1 }), u.VERSION = c, Qe(["bind", "bindKey", "curry", "curryRight", "partial", "partialRight"], function(e) {
+        u[e].placeholder = u;
+      }), Qe(["drop", "take"], function(e, t) {
+        ne.prototype[e] = function(n) {
+          n = n === i ? 1 : Oe(X(n), 0);
+          var s = this.__filtered__ && !t ? new ne(this) : this.clone();
+          return s.__filtered__ ? s.__takeCount__ = Me(n, s.__takeCount__) : s.__views__.push({
+            size: Me(n, gt),
+            type: e + (s.__dir__ < 0 ? "Right" : "")
+          }), s;
+        }, ne.prototype[e + "Right"] = function(n) {
+          return this.reverse()[e](n).reverse();
+        };
+      }), Qe(["filter", "map", "takeWhile"], function(e, t) {
+        var n = t + 1, s = n == jt || n == Su;
+        ne.prototype[e] = function(l) {
+          var f = this.clone();
+          return f.__iteratees__.push({
+            iteratee: U(l, 3),
+            type: n
+          }), f.__filtered__ = f.__filtered__ || s, f;
+        };
+      }), Qe(["head", "last"], function(e, t) {
+        var n = "take" + (t ? "Right" : "");
+        ne.prototype[e] = function() {
+          return this[n](1).value()[0];
+        };
+      }), Qe(["initial", "tail"], function(e, t) {
+        var n = "drop" + (t ? "" : "Right");
+        ne.prototype[e] = function() {
+          return this.__filtered__ ? new ne(this) : this[n](1);
+        };
+      }), ne.prototype.compact = function() {
+        return this.filter(He);
+      }, ne.prototype.find = function(e) {
+        return this.filter(e).head();
+      }, ne.prototype.findLast = function(e) {
+        return this.reverse().find(e);
+      }, ne.prototype.invokeMap = j(function(e, t) {
+        return typeof e == "function" ? new ne(this) : this.map(function(n) {
+          return Jn(n, e, t);
+        });
+      }), ne.prototype.reject = function(e) {
+        return this.filter(ni(U(e)));
+      }, ne.prototype.slice = function(e, t) {
+        e = X(e);
+        var n = this;
+        return n.__filtered__ && (e > 0 || t < 0) ? new ne(n) : (e < 0 ? n = n.takeRight(-e) : e && (n = n.drop(e)), t !== i && (t = X(t), n = t < 0 ? n.dropRight(-t) : n.take(t - e)), n);
+      }, ne.prototype.takeRightWhile = function(e) {
+        return this.reverse().takeWhile(e).reverse();
+      }, ne.prototype.toArray = function() {
+        return this.take(gt);
+      }, mt(ne.prototype, function(e, t) {
+        var n = /^(?:filter|find|map|reject)|While$/.test(t), s = /^(?:head|last)$/.test(t), l = u[s ? "take" + (t == "last" ? "Right" : "") : t], f = s || /^find/.test(t);
+        l && (u.prototype[t] = function() {
+          var d = this.__wrapped__, h = s ? [1] : arguments, m = d instanceof ne, x = h[0], $ = m || Y(d), A = function(te) {
+            var re = l.apply(u, Ut([te], h));
+            return s && I ? re[0] : re;
+          };
+          $ && n && typeof x == "function" && x.length != 1 && (m = $ = !1);
+          var I = this.__chain__, P = !!this.__actions__.length, H = f && !I, J = m && !P;
+          if (!f && $) {
+            d = J ? d : new ne(this);
+            var G = e.apply(d, h);
+            return G.__actions__.push({ func: Qr, args: [A], thisArg: i }), new et(G, I);
+          }
+          return H && J ? e.apply(this, h) : (G = this.thru(A), H ? s ? G.value()[0] : G.value() : G);
+        });
+      }), Qe(["pop", "push", "shift", "sort", "splice", "unshift"], function(e) {
+        var t = $r[e], n = /^(?:push|sort|unshift)$/.test(e) ? "tap" : "thru", s = /^(?:pop|shift)$/.test(e);
+        u.prototype[e] = function() {
+          var l = arguments;
+          if (s && !this.__chain__) {
+            var f = this.value();
+            return t.apply(Y(f) ? f : [], l);
+          }
+          return this[n](function(d) {
+            return t.apply(Y(d) ? d : [], l);
+          });
+        };
+      }), mt(ne.prototype, function(e, t) {
+        var n = u[t];
+        if (n) {
+          var s = n.name + "";
+          ce.call(An, s) || (An[s] = []), An[s].push({ name: t, func: n });
+        }
+      }), An[Zr(i, W).name] = [{
+        name: "wrapper",
+        func: i
+      }], ne.prototype.clone = Ef, ne.prototype.reverse = If, ne.prototype.value = Rf, u.prototype.at = lh, u.prototype.chain = ah, u.prototype.commit = uh, u.prototype.next = ch, u.prototype.plant = dh, u.prototype.reverse = ph, u.prototype.toJSON = u.prototype.valueOf = u.prototype.value = hh, u.prototype.first = u.prototype.head, Gn && (u.prototype[Gn] = fh), u;
+    }, kn = uf();
+    tn ? ((tn.exports = kn)._ = kn, Ii._ = kn) : Re._ = kn;
+  }).call(ir);
+})(li, li.exports);
+var Jg = li.exports;
+const Qg = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "24",
+  height: "24",
+  fill: "none"
+}, jg = /* @__PURE__ */ z("path", {
+  stroke: "#1AB248",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "2",
+  d: "m5 12 5 5L20 7"
+}, null, -1), e0 = [
+  jg
+];
+function t0(r, o) {
+  return S(), R("svg", Qg, e0);
+}
+const n0 = { render: t0 }, r0 = /* @__PURE__ */ se({
+  __name: "BaseDropdownItem",
+  props: {
+    value: {},
+    selected: { type: Boolean, default: !1 },
+    active: { type: Boolean, default: !1 }
+  },
+  emits: ["select"],
+  setup(r, { emit: o }) {
+    const i = r, c = B(() => ({ "--list-item-color": i.value.color })), a = () => {
+      i.value.disabled || o("select", i.value);
+    };
+    return (p, y) => (S(), R("div", {
+      class: M([
+        p.$style["prefix-dropdown-item"],
+        {
+          [p.$style["prefix-dropdown-item_active"]]: p.active,
+          [p.$style["prefix-dropdown-item_selected"]]: p.selected,
+          [p.$style["prefix-dropdown-item_disabled"]]: p.value.disabled,
+          [p.$style["prefix-dropdown-item_colored"]]: !!p.value.color
+        }
+      ]),
+      onClick: a,
+      style: Zs(c.value)
+    }, [
+      p.value.icon ? (S(), R("div", {
+        key: 0,
+        class: M(p.$style["prefix-dropdown-item__left-icon"])
+      }, [
+        (S(), pe(Xt(p.value.icon)))
+      ], 2)) : ae("", !0),
+      z("div", {
+        class: M(p.$style["prefix-dropdown-item__content"])
+      }, [
+        fe(p.$slots, "default", {}, void 0, !0)
+      ], 2),
+      p.selected ? (S(), pe(ie(n0), {
+        key: 1,
+        class: M(p.$style["prefix-dropdown-item__checkmark"])
+      }, null, 8, ["class"])) : ae("", !0)
+    ], 6));
+  }
+}), i0 = {
+  "prefix-dropdown-item": "cdek-dropdown-item",
+  "prefix-dropdown-item_disabled": "cdek-dropdown-item_disabled",
+  "prefix-dropdown-item_active": "cdek-dropdown-item_active",
+  "prefix-dropdown-item_selected": "cdek-dropdown-item_selected",
+  "prefix-dropdown-item_colored": "cdek-dropdown-item_colored",
+  "prefix-dropdown-item__left-icon": "cdek-dropdown-item__left-icon",
+  "prefix-dropdown-item__content": "cdek-dropdown-item__content",
+  "prefix-dropdown-item__checkmark": "cdek-dropdown-item__checkmark"
+}, s0 = {
+  $style: i0
+}, Ya = /* @__PURE__ */ Ae(r0, [["__cssModules", s0], ["__scopeId", "data-v-c47f41d4"]]), o0 = {
+  "prefix-dropdown-box": "cdek-dropdown-box"
+}, l0 = {};
+function a0(r, o) {
+  return S(), R("div", {
+    class: M(r.$style["prefix-dropdown-box"])
+  }, [
+    fe(r.$slots, "default", {}, void 0, !0)
+  ], 2);
+}
+const u0 = {
+  $style: o0
+}, Xa = /* @__PURE__ */ Ae(l0, [["render", a0], ["__cssModules", u0], ["__scopeId", "data-v-91fbc94e"]]), c0 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "16",
+  height: "16",
+  fill: "none"
+}, f0 = /* @__PURE__ */ z("path", {
+  stroke: "#F47500",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "1.5",
+  d: "M8 6v1.333M8 10v.007m-4.667 2.66h9.334a1.332 1.332 0 0 0 1.226-1.833L9.16 2.667a1.333 1.333 0 0 0-2.333 0l-4.734 8.167a1.333 1.333 0 0 0 1.167 1.833"
+}, null, -1), d0 = [
+  f0
+];
+function p0(r, o) {
+  return S(), R("svg", c0, d0);
+}
+const h0 = { render: p0 }, _0 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "16",
+  height: "16",
+  fill: "none"
+}, v0 = /* @__PURE__ */ z("path", {
+  stroke: "#E40029",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "1.5",
+  d: "m3.8 3.8 8.4 8.4M14 8A6 6 0 1 1 2 8a6 6 0 0 1 12 0Z"
+}, null, -1), g0 = [
+  v0
+];
+function m0(r, o) {
+  return S(), R("svg", _0, g0);
+}
+const y0 = { render: m0 }, b0 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "16",
+  height: "16",
+  fill: "none"
+}, w0 = /* @__PURE__ */ z("path", {
+  stroke: "#17A000",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "1.5",
+  d: "m6 8 1.333 1.333L10 6.667M14 8A6 6 0 1 1 2 8a6 6 0 0 1 12 0Z"
+}, null, -1), k0 = [
+  w0
+];
+function x0(r, o) {
+  return S(), R("svg", b0, k0);
+}
+const $0 = { render: x0 }, A0 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "16",
+  height: "16",
+  fill: "none"
+}, S0 = /* @__PURE__ */ z("path", {
+  stroke: "#627791",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "1.5",
+  d: "M8 5.333h.007M7.333 8H8v2.667h.667M14 8A6 6 0 1 1 2 8a6 6 0 0 1 12 0Z"
+}, null, -1), T0 = [
+  S0
+];
+function C0(r, o) {
+  return S(), R("svg", A0, T0);
+}
+const O0 = { render: C0 }, E0 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "24",
+  height: "24",
+  fill: "none"
+}, I0 = /* @__PURE__ */ z("path", {
+  stroke: "#000",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-opacity": ".35",
+  "stroke-width": "1.75",
+  d: "m10 10 4 4m0-4-4 4m11-2a9 9 0 1 1-18 0 9 9 0 0 1 18 0Z"
+}, null, -1), R0 = [
+  I0
+];
+function L0(r, o) {
+  return S(), R("svg", E0, R0);
+}
+const M0 = { render: L0 }, B0 = ["value", "disabled"], P0 = ["innerHTML"], D0 = {
+  inheritAttrs: !1
+}, F0 = /* @__PURE__ */ se({
+  ...D0,
+  __name: "BaseInput",
+  props: {
+    modelValue: {},
+    label: {},
+    validRes: { type: [Boolean, String] },
+    hideErrorMessage: { type: Boolean },
+    disabled: { type: Boolean },
+    readonly: { type: Boolean },
+    small: { type: Boolean },
+    clearable: { type: Boolean },
+    class: { default: "" }
+  },
+  emits: ["update:modelValue"],
+  setup(r, { expose: o, emit: i }) {
+    const c = r, a = B(() => typeof c.validRes == "string"), p = B(() => !c.disabled && !c.readonly), y = B(() => c.modelValue), b = (O) => {
+      i("update:modelValue", O.target.value);
+    }, T = () => {
+      i("update:modelValue", "");
+    }, g = cr(), _ = B(() => !!g["icons-right"]), C = B(() => !!g["icons-left"]), D = oe(), Q = B(() => c.clearable && y.value);
+    return o({ getControl: () => D.value }), (O, E) => (S(), R("div", {
+      class: M([
+        O.$style["prefix-input"],
+        O.small && O.label ? O.$style["prefix-input_small"] : "",
+        c.class
+      ])
+    }, [
+      z("label", {
+        class: M([
+          O.$style["prefix-input__control"],
+          a.value ? O.$style["prefix-input__control_error"] : "",
+          p.value ? O.$style["prefix-input__control_user-event"] : "",
+          O.disabled ? O.$style["prefix-input__control_disabled"] : "",
+          O.readonly ? O.$style["prefix-input__control_readonly"] : "",
+          _.value ? O.$style["prefix-input__control_right-icon"] : "",
+          O.small ? O.$style["prefix-input__control_small"] : "",
+          Q.value ? O.$style["prefix-input__control_clearable"] : ""
+        ])
+      }, [
+        O.label ? (S(), R("div", {
+          key: 0,
+          class: M([
+            O.$style["prefix-input__label"],
+            y.value ? O.$style["prefix-input__label_filled"] : "",
+            a.value ? O.$style["prefix-input__label_error"] : "",
+            O.readonly ? O.$style["prefix-input__label_readonly"] : "",
+            O.small ? O.$style["prefix-input__label_small"] : ""
+          ])
+        }, we(O.label), 3)) : ae("", !0),
+        C.value ? (S(), R("div", {
+          key: 1,
+          class: M(O.$style["prefix-input__left-icon"])
+        }, [
+          fe(O.$slots, "icons-left")
+        ], 2)) : ae("", !0),
+        z("input", Qt({
+          class: [
+            O.$style["prefix-input__input"],
+            a.value ? O.$style["prefix-input__input_error"] : "",
+            O.readonly ? O.$style["prefix-input__input_readonly"] : "",
+            O.label ? "" : O.$style["prefix-input__input_no-label"],
+            O.small ? O.$style["prefix-input__input_small"] : ""
+          ],
+          value: y.value,
+          onInput: b
+        }, O.$attrs, {
+          disabled: O.disabled || O.readonly,
+          ref_key: "inputRef",
+          ref: D
+        }), null, 16, B0),
+        Q.value ? (S(), R("button", {
+          key: 2,
+          class: M(O.$style["prefix-input__clear"]),
+          type: "button",
+          onClick: T
+        }, [
+          ht(ie(M0))
+        ], 2)) : ae("", !0),
+        _.value ? (S(), R("div", {
+          key: 3,
+          class: M([
+            O.$style["prefix-input__right-icon"],
+            a.value ? O.$style["prefix-input__right-icon_red"] : "",
+            O.disabled || O.readonly ? O.$style["prefix-input__right-icon_grey"] : "",
+            Q.value ? O.$style["prefix-input__right-icon_clearable"] : ""
+          ])
+        }, [
+          fe(O.$slots, "icons-right")
+        ], 2)) : ae("", !0)
+      ], 2),
+      z("div", {
+        class: M(O.$style["prefix-input__tip"])
+      }, [
+        a.value ? ci((S(), R("div", {
+          key: 0,
+          class: M(O.$style.error),
+          innerHTML: O.validRes
+        }, null, 10, P0)), [
+          [zs, !O.hideErrorMessage]
+        ]) : fe(O.$slots, "tip", {
+          key: 1,
+          alert: ie(h0),
+          ban: ie(y0),
+          circle: ie($0),
+          info: ie(O0)
+        })
+      ], 2)
+    ], 2));
+  }
+}), N0 = "tertiary", U0 = "attention", W0 = "error", V0 = "success", H0 = {
+  "prefix-input": "cdek-input",
+  "prefix-input_small": "cdek-input_small",
+  "prefix-input__control": "cdek-input__control",
+  "prefix-input__control_user-event": "cdek-input__control_user-event",
+  "prefix-input__control_error": "cdek-input__control_error",
+  "prefix-input__control_disabled": "cdek-input__control_disabled",
+  "prefix-input__control_readonly": "cdek-input__control_readonly",
+  "prefix-input__control_right-icon": "cdek-input__control_right-icon",
+  "prefix-input__control_small": "cdek-input__control_small",
+  "prefix-input__control_clearable": "cdek-input__control_clearable",
+  "prefix-input__input": "cdek-input__input",
+  "prefix-input__input_error": "cdek-input__input_error",
+  "prefix-input__input_readonly": "cdek-input__input_readonly",
+  "prefix-input__input_no-label": "cdek-input__input_no-label",
+  "prefix-input__input_small": "cdek-input__input_small",
+  "prefix-input__label": "cdek-input__label",
+  "prefix-input__label_filled": "cdek-input__label_filled",
+  "prefix-input__label_error": "cdek-input__label_error",
+  "prefix-input__label_small": "cdek-input__label_small",
+  "prefix-input__label_readonly": "cdek-input__label_readonly",
+  "prefix-input__tip": "cdek-input__tip",
+  tertiary: N0,
+  attention: U0,
+  error: W0,
+  success: V0,
+  "prefix-input__clear": "cdek-input__clear",
+  "prefix-input__right-icon": "cdek-input__right-icon",
+  "prefix-input__right-icon_red": "cdek-input__right-icon_red",
+  "prefix-input__right-icon_grey": "cdek-input__right-icon_grey",
+  "prefix-input__right-icon_clearable": "cdek-input__right-icon_clearable",
+  "prefix-input__left-icon": "cdek-input__left-icon"
+}, G0 = {
+  $style: H0
+}, Xs = /* @__PURE__ */ Ae(F0, [["__cssModules", G0], ["__scopeId", "data-v-a648ef84"]]);
+var sr = /* @__PURE__ */ ((r) => (r.ArrowDown = "ArrowDown", r.ArrowUp = "ArrowUp", r.Enter = "Enter", r.Escape = "Escape", r))(sr || {});
+const Ja = (r, o, i) => r ? o && i ? r.map((c) => ({
+  value: o(c),
+  title: i(c)
+})) : typeof r[0] == "object" ? r : r.map((c) => ({ value: c, title: c })) : [], Z0 = (r, o, i, c) => !r || !o ? null : Ja(r, i, c).find((y) => y.value === o) || null, Da = (r, o, i, c) => {
+  const a = Z0(r, o, i, c);
+  return a ? a.title : "";
+}, z0 = (r, o, i) => r ? 0 : o ? i ? 2 : typeof o[0] == "string" ? 1 : typeof o[0] == "object" && "title" in o[0] ? 3 : 4 : 4, q0 = (r, o) => Promise.resolve(
+  o.filter((i) => i.toLowerCase().includes(r.toLowerCase()))
+), K0 = (r, o) => Promise.resolve(
+  o.filter(
+    (i) => i.title.toLowerCase().includes(r.toLowerCase())
+  )
+), Y0 = (r, o, i) => Promise.resolve(
+  i.filter(
+    (c) => r(c).toLowerCase().includes(o.toLowerCase())
+  )
+), X0 = (r, o, i) => r === 0 && o ? o : r === 1 ? q0 : r === 2 && i ? Y0.bind(null, i) : r === 3 ? K0 : () => Promise.resolve([]), J0 = ["innerHTML"], Q0 = /* @__PURE__ */ se({
+  inheritAttrs: !1,
+  __name: "BaseAutocomplete",
+  props: {
+    modelValue: {},
+    items: {},
+    fetchItems: {},
+    getValue: {},
+    getTitle: {},
+    minLength: { default: 3 },
+    class: {},
+    enabledAccentQuery: { type: Boolean }
+  },
+  emits: ["update:modelValue", "select"],
+  setup(r, { emit: o }) {
+    const i = r, c = B(
+      () => z0(i.fetchItems, i.items, i.getTitle)
+    ), a = oe(null), p = B(
+      () => Ja(a.value, i.getValue, i.getTitle)
+    ), y = oe(
+      Da(i.items, i.modelValue, i.getValue, i.getTitle)
+    ), b = oe(y.value || "");
+    Jt(
+      () => i.modelValue,
+      (N) => {
+        if (!N) {
+          (y.value || b.value) && (y.value = "", b.value = "");
+          return;
+        }
+        const Te = Da(
+          i.items,
+          N,
+          i.getValue,
+          i.getTitle
+        );
+        Te && (y.value = Te, b.value = Te);
+      }
+    );
+    const T = B(() => a.value ? Bn.value && !a.value.length ? !0 : a.value.length > 0 : !1), g = oe(-1), _ = oe(), C = oe(), D = oe(!1), Q = Jg.debounce(async (N) => {
+      g.value = -1;
+      const Te = X0(
+        c.value,
+        i.fetchItems,
+        i.getTitle
+      );
+      try {
+        const vt = await Te(N, i.items);
+        if (D.value) {
+          a.value = vt;
+          return;
+        }
+        a.value = null;
+      } catch {
+        a.value = null;
+      }
+    }, 300), ee = (N) => {
+      if (b.value = N, N.length >= i.minLength)
+        return void Q(N);
+      N.length === 0 && (y.value = "", o("update:modelValue", "")), a.value = null;
+    }, O = () => {
+      if (a.value = null, !y.value) {
+        b.value = "";
+        return;
+      }
+      b.value = y.value;
+    }, E = (N, Te) => {
+      var vt;
+      !N || N.disabled || (o("select", (vt = a.value) == null ? void 0 : vt[Te]), O(), y.value = String(N.title), b.value = String(N.title), o("update:modelValue", N.value));
+    }, W = (N) => {
+      var Te;
+      (Te = C.value) != null && Te.contains(N.target) || O();
+    }, V = (N) => {
+      N < 0 && (N = p.value.length - 1), N > p.value.length - 1 && (N = 0), g.value = N;
+    }, F = B(
+      () => new RegExp(`(${b.value})`, "iug")
+    ), Z = (N) => N.replace(
+      F.value,
+      '<span class="accent-query">$1</span>'
+    ), q = (N) => {
+      if (T.value) {
+        if (N.key === sr.ArrowDown)
+          return N.preventDefault(), void V(g.value + 1);
+        if (N.key === sr.ArrowUp)
+          return N.preventDefault(), void V(g.value - 1);
+        if (N.key === sr.Enter)
+          return N.stopImmediatePropagation(), g.value === -1 && p.value.length > 0 && V(0), void E(
+            p.value[g.value],
+            g.value
+          );
+        if (N.key === sr.Escape)
+          return N.stopImmediatePropagation(), void O();
+      }
+    }, ge = () => {
+      D.value = !0;
+    }, Ee = () => {
+      D.value = !1;
+    };
+    Dt(() => {
+      var Te;
+      const N = (Te = _.value) == null ? void 0 : Te.getControl();
+      N == null || N.addEventListener("keydown", q), document.addEventListener("click", W);
+    }), yg(() => {
+      var Te;
+      const N = (Te = _.value) == null ? void 0 : Te.getControl();
+      N == null || N.removeEventListener("keydown", q), document.removeEventListener("click", W);
+    });
+    const At = cr(), Bn = B(() => !!At["not-found"]);
+    return (N, Te) => (S(), R("div", {
+      class: M([N.$style["prefix-autocomplete"], i.class]),
+      ref_key: "autocompleteRef",
+      ref: C
+    }, [
+      ht(Xs, Qt(N.$attrs, {
+        "model-value": b.value,
+        "onUpdate:modelValue": ee,
+        ref_key: "baseInputRef",
+        ref: _,
+        onFocus: ge,
+        onBlur: Ee
+      }), qs({ _: 2 }, [
+        pn(N.$slots, (vt, St) => ({
+          name: St,
+          fn: ye((jt) => [
+            fe(N.$slots, St, fr(fi(jt)))
+          ])
+        }))
+      ]), 1040, ["model-value"]),
+      ht(qa, null, {
+        default: ye(() => [
+          T.value ? (S(), pe(Xa, { key: 0 }, {
+            default: ye(() => {
+              var vt;
+              return [
+                p.value.length === 0 && ((vt = b.value) == null ? void 0 : vt.length) >= N.minLength ? (S(), R("div", {
+                  key: 0,
+                  class: M(N.$style["prefix-autocomplete__not-found"])
+                }, [
+                  fe(N.$slots, "not-found")
+                ], 2)) : ae("", !0),
+                (S(!0), R(xt, null, pn(p.value, (St, jt) => (S(), pe(Ya, {
+                  value: St,
+                  active: jt === g.value,
+                  key: St.value,
+                  onSelect: (hi) => E(hi, jt)
+                }, {
+                  default: ye(() => [
+                    N.enabledAccentQuery ? (S(), R("span", {
+                      key: 0,
+                      innerHTML: Z(St.title)
+                    }, null, 8, J0)) : (S(), R(xt, { key: 1 }, [
+                      lt(we(St.title), 1)
+                    ], 64))
+                  ]),
+                  _: 2
+                }, 1032, ["value", "active", "onSelect"]))), 128))
+              ];
+            }),
+            _: 3
+          })) : ae("", !0)
+        ]),
+        _: 3
+      })
+    ], 2));
+  }
+}), j0 = {
+  "prefix-autocomplete": "cdek-autocomplete",
+  "prefix-autocomplete__not-found": "cdek-autocomplete__not-found",
+  "prefix-dropdown-box": "cdek-dropdown-box",
+  "v-enter-active": "v-enter-active",
+  "v-leave-active": "v-leave-active",
+  "v-enter-from": "v-enter-from",
+  "v-leave-to": "v-leave-to",
+  "accent-query": "accent-query"
+}, e1 = {
+  $style: j0
+}, t1 = /* @__PURE__ */ Ae(Q0, [["__cssModules", e1], ["__scopeId", "data-v-4f422c0f"]]), n1 = /* @__PURE__ */ se({
+  __name: "BaseBadge",
+  props: {
+    type: { default: "info" },
+    variant: { default: "light" },
+    text: { default: "" }
+  },
+  setup(r) {
+    return (o, i) => (S(), R("div", {
+      class: M([o.$style["prefix-badge"], o.$style[o.type], o.$style[o.variant]])
+    }, [
+      fe(o.$slots, "default", {}, () => [
+        lt(we(o.text), 1)
+      ], !0)
+    ], 2));
+  }
+}), r1 = "dark", i1 = "positive", s1 = "process", o1 = "negative", l1 = "info", a1 = "deactive", u1 = "neutral", c1 = "light", f1 = {
+  "prefix-badge": "cdek-badge",
+  dark: r1,
+  positive: i1,
+  process: s1,
+  negative: o1,
+  info: l1,
+  deactive: a1,
+  neutral: u1,
+  light: c1
+}, d1 = {
+  $style: f1
+}, p1 = /* @__PURE__ */ Ae(n1, [["__cssModules", d1], ["__scopeId", "data-v-fba7850b"]]), h1 = ["width", "height"], _1 = /* @__PURE__ */ bg('<defs data-v-762fb7d3><radialGradient id="paint0_angular_102_1932" cx="24" cy="0" r="48" gradientUnits="userSpaceOnUse" data-v-762fb7d3><stop offset="0.177083" stop-color="currentColor" stop-opacity="0.5" data-v-762fb7d3></stop><stop offset="1" stop-color="currentColor" stop-opacity="0" data-v-762fb7d3></stop></radialGradient></defs><circle cx="24" cy="24" r="23" stroke="currentColor" stroke-opacity="0.1" stroke-width="2" data-v-762fb7d3></circle><path fill-rule="evenodd" clip-rule="evenodd" d="M24 0C10.7452 0 0 10.7452 0 24C0 37.2548 10.7452 48 24 48V46C11.8497 46 2 36.1503 2 24C2 11.8497 11.8497 2 24 2V0Z" fill="url(#paint0_angular_102_1932)" data-v-762fb7d3></path><circle cx="24" cy="1" r="1" fill="currentColor" data-v-762fb7d3></circle><animateTransform from="0 0 0" to="360 0 0" attributeName="transform" type="rotate" repeatCount="indefinite" dur="1300ms" data-v-762fb7d3></animateTransform>', 5), v1 = [
+  _1
+], g1 = /* @__PURE__ */ se({
+  __name: "BaseSpinner",
+  props: {
+    color: { default: "green" },
+    size: { default: "small" }
+  },
+  setup(r) {
+    const o = r, i = {
+      small: 24,
+      medium: 32,
+      big: 48
+    }, c = B(() => i[o.size] || o.size), a = B(() => ["green", "white"].includes(o.color) ? {} : {
+      "--spinner-color": o.color
+    });
+    return (p, y) => (S(), R("svg", {
+      class: M(["spinner", { white: p.color === "white" }]),
+      style: Zs(a.value),
+      width: c.value,
+      height: c.value,
+      viewBox: "0 0 48 48",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg"
+    }, v1, 14, h1));
+  }
+});
+const Qa = /* @__PURE__ */ Ae(g1, [["__scopeId", "data-v-762fb7d3"]]), m1 = /* @__PURE__ */ se({
+  __name: "BaseButton",
+  props: {
+    theme: { default: "primary" },
+    width: { default: "auto" },
+    small: { type: Boolean },
+    disabled: { type: Boolean },
+    loading: { type: Boolean },
+    spinnerBefore: { type: Boolean },
+    icon: { type: Boolean },
+    as: {}
+  },
+  setup(r) {
+    const o = r, i = B(() => o.theme === "primary" || o.theme === "toaster" || o.disabled ? "white" : "green");
+    return (c, a) => (S(), pe(Xt(c.as || "button"), {
+      class: M([
+        c.$style["prefix-button"],
+        {
+          [c.$style[c.theme]]: !0,
+          [c.$style.small]: c.small,
+          [c.$style.inline]: c.width === "content",
+          [c.$style.icon]: c.icon,
+          [c.$style.disabled]: c.disabled
+        }
+      ]),
+      type: "button"
+    }, {
+      default: ye(() => [
+        c.loading ? (S(), pe(Qa, {
+          key: 0,
+          color: i.value
+        }, null, 8, ["color"])) : ae("", !0),
+        !c.loading || c.spinnerBefore ? fe(c.$slots, "default", { key: 1 }, void 0, !0) : ae("", !0)
+      ]),
+      _: 3
+    }, 8, ["class"]));
+  }
+}), y1 = "disabled", b1 = "spinner", w1 = "inline", k1 = "small", x1 = "primary", $1 = "secondary", A1 = "outline", S1 = "ghost", T1 = "toaster", C1 = "icon", O1 = {
+  "prefix-button": "cdek-button",
+  disabled: y1,
+  spinner: b1,
+  inline: w1,
+  small: k1,
+  primary: x1,
+  secondary: $1,
+  outline: A1,
+  ghost: S1,
+  toaster: T1,
+  icon: C1
+}, E1 = {
+  $style: O1
+}, Ns = /* @__PURE__ */ Ae(m1, [["__cssModules", E1], ["__scopeId", "data-v-12337b30"]]), I1 = ["disabled"], R1 = /* @__PURE__ */ se({
+  __name: "BaseChip",
+  props: {
+    label: {},
+    modelValue: { type: Boolean, default: !1 },
+    amount: {},
+    disabled: { type: Boolean, default: !1 },
+    small: { type: Boolean, default: !1 }
+  },
+  emits: ["update:modelValue"],
+  setup(r, { emit: o }) {
+    const i = r, c = cr(), a = oe(i.disabled ? !1 : i.modelValue), p = (g) => {
+      o("update:modelValue", g), a.value = g;
+    };
+    Jt(
+      () => i.modelValue,
+      (g) => {
+        if (i.disabled) {
+          p(!1);
+          return;
+        }
+        a.value = g;
+      }
+    );
+    const y = () => {
+      i.disabled || p(!a.value);
+    };
+    Jt(
+      () => i.disabled,
+      () => {
+        i.disabled && p(!1);
+      }
+    );
+    const b = B(
+      () => typeof i.amount == "number" && !Number.isNaN(i.amount)
+    ), T = B(() => !!c.icon);
+    return (g, _) => (S(), R("button", {
+      class: M([
+        g.$style["prefix-chip"],
+        {
+          [g.$style["prefix-chip_selected"]]: a.value,
+          [g.$style["prefix-chip_disabled"]]: g.disabled,
+          [g.$style["prefix-chip_small"]]: g.small
+        }
+      ]),
+      disabled: g.disabled,
+      type: "button",
+      onClick: y
+    }, [
+      T.value ? (S(), R("span", {
+        key: 0,
+        class: M(g.$style["prefix-chip__icon__wrapper"])
+      }, [
+        fe(g.$slots, "icon", {}, void 0, !0)
+      ], 2)) : ae("", !0),
+      z("span", {
+        class: M(g.$style["prefix-chip__text"])
+      }, we(g.label), 3),
+      b.value ? (S(), R("span", {
+        key: 1,
+        class: M(g.$style["prefix-chip__amount"])
+      }, we(g.amount), 3)) : ae("", !0)
+    ], 10, I1));
+  }
+}), L1 = {
+  "prefix-chip": "cdek-chip",
+  "prefix-chip_disabled": "cdek-chip_disabled",
+  "prefix-chip_selected": "cdek-chip_selected",
+  "prefix-chip__icon__wrapper": "cdek-chip__icon__wrapper",
+  "prefix-chip__text": "cdek-chip__text",
+  "prefix-chip__amount": "cdek-chip__amount",
+  "prefix-chip_small": "cdek-chip_small"
+}, M1 = {
+  $style: L1
+}, xw = /* @__PURE__ */ Ae(R1, [["__cssModules", M1], ["__scopeId", "data-v-9e264d89"]]), B1 = {
+  key: 0,
+  class: "headline-1"
+}, P1 = /* @__PURE__ */ se({
+  __name: "BaseHeadline",
+  props: {
+    size: { default: "1" }
+  },
+  setup(r) {
+    return (o, i) => o.size === "1" ? (S(), R("h1", B1, [
+      fe(o.$slots, "default", {}, void 0, !0)
+    ])) : (S(), R("div", {
+      key: 1,
+      class: M(`headline-${o.size}`)
+    }, [
+      fe(o.$slots, "default", {}, void 0, !0)
+    ], 2));
+  }
+});
+const D1 = /* @__PURE__ */ Ae(P1, [["__scopeId", "data-v-09e77485"]]), F1 = {
+  "prefix-link": "cdek-link"
+}, N1 = {};
+function U1(r, o) {
+  return S(), R("span", {
+    class: M(r.$style["prefix-link"])
+  }, [
+    fe(r.$slots, "default")
+  ], 2);
+}
+const W1 = {
+  $style: F1
+}, $w = /* @__PURE__ */ Ae(N1, [["render", U1], ["__cssModules", W1], ["__scopeId", "data-v-0ec8ba24"]]);
+/*! maska v2.1.11 | (c) Alexander Shabunevich | Released under the MIT license */
+var V1 = Object.defineProperty, H1 = (r, o, i) => o in r ? V1(r, o, { enumerable: !0, configurable: !0, writable: !0, value: i }) : r[o] = i, or = (r, o, i) => (H1(r, typeof o != "symbol" ? o + "" : o, i), i);
+const Fa = {
+  "#": { pattern: /[0-9]/ },
+  "@": { pattern: /[a-zA-Z]/ },
+  "*": { pattern: /[a-zA-Z0-9]/ }
+};
+class Na {
+  constructor(o = {}) {
+    or(this, "opts", {}), or(this, "memo", /* @__PURE__ */ new Map());
+    const i = { ...o };
+    if (i.tokens != null) {
+      i.tokens = i.tokensReplace ? { ...i.tokens } : { ...Fa, ...i.tokens };
+      for (const c of Object.values(i.tokens))
+        typeof c.pattern == "string" && (c.pattern = new RegExp(c.pattern));
+    } else
+      i.tokens = Fa;
+    Array.isArray(i.mask) && (i.mask.length > 1 ? i.mask = [...i.mask].sort((c, a) => c.length - a.length) : i.mask = i.mask[0] ?? ""), i.mask === "" && (i.mask = null), this.opts = i;
+  }
+  masked(o) {
+    return this.process(o, this.findMask(o));
+  }
+  unmasked(o) {
+    return this.process(o, this.findMask(o), !1);
+  }
+  isEager() {
+    return this.opts.eager === !0;
+  }
+  isReversed() {
+    return this.opts.reversed === !0;
+  }
+  completed(o) {
+    const i = this.findMask(o);
+    if (this.opts.mask == null || i == null)
+      return !1;
+    const c = this.process(o, i).length;
+    return typeof this.opts.mask == "string" ? c >= this.opts.mask.length : typeof this.opts.mask == "function" ? c >= i.length : this.opts.mask.filter((a) => c >= a.length).length === this.opts.mask.length;
+  }
+  findMask(o) {
+    const i = this.opts.mask;
+    if (i == null)
+      return null;
+    if (typeof i == "string")
+      return i;
+    if (typeof i == "function")
+      return i(o);
+    const c = this.process(o, i.slice(-1).pop() ?? "", !1);
+    return i.find((a) => this.process(o, a, !1).length >= c.length) ?? "";
+  }
+  escapeMask(o) {
+    const i = [], c = [];
+    return o.split("").forEach((a, p) => {
+      a === "!" && o[p - 1] !== "!" ? c.push(p - c.length) : i.push(a);
+    }), { mask: i.join(""), escaped: c };
+  }
+  process(o, i, c = !0) {
+    if (i == null)
+      return o;
+    const a = `value=${o},mask=${i},masked=${c ? 1 : 0}`;
+    if (this.memo.has(a))
+      return this.memo.get(a);
+    const { mask: p, escaped: y } = this.escapeMask(i), b = [], T = this.opts.tokens != null ? this.opts.tokens : {}, g = this.isReversed() ? -1 : 1, _ = this.isReversed() ? "unshift" : "push", C = this.isReversed() ? 0 : p.length - 1, D = this.isReversed() ? () => E > -1 && W > -1 : () => E < p.length && W < o.length, Q = (F) => !this.isReversed() && F <= C || this.isReversed() && F >= C;
+    let ee, O = -1, E = this.isReversed() ? p.length - 1 : 0, W = this.isReversed() ? o.length - 1 : 0, V = !1;
+    for (; D(); ) {
+      const F = p.charAt(E), Z = T[F], q = (Z == null ? void 0 : Z.transform) != null ? Z.transform(o.charAt(W)) : o.charAt(W);
+      if (!y.includes(E) && Z != null ? (q.match(Z.pattern) != null ? (b[_](q), Z.repeated ? (O === -1 ? O = E : E === C && E !== O && (E = O - g), C === O && (E -= g)) : Z.multiple && (V = !0, E -= g), E += g) : Z.multiple ? V && (E += g, W -= g, V = !1) : q === ee ? ee = void 0 : Z.optional && (E += g, W -= g), W += g) : (c && !this.isEager() && b[_](F), q === F && !this.isEager() ? W += g : ee = F, this.isEager() || (E += g)), this.isEager())
+        for (; Q(E) && (T[p.charAt(E)] == null || y.includes(E)); )
+          c ? b[_](p.charAt(E)) : p.charAt(E) === o.charAt(W) && (W += g), E += g;
+    }
+    return this.memo.set(a, b.join("")), this.memo.get(a);
+  }
+}
+const ja = (r) => JSON.parse(r.replaceAll("'", '"')), Ua = (r, o = {}) => {
+  const i = { ...o };
+  return r.dataset.maska != null && r.dataset.maska !== "" && (i.mask = G1(r.dataset.maska)), r.dataset.maskaEager != null && (i.eager = Ps(r.dataset.maskaEager)), r.dataset.maskaReversed != null && (i.reversed = Ps(r.dataset.maskaReversed)), r.dataset.maskaTokensReplace != null && (i.tokensReplace = Ps(r.dataset.maskaTokensReplace)), r.dataset.maskaTokens != null && (i.tokens = Z1(r.dataset.maskaTokens)), i;
+}, Ps = (r) => r !== "" ? !!JSON.parse(r) : !0, G1 = (r) => r.startsWith("[") && r.endsWith("]") ? ja(r) : r, Z1 = (r) => {
+  if (r.startsWith("{") && r.endsWith("}"))
+    return ja(r);
+  const o = {};
+  return r.split("|").forEach((i) => {
+    const c = i.split(":");
+    o[c[0]] = {
+      pattern: new RegExp(c[1]),
+      optional: c[2] === "optional",
+      multiple: c[2] === "multiple",
+      repeated: c[2] === "repeated"
+    };
+  }), o;
+};
+class z1 {
+  constructor(o, i = {}) {
+    or(this, "items", /* @__PURE__ */ new Map()), or(this, "beforeinputEvent", (c) => {
+      const a = c.target, p = this.items.get(a);
+      p.isEager() && "inputType" in c && c.inputType.startsWith("delete") && p.unmasked(a.value).length <= 1 && this.setMaskedValue(a, "");
+    }), or(this, "inputEvent", (c) => {
+      if (c instanceof CustomEvent && c.type === "input" && c.detail != null && typeof c.detail == "object" && "masked" in c.detail)
+        return;
+      const a = c.target, p = this.items.get(a), y = a.value, b = a.selectionStart, T = a.selectionEnd;
+      let g = y;
+      if (p.isEager()) {
+        const _ = p.masked(y), C = p.unmasked(y);
+        C === "" && "data" in c && c.data != null ? g = c.data : C !== p.unmasked(_) && (g = C);
+      }
+      if (this.setMaskedValue(a, g), "inputType" in c && (c.inputType.startsWith("delete") || b != null && b < y.length))
+        try {
+          a.setSelectionRange(b, T);
+        } catch {
+        }
+    }), this.options = i, typeof o == "string" ? this.init(
+      Array.from(document.querySelectorAll(o)),
+      this.getMaskOpts(i)
+    ) : this.init(
+      "length" in o ? Array.from(o) : [o],
+      this.getMaskOpts(i)
+    );
+  }
+  destroy() {
+    for (const o of this.items.keys())
+      o.removeEventListener("input", this.inputEvent), o.removeEventListener("beforeinput", this.beforeinputEvent);
+    this.items.clear();
+  }
+  needUpdateOptions(o, i) {
+    const c = this.items.get(o), a = new Na(Ua(o, this.getMaskOpts(i)));
+    return JSON.stringify(c.opts) !== JSON.stringify(a.opts);
+  }
+  needUpdateValue(o) {
+    const i = o.dataset.maskaValue;
+    return i == null && o.value !== "" || i != null && i !== o.value;
+  }
+  getMaskOpts(o) {
+    const { onMaska: i, preProcess: c, postProcess: a, ...p } = o;
+    return p;
+  }
+  init(o, i) {
+    for (const c of o) {
+      const a = new Na(Ua(c, i));
+      this.items.set(c, a), c.value !== "" && this.setMaskedValue(c, c.value), c.addEventListener("input", this.inputEvent), c.addEventListener("beforeinput", this.beforeinputEvent);
+    }
+  }
+  setMaskedValue(o, i) {
+    const c = this.items.get(o);
+    this.options.preProcess != null && (i = this.options.preProcess(i));
+    const a = c.masked(i), p = c.unmasked(c.isEager() ? a : i), y = c.completed(i), b = { masked: a, unmasked: p, completed: y };
+    i = a, this.options.postProcess != null && (i = this.options.postProcess(i)), o.value = i, o.dataset.maskaValue = i, this.options.onMaska != null && (Array.isArray(this.options.onMaska) ? this.options.onMaska.forEach((T) => T(b)) : this.options.onMaska(b)), o.dispatchEvent(new CustomEvent("maska", { detail: b })), o.dispatchEvent(new CustomEvent("input", { detail: b }));
+  }
+}
+const Us = /* @__PURE__ */ new WeakMap(), q1 = (r) => {
+  setTimeout(() => {
+    var o;
+    ((o = Us.get(r)) == null ? void 0 : o.needUpdateValue(r)) === !0 && r.dispatchEvent(new CustomEvent("input"));
+  });
+}, K1 = (r, o) => {
+  const i = r instanceof HTMLInputElement ? r : r.querySelector("input"), c = { ...o.arg };
+  if (i == null || (i == null ? void 0 : i.type) === "file")
+    return;
+  q1(i);
+  const a = Us.get(i);
+  if (a != null) {
+    if (!a.needUpdateOptions(i, c))
+      return;
+    a.destroy();
+  }
+  if (o.value != null) {
+    const p = o.value, y = (b) => {
+      p.masked = b.masked, p.unmasked = b.unmasked, p.completed = b.completed;
+    };
+    c.onMaska = c.onMaska == null ? y : Array.isArray(c.onMaska) ? [...c.onMaska, y] : [c.onMaska, y];
+  }
+  Us.set(i, new z1(i, c));
+}, Aw = /* @__PURE__ */ se({
+  __name: "BaseMaskedInput",
+  props: {
+    modelValue: {},
+    mask: { type: [String, Array, Function, null] },
+    tokens: {},
+    preProcess: { type: Function },
+    postProcess: { type: Function },
+    type: {}
+  },
+  emits: ["update:modelValue", "update:unmasked", "update:completed", "complete"],
+  setup(r, { emit: o }) {
+    const i = r, c = B(() => {
+      const b = {
+        mask: i.mask
+      };
+      return typeof i.tokens == "object" && (b.tokens = i.tokens), i.preProcess && (b.preProcess = i.preProcess), i.postProcess && (b.postProcess = i.postProcess), b;
+    }), a = oe(i.modelValue || "");
+    Jt(
+      () => i.modelValue,
+      (b) => {
+        b !== a.value && (a.value = b || "");
+      }
+    );
+    const p = (b) => {
+      a.value !== b.detail.masked && (a.value = b.detail.masked, o("update:modelValue", b.detail.masked), o("update:unmasked", b.detail.unmasked), o("update:completed", b.detail.completed), b.detail.completed && o("complete"));
+    }, y = B(() => i.type === "number" ? {
+      type: "text",
+      inputmode: "numeric"
+    } : i.type ? {
+      type: i.type
+    } : {});
+    return (b, T) => ci((S(), pe(Xs, Qt({
+      "model-value": a.value,
+      "data-maska-tokens": typeof b.tokens == "string" ? b.tokens : void 0,
+      onMaska: p
+    }, y.value), qs({ _: 2 }, [
+      pn(b.$slots, (g, _) => ({
+        name: _,
+        fn: ye((C) => [
+          fe(b.$slots, _, fr(fi(C)))
+        ])
+      }))
+    ]), 1040, ["model-value", "data-maska-tokens"])), [
+      [ie(K1), void 0, c.value]
+    ]);
+  }
+});
+class ai {
+  init() {
+  }
+}
+/**
+ * экземпляр класса
+ */
+Ge(ai, "instance", null), /**
+ * объект для хранения экземпляров по ключу
+ */
+Ge(ai, "scopedInstances", {});
+const eu = (r) => (
+  /**
+   * Отдает существующий или новый экземпляр класса (если существующий еще не создан)
+   *
+   * @param key - ключ для получения именнованного экземпляря, иначе отдает общий
+   * @returns требуемый экземпляр класса
+   */
+  (o = "") => o ? r.scopedInstances[o] || (r.scopedInstances[o] = new r()) : r.instance || (r.instance = new r())
+), Sw = (r) => (
+  /**
+   * Уничтожение базового экземпляра или по ключам
+   *
+   * @param keys - если не передано ничего, то уничтожаем базовый,
+   *  если переданы строки через запятую, то уничтожаем все экземпляры
+   *
+   * @example
+   * destroyServiceName();
+   * destroyServiceName('someKey');
+   * destroyServiceName('someKey', 'someAnotherKey');
+   */
+  (...o) => {
+    if (o.length > 0)
+      for (const i of o)
+        delete r.scopedInstances[i];
+    else
+      r.instance = null;
+  }
+);
+function Y1(r, o) {
+  return () => {
+    var c;
+    o.instance || (o.isReactive = !1);
+    let i = r();
+    return o.isReactive || (i = Ks(i), o.instance = i, o.isReactive = !0, (c = i.init) == null || c.call(i)), i;
+  };
+}
+class tu extends ai {
+  constructor() {
+    super(...arguments);
+    Ge(this, "isOpen", !1);
+    Ge(this, "modalData", {});
+  }
+  openModal(i, c) {
+    this.modalData = {
+      component: wg(i),
+      props: c == null ? void 0 : c.props,
+      settings: c == null ? void 0 : c.settings
+    }, this.isOpen = !0;
+  }
+  closeModal() {
+    this.modalData = {}, this.isOpen = !1;
+  }
+}
+const X1 = eu(tu), J1 = Y1(
+  X1,
+  tu
+), Q1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "14",
+  height: "14",
+  fill: "none"
+}, j1 = /* @__PURE__ */ z("path", {
+  stroke: "#1AB248",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "1.75",
+  d: "M13 1 1 13M1 1l12 12"
+}, null, -1), em = [
+  j1
+];
+function tm(r, o) {
+  return S(), R("svg", Q1, em);
+}
+const nm = { render: tm }, rm = /* @__PURE__ */ se({
+  __name: "BaseModal",
+  setup(r) {
+    const o = J1(), i = oe(), c = () => {
+      o.closeModal();
+    }, a = (g) => {
+      var _;
+      (_ = i.value) != null && _.contains(g.target) || c();
+    }, p = (g) => {
+      g.key === "Escape" && c();
+    }, y = B(() => {
+      var g, _;
+      return {
+        "--modal-width": (_ = (g = o.modalData) == null ? void 0 : g.settings) == null ? void 0 : _.width
+      };
+    }), b = B(() => {
+      var g, _;
+      return ((_ = (g = o.modalData) == null ? void 0 : g.settings) == null ? void 0 : _.withoutCloseButton) || !1;
+    }), T = B(() => {
+      var g, _;
+      return ((_ = (g = o.modalData) == null ? void 0 : g.settings) == null ? void 0 : _.wrapperWithoutPaddings) || !1;
+    });
+    return di(() => {
+      var g;
+      document.body.style.overflow = (g = o.modalData) != null && g.component ? "hidden" : "", o.isOpen ? document.addEventListener("keyup", p) : document.removeEventListener("keyup", p);
+    }), (g, _) => (S(), pe(qa, null, {
+      default: ye(() => {
+        var C, D;
+        return [
+          ie(o).isOpen ? (S(), R("div", {
+            key: 0,
+            class: M(g.$style["prefix-modal"])
+          }, [
+            z("div", {
+              class: M([
+                g.$style["prefix-modal__wrapper"],
+                T.value ? g.$style["prefix-modal__wrapper_disable-padding"] : ""
+              ]),
+              onClick: a
+            }, [
+              z("div", {
+                class: M(g.$style["prefix-modal__box"]),
+                ref_key: "boxElement",
+                ref: i,
+                style: Zs(y.value)
+              }, [
+                (S(), pe(Xt((C = ie(o).modalData) == null ? void 0 : C.component), fr(fi(((D = ie(o).modalData) == null ? void 0 : D.props) || {})), null, 16)),
+                b.value ? ae("", !0) : (S(), pe(ie(nm), {
+                  key: 0,
+                  class: M(g.$style["prefix-modal__box__close-trigger"]),
+                  onClick: c
+                }, null, 8, ["class"]))
+              ], 6)
+            ], 2)
+          ], 2)) : ae("", !0)
+        ];
+      }),
+      _: 1
+    }));
+  }
+}), im = {
+  "prefix-modal": "cdek-modal",
+  "prefix-modal__wrapper": "cdek-modal__wrapper",
+  "prefix-modal__wrapper_disable-padding": "cdek-modal__wrapper_disable-padding",
+  "prefix-modal__box": "cdek-modal__box",
+  "prefix-modal__box__close-trigger": "cdek-modal__box__close-trigger",
+  "v-enter-active": "v-enter-active",
+  "v-leave-active": "v-leave-active",
+  "v-enter-from": "v-enter-from",
+  "v-leave-to": "v-leave-to"
+}, sm = {
+  $style: im
+}, Tw = /* @__PURE__ */ Ae(rm, [["__cssModules", sm], ["__scopeId", "data-v-6d8da2e6"]]), om = /* @__PURE__ */ se({
+  __name: "BaseConfirm",
+  props: {
+    title: {},
+    badge: {},
+    hint: {},
+    content: {},
+    footer: {}
+  },
+  setup(r) {
+    return (o, i) => {
+      var c, a, p, y, b;
+      return S(), R("div", {
+        class: M(o.$style["prefix-confirm"])
+      }, [
+        o.title ? (S(), R("div", {
+          key: 0,
+          class: M(o.$style["prefix-confirm__header"])
+        }, [
+          z("div", {
+            class: M(o.$style["prefix-confirm__header__title"])
+          }, [
+            lt(we(o.title) + " ", 1),
+            o.badge ? (S(), pe(p1, fr(Qt({ key: 0 }, o.badge)), null, 16)) : ae("", !0)
+          ], 2),
+          o.hint ? (S(), R("div", {
+            key: 0,
+            class: M(o.$style["prefix-confirm__header__hint"])
+          }, we(o.hint), 3)) : ae("", !0)
+        ], 2)) : ae("", !0),
+        z("div", {
+          class: M(o.$style["prefix-confirm__content"])
+        }, we(o.content), 3),
+        o.footer ? (S(), R("div", {
+          key: 1,
+          class: M(o.$style["prefix-confirm__footer"])
+        }, [
+          o.footer.accept ? (S(), pe(Ns, {
+            key: 0,
+            theme: "primary",
+            onClick: (a = (c = o.footer) == null ? void 0 : c.accept) == null ? void 0 : a.onClick,
+            width: "content"
+          }, {
+            default: ye(() => {
+              var T, g;
+              return [
+                lt(we((g = (T = o.footer) == null ? void 0 : T.accept) == null ? void 0 : g.text), 1)
+              ];
+            }),
+            _: 1
+          }, 8, ["onClick"])) : ae("", !0),
+          (p = o.footer) != null && p.cancel ? (S(), pe(Ns, {
+            key: 1,
+            theme: "outline",
+            onClick: (b = (y = o.footer) == null ? void 0 : y.cancel) == null ? void 0 : b.onClick,
+            width: "content"
+          }, {
+            default: ye(() => {
+              var T, g;
+              return [
+                lt(we((g = (T = o.footer) == null ? void 0 : T.cancel) == null ? void 0 : g.text), 1)
+              ];
+            }),
+            _: 1
+          }, 8, ["onClick"])) : ae("", !0)
+        ], 2)) : ae("", !0)
+      ], 2);
+    };
+  }
+}), lm = {
+  "prefix-confirm": "cdek-confirm",
+  "prefix-confirm__header": "cdek-confirm__header",
+  "prefix-confirm__header__title": "cdek-confirm__header__title",
+  "prefix-badge": "cdek-badge",
+  "prefix-confirm__header__hint": "cdek-confirm__header__hint",
+  "prefix-confirm__footer": "cdek-confirm__footer",
+  "prefix-button": "cdek-button"
+}, am = {
+  $style: lm
+}, Cw = /* @__PURE__ */ Ae(om, [["__cssModules", am], ["__scopeId", "data-v-02e933a3"]]);
+function _t(r, o, ...i) {
+  if (r in o) {
+    let a = o[r];
+    return typeof a == "function" ? a(...i) : a;
+  }
+  let c = new Error(`Tried to handle "${r}" but there is no handler defined. Only defined handlers are: ${Object.keys(o).map((a) => `"${a}"`).join(", ")}.`);
+  throw Error.captureStackTrace && Error.captureStackTrace(c, _t), c;
+}
+var Ws = ((r) => (r[r.None = 0] = "None", r[r.RenderStrategy = 1] = "RenderStrategy", r[r.Static = 2] = "Static", r))(Ws || {}), um = ((r) => (r[r.Unmount = 0] = "Unmount", r[r.Hidden = 1] = "Hidden", r))(um || {});
+function $t({ visible: r = !0, features: o = 0, ourProps: i, theirProps: c, ...a }) {
+  var p;
+  let y = ru(c, i), b = Object.assign(a, { props: y });
+  if (r || o & 2 && y.static)
+    return Ds(b);
+  if (o & 1) {
+    let T = (p = y.unmount) == null || p ? 0 : 1;
+    return _t(T, { 0() {
+      return null;
+    }, 1() {
+      return Ds({ ...a, props: { ...y, hidden: !0, style: { display: "none" } } });
+    } });
+  }
+  return Ds(b);
+}
+function Ds({ props: r, attrs: o, slots: i, slot: c, name: a }) {
+  var p, y;
+  let { as: b, ...T } = Js(r, ["unmount", "static"]), g = (p = i.default) == null ? void 0 : p.call(i, c), _ = {};
+  if (c) {
+    let C = !1, D = [];
+    for (let [Q, ee] of Object.entries(c))
+      typeof ee == "boolean" && (C = !0), ee === !0 && D.push(Q);
+    C && (_["data-headlessui-state"] = D.join(" "));
+  }
+  if (b === "template") {
+    if (g = nu(g ?? []), Object.keys(T).length > 0 || Object.keys(o).length > 0) {
+      let [C, ...D] = g ?? [];
+      if (!cm(C) || D.length > 0)
+        throw new Error(['Passing props on "template"!', "", `The current component <${a} /> is rendering a "template".`, "However we need to passthrough the following props:", Object.keys(T).concat(Object.keys(o)).map((O) => O.trim()).filter((O, E, W) => W.indexOf(O) === E).sort((O, E) => O.localeCompare(E)).map((O) => `  - ${O}`).join(`
+`), "", "You can apply a few solutions:", ['Add an `as="..."` prop, to ensure that we render an actual element instead of a "template".', "Render a single element as the child so that we can forward the props onto that element."].map((O) => `  - ${O}`).join(`
+`)].join(`
+`));
+      let Q = ru((y = C.props) != null ? y : {}, T), ee = kg(C, Q);
+      for (let O in Q)
+        O.startsWith("on") && (ee.props || (ee.props = {}), ee.props[O] = Q[O]);
+      return ee;
+    }
+    return Array.isArray(g) && g.length === 1 ? g[0] : g;
+  }
+  return lr(b, Object.assign({}, T, _), { default: () => g });
+}
+function nu(r) {
+  return r.flatMap((o) => o.type === xt ? nu(o.children) : [o]);
+}
+function ru(...r) {
+  if (r.length === 0)
+    return {};
+  if (r.length === 1)
+    return r[0];
+  let o = {}, i = {};
+  for (let c of r)
+    for (let a in c)
+      a.startsWith("on") && typeof c[a] == "function" ? (i[a] != null || (i[a] = []), i[a].push(c[a])) : o[a] = c[a];
+  if (o.disabled || o["aria-disabled"])
+    return Object.assign(o, Object.fromEntries(Object.keys(i).map((c) => [c, void 0])));
+  for (let c in i)
+    Object.assign(o, { [c](a, ...p) {
+      let y = i[c];
+      for (let b of y) {
+        if (a instanceof Event && a.defaultPrevented)
+          return;
+        b(a, ...p);
+      }
+    } });
+  return o;
+}
+function iu(r) {
+  let o = Object.assign({}, r);
+  for (let i in o)
+    o[i] === void 0 && delete o[i];
+  return o;
+}
+function Js(r, o = []) {
+  let i = Object.assign({}, r);
+  for (let c of o)
+    c in i && delete i[c];
+  return i;
+}
+function cm(r) {
+  return r == null ? !1 : typeof r.type == "string" || typeof r.type == "object" || typeof r.type == "function";
+}
+let fm = 0;
+function dm() {
+  return ++fm;
+}
+function _n() {
+  return dm();
+}
+var Se = ((r) => (r.Space = " ", r.Enter = "Enter", r.Escape = "Escape", r.Backspace = "Backspace", r.Delete = "Delete", r.ArrowLeft = "ArrowLeft", r.ArrowUp = "ArrowUp", r.ArrowRight = "ArrowRight", r.ArrowDown = "ArrowDown", r.Home = "Home", r.End = "End", r.PageUp = "PageUp", r.PageDown = "PageDown", r.Tab = "Tab", r))(Se || {});
+function pm(r) {
+  throw new Error("Unexpected object: " + r);
+}
+var Ne = ((r) => (r[r.First = 0] = "First", r[r.Previous = 1] = "Previous", r[r.Next = 2] = "Next", r[r.Last = 3] = "Last", r[r.Specific = 4] = "Specific", r[r.Nothing = 5] = "Nothing", r))(Ne || {});
+function hm(r, o) {
+  let i = o.resolveItems();
+  if (i.length <= 0)
+    return null;
+  let c = o.resolveActiveIndex(), a = c ?? -1, p = (() => {
+    switch (r.focus) {
+      case 0:
+        return i.findIndex((y) => !o.resolveDisabled(y));
+      case 1: {
+        let y = i.slice().reverse().findIndex((b, T, g) => a !== -1 && g.length - T - 1 >= a ? !1 : !o.resolveDisabled(b));
+        return y === -1 ? y : i.length - 1 - y;
+      }
+      case 2:
+        return i.findIndex((y, b) => b <= a ? !1 : !o.resolveDisabled(y));
+      case 3: {
+        let y = i.slice().reverse().findIndex((b) => !o.resolveDisabled(b));
+        return y === -1 ? y : i.length - 1 - y;
+      }
+      case 4:
+        return i.findIndex((y) => o.resolveId(y) === r.id);
+      case 5:
+        return null;
+      default:
+        pm(r);
+    }
+  })();
+  return p === -1 ? c : p;
+}
+function be(r) {
+  var o;
+  return r == null || r.value == null ? null : (o = r.value.$el) != null ? o : r.value;
+}
+let su = Symbol("Context");
+var ar = ((r) => (r[r.Open = 1] = "Open", r[r.Closed = 2] = "Closed", r[r.Closing = 4] = "Closing", r[r.Opening = 8] = "Opening", r))(ar || {});
+function _m() {
+  return hn(su, null);
+}
+function vm(r) {
+  Mn(su, r);
+}
+function Wa(r, o) {
+  if (r)
+    return r;
+  let i = o ?? "button";
+  if (typeof i == "string" && i.toLowerCase() === "button")
+    return "button";
+}
+function ou(r, o) {
+  let i = oe(Wa(r.value.type, r.value.as));
+  return Dt(() => {
+    i.value = Wa(r.value.type, r.value.as);
+  }), di(() => {
+    var c;
+    i.value || be(o) && be(o) instanceof HTMLButtonElement && !((c = be(o)) != null && c.hasAttribute("type")) && (i.value = "button");
+  }), i;
+}
+var gm = Object.defineProperty, mm = (r, o, i) => o in r ? gm(r, o, { enumerable: !0, configurable: !0, writable: !0, value: i }) : r[o] = i, Va = (r, o, i) => (mm(r, typeof o != "symbol" ? o + "" : o, i), i);
+let ym = class {
+  constructor() {
+    Va(this, "current", this.detect()), Va(this, "currentId", 0);
+  }
+  set(o) {
+    this.current !== o && (this.currentId = 0, this.current = o);
+  }
+  reset() {
+    this.set(this.detect());
+  }
+  nextId() {
+    return ++this.currentId;
+  }
+  get isServer() {
+    return this.current === "server";
+  }
+  get isClient() {
+    return this.current === "client";
+  }
+  detect() {
+    return typeof window > "u" || typeof document > "u" ? "server" : "client";
+  }
+}, lu = new ym();
+function bm(r) {
+  if (lu.isServer)
+    return null;
+  if (r instanceof Node)
+    return r.ownerDocument;
+  if (r != null && r.hasOwnProperty("value")) {
+    let o = be(r);
+    if (o)
+      return o.ownerDocument;
+  }
+  return document;
+}
+let Ha = ["[contentEditable=true]", "[tabindex]", "a[href]", "area[href]", "button:not([disabled])", "iframe", "input:not([disabled])", "select:not([disabled])", "textarea:not([disabled])"].map((r) => `${r}:not([tabindex='-1'])`).join(",");
+var wm = ((r) => (r[r.First = 1] = "First", r[r.Previous = 2] = "Previous", r[r.Next = 4] = "Next", r[r.Last = 8] = "Last", r[r.WrapAround = 16] = "WrapAround", r[r.NoScroll = 32] = "NoScroll", r))(wm || {}), km = ((r) => (r[r.Error = 0] = "Error", r[r.Overflow = 1] = "Overflow", r[r.Success = 2] = "Success", r[r.Underflow = 3] = "Underflow", r))(km || {}), xm = ((r) => (r[r.Previous = -1] = "Previous", r[r.Next = 1] = "Next", r))(xm || {}), Qs = ((r) => (r[r.Strict = 0] = "Strict", r[r.Loose = 1] = "Loose", r))(Qs || {});
+function au(r, o = 0) {
+  var i;
+  return r === ((i = bm(r)) == null ? void 0 : i.body) ? !1 : _t(o, { 0() {
+    return r.matches(Ha);
+  }, 1() {
+    let c = r;
+    for (; c !== null; ) {
+      if (c.matches(Ha))
+        return !0;
+      c = c.parentElement;
+    }
+    return !1;
+  } });
+}
+function $m(r, o = (i) => i) {
+  return r.slice().sort((i, c) => {
+    let a = o(i), p = o(c);
+    if (a === null || p === null)
+      return 0;
+    let y = a.compareDocumentPosition(p);
+    return y & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : y & Node.DOCUMENT_POSITION_PRECEDING ? 1 : 0;
+  });
+}
+function Fs(r, o, i) {
+  lu.isServer || di((c) => {
+    document.addEventListener(r, o, i), c(() => document.removeEventListener(r, o, i));
+  });
+}
+function Am(r, o, i = B(() => !0)) {
+  function c(p, y) {
+    if (!i.value || p.defaultPrevented)
+      return;
+    let b = y(p);
+    if (b === null || !b.getRootNode().contains(b))
+      return;
+    let T = function g(_) {
+      return typeof _ == "function" ? g(_()) : Array.isArray(_) || _ instanceof Set ? _ : [_];
+    }(r);
+    for (let g of T) {
+      if (g === null)
+        continue;
+      let _ = g instanceof HTMLElement ? g : be(g);
+      if (_ != null && _.contains(b) || p.composed && p.composedPath().includes(_))
+        return;
+    }
+    return !au(b, Qs.Loose) && b.tabIndex !== -1 && p.preventDefault(), o(p, b);
+  }
+  let a = oe(null);
+  Fs("mousedown", (p) => {
+    var y, b;
+    i.value && (a.value = ((b = (y = p.composedPath) == null ? void 0 : y.call(p)) == null ? void 0 : b[0]) || p.target);
+  }, !0), Fs("click", (p) => {
+    a.value && (c(p, () => a.value), a.value = null);
+  }, !0), Fs("blur", (p) => c(p, () => window.document.activeElement instanceof HTMLIFrameElement ? window.document.activeElement : null), !0);
+}
+var js = ((r) => (r[r.None = 1] = "None", r[r.Focusable = 2] = "Focusable", r[r.Hidden = 4] = "Hidden", r))(js || {});
+let uu = se({ name: "Hidden", props: { as: { type: [Object, String], default: "div" }, features: { type: Number, default: 1 } }, setup(r, { slots: o, attrs: i }) {
+  return () => {
+    let { features: c, ...a } = r, p = { "aria-hidden": (c & 2) === 2 ? !0 : void 0, style: { position: "fixed", top: 1, left: 1, width: 1, height: 0, padding: 0, margin: -1, overflow: "hidden", clip: "rect(0, 0, 0, 0)", whiteSpace: "nowrap", borderWidth: "0", ...(c & 4) === 4 && (c & 2) !== 2 && { display: "none" } } };
+    return $t({ ourProps: p, theirProps: a, slot: {}, attrs: i, slots: o, name: "Hidden" });
+  };
+} });
+function cu(r = {}, o = null, i = []) {
+  for (let [c, a] of Object.entries(r))
+    du(i, fu(o, c), a);
+  return i;
+}
+function fu(r, o) {
+  return r ? r + "[" + o + "]" : o;
+}
+function du(r, o, i) {
+  if (Array.isArray(i))
+    for (let [c, a] of i.entries())
+      du(r, fu(o, c.toString()), a);
+  else
+    i instanceof Date ? r.push([o, i.toISOString()]) : typeof i == "boolean" ? r.push([o, i ? "1" : "0"]) : typeof i == "string" ? r.push([o, i]) : typeof i == "number" ? r.push([o, `${i}`]) : i == null ? r.push([o, ""]) : cu(i, o, r);
+}
+function Sm(r) {
+  var o;
+  let i = (o = r == null ? void 0 : r.form) != null ? o : r.closest("form");
+  if (i) {
+    for (let c of i.elements)
+      if (c.tagName === "INPUT" && c.type === "submit" || c.tagName === "BUTTON" && c.type === "submit" || c.nodeName === "INPUT" && c.type === "image") {
+        c.click();
+        return;
+      }
+  }
+}
+function pu(r, o, i) {
+  let c = oe(i == null ? void 0 : i.value), a = B(() => r.value !== void 0);
+  return [B(() => a.value ? r.value : c.value), function(p) {
+    return a.value || (c.value = p), o == null ? void 0 : o(p);
+  }];
+}
+function Ga(r) {
+  return [r.screenX, r.screenY];
+}
+function Tm() {
+  let r = oe([-1, -1]);
+  return { wasMoved(o) {
+    let i = Ga(o);
+    return r.value[0] === i[0] && r.value[1] === i[1] ? !1 : (r.value = i, !0);
+  }, update(o) {
+    r.value = Ga(o);
+  } };
+}
+let hu = Symbol("DescriptionContext");
+function Cm() {
+  let r = hn(hu, null);
+  if (r === null)
+    throw new Error("Missing parent");
+  return r;
+}
+function Om({ slot: r = oe({}), name: o = "Description", props: i = {} } = {}) {
+  let c = oe([]);
+  function a(p) {
+    return c.value.push(p), () => {
+      let y = c.value.indexOf(p);
+      y !== -1 && c.value.splice(y, 1);
+    };
+  }
+  return Mn(hu, { register: a, slot: r, name: o, props: i }), B(() => c.value.length > 0 ? c.value.join(" ") : void 0);
+}
+se({ name: "Description", props: { as: { type: [Object, String], default: "p" }, id: { type: String, default: () => `headlessui-description-${_n()}` } }, setup(r, { attrs: o, slots: i }) {
+  let c = Cm();
+  return Dt(() => Ys(c.register(r.id))), () => {
+    let { name: a = "Description", slot: p = oe({}), props: y = {} } = c, { id: b, ...T } = r, g = { ...Object.entries(y).reduce((_, [C, D]) => Object.assign(_, { [C]: ie(D) }), {}), id: b };
+    return $t({ ourProps: g, theirProps: T, slot: p.value, attrs: o, slots: i, name: a });
+  };
+} });
+function Em(r, o) {
+  return r === o;
+}
+var Im = ((r) => (r[r.Open = 0] = "Open", r[r.Closed = 1] = "Closed", r))(Im || {}), Rm = ((r) => (r[r.Single = 0] = "Single", r[r.Multi = 1] = "Multi", r))(Rm || {}), Lm = ((r) => (r[r.Pointer = 0] = "Pointer", r[r.Other = 1] = "Other", r))(Lm || {});
+function Mm(r) {
+  requestAnimationFrame(() => requestAnimationFrame(r));
+}
+let _u = Symbol("ListboxContext");
+function dr(r) {
+  let o = hn(_u, null);
+  if (o === null) {
+    let i = new Error(`<${r} /> is missing a parent <Listbox /> component.`);
+    throw Error.captureStackTrace && Error.captureStackTrace(i, dr), i;
+  }
+  return o;
+}
+let Bm = se({ name: "Listbox", emits: { "update:modelValue": (r) => !0 }, props: { as: { type: [Object, String], default: "template" }, disabled: { type: [Boolean], default: !1 }, by: { type: [String, Function], default: () => Em }, horizontal: { type: [Boolean], default: !1 }, modelValue: { type: [Object, String, Number, Boolean], default: void 0 }, defaultValue: { type: [Object, String, Number, Boolean], default: void 0 }, name: { type: String, optional: !0 }, multiple: { type: [Boolean], default: !1 } }, inheritAttrs: !1, setup(r, { slots: o, attrs: i, emit: c }) {
+  let a = oe(1), p = oe(null), y = oe(null), b = oe(null), T = oe([]), g = oe(""), _ = oe(null), C = oe(1);
+  function D(V = (F) => F) {
+    let F = _.value !== null ? T.value[_.value] : null, Z = $m(V(T.value.slice()), (ge) => be(ge.dataRef.domRef)), q = F ? Z.indexOf(F) : null;
+    return q === -1 && (q = null), { options: Z, activeOptionIndex: q };
+  }
+  let Q = B(() => r.multiple ? 1 : 0), [ee, O] = pu(B(() => r.modelValue === void 0 ? _t(Q.value, { 1: [], 0: void 0 }) : r.modelValue), (V) => c("update:modelValue", V), B(() => r.defaultValue)), E = { listboxState: a, value: ee, mode: Q, compare(V, F) {
+    if (typeof r.by == "string") {
+      let Z = r.by;
+      return (V == null ? void 0 : V[Z]) === (F == null ? void 0 : F[Z]);
+    }
+    return r.by(V, F);
+  }, orientation: B(() => r.horizontal ? "horizontal" : "vertical"), labelRef: p, buttonRef: y, optionsRef: b, disabled: B(() => r.disabled), options: T, searchQuery: g, activeOptionIndex: _, activationTrigger: C, closeListbox() {
+    r.disabled || a.value !== 1 && (a.value = 1, _.value = null);
+  }, openListbox() {
+    r.disabled || a.value !== 0 && (a.value = 0);
+  }, goToOption(V, F, Z) {
+    if (r.disabled || a.value === 1)
+      return;
+    let q = D(), ge = hm(V === Ne.Specific ? { focus: Ne.Specific, id: F } : { focus: V }, { resolveItems: () => q.options, resolveActiveIndex: () => q.activeOptionIndex, resolveId: (Ee) => Ee.id, resolveDisabled: (Ee) => Ee.dataRef.disabled });
+    g.value = "", _.value = ge, C.value = Z ?? 1, T.value = q.options;
+  }, search(V) {
+    if (r.disabled || a.value === 1)
+      return;
+    let F = g.value !== "" ? 0 : 1;
+    g.value += V.toLowerCase();
+    let Z = (_.value !== null ? T.value.slice(_.value + F).concat(T.value.slice(0, _.value + F)) : T.value).find((ge) => ge.dataRef.textValue.startsWith(g.value) && !ge.dataRef.disabled), q = Z ? T.value.indexOf(Z) : -1;
+    q === -1 || q === _.value || (_.value = q, C.value = 1);
+  }, clearSearch() {
+    r.disabled || a.value !== 1 && g.value !== "" && (g.value = "");
+  }, registerOption(V, F) {
+    let Z = D((q) => [...q, { id: V, dataRef: F }]);
+    T.value = Z.options, _.value = Z.activeOptionIndex;
+  }, unregisterOption(V) {
+    let F = D((Z) => {
+      let q = Z.findIndex((ge) => ge.id === V);
+      return q !== -1 && Z.splice(q, 1), Z;
+    });
+    T.value = F.options, _.value = F.activeOptionIndex, C.value = 1;
+  }, select(V) {
+    r.disabled || O(_t(Q.value, { 0: () => V, 1: () => {
+      let F = st(E.value.value).slice(), Z = st(V), q = F.findIndex((ge) => E.compare(Z, st(ge)));
+      return q === -1 ? F.push(Z) : F.splice(q, 1), F;
+    } }));
+  } };
+  Am([y, b], (V, F) => {
+    var Z;
+    E.closeListbox(), au(F, Qs.Loose) || (V.preventDefault(), (Z = be(y)) == null || Z.focus());
+  }, B(() => a.value === 0)), Mn(_u, E), vm(B(() => _t(a.value, { 0: ar.Open, 1: ar.Closed })));
+  let W = B(() => {
+    var V;
+    return (V = be(y)) == null ? void 0 : V.closest("form");
+  });
+  return Dt(() => {
+    Jt([W], () => {
+      if (!W.value || r.defaultValue === void 0)
+        return;
+      function V() {
+        E.select(r.defaultValue);
+      }
+      return W.value.addEventListener("reset", V), () => {
+        var F;
+        (F = W.value) == null || F.removeEventListener("reset", V);
+      };
+    }, { immediate: !0 });
+  }), () => {
+    let { name: V, modelValue: F, disabled: Z, ...q } = r, ge = { open: a.value === 0, disabled: Z, value: ee.value };
+    return lr(xt, [...V != null && ee.value != null ? cu({ [V]: ee.value }).map(([Ee, At]) => lr(uu, iu({ features: js.Hidden, key: Ee, as: "input", type: "hidden", hidden: !0, readOnly: !0, name: Ee, value: At }))) : [], $t({ ourProps: {}, theirProps: { ...i, ...Js(q, ["defaultValue", "onUpdate:modelValue", "horizontal", "multiple", "by"]) }, slot: ge, slots: o, attrs: i, name: "Listbox" })]);
+  };
+} }), Pm = se({ name: "ListboxLabel", props: { as: { type: [Object, String], default: "label" }, id: { type: String, default: () => `headlessui-listbox-label-${_n()}` } }, setup(r, { attrs: o, slots: i }) {
+  let c = dr("ListboxLabel");
+  function a() {
+    var p;
+    (p = be(c.buttonRef)) == null || p.focus({ preventScroll: !0 });
+  }
+  return () => {
+    let p = { open: c.listboxState.value === 0, disabled: c.disabled.value }, { id: y, ...b } = r, T = { id: y, ref: c.labelRef, onClick: a };
+    return $t({ ourProps: T, theirProps: b, slot: p, attrs: o, slots: i, name: "ListboxLabel" });
+  };
+} }), Dm = se({ name: "ListboxButton", props: { as: { type: [Object, String], default: "button" }, id: { type: String, default: () => `headlessui-listbox-button-${_n()}` } }, setup(r, { attrs: o, slots: i, expose: c }) {
+  let a = dr("ListboxButton");
+  c({ el: a.buttonRef, $el: a.buttonRef });
+  function p(g) {
+    switch (g.key) {
+      case Se.Space:
+      case Se.Enter:
+      case Se.ArrowDown:
+        g.preventDefault(), a.openListbox(), Yt(() => {
+          var _;
+          (_ = be(a.optionsRef)) == null || _.focus({ preventScroll: !0 }), a.value.value || a.goToOption(Ne.First);
+        });
+        break;
+      case Se.ArrowUp:
+        g.preventDefault(), a.openListbox(), Yt(() => {
+          var _;
+          (_ = be(a.optionsRef)) == null || _.focus({ preventScroll: !0 }), a.value.value || a.goToOption(Ne.Last);
+        });
+        break;
+    }
+  }
+  function y(g) {
+    switch (g.key) {
+      case Se.Space:
+        g.preventDefault();
+        break;
+    }
+  }
+  function b(g) {
+    a.disabled.value || (a.listboxState.value === 0 ? (a.closeListbox(), Yt(() => {
+      var _;
+      return (_ = be(a.buttonRef)) == null ? void 0 : _.focus({ preventScroll: !0 });
+    })) : (g.preventDefault(), a.openListbox(), Mm(() => {
+      var _;
+      return (_ = be(a.optionsRef)) == null ? void 0 : _.focus({ preventScroll: !0 });
+    })));
+  }
+  let T = ou(B(() => ({ as: r.as, type: o.type })), a.buttonRef);
+  return () => {
+    var g, _;
+    let C = { open: a.listboxState.value === 0, disabled: a.disabled.value, value: a.value.value }, { id: D, ...Q } = r, ee = { ref: a.buttonRef, id: D, type: T.value, "aria-haspopup": "listbox", "aria-controls": (g = be(a.optionsRef)) == null ? void 0 : g.id, "aria-expanded": a.disabled.value ? void 0 : a.listboxState.value === 0, "aria-labelledby": a.labelRef.value ? [(_ = be(a.labelRef)) == null ? void 0 : _.id, D].join(" ") : void 0, disabled: a.disabled.value === !0 ? !0 : void 0, onKeydown: p, onKeyup: y, onClick: b };
+    return $t({ ourProps: ee, theirProps: Q, slot: C, attrs: o, slots: i, name: "ListboxButton" });
+  };
+} }), Fm = se({ name: "ListboxOptions", props: { as: { type: [Object, String], default: "ul" }, static: { type: Boolean, default: !1 }, unmount: { type: Boolean, default: !0 }, id: { type: String, default: () => `headlessui-listbox-options-${_n()}` } }, setup(r, { attrs: o, slots: i, expose: c }) {
+  let a = dr("ListboxOptions"), p = oe(null);
+  c({ el: a.optionsRef, $el: a.optionsRef });
+  function y(g) {
+    switch (p.value && clearTimeout(p.value), g.key) {
+      case Se.Space:
+        if (a.searchQuery.value !== "")
+          return g.preventDefault(), g.stopPropagation(), a.search(g.key);
+      case Se.Enter:
+        if (g.preventDefault(), g.stopPropagation(), a.activeOptionIndex.value !== null) {
+          let _ = a.options.value[a.activeOptionIndex.value];
+          a.select(_.dataRef.value);
+        }
+        a.mode.value === 0 && (a.closeListbox(), Yt(() => {
+          var _;
+          return (_ = be(a.buttonRef)) == null ? void 0 : _.focus({ preventScroll: !0 });
+        }));
+        break;
+      case _t(a.orientation.value, { vertical: Se.ArrowDown, horizontal: Se.ArrowRight }):
+        return g.preventDefault(), g.stopPropagation(), a.goToOption(Ne.Next);
+      case _t(a.orientation.value, { vertical: Se.ArrowUp, horizontal: Se.ArrowLeft }):
+        return g.preventDefault(), g.stopPropagation(), a.goToOption(Ne.Previous);
+      case Se.Home:
+      case Se.PageUp:
+        return g.preventDefault(), g.stopPropagation(), a.goToOption(Ne.First);
+      case Se.End:
+      case Se.PageDown:
+        return g.preventDefault(), g.stopPropagation(), a.goToOption(Ne.Last);
+      case Se.Escape:
+        g.preventDefault(), g.stopPropagation(), a.closeListbox(), Yt(() => {
+          var _;
+          return (_ = be(a.buttonRef)) == null ? void 0 : _.focus({ preventScroll: !0 });
+        });
+        break;
+      case Se.Tab:
+        g.preventDefault(), g.stopPropagation();
+        break;
+      default:
+        g.key.length === 1 && (a.search(g.key), p.value = setTimeout(() => a.clearSearch(), 350));
+        break;
+    }
+  }
+  let b = _m(), T = B(() => b !== null ? (b.value & ar.Open) === ar.Open : a.listboxState.value === 0);
+  return () => {
+    var g, _, C, D;
+    let Q = { open: a.listboxState.value === 0 }, { id: ee, ...O } = r, E = { "aria-activedescendant": a.activeOptionIndex.value === null || (g = a.options.value[a.activeOptionIndex.value]) == null ? void 0 : g.id, "aria-multiselectable": a.mode.value === 1 ? !0 : void 0, "aria-labelledby": (D = (_ = be(a.labelRef)) == null ? void 0 : _.id) != null ? D : (C = be(a.buttonRef)) == null ? void 0 : C.id, "aria-orientation": a.orientation.value, id: ee, onKeydown: y, role: "listbox", tabIndex: 0, ref: a.optionsRef };
+    return $t({ ourProps: E, theirProps: O, slot: Q, attrs: o, slots: i, features: Ws.RenderStrategy | Ws.Static, visible: T.value, name: "ListboxOptions" });
+  };
+} }), Nm = se({ name: "ListboxOption", props: { as: { type: [Object, String], default: "li" }, value: { type: [Object, String, Number, Boolean] }, disabled: { type: Boolean, default: !1 }, id: { type: String, default: () => `headlessui-listbox.option-${_n()}` } }, setup(r, { slots: o, attrs: i, expose: c }) {
+  let a = dr("ListboxOption"), p = oe(null);
+  c({ el: p, $el: p });
+  let y = B(() => a.activeOptionIndex.value !== null ? a.options.value[a.activeOptionIndex.value].id === r.id : !1), b = B(() => _t(a.mode.value, { 0: () => a.compare(st(a.value.value), st(r.value)), 1: () => st(a.value.value).some((E) => a.compare(st(E), st(r.value))) })), T = B(() => _t(a.mode.value, { 1: () => {
+    var E;
+    let W = st(a.value.value);
+    return ((E = a.options.value.find((V) => W.some((F) => a.compare(st(F), st(V.dataRef.value))))) == null ? void 0 : E.id) === r.id;
+  }, 0: () => b.value })), g = B(() => ({ disabled: r.disabled, value: r.value, textValue: "", domRef: p }));
+  Dt(() => {
+    var E, W;
+    let V = (W = (E = be(p)) == null ? void 0 : E.textContent) == null ? void 0 : W.toLowerCase().trim();
+    V !== void 0 && (g.value.textValue = V);
+  }), Dt(() => a.registerOption(r.id, g)), Ys(() => a.unregisterOption(r.id)), Dt(() => {
+    Jt([a.listboxState, b], () => {
+      a.listboxState.value === 0 && b.value && _t(a.mode.value, { 1: () => {
+        T.value && a.goToOption(Ne.Specific, r.id);
+      }, 0: () => {
+        a.goToOption(Ne.Specific, r.id);
+      } });
+    }, { immediate: !0 });
+  }), di(() => {
+    a.listboxState.value === 0 && y.value && a.activationTrigger.value !== 0 && Yt(() => {
+      var E, W;
+      return (W = (E = be(p)) == null ? void 0 : E.scrollIntoView) == null ? void 0 : W.call(E, { block: "nearest" });
+    });
+  });
+  function _(E) {
+    if (r.disabled)
+      return E.preventDefault();
+    a.select(r.value), a.mode.value === 0 && (a.closeListbox(), Yt(() => {
+      var W;
+      return (W = be(a.buttonRef)) == null ? void 0 : W.focus({ preventScroll: !0 });
+    }));
+  }
+  function C() {
+    if (r.disabled)
+      return a.goToOption(Ne.Nothing);
+    a.goToOption(Ne.Specific, r.id);
+  }
+  let D = Tm();
+  function Q(E) {
+    D.update(E);
+  }
+  function ee(E) {
+    D.wasMoved(E) && (r.disabled || y.value || a.goToOption(Ne.Specific, r.id, 0));
+  }
+  function O(E) {
+    D.wasMoved(E) && (r.disabled || y.value && a.goToOption(Ne.Nothing));
+  }
+  return () => {
+    let { disabled: E } = r, W = { active: y.value, selected: b.value, disabled: E }, { id: V, value: F, disabled: Z, ...q } = r, ge = { id: V, ref: p, role: "option", tabIndex: E === !0 ? void 0 : -1, "aria-disabled": E === !0 ? !0 : void 0, "aria-selected": b.value, disabled: void 0, onClick: _, onFocus: C, onPointerenter: Q, onMouseenter: Q, onPointermove: ee, onMousemove: ee, onPointerleave: O, onMouseleave: O };
+    return $t({ ourProps: ge, theirProps: q, slot: W, attrs: i, slots: o, name: "ListboxOption" });
+  };
+} }), vu = Symbol("LabelContext");
+function gu() {
+  let r = hn(vu, null);
+  if (r === null) {
+    let o = new Error("You used a <Label /> component, but it is not inside a parent.");
+    throw Error.captureStackTrace && Error.captureStackTrace(o, gu), o;
+  }
+  return r;
+}
+function Um({ slot: r = {}, name: o = "Label", props: i = {} } = {}) {
+  let c = oe([]);
+  function a(p) {
+    return c.value.push(p), () => {
+      let y = c.value.indexOf(p);
+      y !== -1 && c.value.splice(y, 1);
+    };
+  }
+  return Mn(vu, { register: a, slot: r, name: o, props: i }), B(() => c.value.length > 0 ? c.value.join(" ") : void 0);
+}
+let Wm = se({ name: "Label", props: { as: { type: [Object, String], default: "label" }, passive: { type: [Boolean], default: !1 }, id: { type: String, default: () => `headlessui-label-${_n()}` } }, setup(r, { slots: o, attrs: i }) {
+  let c = gu();
+  return Dt(() => Ys(c.register(r.id))), () => {
+    let { name: a = "Label", slot: p = {}, props: y = {} } = c, { id: b, passive: T, ...g } = r, _ = { ...Object.entries(y).reduce((C, [D, Q]) => Object.assign(C, { [D]: ie(Q) }), {}), id: b };
+    return T && (delete _.onClick, delete _.htmlFor, delete g.onClick), $t({ ourProps: _, theirProps: g, slot: p, attrs: i, slots: o, name: a });
+  };
+} }), mu = Symbol("GroupContext"), Vm = se({ name: "SwitchGroup", props: { as: { type: [Object, String], default: "template" } }, setup(r, { slots: o, attrs: i }) {
+  let c = oe(null), a = Um({ name: "SwitchLabel", props: { htmlFor: B(() => {
+    var y;
+    return (y = c.value) == null ? void 0 : y.id;
+  }), onClick(y) {
+    c.value && (y.currentTarget.tagName === "LABEL" && y.preventDefault(), c.value.click(), c.value.focus({ preventScroll: !0 }));
+  } } }), p = Om({ name: "SwitchDescription" });
+  return Mn(mu, { switchRef: c, labelledby: a, describedby: p }), () => $t({ theirProps: r, ourProps: {}, slot: {}, slots: o, attrs: i, name: "SwitchGroup" });
+} }), Hm = se({ name: "Switch", emits: { "update:modelValue": (r) => !0 }, props: { as: { type: [Object, String], default: "button" }, modelValue: { type: Boolean, default: void 0 }, defaultChecked: { type: Boolean, optional: !0 }, name: { type: String, optional: !0 }, value: { type: String, optional: !0 }, id: { type: String, default: () => `headlessui-switch-${_n()}` } }, inheritAttrs: !1, setup(r, { emit: o, attrs: i, slots: c, expose: a }) {
+  let p = hn(mu, null), [y, b] = pu(B(() => r.modelValue), (E) => o("update:modelValue", E), B(() => r.defaultChecked));
+  function T() {
+    b(!y.value);
+  }
+  let g = oe(null), _ = p === null ? g : p.switchRef, C = ou(B(() => ({ as: r.as, type: i.type })), _);
+  a({ el: _, $el: _ });
+  function D(E) {
+    E.preventDefault(), T();
+  }
+  function Q(E) {
+    E.key === Se.Space ? (E.preventDefault(), T()) : E.key === Se.Enter && Sm(E.currentTarget);
+  }
+  function ee(E) {
+    E.preventDefault();
+  }
+  let O = B(() => {
+    var E, W;
+    return (W = (E = be(_)) == null ? void 0 : E.closest) == null ? void 0 : W.call(E, "form");
+  });
+  return Dt(() => {
+    Jt([O], () => {
+      if (!O.value || r.defaultChecked === void 0)
+        return;
+      function E() {
+        b(r.defaultChecked);
+      }
+      return O.value.addEventListener("reset", E), () => {
+        var W;
+        (W = O.value) == null || W.removeEventListener("reset", E);
+      };
+    }, { immediate: !0 });
+  }), () => {
+    let { id: E, name: W, value: V, ...F } = r, Z = { checked: y.value }, q = { id: E, ref: _, role: "switch", type: C.value, tabIndex: 0, "aria-checked": y.value, "aria-labelledby": p == null ? void 0 : p.labelledby.value, "aria-describedby": p == null ? void 0 : p.describedby.value, onClick: D, onKeyup: Q, onKeypress: ee };
+    return lr(xt, [W != null && y.value != null ? lr(uu, iu({ features: js.Hidden, as: "input", type: "checkbox", hidden: !0, readOnly: !0, checked: y.value, name: W, value: V })) : null, $t({ ourProps: q, theirProps: { ...i, ...Js(F, ["modelValue", "defaultChecked"]) }, slot: Z, attrs: i, slots: c, name: "Switch" })]);
+  };
+} }), Gm = Wm;
+const Zm = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "24",
+  height: "24",
+  fill: "none"
+}, zm = /* @__PURE__ */ z("path", {
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "2",
+  d: "m6 15 6-6 6 6"
+}, null, -1), qm = [
+  zm
+];
+function Km(r, o) {
+  return S(), R("svg", Zm, qm);
+}
+const Ym = { render: Km }, Xm = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "16",
+  height: "16",
+  fill: "none"
+}, Jm = /* @__PURE__ */ z("path", {
+  stroke: "#F47500",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "1.5",
+  d: "M8 6v1.333M8 10v.007m-4.667 2.66h9.334a1.332 1.332 0 0 0 1.226-1.833L9.16 2.667a1.333 1.333 0 0 0-2.333 0l-4.734 8.167a1.333 1.333 0 0 0 1.167 1.833"
+}, null, -1), Qm = [
+  Jm
+];
+function jm(r, o) {
+  return S(), R("svg", Xm, Qm);
+}
+const ey = { render: jm }, ty = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "16",
+  height: "16",
+  fill: "none"
+}, ny = /* @__PURE__ */ z("path", {
+  stroke: "#E40029",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "1.5",
+  d: "m3.8 3.8 8.4 8.4M14 8A6 6 0 1 1 2 8a6 6 0 0 1 12 0Z"
+}, null, -1), ry = [
+  ny
+];
+function iy(r, o) {
+  return S(), R("svg", ty, ry);
+}
+const sy = { render: iy }, oy = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "16",
+  height: "16",
+  fill: "none"
+}, ly = /* @__PURE__ */ z("path", {
+  stroke: "#17A000",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "1.5",
+  d: "m6 8 1.333 1.333L10 6.667M14 8A6 6 0 1 1 2 8a6 6 0 0 1 12 0Z"
+}, null, -1), ay = [
+  ly
+];
+function uy(r, o) {
+  return S(), R("svg", oy, ay);
+}
+const cy = { render: uy }, fy = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "16",
+  height: "16",
+  fill: "none"
+}, dy = /* @__PURE__ */ z("path", {
+  stroke: "#627791",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "1.5",
+  d: "M8 5.333h.007M7.333 8H8v2.667h.667M14 8A6 6 0 1 1 2 8a6 6 0 0 1 12 0Z"
+}, null, -1), py = [
+  dy
+];
+function hy(r, o) {
+  return S(), R("svg", fy, py);
+}
+const _y = { render: hy }, vy = /* @__PURE__ */ se({
+  __name: "BaseSelect",
+  props: {
+    modelValue: { type: [String, Number, Boolean, Array] },
+    items: {},
+    label: {},
+    validRes: { type: [Boolean, String] },
+    hideErrorMessage: { type: Boolean },
+    disabled: { type: Boolean },
+    readonly: { type: Boolean },
+    small: { type: Boolean },
+    multiple: { type: Boolean },
+    getValue: {},
+    getTitle: {}
+  },
+  emits: ["update:modelValue", "select"],
+  setup(r, { emit: o }) {
+    const i = r, c = (_) => i.getValue ? i.getValue(_) : typeof _ == "object" && _.value ? _.value : _, a = (_) => i.getTitle ? i.getTitle(_) : typeof _ == "object" && _.title ? _.title : _, p = B(() => typeof i.items[0] == "object"), y = B(() => p.value ? i.getValue || i.getTitle ? i.items.map((_) => Object.assign(_, {
+      value: c(_),
+      title: a(_)
+    })) : i.items : i.items.map(
+      (_) => ({
+        value: c(_),
+        title: a(_)
+      })
+    )), b = B(() => typeof i.validRes == "string"), T = B(() => !i.disabled && !i.readonly), g = B({
+      get() {
+        return i.multiple ? y.value.filter(
+          (_) => (i.modelValue || []).includes(_.value)
+        ) : y.value.find((_) => i.modelValue === _.value) || {};
+      },
+      set(_) {
+        if (o("select", _), Array.isArray(_)) {
+          o(
+            "update:modelValue",
+            _.map((C) => C.value)
+          );
+          return;
+        }
+        o("update:modelValue", _.value);
+      }
+    });
+    return (_, C) => (S(), R("div", {
+      class: M([
+        _.$style["prefix-select"],
+        _.small && _.label ? _.$style["prefix-select_small"] : ""
+      ])
+    }, [
+      ht(ie(Bm), {
+        modelValue: g.value,
+        "onUpdate:modelValue": C[0] || (C[0] = (D) => g.value = D),
+        disabled: _.disabled || _.readonly,
+        multiple: _.multiple
+      }, {
+        default: ye(() => [
+          ht(ie(Dm), { as: "div" }, {
+            default: ye(({ open: D }) => [
+              z("div", {
+                class: M([
+                  _.$style["prefix-select__control"],
+                  b.value ? _.$style["prefix-select__control_error"] : "",
+                  T.value ? _.$style["prefix-select__control_user-event"] : "",
+                  _.disabled ? _.$style["prefix-select__control_disabled"] : "",
+                  _.readonly ? _.$style["prefix-select__control_readonly"] : "",
+                  _.small ? _.$style["prefix-select__control_small"] : "",
+                  D ? _.$style["prefix-select__control_open"] : ""
+                ])
+              }, [
+                _.label ? (S(), pe(ie(Pm), {
+                  key: 0,
+                  class: M([
+                    _.$style["prefix-select__label"],
+                    Array.isArray(g.value) && g.value.length > 0 || g.value.value ? _.$style["prefix-select__label_filled"] : "",
+                    b.value ? _.$style["prefix-select__label_error"] : "",
+                    _.readonly ? _.$style["prefix-select__label_readonly"] : "",
+                    _.small ? _.$style["prefix-select__label_small"] : "",
+                    D ? _.$style["prefix-select__label_open"] : ""
+                  ])
+                }, {
+                  default: ye(() => [
+                    lt(we(_.label), 1)
+                  ]),
+                  _: 2
+                }, 1032, ["class"])) : ae("", !0),
+                fe(_.$slots, "selectedOption", { value: g.value }, () => [
+                  z("div", {
+                    class: M([
+                      _.$style["prefix-select__value"],
+                      b.value ? _.$style["prefix-select__value_error"] : "",
+                      _.readonly ? _.$style["prefix-select__value_readonly"] : "",
+                      _.label ? "" : _.$style["prefix-select__value_no-label"],
+                      _.small ? _.$style["prefix-select__value_small"] : "",
+                      D ? _.$style["prefix-select__value_open"] : ""
+                    ])
+                  }, we(Array.isArray(g.value) ? g.value.map((Q) => Q.title).join(", ") : g.value.title), 3)
+                ]),
+                _.readonly ? ae("", !0) : (S(), pe(ie(Ym), {
+                  key: 1,
+                  class: M([
+                    _.$style["prefix-select__arrow"],
+                    b.value ? _.$style["prefix-select__arrow_red"] : "",
+                    _.disabled ? _.$style["prefix-select__arrow_grey"] : "",
+                    D ? _.$style["prefix-select__arrow_open"] : ""
+                  ])
+                }, null, 8, ["class"]))
+              ], 2)
+            ]),
+            _: 3
+          }),
+          ht(ie(Fm), { as: Xa }, {
+            default: ye(() => [
+              (S(!0), R(xt, null, pn(y.value, (D) => (S(), pe(ie(Nm), {
+                key: D.value,
+                value: D,
+                disabled: D.disabled,
+                as: "template"
+              }, {
+                default: ye(({ selected: Q, active: ee }) => [
+                  fe(_.$slots, "option", { option: D }, () => [
+                    ht(Ya, {
+                      value: D,
+                      disabled: D.disabled,
+                      selected: Q,
+                      active: ee
+                    }, {
+                      default: ye(() => [
+                        lt(we(D.title), 1)
+                      ]),
+                      _: 2
+                    }, 1032, ["value", "disabled", "selected", "active"])
+                  ])
+                ]),
+                _: 2
+              }, 1032, ["value", "disabled"]))), 128))
+            ]),
+            _: 3
+          })
+        ]),
+        _: 3
+      }, 8, ["modelValue", "disabled", "multiple"]),
+      z("div", {
+        class: M(_.$style["prefix-select__tip"])
+      }, [
+        b.value ? ci((S(), R("span", {
+          key: 0,
+          class: "error"
+        }, we(_.validRes), 513)), [
+          [zs, !_.hideErrorMessage]
+        ]) : fe(_.$slots, "tip", {
+          key: 1,
+          alert: ie(ey),
+          ban: ie(sy),
+          circle: ie(cy),
+          info: ie(_y)
+        })
+      ], 2)
+    ], 2));
+  }
+}), gy = "tertiary", my = "attention", yy = "error", by = "success", wy = {
+  "prefix-select": "cdek-select",
+  "prefix-select_small": "cdek-select_small",
+  "prefix-select__control": "cdek-select__control",
+  "prefix-select__control_user-event": "cdek-select__control_user-event",
+  "prefix-select__control_error": "cdek-select__control_error",
+  "prefix-select__control_open": "cdek-select__control_open",
+  "prefix-select__control_disabled": "cdek-select__control_disabled",
+  "prefix-select__control_readonly": "cdek-select__control_readonly",
+  "prefix-select__control_small": "cdek-select__control_small",
+  "prefix-select__value": "cdek-select__value",
+  "prefix-select__value_error": "cdek-select__value_error",
+  "prefix-select__value_readonly": "cdek-select__value_readonly",
+  "prefix-select__value_open": "cdek-select__value_open",
+  "prefix-select__value_no-label": "cdek-select__value_no-label",
+  "prefix-select__value_small": "cdek-select__value_small",
+  "prefix-select__label": "cdek-select__label",
+  "prefix-select__label_filled": "cdek-select__label_filled",
+  "prefix-select__label_error": "cdek-select__label_error",
+  "prefix-select__label_open": "cdek-select__label_open",
+  "prefix-select__label_small": "cdek-select__label_small",
+  "prefix-select__label_readonly": "cdek-select__label_readonly",
+  "prefix-select__tip": "cdek-select__tip",
+  tertiary: gy,
+  attention: my,
+  error: yy,
+  success: by,
+  "prefix-select__arrow": "cdek-select__arrow",
+  "prefix-select__arrow_open": "cdek-select__arrow_open",
+  "prefix-select__arrow_red": "cdek-select__arrow_red",
+  "prefix-select__arrow_grey": "cdek-select__arrow_grey"
+}, ky = {
+  $style: wy
+}, Ew = /* @__PURE__ */ Ae(vy, [["__cssModules", ky], ["__scopeId", "data-v-7523f8b0"]]), xy = /* @__PURE__ */ se({
+  __name: "BaseSwitch",
+  props: {
+    modelValue: { type: Boolean },
+    disabled: { type: Boolean },
+    small: { type: Boolean },
+    label: {},
+    tip: {}
+  },
+  emits: ["update:modelValue"],
+  setup(r, { emit: o }) {
+    const i = r, c = cr(), a = B({
+      get() {
+        return i.modelValue;
+      },
+      set(p) {
+        i.disabled || o("update:modelValue", p);
+      }
+    });
+    return (p, y) => (S(), pe(ie(Vm), null, {
+      default: ye(() => [
+        z("div", {
+          class: M(p.$style["prefix-switch"])
+        }, [
+          ht(ie(Hm), {
+            modelValue: a.value,
+            "onUpdate:modelValue": y[0] || (y[0] = (b) => a.value = b),
+            disabled: p.disabled,
+            class: M([
+              p.$style["prefix-switch__bg"],
+              a.value ? p.$style["prefix-switch__bg_enabled"] : "",
+              p.small ? p.$style["prefix-switch__bg_small"] : ""
+            ])
+          }, {
+            default: ye(() => [
+              z("span", {
+                class: M([
+                  p.$style["prefix-switch__circle"],
+                  a.value ? p.$style["prefix-switch__circle_enabled"] : "",
+                  p.disabled ? p.$style["prefix-switch__circle_disabled"] : "",
+                  p.small ? p.$style["prefix-switch__circle_small"] : ""
+                ])
+              }, null, 2)
+            ]),
+            _: 1
+          }, 8, ["modelValue", "disabled", "class"]),
+          p.label || ie(c).default ? (S(), pe(ie(Gm), {
+            key: 0,
+            class: M([
+              p.$style["prefix-switch__label"],
+              p.small ? p.$style["prefix-switch__label_small"] : ""
+            ])
+          }, {
+            default: ye(() => [
+              fe(p.$slots, "default", {}, () => [
+                lt(we(p.label), 1)
+              ], !0),
+              p.tip ? (S(), R("span", {
+                key: 0,
+                class: M(p.$style["prefix-switch__tip"])
+              }, we(p.tip), 3)) : ae("", !0)
+            ]),
+            _: 3
+          }, 8, ["class"])) : ae("", !0)
+        ], 2)
+      ]),
+      _: 3
+    }));
+  }
+}), $y = {
+  "prefix-switch": "cdek-switch",
+  "prefix-switch__bg": "cdek-switch__bg",
+  "prefix-switch__bg_enabled": "cdek-switch__bg_enabled",
+  "prefix-switch__bg_small": "cdek-switch__bg_small",
+  "prefix-switch__circle": "cdek-switch__circle",
+  "prefix-switch__circle_enabled": "cdek-switch__circle_enabled",
+  "prefix-switch__circle_disabled": "cdek-switch__circle_disabled",
+  "prefix-switch__circle_small": "cdek-switch__circle_small",
+  "prefix-switch__label": "cdek-switch__label",
+  "prefix-switch__label_small": "cdek-switch__label_small",
+  "prefix-switch__tip": "cdek-switch__tip"
+}, Ay = {
+  $style: $y
+}, Iw = /* @__PURE__ */ Ae(xy, [["__cssModules", Ay], ["__scopeId", "data-v-ee92f573"]]);
+var Vs = /* @__PURE__ */ ((r) => (r.NONE = "none", r.AUTO = "auto", r.USER = "user", r))(Vs || {});
+const Sy = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "16",
+  height: "16",
+  fill: "none"
+}, Ty = /* @__PURE__ */ z("path", {
+  stroke: "#F47500",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "1.5",
+  d: "M8 6v1.333M8 10v.007m-4.667 2.66h9.334a1.332 1.332 0 0 0 1.226-1.833L9.16 2.667a1.333 1.333 0 0 0-2.333 0l-4.734 8.167a1.333 1.333 0 0 0 1.167 1.833"
+}, null, -1), Cy = [
+  Ty
+];
+function Oy(r, o) {
+  return S(), R("svg", Sy, Cy);
+}
+const Ey = { render: Oy }, Iy = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "16",
+  height: "16",
+  fill: "none"
+}, Ry = /* @__PURE__ */ z("path", {
+  stroke: "#E40029",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "1.5",
+  d: "m3.8 3.8 8.4 8.4M14 8A6 6 0 1 1 2 8a6 6 0 0 1 12 0Z"
+}, null, -1), Ly = [
+  Ry
+];
+function My(r, o) {
+  return S(), R("svg", Iy, Ly);
+}
+const By = { render: My }, Py = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "16",
+  height: "16",
+  fill: "none"
+}, Dy = /* @__PURE__ */ z("path", {
+  stroke: "#17A000",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "1.5",
+  d: "m6 8 1.333 1.333L10 6.667M14 8A6 6 0 1 1 2 8a6 6 0 0 1 12 0Z"
+}, null, -1), Fy = [
+  Dy
+];
+function Ny(r, o) {
+  return S(), R("svg", Py, Fy);
+}
+const Uy = { render: Ny }, Wy = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "16",
+  height: "16",
+  fill: "none"
+}, Vy = /* @__PURE__ */ z("path", {
+  stroke: "#627791",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "1.5",
+  d: "M8 5.333h.007M7.333 8H8v2.667h.667M14 8A6 6 0 1 1 2 8a6 6 0 0 1 12 0Z"
+}, null, -1), Hy = [
+  Vy
+];
+function Gy(r, o) {
+  return S(), R("svg", Wy, Hy);
+}
+const Zy = { render: Gy }, zy = ["value", "disabled"], qy = ["innerHTML"], Ky = {
+  inheritAttrs: !1
+}, Yy = /* @__PURE__ */ se({
+  ...Ky,
+  __name: "BaseTextarea",
+  props: {
+    modelValue: {},
+    label: {},
+    validRes: { type: [Boolean, String] },
+    hideErrorMessage: { type: Boolean },
+    disabled: { type: Boolean },
+    class: { default: "" },
+    resize: { default: "none" },
+    height: { default: "88px" }
+  },
+  emits: ["update:modelValue"],
+  setup(r, { expose: o, emit: i }) {
+    const c = r;
+    xg((C) => ({
+      "00e1e5cd": C.height
+    }));
+    const a = B(() => typeof c.validRes == "string"), p = B(() => c.resize === Vs.USER), y = B(() => !c.disabled), b = B(() => c.modelValue), T = (C) => {
+      if (c.resize === Vs.AUTO) {
+        const D = C.target.scrollHeight;
+        C.target.style.height = "auto", C.target.style.height = D + "px";
+      }
+      i("update:modelValue", C.target.value);
+    }, g = oe();
+    return o({ getControl: () => g.value }), (C, D) => (S(), R("div", {
+      class: M([C.$style["prefix-textarea"], c.class])
+    }, [
+      z("label", {
+        class: M([
+          C.$style["prefix-textarea__control"],
+          a.value ? C.$style["prefix-textarea__control_error"] : "",
+          y.value ? C.$style["prefix-textarea__control_user-event"] : "",
+          C.disabled ? C.$style["prefix-textarea__control_disabled"] : "",
+          C.label ? C.$style["prefix-textarea__control_label-filled"] : ""
+        ])
+      }, [
+        C.label ? (S(), R("div", {
+          key: 0,
+          class: M([
+            C.$style["prefix-textarea__label"],
+            b.value ? C.$style["prefix-textarea__label_filled"] : "",
+            a.value ? C.$style["prefix-textarea__label_error"] : ""
+          ])
+        }, we(C.label), 3)) : ae("", !0),
+        z("textarea", Qt({
+          class: [
+            C.$style["prefix-textarea__textarea"],
+            a.value ? C.$style["prefix-textarea__textarea_error"] : "",
+            C.label ? "" : C.$style["prefix-textarea__textarea_no-label"],
+            p.value ? C.$style["prefix-textarea__textarea_resizable"] : ""
+          ],
+          value: b.value,
+          onInput: T
+        }, C.$attrs, {
+          disabled: C.disabled,
+          ref_key: "textareaRef",
+          ref: g
+        }), null, 16, zy)
+      ], 2),
+      z("div", {
+        class: M(C.$style["prefix-textarea__tip"])
+      }, [
+        a.value ? ci((S(), R("div", {
+          key: 0,
+          class: M(C.$style.error),
+          innerHTML: C.validRes
+        }, null, 10, qy)), [
+          [zs, !C.hideErrorMessage]
+        ]) : fe(C.$slots, "tip", {
+          key: 1,
+          alert: ie(Ey),
+          ban: ie(By),
+          circle: ie(Uy),
+          info: ie(Zy)
+        })
+      ], 2)
+    ], 2));
+  }
+}), Xy = "tertiary", Jy = "attention", Qy = "error", jy = "success", eb = {
+  "prefix-textarea": "cdek-textarea",
+  "prefix-textarea__control": "cdek-textarea__control",
+  "prefix-textarea__control_user-event": "cdek-textarea__control_user-event",
+  "prefix-textarea__control_error": "cdek-textarea__control_error",
+  "prefix-textarea__control_label-filled": "cdek-textarea__control_label-filled",
+  "prefix-textarea__control_disabled": "cdek-textarea__control_disabled",
+  "prefix-textarea__textarea": "cdek-textarea__textarea",
+  "prefix-textarea__textarea_error": "cdek-textarea__textarea_error",
+  "prefix-textarea__textarea_no-label": "cdek-textarea__textarea_no-label",
+  "prefix-textarea__textarea_resizable": "cdek-textarea__textarea_resizable",
+  "prefix-textarea__label": "cdek-textarea__label",
+  "prefix-textarea__label_filled": "cdek-textarea__label_filled",
+  "prefix-textarea__label_error": "cdek-textarea__label_error",
+  "prefix-textarea__tip": "cdek-textarea__tip",
+  tertiary: Xy,
+  attention: Jy,
+  error: Qy,
+  success: jy
+}, tb = {
+  $style: eb
+}, Rw = /* @__PURE__ */ Ae(Yy, [["__cssModules", tb], ["__scopeId", "data-v-4573475e"]]), nb = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "24",
+  height: "24",
+  fill: "none"
+}, rb = /* @__PURE__ */ z("path", {
+  stroke: "#fff",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "1.75",
+  d: "M18 6 6 18M6 6l12 12"
+}, null, -1), ib = [
+  rb
+];
+function sb(r, o) {
+  return S(), R("svg", nb, ib);
+}
+const ob = { render: sb }, lb = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "24",
+  height: "24",
+  fill: "none",
+  viewBox: "0 0 20 20"
+}, ab = /* @__PURE__ */ z("path", {
+  stroke: "#fff",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "2",
+  d: "M10 6.667h.008M9.167 10H10v3.333h.833M17.5 10a7.5 7.5 0 1 1-15 0 7.5 7.5 0 0 1 15 0Z"
+}, null, -1), ub = [
+  ab
+];
+function cb(r, o) {
+  return S(), R("svg", lb, ub);
+}
+const fb = { render: cb }, db = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "24",
+  height: "24",
+  fill: "none"
+}, pb = /* @__PURE__ */ z("path", {
+  stroke: "#fff",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "2",
+  d: "m9 12 2 2 4-4m6 2a9 9 0 1 1-18 0 9 9 0 0 1 18 0Z"
+}, null, -1), hb = [
+  pb
+];
+function _b(r, o) {
+  return S(), R("svg", db, hb);
+}
+const vb = { render: _b }, gb = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "24",
+  height: "24",
+  fill: "none"
+}, mb = /* @__PURE__ */ z("path", {
+  stroke: "#fff",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "2",
+  d: "M12 9v2m0 4v.01M5 19h14a2 2 0 0 0 1.84-2.75L13.74 4a2 2 0 0 0-3.5 0l-7.1 12.25A2 2 0 0 0 4.89 19"
+}, null, -1), yb = [
+  mb
+];
+function bb(r, o) {
+  return S(), R("svg", gb, yb);
+}
+const wb = { render: bb }, kb = { class: "toast__main" }, xb = { class: "toast__content" }, $b = { class: "toast__title" }, Ab = {
+  key: 0,
+  class: "toast__text"
+}, Sb = /* @__PURE__ */ se({
+  __name: "BaseToaster",
+  props: {
+    type: { default: "info" },
+    title: {},
+    text: {},
+    button: {},
+    icon: {},
+    withoutIcon: { type: Boolean }
+  },
+  setup(r) {
+    const o = r, i = {
+      info: fb,
+      success: vb,
+      error: wb
+    }, c = B(() => i[o.type]);
+    return (a, p) => {
+      var y;
+      return S(), R("div", {
+        class: M(["toast", [a.type]])
+      }, [
+        z("button", {
+          onClick: p[0] || (p[0] = (b) => a.$emit("close-toast")),
+          class: "toast__close"
+        }, [
+          ht(ie(ob))
+        ]),
+        z("div", kb, [
+          a.withoutIcon ? ae("", !0) : (S(), R(xt, { key: 0 }, [
+            a.icon ? (S(), pe(Xt(a.icon), {
+              key: 0,
+              class: "toast__icon"
+            })) : (S(), pe(Xt(c.value), {
+              key: 1,
+              class: "toast__icon"
+            }))
+          ], 64)),
+          z("div", xb, [
+            z("p", $b, we(a.title), 1),
+            a.text ? (S(), R("p", Ab, we(a.text), 1)) : ae("", !0)
+          ])
+        ]),
+        a.button ? (S(), pe(Ns, {
+          key: 0,
+          onClick: Ka((y = a.button) == null ? void 0 : y.action, ["stop"]),
+          theme: "toaster",
+          small: "",
+          loading: a.button.loading
+        }, {
+          default: ye(() => [
+            lt(we(a.button.text), 1)
+          ]),
+          _: 1
+        }, 8, ["onClick", "loading"])) : ae("", !0)
+      ], 2);
+    };
+  }
+});
+const Za = /* @__PURE__ */ Ae(Sb, [["__scopeId", "data-v-7e60bfac"]]), Tb = /* @__PURE__ */ se({
+  __name: "BaseWidget",
+  props: {
+    headline: { default: "" },
+    withoutPaddings: { type: Boolean },
+    loading: { type: Boolean },
+    disabled: { type: Boolean }
+  },
+  setup(r) {
+    const o = r, i = cr(), c = B(() => !!(o.headline || i.header));
+    return (a, p) => (S(), R("div", {
+      class: M([
+        a.$style["prefix-widget"],
+        a.withoutPaddings ? a.$style["prefix-widget_without-paddings"] : "",
+        a.loading ? a.$style["prefix-widget_loading"] : "",
+        a.disabled ? a.$style["prefix-widget_disabled"] : ""
+      ])
+    }, [
+      c.value ? (S(), pe(D1, {
+        key: 0,
+        size: "4",
+        class: M(a.$style["prefix-widget__title"])
+      }, {
+        default: ye(() => [
+          fe(a.$slots, "header", {}, () => [
+            lt(we(a.headline), 1)
+          ], !0)
+        ]),
+        _: 3
+      }, 8, ["class"])) : ae("", !0),
+      fe(a.$slots, "default", {}, void 0, !0),
+      a.loading ? (S(), R("div", {
+        key: 1,
+        class: M(a.$style["prefix-widget__spinner"])
+      }, [
+        ht(Qa, { size: "medium" })
+      ], 2)) : ae("", !0)
+    ], 2));
+  }
+}), Cb = {
+  "prefix-widget": "cdek-widget",
+  "prefix-widget_without-paddings": "cdek-widget_without-paddings",
+  "prefix-widget_loading": "cdek-widget_loading",
+  "prefix-widget_disabled": "cdek-widget_disabled",
+  "prefix-widget__title": "cdek-widget__title",
+  "prefix-widget__spinner": "cdek-widget__spinner"
+}, Ob = {
+  $style: Cb
+}, Lw = /* @__PURE__ */ Ae(Tb, [["__cssModules", Ob], ["__scopeId", "data-v-6353b8a3"]]), Eb = {
+  "prefix-breadcrumbs": "cdek-breadcrumbs"
+}, Ib = {};
+function Rb(r, o) {
+  return S(), R("div", {
+    class: M(r.$style["prefix-breadcrumbs"])
+  }, [
+    fe(r.$slots, "default")
+  ], 2);
+}
+const Lb = {
+  $style: Eb
+}, Mw = /* @__PURE__ */ Ae(Ib, [["render", Rb], ["__cssModules", Lb], ["__scopeId", "data-v-c9d59172"]]);
+/**
+  * vee-validate v4.7.3
+  * (c) 2022 Abdelrahman Awad
+  * @license MIT
+  */
+const oi = {
+  en: /^[A-Z]*$/i,
+  cs: /^[A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ]*$/i,
+  da: /^[A-ZÆØÅ]*$/i,
+  de: /^[A-ZÄÖÜß]*$/i,
+  es: /^[A-ZÁÉÍÑÓÚÜ]*$/i,
+  fr: /^[A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ]*$/i,
+  it: /^[A-Z\xC0-\xFF]*$/i,
+  lt: /^[A-ZĄČĘĖĮŠŲŪŽ]*$/i,
+  nl: /^[A-ZÉËÏÓÖÜ]*$/i,
+  hu: /^[A-ZÁÉÍÓÖŐÚÜŰ]*$/i,
+  pl: /^[A-ZĄĆĘŚŁŃÓŻŹ]*$/i,
+  pt: /^[A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ]*$/i,
+  ru: /^[А-ЯЁ]*$/i,
+  sk: /^[A-ZÁÄČĎÉÍĹĽŇÓŔŠŤÚÝŽ]*$/i,
+  sr: /^[A-ZČĆŽŠĐ]*$/i,
+  sv: /^[A-ZÅÄÖ]*$/i,
+  tr: /^[A-ZÇĞİıÖŞÜ]*$/i,
+  uk: /^[А-ЩЬЮЯЄІЇҐ]*$/i,
+  ar: /^[ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰ]*$/,
+  az: /^[A-ZÇƏĞİıÖŞÜ]*$/i,
+  ug: /^[A-Zچۋېرتيۇڭوپھسداەىقكلزشغۈبنمژفگخجۆئ]*$/i
+}, Mb = (r) => {
+  if (r)
+    return Array.isArray(r) ? r[0] : r.locale;
+};
+function Bb(r, o) {
+  return Array.isArray(r) ? r[0] : r[o];
+}
+function eo(r) {
+  return !!(r == null || r === "" || Array.isArray(r) && r.length === 0);
+}
+const yu = (r, o) => {
+  if (eo(r))
+    return !0;
+  const i = Mb(o);
+  if (Array.isArray(r))
+    return r.every((a) => yu(a, { locale: i }));
+  const c = String(r);
+  return i ? (oi[i] || oi.en).test(c) : Object.keys(oi).some((a) => oi[a].test(c));
+}, Pb = (r) => {
+  if (eo(r))
+    return !0;
+  const o = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+  return Array.isArray(r) ? r.every((i) => o.test(String(i))) : o.test(String(r));
+};
+function Db(r) {
+  return r == null;
+}
+function Fb(r) {
+  return Array.isArray(r) && r.length === 0;
+}
+const bu = (r, o) => {
+  if (eo(r))
+    return !0;
+  let i = Bb(o, "regex");
+  return typeof i == "string" && (i = new RegExp(i)), Array.isArray(r) ? r.every((c) => bu(c, { regex: i })) : i.test(String(r));
+}, Nb = (r) => Db(r) || Fb(r) || r === !1 ? !1 : !!String(r).trim().length, kt = {
+  alpha: {
+    default: "Доступны только буквы",
+    ru: "Доступны только буквы"
+  },
+  required: {
+    default: "Обязательное поле",
+    ru: "Обязательное поле"
+  },
+  email: {
+    default: "Введите корректный email",
+    ru: "Введите корректный email"
+  },
+  regex: {
+    default: "Недопустимый формат",
+    ru: "Недопустимый формат"
+  }
+};
+class Ub extends ai {
+  constructor() {
+    super(...arguments);
+    Ge(this, "locale", "ru");
+    Ge(this, "changeLocaleCallbacks", []);
+    Ge(this, "vd", {
+      alpha: this.withMessage.bind(this, yu, "alpha"),
+      required: this.withMessage.bind(this, Nb, "required"),
+      email: this.withMessage.bind(this, Pb, "email"),
+      regex: this.withMessage.bind(this, bu, "regex")
+    });
+  }
+  withMessage(i, c, a, p) {
+    const y = { ...a }, b = y.message;
+    let T;
+    b ? typeof b == "string" ? T = () => b : T = b : T = () => "", delete y.message;
+    let g = { locale: this.locale };
+    y && (g = { ...g, ...y });
+    const _ = i(p, g), C = (T == null ? void 0 : T()) || kt[c][this.locale] || kt[c].default;
+    return _ ? !0 : C;
+  }
+  parseRules(i) {
+    const c = {};
+    if (typeof i == "string") {
+      const a = i.split("|");
+      for (const p of a)
+        this.parseStringRule(p, c);
+    }
+    if (typeof i == "object")
+      for (const a in i) {
+        if (a === "regex") {
+          this.parseRegexRule(
+            i[a],
+            c
+          );
+          continue;
+        }
+        if (typeof i[a] == "boolean" && i[a]) {
+          this.parseStringRule(a, c);
+          continue;
+        }
+        typeof i[a] == "string" && this.parseStringRule(a, c, i[a]), typeof i[a] == "function" && this.parseFunctionRule(a, i[a], c);
+      }
+    return c;
+  }
+  parseStringRule(i, c, a) {
+    const p = a ? { message: a } : {};
+    this.vd[i] && (c[i] = this.vd[i].bind(this, p));
+  }
+  parseFunctionRule(i, c, a) {
+    if (this.vd[i]) {
+      this.parseStringRule(
+        i,
+        a,
+        c
+      );
+      return;
+    }
+    a[i] = c;
+  }
+  parseRegexRule(i, c) {
+    const a = {};
+    i instanceof RegExp ? a.regex = i : (a.regex = i.pattern, a.message = i.message), c.regex = this.vd.regex.bind(this, a);
+  }
+  subscribeOnLanguageChange(i) {
+    this.changeLocaleCallbacks.push(i);
+  }
+  triggerLanguageChange() {
+    for (const i of this.changeLocaleCallbacks)
+      i();
+  }
+}
+const Hs = eu(Ub), Wb = (r, o) => {
+  kt[r] ? kt[r] = { ...kt[r], ...o } : kt[r] = o;
+}, Vb = (r) => {
+  const o = Hs();
+  o.locale = r, o.triggerLanguageChange();
+}, Hb = (r) => {
+  for (const o in kt)
+    kt[o][r] && (kt[o].default = kt[o][r]);
+};
+class Gb {
+  constructor(o, i, c) {
+    Ge(this, "error");
+    Ge(this, "isValid", !0);
+    this.formService = o, this.fieldName = i, this.rules = c, this.parseRules(this.rules);
+  }
+  /**
+   * Переводит RulesT в RulesObjectT, чтобы валидаторы всегда были объектом
+   */
+  parseRules(o) {
+    this.rules = Hs().parseRules(o);
+  }
+  /**
+   * Запускается после монтирования в компонент, чтобы
+   * реактивность нормально реагировала
+   */
+  init(o) {
+    this.register(o || ""), this.formService.subscribeOnSubmit(this.showError.bind(this)), Hs().subscribeOnLanguageChange(
+      this.changeErrorMessage.bind(this)
+    );
+  }
+  /**
+   * Регистрация поля в форме
+   */
+  register(o) {
+    this.formService.registerField(this.fieldName, o), this.validateField();
+  }
+  /**
+   * Обновление валидаторов при изменении
+   */
+  updateValidators(o) {
+    this.parseRules(o), this.validateField(), this.changeErrorMessage();
+  }
+  /**
+   * Изменение значения в поле
+   */
+  change(o) {
+    this.formService.changeField(this.fieldName, o), this.validateField(), this.showError();
+  }
+  /**
+   * Показать ошибку в форме
+   */
+  showError() {
+    this.error = this.errorMessage;
+  }
+  /**
+   * Изменить сообщение об ошибке, если оно показывается сейчас
+   *
+   * Необходимо после смены языка (чтобы показать сообщение на другом языке)
+   * и после смены валидаторов (другие валидаторы = другие ошибки)
+   */
+  changeErrorMessage() {
+    this.validateField(), this.error && this.showError();
+  }
+  /**
+   * Текущее значение поля, хранится в форме
+   */
+  get value() {
+    return this.formService.fields[this.fieldName];
+  }
+  /**
+   * Валидно ли значение с учетом текущих валидаторов
+   */
+  validateField() {
+    if (!this.rules) {
+      this.saveValidation(!0);
+      return;
+    }
+    for (const o of Object.getOwnPropertyNames(this.rules)) {
+      const i = this.rules[o](this.value);
+      if (typeof i == "string") {
+        this.saveValidation({ key: o, message: i });
+        return;
+      }
+      if (!i) {
+        this.saveValidation({ key: o });
+        return;
+      }
+    }
+    this.saveValidation(!0);
+  }
+  saveValidation(o) {
+    this.isValid = o, this.formService.validateField(this.fieldName, this.errorKey);
+  }
+  /**
+   * Сообщение об ошибке
+   */
+  get errorMessage() {
+    var o;
+    return typeof this.isValid == "boolean" ? this.isValid : ((o = this.isValid) == null ? void 0 : o.message) || this.isValid.key;
+  }
+  /**
+   * Название валидатора, который не прошел успешно
+   */
+  get errorKey() {
+    return typeof this.isValid == "boolean" ? this.isValid : this.isValid.key;
+  }
+}
+const wu = Symbol();
+class Zb {
+  constructor() {
+    Ge(this, "fields", {});
+    Ge(this, "errors", {});
+    Ge(this, "submitSubscribers", []);
+  }
+  /**
+   * @param name - название поля
+   * @param initialValue
+   */
+  registerField(o, i) {
+    this.fields[o] = i;
+  }
+  /**
+   * @param name - название поля
+   * @param newValue
+   */
+  changeField(o, i) {
+    this.fields[o] = i;
+  }
+  /**
+   * @param name - название поля
+   * @param validOrError - true если валидно, название валидатора, если нет
+   */
+  validateField(o, i) {
+    this.errors[o] = i;
+  }
+  triggerSubmit() {
+    for (const o of this.submitSubscribers)
+      o();
+  }
+  subscribeOnSubmit(o) {
+    this.submitSubscribers.push(o);
+  }
+  getFieldService(...o) {
+    return new Gb(this, ...o);
+  }
+  clearForm() {
+    Object.keys(this.fields).forEach((o) => {
+      this.changeField(o, "");
+    });
+  }
+}
+const zb = ["onSubmit"], Bw = /* @__PURE__ */ se({
+  __name: "BaseForm",
+  emits: ["submit", "submitError"],
+  setup(r, { expose: o, emit: i }) {
+    const c = Ks(new Zb());
+    Mn(wu, c);
+    const a = () => {
+      for (const T of Object.getOwnPropertyNames(c.errors))
+        if (typeof c.errors[T] == "string") {
+          const g = { ...c.errors };
+          return i("submitError", g), c.triggerSubmit(), { isValid: !1, errors: g };
+        }
+      const b = { ...c.fields };
+      return i("submit", b), { isValid: !0, values: b };
+    };
+    return o({
+      triggerSubmit: () => a(),
+      clearForm: () => {
+        c.clearForm();
+      }
+    }), (b, T) => (S(), R("form", {
+      onSubmit: Ka(a, ["prevent"])
+    }, [
+      fe(b.$slots, "default")
+    ], 40, zb));
+  }
+}), qb = {
+  inheritAttrs: !1
+}, Pw = /* @__PURE__ */ se({
+  ...qb,
+  __name: "BaseFormControl",
+  props: {
+    name: {},
+    rules: {},
+    type: { default: "text" },
+    className: { default: "" },
+    initialValue: { default: "" }
+  },
+  setup(r, { expose: o }) {
+    const i = r, c = hn(wu), a = Ks(
+      c.getFieldService(i.name, i.rules)
+    );
+    a.init(i.initialValue), Jt(
+      () => i.rules,
+      (T) => {
+        a.updateValidators(T);
+      },
+      { deep: !0 }
+    );
+    const p = B({
+      get() {
+        return a.value || "";
+      },
+      set(T) {
+        a.change(T);
+      }
+    }), y = (T) => {
+      p.value = T;
+    }, b = B(() => i.type === "autocomplete" ? t1 : ["text", "number"].includes(i.type) ? Xs : null);
+    return o({
+      changeValue: y
+    }), (T, g) => (S(), R("div", {
+      class: M(T.className)
+    }, [
+      b.value ? (S(), pe(Xt(b.value), Qt({
+        key: 0,
+        type: T.type === "number" ? "number" : void 0,
+        modelValue: p.value,
+        "onUpdate:modelValue": g[0] || (g[0] = (_) => p.value = _),
+        "valid-res": a.error
+      }, T.$attrs), qs({ _: 2 }, [
+        pn(T.$slots, (_, C) => ({
+          name: C,
+          fn: ye((D) => [
+            fe(T.$slots, C, fr(fi(D)))
+          ])
+        }))
+      ]), 1040, ["type", "modelValue", "valid-res"])) : fe(T.$slots, "default", {
+        key: 1,
+        value: p.value,
+        changeValue: y,
+        validRes: a.error
+      })
+    ], 2));
+  }
+}), Dw = { changeLocale: Vb, addMessages: Wb, changeDefaultLocale: Hb }, pi = (r) => typeof r == "function", to = (r) => typeof r == "string", Kb = (r) => to(r) && r.trim().length > 0, fn = (r) => typeof r > "u", ui = (r) => typeof r == "object" && r !== null, Yb = (r) => Ln(r, "tag") && Kb(r.tag), ku = (r) => Ln(r, "component") && Jb(r.component), Xb = (r) => pi(r) || ui(r), Jb = (r) => (
+  // Ignore undefined
+  !fn(r) && // Is a string
+  (to(r) || // Regular Vue component
+  Xb(r) || // Nested object
+  ku(r))
+), Ln = (r, o) => (ui(r) || pi(r)) && o in r, Qb = ((r) => () => r++)(0), jb = (r) => {
+  fn(r.remove) ? r.parentNode && r.parentNode.removeChild(r) : r.remove();
+}, no = (r) => ku(r) ? no(r.component) : Yb(r) ? se({
+  render() {
+    return r;
+  }
+}) : typeof r == "string" ? r : st(ie(r)), ew = (r) => {
+  if (typeof r == "string")
+    return r;
+  const o = Ln(r, "props") && ui(r.props) ? r.props : {}, i = Ln(r, "listeners") && ui(r.listeners) ? r.listeners : {};
+  return { component: no(r), props: o, listeners: i };
+}, tw = () => typeof window < "u";
+class ro {
+  constructor() {
+    Ge(this, "allHandlers", {});
+  }
+  getHandlers(o) {
+    return this.allHandlers[o] || [];
+  }
+  on(o, i) {
+    const c = this.getHandlers(o);
+    c.push(i), this.allHandlers[o] = c;
+  }
+  off(o, i) {
+    const c = this.getHandlers(o);
+    c.splice(c.indexOf(i) >>> 0, 1);
+  }
+  emit(o, i) {
+    this.getHandlers(o).forEach((a) => a(i));
+  }
+}
+const nw = (r) => ["on", "off", "emit"].every((o) => Ln(r, o) && pi(r[o]));
+var wt = /* @__PURE__ */ ((r) => (r.SUCCESS = "success", r.ERROR = "error", r.WARNING = "warning", r.INFO = "info", r.DEFAULT = "default", r))(wt || {}), ur = /* @__PURE__ */ ((r) => (r.TOP_LEFT = "top-left", r.TOP_CENTER = "top-center", r.TOP_RIGHT = "top-right", r.BOTTOM_LEFT = "bottom-left", r.BOTTOM_CENTER = "bottom-center", r.BOTTOM_RIGHT = "bottom-right", r))(ur || {}), ot = /* @__PURE__ */ ((r) => (r.ADD = "add", r.DISMISS = "dismiss", r.UPDATE = "update", r.CLEAR = "clear", r.UPDATE_DEFAULTS = "update_defaults", r))(ot || {});
+const dn = "Vue-Toastification", Kt = {
+  type: {
+    type: String,
+    default: wt.DEFAULT
+  },
+  classNames: {
+    type: [String, Array],
+    default: () => []
+  },
+  trueBoolean: {
+    type: Boolean,
+    default: !0
+  }
+}, xu = {
+  transition: {
+    type: [Object, String],
+    default: `${dn}__bounce`
+  }
+}, rw = {
+  position: {
+    type: String,
+    default: ur.TOP_RIGHT
+  },
+  timeout: {
+    type: [Number, Boolean],
+    default: 5e3
+  },
+  pauseOnFocusLoss: Kt.trueBoolean,
+  pauseOnHover: Kt.trueBoolean,
+  closeOnClick: Kt.trueBoolean,
+  toastClassName: Kt.classNames,
+  bodyClassName: Kt.classNames,
+  accessibility: {
+    type: Object,
+    default: () => ({
+      toastRole: "alert",
+      closeButtonLabel: "close"
+    })
+  },
+  rtl: {
+    type: Boolean,
+    default: !1
+  },
+  eventBus: {
+    type: Object,
+    required: !1,
+    default: () => new ro()
+  }
+}, iw = {
+  id: {
+    type: [String, Number],
+    required: !0,
+    default: 0
+  },
+  type: Kt.type,
+  content: {
+    type: [String, Object, Function],
+    required: !0,
+    default: ""
+  },
+  onClick: {
+    type: Function,
+    default: void 0
+  },
+  onClose: {
+    type: Function,
+    default: void 0
+  }
+}, sw = {
+  container: {
+    type: [
+      Object,
+      Function
+    ],
+    default: () => document == null ? void 0 : document.body
+  },
+  newestOnTop: Kt.trueBoolean,
+  maxToasts: {
+    type: Number,
+    default: 20
+  },
+  transition: xu.transition,
+  toastDefaults: Object,
+  filterBeforeCreate: {
+    type: Function,
+    default: (r) => r
+  },
+  filterToasts: {
+    type: Function,
+    default: (r) => r
+  },
+  containerClassName: Kt.classNames,
+  onMounted: Function,
+  shareAppContext: [Boolean, Object]
+}, Rn = {
+  CORE_TOAST: rw,
+  TOAST: iw,
+  CONTAINER: sw,
+  TRANSITION: xu
+}, ow = se({
+  name: "VtToast",
+  inheritAttrs: !1,
+  props: Object.assign({}, Rn.CORE_TOAST, Rn.TOAST),
+  data() {
+    return {
+      isRunning: !0,
+      disableTransitions: !1,
+      beingDragged: !1,
+      dragStart: 0,
+      dragPos: { x: 0, y: 0 },
+      dragRect: {}
+    };
+  },
+  computed: {
+    classes() {
+      const r = [
+        `${dn}__toast`,
+        `${dn}__toast--${this.type}`,
+        `${this.position}`
+      ].concat(this.toastClassName);
+      return this.disableTransitions && r.push("disable-transition"), this.rtl && r.push(`${dn}__toast--rtl`), r;
+    },
+    bodyClasses() {
+      return [
+        `${dn}__toast-${to(this.content) ? "body" : "component-body"}`
+      ].concat(this.bodyClassName);
+    }
+  },
+  mounted() {
+    this.timeout && setTimeout(() => {
+      this.timeoutHandler();
+    }, this.timeout), this.pauseOnFocusLoss && this.focusSetup();
+  },
+  beforeUnmount() {
+    this.pauseOnFocusLoss && this.focusCleanup();
+  },
+  methods: {
+    hasProp: Ln,
+    getVueComponentFromObj: no,
+    closeToast() {
+      this.eventBus.emit(ot.DISMISS, this.id);
+    },
+    clickHandler() {
+      this.onClick && this.onClick(this.closeToast), this.closeOnClick && (!this.beingDragged || this.dragStart === this.dragPos.x) && this.closeToast();
+    },
+    timeoutHandler() {
+      this.closeToast();
+    },
+    hoverPause() {
+      this.pauseOnHover && (this.isRunning = !1);
+    },
+    hoverPlay() {
+      this.pauseOnHover && (this.isRunning = !0);
+    },
+    focusPause() {
+      this.isRunning = !1;
+    },
+    focusPlay() {
+      this.isRunning = !0;
+    },
+    focusSetup() {
+      addEventListener("blur", this.focusPause), addEventListener("focus", this.focusPlay);
+    },
+    focusCleanup() {
+      removeEventListener("blur", this.focusPause), removeEventListener("focus", this.focusPlay);
+    }
+  }
+}), lw = ["role"];
+function aw(r, o, i, c, a, p) {
+  return S(), R("div", {
+    class: M(r.classes),
+    onClick: o[0] || (o[0] = (...y) => r.clickHandler && r.clickHandler(...y)),
+    onMouseenter: o[1] || (o[1] = (...y) => r.hoverPause && r.hoverPause(...y)),
+    onMouseleave: o[2] || (o[2] = (...y) => r.hoverPlay && r.hoverPlay(...y))
+  }, [
+    z("div", {
+      role: r.accessibility.toastRole || "alert",
+      class: M(r.bodyClasses)
+    }, [
+      typeof r.content == "string" ? (S(), R(xt, { key: 0 }, [
+        lt(we(r.content), 1)
+      ], 64)) : (S(), pe(Xt(r.getVueComponentFromObj(r.content)), Qt({
+        key: 1,
+        "toast-id": r.id
+      }, r.hasProp(r.content, "props") ? r.content.props : {}, $g(r.hasProp(r.content, "listeners") ? r.content.listeners : {}), { onCloseToast: r.closeToast }), null, 16, ["toast-id", "onCloseToast"]))
+    ], 10, lw)
+  ], 34);
+}
+const uw = /* @__PURE__ */ Ae(ow, [["render", aw]]), cw = /* @__PURE__ */ se({
+  __name: "VtTransition",
+  props: Rn.TRANSITION,
+  setup(r) {
+    return (o, i) => (S(), pe(Ag, {
+      tag: "div",
+      "enter-active-class": `${o.transition}-enter-active`,
+      "move-class": `${o.transition}-move`,
+      "leave-active-class": `${o.transition}-leave-active`
+    }, {
+      default: ye(() => [
+        fe(o.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["enter-active-class", "move-class", "leave-active-class"]));
+  }
+}), fw = se({
+  name: "VueToastification",
+  devtools: {
+    hide: !0
+  },
+  components: { Toast: uw, VtTransition: cw },
+  props: Object.assign({}, Rn.CORE_TOAST, Rn.CONTAINER, Rn.TRANSITION),
+  data() {
+    return {
+      count: 0,
+      positions: Object.values(ur),
+      toasts: {},
+      defaults: {}
+    };
+  },
+  computed: {
+    toastArray() {
+      return Object.values(this.toasts);
+    },
+    filteredToasts() {
+      return this.defaults.filterToasts(this.toastArray);
+    }
+  },
+  beforeMount() {
+    const r = this.eventBus;
+    r.on(ot.ADD, this.addToast), r.on(ot.CLEAR, this.clearToasts), r.on(ot.DISMISS, this.dismissToast), r.on(ot.UPDATE, this.updateToast), r.on(ot.UPDATE_DEFAULTS, this.updateDefaults), this.defaults = this.$props;
+  },
+  mounted() {
+    this.setup(this.container);
+  },
+  methods: {
+    async setup(r) {
+      pi(r) && (r = await r()), jb(this.$el), r.appendChild(this.$el);
+    },
+    setToast(r) {
+      fn(r.id) || (this.toasts[r.id] = r);
+    },
+    addToast(r) {
+      r.content = ew(r.content);
+      const o = Object.assign(
+        {},
+        this.defaults,
+        r.type && this.defaults.toastDefaults && this.defaults.toastDefaults[r.type],
+        r
+      ), i = this.defaults.filterBeforeCreate(o, this.toastArray);
+      i && this.setToast(i);
+    },
+    dismissToast(r) {
+      const o = this.toasts[r];
+      !fn(o) && !fn(o.onClose) && o.onClose(), delete this.toasts[r];
+    },
+    clearToasts() {
+      Object.keys(this.toasts).forEach((r) => {
+        this.dismissToast(r);
+      });
+    },
+    getPositionToasts(r) {
+      const o = this.filteredToasts.filter((i) => i.position === r).slice(0, this.defaults.maxToasts);
+      return this.defaults.newestOnTop ? o.reverse() : o;
+    },
+    updateDefaults(r) {
+      fn(r.container) || this.setup(r.container), this.defaults = Object.assign({}, this.defaults, r);
+    },
+    updateToast({
+      id: r,
+      options: o,
+      create: i
+    }) {
+      this.toasts[r] ? (o.timeout && o.timeout === this.toasts[r].timeout && o.timeout++, this.setToast(Object.assign({}, this.toasts[r], o))) : i && this.addToast(
+        Object.assign({}, { id: r }, o)
+      );
+    },
+    getClasses(r) {
+      return [`${dn}__container`, r].concat(this.defaults.containerClassName);
+    }
+  }
+}), dw = { key: 0 };
+function pw(r, o, i, c, a, p) {
+  const y = Pa("Toast"), b = Pa("VtTransition");
+  return r.container ? (S(), R("div", dw, [
+    (S(!0), R(xt, null, pn(r.positions, (T) => (S(), R("div", { key: T }, [
+      ht(b, {
+        transition: r.defaults.transition,
+        class: M(r.getClasses(T))
+      }, {
+        default: ye(() => [
+          (S(!0), R(xt, null, pn(r.getPositionToasts(T), (g) => (S(), pe(y, Qt({
+            key: g.id
+          }, g), null, 16))), 128))
+        ]),
+        _: 2
+      }, 1032, ["transition", "class"])
+    ]))), 128))
+  ])) : ae("", !0);
+}
+const hw = /* @__PURE__ */ Ae(fw, [["render", pw]]), _w = (r) => {
+  if (!(document == null ? void 0 : document.getElementById("toastification"))) {
+    const i = Sg(hw, {
+      ...r
+    }), c = document == null ? void 0 : document.createElement("div");
+    c.setAttribute("id", "toastification");
+    const a = i.mount(c), p = r.onMounted;
+    fn(p) || p(a, i);
+  }
+}, za = (r = {}, o = !0) => {
+  const i = r.eventBus = r.eventBus || new ro();
+  o && Yt(() => {
+    _w(r);
+  });
+  const c = (p, y) => {
+    const b = Object.assign({}, { id: Qb(), type: wt.DEFAULT }, y, {
+      content: p
+    });
+    return i.emit(ot.ADD, b), b.id;
+  };
+  c.clear = () => i.emit(ot.CLEAR, void 0), c.updateDefaults = (p) => {
+    i.emit(ot.UPDATE_DEFAULTS, p);
+  }, c.dismiss = (p) => {
+    i.emit(ot.DISMISS, p);
+  };
+  function a(p, { content: y, options: b }, T = !1) {
+    const g = Object.assign({}, b, { content: y });
+    i.emit(ot.UPDATE, {
+      id: p,
+      options: g,
+      create: T
+    });
+  }
+  return c.update = a, c.success = (p, y) => c(p, Object.assign({}, y, { type: wt.SUCCESS })), c.info = (p, y) => c(p, Object.assign({}, y, { type: wt.INFO })), c.error = (p, y) => c(p, Object.assign({}, y, { type: wt.ERROR })), c.warning = (p, y) => c(p, Object.assign({}, y, { type: wt.WARNING })), c;
+};
+const vw = () => {
+  const r = () => console.warn(`[${dn}] This plugin does not support SSR!`);
+  return new Proxy(r, {
+    get() {
+      return r;
+    }
+  });
+};
+function Gs(r) {
+  return tw() ? nw(r) ? za({ eventBus: r }, !1) : za(r, !0) : vw();
+}
+const $u = Symbol("VueToastification"), Au = new ro(), gw = (r, o) => {
+  const i = Gs({
+    eventBus: Au,
+    ...o
+  });
+  r.provide($u, i);
+}, mw = (r) => {
+  if (r)
+    return Gs(r);
+  const o = Tg() ? hn($u, void 0) : void 0;
+  return o || Gs(Au);
+};
+const yw = {
+  maxToasts: 5
+};
+function Fw(r) {
+  r.use(gw, yw);
+}
+function Nw() {
+  const r = mw();
+  function o(c, a = {}, p = "info") {
+    let b = (window == null ? void 0 : window.matchMedia("(max-width: 768px)")).matches ? ur.BOTTOM_CENTER : ur.TOP_RIGHT;
+    return a.position && (b = a.position), typeof c == "string" && (c = {
+      title: c
+    }), c.type || (c.type = p), r(
+      { component: Za, props: c },
+      { position: b, timeout: a.timeout || 5e3 }
+    );
+  }
+  function i(...c) {
+    return o(...c);
+  }
+  return i.info = function(...a) {
+    return o(a[0], a[1], wt.INFO);
+  }, i.success = function(...a) {
+    return o(a[0], a[1], wt.SUCCESS);
+  }, i.error = function(...a) {
+    return o(a[0], a[1], wt.ERROR);
+  }, i.dismiss = r.dismiss, i.clear = r.clear, i.update = function(a, p) {
+    r.update(a, { content: { component: Za, props: p } });
+  }, i;
+}
+export {
+  kw as CdekAlert,
+  t1 as CdekAutocomplete,
+  p1 as CdekBadge,
+  Mw as CdekBreadcrumbs,
+  Ns as CdekButton,
+  xw as CdekChip,
+  Cw as CdekConfirm,
+  Xa as CdekDropdownBox,
+  Ya as CdekDropdownItem,
+  Bw as CdekForm,
+  Pw as CdekFormControl,
+  D1 as CdekHeadline,
+  Xs as CdekInput,
+  $w as CdekLink,
+  Aw as CdekMaskedInput,
+  Tw as CdekModal,
+  Ew as CdekSelect,
+  Qa as CdekSpinner,
+  Iw as CdekSwitch,
+  Rw as CdekTextarea,
+  Za as CdekToaster,
+  Lw as CdekWidget,
+  ai as Multitone,
+  ur as TOAST_POSITION,
+  Sw as destroyFactory,
+  Dw as formSettings,
+  eu as getInstanceFactory,
+  Fw as registerToastification,
+  J1 as useModalService,
+  Y1 as useServiceFactory,
+  Nw as useToast
+};
diff --git a/parent_dir/node_modules/deepmerge/dist/cjs.js b/parent_dir/node_modules/deepmerge/dist/cjs.js
new file mode 100644
index 0000000..7c36cbd
--- /dev/null
+++ b/parent_dir/node_modules/deepmerge/dist/cjs.js
@@ -0,0 +1,133 @@
+'use strict';
+
+var isMergeableObject = function isMergeableObject(value) {
+	return isNonNullObject(value)
+		&& !isSpecial(value)
+};
+
+function isNonNullObject(value) {
+	return !!value && typeof value === 'object'
+}
+
+function isSpecial(value) {
+	var stringValue = Object.prototype.toString.call(value);
+
+	return stringValue === '[object RegExp]'
+		|| stringValue === '[object Date]'
+		|| isReactElement(value)
+}
+
+// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
+var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
+var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
+
+function isReactElement(value) {
+	return value.$$typeof === REACT_ELEMENT_TYPE
+}
+
+function emptyTarget(val) {
+	return Array.isArray(val) ? [] : {}
+}
+
+function cloneUnlessOtherwiseSpecified(value, options) {
+	return (options.clone !== false && options.isMergeableObject(value))
+		? deepmerge(emptyTarget(value), value, options)
+		: value
+}
+
+function defaultArrayMerge(target, source, options) {
+	return target.concat(source).map(function(element) {
+		return cloneUnlessOtherwiseSpecified(element, options)
+	})
+}
+
+function getMergeFunction(key, options) {
+	if (!options.customMerge) {
+		return deepmerge
+	}
+	var customMerge = options.customMerge(key);
+	return typeof customMerge === 'function' ? customMerge : deepmerge
+}
+
+function getEnumerableOwnPropertySymbols(target) {
+	return Object.getOwnPropertySymbols
+		? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+			return Object.propertyIsEnumerable.call(target, symbol)
+		})
+		: []
+}
+
+function getKeys(target) {
+	return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
+}
+
+function propertyIsOnObject(object, property) {
+	try {
+		return property in object
+	} catch(_) {
+		return false
+	}
+}
+
+// Protects from prototype poisoning and unexpected merging up the prototype chain.
+function propertyIsUnsafe(target, key) {
+	return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
+		&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
+			&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
+}
+
+function mergeObject(target, source, options) {
+	var destination = {};
+	if (options.isMergeableObject(target)) {
+		getKeys(target).forEach(function(key) {
+			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+		});
+	}
+	getKeys(source).forEach(function(key) {
+		if (propertyIsUnsafe(target, key)) {
+			return
+		}
+
+		if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+			destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+		} else {
+			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+		}
+	});
+	return destination
+}
+
+function deepmerge(target, source, options) {
+	options = options || {};
+	options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+	options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+	// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
+	// implementations can use it. The caller may not replace it.
+	options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+
+	var sourceIsArray = Array.isArray(source);
+	var targetIsArray = Array.isArray(target);
+	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+
+	if (!sourceAndTargetTypesMatch) {
+		return cloneUnlessOtherwiseSpecified(source, options)
+	} else if (sourceIsArray) {
+		return options.arrayMerge(target, source, options)
+	} else {
+		return mergeObject(target, source, options)
+	}
+}
+
+deepmerge.all = function deepmergeAll(array, options) {
+	if (!Array.isArray(array)) {
+		throw new Error('first argument should be an array')
+	}
+
+	return array.reduce(function(prev, next) {
+		return deepmerge(prev, next, options)
+	}, {})
+};
+
+var deepmerge_1 = deepmerge;
+
+module.exports = deepmerge_1;
diff --git a/parent_dir/node_modules/floating-ui/core/dist/floating-ui.core.esm.js b/parent_dir/node_modules/floating-ui/core/dist/floating-ui.core.esm.js
new file mode 100644
index 0000000..342af40
--- /dev/null
+++ b/parent_dir/node_modules/floating-ui/core/dist/floating-ui.core.esm.js
@@ -0,0 +1,1029 @@
+function getBasePlacement(placement) {
+  return placement.split('-')[0];
+}
+
+function getAlignment(placement) {
+  return placement.split('-')[1];
+}
+
+function getMainAxisFromPlacement(placement) {
+  return ['top', 'bottom'].includes(getBasePlacement(placement)) ? 'x' : 'y';
+}
+
+function getLengthFromAxis(axis) {
+  return axis === 'y' ? 'height' : 'width';
+}
+
+function computeCoordsFromPlacement(_ref) {
+  let {
+    reference,
+    floating,
+    placement
+  } = _ref;
+  const commonX = reference.x + reference.width / 2 - floating.width / 2;
+  const commonY = reference.y + reference.height / 2 - floating.height / 2;
+  let coords;
+
+  switch (getBasePlacement(placement)) {
+    case 'top':
+      coords = {
+        x: commonX,
+        y: reference.y - floating.height
+      };
+      break;
+
+    case 'bottom':
+      coords = {
+        x: commonX,
+        y: reference.y + reference.height
+      };
+      break;
+
+    case 'right':
+      coords = {
+        x: reference.x + reference.width,
+        y: commonY
+      };
+      break;
+
+    case 'left':
+      coords = {
+        x: reference.x - floating.width,
+        y: commonY
+      };
+      break;
+
+    default:
+      coords = {
+        x: reference.x,
+        y: reference.y
+      };
+  }
+
+  const mainAxis = getMainAxisFromPlacement(placement);
+  const length = getLengthFromAxis(mainAxis);
+
+  switch (getAlignment(placement)) {
+    case 'start':
+      coords[mainAxis] = coords[mainAxis] - (reference[length] / 2 - floating[length] / 2);
+      break;
+
+    case 'end':
+      coords[mainAxis] = coords[mainAxis] + (reference[length] / 2 - floating[length] / 2);
+      break;
+  }
+
+  return coords;
+}
+
+const computePosition = async (reference, floating, config) => {
+  const {
+    placement = 'bottom',
+    strategy = 'absolute',
+    middleware = [],
+    platform
+  } = config;
+
+  if (process.env.NODE_ENV !== "production") {
+    if (platform == null) {
+      console.error(['Floating UI: `platform` property was not passed to config. If you', 'want to use Floating UI on the web, install @floating-ui/dom', 'instead of the /core package. Otherwise, you can create your own', '`platform`: https://floating-ui.com/docs/platform'].join(' '));
+    }
+
+    if (middleware.filter(_ref => {
+      let {
+        name
+      } = _ref;
+      return name === 'autoPlacement' || name === 'flip';
+    }).length > 1) {
+      throw new Error(['Floating UI: duplicate `flip` and/or `autoPlacement`', 'middleware detected. This will lead to an infinite loop. Ensure only', 'one of either has been passed to the `middleware` array.'].join(' '));
+    }
+  }
+
+  let rects = await platform.getElementRects({
+    reference,
+    floating,
+    strategy
+  });
+  let {
+    x,
+    y
+  } = computeCoordsFromPlacement({ ...rects,
+    placement
+  });
+  let statefulPlacement = placement;
+  let middlewareData = {};
+  let _debug_loop_count_ = 0;
+
+  for (let i = 0; i < middleware.length; i++) {
+    if (process.env.NODE_ENV !== "production") {
+      _debug_loop_count_++;
+
+      if (_debug_loop_count_ > 100) {
+        throw new Error(['Floating UI: The middleware lifecycle appears to be', 'running in an infinite loop. This is usually caused by a `reset`', 'continually being returned without a break condition.'].join(' '));
+      }
+    }
+
+    const {
+      name,
+      fn
+    } = middleware[i];
+    const {
+      x: nextX,
+      y: nextY,
+      data,
+      reset
+    } = await fn({
+      x,
+      y,
+      initialPlacement: placement,
+      placement: statefulPlacement,
+      strategy,
+      middlewareData,
+      rects,
+      platform,
+      elements: {
+        reference,
+        floating
+      }
+    });
+    x = nextX != null ? nextX : x;
+    y = nextY != null ? nextY : y;
+    middlewareData = { ...middlewareData,
+      [name]: data != null ? data : {}
+    };
+
+    if (reset) {
+      if (typeof reset === 'object') {
+        if (reset.placement) {
+          statefulPlacement = reset.placement;
+        }
+
+        if (reset.rects) {
+          rects = reset.rects === true ? await platform.getElementRects({
+            reference,
+            floating,
+            strategy
+          }) : reset.rects;
+        }
+
+        ({
+          x,
+          y
+        } = computeCoordsFromPlacement({ ...rects,
+          placement: statefulPlacement
+        }));
+      }
+
+      i = -1;
+      continue;
+    }
+  }
+
+  return {
+    x,
+    y,
+    placement: statefulPlacement,
+    strategy,
+    middlewareData
+  };
+};
+
+function expandPaddingObject(padding) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...padding
+  };
+}
+
+function getSideObjectFromPadding(padding) {
+  return typeof padding !== 'number' ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+
+function rectToClientRect(rect) {
+  return { ...rect,
+    top: rect.y,
+    left: rect.x,
+    right: rect.x + rect.width,
+    bottom: rect.y + rect.height
+  };
+}
+
+async function detectOverflow(middlewareArguments, options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  const {
+    x,
+    y,
+    platform,
+    rects,
+    elements,
+    strategy
+  } = middlewareArguments;
+  const {
+    boundary = 'clippingParents',
+    rootBoundary = 'viewport',
+    elementContext = 'floating',
+    altBoundary = false,
+    padding = 0
+  } = options;
+  const paddingObject = getSideObjectFromPadding(padding);
+  const altContext = elementContext === 'floating' ? 'reference' : 'floating';
+  const element = elements[altBoundary ? altContext : elementContext];
+  const clippingClientRect = await platform.getClippingClientRect({
+    element: (await platform.isElement(element)) ? element : element.contextElement || (await platform.getDocumentElement({
+      element: elements.floating
+    })),
+    boundary,
+    rootBoundary
+  });
+  const elementClientRect = rectToClientRect(await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+    rect: elementContext === 'floating' ? { ...rects.floating,
+      x,
+      y
+    } : rects.reference,
+    offsetParent: await platform.getOffsetParent({
+      element: elements.floating
+    }),
+    strategy
+  })); // positive = overflowing the clipping rect
+  // 0 or negative = within the clipping rect
+
+  return {
+    top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
+    bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
+    left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
+    right: elementClientRect.right - clippingClientRect.right + paddingObject.right
+  };
+}
+
+const min = Math.min;
+const max = Math.max;
+
+function within(min$1, value, max$1) {
+  return max(min$1, min(value, max$1));
+}
+
+const arrow = options => ({
+  name: 'arrow',
+  options,
+
+  async fn(middlewareArguments) {
+    // Since `element` is required, we don't Partial<> the type
+    const {
+      element,
+      padding = 0
+    } = options != null ? options : {};
+    const {
+      x,
+      y,
+      placement,
+      rects,
+      platform
+    } = middlewareArguments;
+
+    if (element == null) {
+      if (process.env.NODE_ENV !== "production") {
+        console.warn('Floating UI: No `element` was passed to the `arrow` middleware.');
+      }
+
+      return {};
+    }
+
+    const paddingObject = getSideObjectFromPadding(padding);
+    const coords = {
+      x,
+      y
+    };
+    const basePlacement = getBasePlacement(placement);
+    const axis = getMainAxisFromPlacement(basePlacement);
+    const length = getLengthFromAxis(axis);
+    const arrowDimensions = await platform.getDimensions({
+      element
+    });
+    const minProp = axis === 'y' ? 'top' : 'left';
+    const maxProp = axis === 'y' ? 'bottom' : 'right';
+    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
+    const startDiff = coords[axis] - rects.reference[axis];
+    const arrowOffsetParent = await platform.getOffsetParent({
+      element
+    });
+    const clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
+    const centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the floating element if the center
+    // point is outside of the floating element's bounds
+
+    const min = paddingObject[minProp];
+    const max = clientSize - arrowDimensions[length] - paddingObject[maxProp];
+    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+    const offset = within(min, center, max);
+    return {
+      data: {
+        [axis]: offset,
+        centerOffset: center - offset
+      }
+    };
+  }
+
+});
+
+const hash$1 = {
+  left: 'right',
+  right: 'left',
+  bottom: 'top',
+  top: 'bottom'
+};
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, matched => hash$1[matched]);
+}
+
+function getAlignmentSides(placement, rects) {
+  const isStart = getAlignment(placement) === 'start';
+  const mainAxis = getMainAxisFromPlacement(placement);
+  const length = getLengthFromAxis(mainAxis);
+  let mainAlignmentSide = mainAxis === 'x' ? isStart ? 'right' : 'left' : isStart ? 'bottom' : 'top';
+
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+
+  return {
+    main: mainAlignmentSide,
+    cross: getOppositePlacement(mainAlignmentSide)
+  };
+}
+
+const hash = {
+  start: 'end',
+  end: 'start'
+};
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, matched => hash[matched]);
+}
+
+const basePlacements = ['top', 'right', 'bottom', 'left'];
+const allPlacements = /*#__PURE__*/basePlacements.reduce((acc, basePlacement) => acc.concat(basePlacement, basePlacement + "-start", basePlacement + "-end"), []);
+
+function getPlacementList(alignment, autoAlignment, allowedPlacements) {
+  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getBasePlacement(placement) === placement);
+  return allowedPlacementsSortedByAlignment.filter(placement => {
+    if (alignment) {
+      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);
+    }
+
+    return true;
+  });
+}
+const autoPlacement = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  return {
+    name: 'autoPlacement',
+    options,
+
+    async fn(middlewareArguments) {
+      var _middlewareData$autoP, _middlewareData$autoP2, _middlewareData$autoP3, _middlewareData$autoP4, _middlewareData$autoP5, _placementsSortedByLe;
+
+      const {
+        x,
+        y,
+        rects,
+        middlewareData,
+        placement
+      } = middlewareArguments;
+      const {
+        alignment = null,
+        allowedPlacements = allPlacements,
+        autoAlignment = true,
+        ...detectOverflowOptions
+      } = options;
+
+      if ((_middlewareData$autoP = middlewareData.autoPlacement) != null && _middlewareData$autoP.skip) {
+        return {};
+      }
+
+      const placements = getPlacementList(alignment, autoAlignment, allowedPlacements);
+      const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
+      const currentIndex = (_middlewareData$autoP2 = (_middlewareData$autoP3 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP3.index) != null ? _middlewareData$autoP2 : 0;
+      const currentPlacement = placements[currentIndex];
+      const {
+        main,
+        cross
+      } = getAlignmentSides(currentPlacement, rects); // Make `computeCoords` start from the right place
+
+      if (placement !== currentPlacement) {
+        return {
+          x,
+          y,
+          reset: {
+            placement: placements[0]
+          }
+        };
+      }
+
+      const currentOverflows = [overflow[getBasePlacement(currentPlacement)], overflow[main], overflow[cross]];
+      const allOverflows = [...((_middlewareData$autoP4 = (_middlewareData$autoP5 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP5.overflows) != null ? _middlewareData$autoP4 : []), {
+        placement: currentPlacement,
+        overflows: currentOverflows
+      }];
+      const nextPlacement = placements[currentIndex + 1]; // There are more placements to check
+
+      if (nextPlacement) {
+        return {
+          data: {
+            index: currentIndex + 1,
+            overflows: allOverflows
+          },
+          reset: {
+            placement: nextPlacement
+          }
+        };
+      }
+
+      const placementsSortedByLeastOverflow = allOverflows.slice().sort((a, b) => a.overflows[0] - b.overflows[0]);
+      const placementThatFitsOnAllSides = (_placementsSortedByLe = placementsSortedByLeastOverflow.find(_ref => {
+        let {
+          overflows
+        } = _ref;
+        return overflows.every(overflow => overflow <= 0);
+      })) == null ? void 0 : _placementsSortedByLe.placement;
+      return {
+        data: {
+          skip: true
+        },
+        reset: {
+          placement: placementThatFitsOnAllSides != null ? placementThatFitsOnAllSides : placementsSortedByLeastOverflow[0].placement
+        }
+      };
+    }
+
+  };
+};
+
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+
+const flip = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  return {
+    name: 'flip',
+    options,
+
+    async fn(middlewareArguments) {
+      var _middlewareData$flip, _middlewareData$flip2;
+
+      const {
+        placement,
+        middlewareData,
+        rects,
+        initialPlacement
+      } = middlewareArguments;
+
+      if ((_middlewareData$flip = middlewareData.flip) != null && _middlewareData$flip.skip) {
+        return {};
+      }
+
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true,
+        fallbackPlacements: specifiedFallbackPlacements,
+        fallbackStrategy = 'bestFit',
+        flipAlignment = true,
+        ...detectOverflowOptions
+      } = options;
+      const basePlacement = getBasePlacement(placement);
+      const isBasePlacement = basePlacement === initialPlacement;
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+      const placements = [initialPlacement, ...fallbackPlacements];
+      const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
+      const overflows = [];
+      let overflowsData = ((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.overflows) || [];
+
+      if (checkMainAxis) {
+        overflows.push(overflow[basePlacement]);
+      }
+
+      if (checkCrossAxis) {
+        const {
+          main,
+          cross
+        } = getAlignmentSides(placement, rects);
+        overflows.push(overflow[main], overflow[cross]);
+      }
+
+      overflowsData = [...overflowsData, {
+        placement,
+        overflows
+      }]; // One or more sides is overflowing
+
+      if (!overflows.every(side => side <= 0)) {
+        var _middlewareData$flip$, _middlewareData$flip3;
+
+        const nextIndex = ((_middlewareData$flip$ = (_middlewareData$flip3 = middlewareData.flip) == null ? void 0 : _middlewareData$flip3.index) != null ? _middlewareData$flip$ : 0) + 1;
+        const nextPlacement = placements[nextIndex];
+
+        if (nextPlacement) {
+          // Try next placement and re-run the lifecycle
+          return {
+            data: {
+              index: nextIndex,
+              overflows: overflowsData
+            },
+            reset: {
+              placement: nextPlacement
+            }
+          };
+        }
+
+        let resetPlacement = 'bottom';
+
+        switch (fallbackStrategy) {
+          case 'bestFit':
+            {
+              var _overflowsData$slice$;
+
+              const placement = (_overflowsData$slice$ = overflowsData.slice().sort((a, b) => a.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0) - b.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0))[0]) == null ? void 0 : _overflowsData$slice$.placement;
+
+              if (placement) {
+                resetPlacement = placement;
+              }
+
+              break;
+            }
+
+          case 'initialPlacement':
+            resetPlacement = initialPlacement;
+            break;
+        }
+
+        return {
+          data: {
+            skip: true
+          },
+          reset: {
+            placement: resetPlacement
+          }
+        };
+      }
+
+      return {};
+    }
+
+  };
+};
+
+function getSideOffsets(overflow, rect) {
+  return {
+    top: overflow.top - rect.height,
+    right: overflow.right - rect.width,
+    bottom: overflow.bottom - rect.height,
+    left: overflow.left - rect.width
+  };
+}
+
+function isAnySideFullyClipped(overflow) {
+  return basePlacements.some(side => overflow[side] >= 0);
+}
+
+const hide = () => ({
+  name: 'hide',
+
+  async fn(modifierArguments) {
+    const referenceOverflow = await detectOverflow(modifierArguments, {
+      elementContext: 'reference'
+    });
+    const floatingAltOverflow = await detectOverflow(modifierArguments, {
+      altBoundary: true
+    });
+    const referenceHiddenOffsets = getSideOffsets(referenceOverflow, modifierArguments.rects.reference);
+    const escapedOffsets = getSideOffsets(floatingAltOverflow, modifierArguments.rects.floating);
+    const referenceHidden = isAnySideFullyClipped(referenceHiddenOffsets);
+    const escaped = isAnySideFullyClipped(escapedOffsets);
+    return {
+      data: {
+        referenceHidden,
+        referenceHiddenOffsets,
+        escaped,
+        escapedOffsets
+      }
+    };
+  }
+
+});
+
+function convertValueToCoords(_ref) {
+  let {
+    placement,
+    rects,
+    value
+  } = _ref;
+  const basePlacement = getBasePlacement(placement);
+  const multiplier = ['left', 'top'].includes(basePlacement) ? -1 : 1;
+  const rawValue = typeof value === 'function' ? value({ ...rects,
+    placement
+  }) : value;
+  const {
+    mainAxis,
+    crossAxis
+  } = typeof rawValue === 'number' ? {
+    mainAxis: rawValue,
+    crossAxis: 0
+  } : {
+    mainAxis: 0,
+    crossAxis: 0,
+    ...rawValue
+  };
+  return getMainAxisFromPlacement(basePlacement) === 'x' ? {
+    x: crossAxis,
+    y: mainAxis * multiplier
+  } : {
+    x: mainAxis * multiplier,
+    y: crossAxis
+  };
+}
+const offset = function (value) {
+  if (value === void 0) {
+    value = 0;
+  }
+
+  return {
+    name: 'offset',
+    options: value,
+
+    fn(middlewareArguments) {
+      const {
+        x,
+        y,
+        placement,
+        rects
+      } = middlewareArguments;
+      const diffCoords = convertValueToCoords({
+        placement,
+        rects,
+        value
+      });
+      return {
+        x: x + diffCoords.x,
+        y: y + diffCoords.y,
+        data: diffCoords
+      };
+    }
+
+  };
+};
+
+function getCrossAxis(axis) {
+  return axis === 'x' ? 'y' : 'x';
+}
+
+const shift = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  return {
+    name: 'shift',
+    options,
+
+    async fn(middlewareArguments) {
+      const {
+        x,
+        y,
+        placement
+      } = middlewareArguments;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = false,
+        limiter = {
+          fn: _ref => {
+            let {
+              x,
+              y
+            } = _ref;
+            return {
+              x,
+              y
+            };
+          }
+        },
+        ...detectOverflowOptions
+      } = options;
+      const coords = {
+        x,
+        y
+      };
+      const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
+      const mainAxis = getMainAxisFromPlacement(getBasePlacement(placement));
+      const crossAxis = getCrossAxis(mainAxis);
+      let mainAxisCoord = coords[mainAxis];
+      let crossAxisCoord = coords[crossAxis];
+
+      if (checkMainAxis) {
+        const minSide = mainAxis === 'y' ? 'top' : 'left';
+        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';
+        const min = mainAxisCoord + overflow[minSide];
+        const max = mainAxisCoord - overflow[maxSide];
+        mainAxisCoord = within(min, mainAxisCoord, max);
+      }
+
+      if (checkCrossAxis) {
+        const minSide = crossAxis === 'y' ? 'top' : 'left';
+        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';
+        const min = crossAxisCoord + overflow[minSide];
+        const max = crossAxisCoord - overflow[maxSide];
+        crossAxisCoord = within(min, crossAxisCoord, max);
+      }
+
+      const limitedCoords = limiter.fn({ ...middlewareArguments,
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
+      });
+      return { ...limitedCoords,
+        data: {
+          x: limitedCoords.x - x,
+          y: limitedCoords.y - y
+        }
+      };
+    }
+
+  };
+};
+const limitShift = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  return {
+    options,
+
+    fn(middlewareArguments) {
+      const {
+        x,
+        y,
+        placement,
+        rects,
+        middlewareData
+      } = middlewareArguments;
+      const {
+        offset = 0,
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true
+      } = options;
+      const coords = {
+        x,
+        y
+      };
+      const mainAxis = getMainAxisFromPlacement(placement);
+      const crossAxis = getCrossAxis(mainAxis);
+      let mainAxisCoord = coords[mainAxis];
+      let crossAxisCoord = coords[crossAxis];
+      const rawOffset = typeof offset === 'function' ? offset({ ...rects,
+        placement
+      }) : offset;
+      const computedOffset = typeof rawOffset === 'number' ? {
+        mainAxis: rawOffset,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...rawOffset
+      };
+
+      if (checkMainAxis) {
+        const len = mainAxis === 'y' ? 'height' : 'width';
+        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
+        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
+
+        if (mainAxisCoord < limitMin) {
+          mainAxisCoord = limitMin;
+        } else if (mainAxisCoord > limitMax) {
+          mainAxisCoord = limitMax;
+        }
+      }
+
+      if (checkCrossAxis) {
+        var _middlewareData$offse, _middlewareData$offse2, _middlewareData$offse3, _middlewareData$offse4;
+
+        const len = mainAxis === 'y' ? 'width' : 'height';
+        const isOriginSide = ['top', 'left'].includes(getBasePlacement(placement));
+        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? (_middlewareData$offse = (_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) != null ? _middlewareData$offse : 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
+        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : (_middlewareData$offse3 = (_middlewareData$offse4 = middlewareData.offset) == null ? void 0 : _middlewareData$offse4[crossAxis]) != null ? _middlewareData$offse3 : 0) - (isOriginSide ? computedOffset.crossAxis : 0);
+
+        if (crossAxisCoord < limitMin) {
+          crossAxisCoord = limitMin;
+        } else if (crossAxisCoord > limitMax) {
+          crossAxisCoord = limitMax;
+        }
+      }
+
+      return {
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
+      };
+    }
+
+  };
+};
+
+const size = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  return {
+    name: 'size',
+    options,
+
+    async fn(middlewareArguments) {
+      var _middlewareData$size;
+
+      const {
+        placement,
+        rects,
+        middlewareData
+      } = middlewareArguments;
+      const {
+        apply,
+        ...detectOverflowOptions
+      } = options;
+
+      if ((_middlewareData$size = middlewareData.size) != null && _middlewareData$size.skip) {
+        return {};
+      }
+
+      const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
+      const basePlacement = getBasePlacement(placement);
+      const isEnd = getAlignment(placement) === 'end';
+      let heightSide;
+      let widthSide;
+
+      if (basePlacement === 'top' || basePlacement === 'bottom') {
+        heightSide = basePlacement;
+        widthSide = isEnd ? 'left' : 'right';
+      } else {
+        widthSide = basePlacement;
+        heightSide = isEnd ? 'top' : 'bottom';
+      }
+
+      const xMin = max(overflow.left, 0);
+      const xMax = max(overflow.right, 0);
+      const yMin = max(overflow.top, 0);
+      const yMax = max(overflow.bottom, 0);
+      const dimensions = {
+        height: rects.floating.height - (['left', 'right'].includes(placement) ? 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom)) : overflow[heightSide]),
+        width: rects.floating.width - (['top', 'bottom'].includes(placement) ? 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right)) : overflow[widthSide])
+      };
+      apply == null ? void 0 : apply({ ...dimensions,
+        ...rects
+      });
+      return {
+        data: {
+          skip: true
+        },
+        reset: {
+          rects: true
+        }
+      };
+    }
+
+  };
+};
+
+const inline = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  return {
+    name: 'inline',
+    options,
+
+    async fn(middlewareArguments) {
+      var _middlewareData$inlin, _await$platform$getCl;
+
+      const {
+        placement,
+        elements,
+        rects,
+        platform,
+        strategy,
+        middlewareData
+      } = middlewareArguments; // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a
+      // ClientRect's bounds, despite the event listener being triggered. A
+      // padding of 2 seems to handle this issue.
+
+      const {
+        padding = 2,
+        x,
+        y
+      } = options;
+
+      if ((_middlewareData$inlin = middlewareData.inline) != null && _middlewareData$inlin.skip) {
+        return {};
+      }
+
+      const fallback = rectToClientRect(await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+        rect: rects.reference,
+        offsetParent: await platform.getOffsetParent({
+          element: elements.floating
+        }),
+        strategy
+      }));
+      const clientRects = Array.from((_await$platform$getCl = await (platform.getClientRects == null ? void 0 : platform.getClientRects({
+        element: elements.reference
+      }))) != null ? _await$platform$getCl : []);
+      const paddingObject = getSideObjectFromPadding(padding);
+
+      function getBoundingClientRect() {
+        // There are two rects and they are disjoined
+        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {
+          var _clientRects$find;
+
+          // Find the first rect in which the point is fully inside
+          return (_clientRects$find = clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom)) != null ? _clientRects$find : fallback;
+        } // There are 2 or more connected rects
+
+
+        if (clientRects.length >= 2) {
+          if (getMainAxisFromPlacement(placement) === 'x') {
+            const firstRect = clientRects[0];
+            const lastRect = clientRects[clientRects.length - 1];
+            const isTop = getBasePlacement(placement) === 'top';
+            const top = firstRect.top;
+            const bottom = lastRect.bottom;
+            const left = isTop ? firstRect.left : lastRect.left;
+            const right = isTop ? firstRect.right : lastRect.right;
+            const width = right - left;
+            const height = bottom - top;
+            return {
+              top,
+              bottom,
+              left,
+              right,
+              width,
+              height,
+              x: left,
+              y: top
+            };
+          }
+
+          const isLeftPlacement = getBasePlacement(placement) === 'left';
+          const maxRight = max(...clientRects.map(rect => rect.right));
+          const minLeft = min(...clientRects.map(rect => rect.left));
+          const measureRects = clientRects.filter(rect => isLeftPlacement ? rect.left === minLeft : rect.right === maxRight);
+          const top = measureRects[0].top;
+          const bottom = measureRects[measureRects.length - 1].bottom;
+          const left = minLeft;
+          const right = maxRight;
+          const width = right - left;
+          const height = bottom - top;
+          return {
+            top,
+            bottom,
+            left,
+            right,
+            width,
+            height,
+            x: left,
+            y: top
+          };
+        }
+
+        return fallback;
+      }
+
+      return {
+        data: {
+          skip: true
+        },
+        reset: {
+          rects: await platform.getElementRects({
+            reference: {
+              getBoundingClientRect
+            },
+            floating: elements.floating,
+            strategy
+          })
+        }
+      };
+    }
+
+  };
+};
+
+export { arrow, autoPlacement, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, rectToClientRect, shift, size };
diff --git a/parent_dir/node_modules/floating-ui/dom/dist/floating-ui.dom.esm.js b/parent_dir/node_modules/floating-ui/dom/dist/floating-ui.dom.esm.js
new file mode 100644
index 0000000..58c7520
--- /dev/null
+++ b/parent_dir/node_modules/floating-ui/dom/dist/floating-ui.dom.esm.js
@@ -0,0 +1,488 @@
+import { rectToClientRect, computePosition as computePosition$1 } from '@floating-ui/core';
+export { arrow, autoPlacement, detectOverflow, flip, hide, inline, limitShift, offset, shift, size } from '@floating-ui/core';
+
+function isWindow(value) {
+  return (value == null ? void 0 : value.toString()) === '[object Window]';
+}
+function getWindow(node) {
+  if (node == null) {
+    return window;
+  }
+
+  if (!isWindow(node)) {
+    const ownerDocument = node.ownerDocument;
+    return ownerDocument ? ownerDocument.defaultView || window : window;
+  }
+
+  return node;
+}
+
+function getComputedStyle$1(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+
+function getNodeName(node) {
+  return isWindow(node) ? '' : node ? (node.nodeName || '').toLowerCase() : '';
+}
+
+function isHTMLElement(value) {
+  return value instanceof getWindow(value).HTMLElement;
+}
+function isElement(value) {
+  return value instanceof getWindow(value).Element;
+}
+function isNode(value) {
+  return value instanceof getWindow(value).Node;
+}
+function isShadowRoot(node) {
+  const OwnElement = getWindow(node).ShadowRoot;
+  return node instanceof OwnElement || node instanceof ShadowRoot;
+}
+function isScrollParent(element) {
+  // Firefox wants us to check `-x` and `-y` variations as well
+  const {
+    overflow,
+    overflowX,
+    overflowY
+  } = getComputedStyle$1(element);
+  return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
+}
+function isTableElement(element) {
+  return ['table', 'td', 'th'].includes(getNodeName(element));
+}
+function isContainingBlock(element) {
+  // TODO: Try and use feature detection here instead
+  const isFirefox = navigator.userAgent.toLowerCase().includes('firefox');
+  const css = getComputedStyle$1(element); // This is non-exhaustive but covers the most common CSS properties that
+  // create a containing block.
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+
+  return css.transform !== 'none' || css.perspective !== 'none' || css.contain === 'paint' || ['transform', 'perspective'].includes(css.willChange) || isFirefox && css.willChange === 'filter' || isFirefox && (css.filter ? css.filter !== 'none' : false);
+}
+
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+
+function getBoundingClientRect(element, includeScale) {
+  if (includeScale === void 0) {
+    includeScale = false;
+  }
+
+  const clientRect = element.getBoundingClientRect();
+  let scaleX = 1;
+  let scaleY = 1;
+
+  if (includeScale && isHTMLElement(element)) {
+    scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;
+    scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;
+  }
+
+  return {
+    width: clientRect.width / scaleX,
+    height: clientRect.height / scaleY,
+    top: clientRect.top / scaleY,
+    right: clientRect.right / scaleX,
+    bottom: clientRect.bottom / scaleY,
+    left: clientRect.left / scaleX,
+    x: clientRect.left / scaleX,
+    y: clientRect.top / scaleY
+  };
+}
+
+function getDocumentElement(node) {
+  return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;
+}
+
+function getNodeScroll(element) {
+  if (isWindow(element)) {
+    return {
+      scrollLeft: element.pageXOffset,
+      scrollTop: element.pageYOffset
+    };
+  }
+
+  return {
+    scrollLeft: element.scrollLeft,
+    scrollTop: element.scrollTop
+  };
+}
+
+function getWindowScrollBarX(element) {
+  // If <html> has a CSS width greater than the viewport, then this will be
+  // incorrect for RTL.
+  return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
+}
+
+function isScaled(element) {
+  const rect = getBoundingClientRect(element);
+  return round(rect.width) !== element.offsetWidth || round(rect.height) !== element.offsetHeight;
+}
+
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  const documentElement = getDocumentElement(offsetParent);
+  const rect = getBoundingClientRect(element, isOffsetParentAnElement && isScaled(offsetParent));
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const offsets = {
+    x: 0,
+    y: 0
+  };
+
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {
+    if (getNodeName(offsetParent) !== 'body' || isScrollParent(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+
+    if (isHTMLElement(offsetParent)) {
+      const offsetRect = getBoundingClientRect(offsetParent, true);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    } else if (documentElement) {
+      offsets.x = getWindowScrollBarX(documentElement);
+    }
+  }
+
+  return {
+    x: rect.left + scroll.scrollLeft - offsets.x,
+    y: rect.top + scroll.scrollTop - offsets.y,
+    width: rect.width,
+    height: rect.height
+  };
+}
+
+function getParentNode(node) {
+  if (getNodeName(node) === 'html') {
+    return node;
+  }
+
+  return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
+    // @ts-ignore
+    node.assignedSlot || // step into the shadow DOM of the parent of a slotted node
+    node.parentNode || ( // DOM Element detected
+    isShadowRoot(node) ? node.host : null) || // ShadowRoot detected
+    getDocumentElement(node) // fallback
+
+  );
+}
+
+function getTrueOffsetParent(element) {
+  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {
+    return null;
+  }
+
+  return element.offsetParent;
+}
+
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+
+  while (isHTMLElement(currentNode) && !['html', 'body'].includes(getNodeName(currentNode))) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else {
+      currentNode = currentNode.parentNode;
+    }
+  }
+
+  return null;
+} // Gets the closest ancestor positioned element. Handles some edge cases,
+// such as table ancestors and cross browser bugs.
+
+
+function getOffsetParent(element) {
+  const window = getWindow(element);
+  let offsetParent = getTrueOffsetParent(element);
+
+  while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === 'static') {
+    offsetParent = getTrueOffsetParent(offsetParent);
+  }
+
+  if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {
+    return window;
+  }
+
+  return offsetParent || getContainingBlock(element) || window;
+}
+
+function getDimensions(element) {
+  return {
+    width: element.offsetWidth,
+    height: element.offsetHeight
+  };
+}
+
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+  let {
+    rect,
+    offsetParent,
+    strategy
+  } = _ref;
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  const documentElement = getDocumentElement(offsetParent);
+
+  if (offsetParent === documentElement) {
+    return rect;
+  }
+
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const offsets = {
+    x: 0,
+    y: 0
+  };
+
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {
+    if (getNodeName(offsetParent) !== 'body' || isScrollParent(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+
+    if (isHTMLElement(offsetParent)) {
+      const offsetRect = getBoundingClientRect(offsetParent, true);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    } // This doesn't appear to be need to be negated.
+    // else if (documentElement) {
+    //   offsets.x = getWindowScrollBarX(documentElement);
+    // }
+
+  }
+
+  return { ...rect,
+    x: rect.x - scroll.scrollLeft + offsets.x,
+    y: rect.y - scroll.scrollTop + offsets.y
+  };
+}
+
+function getViewportRect(element) {
+  const win = getWindow(element);
+  const html = getDocumentElement(element);
+  const visualViewport = win.visualViewport;
+  let width = html.clientWidth;
+  let height = html.clientHeight;
+  let x = 0;
+  let y = 0;
+
+  if (visualViewport) {
+    width = visualViewport.width;
+    height = visualViewport.height; // Uses Layout Viewport (like Chrome; Safari does not currently)
+    // In Chrome, it returns a value very close to 0 (+/-) but contains rounding
+    // errors due to floating point numbers, so we need to check precision.
+    // Safari returns a number <= 0, usually < -1 when pinch-zoomed
+
+    if (Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) < 0.01) {
+      x = visualViewport.offsetLeft;
+      y = visualViewport.offsetTop;
+    }
+  }
+
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+
+// of the `<html>` and `<body>` rect bounds if horizontally scrollable
+
+function getDocumentRect(element) {
+  var _element$ownerDocumen;
+
+  const html = getDocumentElement(element);
+  const scroll = getNodeScroll(element);
+  const body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
+  const width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
+  const height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
+  let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+  const y = -scroll.scrollTop;
+
+  if (getComputedStyle$1(body || html).direction === 'rtl') {
+    x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
+  }
+
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+
+function getScrollParent(node) {
+  if (['html', 'body', '#document'].includes(getNodeName(node))) {
+    // @ts-ignore assume body is always available
+    return node.ownerDocument.body;
+  }
+
+  if (isHTMLElement(node) && isScrollParent(node)) {
+    return node;
+  }
+
+  return getScrollParent(getParentNode(node));
+}
+
+function getScrollParents(node, list) {
+  var _node$ownerDocument;
+
+  if (list === void 0) {
+    list = [];
+  }
+
+  const scrollParent = getScrollParent(node);
+  const isBody = scrollParent === ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.body);
+  const win = getWindow(scrollParent);
+  const target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
+  const updatedList = list.concat(target);
+  return isBody ? updatedList : // @ts-ignore: isBody tells us target will be an HTMLElement here
+  updatedList.concat(getScrollParents(getParentNode(target)));
+}
+
+function contains(parent, child) {
+  const rootNode = child.getRootNode == null ? void 0 : child.getRootNode(); // First, attempt with faster native method
+
+  if (parent.contains(child)) {
+    return true;
+  } // then fallback to custom implementation with Shadow DOM support
+  else if (rootNode && isShadowRoot(rootNode)) {
+    let next = child;
+
+    do {
+      // use `===` replace node.isSameNode()
+      if (next && parent === next) {
+        return true;
+      } // @ts-ignore: need a better way to handle this...
+
+
+      next = next.parentNode || next.host;
+    } while (next);
+  }
+
+  return false;
+}
+
+function getInnerBoundingClientRect(element) {
+  const clientRect = getBoundingClientRect(element);
+  const top = clientRect.top + element.clientTop;
+  const left = clientRect.left + element.clientLeft;
+  return {
+    top,
+    left,
+    x: left,
+    y: top,
+    right: left + element.clientWidth,
+    bottom: top + element.clientHeight,
+    width: element.clientWidth,
+    height: element.clientHeight
+  };
+}
+
+function getClientRectFromClippingParent(element, clippingParent) {
+  if (clippingParent === 'viewport') {
+    return rectToClientRect(getViewportRect(element));
+  }
+
+  if (isElement(clippingParent)) {
+    return getInnerBoundingClientRect(clippingParent);
+  }
+
+  return rectToClientRect(getDocumentRect(getDocumentElement(element)));
+} // A "clipping parent" is an overflowable container with the characteristic of
+// clipping (or hiding) overflowing elements with a position different from
+// `initial`
+
+
+function getClippingParents(element) {
+  const clippingParents = getScrollParents(getParentNode(element));
+  const canEscapeClipping = ['absolute', 'fixed'].includes(getComputedStyle$1(element).position);
+  const clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
+
+  if (!isElement(clipperElement)) {
+    return [];
+  } // @ts-ignore isElement check ensures we return Array<Element>
+
+
+  return clippingParents.filter(clippingParent => isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body');
+} // Gets the maximum area that the element is visible in due to any number of
+// clipping parents
+
+
+function getClippingClientRect(_ref) {
+  let {
+    element,
+    boundary,
+    rootBoundary
+  } = _ref;
+  const mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary);
+  const clippingParents = [...mainClippingParents, rootBoundary];
+  const firstClippingParent = clippingParents[0];
+  const clippingRect = clippingParents.reduce((accRect, clippingParent) => {
+    const rect = getClientRectFromClippingParent(element, clippingParent);
+    accRect.top = max(rect.top, accRect.top);
+    accRect.right = min(rect.right, accRect.right);
+    accRect.bottom = min(rect.bottom, accRect.bottom);
+    accRect.left = max(rect.left, accRect.left);
+    return accRect;
+  }, getClientRectFromClippingParent(element, firstClippingParent));
+  clippingRect.width = clippingRect.right - clippingRect.left;
+  clippingRect.height = clippingRect.bottom - clippingRect.top;
+  clippingRect.x = clippingRect.left;
+  clippingRect.y = clippingRect.top;
+  return clippingRect;
+}
+
+const platform = {
+  getElementRects: _ref => {
+    let {
+      reference,
+      floating,
+      strategy
+    } = _ref;
+    return {
+      reference: getRectRelativeToOffsetParent(reference, getOffsetParent(floating), strategy),
+      floating: { ...getDimensions(floating),
+        x: 0,
+        y: 0
+      }
+    };
+  },
+  convertOffsetParentRelativeRectToViewportRelativeRect: args => convertOffsetParentRelativeRectToViewportRelativeRect(args),
+  getOffsetParent: _ref2 => {
+    let {
+      element
+    } = _ref2;
+    return getOffsetParent(element);
+  },
+  isElement: value => isElement(value),
+  getDocumentElement: _ref3 => {
+    let {
+      element
+    } = _ref3;
+    return getDocumentElement(element);
+  },
+  getClippingClientRect: args => getClippingClientRect(args),
+  getDimensions: _ref4 => {
+    let {
+      element
+    } = _ref4;
+    return getDimensions(element);
+  },
+  getClientRects: _ref5 => {
+    let {
+      element
+    } = _ref5;
+    return element.getClientRects();
+  }
+};
+
+const computePosition = (reference, floating, options) => computePosition$1(reference, floating, {
+  platform,
+  ...options
+});
+
+export { computePosition, getScrollParents };
diff --git a/parent_dir/node_modules/floating-vue/dist/floating-vue.es.js b/parent_dir/node_modules/floating-vue/dist/floating-vue.es.js
new file mode 100644
index 0000000..c98113e
--- /dev/null
+++ b/parent_dir/node_modules/floating-vue/dist/floating-vue.es.js
@@ -0,0 +1,1833 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { defineComponent, openBlock, createElementBlock, normalizeClass, renderSlot, normalizeProps, guardReactiveProps, pushScopeId, popScopeId, nextTick, createBlock, withScopeId, resolveComponent, normalizeStyle, withKeys, createElementVNode, Fragment, createCommentVNode, withCtx, createVNode, mergeProps, toDisplayString, ref, createApp, h } from "vue";
+import { offset, autoPlacement, shift, flip, arrow, size, computePosition, getScrollParents } from "@floating-ui/dom";
+function assign(to, from) {
+  for (const key in from) {
+    if (Object.prototype.hasOwnProperty.call(from, key)) {
+      if (typeof from[key] === "object" && to[key]) {
+        assign(to[key], from[key]);
+      } else {
+        to[key] = from[key];
+      }
+    }
+  }
+}
+const config = {
+  disabled: false,
+  distance: 5,
+  skidding: 0,
+  container: "body",
+  boundary: void 0,
+  instantMove: false,
+  disposeTimeout: 5e3,
+  popperTriggers: [],
+  strategy: "absolute",
+  preventOverflow: true,
+  flip: true,
+  shift: true,
+  overflowPadding: 0,
+  arrowPadding: 0,
+  arrowOverflow: true,
+  themes: {
+    tooltip: {
+      placement: "top",
+      triggers: ["hover", "focus", "touch"],
+      hideTriggers: (events) => [...events, "click"],
+      delay: {
+        show: 200,
+        hide: 0
+      },
+      handleResize: false,
+      html: false,
+      loadingContent: "..."
+    },
+    dropdown: {
+      placement: "bottom",
+      triggers: ["click"],
+      delay: 0,
+      handleResize: true,
+      autoHide: true
+    },
+    menu: {
+      $extend: "dropdown",
+      triggers: ["hover", "focus"],
+      popperTriggers: ["hover", "focus"],
+      delay: {
+        show: 0,
+        hide: 400
+      }
+    }
+  }
+};
+function getDefaultConfig(theme, key) {
+  let themeConfig = config.themes[theme] || {};
+  let value;
+  do {
+    value = themeConfig[key];
+    if (typeof value === "undefined") {
+      if (themeConfig.$extend) {
+        themeConfig = config.themes[themeConfig.$extend] || {};
+      } else {
+        themeConfig = null;
+        value = config[key];
+      }
+    } else {
+      themeConfig = null;
+    }
+  } while (themeConfig);
+  return value;
+}
+function getThemeClasses(theme) {
+  const result = [theme];
+  let themeConfig = config.themes[theme] || {};
+  do {
+    if (themeConfig.$extend && !themeConfig.$resetCss) {
+      result.push(themeConfig.$extend);
+      themeConfig = config.themes[themeConfig.$extend] || {};
+    } else {
+      themeConfig = null;
+    }
+  } while (themeConfig);
+  return result.map((c) => `v-popper--theme-${c}`);
+}
+function getAllParentThemes(theme) {
+  const result = [theme];
+  let themeConfig = config.themes[theme] || {};
+  do {
+    if (themeConfig.$extend) {
+      result.push(themeConfig.$extend);
+      themeConfig = config.themes[themeConfig.$extend] || {};
+    } else {
+      themeConfig = null;
+    }
+  } while (themeConfig);
+  return result;
+}
+var vueResize = "";
+let supportsPassive = false;
+if (typeof window !== "undefined") {
+  supportsPassive = false;
+  try {
+    const opts = Object.defineProperty({}, "passive", {
+      get() {
+        supportsPassive = true;
+      }
+    });
+    window.addEventListener("test", null, opts);
+  } catch (e) {
+  }
+}
+let isIOS = false;
+if (typeof window !== "undefined" && typeof navigator !== "undefined") {
+  isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
+}
+const placements = ["auto", "top", "bottom", "left", "right"].reduce((acc, base) => acc.concat([
+  base,
+  `${base}-start`,
+  `${base}-end`
+]), []);
+const SHOW_EVENT_MAP = {
+  hover: "mouseenter",
+  focus: "focus",
+  click: "click",
+  touch: "touchstart"
+};
+const HIDE_EVENT_MAP = {
+  hover: "mouseleave",
+  focus: "blur",
+  click: "click",
+  touch: "touchend"
+};
+function removeFromArray(array, item) {
+  const index = array.indexOf(item);
+  if (index !== -1) {
+    array.splice(index, 1);
+  }
+}
+function nextFrame() {
+  return new Promise((resolve) => requestAnimationFrame(() => {
+    requestAnimationFrame(resolve);
+  }));
+}
+const shownPoppers = [];
+let hidingPopper = null;
+const shownPoppersByTheme = {};
+function getShownPoppersByTheme(theme) {
+  let list = shownPoppersByTheme[theme];
+  if (!list) {
+    list = shownPoppersByTheme[theme] = [];
+  }
+  return list;
+}
+let Element = function() {
+};
+if (typeof window !== "undefined") {
+  Element = window.Element;
+}
+function defaultPropFactory(prop) {
+  return function(props) {
+    return getDefaultConfig(props.theme, prop);
+  };
+}
+const PROVIDE_KEY = "__floating-vue__popper";
+var PrivatePopper = () => defineComponent({
+  name: "VPopper",
+  provide() {
+    return {
+      [PROVIDE_KEY]: {
+        parentPopper: this
+      }
+    };
+  },
+  inject: {
+    [PROVIDE_KEY]: { default: null }
+  },
+  props: {
+    theme: {
+      type: String,
+      required: true
+    },
+    targetNodes: {
+      type: Function,
+      required: true
+    },
+    referenceNode: {
+      type: Function,
+      default: null
+    },
+    popperNode: {
+      type: Function,
+      required: true
+    },
+    shown: {
+      type: Boolean,
+      default: false
+    },
+    showGroup: {
+      type: String,
+      default: null
+    },
+    ariaId: {
+      default: null
+    },
+    disabled: {
+      type: Boolean,
+      default: defaultPropFactory("disabled")
+    },
+    positioningDisabled: {
+      type: Boolean,
+      default: defaultPropFactory("positioningDisabled")
+    },
+    placement: {
+      type: String,
+      default: defaultPropFactory("placement"),
+      validator: (value) => placements.includes(value)
+    },
+    delay: {
+      type: [String, Number, Object],
+      default: defaultPropFactory("delay")
+    },
+    distance: {
+      type: [Number, String],
+      default: defaultPropFactory("distance")
+    },
+    skidding: {
+      type: [Number, String],
+      default: defaultPropFactory("skidding")
+    },
+    triggers: {
+      type: Array,
+      default: defaultPropFactory("triggers")
+    },
+    showTriggers: {
+      type: [Array, Function],
+      default: defaultPropFactory("showTriggers")
+    },
+    hideTriggers: {
+      type: [Array, Function],
+      default: defaultPropFactory("hideTriggers")
+    },
+    popperTriggers: {
+      type: Array,
+      default: defaultPropFactory("popperTriggers")
+    },
+    popperShowTriggers: {
+      type: [Array, Function],
+      default: defaultPropFactory("popperShowTriggers")
+    },
+    popperHideTriggers: {
+      type: [Array, Function],
+      default: defaultPropFactory("popperHideTriggers")
+    },
+    container: {
+      type: [String, Object, Element, Boolean],
+      default: defaultPropFactory("container")
+    },
+    boundary: {
+      type: [String, Element],
+      default: defaultPropFactory("boundary")
+    },
+    strategy: {
+      type: String,
+      validator: (value) => ["absolute", "fixed"].includes(value),
+      default: defaultPropFactory("strategy")
+    },
+    autoHide: {
+      type: [Boolean, Function],
+      default: defaultPropFactory("autoHide")
+    },
+    handleResize: {
+      type: Boolean,
+      default: defaultPropFactory("handleResize")
+    },
+    instantMove: {
+      type: Boolean,
+      default: defaultPropFactory("instantMove")
+    },
+    eagerMount: {
+      type: Boolean,
+      default: defaultPropFactory("eagerMount")
+    },
+    popperClass: {
+      type: [String, Array, Object],
+      default: defaultPropFactory("popperClass")
+    },
+    computeTransformOrigin: {
+      type: Boolean,
+      default: defaultPropFactory("computeTransformOrigin")
+    },
+    autoMinSize: {
+      type: Boolean,
+      default: defaultPropFactory("autoMinSize")
+    },
+    autoSize: {
+      type: [Boolean, String],
+      default: defaultPropFactory("autoSize")
+    },
+    autoMaxSize: {
+      type: Boolean,
+      default: defaultPropFactory("autoMaxSize")
+    },
+    autoBoundaryMaxSize: {
+      type: Boolean,
+      default: defaultPropFactory("autoBoundaryMaxSize")
+    },
+    preventOverflow: {
+      type: Boolean,
+      default: defaultPropFactory("preventOverflow")
+    },
+    overflowPadding: {
+      type: [Number, String],
+      default: defaultPropFactory("overflowPadding")
+    },
+    arrowPadding: {
+      type: [Number, String],
+      default: defaultPropFactory("arrowPadding")
+    },
+    arrowOverflow: {
+      type: Boolean,
+      default: defaultPropFactory("arrowOverflow")
+    },
+    flip: {
+      type: Boolean,
+      default: defaultPropFactory("flip")
+    },
+    shift: {
+      type: Boolean,
+      default: defaultPropFactory("shift")
+    },
+    shiftCrossAxis: {
+      type: Boolean,
+      default: defaultPropFactory("shiftCrossAxis")
+    },
+    noAutoFocus: {
+      type: Boolean,
+      default: defaultPropFactory("noAutoFocus")
+    }
+  },
+  emits: [
+    "show",
+    "hide",
+    "update:shown",
+    "apply-show",
+    "apply-hide",
+    "close-group",
+    "close-directive",
+    "auto-hide",
+    "resize",
+    "dispose"
+  ],
+  data() {
+    return {
+      isShown: false,
+      isMounted: false,
+      skipTransition: false,
+      classes: {
+        showFrom: false,
+        showTo: false,
+        hideFrom: false,
+        hideTo: true
+      },
+      result: {
+        x: 0,
+        y: 0,
+        placement: "",
+        strategy: this.strategy,
+        arrow: {
+          x: 0,
+          y: 0,
+          centerOffset: 0
+        },
+        transformOrigin: null
+      },
+      shownChildren: new Set(),
+      lastAutoHide: true
+    };
+  },
+  computed: {
+    popperId() {
+      return this.ariaId != null ? this.ariaId : this.randomId;
+    },
+    shouldMountContent() {
+      return this.eagerMount || this.isMounted;
+    },
+    slotData() {
+      return {
+        popperId: this.popperId,
+        isShown: this.isShown,
+        shouldMountContent: this.shouldMountContent,
+        skipTransition: this.skipTransition,
+        autoHide: typeof this.autoHide === "function" ? this.lastAutoHide : this.autoHide,
+        show: this.show,
+        hide: this.hide,
+        handleResize: this.handleResize,
+        onResize: this.onResize,
+        classes: __spreadProps(__spreadValues({}, this.classes), {
+          popperClass: this.popperClass
+        }),
+        result: this.positioningDisabled ? null : this.result,
+        attrs: this.$attrs
+      };
+    },
+    parentPopper() {
+      var _a;
+      return (_a = this[PROVIDE_KEY]) == null ? void 0 : _a.parentPopper;
+    },
+    hasPopperShowTriggerHover() {
+      var _a, _b;
+      return ((_a = this.popperTriggers) == null ? void 0 : _a.includes("hover")) || ((_b = this.popperShowTriggers) == null ? void 0 : _b.includes("hover"));
+    }
+  },
+  watch: __spreadValues(__spreadValues({
+    shown: "$_autoShowHide",
+    disabled(value) {
+      if (value) {
+        this.dispose();
+      } else {
+        this.init();
+      }
+    },
+    async container() {
+      if (this.isShown) {
+        this.$_ensureTeleport();
+        await this.$_computePosition();
+      }
+    }
+  }, [
+    "triggers",
+    "positioningDisabled"
+  ].reduce((acc, prop) => {
+    acc[prop] = "$_refreshListeners";
+    return acc;
+  }, {})), [
+    "placement",
+    "distance",
+    "skidding",
+    "boundary",
+    "strategy",
+    "overflowPadding",
+    "arrowPadding",
+    "preventOverflow",
+    "shift",
+    "shiftCrossAxis",
+    "flip"
+  ].reduce((acc, prop) => {
+    acc[prop] = "$_computePosition";
+    return acc;
+  }, {})),
+  created() {
+    this.$_isDisposed = true;
+    this.randomId = `popper_${[Math.random(), Date.now()].map((n) => n.toString(36).substring(2, 10)).join("_")}`;
+    if (this.autoMinSize) {
+      console.warn('[floating-vue] `autoMinSize` option is deprecated. Use `autoSize="min"` instead.');
+    }
+    if (this.autoMaxSize) {
+      console.warn("[floating-vue] `autoMaxSize` option is deprecated. Use `autoBoundaryMaxSize` instead.");
+    }
+  },
+  mounted() {
+    this.init();
+    this.$_detachPopperNode();
+  },
+  activated() {
+    this.$_autoShowHide();
+  },
+  deactivated() {
+    this.hide();
+  },
+  beforeUnmount() {
+    this.dispose();
+  },
+  methods: {
+    show({ event = null, skipDelay = false, force = false } = {}) {
+      var _a, _b;
+      if (((_a = this.parentPopper) == null ? void 0 : _a.lockedChild) && this.parentPopper.lockedChild !== this)
+        return;
+      this.$_pendingHide = false;
+      if (force || !this.disabled) {
+        if (((_b = this.parentPopper) == null ? void 0 : _b.lockedChild) === this) {
+          this.parentPopper.lockedChild = null;
+        }
+        this.$_scheduleShow(event, skipDelay);
+        this.$emit("show");
+        this.$_showFrameLocked = true;
+        requestAnimationFrame(() => {
+          this.$_showFrameLocked = false;
+        });
+      }
+      this.$emit("update:shown", true);
+    },
+    hide({ event = null, skipDelay = false } = {}) {
+      var _a;
+      if (this.$_hideInProgress)
+        return;
+      if (this.shownChildren.size > 0) {
+        this.$_pendingHide = true;
+        return;
+      }
+      if (this.hasPopperShowTriggerHover && this.$_isAimingPopper()) {
+        if (this.parentPopper) {
+          this.parentPopper.lockedChild = this;
+          clearTimeout(this.parentPopper.lockedChildTimer);
+          this.parentPopper.lockedChildTimer = setTimeout(() => {
+            if (this.parentPopper.lockedChild === this) {
+              this.parentPopper.lockedChild.hide({ skipDelay });
+              this.parentPopper.lockedChild = null;
+            }
+          }, 1e3);
+        }
+        return;
+      }
+      if (((_a = this.parentPopper) == null ? void 0 : _a.lockedChild) === this) {
+        this.parentPopper.lockedChild = null;
+      }
+      this.$_pendingHide = false;
+      this.$_scheduleHide(event, skipDelay);
+      this.$emit("hide");
+      this.$emit("update:shown", false);
+    },
+    init() {
+      var _a, _b;
+      if (!this.$_isDisposed)
+        return;
+      this.$_isDisposed = false;
+      this.isMounted = false;
+      this.$_events = [];
+      this.$_preventShow = false;
+      this.$_referenceNode = (_b = (_a = this.referenceNode) == null ? void 0 : _a.call(this)) != null ? _b : this.$el;
+      this.$_targetNodes = this.targetNodes().filter((e) => e.nodeType === e.ELEMENT_NODE);
+      this.$_popperNode = this.popperNode();
+      this.$_innerNode = this.$_popperNode.querySelector(".v-popper__inner");
+      this.$_arrowNode = this.$_popperNode.querySelector(".v-popper__arrow-container");
+      this.$_swapTargetAttrs("title", "data-original-title");
+      this.$_detachPopperNode();
+      if (this.triggers.length) {
+        this.$_addEventListeners();
+      }
+      if (this.shown) {
+        this.show();
+      }
+    },
+    dispose() {
+      if (this.$_isDisposed)
+        return;
+      this.$_isDisposed = true;
+      this.$_removeEventListeners();
+      this.hide({ skipDelay: true });
+      this.$_detachPopperNode();
+      this.isMounted = false;
+      this.isShown = false;
+      this.$_updateParentShownChildren(false);
+      this.$_swapTargetAttrs("data-original-title", "title");
+      this.$emit("dispose");
+    },
+    async onResize() {
+      if (this.isShown) {
+        await this.$_computePosition();
+        this.$emit("resize");
+      }
+    },
+    async $_computePosition() {
+      var _a;
+      if (this.$_isDisposed || this.positioningDisabled)
+        return;
+      const options2 = {
+        strategy: this.strategy,
+        middleware: []
+      };
+      if (this.distance || this.skidding) {
+        options2.middleware.push(offset({
+          mainAxis: this.distance,
+          crossAxis: this.skidding
+        }));
+      }
+      const isPlacementAuto = this.placement.startsWith("auto");
+      if (isPlacementAuto) {
+        options2.middleware.push(autoPlacement({
+          alignment: (_a = this.placement.split("-")[1]) != null ? _a : ""
+        }));
+      } else {
+        options2.placement = this.placement;
+      }
+      if (this.preventOverflow) {
+        if (this.shift) {
+          options2.middleware.push(shift({
+            padding: this.overflowPadding,
+            boundary: this.boundary,
+            crossAxis: this.shiftCrossAxis
+          }));
+        }
+        if (!isPlacementAuto && this.flip) {
+          options2.middleware.push(flip({
+            padding: this.overflowPadding,
+            boundary: this.boundary
+          }));
+        }
+      }
+      options2.middleware.push(arrow({
+        element: this.$_arrowNode,
+        padding: this.arrowPadding
+      }));
+      if (this.arrowOverflow) {
+        options2.middleware.push({
+          name: "arrowOverflow",
+          fn: ({ placement, rects, middlewareData }) => {
+            let overflow;
+            const { centerOffset } = middlewareData.arrow;
+            if (placement.startsWith("top") || placement.startsWith("bottom")) {
+              overflow = Math.abs(centerOffset) > rects.reference.width / 2;
+            } else {
+              overflow = Math.abs(centerOffset) > rects.reference.height / 2;
+            }
+            return {
+              data: {
+                overflow
+              }
+            };
+          }
+        });
+      }
+      if (this.autoMinSize || this.autoSize) {
+        const autoSize = this.autoSize ? this.autoSize : this.autoMinSize ? "min" : null;
+        options2.middleware.push({
+          name: "autoSize",
+          fn: ({ rects, placement, middlewareData }) => {
+            var _a2;
+            if ((_a2 = middlewareData.autoSize) == null ? void 0 : _a2.skip) {
+              return {};
+            }
+            let width;
+            let height;
+            if (placement.startsWith("top") || placement.startsWith("bottom")) {
+              width = rects.reference.width;
+            } else {
+              height = rects.reference.height;
+            }
+            this.$_innerNode.style[autoSize === "min" ? "minWidth" : autoSize === "max" ? "maxWidth" : "width"] = width != null ? `${width}px` : null;
+            this.$_innerNode.style[autoSize === "min" ? "minHeight" : autoSize === "max" ? "maxHeight" : "height"] = height != null ? `${height}px` : null;
+            return {
+              data: {
+                skip: true
+              },
+              reset: {
+                rects: true
+              }
+            };
+          }
+        });
+      }
+      if (this.autoMaxSize || this.autoBoundaryMaxSize) {
+        this.$_innerNode.style.maxWidth = null;
+        this.$_innerNode.style.maxHeight = null;
+        options2.middleware.push(size({
+          boundary: this.boundary,
+          padding: this.overflowPadding,
+          apply: ({ width, height }) => {
+            this.$_innerNode.style.maxWidth = width != null ? `${width}px` : null;
+            this.$_innerNode.style.maxHeight = height != null ? `${height}px` : null;
+          }
+        }));
+      }
+      const data = await computePosition(this.$_referenceNode, this.$_popperNode, options2);
+      Object.assign(this.result, {
+        x: data.x,
+        y: data.y,
+        placement: data.placement,
+        strategy: data.strategy,
+        arrow: __spreadValues(__spreadValues({}, data.middlewareData.arrow), data.middlewareData.arrowOverflow)
+      });
+    },
+    $_scheduleShow(event = null, skipDelay = false) {
+      this.$_updateParentShownChildren(true);
+      this.$_hideInProgress = false;
+      clearTimeout(this.$_scheduleTimer);
+      if (hidingPopper && this.instantMove && hidingPopper.instantMove && hidingPopper !== this.parentPopper) {
+        hidingPopper.$_applyHide(true);
+        this.$_applyShow(true);
+        return;
+      }
+      if (skipDelay) {
+        this.$_applyShow();
+      } else {
+        this.$_scheduleTimer = setTimeout(this.$_applyShow.bind(this), this.$_computeDelay("show"));
+      }
+    },
+    $_scheduleHide(event = null, skipDelay = false) {
+      if (this.shownChildren.size > 0) {
+        this.$_pendingHide = true;
+        return;
+      }
+      this.$_updateParentShownChildren(false);
+      this.$_hideInProgress = true;
+      clearTimeout(this.$_scheduleTimer);
+      if (this.isShown) {
+        hidingPopper = this;
+      }
+      if (skipDelay) {
+        this.$_applyHide();
+      } else {
+        this.$_scheduleTimer = setTimeout(this.$_applyHide.bind(this), this.$_computeDelay("hide"));
+      }
+    },
+    $_computeDelay(type) {
+      const delay = this.delay;
+      return parseInt(delay && delay[type] || delay || 0);
+    },
+    async $_applyShow(skipTransition = false) {
+      clearTimeout(this.$_disposeTimer);
+      clearTimeout(this.$_scheduleTimer);
+      this.skipTransition = skipTransition;
+      if (this.isShown) {
+        return;
+      }
+      this.$_ensureTeleport();
+      await nextFrame();
+      await this.$_computePosition();
+      await this.$_applyShowEffect();
+      if (!this.positioningDisabled) {
+        this.$_registerEventListeners([
+          ...getScrollParents(this.$_referenceNode),
+          ...getScrollParents(this.$_popperNode)
+        ], "scroll", () => {
+          this.$_computePosition();
+        });
+      }
+    },
+    async $_applyShowEffect() {
+      if (this.$_hideInProgress)
+        return;
+      if (this.computeTransformOrigin) {
+        const bounds = this.$_referenceNode.getBoundingClientRect();
+        const popperWrapper = this.$_popperNode.querySelector(".v-popper__wrapper");
+        const parentBounds = popperWrapper.parentNode.getBoundingClientRect();
+        const x = bounds.x + bounds.width / 2 - (parentBounds.left + popperWrapper.offsetLeft);
+        const y = bounds.y + bounds.height / 2 - (parentBounds.top + popperWrapper.offsetTop);
+        this.result.transformOrigin = `${x}px ${y}px`;
+      }
+      this.isShown = true;
+      this.$_applyAttrsToTarget({
+        "aria-describedby": this.popperId,
+        "data-popper-shown": ""
+      });
+      const showGroup = this.showGroup;
+      if (showGroup) {
+        let popover;
+        for (let i = 0; i < shownPoppers.length; i++) {
+          popover = shownPoppers[i];
+          if (popover.showGroup !== showGroup) {
+            popover.hide();
+            popover.$emit("close-group");
+          }
+        }
+      }
+      shownPoppers.push(this);
+      document.body.classList.add("v-popper--some-open");
+      for (const theme of getAllParentThemes(this.theme)) {
+        getShownPoppersByTheme(theme).push(this);
+        document.body.classList.add(`v-popper--some-open--${theme}`);
+      }
+      this.$emit("apply-show");
+      this.classes.showFrom = true;
+      this.classes.showTo = false;
+      this.classes.hideFrom = false;
+      this.classes.hideTo = false;
+      await nextFrame();
+      this.classes.showFrom = false;
+      this.classes.showTo = true;
+      if (!this.noAutoFocus)
+        this.$_popperNode.focus();
+    },
+    async $_applyHide(skipTransition = false) {
+      if (this.shownChildren.size > 0) {
+        this.$_pendingHide = true;
+        this.$_hideInProgress = false;
+        return;
+      }
+      clearTimeout(this.$_scheduleTimer);
+      if (!this.isShown) {
+        return;
+      }
+      this.skipTransition = skipTransition;
+      removeFromArray(shownPoppers, this);
+      if (shownPoppers.length === 0) {
+        document.body.classList.remove("v-popper--some-open");
+      }
+      for (const theme of getAllParentThemes(this.theme)) {
+        const list = getShownPoppersByTheme(theme);
+        removeFromArray(list, this);
+        if (list.length === 0) {
+          document.body.classList.remove(`v-popper--some-open--${theme}`);
+        }
+      }
+      if (hidingPopper === this) {
+        hidingPopper = null;
+      }
+      this.isShown = false;
+      this.$_applyAttrsToTarget({
+        "aria-describedby": void 0,
+        "data-popper-shown": void 0
+      });
+      clearTimeout(this.$_disposeTimer);
+      const disposeTime = getDefaultConfig(this.theme, "disposeTimeout");
+      if (disposeTime !== null) {
+        this.$_disposeTimer = setTimeout(() => {
+          if (this.$_popperNode) {
+            this.$_detachPopperNode();
+            this.isMounted = false;
+          }
+        }, disposeTime);
+      }
+      this.$_removeEventListeners("scroll");
+      this.$emit("apply-hide");
+      this.classes.showFrom = false;
+      this.classes.showTo = false;
+      this.classes.hideFrom = true;
+      this.classes.hideTo = false;
+      await nextFrame();
+      this.classes.hideFrom = false;
+      this.classes.hideTo = true;
+    },
+    $_autoShowHide() {
+      if (this.shown) {
+        this.show();
+      } else {
+        this.hide();
+      }
+    },
+    $_ensureTeleport() {
+      if (this.$_isDisposed)
+        return;
+      let container = this.container;
+      if (typeof container === "string") {
+        container = window.document.querySelector(container);
+      } else if (container === false) {
+        container = this.$_targetNodes[0].parentNode;
+      }
+      if (!container) {
+        throw new Error("No container for popover: " + this.container);
+      }
+      container.appendChild(this.$_popperNode);
+      this.isMounted = true;
+    },
+    $_addEventListeners() {
+      const handleShow = (event) => {
+        if (this.isShown && !this.$_hideInProgress) {
+          return;
+        }
+        event.usedByTooltip = true;
+        !this.$_preventShow && this.show({ event });
+      };
+      this.$_registerTriggerListeners(this.$_targetNodes, SHOW_EVENT_MAP, this.triggers, this.showTriggers, handleShow);
+      this.$_registerTriggerListeners([this.$_popperNode], SHOW_EVENT_MAP, this.popperTriggers, this.popperShowTriggers, handleShow);
+      const handleHide = (event) => {
+        if (event.usedByTooltip) {
+          return;
+        }
+        this.hide({ event });
+      };
+      this.$_registerTriggerListeners(this.$_targetNodes, HIDE_EVENT_MAP, this.triggers, this.hideTriggers, handleHide);
+      this.$_registerTriggerListeners([this.$_popperNode], HIDE_EVENT_MAP, this.popperTriggers, this.popperHideTriggers, handleHide);
+    },
+    $_registerEventListeners(targetNodes, eventType, handler) {
+      this.$_events.push({ targetNodes, eventType, handler });
+      targetNodes.forEach((node) => node.addEventListener(eventType, handler, supportsPassive ? {
+        passive: true
+      } : void 0));
+    },
+    $_registerTriggerListeners(targetNodes, eventMap, commonTriggers, customTrigger, handler) {
+      let triggers = commonTriggers;
+      if (customTrigger != null) {
+        triggers = typeof customTrigger === "function" ? customTrigger(triggers) : customTrigger;
+      }
+      triggers.forEach((trigger) => {
+        const eventType = eventMap[trigger];
+        if (eventType) {
+          this.$_registerEventListeners(targetNodes, eventType, handler);
+        }
+      });
+    },
+    $_removeEventListeners(filterEventType) {
+      const newList = [];
+      this.$_events.forEach((listener) => {
+        const { targetNodes, eventType, handler } = listener;
+        if (!filterEventType || filterEventType === eventType) {
+          targetNodes.forEach((node) => node.removeEventListener(eventType, handler));
+        } else {
+          newList.push(listener);
+        }
+      });
+      this.$_events = newList;
+    },
+    $_refreshListeners() {
+      if (!this.$_isDisposed) {
+        this.$_removeEventListeners();
+        this.$_addEventListeners();
+      }
+    },
+    $_handleGlobalClose(event, touch = false) {
+      if (this.$_showFrameLocked)
+        return;
+      this.hide({ event });
+      if (event.closePopover) {
+        this.$emit("close-directive");
+      } else {
+        this.$emit("auto-hide");
+      }
+      if (touch) {
+        this.$_preventShow = true;
+        setTimeout(() => {
+          this.$_preventShow = false;
+        }, 300);
+      }
+    },
+    $_detachPopperNode() {
+      this.$_popperNode.parentNode && this.$_popperNode.parentNode.removeChild(this.$_popperNode);
+    },
+    $_swapTargetAttrs(attrFrom, attrTo) {
+      for (const el of this.$_targetNodes) {
+        const value = el.getAttribute(attrFrom);
+        if (value) {
+          el.removeAttribute(attrFrom);
+          el.setAttribute(attrTo, value);
+        }
+      }
+    },
+    $_applyAttrsToTarget(attrs) {
+      for (const el of this.$_targetNodes) {
+        for (const n in attrs) {
+          const value = attrs[n];
+          if (value == null) {
+            el.removeAttribute(n);
+          } else {
+            el.setAttribute(n, value);
+          }
+        }
+      }
+    },
+    $_updateParentShownChildren(value) {
+      let parent = this.parentPopper;
+      while (parent) {
+        if (value) {
+          parent.shownChildren.add(this.randomId);
+        } else {
+          parent.shownChildren.delete(this.randomId);
+          if (parent.$_pendingHide) {
+            parent.hide();
+          }
+        }
+        parent = parent.parentPopper;
+      }
+    },
+    $_isAimingPopper() {
+      const referenceBounds = this.$_referenceNode.getBoundingClientRect();
+      if (mouseX >= referenceBounds.left && mouseX <= referenceBounds.right && mouseY >= referenceBounds.top && mouseY <= referenceBounds.bottom) {
+        const popperBounds = this.$_popperNode.getBoundingClientRect();
+        const vectorX = mouseX - mousePreviousX;
+        const vectorY = mouseY - mousePreviousY;
+        const distance = popperBounds.left + popperBounds.width / 2 - mousePreviousX + (popperBounds.top + popperBounds.height / 2) - mousePreviousY;
+        const newVectorLength = distance + popperBounds.width + popperBounds.height;
+        const edgeX = mousePreviousX + vectorX * newVectorLength;
+        const edgeY = mousePreviousY + vectorY * newVectorLength;
+        return lineIntersectsLine(mousePreviousX, mousePreviousY, edgeX, edgeY, popperBounds.left, popperBounds.top, popperBounds.left, popperBounds.bottom) || lineIntersectsLine(mousePreviousX, mousePreviousY, edgeX, edgeY, popperBounds.left, popperBounds.top, popperBounds.right, popperBounds.top) || lineIntersectsLine(mousePreviousX, mousePreviousY, edgeX, edgeY, popperBounds.right, popperBounds.top, popperBounds.right, popperBounds.bottom) || lineIntersectsLine(mousePreviousX, mousePreviousY, edgeX, edgeY, popperBounds.left, popperBounds.bottom, popperBounds.right, popperBounds.bottom);
+      }
+      return false;
+    }
+  },
+  render() {
+    return this.$slots.default(this.slotData);
+  }
+});
+if (typeof document !== "undefined" && typeof window !== "undefined") {
+  if (isIOS) {
+    document.addEventListener("touchstart", handleGlobalMousedown, supportsPassive ? {
+      passive: true,
+      capture: true
+    } : true);
+    document.addEventListener("touchend", handleGlobalTouchend, supportsPassive ? {
+      passive: true,
+      capture: true
+    } : true);
+  } else {
+    window.addEventListener("mousedown", handleGlobalMousedown, true);
+    window.addEventListener("click", handleGlobalClick, true);
+  }
+  window.addEventListener("resize", computePositionAllShownPoppers);
+}
+function handleGlobalMousedown(event) {
+  for (let i = 0; i < shownPoppers.length; i++) {
+    const popper = shownPoppers[i];
+    try {
+      const popperContent = popper.popperNode();
+      popper.$_mouseDownContains = popperContent.contains(event.target);
+    } catch (e) {
+    }
+  }
+}
+function handleGlobalClick(event) {
+  handleGlobalClose(event);
+}
+function handleGlobalTouchend(event) {
+  handleGlobalClose(event, true);
+}
+function handleGlobalClose(event, touch = false) {
+  const preventClose = {};
+  for (let i = shownPoppers.length - 1; i >= 0; i--) {
+    const popper = shownPoppers[i];
+    try {
+      const contains = popper.$_containsGlobalTarget = isContainingEventTarget(popper, event);
+      popper.$_pendingHide = false;
+      requestAnimationFrame(() => {
+        popper.$_pendingHide = false;
+        if (preventClose[popper.randomId])
+          return;
+        if (shouldAutoHide(popper, contains, event)) {
+          popper.$_handleGlobalClose(event, touch);
+          if (!event.closeAllPopover && event.closePopover && contains) {
+            let parent2 = popper.parentPopper;
+            while (parent2) {
+              preventClose[parent2.randomId] = true;
+              parent2 = parent2.parentPopper;
+            }
+            return;
+          }
+          let parent = popper.parentPopper;
+          while (parent) {
+            if (shouldAutoHide(parent, parent.$_containsGlobalTarget, event)) {
+              parent.$_handleGlobalClose(event, touch);
+            } else {
+              break;
+            }
+            parent = parent.parentPopper;
+          }
+        }
+      });
+    } catch (e) {
+    }
+  }
+}
+function isContainingEventTarget(popper, event) {
+  const popperContent = popper.popperNode();
+  return popper.$_mouseDownContains || popperContent.contains(event.target);
+}
+function shouldAutoHide(popper, contains, event) {
+  return event.closeAllPopover || event.closePopover && contains || getAutoHideResult(popper, event) && !contains;
+}
+function getAutoHideResult(popper, event) {
+  if (typeof popper.autoHide === "function") {
+    const result = popper.autoHide(event);
+    popper.lastAutoHide = result;
+    return result;
+  }
+  return popper.autoHide;
+}
+function computePositionAllShownPoppers(event) {
+  for (let i = 0; i < shownPoppers.length; i++) {
+    const popper = shownPoppers[i];
+    popper.$_computePosition(event);
+  }
+}
+function hideAllPoppers() {
+  for (let i = 0; i < shownPoppers.length; i++) {
+    const popper = shownPoppers[i];
+    popper.hide();
+  }
+}
+let mousePreviousX = 0;
+let mousePreviousY = 0;
+let mouseX = 0;
+let mouseY = 0;
+if (typeof window !== "undefined") {
+  window.addEventListener("mousemove", (event) => {
+    mousePreviousX = mouseX;
+    mousePreviousY = mouseY;
+    mouseX = event.clientX;
+    mouseY = event.clientY;
+  }, supportsPassive ? {
+    passive: true
+  } : void 0);
+}
+function lineIntersectsLine(x1, y1, x2, y2, x3, y3, x4, y4) {
+  const uA = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));
+  const uB = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));
+  return uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1;
+}
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _sfc_main$6 = {
+  extends: PrivatePopper()
+};
+function _sfc_render$3(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("div", {
+    ref: "reference",
+    class: normalizeClass(["v-popper", {
+      "v-popper--shown": _ctx.slotData.isShown
+    }])
+  }, [
+    renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(_ctx.slotData)))
+  ], 2);
+}
+var Popper$1 = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["render", _sfc_render$3]]);
+function getInternetExplorerVersion() {
+  var ua = window.navigator.userAgent;
+  var msie = ua.indexOf("MSIE ");
+  if (msie > 0) {
+    return parseInt(ua.substring(msie + 5, ua.indexOf(".", msie)), 10);
+  }
+  var trident = ua.indexOf("Trident/");
+  if (trident > 0) {
+    var rv = ua.indexOf("rv:");
+    return parseInt(ua.substring(rv + 3, ua.indexOf(".", rv)), 10);
+  }
+  var edge = ua.indexOf("Edge/");
+  if (edge > 0) {
+    return parseInt(ua.substring(edge + 5, ua.indexOf(".", edge)), 10);
+  }
+  return -1;
+}
+let isIE;
+function initCompat() {
+  if (!initCompat.init) {
+    initCompat.init = true;
+    isIE = getInternetExplorerVersion() !== -1;
+  }
+}
+var script = {
+  name: "ResizeObserver",
+  props: {
+    emitOnMount: {
+      type: Boolean,
+      default: false
+    },
+    ignoreWidth: {
+      type: Boolean,
+      default: false
+    },
+    ignoreHeight: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: [
+    "notify"
+  ],
+  mounted() {
+    initCompat();
+    nextTick(() => {
+      this._w = this.$el.offsetWidth;
+      this._h = this.$el.offsetHeight;
+      if (this.emitOnMount) {
+        this.emitSize();
+      }
+    });
+    const object = document.createElement("object");
+    this._resizeObject = object;
+    object.setAttribute("aria-hidden", "true");
+    object.setAttribute("tabindex", -1);
+    object.onload = this.addResizeHandlers;
+    object.type = "text/html";
+    if (isIE) {
+      this.$el.appendChild(object);
+    }
+    object.data = "about:blank";
+    if (!isIE) {
+      this.$el.appendChild(object);
+    }
+  },
+  beforeUnmount() {
+    this.removeResizeHandlers();
+  },
+  methods: {
+    compareAndNotify() {
+      if (!this.ignoreWidth && this._w !== this.$el.offsetWidth || !this.ignoreHeight && this._h !== this.$el.offsetHeight) {
+        this._w = this.$el.offsetWidth;
+        this._h = this.$el.offsetHeight;
+        this.emitSize();
+      }
+    },
+    emitSize() {
+      this.$emit("notify", {
+        width: this._w,
+        height: this._h
+      });
+    },
+    addResizeHandlers() {
+      this._resizeObject.contentDocument.defaultView.addEventListener("resize", this.compareAndNotify);
+      this.compareAndNotify();
+    },
+    removeResizeHandlers() {
+      if (this._resizeObject && this._resizeObject.onload) {
+        if (!isIE && this._resizeObject.contentDocument) {
+          this._resizeObject.contentDocument.defaultView.removeEventListener("resize", this.compareAndNotify);
+        }
+        this.$el.removeChild(this._resizeObject);
+        this._resizeObject.onload = null;
+        this._resizeObject = null;
+      }
+    }
+  }
+};
+const _withId = /* @__PURE__ */ withScopeId("data-v-b329ee4c");
+pushScopeId("data-v-b329ee4c");
+const _hoisted_1$2 = {
+  class: "resize-observer",
+  tabindex: "-1"
+};
+popScopeId();
+const render = /* @__PURE__ */ _withId((_ctx, _cache, $props, $setup, $data, $options) => {
+  return openBlock(), createBlock("div", _hoisted_1$2);
+});
+script.render = render;
+script.__scopeId = "data-v-b329ee4c";
+script.__file = "src/components/ResizeObserver.vue";
+var PrivateThemeClass = (prop = "theme") => ({
+  computed: {
+    themeClass() {
+      return getThemeClasses(this[prop]);
+    }
+  }
+});
+var PopperContent_vue_vue_type_style_index_0_lang = "";
+const _sfc_main$5 = defineComponent({
+  name: "VPopperContent",
+  components: {
+    ResizeObserver: script
+  },
+  mixins: [
+    PrivateThemeClass()
+  ],
+  props: {
+    popperId: String,
+    theme: String,
+    shown: Boolean,
+    mounted: Boolean,
+    skipTransition: Boolean,
+    autoHide: Boolean,
+    handleResize: Boolean,
+    classes: Object,
+    result: Object
+  },
+  emits: [
+    "hide",
+    "resize"
+  ],
+  methods: {
+    toPx(value) {
+      if (value != null && !isNaN(value)) {
+        return `${value}px`;
+      }
+      return null;
+    }
+  }
+});
+const _hoisted_1$1 = ["id", "aria-hidden", "tabindex", "data-popper-placement"];
+const _hoisted_2$1 = {
+  ref: "inner",
+  class: "v-popper__inner"
+};
+const _hoisted_3 = /* @__PURE__ */ createElementVNode("div", { class: "v-popper__arrow-outer" }, null, -1);
+const _hoisted_4 = /* @__PURE__ */ createElementVNode("div", { class: "v-popper__arrow-inner" }, null, -1);
+const _hoisted_5 = [
+  _hoisted_3,
+  _hoisted_4
+];
+function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ResizeObserver = resolveComponent("ResizeObserver");
+  return openBlock(), createElementBlock("div", {
+    id: _ctx.popperId,
+    ref: "popover",
+    class: normalizeClass(["v-popper__popper", [
+      _ctx.themeClass,
+      _ctx.classes.popperClass,
+      {
+        "v-popper__popper--shown": _ctx.shown,
+        "v-popper__popper--hidden": !_ctx.shown,
+        "v-popper__popper--show-from": _ctx.classes.showFrom,
+        "v-popper__popper--show-to": _ctx.classes.showTo,
+        "v-popper__popper--hide-from": _ctx.classes.hideFrom,
+        "v-popper__popper--hide-to": _ctx.classes.hideTo,
+        "v-popper__popper--skip-transition": _ctx.skipTransition,
+        "v-popper__popper--arrow-overflow": _ctx.result && _ctx.result.arrow.overflow,
+        "v-popper__popper--no-positioning": !_ctx.result
+      }
+    ]]),
+    style: normalizeStyle(_ctx.result ? {
+      position: _ctx.result.strategy,
+      transform: `translate3d(${Math.round(_ctx.result.x)}px,${Math.round(_ctx.result.y)}px,0)`
+    } : void 0),
+    "aria-hidden": _ctx.shown ? "false" : "true",
+    tabindex: _ctx.autoHide ? 0 : void 0,
+    "data-popper-placement": _ctx.result ? _ctx.result.placement : void 0,
+    onKeyup: _cache[2] || (_cache[2] = withKeys(($event) => _ctx.autoHide && _ctx.$emit("hide"), ["esc"]))
+  }, [
+    createElementVNode("div", {
+      class: "v-popper__backdrop",
+      onClick: _cache[0] || (_cache[0] = ($event) => _ctx.autoHide && _ctx.$emit("hide"))
+    }),
+    createElementVNode("div", {
+      class: "v-popper__wrapper",
+      style: normalizeStyle(_ctx.result ? {
+        transformOrigin: _ctx.result.transformOrigin
+      } : void 0)
+    }, [
+      createElementVNode("div", _hoisted_2$1, [
+        _ctx.mounted ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+          createElementVNode("div", null, [
+            renderSlot(_ctx.$slots, "default")
+          ]),
+          _ctx.handleResize ? (openBlock(), createBlock(_component_ResizeObserver, {
+            key: 0,
+            onNotify: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("resize", $event))
+          })) : createCommentVNode("", true)
+        ], 64)) : createCommentVNode("", true)
+      ], 512),
+      createElementVNode("div", {
+        ref: "arrow",
+        class: "v-popper__arrow-container",
+        style: normalizeStyle(_ctx.result ? {
+          left: _ctx.toPx(_ctx.result.arrow.x),
+          top: _ctx.toPx(_ctx.result.arrow.y)
+        } : void 0)
+      }, _hoisted_5, 4)
+    ], 4)
+  ], 46, _hoisted_1$1);
+}
+var PrivatePopperContent = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["render", _sfc_render$2]]);
+var PrivatePopperMethods = {
+  methods: {
+    show(...args) {
+      return this.$refs.popper.show(...args);
+    },
+    hide(...args) {
+      return this.$refs.popper.hide(...args);
+    },
+    dispose(...args) {
+      return this.$refs.popper.dispose(...args);
+    },
+    onResize(...args) {
+      return this.$refs.popper.onResize(...args);
+    }
+  }
+};
+const _sfc_main$4 = defineComponent({
+  name: "VPopperWrapper",
+  components: {
+    Popper: Popper$1,
+    PopperContent: PrivatePopperContent
+  },
+  mixins: [
+    PrivatePopperMethods,
+    PrivateThemeClass("finalTheme")
+  ],
+  props: {
+    theme: {
+      type: String,
+      default: null
+    }
+  },
+  computed: {
+    finalTheme() {
+      var _a;
+      return (_a = this.theme) != null ? _a : this.$options.vPopperTheme;
+    }
+  },
+  methods: {
+    getTargetNodes() {
+      return Array.from(this.$el.children).filter((node) => node !== this.$refs.popperContent.$el);
+    }
+  }
+});
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_PopperContent = resolveComponent("PopperContent");
+  const _component_Popper = resolveComponent("Popper");
+  return openBlock(), createBlock(_component_Popper, {
+    ref: "popper",
+    theme: _ctx.finalTheme,
+    "target-nodes": _ctx.getTargetNodes,
+    "popper-node": () => _ctx.$refs.popperContent.$el,
+    class: normalizeClass([
+      _ctx.themeClass
+    ])
+  }, {
+    default: withCtx(({
+      popperId,
+      isShown,
+      shouldMountContent,
+      skipTransition,
+      autoHide,
+      show,
+      hide,
+      handleResize,
+      onResize,
+      classes,
+      result
+    }) => [
+      renderSlot(_ctx.$slots, "default", {
+        shown: isShown,
+        show,
+        hide
+      }),
+      createVNode(_component_PopperContent, {
+        ref: "popperContent",
+        "popper-id": popperId,
+        theme: _ctx.finalTheme,
+        shown: isShown,
+        mounted: shouldMountContent,
+        "skip-transition": skipTransition,
+        "auto-hide": autoHide,
+        "handle-resize": handleResize,
+        classes,
+        result,
+        onHide: hide,
+        onResize
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "popper", {
+            shown: isShown,
+            hide
+          })
+        ]),
+        _: 2
+      }, 1032, ["popper-id", "theme", "shown", "mounted", "skip-transition", "auto-hide", "handle-resize", "classes", "result", "onHide", "onResize"])
+    ]),
+    _: 3
+  }, 8, ["theme", "target-nodes", "popper-node", "class"]);
+}
+var PrivatePopperWrapper = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["render", _sfc_render$1]]);
+var Dropdown_vue_vue_type_style_index_0_lang = "";
+const _sfc_main$3 = defineComponent(__spreadProps(__spreadValues({}, PrivatePopperWrapper), {
+  name: "VDropdown",
+  vPopperTheme: "dropdown"
+}));
+const _sfc_main$2 = defineComponent(__spreadProps(__spreadValues({}, PrivatePopperWrapper), {
+  name: "VMenu",
+  vPopperTheme: "menu"
+}));
+var Tooltip_vue_vue_type_style_index_0_lang = "";
+const _sfc_main$1 = defineComponent(__spreadProps(__spreadValues({}, PrivatePopperWrapper), {
+  name: "VTooltip",
+  vPopperTheme: "tooltip"
+}));
+const _sfc_main = defineComponent({
+  name: "VTooltipDirective",
+  components: {
+    Popper: PrivatePopper(),
+    PopperContent: PrivatePopperContent
+  },
+  mixins: [
+    PrivatePopperMethods
+  ],
+  inheritAttrs: false,
+  props: {
+    theme: {
+      type: String,
+      default: "tooltip"
+    },
+    html: {
+      type: Boolean,
+      default: (props) => getDefaultConfig(props.theme, "html")
+    },
+    content: {
+      type: [String, Number, Function],
+      default: null
+    },
+    loadingContent: {
+      type: String,
+      default: (props) => getDefaultConfig(props.theme, "loadingContent")
+    }
+  },
+  data() {
+    return {
+      asyncContent: null
+    };
+  },
+  computed: {
+    isContentAsync() {
+      return typeof this.content === "function";
+    },
+    loading() {
+      return this.isContentAsync && this.asyncContent == null;
+    },
+    finalContent() {
+      if (this.isContentAsync) {
+        return this.loading ? this.loadingContent : this.asyncContent;
+      }
+      return this.content;
+    }
+  },
+  watch: {
+    content: {
+      handler() {
+        this.fetchContent(true);
+      },
+      immediate: true
+    },
+    async finalContent() {
+      await this.$nextTick();
+      this.$refs.popper.onResize();
+    }
+  },
+  created() {
+    this.$_fetchId = 0;
+  },
+  methods: {
+    fetchContent(force) {
+      if (typeof this.content === "function" && this.$_isShown && (force || !this.$_loading && this.asyncContent == null)) {
+        this.asyncContent = null;
+        this.$_loading = true;
+        const fetchId = ++this.$_fetchId;
+        const result = this.content(this);
+        if (result.then) {
+          result.then((res) => this.onResult(fetchId, res));
+        } else {
+          this.onResult(fetchId, result);
+        }
+      }
+    },
+    onResult(fetchId, result) {
+      if (fetchId !== this.$_fetchId)
+        return;
+      this.$_loading = false;
+      this.asyncContent = result;
+    },
+    onShow() {
+      this.$_isShown = true;
+      this.fetchContent();
+    },
+    onHide() {
+      this.$_isShown = false;
+    }
+  }
+});
+const _hoisted_1 = ["innerHTML"];
+const _hoisted_2 = ["textContent"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_PopperContent = resolveComponent("PopperContent");
+  const _component_Popper = resolveComponent("Popper");
+  return openBlock(), createBlock(_component_Popper, mergeProps({ ref: "popper" }, _ctx.$attrs, {
+    theme: _ctx.theme,
+    "popper-node": () => _ctx.$refs.popperContent.$el,
+    onApplyShow: _ctx.onShow,
+    onApplyHide: _ctx.onHide
+  }), {
+    default: withCtx(({
+      popperId,
+      isShown,
+      shouldMountContent,
+      skipTransition,
+      autoHide,
+      hide,
+      handleResize,
+      onResize,
+      classes,
+      result
+    }) => [
+      createVNode(_component_PopperContent, {
+        ref: "popperContent",
+        class: normalizeClass({
+          "v-popper--tooltip-loading": _ctx.loading
+        }),
+        "popper-id": popperId,
+        theme: _ctx.theme,
+        shown: isShown,
+        mounted: shouldMountContent,
+        "skip-transition": skipTransition,
+        "auto-hide": autoHide,
+        "handle-resize": handleResize,
+        classes,
+        result,
+        onHide: hide,
+        onResize
+      }, {
+        default: withCtx(() => [
+          _ctx.html ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            innerHTML: _ctx.finalContent
+          }, null, 8, _hoisted_1)) : (openBlock(), createElementBlock("div", {
+            key: 1,
+            textContent: toDisplayString(_ctx.finalContent)
+          }, null, 8, _hoisted_2))
+        ]),
+        _: 2
+      }, 1032, ["class", "popper-id", "theme", "shown", "mounted", "skip-transition", "auto-hide", "handle-resize", "classes", "result", "onHide", "onResize"])
+    ]),
+    _: 1
+  }, 16, ["theme", "popper-node", "onApplyShow", "onApplyHide"]);
+}
+var PrivateTooltipDirective = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+const TARGET_CLASS = "v-popper--has-tooltip";
+function getPlacement(options2, modifiers) {
+  let result = options2.placement;
+  if (!result && modifiers) {
+    for (const pos of placements) {
+      if (modifiers[pos]) {
+        result = pos;
+      }
+    }
+  }
+  if (!result) {
+    result = getDefaultConfig(options2.theme || "tooltip", "placement");
+  }
+  return result;
+}
+function getOptions(el, value, modifiers) {
+  let options2;
+  const type = typeof value;
+  if (type === "string") {
+    options2 = { content: value };
+  } else if (value && type === "object") {
+    options2 = value;
+  } else {
+    options2 = { content: false };
+  }
+  options2.placement = getPlacement(options2, modifiers);
+  options2.targetNodes = () => [el];
+  options2.referenceNode = () => el;
+  return options2;
+}
+let directiveApp;
+let directives;
+let uid = 0;
+function ensureDirectiveApp() {
+  if (directiveApp)
+    return;
+  directives = ref([]);
+  directiveApp = createApp({
+    name: "VTooltipDirectiveApp",
+    setup() {
+      return {
+        directives
+      };
+    },
+    render() {
+      return this.directives.map((directive) => {
+        return h(PrivateTooltipDirective, __spreadProps(__spreadValues({}, directive.options), {
+          shown: directive.shown || directive.options.shown,
+          key: directive.id
+        }));
+      });
+    },
+    devtools: {
+      hide: true
+    }
+  });
+  const mountTarget = document.createElement("div");
+  document.body.appendChild(mountTarget);
+  directiveApp.mount(mountTarget);
+}
+function createTooltip(el, value, modifiers) {
+  ensureDirectiveApp();
+  const options2 = ref(getOptions(el, value, modifiers));
+  const shown = ref(false);
+  const item = {
+    id: uid++,
+    options: options2,
+    shown
+  };
+  directives.value.push(item);
+  if (el.classList) {
+    el.classList.add(TARGET_CLASS);
+  }
+  const result = el.$_popper = {
+    options: options2,
+    item,
+    show() {
+      shown.value = true;
+    },
+    hide() {
+      shown.value = false;
+    }
+  };
+  return result;
+}
+function destroyTooltip(el) {
+  if (el.$_popper) {
+    const index = directives.value.indexOf(el.$_popper.item);
+    if (index !== -1)
+      directives.value.splice(index, 1);
+    delete el.$_popper;
+    delete el.$_popperOldShown;
+    delete el.$_popperMountTarget;
+  }
+  if (el.classList) {
+    el.classList.remove(TARGET_CLASS);
+  }
+}
+function bind(el, { value, modifiers }) {
+  const options2 = getOptions(el, value, modifiers);
+  if (!options2.content || getDefaultConfig(options2.theme || "tooltip", "disabled")) {
+    destroyTooltip(el);
+  } else {
+    let directive;
+    if (el.$_popper) {
+      directive = el.$_popper;
+      directive.options.value = options2;
+    } else {
+      directive = createTooltip(el, value, modifiers);
+    }
+    if (typeof value.shown !== "undefined" && value.shown !== el.$_popperOldShown) {
+      el.$_popperOldShown = value.shown;
+      value.shown ? directive.show() : directive.hide();
+    }
+  }
+}
+var PrivateVTooltip = {
+  beforeMount: bind,
+  updated: bind,
+  beforeUnmount(el) {
+    destroyTooltip(el);
+  }
+};
+function addListeners(el) {
+  el.addEventListener("click", onClick);
+  el.addEventListener("touchstart", onTouchStart, supportsPassive ? {
+    passive: true
+  } : false);
+}
+function removeListeners(el) {
+  el.removeEventListener("click", onClick);
+  el.removeEventListener("touchstart", onTouchStart);
+  el.removeEventListener("touchend", onTouchEnd);
+  el.removeEventListener("touchcancel", onTouchCancel);
+}
+function onClick(event) {
+  const el = event.currentTarget;
+  event.closePopover = !el.$_vclosepopover_touch;
+  event.closeAllPopover = el.$_closePopoverModifiers && !!el.$_closePopoverModifiers.all;
+}
+function onTouchStart(event) {
+  if (event.changedTouches.length === 1) {
+    const el = event.currentTarget;
+    el.$_vclosepopover_touch = true;
+    const touch = event.changedTouches[0];
+    el.$_vclosepopover_touchPoint = touch;
+    el.addEventListener("touchend", onTouchEnd);
+    el.addEventListener("touchcancel", onTouchCancel);
+  }
+}
+function onTouchEnd(event) {
+  const el = event.currentTarget;
+  el.$_vclosepopover_touch = false;
+  if (event.changedTouches.length === 1) {
+    const touch = event.changedTouches[0];
+    const firstTouch = el.$_vclosepopover_touchPoint;
+    event.closePopover = Math.abs(touch.screenY - firstTouch.screenY) < 20 && Math.abs(touch.screenX - firstTouch.screenX) < 20;
+    event.closeAllPopover = el.$_closePopoverModifiers && !!el.$_closePopoverModifiers.all;
+  }
+}
+function onTouchCancel(event) {
+  const el = event.currentTarget;
+  el.$_vclosepopover_touch = false;
+}
+var PrivateVClosePopper = {
+  beforeMount(el, { value, modifiers }) {
+    el.$_closePopoverModifiers = modifiers;
+    if (typeof value === "undefined" || value) {
+      addListeners(el);
+    }
+  },
+  updated(el, { value, oldValue, modifiers }) {
+    el.$_closePopoverModifiers = modifiers;
+    if (value !== oldValue) {
+      if (typeof value === "undefined" || value) {
+        addListeners(el);
+      } else {
+        removeListeners(el);
+      }
+    }
+  },
+  beforeUnmount(el) {
+    removeListeners(el);
+  }
+};
+const options = config;
+const VTooltip = PrivateVTooltip;
+const VClosePopper = PrivateVClosePopper;
+const Dropdown = _sfc_main$3;
+const Menu = _sfc_main$2;
+const Popper = PrivatePopper;
+const PopperContent = PrivatePopperContent;
+const PopperMethods = PrivatePopperMethods;
+const PopperWrapper = PrivatePopperWrapper;
+const ThemeClass = PrivateThemeClass;
+const Tooltip = _sfc_main$1;
+const TooltipDirective = PrivateTooltipDirective;
+function install(app, options2 = {}) {
+  if (app.$_vTooltipInstalled)
+    return;
+  app.$_vTooltipInstalled = true;
+  assign(config, options2);
+  app.directive("tooltip", PrivateVTooltip);
+  app.directive("close-popper", PrivateVClosePopper);
+  app.component("VTooltip", _sfc_main$1);
+  app.component("VDropdown", _sfc_main$3);
+  app.component("VMenu", _sfc_main$2);
+}
+const plugin = {
+  version: "2.0.0-beta.20",
+  install,
+  options: config
+};
+export { Dropdown, HIDE_EVENT_MAP, Menu, Popper, PopperContent, PopperMethods, PopperWrapper, SHOW_EVENT_MAP, ThemeClass, Tooltip, TooltipDirective, VClosePopper, VTooltip, createTooltip, plugin as default, destroyTooltip, hideAllPoppers, install, options, placements };
diff --git a/parent_dir/node_modules/hookable/dist/index.mjs b/parent_dir/node_modules/hookable/dist/index.mjs
new file mode 100644
index 0000000..6695406
--- /dev/null
+++ b/parent_dir/node_modules/hookable/dist/index.mjs
@@ -0,0 +1,290 @@
+function flatHooks(configHooks, hooks = {}, parentName) {
+  for (const key in configHooks) {
+    const subHook = configHooks[key];
+    const name = parentName ? `${parentName}:${key}` : key;
+    if (typeof subHook === "object" && subHook !== null) {
+      flatHooks(subHook, hooks, name);
+    } else if (typeof subHook === "function") {
+      hooks[name] = subHook;
+    }
+  }
+  return hooks;
+}
+function mergeHooks(...hooks) {
+  const finalHooks = {};
+  for (const hook of hooks) {
+    const flatenHook = flatHooks(hook);
+    for (const key in flatenHook) {
+      if (finalHooks[key]) {
+        finalHooks[key].push(flatenHook[key]);
+      } else {
+        finalHooks[key] = [flatenHook[key]];
+      }
+    }
+  }
+  for (const key in finalHooks) {
+    if (finalHooks[key].length > 1) {
+      const array = finalHooks[key];
+      finalHooks[key] = (...arguments_) => serial(array, (function_) => function_(...arguments_));
+    } else {
+      finalHooks[key] = finalHooks[key][0];
+    }
+  }
+  return finalHooks;
+}
+function serial(tasks, function_) {
+  return tasks.reduce(
+    (promise, task) => promise.then(() => function_(task)),
+    Promise.resolve()
+  );
+}
+const defaultTask = { run: (function_) => function_() };
+const _createTask = () => defaultTask;
+const createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
+function serialTaskCaller(hooks, args) {
+  const name = args.shift();
+  const task = createTask(name);
+  return hooks.reduce(
+    (promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))),
+    Promise.resolve()
+  );
+}
+function parallelTaskCaller(hooks, args) {
+  const name = args.shift();
+  const task = createTask(name);
+  return Promise.all(hooks.map((hook) => task.run(() => hook(...args))));
+}
+function serialCaller(hooks, arguments_) {
+  return hooks.reduce(
+    (promise, hookFunction) => promise.then(() => hookFunction(...arguments_ || [])),
+    Promise.resolve()
+  );
+}
+function parallelCaller(hooks, args) {
+  return Promise.all(hooks.map((hook) => hook(...args || [])));
+}
+function callEachWith(callbacks, arg0) {
+  for (const callback of [...callbacks]) {
+    callback(arg0);
+  }
+}
+
+class Hookable {
+  constructor() {
+    this._hooks = {};
+    this._before = void 0;
+    this._after = void 0;
+    this._deprecatedMessages = void 0;
+    this._deprecatedHooks = {};
+    this.hook = this.hook.bind(this);
+    this.callHook = this.callHook.bind(this);
+    this.callHookWith = this.callHookWith.bind(this);
+  }
+  hook(name, function_, options = {}) {
+    if (!name || typeof function_ !== "function") {
+      return () => {
+      };
+    }
+    const originalName = name;
+    let dep;
+    while (this._deprecatedHooks[name]) {
+      dep = this._deprecatedHooks[name];
+      name = dep.to;
+    }
+    if (dep && !options.allowDeprecated) {
+      let message = dep.message;
+      if (!message) {
+        message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
+      }
+      if (!this._deprecatedMessages) {
+        this._deprecatedMessages = /* @__PURE__ */ new Set();
+      }
+      if (!this._deprecatedMessages.has(message)) {
+        console.warn(message);
+        this._deprecatedMessages.add(message);
+      }
+    }
+    if (!function_.name) {
+      try {
+        Object.defineProperty(function_, "name", {
+          get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
+          configurable: true
+        });
+      } catch {
+      }
+    }
+    this._hooks[name] = this._hooks[name] || [];
+    this._hooks[name].push(function_);
+    return () => {
+      if (function_) {
+        this.removeHook(name, function_);
+        function_ = void 0;
+      }
+    };
+  }
+  hookOnce(name, function_) {
+    let _unreg;
+    let _function = (...arguments_) => {
+      if (typeof _unreg === "function") {
+        _unreg();
+      }
+      _unreg = void 0;
+      _function = void 0;
+      return function_(...arguments_);
+    };
+    _unreg = this.hook(name, _function);
+    return _unreg;
+  }
+  removeHook(name, function_) {
+    if (this._hooks[name]) {
+      const index = this._hooks[name].indexOf(function_);
+      if (index !== -1) {
+        this._hooks[name].splice(index, 1);
+      }
+      if (this._hooks[name].length === 0) {
+        delete this._hooks[name];
+      }
+    }
+  }
+  deprecateHook(name, deprecated) {
+    this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
+    const _hooks = this._hooks[name] || [];
+    delete this._hooks[name];
+    for (const hook of _hooks) {
+      this.hook(name, hook);
+    }
+  }
+  deprecateHooks(deprecatedHooks) {
+    Object.assign(this._deprecatedHooks, deprecatedHooks);
+    for (const name in deprecatedHooks) {
+      this.deprecateHook(name, deprecatedHooks[name]);
+    }
+  }
+  addHooks(configHooks) {
+    const hooks = flatHooks(configHooks);
+    const removeFns = Object.keys(hooks).map(
+      (key) => this.hook(key, hooks[key])
+    );
+    return () => {
+      for (const unreg of removeFns.splice(0, removeFns.length)) {
+        unreg();
+      }
+    };
+  }
+  removeHooks(configHooks) {
+    const hooks = flatHooks(configHooks);
+    for (const key in hooks) {
+      this.removeHook(key, hooks[key]);
+    }
+  }
+  removeAllHooks() {
+    for (const key in this._hooks) {
+      delete this._hooks[key];
+    }
+  }
+  callHook(name, ...arguments_) {
+    arguments_.unshift(name);
+    return this.callHookWith(serialTaskCaller, name, ...arguments_);
+  }
+  callHookParallel(name, ...arguments_) {
+    arguments_.unshift(name);
+    return this.callHookWith(parallelTaskCaller, name, ...arguments_);
+  }
+  callHookWith(caller, name, ...arguments_) {
+    const event = this._before || this._after ? { name, args: arguments_, context: {} } : void 0;
+    if (this._before) {
+      callEachWith(this._before, event);
+    }
+    const result = caller(
+      name in this._hooks ? [...this._hooks[name]] : [],
+      arguments_
+    );
+    if (result instanceof Promise) {
+      return result.finally(() => {
+        if (this._after && event) {
+          callEachWith(this._after, event);
+        }
+      });
+    }
+    if (this._after && event) {
+      callEachWith(this._after, event);
+    }
+    return result;
+  }
+  beforeEach(function_) {
+    this._before = this._before || [];
+    this._before.push(function_);
+    return () => {
+      if (this._before !== void 0) {
+        const index = this._before.indexOf(function_);
+        if (index !== -1) {
+          this._before.splice(index, 1);
+        }
+      }
+    };
+  }
+  afterEach(function_) {
+    this._after = this._after || [];
+    this._after.push(function_);
+    return () => {
+      if (this._after !== void 0) {
+        const index = this._after.indexOf(function_);
+        if (index !== -1) {
+          this._after.splice(index, 1);
+        }
+      }
+    };
+  }
+}
+function createHooks() {
+  return new Hookable();
+}
+
+const isBrowser = typeof window !== "undefined";
+function createDebugger(hooks, _options = {}) {
+  const options = {
+    inspect: isBrowser,
+    group: isBrowser,
+    filter: () => true,
+    ..._options
+  };
+  const _filter = options.filter;
+  const filter = typeof _filter === "string" ? (name) => name.startsWith(_filter) : _filter;
+  const _tag = options.tag ? `[${options.tag}] ` : "";
+  const logPrefix = (event) => _tag + event.name + "".padEnd(event._id, "\0");
+  const _idCtr = {};
+  const unsubscribeBefore = hooks.beforeEach((event) => {
+    if (filter !== void 0 && !filter(event.name)) {
+      return;
+    }
+    _idCtr[event.name] = _idCtr[event.name] || 0;
+    event._id = _idCtr[event.name]++;
+    console.time(logPrefix(event));
+  });
+  const unsubscribeAfter = hooks.afterEach((event) => {
+    if (filter !== void 0 && !filter(event.name)) {
+      return;
+    }
+    if (options.group) {
+      console.groupCollapsed(event.name);
+    }
+    if (options.inspect) {
+      console.timeLog(logPrefix(event), event.args);
+    } else {
+      console.timeEnd(logPrefix(event));
+    }
+    if (options.group) {
+      console.groupEnd();
+    }
+    _idCtr[event.name]--;
+  });
+  return {
+    /** Stop debugging and remove listeners */
+    close: () => {
+      unsubscribeBefore();
+      unsubscribeAfter();
+    }
+  };
+}
+
+export { Hookable, createDebugger, createHooks, flatHooks, mergeHooks, parallelCaller, serial, serialCaller };
diff --git a/parent_dir/node_modules/intlify/core-base/dist/core-base.esm-bundler.js b/parent_dir/node_modules/intlify/core-base/dist/core-base.esm-bundler.js
new file mode 100644
index 0000000..13236c6
--- /dev/null
+++ b/parent_dir/node_modules/intlify/core-base/dist/core-base.esm-bundler.js
@@ -0,0 +1,1573 @@
+/*!
+  * core-base v9.2.2
+  * (c) 2022 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+import { isObject, isString, isFunction, isNumber, isPlainObject, toDisplayString, isArray, format, isBoolean, assign, isRegExp, warn, escapeHtml, inBrowser, mark, measure, isEmptyObject, generateCodeFrame, generateFormatCacheKey, isDate, getGlobalThis } from '@intlify/shared';
+import { defaultOnError, baseCompile, CompileErrorCodes, createCompileError } from '@intlify/message-compiler';
+export { CompileErrorCodes, createCompileError } from '@intlify/message-compiler';
+import { IntlifyDevToolsHooks } from '@intlify/devtools-if';
+
+const pathStateMachine =  [];
+pathStateMachine[0 /* BEFORE_PATH */] = {
+    ["w" /* WORKSPACE */]: [0 /* BEFORE_PATH */],
+    ["i" /* IDENT */]: [3 /* IN_IDENT */, 0 /* APPEND */],
+    ["[" /* LEFT_BRACKET */]: [4 /* IN_SUB_PATH */],
+    ["o" /* END_OF_FAIL */]: [7 /* AFTER_PATH */]
+};
+pathStateMachine[1 /* IN_PATH */] = {
+    ["w" /* WORKSPACE */]: [1 /* IN_PATH */],
+    ["." /* DOT */]: [2 /* BEFORE_IDENT */],
+    ["[" /* LEFT_BRACKET */]: [4 /* IN_SUB_PATH */],
+    ["o" /* END_OF_FAIL */]: [7 /* AFTER_PATH */]
+};
+pathStateMachine[2 /* BEFORE_IDENT */] = {
+    ["w" /* WORKSPACE */]: [2 /* BEFORE_IDENT */],
+    ["i" /* IDENT */]: [3 /* IN_IDENT */, 0 /* APPEND */],
+    ["0" /* ZERO */]: [3 /* IN_IDENT */, 0 /* APPEND */]
+};
+pathStateMachine[3 /* IN_IDENT */] = {
+    ["i" /* IDENT */]: [3 /* IN_IDENT */, 0 /* APPEND */],
+    ["0" /* ZERO */]: [3 /* IN_IDENT */, 0 /* APPEND */],
+    ["w" /* WORKSPACE */]: [1 /* IN_PATH */, 1 /* PUSH */],
+    ["." /* DOT */]: [2 /* BEFORE_IDENT */, 1 /* PUSH */],
+    ["[" /* LEFT_BRACKET */]: [4 /* IN_SUB_PATH */, 1 /* PUSH */],
+    ["o" /* END_OF_FAIL */]: [7 /* AFTER_PATH */, 1 /* PUSH */]
+};
+pathStateMachine[4 /* IN_SUB_PATH */] = {
+    ["'" /* SINGLE_QUOTE */]: [5 /* IN_SINGLE_QUOTE */, 0 /* APPEND */],
+    ["\"" /* DOUBLE_QUOTE */]: [6 /* IN_DOUBLE_QUOTE */, 0 /* APPEND */],
+    ["[" /* LEFT_BRACKET */]: [
+        4 /* IN_SUB_PATH */,
+        2 /* INC_SUB_PATH_DEPTH */
+    ],
+    ["]" /* RIGHT_BRACKET */]: [1 /* IN_PATH */, 3 /* PUSH_SUB_PATH */],
+    ["o" /* END_OF_FAIL */]: 8 /* ERROR */,
+    ["l" /* ELSE */]: [4 /* IN_SUB_PATH */, 0 /* APPEND */]
+};
+pathStateMachine[5 /* IN_SINGLE_QUOTE */] = {
+    ["'" /* SINGLE_QUOTE */]: [4 /* IN_SUB_PATH */, 0 /* APPEND */],
+    ["o" /* END_OF_FAIL */]: 8 /* ERROR */,
+    ["l" /* ELSE */]: [5 /* IN_SINGLE_QUOTE */, 0 /* APPEND */]
+};
+pathStateMachine[6 /* IN_DOUBLE_QUOTE */] = {
+    ["\"" /* DOUBLE_QUOTE */]: [4 /* IN_SUB_PATH */, 0 /* APPEND */],
+    ["o" /* END_OF_FAIL */]: 8 /* ERROR */,
+    ["l" /* ELSE */]: [6 /* IN_DOUBLE_QUOTE */, 0 /* APPEND */]
+};
+/**
+ * Check if an expression is a literal value.
+ */
+const literalValueRE = /^\s?(?:true|false|-?[\d.]+|'[^']*'|"[^"]*")\s?$/;
+function isLiteral(exp) {
+    return literalValueRE.test(exp);
+}
+/**
+ * Strip quotes from a string
+ */
+function stripQuotes(str) {
+    const a = str.charCodeAt(0);
+    const b = str.charCodeAt(str.length - 1);
+    return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;
+}
+/**
+ * Determine the type of a character in a keypath.
+ */
+function getPathCharType(ch) {
+    if (ch === undefined || ch === null) {
+        return "o" /* END_OF_FAIL */;
+    }
+    const code = ch.charCodeAt(0);
+    switch (code) {
+        case 0x5b: // [
+        case 0x5d: // ]
+        case 0x2e: // .
+        case 0x22: // "
+        case 0x27: // '
+            return ch;
+        case 0x5f: // _
+        case 0x24: // $
+        case 0x2d: // -
+            return "i" /* IDENT */;
+        case 0x09: // Tab (HT)
+        case 0x0a: // Newline (LF)
+        case 0x0d: // Return (CR)
+        case 0xa0: // No-break space (NBSP)
+        case 0xfeff: // Byte Order Mark (BOM)
+        case 0x2028: // Line Separator (LS)
+        case 0x2029: // Paragraph Separator (PS)
+            return "w" /* WORKSPACE */;
+    }
+    return "i" /* IDENT */;
+}
+/**
+ * Format a subPath, return its plain form if it is
+ * a literal string or number. Otherwise prepend the
+ * dynamic indicator (*).
+ */
+function formatSubPath(path) {
+    const trimmed = path.trim();
+    // invalid leading 0
+    if (path.charAt(0) === '0' && isNaN(parseInt(path))) {
+        return false;
+    }
+    return isLiteral(trimmed)
+        ? stripQuotes(trimmed)
+        : "*" /* ASTARISK */ + trimmed;
+}
+/**
+ * Parse a string path into an array of segments
+ */
+function parse(path) {
+    const keys = [];
+    let index = -1;
+    let mode = 0 /* BEFORE_PATH */;
+    let subPathDepth = 0;
+    let c;
+    let key; // eslint-disable-line
+    let newChar;
+    let type;
+    let transition;
+    let action;
+    let typeMap;
+    const actions = [];
+    actions[0 /* APPEND */] = () => {
+        if (key === undefined) {
+            key = newChar;
+        }
+        else {
+            key += newChar;
+        }
+    };
+    actions[1 /* PUSH */] = () => {
+        if (key !== undefined) {
+            keys.push(key);
+            key = undefined;
+        }
+    };
+    actions[2 /* INC_SUB_PATH_DEPTH */] = () => {
+        actions[0 /* APPEND */]();
+        subPathDepth++;
+    };
+    actions[3 /* PUSH_SUB_PATH */] = () => {
+        if (subPathDepth > 0) {
+            subPathDepth--;
+            mode = 4 /* IN_SUB_PATH */;
+            actions[0 /* APPEND */]();
+        }
+        else {
+            subPathDepth = 0;
+            if (key === undefined) {
+                return false;
+            }
+            key = formatSubPath(key);
+            if (key === false) {
+                return false;
+            }
+            else {
+                actions[1 /* PUSH */]();
+            }
+        }
+    };
+    function maybeUnescapeQuote() {
+        const nextChar = path[index + 1];
+        if ((mode === 5 /* IN_SINGLE_QUOTE */ &&
+            nextChar === "'" /* SINGLE_QUOTE */) ||
+            (mode === 6 /* IN_DOUBLE_QUOTE */ &&
+                nextChar === "\"" /* DOUBLE_QUOTE */)) {
+            index++;
+            newChar = '\\' + nextChar;
+            actions[0 /* APPEND */]();
+            return true;
+        }
+    }
+    while (mode !== null) {
+        index++;
+        c = path[index];
+        if (c === '\\' && maybeUnescapeQuote()) {
+            continue;
+        }
+        type = getPathCharType(c);
+        typeMap = pathStateMachine[mode];
+        transition = typeMap[type] || typeMap["l" /* ELSE */] || 8 /* ERROR */;
+        // check parse error
+        if (transition === 8 /* ERROR */) {
+            return;
+        }
+        mode = transition[0];
+        if (transition[1] !== undefined) {
+            action = actions[transition[1]];
+            if (action) {
+                newChar = c;
+                if (action() === false) {
+                    return;
+                }
+            }
+        }
+        // check parse finish
+        if (mode === 7 /* AFTER_PATH */) {
+            return keys;
+        }
+    }
+}
+// path token cache
+const cache = new Map();
+/**
+ * key-value message resolver
+ *
+ * @remarks
+ * Resolves messages with the key-value structure. Note that messages with a hierarchical structure such as objects cannot be resolved
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
+ *
+ * @VueI18nGeneral
+ */
+function resolveWithKeyValue(obj, path) {
+    return isObject(obj) ? obj[path] : null;
+}
+/**
+ * message resolver
+ *
+ * @remarks
+ * Resolves messages. messages with a hierarchical structure such as objects can be resolved. This resolver is used in VueI18n as default.
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
+ *
+ * @VueI18nGeneral
+ */
+function resolveValue(obj, path) {
+    // check object
+    if (!isObject(obj)) {
+        return null;
+    }
+    // parse path
+    let hit = cache.get(path);
+    if (!hit) {
+        hit = parse(path);
+        if (hit) {
+            cache.set(path, hit);
+        }
+    }
+    // check hit
+    if (!hit) {
+        return null;
+    }
+    // resolve path value
+    const len = hit.length;
+    let last = obj;
+    let i = 0;
+    while (i < len) {
+        const val = last[hit[i]];
+        if (val === undefined) {
+            return null;
+        }
+        last = val;
+        i++;
+    }
+    return last;
+}
+
+const DEFAULT_MODIFIER = (str) => str;
+const DEFAULT_MESSAGE = (ctx) => ''; // eslint-disable-line
+const DEFAULT_MESSAGE_DATA_TYPE = 'text';
+const DEFAULT_NORMALIZE = (values) => values.length === 0 ? '' : values.join('');
+const DEFAULT_INTERPOLATE = toDisplayString;
+function pluralDefault(choice, choicesLength) {
+    choice = Math.abs(choice);
+    if (choicesLength === 2) {
+        // prettier-ignore
+        return choice
+            ? choice > 1
+                ? 1
+                : 0
+            : 1;
+    }
+    return choice ? Math.min(choice, 2) : 0;
+}
+function getPluralIndex(options) {
+    // prettier-ignore
+    const index = isNumber(options.pluralIndex)
+        ? options.pluralIndex
+        : -1;
+    // prettier-ignore
+    return options.named && (isNumber(options.named.count) || isNumber(options.named.n))
+        ? isNumber(options.named.count)
+            ? options.named.count
+            : isNumber(options.named.n)
+                ? options.named.n
+                : index
+        : index;
+}
+function normalizeNamed(pluralIndex, props) {
+    if (!props.count) {
+        props.count = pluralIndex;
+    }
+    if (!props.n) {
+        props.n = pluralIndex;
+    }
+}
+function createMessageContext(options = {}) {
+    const locale = options.locale;
+    const pluralIndex = getPluralIndex(options);
+    const pluralRule = isObject(options.pluralRules) &&
+        isString(locale) &&
+        isFunction(options.pluralRules[locale])
+        ? options.pluralRules[locale]
+        : pluralDefault;
+    const orgPluralRule = isObject(options.pluralRules) &&
+        isString(locale) &&
+        isFunction(options.pluralRules[locale])
+        ? pluralDefault
+        : undefined;
+    const plural = (messages) => {
+        return messages[pluralRule(pluralIndex, messages.length, orgPluralRule)];
+    };
+    const _list = options.list || [];
+    const list = (index) => _list[index];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const _named = options.named || {};
+    isNumber(options.pluralIndex) && normalizeNamed(pluralIndex, _named);
+    const named = (key) => _named[key];
+    function message(key) {
+        // prettier-ignore
+        const msg = isFunction(options.messages)
+            ? options.messages(key)
+            : isObject(options.messages)
+                ? options.messages[key]
+                : false;
+        return !msg
+            ? options.parent
+                ? options.parent.message(key) // resolve from parent messages
+                : DEFAULT_MESSAGE
+            : msg;
+    }
+    const _modifier = (name) => options.modifiers
+        ? options.modifiers[name]
+        : DEFAULT_MODIFIER;
+    const normalize = isPlainObject(options.processor) && isFunction(options.processor.normalize)
+        ? options.processor.normalize
+        : DEFAULT_NORMALIZE;
+    const interpolate = isPlainObject(options.processor) &&
+        isFunction(options.processor.interpolate)
+        ? options.processor.interpolate
+        : DEFAULT_INTERPOLATE;
+    const type = isPlainObject(options.processor) && isString(options.processor.type)
+        ? options.processor.type
+        : DEFAULT_MESSAGE_DATA_TYPE;
+    const linked = (key, ...args) => {
+        const [arg1, arg2] = args;
+        let type = 'text';
+        let modifier = '';
+        if (args.length === 1) {
+            if (isObject(arg1)) {
+                modifier = arg1.modifier || modifier;
+                type = arg1.type || type;
+            }
+            else if (isString(arg1)) {
+                modifier = arg1 || modifier;
+            }
+        }
+        else if (args.length === 2) {
+            if (isString(arg1)) {
+                modifier = arg1 || modifier;
+            }
+            if (isString(arg2)) {
+                type = arg2 || type;
+            }
+        }
+        let msg = message(key)(ctx);
+        // The message in vnode resolved with linked are returned as an array by processor.nomalize
+        if (type === 'vnode' && isArray(msg) && modifier) {
+            msg = msg[0];
+        }
+        return modifier ? _modifier(modifier)(msg, type) : msg;
+    };
+    const ctx = {
+        ["list" /* LIST */]: list,
+        ["named" /* NAMED */]: named,
+        ["plural" /* PLURAL */]: plural,
+        ["linked" /* LINKED */]: linked,
+        ["message" /* MESSAGE */]: message,
+        ["type" /* TYPE */]: type,
+        ["interpolate" /* INTERPOLATE */]: interpolate,
+        ["normalize" /* NORMALIZE */]: normalize
+    };
+    return ctx;
+}
+
+let devtools = null;
+function setDevToolsHook(hook) {
+    devtools = hook;
+}
+function getDevToolsHook() {
+    return devtools;
+}
+function initI18nDevTools(i18n, version, meta) {
+    // TODO: queue if devtools is undefined
+    devtools &&
+        devtools.emit(IntlifyDevToolsHooks.I18nInit, {
+            timestamp: Date.now(),
+            i18n,
+            version,
+            meta
+        });
+}
+const translateDevTools = /* #__PURE__*/ createDevToolsHook(IntlifyDevToolsHooks.FunctionTranslate);
+function createDevToolsHook(hook) {
+    return (payloads) => devtools && devtools.emit(hook, payloads);
+}
+
+const CoreWarnCodes = {
+    NOT_FOUND_KEY: 1,
+    FALLBACK_TO_TRANSLATE: 2,
+    CANNOT_FORMAT_NUMBER: 3,
+    FALLBACK_TO_NUMBER_FORMAT: 4,
+    CANNOT_FORMAT_DATE: 5,
+    FALLBACK_TO_DATE_FORMAT: 6,
+    __EXTEND_POINT__: 7
+};
+/** @internal */
+const warnMessages = {
+    [CoreWarnCodes.NOT_FOUND_KEY]: `Not found '{key}' key in '{locale}' locale messages.`,
+    [CoreWarnCodes.FALLBACK_TO_TRANSLATE]: `Fall back to translate '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.CANNOT_FORMAT_NUMBER]: `Cannot format a number value due to not supported Intl.NumberFormat.`,
+    [CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT]: `Fall back to number format '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.CANNOT_FORMAT_DATE]: `Cannot format a date value due to not supported Intl.DateTimeFormat.`,
+    [CoreWarnCodes.FALLBACK_TO_DATE_FORMAT]: `Fall back to datetime format '{key}' key with '{target}' locale.`
+};
+function getWarnMessage(code, ...args) {
+    return format(warnMessages[code], ...args);
+}
+
+/**
+ * Fallback with simple implemenation
+ *
+ * @remarks
+ * A fallback locale function implemented with a simple fallback algorithm.
+ *
+ * Basically, it returns the value as specified in the `fallbackLocale` props, and is processed with the fallback inside intlify.
+ *
+ * @param ctx - A {@link CoreContext | context}
+ * @param fallback - A {@link FallbackLocale | fallback locale}
+ * @param start - A starting {@link Locale | locale}
+ *
+ * @returns Fallback locales
+ *
+ * @VueI18nGeneral
+ */
+function fallbackWithSimple(ctx, fallback, start // eslint-disable-line @typescript-eslint/no-unused-vars
+) {
+    // prettier-ignore
+    return [...new Set([
+            start,
+            ...(isArray(fallback)
+                ? fallback
+                : isObject(fallback)
+                    ? Object.keys(fallback)
+                    : isString(fallback)
+                        ? [fallback]
+                        : [start])
+        ])];
+}
+/**
+ * Fallback with locale chain
+ *
+ * @remarks
+ * A fallback locale function implemented with a fallback chain algorithm. It's used in VueI18n as default.
+ *
+ * @param ctx - A {@link CoreContext | context}
+ * @param fallback - A {@link FallbackLocale | fallback locale}
+ * @param start - A starting {@link Locale | locale}
+ *
+ * @returns Fallback locales
+ *
+ * @VueI18nSee [Fallbacking](../guide/essentials/fallback)
+ *
+ * @VueI18nGeneral
+ */
+function fallbackWithLocaleChain(ctx, fallback, start) {
+    const startLocale = isString(start) ? start : DEFAULT_LOCALE;
+    const context = ctx;
+    if (!context.__localeChainCache) {
+        context.__localeChainCache = new Map();
+    }
+    let chain = context.__localeChainCache.get(startLocale);
+    if (!chain) {
+        chain = [];
+        // first block defined by start
+        let block = [start];
+        // while any intervening block found
+        while (isArray(block)) {
+            block = appendBlockToChain(chain, block, fallback);
+        }
+        // prettier-ignore
+        // last block defined by default
+        const defaults = isArray(fallback) || !isPlainObject(fallback)
+            ? fallback
+            : fallback['default']
+                ? fallback['default']
+                : null;
+        // convert defaults to array
+        block = isString(defaults) ? [defaults] : defaults;
+        if (isArray(block)) {
+            appendBlockToChain(chain, block, false);
+        }
+        context.__localeChainCache.set(startLocale, chain);
+    }
+    return chain;
+}
+function appendBlockToChain(chain, block, blocks) {
+    let follow = true;
+    for (let i = 0; i < block.length && isBoolean(follow); i++) {
+        const locale = block[i];
+        if (isString(locale)) {
+            follow = appendLocaleToChain(chain, block[i], blocks);
+        }
+    }
+    return follow;
+}
+function appendLocaleToChain(chain, locale, blocks) {
+    let follow;
+    const tokens = locale.split('-');
+    do {
+        const target = tokens.join('-');
+        follow = appendItemToChain(chain, target, blocks);
+        tokens.splice(-1, 1);
+    } while (tokens.length && follow === true);
+    return follow;
+}
+function appendItemToChain(chain, target, blocks) {
+    let follow = false;
+    if (!chain.includes(target)) {
+        follow = true;
+        if (target) {
+            follow = target[target.length - 1] !== '!';
+            const locale = target.replace(/!/g, '');
+            chain.push(locale);
+            if ((isArray(blocks) || isPlainObject(blocks)) &&
+                blocks[locale] // eslint-disable-line @typescript-eslint/no-explicit-any
+            ) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                follow = blocks[locale];
+            }
+        }
+    }
+    return follow;
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Intlify core-base version
+ * @internal
+ */
+const VERSION = '9.2.2';
+const NOT_REOSLVED = -1;
+const DEFAULT_LOCALE = 'en-US';
+const MISSING_RESOLVE_VALUE = '';
+const capitalize = (str) => `${str.charAt(0).toLocaleUpperCase()}${str.substr(1)}`;
+function getDefaultLinkedModifiers() {
+    return {
+        upper: (val, type) => {
+            // prettier-ignore
+            return type === 'text' && isString(val)
+                ? val.toUpperCase()
+                : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                    ? val.children.toUpperCase()
+                    : val;
+        },
+        lower: (val, type) => {
+            // prettier-ignore
+            return type === 'text' && isString(val)
+                ? val.toLowerCase()
+                : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                    ? val.children.toLowerCase()
+                    : val;
+        },
+        capitalize: (val, type) => {
+            // prettier-ignore
+            return (type === 'text' && isString(val)
+                ? capitalize(val)
+                : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                    ? capitalize(val.children)
+                    : val);
+        }
+    };
+}
+let _compiler;
+function registerMessageCompiler(compiler) {
+    _compiler = compiler;
+}
+let _resolver;
+/**
+ * Register the message resolver
+ *
+ * @param resolver - A {@link MessageResolver} function
+ *
+ * @VueI18nGeneral
+ */
+function registerMessageResolver(resolver) {
+    _resolver = resolver;
+}
+let _fallbacker;
+/**
+ * Register the locale fallbacker
+ *
+ * @param fallbacker - A {@link LocaleFallbacker} function
+ *
+ * @VueI18nGeneral
+ */
+function registerLocaleFallbacker(fallbacker) {
+    _fallbacker = fallbacker;
+}
+// Additional Meta for Intlify DevTools
+let _additionalMeta = null;
+const setAdditionalMeta =  (meta) => {
+    _additionalMeta = meta;
+};
+const getAdditionalMeta =  () => _additionalMeta;
+let _fallbackContext = null;
+const setFallbackContext = (context) => {
+    _fallbackContext = context;
+};
+const getFallbackContext = () => _fallbackContext;
+// ID for CoreContext
+let _cid = 0;
+function createCoreContext(options = {}) {
+    // setup options
+    const version = isString(options.version) ? options.version : VERSION;
+    const locale = isString(options.locale) ? options.locale : DEFAULT_LOCALE;
+    const fallbackLocale = isArray(options.fallbackLocale) ||
+        isPlainObject(options.fallbackLocale) ||
+        isString(options.fallbackLocale) ||
+        options.fallbackLocale === false
+        ? options.fallbackLocale
+        : locale;
+    const messages = isPlainObject(options.messages)
+        ? options.messages
+        : { [locale]: {} };
+    const datetimeFormats = isPlainObject(options.datetimeFormats)
+            ? options.datetimeFormats
+            : { [locale]: {} }
+        ;
+    const numberFormats = isPlainObject(options.numberFormats)
+            ? options.numberFormats
+            : { [locale]: {} }
+        ;
+    const modifiers = assign({}, options.modifiers || {}, getDefaultLinkedModifiers());
+    const pluralRules = options.pluralRules || {};
+    const missing = isFunction(options.missing) ? options.missing : null;
+    const missingWarn = isBoolean(options.missingWarn) || isRegExp(options.missingWarn)
+        ? options.missingWarn
+        : true;
+    const fallbackWarn = isBoolean(options.fallbackWarn) || isRegExp(options.fallbackWarn)
+        ? options.fallbackWarn
+        : true;
+    const fallbackFormat = !!options.fallbackFormat;
+    const unresolving = !!options.unresolving;
+    const postTranslation = isFunction(options.postTranslation)
+        ? options.postTranslation
+        : null;
+    const processor = isPlainObject(options.processor) ? options.processor : null;
+    const warnHtmlMessage = isBoolean(options.warnHtmlMessage)
+        ? options.warnHtmlMessage
+        : true;
+    const escapeParameter = !!options.escapeParameter;
+    const messageCompiler = isFunction(options.messageCompiler)
+        ? options.messageCompiler
+        : _compiler;
+    const messageResolver = isFunction(options.messageResolver)
+        ? options.messageResolver
+        : _resolver || resolveWithKeyValue;
+    const localeFallbacker = isFunction(options.localeFallbacker)
+        ? options.localeFallbacker
+        : _fallbacker || fallbackWithSimple;
+    const fallbackContext = isObject(options.fallbackContext)
+        ? options.fallbackContext
+        : undefined;
+    const onWarn = isFunction(options.onWarn) ? options.onWarn : warn;
+    // setup internal options
+    const internalOptions = options;
+    const __datetimeFormatters = isObject(internalOptions.__datetimeFormatters)
+            ? internalOptions.__datetimeFormatters
+            : new Map()
+        ;
+    const __numberFormatters = isObject(internalOptions.__numberFormatters)
+            ? internalOptions.__numberFormatters
+            : new Map()
+        ;
+    const __meta = isObject(internalOptions.__meta) ? internalOptions.__meta : {};
+    _cid++;
+    const context = {
+        version,
+        cid: _cid,
+        locale,
+        fallbackLocale,
+        messages,
+        modifiers,
+        pluralRules,
+        missing,
+        missingWarn,
+        fallbackWarn,
+        fallbackFormat,
+        unresolving,
+        postTranslation,
+        processor,
+        warnHtmlMessage,
+        escapeParameter,
+        messageCompiler,
+        messageResolver,
+        localeFallbacker,
+        fallbackContext,
+        onWarn,
+        __meta
+    };
+    {
+        context.datetimeFormats = datetimeFormats;
+        context.numberFormats = numberFormats;
+        context.__datetimeFormatters = __datetimeFormatters;
+        context.__numberFormatters = __numberFormatters;
+    }
+    // for vue-devtools timeline event
+    if ((process.env.NODE_ENV !== 'production')) {
+        context.__v_emitter =
+            internalOptions.__v_emitter != null
+                ? internalOptions.__v_emitter
+                : undefined;
+    }
+    // NOTE: experimental !!
+    if ((process.env.NODE_ENV !== 'production') || __INTLIFY_PROD_DEVTOOLS__) {
+        initI18nDevTools(context, version, __meta);
+    }
+    return context;
+}
+/** @internal */
+function isTranslateFallbackWarn(fallback, key) {
+    return fallback instanceof RegExp ? fallback.test(key) : fallback;
+}
+/** @internal */
+function isTranslateMissingWarn(missing, key) {
+    return missing instanceof RegExp ? missing.test(key) : missing;
+}
+/** @internal */
+function handleMissing(context, key, locale, missingWarn, type) {
+    const { missing, onWarn } = context;
+    // for vue-devtools timeline event
+    if ((process.env.NODE_ENV !== 'production')) {
+        const emitter = context.__v_emitter;
+        if (emitter) {
+            emitter.emit("missing" /* MISSING */, {
+                locale,
+                key,
+                type,
+                groupId: `${type}:${key}`
+            });
+        }
+    }
+    if (missing !== null) {
+        const ret = missing(context, locale, key, type);
+        return isString(ret) ? ret : key;
+    }
+    else {
+        if ((process.env.NODE_ENV !== 'production') && isTranslateMissingWarn(missingWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.NOT_FOUND_KEY, { key, locale }));
+        }
+        return key;
+    }
+}
+/** @internal */
+function updateFallbackLocale(ctx, locale, fallback) {
+    const context = ctx;
+    context.__localeChainCache = new Map();
+    ctx.localeFallbacker(ctx, fallback, locale);
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+const RE_HTML_TAG = /<\/?[\w\s="/.':;#-\/]+>/;
+const WARN_MESSAGE = `Detected HTML in '{source}' message. Recommend not using HTML messages to avoid XSS.`;
+function checkHtmlMessage(source, options) {
+    const warnHtmlMessage = isBoolean(options.warnHtmlMessage)
+        ? options.warnHtmlMessage
+        : true;
+    if (warnHtmlMessage && RE_HTML_TAG.test(source)) {
+        warn(format(WARN_MESSAGE, { source }));
+    }
+}
+const defaultOnCacheKey = (source) => source;
+let compileCache = Object.create(null);
+function clearCompileCache() {
+    compileCache = Object.create(null);
+}
+function compileToFunction(source, options = {}) {
+    {
+        // check HTML message
+        (process.env.NODE_ENV !== 'production') && checkHtmlMessage(source, options);
+        // check caches
+        const onCacheKey = options.onCacheKey || defaultOnCacheKey;
+        const key = onCacheKey(source);
+        const cached = compileCache[key];
+        if (cached) {
+            return cached;
+        }
+        // compile error detecting
+        let occurred = false;
+        const onError = options.onError || defaultOnError;
+        options.onError = (err) => {
+            occurred = true;
+            onError(err);
+        };
+        // compile
+        const { code } = baseCompile(source, options);
+        // evaluate function
+        const msg = new Function(`return ${code}`)();
+        // if occurred compile error, don't cache
+        return !occurred ? (compileCache[key] = msg) : msg;
+    }
+}
+
+let code = CompileErrorCodes.__EXTEND_POINT__;
+const inc = () => ++code;
+const CoreErrorCodes = {
+    INVALID_ARGUMENT: code,
+    INVALID_DATE_ARGUMENT: inc(),
+    INVALID_ISO_DATE_ARGUMENT: inc(),
+    __EXTEND_POINT__: inc() // 18
+};
+function createCoreError(code) {
+    return createCompileError(code, null, (process.env.NODE_ENV !== 'production') ? { messages: errorMessages } : undefined);
+}
+/** @internal */
+const errorMessages = {
+    [CoreErrorCodes.INVALID_ARGUMENT]: 'Invalid arguments',
+    [CoreErrorCodes.INVALID_DATE_ARGUMENT]: 'The date provided is an invalid Date object.' +
+        'Make sure your Date represents a valid date.',
+    [CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT]: 'The argument provided is not a valid ISO date string'
+};
+
+const NOOP_MESSAGE_FUNCTION = () => '';
+const isMessageFunction = (val) => isFunction(val);
+// implementation of `translate` function
+function translate(context, ...args) {
+    const { fallbackFormat, postTranslation, unresolving, messageCompiler, fallbackLocale, messages } = context;
+    const [key, options] = parseTranslateArgs(...args);
+    const missingWarn = isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    const fallbackWarn = isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const escapeParameter = isBoolean(options.escapeParameter)
+        ? options.escapeParameter
+        : context.escapeParameter;
+    const resolvedMessage = !!options.resolvedMessage;
+    // prettier-ignore
+    const defaultMsgOrKey = isString(options.default) || isBoolean(options.default) // default by function option
+        ? !isBoolean(options.default)
+            ? options.default
+            : (!messageCompiler ? () => key : key)
+        : fallbackFormat // default by `fallbackFormat` option
+            ? (!messageCompiler ? () => key : key)
+            : '';
+    const enableDefaultMsg = fallbackFormat || defaultMsgOrKey !== '';
+    const locale = isString(options.locale) ? options.locale : context.locale;
+    // escape params
+    escapeParameter && escapeParams(options);
+    // resolve message format
+    // eslint-disable-next-line prefer-const
+    let [formatScope, targetLocale, message] = !resolvedMessage
+        ? resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn)
+        : [
+            key,
+            locale,
+            messages[locale] || {}
+        ];
+    // NOTE:
+    //  Fix to work around `ssrTransfrom` bug in Vite.
+    //  https://github.com/vitejs/vite/issues/4306
+    //  To get around this, use temporary variables.
+    //  https://github.com/nuxt/framework/issues/1461#issuecomment-954606243
+    let format = formatScope;
+    // if you use default message, set it as message format!
+    let cacheBaseKey = key;
+    if (!resolvedMessage &&
+        !(isString(format) || isMessageFunction(format))) {
+        if (enableDefaultMsg) {
+            format = defaultMsgOrKey;
+            cacheBaseKey = format;
+        }
+    }
+    // checking message format and target locale
+    if (!resolvedMessage &&
+        (!(isString(format) || isMessageFunction(format)) ||
+            !isString(targetLocale))) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    if ((process.env.NODE_ENV !== 'production') && isString(format) && context.messageCompiler == null) {
+        warn(`The message format compilation is not supported in this build. ` +
+            `Because message compiler isn't included. ` +
+            `You need to pre-compilation all message format. ` +
+            `So translate function return '${key}'.`);
+        return key;
+    }
+    // setup compile error detecting
+    let occurred = false;
+    const errorDetector = () => {
+        occurred = true;
+    };
+    // compile message format
+    const msg = !isMessageFunction(format)
+        ? compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, errorDetector)
+        : format;
+    // if occurred compile error, return the message format
+    if (occurred) {
+        return format;
+    }
+    // evaluate message with context
+    const ctxOptions = getMessageContextOptions(context, targetLocale, message, options);
+    const msgContext = createMessageContext(ctxOptions);
+    const messaged = evaluateMessage(context, msg, msgContext);
+    // if use post translation option, proceed it with handler
+    const ret = postTranslation
+        ? postTranslation(messaged, key)
+        : messaged;
+    // NOTE: experimental !!
+    if ((process.env.NODE_ENV !== 'production') || __INTLIFY_PROD_DEVTOOLS__) {
+        // prettier-ignore
+        const payloads = {
+            timestamp: Date.now(),
+            key: isString(key)
+                ? key
+                : isMessageFunction(format)
+                    ? format.key
+                    : '',
+            locale: targetLocale || (isMessageFunction(format)
+                ? format.locale
+                : ''),
+            format: isString(format)
+                ? format
+                : isMessageFunction(format)
+                    ? format.source
+                    : '',
+            message: ret
+        };
+        payloads.meta = assign({}, context.__meta, getAdditionalMeta() || {});
+        translateDevTools(payloads);
+    }
+    return ret;
+}
+function escapeParams(options) {
+    if (isArray(options.list)) {
+        options.list = options.list.map(item => isString(item) ? escapeHtml(item) : item);
+    }
+    else if (isObject(options.named)) {
+        Object.keys(options.named).forEach(key => {
+            if (isString(options.named[key])) {
+                options.named[key] = escapeHtml(options.named[key]);
+            }
+        });
+    }
+}
+function resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn) {
+    const { messages, onWarn, messageResolver: resolveValue, localeFallbacker } = context;
+    const locales = localeFallbacker(context, fallbackLocale, locale); // eslint-disable-line @typescript-eslint/no-explicit-any
+    let message = {};
+    let targetLocale;
+    let format = null;
+    let from = locale;
+    let to = null;
+    const type = 'translate';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = to = locales[i];
+        if ((process.env.NODE_ENV !== 'production') &&
+            locale !== targetLocale &&
+            isTranslateFallbackWarn(fallbackWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_TRANSLATE, {
+                key,
+                target: targetLocale
+            }));
+        }
+        // for vue-devtools timeline event
+        if ((process.env.NODE_ENV !== 'production') && locale !== targetLocale) {
+            const emitter = context.__v_emitter;
+            if (emitter) {
+                emitter.emit("fallback" /* FALBACK */, {
+                    type,
+                    key,
+                    from,
+                    to,
+                    groupId: `${type}:${key}`
+                });
+            }
+        }
+        message =
+            messages[targetLocale] || {};
+        // for vue-devtools timeline event
+        let start = null;
+        let startTag;
+        let endTag;
+        if ((process.env.NODE_ENV !== 'production') && inBrowser) {
+            start = window.performance.now();
+            startTag = 'intlify-message-resolve-start';
+            endTag = 'intlify-message-resolve-end';
+            mark && mark(startTag);
+        }
+        if ((format = resolveValue(message, key)) === null) {
+            // if null, resolve with object key path
+            format = message[key]; // eslint-disable-line @typescript-eslint/no-explicit-any
+        }
+        // for vue-devtools timeline event
+        if ((process.env.NODE_ENV !== 'production') && inBrowser) {
+            const end = window.performance.now();
+            const emitter = context.__v_emitter;
+            if (emitter && start && format) {
+                emitter.emit("message-resolve" /* MESSAGE_RESOLVE */, {
+                    type: "message-resolve" /* MESSAGE_RESOLVE */,
+                    key,
+                    message: format,
+                    time: end - start,
+                    groupId: `${type}:${key}`
+                });
+            }
+            if (startTag && endTag && mark && measure) {
+                mark(endTag);
+                measure('intlify message resolve', startTag, endTag);
+            }
+        }
+        if (isString(format) || isFunction(format))
+            break;
+        const missingRet = handleMissing(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+        key, targetLocale, missingWarn, type);
+        if (missingRet !== key) {
+            format = missingRet;
+        }
+        from = to;
+    }
+    return [format, targetLocale, message];
+}
+function compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, errorDetector) {
+    const { messageCompiler, warnHtmlMessage } = context;
+    if (isMessageFunction(format)) {
+        const msg = format;
+        msg.locale = msg.locale || targetLocale;
+        msg.key = msg.key || key;
+        return msg;
+    }
+    if (messageCompiler == null) {
+        const msg = (() => format);
+        msg.locale = targetLocale;
+        msg.key = key;
+        return msg;
+    }
+    // for vue-devtools timeline event
+    let start = null;
+    let startTag;
+    let endTag;
+    if ((process.env.NODE_ENV !== 'production') && inBrowser) {
+        start = window.performance.now();
+        startTag = 'intlify-message-compilation-start';
+        endTag = 'intlify-message-compilation-end';
+        mark && mark(startTag);
+    }
+    const msg = messageCompiler(format, getCompileOptions(context, targetLocale, cacheBaseKey, format, warnHtmlMessage, errorDetector));
+    // for vue-devtools timeline event
+    if ((process.env.NODE_ENV !== 'production') && inBrowser) {
+        const end = window.performance.now();
+        const emitter = context.__v_emitter;
+        if (emitter && start) {
+            emitter.emit("message-compilation" /* MESSAGE_COMPILATION */, {
+                type: "message-compilation" /* MESSAGE_COMPILATION */,
+                message: format,
+                time: end - start,
+                groupId: `${'translate'}:${key}`
+            });
+        }
+        if (startTag && endTag && mark && measure) {
+            mark(endTag);
+            measure('intlify message compilation', startTag, endTag);
+        }
+    }
+    msg.locale = targetLocale;
+    msg.key = key;
+    msg.source = format;
+    return msg;
+}
+function evaluateMessage(context, msg, msgCtx) {
+    // for vue-devtools timeline event
+    let start = null;
+    let startTag;
+    let endTag;
+    if ((process.env.NODE_ENV !== 'production') && inBrowser) {
+        start = window.performance.now();
+        startTag = 'intlify-message-evaluation-start';
+        endTag = 'intlify-message-evaluation-end';
+        mark && mark(startTag);
+    }
+    const messaged = msg(msgCtx);
+    // for vue-devtools timeline event
+    if ((process.env.NODE_ENV !== 'production') && inBrowser) {
+        const end = window.performance.now();
+        const emitter = context.__v_emitter;
+        if (emitter && start) {
+            emitter.emit("message-evaluation" /* MESSAGE_EVALUATION */, {
+                type: "message-evaluation" /* MESSAGE_EVALUATION */,
+                value: messaged,
+                time: end - start,
+                groupId: `${'translate'}:${msg.key}`
+            });
+        }
+        if (startTag && endTag && mark && measure) {
+            mark(endTag);
+            measure('intlify message evaluation', startTag, endTag);
+        }
+    }
+    return messaged;
+}
+/** @internal */
+function parseTranslateArgs(...args) {
+    const [arg1, arg2, arg3] = args;
+    const options = {};
+    if (!isString(arg1) && !isNumber(arg1) && !isMessageFunction(arg1)) {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    // prettier-ignore
+    const key = isNumber(arg1)
+        ? String(arg1)
+        : isMessageFunction(arg1)
+            ? arg1
+            : arg1;
+    if (isNumber(arg2)) {
+        options.plural = arg2;
+    }
+    else if (isString(arg2)) {
+        options.default = arg2;
+    }
+    else if (isPlainObject(arg2) && !isEmptyObject(arg2)) {
+        options.named = arg2;
+    }
+    else if (isArray(arg2)) {
+        options.list = arg2;
+    }
+    if (isNumber(arg3)) {
+        options.plural = arg3;
+    }
+    else if (isString(arg3)) {
+        options.default = arg3;
+    }
+    else if (isPlainObject(arg3)) {
+        assign(options, arg3);
+    }
+    return [key, options];
+}
+function getCompileOptions(context, locale, key, source, warnHtmlMessage, errorDetector) {
+    return {
+        warnHtmlMessage,
+        onError: (err) => {
+            errorDetector && errorDetector(err);
+            if ((process.env.NODE_ENV !== 'production')) {
+                const message = `Message compilation error: ${err.message}`;
+                const codeFrame = err.location &&
+                    generateCodeFrame(source, err.location.start.offset, err.location.end.offset);
+                const emitter = context.__v_emitter;
+                if (emitter) {
+                    emitter.emit("compile-error" /* COMPILE_ERROR */, {
+                        message: source,
+                        error: err.message,
+                        start: err.location && err.location.start.offset,
+                        end: err.location && err.location.end.offset,
+                        groupId: `${'translate'}:${key}`
+                    });
+                }
+                console.error(codeFrame ? `${message}\n${codeFrame}` : message);
+            }
+            else {
+                throw err;
+            }
+        },
+        onCacheKey: (source) => generateFormatCacheKey(locale, key, source)
+    };
+}
+function getMessageContextOptions(context, locale, message, options) {
+    const { modifiers, pluralRules, messageResolver: resolveValue, fallbackLocale, fallbackWarn, missingWarn, fallbackContext } = context;
+    const resolveMessage = (key) => {
+        let val = resolveValue(message, key);
+        // fallback to root context
+        if (val == null && fallbackContext) {
+            const [, , message] = resolveMessageFormat(fallbackContext, key, locale, fallbackLocale, fallbackWarn, missingWarn);
+            val = resolveValue(message, key);
+        }
+        if (isString(val)) {
+            let occurred = false;
+            const errorDetector = () => {
+                occurred = true;
+            };
+            const msg = compileMessageFormat(context, key, locale, val, key, errorDetector);
+            return !occurred
+                ? msg
+                : NOOP_MESSAGE_FUNCTION;
+        }
+        else if (isMessageFunction(val)) {
+            return val;
+        }
+        else {
+            // TODO: should be implemented warning message
+            return NOOP_MESSAGE_FUNCTION;
+        }
+    };
+    const ctxOptions = {
+        locale,
+        modifiers,
+        pluralRules,
+        messages: resolveMessage
+    };
+    if (context.processor) {
+        ctxOptions.processor = context.processor;
+    }
+    if (options.list) {
+        ctxOptions.list = options.list;
+    }
+    if (options.named) {
+        ctxOptions.named = options.named;
+    }
+    if (isNumber(options.plural)) {
+        ctxOptions.pluralIndex = options.plural;
+    }
+    return ctxOptions;
+}
+
+const intlDefined = typeof Intl !== 'undefined';
+const Availabilities = {
+    dateTimeFormat: intlDefined && typeof Intl.DateTimeFormat !== 'undefined',
+    numberFormat: intlDefined && typeof Intl.NumberFormat !== 'undefined'
+};
+
+// implementation of `datetime` function
+function datetime(context, ...args) {
+    const { datetimeFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { __datetimeFormatters } = context;
+    if ((process.env.NODE_ENV !== 'production') && !Availabilities.dateTimeFormat) {
+        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_DATE));
+        return MISSING_RESOLVE_VALUE;
+    }
+    const [key, value, options, overrides] = parseDateTimeArgs(...args);
+    const missingWarn = isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    const fallbackWarn = isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const part = !!options.part;
+    const locale = isString(options.locale) ? options.locale : context.locale;
+    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+    fallbackLocale, locale);
+    if (!isString(key) || key === '') {
+        return new Intl.DateTimeFormat(locale, overrides).format(value);
+    }
+    // resolve format
+    let datetimeFormat = {};
+    let targetLocale;
+    let format = null;
+    let from = locale;
+    let to = null;
+    const type = 'datetime format';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = to = locales[i];
+        if ((process.env.NODE_ENV !== 'production') &&
+            locale !== targetLocale &&
+            isTranslateFallbackWarn(fallbackWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_DATE_FORMAT, {
+                key,
+                target: targetLocale
+            }));
+        }
+        // for vue-devtools timeline event
+        if ((process.env.NODE_ENV !== 'production') && locale !== targetLocale) {
+            const emitter = context.__v_emitter;
+            if (emitter) {
+                emitter.emit("fallback" /* FALBACK */, {
+                    type,
+                    key,
+                    from,
+                    to,
+                    groupId: `${type}:${key}`
+                });
+            }
+        }
+        datetimeFormat =
+            datetimeFormats[targetLocale] || {};
+        format = datetimeFormat[key];
+        if (isPlainObject(format))
+            break;
+        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+        from = to;
+    }
+    // checking format and target locale
+    if (!isPlainObject(format) || !isString(targetLocale)) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    let id = `${targetLocale}__${key}`;
+    if (!isEmptyObject(overrides)) {
+        id = `${id}__${JSON.stringify(overrides)}`;
+    }
+    let formatter = __datetimeFormatters.get(id);
+    if (!formatter) {
+        formatter = new Intl.DateTimeFormat(targetLocale, assign({}, format, overrides));
+        __datetimeFormatters.set(id, formatter);
+    }
+    return !part ? formatter.format(value) : formatter.formatToParts(value);
+}
+/** @internal */
+const DATETIME_FORMAT_OPTIONS_KEYS = [
+    'localeMatcher',
+    'weekday',
+    'era',
+    'year',
+    'month',
+    'day',
+    'hour',
+    'minute',
+    'second',
+    'timeZoneName',
+    'formatMatcher',
+    'hour12',
+    'timeZone',
+    'dateStyle',
+    'timeStyle',
+    'calendar',
+    'dayPeriod',
+    'numberingSystem',
+    'hourCycle',
+    'fractionalSecondDigits'
+];
+/** @internal */
+function parseDateTimeArgs(...args) {
+    const [arg1, arg2, arg3, arg4] = args;
+    const options = {};
+    let overrides = {};
+    let value;
+    if (isString(arg1)) {
+        // Only allow ISO strings - other date formats are often supported,
+        // but may cause different results in different browsers.
+        const matches = arg1.match(/(\d{4}-\d{2}-\d{2})(T|\s)?(.*)/);
+        if (!matches) {
+            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+        }
+        // Some browsers can not parse the iso datetime separated by space,
+        // this is a compromise solution by replace the 'T'/' ' with 'T'
+        const dateTime = matches[3]
+            ? matches[3].trim().startsWith('T')
+                ? `${matches[1].trim()}${matches[3].trim()}`
+                : `${matches[1].trim()}T${matches[3].trim()}`
+            : matches[1].trim();
+        value = new Date(dateTime);
+        try {
+            // This will fail if the date is not valid
+            value.toISOString();
+        }
+        catch (e) {
+            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+        }
+    }
+    else if (isDate(arg1)) {
+        if (isNaN(arg1.getTime())) {
+            throw createCoreError(CoreErrorCodes.INVALID_DATE_ARGUMENT);
+        }
+        value = arg1;
+    }
+    else if (isNumber(arg1)) {
+        value = arg1;
+    }
+    else {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    if (isString(arg2)) {
+        options.key = arg2;
+    }
+    else if (isPlainObject(arg2)) {
+        Object.keys(arg2).forEach(key => {
+            if (DATETIME_FORMAT_OPTIONS_KEYS.includes(key)) {
+                overrides[key] = arg2[key];
+            }
+            else {
+                options[key] = arg2[key];
+            }
+        });
+    }
+    if (isString(arg3)) {
+        options.locale = arg3;
+    }
+    else if (isPlainObject(arg3)) {
+        overrides = arg3;
+    }
+    if (isPlainObject(arg4)) {
+        overrides = arg4;
+    }
+    return [options.key || '', value, options, overrides];
+}
+/** @internal */
+function clearDateTimeFormat(ctx, locale, format) {
+    const context = ctx;
+    for (const key in format) {
+        const id = `${locale}__${key}`;
+        if (!context.__datetimeFormatters.has(id)) {
+            continue;
+        }
+        context.__datetimeFormatters.delete(id);
+    }
+}
+
+// implementation of `number` function
+function number(context, ...args) {
+    const { numberFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { __numberFormatters } = context;
+    if ((process.env.NODE_ENV !== 'production') && !Availabilities.numberFormat) {
+        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_NUMBER));
+        return MISSING_RESOLVE_VALUE;
+    }
+    const [key, value, options, overrides] = parseNumberArgs(...args);
+    const missingWarn = isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    const fallbackWarn = isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const part = !!options.part;
+    const locale = isString(options.locale) ? options.locale : context.locale;
+    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+    fallbackLocale, locale);
+    if (!isString(key) || key === '') {
+        return new Intl.NumberFormat(locale, overrides).format(value);
+    }
+    // resolve format
+    let numberFormat = {};
+    let targetLocale;
+    let format = null;
+    let from = locale;
+    let to = null;
+    const type = 'number format';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = to = locales[i];
+        if ((process.env.NODE_ENV !== 'production') &&
+            locale !== targetLocale &&
+            isTranslateFallbackWarn(fallbackWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT, {
+                key,
+                target: targetLocale
+            }));
+        }
+        // for vue-devtools timeline event
+        if ((process.env.NODE_ENV !== 'production') && locale !== targetLocale) {
+            const emitter = context.__v_emitter;
+            if (emitter) {
+                emitter.emit("fallback" /* FALBACK */, {
+                    type,
+                    key,
+                    from,
+                    to,
+                    groupId: `${type}:${key}`
+                });
+            }
+        }
+        numberFormat =
+            numberFormats[targetLocale] || {};
+        format = numberFormat[key];
+        if (isPlainObject(format))
+            break;
+        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+        from = to;
+    }
+    // checking format and target locale
+    if (!isPlainObject(format) || !isString(targetLocale)) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    let id = `${targetLocale}__${key}`;
+    if (!isEmptyObject(overrides)) {
+        id = `${id}__${JSON.stringify(overrides)}`;
+    }
+    let formatter = __numberFormatters.get(id);
+    if (!formatter) {
+        formatter = new Intl.NumberFormat(targetLocale, assign({}, format, overrides));
+        __numberFormatters.set(id, formatter);
+    }
+    return !part ? formatter.format(value) : formatter.formatToParts(value);
+}
+/** @internal */
+const NUMBER_FORMAT_OPTIONS_KEYS = [
+    'localeMatcher',
+    'style',
+    'currency',
+    'currencyDisplay',
+    'currencySign',
+    'useGrouping',
+    'minimumIntegerDigits',
+    'minimumFractionDigits',
+    'maximumFractionDigits',
+    'minimumSignificantDigits',
+    'maximumSignificantDigits',
+    'compactDisplay',
+    'notation',
+    'signDisplay',
+    'unit',
+    'unitDisplay',
+    'roundingMode',
+    'roundingPriority',
+    'roundingIncrement',
+    'trailingZeroDisplay'
+];
+/** @internal */
+function parseNumberArgs(...args) {
+    const [arg1, arg2, arg3, arg4] = args;
+    const options = {};
+    let overrides = {};
+    if (!isNumber(arg1)) {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    const value = arg1;
+    if (isString(arg2)) {
+        options.key = arg2;
+    }
+    else if (isPlainObject(arg2)) {
+        Object.keys(arg2).forEach(key => {
+            if (NUMBER_FORMAT_OPTIONS_KEYS.includes(key)) {
+                overrides[key] = arg2[key];
+            }
+            else {
+                options[key] = arg2[key];
+            }
+        });
+    }
+    if (isString(arg3)) {
+        options.locale = arg3;
+    }
+    else if (isPlainObject(arg3)) {
+        overrides = arg3;
+    }
+    if (isPlainObject(arg4)) {
+        overrides = arg4;
+    }
+    return [options.key || '', value, options, overrides];
+}
+/** @internal */
+function clearNumberFormat(ctx, locale, format) {
+    const context = ctx;
+    for (const key in format) {
+        const id = `${locale}__${key}`;
+        if (!context.__numberFormatters.has(id)) {
+            continue;
+        }
+        context.__numberFormatters.delete(id);
+    }
+}
+
+// TODO: we could not exports for Node native ES Moudles yet...
+{
+    if (typeof __INTLIFY_PROD_DEVTOOLS__ !== 'boolean') {
+        getGlobalThis().__INTLIFY_PROD_DEVTOOLS__ = false;
+    }
+}
+
+export { CoreErrorCodes, CoreWarnCodes, DATETIME_FORMAT_OPTIONS_KEYS, DEFAULT_LOCALE, DEFAULT_MESSAGE_DATA_TYPE, MISSING_RESOLVE_VALUE, NOT_REOSLVED, NUMBER_FORMAT_OPTIONS_KEYS, VERSION, clearCompileCache, clearDateTimeFormat, clearNumberFormat, compileToFunction, createCoreContext, createCoreError, createMessageContext, datetime, fallbackWithLocaleChain, fallbackWithSimple, getAdditionalMeta, getDevToolsHook, getFallbackContext, getWarnMessage, handleMissing, initI18nDevTools, isMessageFunction, isTranslateFallbackWarn, isTranslateMissingWarn, number, parse, parseDateTimeArgs, parseNumberArgs, parseTranslateArgs, registerLocaleFallbacker, registerMessageCompiler, registerMessageResolver, resolveValue, resolveWithKeyValue, setAdditionalMeta, setDevToolsHook, setFallbackContext, translate, translateDevTools, updateFallbackLocale };
diff --git a/parent_dir/node_modules/intlify/devtools-if/dist/devtools-if.esm-bundler.js b/parent_dir/node_modules/intlify/devtools-if/dist/devtools-if.esm-bundler.js
new file mode 100644
index 0000000..16d1112
--- /dev/null
+++ b/parent_dir/node_modules/intlify/devtools-if/dist/devtools-if.esm-bundler.js
@@ -0,0 +1,11 @@
+/*!
+  * devtools-if v9.2.2
+  * (c) 2022 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+const IntlifyDevToolsHooks =  {
+    I18nInit: 'i18n:init',
+    FunctionTranslate: 'function:translate'
+};
+
+export { IntlifyDevToolsHooks };
diff --git a/parent_dir/node_modules/intlify/message-compiler/dist/message-compiler.esm-bundler.js b/parent_dir/node_modules/intlify/message-compiler/dist/message-compiler.esm-bundler.js
new file mode 100644
index 0000000..5c5f2e9
--- /dev/null
+++ b/parent_dir/node_modules/intlify/message-compiler/dist/message-compiler.esm-bundler.js
@@ -0,0 +1,1372 @@
+/*!
+  * message-compiler v9.2.2
+  * (c) 2022 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+import { format, assign, isString } from '@intlify/shared';
+
+const CompileErrorCodes = {
+    // tokenizer error codes
+    EXPECTED_TOKEN: 1,
+    INVALID_TOKEN_IN_PLACEHOLDER: 2,
+    UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3,
+    UNKNOWN_ESCAPE_SEQUENCE: 4,
+    INVALID_UNICODE_ESCAPE_SEQUENCE: 5,
+    UNBALANCED_CLOSING_BRACE: 6,
+    UNTERMINATED_CLOSING_BRACE: 7,
+    EMPTY_PLACEHOLDER: 8,
+    NOT_ALLOW_NEST_PLACEHOLDER: 9,
+    INVALID_LINKED_FORMAT: 10,
+    // parser error codes
+    MUST_HAVE_MESSAGES_IN_PLURAL: 11,
+    UNEXPECTED_EMPTY_LINKED_MODIFIER: 12,
+    UNEXPECTED_EMPTY_LINKED_KEY: 13,
+    UNEXPECTED_LEXICAL_ANALYSIS: 14,
+    // Special value for higher-order compilers to pick up the last code
+    // to avoid collision of error codes. This should always be kept as the last
+    // item.
+    __EXTEND_POINT__: 15
+};
+/** @internal */
+const errorMessages = {
+    // tokenizer error messages
+    [CompileErrorCodes.EXPECTED_TOKEN]: `Expected token: '{0}'`,
+    [CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER]: `Invalid token in placeholder: '{0}'`,
+    [CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER]: `Unterminated single quote in placeholder`,
+    [CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE]: `Unknown escape sequence: \\{0}`,
+    [CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE]: `Invalid unicode escape sequence: {0}`,
+    [CompileErrorCodes.UNBALANCED_CLOSING_BRACE]: `Unbalanced closing brace`,
+    [CompileErrorCodes.UNTERMINATED_CLOSING_BRACE]: `Unterminated closing brace`,
+    [CompileErrorCodes.EMPTY_PLACEHOLDER]: `Empty placeholder`,
+    [CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER]: `Not allowed nest placeholder`,
+    [CompileErrorCodes.INVALID_LINKED_FORMAT]: `Invalid linked format`,
+    // parser error messages
+    [CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL]: `Plural must have messages`,
+    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER]: `Unexpected empty linked modifier`,
+    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY]: `Unexpected empty linked key`,
+    [CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS]: `Unexpected lexical analysis in token: '{0}'`
+};
+function createCompileError(code, loc, options = {}) {
+    const { domain, messages, args } = options;
+    const msg = (process.env.NODE_ENV !== 'production')
+        ? format((messages || errorMessages)[code] || '', ...(args || []))
+        : code;
+    const error = new SyntaxError(String(msg));
+    error.code = code;
+    if (loc) {
+        error.location = loc;
+    }
+    error.domain = domain;
+    return error;
+}
+/** @internal */
+function defaultOnError(error) {
+    throw error;
+}
+
+const LocationStub = {
+    start: { line: 1, column: 1, offset: 0 },
+    end: { line: 1, column: 1, offset: 0 }
+};
+function createPosition(line, column, offset) {
+    return { line, column, offset };
+}
+function createLocation(start, end, source) {
+    const loc = { start, end };
+    if (source != null) {
+        loc.source = source;
+    }
+    return loc;
+}
+
+const CHAR_SP = ' ';
+const CHAR_CR = '\r';
+const CHAR_LF = '\n';
+const CHAR_LS = String.fromCharCode(0x2028);
+const CHAR_PS = String.fromCharCode(0x2029);
+function createScanner(str) {
+    const _buf = str;
+    let _index = 0;
+    let _line = 1;
+    let _column = 1;
+    let _peekOffset = 0;
+    const isCRLF = (index) => _buf[index] === CHAR_CR && _buf[index + 1] === CHAR_LF;
+    const isLF = (index) => _buf[index] === CHAR_LF;
+    const isPS = (index) => _buf[index] === CHAR_PS;
+    const isLS = (index) => _buf[index] === CHAR_LS;
+    const isLineEnd = (index) => isCRLF(index) || isLF(index) || isPS(index) || isLS(index);
+    const index = () => _index;
+    const line = () => _line;
+    const column = () => _column;
+    const peekOffset = () => _peekOffset;
+    const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? CHAR_LF : _buf[offset];
+    const currentChar = () => charAt(_index);
+    const currentPeek = () => charAt(_index + _peekOffset);
+    function next() {
+        _peekOffset = 0;
+        if (isLineEnd(_index)) {
+            _line++;
+            _column = 0;
+        }
+        if (isCRLF(_index)) {
+            _index++;
+        }
+        _index++;
+        _column++;
+        return _buf[_index];
+    }
+    function peek() {
+        if (isCRLF(_index + _peekOffset)) {
+            _peekOffset++;
+        }
+        _peekOffset++;
+        return _buf[_index + _peekOffset];
+    }
+    function reset() {
+        _index = 0;
+        _line = 1;
+        _column = 1;
+        _peekOffset = 0;
+    }
+    function resetPeek(offset = 0) {
+        _peekOffset = offset;
+    }
+    function skipToPeek() {
+        const target = _index + _peekOffset;
+        // eslint-disable-next-line no-unmodified-loop-condition
+        while (target !== _index) {
+            next();
+        }
+        _peekOffset = 0;
+    }
+    return {
+        index,
+        line,
+        column,
+        peekOffset,
+        charAt,
+        currentChar,
+        currentPeek,
+        next,
+        peek,
+        reset,
+        resetPeek,
+        skipToPeek
+    };
+}
+
+const EOF = undefined;
+const LITERAL_DELIMITER = "'";
+const ERROR_DOMAIN$1 = 'tokenizer';
+function createTokenizer(source, options = {}) {
+    const location = options.location !== false;
+    const _scnr = createScanner(source);
+    const currentOffset = () => _scnr.index();
+    const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());
+    const _initLoc = currentPosition();
+    const _initOffset = currentOffset();
+    const _context = {
+        currentType: 14 /* EOF */,
+        offset: _initOffset,
+        startLoc: _initLoc,
+        endLoc: _initLoc,
+        lastType: 14 /* EOF */,
+        lastOffset: _initOffset,
+        lastStartLoc: _initLoc,
+        lastEndLoc: _initLoc,
+        braceNest: 0,
+        inLinked: false,
+        text: ''
+    };
+    const context = () => _context;
+    const { onError } = options;
+    function emitError(code, pos, offset, ...args) {
+        const ctx = context();
+        pos.column += offset;
+        pos.offset += offset;
+        if (onError) {
+            const loc = createLocation(ctx.startLoc, pos);
+            const err = createCompileError(code, loc, {
+                domain: ERROR_DOMAIN$1,
+                args
+            });
+            onError(err);
+        }
+    }
+    function getToken(context, type, value) {
+        context.endLoc = currentPosition();
+        context.currentType = type;
+        const token = { type };
+        if (location) {
+            token.loc = createLocation(context.startLoc, context.endLoc);
+        }
+        if (value != null) {
+            token.value = value;
+        }
+        return token;
+    }
+    const getEndToken = (context) => getToken(context, 14 /* EOF */);
+    function eat(scnr, ch) {
+        if (scnr.currentChar() === ch) {
+            scnr.next();
+            return ch;
+        }
+        else {
+            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+            return '';
+        }
+    }
+    function peekSpaces(scnr) {
+        let buf = '';
+        while (scnr.currentPeek() === CHAR_SP || scnr.currentPeek() === CHAR_LF) {
+            buf += scnr.currentPeek();
+            scnr.peek();
+        }
+        return buf;
+    }
+    function skipSpaces(scnr) {
+        const buf = peekSpaces(scnr);
+        scnr.skipToPeek();
+        return buf;
+    }
+    function isIdentifierStart(ch) {
+        if (ch === EOF) {
+            return false;
+        }
+        const cc = ch.charCodeAt(0);
+        return ((cc >= 97 && cc <= 122) || // a-z
+            (cc >= 65 && cc <= 90) || // A-Z
+            cc === 95 // _
+        );
+    }
+    function isNumberStart(ch) {
+        if (ch === EOF) {
+            return false;
+        }
+        const cc = ch.charCodeAt(0);
+        return cc >= 48 && cc <= 57; // 0-9
+    }
+    function isNamedIdentifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = isIdentifierStart(scnr.currentPeek());
+        scnr.resetPeek();
+        return ret;
+    }
+    function isListIdentifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ch = scnr.currentPeek() === '-' ? scnr.peek() : scnr.currentPeek();
+        const ret = isNumberStart(ch);
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLiteralStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === LITERAL_DELIMITER;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedDotStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 8 /* LinkedAlias */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "." /* LinkedDot */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedModifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 9 /* LinkedDot */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = isIdentifierStart(scnr.currentPeek());
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedDelimiterStart(scnr, context) {
+        const { currentType } = context;
+        if (!(currentType === 8 /* LinkedAlias */ ||
+            currentType === 12 /* LinkedModifier */)) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === ":" /* LinkedDelimiter */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedReferStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 10 /* LinkedDelimiter */) {
+            return false;
+        }
+        const fn = () => {
+            const ch = scnr.currentPeek();
+            if (ch === "{" /* BraceLeft */) {
+                return isIdentifierStart(scnr.peek());
+            }
+            else if (ch === "@" /* LinkedAlias */ ||
+                ch === "%" /* Modulo */ ||
+                ch === "|" /* Pipe */ ||
+                ch === ":" /* LinkedDelimiter */ ||
+                ch === "." /* LinkedDot */ ||
+                ch === CHAR_SP ||
+                !ch) {
+                return false;
+            }
+            else if (ch === CHAR_LF) {
+                scnr.peek();
+                return fn();
+            }
+            else {
+                // other characters
+                return isIdentifierStart(ch);
+            }
+        };
+        const ret = fn();
+        scnr.resetPeek();
+        return ret;
+    }
+    function isPluralStart(scnr) {
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "|" /* Pipe */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function detectModuloStart(scnr) {
+        const spaces = peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "%" /* Modulo */ &&
+            scnr.peek() === "{" /* BraceLeft */;
+        scnr.resetPeek();
+        return {
+            isModulo: ret,
+            hasSpace: spaces.length > 0
+        };
+    }
+    function isTextStart(scnr, reset = true) {
+        const fn = (hasSpace = false, prev = '', detectModulo = false) => {
+            const ch = scnr.currentPeek();
+            if (ch === "{" /* BraceLeft */) {
+                return prev === "%" /* Modulo */ ? false : hasSpace;
+            }
+            else if (ch === "@" /* LinkedAlias */ || !ch) {
+                return prev === "%" /* Modulo */ ? true : hasSpace;
+            }
+            else if (ch === "%" /* Modulo */) {
+                scnr.peek();
+                return fn(hasSpace, "%" /* Modulo */, true);
+            }
+            else if (ch === "|" /* Pipe */) {
+                return prev === "%" /* Modulo */ || detectModulo
+                    ? true
+                    : !(prev === CHAR_SP || prev === CHAR_LF);
+            }
+            else if (ch === CHAR_SP) {
+                scnr.peek();
+                return fn(true, CHAR_SP, detectModulo);
+            }
+            else if (ch === CHAR_LF) {
+                scnr.peek();
+                return fn(true, CHAR_LF, detectModulo);
+            }
+            else {
+                return true;
+            }
+        };
+        const ret = fn();
+        reset && scnr.resetPeek();
+        return ret;
+    }
+    function takeChar(scnr, fn) {
+        const ch = scnr.currentChar();
+        if (ch === EOF) {
+            return EOF;
+        }
+        if (fn(ch)) {
+            scnr.next();
+            return ch;
+        }
+        return null;
+    }
+    function takeIdentifierChar(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return ((cc >= 97 && cc <= 122) || // a-z
+                (cc >= 65 && cc <= 90) || // A-Z
+                (cc >= 48 && cc <= 57) || // 0-9
+                cc === 95 || // _
+                cc === 36 // $
+            );
+        };
+        return takeChar(scnr, closure);
+    }
+    function takeDigit(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return cc >= 48 && cc <= 57; // 0-9
+        };
+        return takeChar(scnr, closure);
+    }
+    function takeHexDigit(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return ((cc >= 48 && cc <= 57) || // 0-9
+                (cc >= 65 && cc <= 70) || // A-F
+                (cc >= 97 && cc <= 102)); // a-f
+        };
+        return takeChar(scnr, closure);
+    }
+    function getDigits(scnr) {
+        let ch = '';
+        let num = '';
+        while ((ch = takeDigit(scnr))) {
+            num += ch;
+        }
+        return num;
+    }
+    function readModulo(scnr) {
+        skipSpaces(scnr);
+        const ch = scnr.currentChar();
+        if (ch !== "%" /* Modulo */) {
+            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+        }
+        scnr.next();
+        return "%" /* Modulo */;
+    }
+    function readText(scnr) {
+        let buf = '';
+        while (true) {
+            const ch = scnr.currentChar();
+            if (ch === "{" /* BraceLeft */ ||
+                ch === "}" /* BraceRight */ ||
+                ch === "@" /* LinkedAlias */ ||
+                ch === "|" /* Pipe */ ||
+                !ch) {
+                break;
+            }
+            else if (ch === "%" /* Modulo */) {
+                if (isTextStart(scnr)) {
+                    buf += ch;
+                    scnr.next();
+                }
+                else {
+                    break;
+                }
+            }
+            else if (ch === CHAR_SP || ch === CHAR_LF) {
+                if (isTextStart(scnr)) {
+                    buf += ch;
+                    scnr.next();
+                }
+                else if (isPluralStart(scnr)) {
+                    break;
+                }
+                else {
+                    buf += ch;
+                    scnr.next();
+                }
+            }
+            else {
+                buf += ch;
+                scnr.next();
+            }
+        }
+        return buf;
+    }
+    function readNamedIdentifier(scnr) {
+        skipSpaces(scnr);
+        let ch = '';
+        let name = '';
+        while ((ch = takeIdentifierChar(scnr))) {
+            name += ch;
+        }
+        if (scnr.currentChar() === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+        }
+        return name;
+    }
+    function readListIdentifier(scnr) {
+        skipSpaces(scnr);
+        let value = '';
+        if (scnr.currentChar() === '-') {
+            scnr.next();
+            value += `-${getDigits(scnr)}`;
+        }
+        else {
+            value += getDigits(scnr);
+        }
+        if (scnr.currentChar() === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+        }
+        return value;
+    }
+    function readLiteral(scnr) {
+        skipSpaces(scnr);
+        eat(scnr, `\'`);
+        let ch = '';
+        let literal = '';
+        const fn = (x) => x !== LITERAL_DELIMITER && x !== CHAR_LF;
+        while ((ch = takeChar(scnr, fn))) {
+            if (ch === '\\') {
+                literal += readEscapeSequence(scnr);
+            }
+            else {
+                literal += ch;
+            }
+        }
+        const current = scnr.currentChar();
+        if (current === CHAR_LF || current === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER, currentPosition(), 0);
+            // TODO: Is it correct really?
+            if (current === CHAR_LF) {
+                scnr.next();
+                eat(scnr, `\'`);
+            }
+            return literal;
+        }
+        eat(scnr, `\'`);
+        return literal;
+    }
+    function readEscapeSequence(scnr) {
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case '\\':
+            case `\'`:
+                scnr.next();
+                return `\\${ch}`;
+            case 'u':
+                return readUnicodeEscapeSequence(scnr, ch, 4);
+            case 'U':
+                return readUnicodeEscapeSequence(scnr, ch, 6);
+            default:
+                emitError(CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE, currentPosition(), 0, ch);
+                return '';
+        }
+    }
+    function readUnicodeEscapeSequence(scnr, unicode, digits) {
+        eat(scnr, unicode);
+        let sequence = '';
+        for (let i = 0; i < digits; i++) {
+            const ch = takeHexDigit(scnr);
+            if (!ch) {
+                emitError(CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE, currentPosition(), 0, `\\${unicode}${sequence}${scnr.currentChar()}`);
+                break;
+            }
+            sequence += ch;
+        }
+        return `\\${unicode}${sequence}`;
+    }
+    function readInvalidIdentifier(scnr) {
+        skipSpaces(scnr);
+        let ch = '';
+        let identifiers = '';
+        const closure = (ch) => ch !== "{" /* BraceLeft */ &&
+            ch !== "}" /* BraceRight */ &&
+            ch !== CHAR_SP &&
+            ch !== CHAR_LF;
+        while ((ch = takeChar(scnr, closure))) {
+            identifiers += ch;
+        }
+        return identifiers;
+    }
+    function readLinkedModifier(scnr) {
+        let ch = '';
+        let name = '';
+        while ((ch = takeIdentifierChar(scnr))) {
+            name += ch;
+        }
+        return name;
+    }
+    function readLinkedRefer(scnr) {
+        const fn = (detect = false, buf) => {
+            const ch = scnr.currentChar();
+            if (ch === "{" /* BraceLeft */ ||
+                ch === "%" /* Modulo */ ||
+                ch === "@" /* LinkedAlias */ ||
+                ch === "|" /* Pipe */ ||
+                !ch) {
+                return buf;
+            }
+            else if (ch === CHAR_SP) {
+                return buf;
+            }
+            else if (ch === CHAR_LF) {
+                buf += ch;
+                scnr.next();
+                return fn(detect, buf);
+            }
+            else {
+                buf += ch;
+                scnr.next();
+                return fn(true, buf);
+            }
+        };
+        return fn(false, '');
+    }
+    function readPlural(scnr) {
+        skipSpaces(scnr);
+        const plural = eat(scnr, "|" /* Pipe */);
+        skipSpaces(scnr);
+        return plural;
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readTokenInPlaceholder(scnr, context) {
+        let token = null;
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case "{" /* BraceLeft */:
+                if (context.braceNest >= 1) {
+                    emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);
+                }
+                scnr.next();
+                token = getToken(context, 2 /* BraceLeft */, "{" /* BraceLeft */);
+                skipSpaces(scnr);
+                context.braceNest++;
+                return token;
+            case "}" /* BraceRight */:
+                if (context.braceNest > 0 &&
+                    context.currentType === 2 /* BraceLeft */) {
+                    emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);
+                }
+                scnr.next();
+                token = getToken(context, 3 /* BraceRight */, "}" /* BraceRight */);
+                context.braceNest--;
+                context.braceNest > 0 && skipSpaces(scnr);
+                if (context.inLinked && context.braceNest === 0) {
+                    context.inLinked = false;
+                }
+                return token;
+            case "@" /* LinkedAlias */:
+                if (context.braceNest > 0) {
+                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                }
+                token = readTokenInLinked(scnr, context) || getEndToken(context);
+                context.braceNest = 0;
+                return token;
+            default:
+                let validNamedIdentifier = true;
+                let validListIdentifier = true;
+                let validLiteral = true;
+                if (isPluralStart(scnr)) {
+                    if (context.braceNest > 0) {
+                        emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                    }
+                    token = getToken(context, 1 /* Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                if (context.braceNest > 0 &&
+                    (context.currentType === 5 /* Named */ ||
+                        context.currentType === 6 /* List */ ||
+                        context.currentType === 7 /* Literal */)) {
+                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                    context.braceNest = 0;
+                    return readToken(scnr, context);
+                }
+                if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {
+                    token = getToken(context, 5 /* Named */, readNamedIdentifier(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
+                    token = getToken(context, 6 /* List */, readListIdentifier(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if ((validLiteral = isLiteralStart(scnr, context))) {
+                    token = getToken(context, 7 /* Literal */, readLiteral(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
+                    // TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...
+                    token = getToken(context, 13 /* InvalidPlace */, readInvalidIdentifier(scnr));
+                    emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
+                    skipSpaces(scnr);
+                    return token;
+                }
+                break;
+        }
+        return token;
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readTokenInLinked(scnr, context) {
+        const { currentType } = context;
+        let token = null;
+        const ch = scnr.currentChar();
+        if ((currentType === 8 /* LinkedAlias */ ||
+            currentType === 9 /* LinkedDot */ ||
+            currentType === 12 /* LinkedModifier */ ||
+            currentType === 10 /* LinkedDelimiter */) &&
+            (ch === CHAR_LF || ch === CHAR_SP)) {
+            emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+        }
+        switch (ch) {
+            case "@" /* LinkedAlias */:
+                scnr.next();
+                token = getToken(context, 8 /* LinkedAlias */, "@" /* LinkedAlias */);
+                context.inLinked = true;
+                return token;
+            case "." /* LinkedDot */:
+                skipSpaces(scnr);
+                scnr.next();
+                return getToken(context, 9 /* LinkedDot */, "." /* LinkedDot */);
+            case ":" /* LinkedDelimiter */:
+                skipSpaces(scnr);
+                scnr.next();
+                return getToken(context, 10 /* LinkedDelimiter */, ":" /* LinkedDelimiter */);
+            default:
+                if (isPluralStart(scnr)) {
+                    token = getToken(context, 1 /* Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                if (isLinkedDotStart(scnr, context) ||
+                    isLinkedDelimiterStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    return readTokenInLinked(scnr, context);
+                }
+                if (isLinkedModifierStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    return getToken(context, 12 /* LinkedModifier */, readLinkedModifier(scnr));
+                }
+                if (isLinkedReferStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    if (ch === "{" /* BraceLeft */) {
+                        // scan the placeholder
+                        return readTokenInPlaceholder(scnr, context) || token;
+                    }
+                    else {
+                        return getToken(context, 11 /* LinkedKey */, readLinkedRefer(scnr));
+                    }
+                }
+                if (currentType === 8 /* LinkedAlias */) {
+                    emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+                }
+                context.braceNest = 0;
+                context.inLinked = false;
+                return readToken(scnr, context);
+        }
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readToken(scnr, context) {
+        let token = { type: 14 /* EOF */ };
+        if (context.braceNest > 0) {
+            return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+        }
+        if (context.inLinked) {
+            return readTokenInLinked(scnr, context) || getEndToken(context);
+        }
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case "{" /* BraceLeft */:
+                return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+            case "}" /* BraceRight */:
+                emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
+                scnr.next();
+                return getToken(context, 3 /* BraceRight */, "}" /* BraceRight */);
+            case "@" /* LinkedAlias */:
+                return readTokenInLinked(scnr, context) || getEndToken(context);
+            default:
+                if (isPluralStart(scnr)) {
+                    token = getToken(context, 1 /* Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                const { isModulo, hasSpace } = detectModuloStart(scnr);
+                if (isModulo) {
+                    return hasSpace
+                        ? getToken(context, 0 /* Text */, readText(scnr))
+                        : getToken(context, 4 /* Modulo */, readModulo(scnr));
+                }
+                if (isTextStart(scnr)) {
+                    return getToken(context, 0 /* Text */, readText(scnr));
+                }
+                break;
+        }
+        return token;
+    }
+    function nextToken() {
+        const { currentType, offset, startLoc, endLoc } = _context;
+        _context.lastType = currentType;
+        _context.lastOffset = offset;
+        _context.lastStartLoc = startLoc;
+        _context.lastEndLoc = endLoc;
+        _context.offset = currentOffset();
+        _context.startLoc = currentPosition();
+        if (_scnr.currentChar() === EOF) {
+            return getToken(_context, 14 /* EOF */);
+        }
+        return readToken(_scnr, _context);
+    }
+    return {
+        nextToken,
+        currentOffset,
+        currentPosition,
+        context
+    };
+}
+
+const ERROR_DOMAIN = 'parser';
+// Backslash backslash, backslash quote, uHHHH, UHHHHHH.
+const KNOWN_ESCAPES = /(?:\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
+function fromEscapeSequence(match, codePoint4, codePoint6) {
+    switch (match) {
+        case `\\\\`:
+            return `\\`;
+        case `\\\'`:
+            return `\'`;
+        default: {
+            const codePoint = parseInt(codePoint4 || codePoint6, 16);
+            if (codePoint <= 0xd7ff || codePoint >= 0xe000) {
+                return String.fromCodePoint(codePoint);
+            }
+            // invalid ...
+            // Replace them with U+FFFD REPLACEMENT CHARACTER.
+            return '�';
+        }
+    }
+}
+function createParser(options = {}) {
+    const location = options.location !== false;
+    const { onError } = options;
+    function emitError(tokenzer, code, start, offset, ...args) {
+        const end = tokenzer.currentPosition();
+        end.offset += offset;
+        end.column += offset;
+        if (onError) {
+            const loc = createLocation(start, end);
+            const err = createCompileError(code, loc, {
+                domain: ERROR_DOMAIN,
+                args
+            });
+            onError(err);
+        }
+    }
+    function startNode(type, offset, loc) {
+        const node = {
+            type,
+            start: offset,
+            end: offset
+        };
+        if (location) {
+            node.loc = { start: loc, end: loc };
+        }
+        return node;
+    }
+    function endNode(node, offset, pos, type) {
+        node.end = offset;
+        if (type) {
+            node.type = type;
+        }
+        if (location && node.loc) {
+            node.loc.end = pos;
+        }
+    }
+    function parseText(tokenizer, value) {
+        const context = tokenizer.context();
+        const node = startNode(3 /* Text */, context.offset, context.startLoc);
+        node.value = value;
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseList(tokenizer, index) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(5 /* List */, offset, loc);
+        node.index = parseInt(index, 10);
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseNamed(tokenizer, key) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(4 /* Named */, offset, loc);
+        node.key = key;
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLiteral(tokenizer, value) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(9 /* Literal */, offset, loc);
+        node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLinkedModifier(tokenizer) {
+        const token = tokenizer.nextToken();
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc
+        const node = startNode(8 /* LinkedModifier */, offset, loc);
+        if (token.type !== 12 /* LinkedModifier */) {
+            // empty modifier
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
+            node.value = '';
+            endNode(node, offset, loc);
+            return {
+                nextConsumeToken: token,
+                node
+            };
+        }
+        // check token
+        if (token.value == null) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+        }
+        node.value = token.value || '';
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return {
+            node
+        };
+    }
+    function parseLinkedKey(tokenizer, value) {
+        const context = tokenizer.context();
+        const node = startNode(7 /* LinkedKey */, context.offset, context.startLoc);
+        node.value = value;
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLinked(tokenizer) {
+        const context = tokenizer.context();
+        const linkedNode = startNode(6 /* Linked */, context.offset, context.startLoc);
+        let token = tokenizer.nextToken();
+        if (token.type === 9 /* LinkedDot */) {
+            const parsed = parseLinkedModifier(tokenizer);
+            linkedNode.modifier = parsed.node;
+            token = parsed.nextConsumeToken || tokenizer.nextToken();
+        }
+        // asset check token
+        if (token.type !== 10 /* LinkedDelimiter */) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+        }
+        token = tokenizer.nextToken();
+        // skip brace left
+        if (token.type === 2 /* BraceLeft */) {
+            token = tokenizer.nextToken();
+        }
+        switch (token.type) {
+            case 11 /* LinkedKey */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseLinkedKey(tokenizer, token.value || '');
+                break;
+            case 5 /* Named */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseNamed(tokenizer, token.value || '');
+                break;
+            case 6 /* List */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseList(tokenizer, token.value || '');
+                break;
+            case 7 /* Literal */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseLiteral(tokenizer, token.value || '');
+                break;
+            default:
+                // empty key
+                emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);
+                const nextContext = tokenizer.context();
+                const emptyLinkedKeyNode = startNode(7 /* LinkedKey */, nextContext.offset, nextContext.startLoc);
+                emptyLinkedKeyNode.value = '';
+                endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
+                linkedNode.key = emptyLinkedKeyNode;
+                endNode(linkedNode, nextContext.offset, nextContext.startLoc);
+                return {
+                    nextConsumeToken: token,
+                    node: linkedNode
+                };
+        }
+        endNode(linkedNode, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return {
+            node: linkedNode
+        };
+    }
+    function parseMessage(tokenizer) {
+        const context = tokenizer.context();
+        const startOffset = context.currentType === 1 /* Pipe */
+            ? tokenizer.currentOffset()
+            : context.offset;
+        const startLoc = context.currentType === 1 /* Pipe */
+            ? context.endLoc
+            : context.startLoc;
+        const node = startNode(2 /* Message */, startOffset, startLoc);
+        node.items = [];
+        let nextToken = null;
+        do {
+            const token = nextToken || tokenizer.nextToken();
+            nextToken = null;
+            switch (token.type) {
+                case 0 /* Text */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseText(tokenizer, token.value || ''));
+                    break;
+                case 6 /* List */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseList(tokenizer, token.value || ''));
+                    break;
+                case 5 /* Named */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseNamed(tokenizer, token.value || ''));
+                    break;
+                case 7 /* Literal */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseLiteral(tokenizer, token.value || ''));
+                    break;
+                case 8 /* LinkedAlias */:
+                    const parsed = parseLinked(tokenizer);
+                    node.items.push(parsed.node);
+                    nextToken = parsed.nextConsumeToken || null;
+                    break;
+            }
+        } while (context.currentType !== 14 /* EOF */ &&
+            context.currentType !== 1 /* Pipe */);
+        // adjust message node loc
+        const endOffset = context.currentType === 1 /* Pipe */
+            ? context.lastOffset
+            : tokenizer.currentOffset();
+        const endLoc = context.currentType === 1 /* Pipe */
+            ? context.lastEndLoc
+            : tokenizer.currentPosition();
+        endNode(node, endOffset, endLoc);
+        return node;
+    }
+    function parsePlural(tokenizer, offset, loc, msgNode) {
+        const context = tokenizer.context();
+        let hasEmptyMessage = msgNode.items.length === 0;
+        const node = startNode(1 /* Plural */, offset, loc);
+        node.cases = [];
+        node.cases.push(msgNode);
+        do {
+            const msg = parseMessage(tokenizer);
+            if (!hasEmptyMessage) {
+                hasEmptyMessage = msg.items.length === 0;
+            }
+            node.cases.push(msg);
+        } while (context.currentType !== 14 /* EOF */);
+        if (hasEmptyMessage) {
+            emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
+        }
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseResource(tokenizer) {
+        const context = tokenizer.context();
+        const { offset, startLoc } = context;
+        const msgNode = parseMessage(tokenizer);
+        if (context.currentType === 14 /* EOF */) {
+            return msgNode;
+        }
+        else {
+            return parsePlural(tokenizer, offset, startLoc, msgNode);
+        }
+    }
+    function parse(source) {
+        const tokenizer = createTokenizer(source, assign({}, options));
+        const context = tokenizer.context();
+        const node = startNode(0 /* Resource */, context.offset, context.startLoc);
+        if (location && node.loc) {
+            node.loc.source = source;
+        }
+        node.body = parseResource(tokenizer);
+        // assert whether achieved to EOF
+        if (context.currentType !== 14 /* EOF */) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
+        }
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    return { parse };
+}
+function getTokenCaption(token) {
+    if (token.type === 14 /* EOF */) {
+        return 'EOF';
+    }
+    const name = (token.value || '').replace(/\r?\n/gu, '\\n');
+    return name.length > 10 ? name.slice(0, 9) + '…' : name;
+}
+
+function createTransformer(ast, options = {} // eslint-disable-line
+) {
+    const _context = {
+        ast,
+        helpers: new Set()
+    };
+    const context = () => _context;
+    const helper = (name) => {
+        _context.helpers.add(name);
+        return name;
+    };
+    return { context, helper };
+}
+function traverseNodes(nodes, transformer) {
+    for (let i = 0; i < nodes.length; i++) {
+        traverseNode(nodes[i], transformer);
+    }
+}
+function traverseNode(node, transformer) {
+    // TODO: if we need pre-hook of transform, should be implemented to here
+    switch (node.type) {
+        case 1 /* Plural */:
+            traverseNodes(node.cases, transformer);
+            transformer.helper("plural" /* PLURAL */);
+            break;
+        case 2 /* Message */:
+            traverseNodes(node.items, transformer);
+            break;
+        case 6 /* Linked */:
+            const linked = node;
+            traverseNode(linked.key, transformer);
+            transformer.helper("linked" /* LINKED */);
+            transformer.helper("type" /* TYPE */);
+            break;
+        case 5 /* List */:
+            transformer.helper("interpolate" /* INTERPOLATE */);
+            transformer.helper("list" /* LIST */);
+            break;
+        case 4 /* Named */:
+            transformer.helper("interpolate" /* INTERPOLATE */);
+            transformer.helper("named" /* NAMED */);
+            break;
+    }
+    // TODO: if we need post-hook of transform, should be implemented to here
+}
+// transform AST
+function transform(ast, options = {} // eslint-disable-line
+) {
+    const transformer = createTransformer(ast);
+    transformer.helper("normalize" /* NORMALIZE */);
+    // traverse
+    ast.body && traverseNode(ast.body, transformer);
+    // set meta information
+    const context = transformer.context();
+    ast.helpers = Array.from(context.helpers);
+}
+
+function createCodeGenerator(ast, options) {
+    const { sourceMap, filename, breakLineCode, needIndent: _needIndent } = options;
+    const _context = {
+        source: ast.loc.source,
+        filename,
+        code: '',
+        column: 1,
+        line: 1,
+        offset: 0,
+        map: undefined,
+        breakLineCode,
+        needIndent: _needIndent,
+        indentLevel: 0
+    };
+    const context = () => _context;
+    function push(code, node) {
+        _context.code += code;
+    }
+    function _newline(n, withBreakLine = true) {
+        const _breakLineCode = withBreakLine ? breakLineCode : '';
+        push(_needIndent ? _breakLineCode + `  `.repeat(n) : _breakLineCode);
+    }
+    function indent(withNewLine = true) {
+        const level = ++_context.indentLevel;
+        withNewLine && _newline(level);
+    }
+    function deindent(withNewLine = true) {
+        const level = --_context.indentLevel;
+        withNewLine && _newline(level);
+    }
+    function newline() {
+        _newline(_context.indentLevel);
+    }
+    const helper = (key) => `_${key}`;
+    const needIndent = () => _context.needIndent;
+    return {
+        context,
+        push,
+        indent,
+        deindent,
+        newline,
+        helper,
+        needIndent
+    };
+}
+function generateLinkedNode(generator, node) {
+    const { helper } = generator;
+    generator.push(`${helper("linked" /* LINKED */)}(`);
+    generateNode(generator, node.key);
+    if (node.modifier) {
+        generator.push(`, `);
+        generateNode(generator, node.modifier);
+        generator.push(`, _type`);
+    }
+    else {
+        generator.push(`, undefined, _type`);
+    }
+    generator.push(`)`);
+}
+function generateMessageNode(generator, node) {
+    const { helper, needIndent } = generator;
+    generator.push(`${helper("normalize" /* NORMALIZE */)}([`);
+    generator.indent(needIndent());
+    const length = node.items.length;
+    for (let i = 0; i < length; i++) {
+        generateNode(generator, node.items[i]);
+        if (i === length - 1) {
+            break;
+        }
+        generator.push(', ');
+    }
+    generator.deindent(needIndent());
+    generator.push('])');
+}
+function generatePluralNode(generator, node) {
+    const { helper, needIndent } = generator;
+    if (node.cases.length > 1) {
+        generator.push(`${helper("plural" /* PLURAL */)}([`);
+        generator.indent(needIndent());
+        const length = node.cases.length;
+        for (let i = 0; i < length; i++) {
+            generateNode(generator, node.cases[i]);
+            if (i === length - 1) {
+                break;
+            }
+            generator.push(', ');
+        }
+        generator.deindent(needIndent());
+        generator.push(`])`);
+    }
+}
+function generateResource(generator, node) {
+    if (node.body) {
+        generateNode(generator, node.body);
+    }
+    else {
+        generator.push('null');
+    }
+}
+function generateNode(generator, node) {
+    const { helper } = generator;
+    switch (node.type) {
+        case 0 /* Resource */:
+            generateResource(generator, node);
+            break;
+        case 1 /* Plural */:
+            generatePluralNode(generator, node);
+            break;
+        case 2 /* Message */:
+            generateMessageNode(generator, node);
+            break;
+        case 6 /* Linked */:
+            generateLinkedNode(generator, node);
+            break;
+        case 8 /* LinkedModifier */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 7 /* LinkedKey */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 5 /* List */:
+            generator.push(`${helper("interpolate" /* INTERPOLATE */)}(${helper("list" /* LIST */)}(${node.index}))`, node);
+            break;
+        case 4 /* Named */:
+            generator.push(`${helper("interpolate" /* INTERPOLATE */)}(${helper("named" /* NAMED */)}(${JSON.stringify(node.key)}))`, node);
+            break;
+        case 9 /* Literal */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 3 /* Text */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        default:
+            if ((process.env.NODE_ENV !== 'production')) {
+                throw new Error(`unhandled codegen node type: ${node.type}`);
+            }
+    }
+}
+// generate code from AST
+const generate = (ast, options = {} // eslint-disable-line
+) => {
+    const mode = isString(options.mode) ? options.mode : 'normal';
+    const filename = isString(options.filename)
+        ? options.filename
+        : 'message.intl';
+    const sourceMap = !!options.sourceMap;
+    // prettier-ignore
+    const breakLineCode = options.breakLineCode != null
+        ? options.breakLineCode
+        : mode === 'arrow'
+            ? ';'
+            : '\n';
+    const needIndent = options.needIndent ? options.needIndent : mode !== 'arrow';
+    const helpers = ast.helpers || [];
+    const generator = createCodeGenerator(ast, {
+        mode,
+        filename,
+        sourceMap,
+        breakLineCode,
+        needIndent
+    });
+    generator.push(mode === 'normal' ? `function __msg__ (ctx) {` : `(ctx) => {`);
+    generator.indent(needIndent);
+    if (helpers.length > 0) {
+        generator.push(`const { ${helpers.map(s => `${s}: _${s}`).join(', ')} } = ctx`);
+        generator.newline();
+    }
+    generator.push(`return `);
+    generateNode(generator, ast);
+    generator.deindent(needIndent);
+    generator.push(`}`);
+    const { code, map } = generator.context();
+    return {
+        ast,
+        code,
+        map: map ? map.toJSON() : undefined // eslint-disable-line @typescript-eslint/no-explicit-any
+    };
+};
+
+function baseCompile(source, options = {}) {
+    const assignedOptions = assign({}, options);
+    // parse source codes
+    const parser = createParser(assignedOptions);
+    const ast = parser.parse(source);
+    // transform ASTs
+    transform(ast, assignedOptions);
+    // generate javascript codes
+    return generate(ast, assignedOptions);
+}
+
+export { CompileErrorCodes, ERROR_DOMAIN, LocationStub, baseCompile, createCompileError, createLocation, createParser, createPosition, defaultOnError, errorMessages };
diff --git a/parent_dir/node_modules/intlify/shared/dist/shared.esm-bundler.js b/parent_dir/node_modules/intlify/shared/dist/shared.esm-bundler.js
new file mode 100644
index 0000000..d90716f
--- /dev/null
+++ b/parent_dir/node_modules/intlify/shared/dist/shared.esm-bundler.js
@@ -0,0 +1,192 @@
+/*!
+  * shared v9.2.2
+  * (c) 2022 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+/**
+ * Original Utilities
+ * written by kazuya kawaguchi
+ */
+const inBrowser = typeof window !== 'undefined';
+let mark;
+let measure;
+if ((process.env.NODE_ENV !== 'production')) {
+    const perf = inBrowser && window.performance;
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = (tag) => perf.mark(tag);
+        measure = (name, startTag, endTag) => {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+        };
+    }
+}
+const RE_ARGS = /\{([0-9a-zA-Z]+)\}/g;
+/* eslint-disable */
+function format(message, ...args) {
+    if (args.length === 1 && isObject(args[0])) {
+        args = args[0];
+    }
+    if (!args || !args.hasOwnProperty) {
+        args = {};
+    }
+    return message.replace(RE_ARGS, (match, identifier) => {
+        return args.hasOwnProperty(identifier) ? args[identifier] : '';
+    });
+}
+const hasSymbol = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
+const makeSymbol = (name) => hasSymbol ? Symbol(name) : name;
+const generateFormatCacheKey = (locale, key, source) => friendlyJSONstringify({ l: locale, k: key, s: source });
+const friendlyJSONstringify = (json) => JSON.stringify(json)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(/\u0027/g, '\\u0027');
+const isNumber = (val) => typeof val === 'number' && isFinite(val);
+const isDate = (val) => toTypeString(val) === '[object Date]';
+const isRegExp = (val) => toTypeString(val) === '[object RegExp]';
+const isEmptyObject = (val) => isPlainObject(val) && Object.keys(val).length === 0;
+function warn(msg, err) {
+    if (typeof console !== 'undefined') {
+        console.warn(`[intlify] ` + msg);
+        /* istanbul ignore if */
+        if (err) {
+            console.warn(err.stack);
+        }
+    }
+}
+const assign = Object.assign;
+let _globalThis;
+const getGlobalThis = () => {
+    // prettier-ignore
+    return (_globalThis ||
+        (_globalThis =
+            typeof globalThis !== 'undefined'
+                ? globalThis
+                : typeof self !== 'undefined'
+                    ? self
+                    : typeof window !== 'undefined'
+                        ? window
+                        : typeof global !== 'undefined'
+                            ? global
+                            : {}));
+};
+function escapeHtml(rawText) {
+    return rawText
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/* eslint-enable */
+/**
+ * Useful Utilities By Evan you
+ * Modified by kazuya kawaguchi
+ * MIT License
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
+ */
+const isArray = Array.isArray;
+const isFunction = (val) => typeof val === 'function';
+const isString = (val) => typeof val === 'string';
+const isBoolean = (val) => typeof val === 'boolean';
+const isSymbol = (val) => typeof val === 'symbol';
+const isObject = (val) => // eslint-disable-line
+ val !== null && typeof val === 'object';
+const isPromise = (val) => {
+    return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const isPlainObject = (val) => toTypeString(val) === '[object Object]';
+// for converting list and named values to displayed strings.
+const toDisplayString = (val) => {
+    return val == null
+        ? ''
+        : isArray(val) || (isPlainObject(val) && val.toString === objectToString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+};
+const RANGE = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - RANGE; j <= i + RANGE || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                const line = j + 1;
+                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.max(Math.min(end - count, lineLength), 1);
+                        res.push(`   |  ` + '^'.repeat(length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+
+/**
+ * Event emitter, forked from the below:
+ * - original repository url: https://github.com/developit/mitt
+ * - code url: https://github.com/developit/mitt/blob/master/src/index.ts
+ * - author: Jason Miller (https://github.com/developit)
+ * - license: MIT
+ */
+/**
+ * Create a event emitter
+ *
+ * @returns An event emitter
+ */
+function createEmitter() {
+    const events = new Map();
+    const emitter = {
+        events,
+        on(event, handler) {
+            const handlers = events.get(event);
+            const added = handlers && handlers.push(handler);
+            if (!added) {
+                events.set(event, [handler]);
+            }
+        },
+        off(event, handler) {
+            const handlers = events.get(event);
+            if (handlers) {
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            }
+        },
+        emit(event, payload) {
+            (events.get(event) || [])
+                .slice()
+                .map(handler => handler(payload));
+            (events.get('*') || [])
+                .slice()
+                .map(handler => handler(event, payload));
+        }
+    };
+    return emitter;
+}
+
+export { assign, createEmitter, escapeHtml, format, friendlyJSONstringify, generateCodeFrame, generateFormatCacheKey, getGlobalThis, hasOwn, inBrowser, isArray, isBoolean, isDate, isEmptyObject, isFunction, isNumber, isObject, isPlainObject, isPromise, isRegExp, isString, isSymbol, makeSymbol, mark, measure, objectToString, toDisplayString, toTypeString, warn };
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/ParseError.js b/parent_dir/node_modules/libphonenumber-js/es6/ParseError.js
new file mode 100644
index 0000000..6956927
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/ParseError.js
@@ -0,0 +1,56 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+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 _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+// https://stackoverflow.com/a/46971044/970769
+// "Breaking changes in Typescript 2.1"
+// "Extending built-ins like Error, Array, and Map may no longer work."
+// "As a recommendation, you can manually adjust the prototype immediately after any super(...) calls."
+// https://github.com/Microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+var ParseError = /*#__PURE__*/function (_Error) {
+  _inherits(ParseError, _Error);
+
+  var _super = _createSuper(ParseError);
+
+  function ParseError(code) {
+    var _this;
+
+    _classCallCheck(this, ParseError);
+
+    _this = _super.call(this, code); // Set the prototype explicitly.
+    // Any subclass of FooError will have to manually set the prototype as well.
+
+    Object.setPrototypeOf(_assertThisInitialized(_this), ParseError.prototype);
+    _this.name = _this.constructor.name;
+    return _this;
+  }
+
+  return _createClass(ParseError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+export { ParseError as default };
+//# sourceMappingURL=ParseError.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/PhoneNumber.js b/parent_dir/node_modules/libphonenumber-js/es6/PhoneNumber.js
new file mode 100644
index 0000000..9dda1ef
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/PhoneNumber.js
@@ -0,0 +1,176 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(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 _classCallCheck(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 _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+import Metadata from './metadata.js';
+import isPossibleNumber from './isPossible.js';
+import isValidNumber from './isValid.js'; // import checkNumberLength from './helpers/checkNumberLength.js'
+
+import getNumberType from './helpers/getNumberType.js';
+import getPossibleCountriesForNumber from './helpers/getPossibleCountriesForNumber.js';
+import formatNumber from './format.js';
+var USE_NON_GEOGRAPHIC_COUNTRY_CODE = false;
+
+var PhoneNumber = /*#__PURE__*/function () {
+  /**
+   * @param  {string} countryOrCountryCallingCode
+   * @param  {string} nationalNumber
+   * @param  {object} metadata — Metadata JSON
+   * @return {PhoneNumber}
+   */
+  function PhoneNumber(countryOrCountryCallingCode, nationalNumber, metadata) {
+    _classCallCheck(this, PhoneNumber);
+
+    if (!countryOrCountryCallingCode) {
+      throw new TypeError('`country` or `countryCallingCode` not passed');
+    }
+
+    if (!nationalNumber) {
+      throw new TypeError('`nationalNumber` not passed');
+    }
+
+    if (!metadata) {
+      throw new TypeError('`metadata` not passed');
+    }
+
+    var _getCountryAndCountry = getCountryAndCountryCallingCode(countryOrCountryCallingCode, metadata),
+        country = _getCountryAndCountry.country,
+        countryCallingCode = _getCountryAndCountry.countryCallingCode;
+
+    this.country = country;
+    this.countryCallingCode = countryCallingCode;
+    this.nationalNumber = nationalNumber;
+    this.number = '+' + this.countryCallingCode + this.nationalNumber;
+    this.metadata = metadata;
+  }
+
+  _createClass(PhoneNumber, [{
+    key: "setExt",
+    value: function setExt(ext) {
+      this.ext = ext;
+    }
+  }, {
+    key: "getPossibleCountries",
+    value: function getPossibleCountries() {
+      if (this.country) {
+        return [this.country];
+      }
+
+      return getPossibleCountriesForNumber(this.countryCallingCode, this.nationalNumber, this.metadata);
+    }
+  }, {
+    key: "isPossible",
+    value: function isPossible() {
+      return isPossibleNumber(this, {
+        v2: true
+      }, this.metadata);
+    }
+  }, {
+    key: "isValid",
+    value: function isValid() {
+      return isValidNumber(this, {
+        v2: true
+      }, this.metadata);
+    }
+  }, {
+    key: "isNonGeographic",
+    value: function isNonGeographic() {
+      var metadata = new Metadata(this.metadata);
+      return metadata.isNonGeographicCallingCode(this.countryCallingCode);
+    }
+  }, {
+    key: "isEqual",
+    value: function isEqual(phoneNumber) {
+      return this.number === phoneNumber.number && this.ext === phoneNumber.ext;
+    } // This function was originally meant to be an equivalent for `validatePhoneNumberLength()`,
+    // but later it was found out that it doesn't include the possible `TOO_SHORT` result
+    // returned from `parsePhoneNumberWithError()` in the original `validatePhoneNumberLength()`,
+    // so eventually I simply commented out this method from the `PhoneNumber` class
+    // and just left the `validatePhoneNumberLength()` function, even though that one would require
+    // and additional step to also validate the actual country / calling code of the phone number.
+    // validateLength() {
+    // 	const metadata = new Metadata(this.metadata)
+    // 	metadata.selectNumberingPlan(this.countryCallingCode)
+    // 	const result = checkNumberLength(this.nationalNumber, metadata)
+    // 	if (result !== 'IS_POSSIBLE') {
+    // 		return result
+    // 	}
+    // }
+
+  }, {
+    key: "getType",
+    value: function getType() {
+      return getNumberType(this, {
+        v2: true
+      }, this.metadata);
+    }
+  }, {
+    key: "format",
+    value: function format(_format, options) {
+      return formatNumber(this, _format, options ? _objectSpread(_objectSpread({}, options), {}, {
+        v2: true
+      }) : {
+        v2: true
+      }, this.metadata);
+    }
+  }, {
+    key: "formatNational",
+    value: function formatNational(options) {
+      return this.format('NATIONAL', options);
+    }
+  }, {
+    key: "formatInternational",
+    value: function formatInternational(options) {
+      return this.format('INTERNATIONAL', options);
+    }
+  }, {
+    key: "getURI",
+    value: function getURI(options) {
+      return this.format('RFC3966', options);
+    }
+  }]);
+
+  return PhoneNumber;
+}();
+
+export { PhoneNumber as default };
+
+var isCountryCode = function isCountryCode(value) {
+  return /^[A-Z]{2}$/.test(value);
+};
+
+function getCountryAndCountryCallingCode(countryOrCountryCallingCode, metadataJson) {
+  var country;
+  var countryCallingCode;
+  var metadata = new Metadata(metadataJson); // If country code is passed then derive `countryCallingCode` from it.
+  // Also store the country code as `.country`.
+
+  if (isCountryCode(countryOrCountryCallingCode)) {
+    country = countryOrCountryCallingCode;
+    metadata.selectNumberingPlan(country);
+    countryCallingCode = metadata.countryCallingCode();
+  } else {
+    countryCallingCode = countryOrCountryCallingCode;
+    /* istanbul ignore if */
+
+    if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {
+      if (metadata.isNonGeographicCallingCode(countryCallingCode)) {
+        country = '001';
+      }
+    }
+  }
+
+  return {
+    country: country,
+    countryCallingCode: countryCallingCode
+  };
+}
+//# sourceMappingURL=PhoneNumber.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/constants.js b/parent_dir/node_modules/libphonenumber-js/es6/constants.js
new file mode 100644
index 0000000..1d50b69
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/constants.js
@@ -0,0 +1,25 @@
+// The minimum length of the national significant number.
+export var MIN_LENGTH_FOR_NSN = 2; // The ITU says the maximum length should be 15,
+// but one can find longer numbers in Germany.
+
+export var MAX_LENGTH_FOR_NSN = 17; // The maximum length of the country calling code.
+
+export var MAX_LENGTH_COUNTRY_CODE = 3; // Digits accepted in phone numbers
+// (ascii, fullwidth, arabic-indic, and eastern arabic digits).
+
+export var VALID_DIGITS = "0-9\uFF10-\uFF19\u0660-\u0669\u06F0-\u06F9"; // `DASHES` will be right after the opening square bracket of the "character class"
+
+var DASHES = "-\u2010-\u2015\u2212\u30FC\uFF0D";
+var SLASHES = "\uFF0F/";
+var DOTS = "\uFF0E.";
+export var WHITESPACE = " \xA0\xAD\u200B\u2060\u3000";
+var BRACKETS = "()\uFF08\uFF09\uFF3B\uFF3D\\[\\]"; // export const OPENING_BRACKETS = '(\uFF08\uFF3B\\\['
+
+var TILDES = "~\u2053\u223C\uFF5E"; // Regular expression of acceptable punctuation found in phone numbers. This
+// excludes punctuation found as a leading character only. This consists of dash
+// characters, white space characters, full stops, slashes, square brackets,
+// parentheses and tildes. Full-width variants are also present.
+
+export var VALID_PUNCTUATION = "".concat(DASHES).concat(SLASHES).concat(DOTS).concat(WHITESPACE).concat(BRACKETS).concat(TILDES);
+export var PLUS_CHARS = "+\uFF0B"; // const LEADING_PLUS_CHARS_PATTERN = new RegExp('^[' + PLUS_CHARS + ']+')
+//# sourceMappingURL=constants.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/format.js b/parent_dir/node_modules/libphonenumber-js/es6/format.js
new file mode 100644
index 0000000..3fab9bb
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/format.js
@@ -0,0 +1,190 @@
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(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; }
+
+// This is a port of Google Android `libphonenumber`'s
+// `phonenumberutil.js` of December 31th, 2018.
+//
+// https://github.com/googlei18n/libphonenumber/commits/master/javascript/i18n/phonenumbers/phonenumberutil.js
+import matchesEntirely from './helpers/matchesEntirely.js';
+import formatNationalNumberUsingFormat from './helpers/formatNationalNumberUsingFormat.js';
+import Metadata, { getCountryCallingCode } from './metadata.js';
+import getIddPrefix from './helpers/getIddPrefix.js';
+import { formatRFC3966 } from './helpers/RFC3966.js';
+var DEFAULT_OPTIONS = {
+  formatExtension: function formatExtension(formattedNumber, extension, metadata) {
+    return "".concat(formattedNumber).concat(metadata.ext()).concat(extension);
+  }
+};
+/**
+ * Formats a phone number.
+ *
+ * format(phoneNumberInstance, 'INTERNATIONAL', { ..., v2: true }, metadata)
+ * format(phoneNumberInstance, 'NATIONAL', { ..., v2: true }, metadata)
+ *
+ * format({ phone: '8005553535', country: 'RU' }, 'INTERNATIONAL', { ... }, metadata)
+ * format({ phone: '8005553535', country: 'RU' }, 'NATIONAL', undefined, metadata)
+ *
+ * @param  {object|PhoneNumber} input — If `options.v2: true` flag is passed, the `input` should be a `PhoneNumber` instance. Otherwise, it should be an object of shape `{ phone: '...', country: '...' }`.
+ * @param  {string} format
+ * @param  {object} [options]
+ * @param  {object} metadata
+ * @return {string}
+ */
+
+export default function formatNumber(input, format, options, metadata) {
+  // Apply default options.
+  if (options) {
+    options = _objectSpread(_objectSpread({}, DEFAULT_OPTIONS), options);
+  } else {
+    options = DEFAULT_OPTIONS;
+  }
+
+  metadata = new Metadata(metadata);
+
+  if (input.country && input.country !== '001') {
+    // Validate `input.country`.
+    if (!metadata.hasCountry(input.country)) {
+      throw new Error("Unknown country: ".concat(input.country));
+    }
+
+    metadata.country(input.country);
+  } else if (input.countryCallingCode) {
+    metadata.selectNumberingPlan(input.countryCallingCode);
+  } else return input.phone || '';
+
+  var countryCallingCode = metadata.countryCallingCode();
+  var nationalNumber = options.v2 ? input.nationalNumber : input.phone; // This variable should have been declared inside `case`s
+  // but Babel has a bug and it says "duplicate variable declaration".
+
+  var number;
+
+  switch (format) {
+    case 'NATIONAL':
+      // Legacy argument support.
+      // (`{ country: ..., phone: '' }`)
+      if (!nationalNumber) {
+        return '';
+      }
+
+      number = formatNationalNumber(nationalNumber, input.carrierCode, 'NATIONAL', metadata, options);
+      return addExtension(number, input.ext, metadata, options.formatExtension);
+
+    case 'INTERNATIONAL':
+      // Legacy argument support.
+      // (`{ country: ..., phone: '' }`)
+      if (!nationalNumber) {
+        return "+".concat(countryCallingCode);
+      }
+
+      number = formatNationalNumber(nationalNumber, null, 'INTERNATIONAL', metadata, options);
+      number = "+".concat(countryCallingCode, " ").concat(number);
+      return addExtension(number, input.ext, metadata, options.formatExtension);
+
+    case 'E.164':
+      // `E.164` doesn't define "phone number extensions".
+      return "+".concat(countryCallingCode).concat(nationalNumber);
+
+    case 'RFC3966':
+      return formatRFC3966({
+        number: "+".concat(countryCallingCode).concat(nationalNumber),
+        ext: input.ext
+      });
+    // For reference, here's Google's IDD formatter:
+    // https://github.com/google/libphonenumber/blob/32719cf74e68796788d1ca45abc85dcdc63ba5b9/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L1546
+    // Not saying that this IDD formatter replicates it 1:1, but it seems to work.
+    // Who would even need to format phone numbers in IDD format anyway?
+
+    case 'IDD':
+      if (!options.fromCountry) {
+        return; // throw new Error('`fromCountry` option not passed for IDD-prefixed formatting.')
+      }
+
+      var formattedNumber = formatIDD(nationalNumber, input.carrierCode, countryCallingCode, options.fromCountry, metadata);
+      return addExtension(formattedNumber, input.ext, metadata, options.formatExtension);
+
+    default:
+      throw new Error("Unknown \"format\" argument passed to \"formatNumber()\": \"".concat(format, "\""));
+  }
+}
+
+function formatNationalNumber(number, carrierCode, formatAs, metadata, options) {
+  var format = chooseFormatForNumber(metadata.formats(), number);
+
+  if (!format) {
+    return number;
+  }
+
+  return formatNationalNumberUsingFormat(number, format, {
+    useInternationalFormat: formatAs === 'INTERNATIONAL',
+    withNationalPrefix: format.nationalPrefixIsOptionalWhenFormattingInNationalFormat() && options && options.nationalPrefix === false ? false : true,
+    carrierCode: carrierCode,
+    metadata: metadata
+  });
+}
+
+export function chooseFormatForNumber(availableFormats, nationalNnumber) {
+  for (var _iterator = _createForOfIteratorHelperLoose(availableFormats), _step; !(_step = _iterator()).done;) {
+    var format = _step.value;
+
+    // Validate leading digits.
+    // The test case for "else path" could be found by searching for
+    // "format.leadingDigitsPatterns().length === 0".
+    if (format.leadingDigitsPatterns().length > 0) {
+      // The last leading_digits_pattern is used here, as it is the most detailed
+      var lastLeadingDigitsPattern = format.leadingDigitsPatterns()[format.leadingDigitsPatterns().length - 1]; // If leading digits don't match then move on to the next phone number format
+
+      if (nationalNnumber.search(lastLeadingDigitsPattern) !== 0) {
+        continue;
+      }
+    } // Check that the national number matches the phone number format regular expression
+
+
+    if (matchesEntirely(nationalNnumber, format.pattern())) {
+      return format;
+    }
+  }
+}
+
+function addExtension(formattedNumber, ext, metadata, formatExtension) {
+  return ext ? formatExtension(formattedNumber, ext, metadata) : formattedNumber;
+}
+
+function formatIDD(nationalNumber, carrierCode, countryCallingCode, fromCountry, metadata) {
+  var fromCountryCallingCode = getCountryCallingCode(fromCountry, metadata.metadata); // When calling within the same country calling code.
+
+  if (fromCountryCallingCode === countryCallingCode) {
+    var formattedNumber = formatNationalNumber(nationalNumber, carrierCode, 'NATIONAL', metadata); // For NANPA regions, return the national format for these regions
+    // but prefix it with the country calling code.
+
+    if (countryCallingCode === '1') {
+      return countryCallingCode + ' ' + formattedNumber;
+    } // If regions share a country calling code, the country calling code need
+    // not be dialled. This also applies when dialling within a region, so this
+    // if clause covers both these cases. Technically this is the case for
+    // dialling from La Reunion to other overseas departments of France (French
+    // Guiana, Martinique, Guadeloupe), but not vice versa - so we don't cover
+    // this edge case for now and for those cases return the version including
+    // country calling code. Details here:
+    // http://www.petitfute.com/voyage/225-info-pratiques-reunion
+    //
+
+
+    return formattedNumber;
+  }
+
+  var iddPrefix = getIddPrefix(fromCountry, undefined, metadata.metadata);
+
+  if (iddPrefix) {
+    return "".concat(iddPrefix, " ").concat(countryCallingCode, " ").concat(formatNationalNumber(nationalNumber, null, 'INTERNATIONAL', metadata));
+  }
+}
+//# sourceMappingURL=format.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/RFC3966.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/RFC3966.js
new file mode 100644
index 0000000..cb2b067
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/RFC3966.js
@@ -0,0 +1,90 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+import isViablePhoneNumber from './isViablePhoneNumber.js'; // https://www.ietf.org/rfc/rfc3966.txt
+
+/**
+ * @param  {string} text - Phone URI (RFC 3966).
+ * @return {object} `{ ?number, ?ext }`.
+ */
+
+export function parseRFC3966(text) {
+  var number;
+  var ext; // Replace "tel:" with "tel=" for parsing convenience.
+
+  text = text.replace(/^tel:/, 'tel=');
+
+  for (var _iterator = _createForOfIteratorHelperLoose(text.split(';')), _step; !(_step = _iterator()).done;) {
+    var part = _step.value;
+
+    var _part$split = part.split('='),
+        _part$split2 = _slicedToArray(_part$split, 2),
+        name = _part$split2[0],
+        value = _part$split2[1];
+
+    switch (name) {
+      case 'tel':
+        number = value;
+        break;
+
+      case 'ext':
+        ext = value;
+        break;
+
+      case 'phone-context':
+        // Only "country contexts" are supported.
+        // "Domain contexts" are ignored.
+        if (value[0] === '+') {
+          number = value + number;
+        }
+
+        break;
+    }
+  } // If the phone number is not viable, then abort.
+
+
+  if (!isViablePhoneNumber(number)) {
+    return {};
+  }
+
+  var result = {
+    number: number
+  };
+
+  if (ext) {
+    result.ext = ext;
+  }
+
+  return result;
+}
+/**
+ * @param  {object} - `{ ?number, ?extension }`.
+ * @return {string} Phone URI (RFC 3966).
+ */
+
+export function formatRFC3966(_ref) {
+  var number = _ref.number,
+      ext = _ref.ext;
+
+  if (!number) {
+    return '';
+  }
+
+  if (number[0] !== '+') {
+    throw new Error("\"formatRFC3966()\" expects \"number\" to be in E.164 format.");
+  }
+
+  return "tel:".concat(number).concat(ext ? ';ext=' + ext : '');
+}
+//# sourceMappingURL=RFC3966.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/applyInternationalSeparatorStyle.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/applyInternationalSeparatorStyle.js
new file mode 100644
index 0000000..11a6ddc
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/applyInternationalSeparatorStyle.js
@@ -0,0 +1,35 @@
+import { VALID_PUNCTUATION } from '../constants.js'; // Removes brackets and replaces dashes with spaces.
+//
+// E.g. "(999) 111-22-33" -> "999 111 22 33"
+//
+// For some reason Google's metadata contains `<intlFormat/>`s with brackets and dashes.
+// Meanwhile, there's no single opinion about using punctuation in international phone numbers.
+//
+// For example, Google's `<intlFormat/>` for USA is `+1 213-373-4253`.
+// And here's a quote from WikiPedia's "North American Numbering Plan" page:
+// https://en.wikipedia.org/wiki/North_American_Numbering_Plan
+//
+// "The country calling code for all countries participating in the NANP is 1.
+// In international format, an NANP number should be listed as +1 301 555 01 00,
+// where 301 is an area code (Maryland)."
+//
+// I personally prefer the international format without any punctuation.
+// For example, brackets are remnants of the old age, meaning that the
+// phone number part in brackets (so called "area code") can be omitted
+// if dialing within the same "area".
+// And hyphens were clearly introduced for splitting local numbers into memorizable groups.
+// For example, remembering "5553535" is difficult but "555-35-35" is much simpler.
+// Imagine a man taking a bus from home to work and seeing an ad with a phone number.
+// He has a couple of seconds to memorize that number until it passes by.
+// If it were spaces instead of hyphens the man wouldn't necessarily get it,
+// but with hyphens instead of spaces the grouping is more explicit.
+// I personally think that hyphens introduce visual clutter,
+// so I prefer replacing them with spaces in international numbers.
+// In the modern age all output is done on displays where spaces are clearly distinguishable
+// so hyphens can be safely replaced with spaces without losing any legibility.
+//
+
+export default function applyInternationalSeparatorStyle(formattedNumber) {
+  return formattedNumber.replace(new RegExp("[".concat(VALID_PUNCTUATION, "]+"), 'g'), ' ').trim();
+}
+//# sourceMappingURL=applyInternationalSeparatorStyle.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/checkNumberLength.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/checkNumberLength.js
new file mode 100644
index 0000000..0f3f08a
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/checkNumberLength.js
@@ -0,0 +1,80 @@
+import mergeArrays from './mergeArrays.js';
+export default function checkNumberLength(nationalNumber, metadata) {
+  return checkNumberLengthForType(nationalNumber, undefined, metadata);
+} // Checks whether a number is possible for the country based on its length.
+// Should only be called for the "new" metadata which has "possible lengths".
+
+export function checkNumberLengthForType(nationalNumber, type, metadata) {
+  var type_info = metadata.type(type); // There should always be "<possiblePengths/>" set for every type element.
+  // This is declared in the XML schema.
+  // For size efficiency, where a sub-description (e.g. fixed-line)
+  // has the same "<possiblePengths/>" as the "general description", this is missing,
+  // so we fall back to the "general description". Where no numbers of the type
+  // exist at all, there is one possible length (-1) which is guaranteed
+  // not to match the length of any real phone number.
+
+  var possible_lengths = type_info && type_info.possibleLengths() || metadata.possibleLengths(); // let local_lengths    = type_info && type.possibleLengthsLocal() || metadata.possibleLengthsLocal()
+  // Metadata before version `1.0.18` didn't contain `possible_lengths`.
+
+  if (!possible_lengths) {
+    return 'IS_POSSIBLE';
+  }
+
+  if (type === 'FIXED_LINE_OR_MOBILE') {
+    // No such country in metadata.
+
+    /* istanbul ignore next */
+    if (!metadata.type('FIXED_LINE')) {
+      // The rare case has been encountered where no fixedLine data is available
+      // (true for some non-geographic entities), so we just check mobile.
+      return checkNumberLengthForType(nationalNumber, 'MOBILE', metadata);
+    }
+
+    var mobile_type = metadata.type('MOBILE');
+
+    if (mobile_type) {
+      // Merge the mobile data in if there was any. "Concat" creates a new
+      // array, it doesn't edit possible_lengths in place, so we don't need a copy.
+      // Note that when adding the possible lengths from mobile, we have
+      // to again check they aren't empty since if they are this indicates
+      // they are the same as the general desc and should be obtained from there.
+      possible_lengths = mergeArrays(possible_lengths, mobile_type.possibleLengths()); // The current list is sorted; we need to merge in the new list and
+      // re-sort (duplicates are okay). Sorting isn't so expensive because
+      // the lists are very small.
+      // if (local_lengths) {
+      // 	local_lengths = mergeArrays(local_lengths, mobile_type.possibleLengthsLocal())
+      // } else {
+      // 	local_lengths = mobile_type.possibleLengthsLocal()
+      // }
+    }
+  } // If the type doesn't exist then return 'INVALID_LENGTH'.
+  else if (type && !type_info) {
+    return 'INVALID_LENGTH';
+  }
+
+  var actual_length = nationalNumber.length; // In `libphonenumber-js` all "local-only" formats are dropped for simplicity.
+  // // This is safe because there is never an overlap beween the possible lengths
+  // // and the local-only lengths; this is checked at build time.
+  // if (local_lengths && local_lengths.indexOf(nationalNumber.length) >= 0)
+  // {
+  // 	return 'IS_POSSIBLE_LOCAL_ONLY'
+  // }
+
+  var minimum_length = possible_lengths[0];
+
+  if (minimum_length === actual_length) {
+    return 'IS_POSSIBLE';
+  }
+
+  if (minimum_length > actual_length) {
+    return 'TOO_SHORT';
+  }
+
+  if (possible_lengths[possible_lengths.length - 1] < actual_length) {
+    return 'TOO_LONG';
+  } // We skip the first element since we've already checked it.
+
+
+  return possible_lengths.indexOf(actual_length, 1) >= 0 ? 'IS_POSSIBLE' : 'INVALID_LENGTH';
+}
+//# sourceMappingURL=checkNumberLength.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/extension/createExtensionPattern.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extension/createExtensionPattern.js
new file mode 100644
index 0000000..2880e2e
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extension/createExtensionPattern.js
@@ -0,0 +1,108 @@
+import { VALID_DIGITS } from '../../constants.js'; // The RFC 3966 format for extensions.
+
+var RFC3966_EXTN_PREFIX = ';ext=';
+/**
+ * Helper method for constructing regular expressions for parsing. Creates
+ * an expression that captures up to max_length digits.
+ * @return {string} RegEx pattern to capture extension digits.
+ */
+
+var getExtensionDigitsPattern = function getExtensionDigitsPattern(maxLength) {
+  return "([".concat(VALID_DIGITS, "]{1,").concat(maxLength, "})");
+};
+/**
+ * Helper initialiser method to create the regular-expression pattern to match
+ * extensions.
+ * Copy-pasted from Google's `libphonenumber`:
+ * https://github.com/google/libphonenumber/blob/55b2646ec9393f4d3d6661b9c82ef9e258e8b829/javascript/i18n/phonenumbers/phonenumberutil.js#L759-L766
+ * @return {string} RegEx pattern to capture extensions.
+ */
+
+
+export default function createExtensionPattern(purpose) {
+  // We cap the maximum length of an extension based on the ambiguity of the way
+  // the extension is prefixed. As per ITU, the officially allowed length for
+  // extensions is actually 40, but we don't support this since we haven't seen real
+  // examples and this introduces many false interpretations as the extension labels
+  // are not standardized.
+
+  /** @type {string} */
+  var extLimitAfterExplicitLabel = '20';
+  /** @type {string} */
+
+  var extLimitAfterLikelyLabel = '15';
+  /** @type {string} */
+
+  var extLimitAfterAmbiguousChar = '9';
+  /** @type {string} */
+
+  var extLimitWhenNotSure = '6';
+  /** @type {string} */
+
+  var possibleSeparatorsBetweenNumberAndExtLabel = "[ \xA0\\t,]*"; // Optional full stop (.) or colon, followed by zero or more spaces/tabs/commas.
+
+  /** @type {string} */
+
+  var possibleCharsAfterExtLabel = "[:\\.\uFF0E]?[ \xA0\\t,-]*";
+  /** @type {string} */
+
+  var optionalExtnSuffix = "#?"; // Here the extension is called out in more explicit way, i.e mentioning it obvious
+  // patterns like "ext.".
+
+  /** @type {string} */
+
+  var explicitExtLabels = "(?:e?xt(?:ensi(?:o\u0301?|\xF3))?n?|\uFF45?\uFF58\uFF54\uFF4E?|\u0434\u043E\u0431|anexo)"; // One-character symbols that can be used to indicate an extension, and less
+  // commonly used or more ambiguous extension labels.
+
+  /** @type {string} */
+
+  var ambiguousExtLabels = "(?:[x\uFF58#\uFF03~\uFF5E]|int|\uFF49\uFF4E\uFF54)"; // When extension is not separated clearly.
+
+  /** @type {string} */
+
+  var ambiguousSeparator = "[- ]+"; // This is the same as possibleSeparatorsBetweenNumberAndExtLabel, but not matching
+  // comma as extension label may have it.
+
+  /** @type {string} */
+
+  var possibleSeparatorsNumberExtLabelNoComma = "[ \xA0\\t]*"; // ",," is commonly used for auto dialling the extension when connected. First
+  // comma is matched through possibleSeparatorsBetweenNumberAndExtLabel, so we do
+  // not repeat it here. Semi-colon works in Iphone and Android also to pop up a
+  // button with the extension number following.
+
+  /** @type {string} */
+
+  var autoDiallingAndExtLabelsFound = "(?:,{2}|;)";
+  /** @type {string} */
+
+  var rfcExtn = RFC3966_EXTN_PREFIX + getExtensionDigitsPattern(extLimitAfterExplicitLabel);
+  /** @type {string} */
+
+  var explicitExtn = possibleSeparatorsBetweenNumberAndExtLabel + explicitExtLabels + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterExplicitLabel) + optionalExtnSuffix;
+  /** @type {string} */
+
+  var ambiguousExtn = possibleSeparatorsBetweenNumberAndExtLabel + ambiguousExtLabels + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterAmbiguousChar) + optionalExtnSuffix;
+  /** @type {string} */
+
+  var americanStyleExtnWithSuffix = ambiguousSeparator + getExtensionDigitsPattern(extLimitWhenNotSure) + "#";
+  /** @type {string} */
+
+  var autoDiallingExtn = possibleSeparatorsNumberExtLabelNoComma + autoDiallingAndExtLabelsFound + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterLikelyLabel) + optionalExtnSuffix;
+  /** @type {string} */
+
+  var onlyCommasExtn = possibleSeparatorsNumberExtLabelNoComma + "(?:,)+" + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterAmbiguousChar) + optionalExtnSuffix; // The first regular expression covers RFC 3966 format, where the extension is added
+  // using ";ext=". The second more generic where extension is mentioned with explicit
+  // labels like "ext:". In both the above cases we allow more numbers in extension than
+  // any other extension labels. The third one captures when single character extension
+  // labels or less commonly used labels are used. In such cases we capture fewer
+  // extension digits in order to reduce the chance of falsely interpreting two
+  // numbers beside each other as a number + extension. The fourth one covers the
+  // special case of American numbers where the extension is written with a hash
+  // at the end, such as "- 503#". The fifth one is exclusively for extension
+  // autodialling formats which are used when dialling and in this case we accept longer
+  // extensions. The last one is more liberal on the number of commas that acts as
+  // extension labels, so we have a strict cap on the number of digits in such extensions.
+
+  return rfcExtn + "|" + explicitExtn + "|" + ambiguousExtn + "|" + americanStyleExtnWithSuffix + "|" + autoDiallingExtn + "|" + onlyCommasExtn;
+}
+//# sourceMappingURL=createExtensionPattern.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/extension/extractExtension.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extension/extractExtension.js
new file mode 100644
index 0000000..7b90393
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extension/extractExtension.js
@@ -0,0 +1,32 @@
+import createExtensionPattern from './createExtensionPattern.js'; // Regexp of all known extension prefixes used by different regions followed by
+// 1 or more valid digits, for use when parsing.
+
+var EXTN_PATTERN = new RegExp('(?:' + createExtensionPattern() + ')$', 'i'); // Strips any extension (as in, the part of the number dialled after the call is
+// connected, usually indicated with extn, ext, x or similar) from the end of
+// the number, and returns it.
+
+export default function extractExtension(number) {
+  var start = number.search(EXTN_PATTERN);
+
+  if (start < 0) {
+    return {};
+  } // If we find a potential extension, and the number preceding this is a viable
+  // number, we assume it is an extension.
+
+
+  var numberWithoutExtension = number.slice(0, start);
+  var matches = number.match(EXTN_PATTERN);
+  var i = 1;
+
+  while (i < matches.length) {
+    if (matches[i]) {
+      return {
+        number: numberWithoutExtension,
+        ext: matches[i]
+      };
+    }
+
+    i++;
+  }
+}
+//# sourceMappingURL=extractExtension.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCode.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCode.js
new file mode 100644
index 0000000..524287f
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCode.js
@@ -0,0 +1,142 @@
+import stripIddPrefix from './stripIddPrefix.js';
+import extractCountryCallingCodeFromInternationalNumberWithoutPlusSign from './extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js';
+import Metadata from '../metadata.js';
+import { MAX_LENGTH_COUNTRY_CODE } from '../constants.js';
+/**
+ * Converts a phone number digits (possibly with a `+`)
+ * into a calling code and the rest phone number digits.
+ * The "rest phone number digits" could include
+ * a national prefix, carrier code, and national
+ * (significant) number.
+ * @param  {string} number — Phone number digits (possibly with a `+`).
+ * @param  {string} [country] — Default country.
+ * @param  {string} [callingCode] — Default calling code (some phone numbering plans are non-geographic).
+ * @param  {object} metadata
+ * @return {object} `{ countryCallingCodeSource: string?, countryCallingCode: string?, number: string }`
+ * @example
+ * // Returns `{ countryCallingCode: "1", number: "2133734253" }`.
+ * extractCountryCallingCode('2133734253', 'US', null, metadata)
+ * extractCountryCallingCode('2133734253', null, '1', metadata)
+ * extractCountryCallingCode('+12133734253', null, null, metadata)
+ * extractCountryCallingCode('+12133734253', 'RU', null, metadata)
+ */
+
+export default function extractCountryCallingCode(number, country, callingCode, metadata) {
+  if (!number) {
+    return {};
+  }
+
+  var isNumberWithIddPrefix; // If this is not an international phone number,
+  // then either extract an "IDD" prefix, or extract a
+  // country calling code from a number by autocorrecting it
+  // by prepending a leading `+` in cases when it starts
+  // with the country calling code.
+  // https://wikitravel.org/en/International_dialling_prefix
+  // https://github.com/catamphetamine/libphonenumber-js/issues/376
+
+  if (number[0] !== '+') {
+    // Convert an "out-of-country" dialing phone number
+    // to a proper international phone number.
+    var numberWithoutIDD = stripIddPrefix(number, country, callingCode, metadata); // If an IDD prefix was stripped then
+    // convert the number to international one
+    // for subsequent parsing.
+
+    if (numberWithoutIDD && numberWithoutIDD !== number) {
+      isNumberWithIddPrefix = true;
+      number = '+' + numberWithoutIDD;
+    } else {
+      // Check to see if the number starts with the country calling code
+      // for the default country. If so, we remove the country calling code,
+      // and do some checks on the validity of the number before and after.
+      // https://github.com/catamphetamine/libphonenumber-js/issues/376
+      if (country || callingCode) {
+        var _extractCountryCallin = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, callingCode, metadata),
+            countryCallingCode = _extractCountryCallin.countryCallingCode,
+            shorterNumber = _extractCountryCallin.number;
+
+        if (countryCallingCode) {
+          return {
+            countryCallingCodeSource: 'FROM_NUMBER_WITHOUT_PLUS_SIGN',
+            countryCallingCode: countryCallingCode,
+            number: shorterNumber
+          };
+        }
+      }
+
+      return {
+        // No need to set it to `UNSPECIFIED`. It can be just `undefined`.
+        // countryCallingCodeSource: 'UNSPECIFIED',
+        number: number
+      };
+    }
+  } // Fast abortion: country codes do not begin with a '0'
+
+
+  if (number[1] === '0') {
+    return {};
+  }
+
+  metadata = new Metadata(metadata); // The thing with country phone codes
+  // is that they are orthogonal to each other
+  // i.e. there's no such country phone code A
+  // for which country phone code B exists
+  // where B starts with A.
+  // Therefore, while scanning digits,
+  // if a valid country code is found,
+  // that means that it is the country code.
+  //
+
+  var i = 2;
+
+  while (i - 1 <= MAX_LENGTH_COUNTRY_CODE && i <= number.length) {
+    var _countryCallingCode = number.slice(1, i);
+
+    if (metadata.hasCallingCode(_countryCallingCode)) {
+      metadata.selectNumberingPlan(_countryCallingCode);
+      return {
+        countryCallingCodeSource: isNumberWithIddPrefix ? 'FROM_NUMBER_WITH_IDD' : 'FROM_NUMBER_WITH_PLUS_SIGN',
+        countryCallingCode: _countryCallingCode,
+        number: number.slice(i)
+      };
+    }
+
+    i++;
+  }
+
+  return {};
+} // The possible values for the returned `countryCallingCodeSource` are:
+//
+// Copy-pasted from:
+// https://github.com/google/libphonenumber/blob/master/resources/phonenumber.proto
+//
+// // The source from which the country_code is derived. This is not set in the
+// // general parsing method, but in the method that parses and keeps raw_input.
+// // New fields could be added upon request.
+// enum CountryCodeSource {
+//  // Default value returned if this is not set, because the phone number was
+//  // created using parse, not parseAndKeepRawInput. hasCountryCodeSource will
+//  // return false if this is the case.
+//  UNSPECIFIED = 0;
+//
+//  // The country_code is derived based on a phone number with a leading "+",
+//  // e.g. the French number "+33 1 42 68 53 00".
+//  FROM_NUMBER_WITH_PLUS_SIGN = 1;
+//
+//  // The country_code is derived based on a phone number with a leading IDD,
+//  // e.g. the French number "011 33 1 42 68 53 00", as it is dialled from US.
+//  FROM_NUMBER_WITH_IDD = 5;
+//
+//  // The country_code is derived based on a phone number without a leading
+//  // "+", e.g. the French number "33 1 42 68 53 00" when defaultCountry is
+//  // supplied as France.
+//  FROM_NUMBER_WITHOUT_PLUS_SIGN = 10;
+//
+//  // The country_code is derived NOT based on the phone number itself, but
+//  // from the defaultCountry parameter provided in the parsing function by the
+//  // clients. This happens mostly for numbers written in the national format
+//  // (without country code). For example, this would be set when parsing the
+//  // French number "01 42 68 53 00", when defaultCountry is supplied as
+//  // France.
+//  FROM_DEFAULT_COUNTRY = 20;
+// }
+//# sourceMappingURL=extractCountryCallingCode.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js
new file mode 100644
index 0000000..5fe1c78
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js
@@ -0,0 +1,50 @@
+import Metadata from '../metadata.js';
+import matchesEntirely from './matchesEntirely.js';
+import extractNationalNumber from './extractNationalNumber.js';
+import checkNumberLength from './checkNumberLength.js';
+import getCountryCallingCode from '../getCountryCallingCode.js';
+/**
+ * Sometimes some people incorrectly input international phone numbers
+ * without the leading `+`. This function corrects such input.
+ * @param  {string} number — Phone number digits.
+ * @param  {string?} country
+ * @param  {string?} callingCode
+ * @param  {object} metadata
+ * @return {object} `{ countryCallingCode: string?, number: string }`.
+ */
+
+export default function extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, callingCode, metadata) {
+  var countryCallingCode = country ? getCountryCallingCode(country, metadata) : callingCode;
+
+  if (number.indexOf(countryCallingCode) === 0) {
+    metadata = new Metadata(metadata);
+    metadata.selectNumberingPlan(country, callingCode);
+    var possibleShorterNumber = number.slice(countryCallingCode.length);
+
+    var _extractNationalNumbe = extractNationalNumber(possibleShorterNumber, metadata),
+        possibleShorterNationalNumber = _extractNationalNumbe.nationalNumber;
+
+    var _extractNationalNumbe2 = extractNationalNumber(number, metadata),
+        nationalNumber = _extractNationalNumbe2.nationalNumber; // If the number was not valid before but is valid now,
+    // or if it was too long before, we consider the number
+    // with the country calling code stripped to be a better result
+    // and keep that instead.
+    // For example, in Germany (+49), `49` is a valid area code,
+    // so if a number starts with `49`, it could be both a valid
+    // national German number or an international number without
+    // a leading `+`.
+
+
+    if (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) && matchesEntirely(possibleShorterNationalNumber, metadata.nationalNumberPattern()) || checkNumberLength(nationalNumber, metadata) === 'TOO_LONG') {
+      return {
+        countryCallingCode: countryCallingCode,
+        number: possibleShorterNumber
+      };
+    }
+  }
+
+  return {
+    number: number
+  };
+}
+//# sourceMappingURL=extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractFormattedPhoneNumberFromPossibleRfc3966NumberUri.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractFormattedPhoneNumberFromPossibleRfc3966NumberUri.js
new file mode 100644
index 0000000..0f455c1
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractFormattedPhoneNumberFromPossibleRfc3966NumberUri.js
@@ -0,0 +1,70 @@
+import extractPhoneContext, { isPhoneContextValid, PLUS_SIGN, RFC3966_PREFIX_, RFC3966_PHONE_CONTEXT_, RFC3966_ISDN_SUBADDRESS_ } from './extractPhoneContext.js';
+import ParseError from '../ParseError.js';
+/**
+ * @param  {string} numberToParse
+ * @param  {string} nationalNumber
+ * @return {}
+ */
+
+export default function extractFormattedPhoneNumberFromPossibleRfc3966NumberUri(numberToParse, _ref) {
+  var extractFormattedPhoneNumber = _ref.extractFormattedPhoneNumber;
+  var phoneContext = extractPhoneContext(numberToParse);
+
+  if (!isPhoneContextValid(phoneContext)) {
+    throw new ParseError('NOT_A_NUMBER');
+  }
+
+  var phoneNumberString;
+
+  if (phoneContext === null) {
+    // Extract a possible number from the string passed in.
+    // (this strips leading characters that could not be the start of a phone number)
+    phoneNumberString = extractFormattedPhoneNumber(numberToParse) || '';
+  } else {
+    phoneNumberString = ''; // If the phone context contains a phone number prefix, we need to capture
+    // it, whereas domains will be ignored.
+
+    if (phoneContext.charAt(0) === PLUS_SIGN) {
+      phoneNumberString += phoneContext;
+    } // Now append everything between the "tel:" prefix and the phone-context.
+    // This should include the national number, an optional extension or
+    // isdn-subaddress component. Note we also handle the case when "tel:" is
+    // missing, as we have seen in some of the phone number inputs.
+    // In that case, we append everything from the beginning.
+
+
+    var indexOfRfc3966Prefix = numberToParse.indexOf(RFC3966_PREFIX_);
+    var indexOfNationalNumber; // RFC 3966 "tel:" prefix is preset at this stage because
+    // `isPhoneContextValid()` requires it to be present.
+
+    /* istanbul ignore else */
+
+    if (indexOfRfc3966Prefix >= 0) {
+      indexOfNationalNumber = indexOfRfc3966Prefix + RFC3966_PREFIX_.length;
+    } else {
+      indexOfNationalNumber = 0;
+    }
+
+    var indexOfPhoneContext = numberToParse.indexOf(RFC3966_PHONE_CONTEXT_);
+    phoneNumberString += numberToParse.substring(indexOfNationalNumber, indexOfPhoneContext);
+  } // Delete the isdn-subaddress and everything after it if it is present.
+  // Note extension won't appear at the same time with isdn-subaddress
+  // according to paragraph 5.3 of the RFC3966 spec.
+
+
+  var indexOfIsdn = phoneNumberString.indexOf(RFC3966_ISDN_SUBADDRESS_);
+
+  if (indexOfIsdn > 0) {
+    phoneNumberString = phoneNumberString.substring(0, indexOfIsdn);
+  } // If both phone context and isdn-subaddress are absent but other
+  // parameters are present, the parameters are left in nationalNumber.
+  // This is because we are concerned about deleting content from a potential
+  // number string when there is no strong evidence that the number is
+  // actually written in RFC3966.
+
+
+  if (phoneNumberString !== '') {
+    return phoneNumberString;
+  }
+}
+//# sourceMappingURL=extractFormattedPhoneNumberFromPossibleRfc3966NumberUri.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractNationalNumber.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractNationalNumber.js
new file mode 100644
index 0000000..ecb2d84
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractNationalNumber.js
@@ -0,0 +1,111 @@
+import extractNationalNumberFromPossiblyIncompleteNumber from './extractNationalNumberFromPossiblyIncompleteNumber.js';
+import matchesEntirely from './matchesEntirely.js';
+import checkNumberLength from './checkNumberLength.js';
+/**
+ * Strips national prefix and carrier code from a complete phone number.
+ * The difference from the non-"FromCompleteNumber" function is that
+ * it won't extract national prefix if the resultant number is too short
+ * to be a complete number for the selected phone numbering plan.
+ * @param  {string} number — Complete phone number digits.
+ * @param  {Metadata} metadata — Metadata with a phone numbering plan selected.
+ * @return {object} `{ nationalNumber: string, carrierCode: string? }`.
+ */
+
+export default function extractNationalNumber(number, metadata) {
+  // Parsing national prefixes and carrier codes
+  // is only required for local phone numbers
+  // but some people don't understand that
+  // and sometimes write international phone numbers
+  // with national prefixes (or maybe even carrier codes).
+  // http://ucken.blogspot.ru/2016/03/trunk-prefixes-in-skype4b.html
+  // Google's original library forgives such mistakes
+  // and so does this library, because it has been requested:
+  // https://github.com/catamphetamine/libphonenumber-js/issues/127
+  var _extractNationalNumbe = extractNationalNumberFromPossiblyIncompleteNumber(number, metadata),
+      carrierCode = _extractNationalNumbe.carrierCode,
+      nationalNumber = _extractNationalNumbe.nationalNumber;
+
+  if (nationalNumber !== number) {
+    if (!shouldHaveExtractedNationalPrefix(number, nationalNumber, metadata)) {
+      // Don't strip the national prefix.
+      return {
+        nationalNumber: number
+      };
+    } // Check the national (significant) number length after extracting national prefix and carrier code.
+    // Legacy generated metadata (before `1.0.18`) didn't support the "possible lengths" feature.
+
+
+    if (metadata.possibleLengths()) {
+      // The number remaining after stripping the national prefix and carrier code
+      // should be long enough to have a possible length for the country.
+      // Otherwise, don't strip the national prefix and carrier code,
+      // since the original number could be a valid number.
+      // This check has been copy-pasted "as is" from Google's original library:
+      // https://github.com/google/libphonenumber/blob/876268eb1ad6cdc1b7b5bef17fc5e43052702d57/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L3236-L3250
+      // It doesn't check for the "possibility" of the original `number`.
+      // I guess it's fine not checking that one. It works as is anyway.
+      if (!isPossibleIncompleteNationalNumber(nationalNumber, metadata)) {
+        // Don't strip the national prefix.
+        return {
+          nationalNumber: number
+        };
+      }
+    }
+  }
+
+  return {
+    nationalNumber: nationalNumber,
+    carrierCode: carrierCode
+  };
+} // In some countries, the same digit could be a national prefix
+// or a leading digit of a valid phone number.
+// For example, in Russia, national prefix is `8`,
+// and also `800 555 35 35` is a valid number
+// in which `8` is not a national prefix, but the first digit
+// of a national (significant) number.
+// Same's with Belarus:
+// `82004910060` is a valid national (significant) number,
+// but `2004910060` is not.
+// To support such cases (to prevent the code from always stripping
+// national prefix), a condition is imposed: a national prefix
+// is not extracted when the original number is "viable" and the
+// resultant number is not, a "viable" national number being the one
+// that matches `national_number_pattern`.
+
+function shouldHaveExtractedNationalPrefix(nationalNumberBefore, nationalNumberAfter, metadata) {
+  // The equivalent in Google's code is:
+  // https://github.com/google/libphonenumber/blob/e326fa1fc4283bb05eb35cb3c15c18f98a31af33/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L2969-L3004
+  if (matchesEntirely(nationalNumberBefore, metadata.nationalNumberPattern()) && !matchesEntirely(nationalNumberAfter, metadata.nationalNumberPattern())) {
+    return false;
+  } // This "is possible" national number (length) check has been commented out
+  // because it's superceded by the (effectively) same check done in the
+  // `extractNationalNumber()` function after it calls `shouldHaveExtractedNationalPrefix()`.
+  // In other words, why run the same check twice if it could only be run once.
+  // // Check the national (significant) number length after extracting national prefix and carrier code.
+  // // Fixes a minor "weird behavior" bug: https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/57
+  // // (Legacy generated metadata (before `1.0.18`) didn't support the "possible lengths" feature).
+  // if (metadata.possibleLengths()) {
+  // 	if (isPossibleIncompleteNationalNumber(nationalNumberBefore, metadata) &&
+  // 		!isPossibleIncompleteNationalNumber(nationalNumberAfter, metadata)) {
+  // 		return false
+  // 	}
+  // }
+
+
+  return true;
+}
+
+function isPossibleIncompleteNationalNumber(nationalNumber, metadata) {
+  switch (checkNumberLength(nationalNumber, metadata)) {
+    case 'TOO_SHORT':
+    case 'INVALID_LENGTH':
+      // This library ignores "local-only" phone numbers (for simplicity).
+      // See the readme for more info on what are "local-only" phone numbers.
+      // case 'IS_POSSIBLE_LOCAL_ONLY':
+      return false;
+
+    default:
+      return true;
+  }
+}
+//# sourceMappingURL=extractNationalNumber.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractNationalNumberFromPossiblyIncompleteNumber.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractNationalNumberFromPossiblyIncompleteNumber.js
new file mode 100644
index 0000000..a7d4732
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractNationalNumberFromPossiblyIncompleteNumber.js
@@ -0,0 +1,107 @@
+/**
+ * Strips any national prefix (such as 0, 1) present in a
+ * (possibly incomplete) number provided.
+ * "Carrier codes" are only used  in Colombia and Brazil,
+ * and only when dialing within those countries from a mobile phone to a fixed line number.
+ * Sometimes it won't actually strip national prefix
+ * and will instead prepend some digits to the `number`:
+ * for example, when number `2345678` is passed with `VI` country selected,
+ * it will return `{ number: "3402345678" }`, because `340` area code is prepended.
+ * @param {string} number — National number digits.
+ * @param {object} metadata — Metadata with country selected.
+ * @return {object} `{ nationalNumber: string, nationalPrefix: string? carrierCode: string? }`. Even if a national prefix was extracted, it's not necessarily present in the returned object, so don't rely on its presence in the returned object in order to find out whether a national prefix has been extracted or not.
+ */
+export default function extractNationalNumberFromPossiblyIncompleteNumber(number, metadata) {
+  if (number && metadata.numberingPlan.nationalPrefixForParsing()) {
+    // See METADATA.md for the description of
+    // `national_prefix_for_parsing` and `national_prefix_transform_rule`.
+    // Attempt to parse the first digits as a national prefix.
+    var prefixPattern = new RegExp('^(?:' + metadata.numberingPlan.nationalPrefixForParsing() + ')');
+    var prefixMatch = prefixPattern.exec(number);
+
+    if (prefixMatch) {
+      var nationalNumber;
+      var carrierCode; // https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule
+      // If a `national_prefix_for_parsing` has any "capturing groups"
+      // then it means that the national (significant) number is equal to
+      // those "capturing groups" transformed via `national_prefix_transform_rule`,
+      // and nothing could be said about the actual national prefix:
+      // what is it and was it even there.
+      // If a `national_prefix_for_parsing` doesn't have any "capturing groups",
+      // then everything it matches is a national prefix.
+      // To determine whether `national_prefix_for_parsing` matched any
+      // "capturing groups", the value of the result of calling `.exec()`
+      // is looked at, and if it has non-undefined values where there're
+      // "capturing groups" in the regular expression, then it means
+      // that "capturing groups" have been matched.
+      // It's not possible to tell whether there'll be any "capturing gropus"
+      // before the matching process, because a `national_prefix_for_parsing`
+      // could exhibit both behaviors.
+
+      var capturedGroupsCount = prefixMatch.length - 1;
+      var hasCapturedGroups = capturedGroupsCount > 0 && prefixMatch[capturedGroupsCount];
+
+      if (metadata.nationalPrefixTransformRule() && hasCapturedGroups) {
+        nationalNumber = number.replace(prefixPattern, metadata.nationalPrefixTransformRule()); // If there's more than one captured group,
+        // then carrier code is the second one.
+
+        if (capturedGroupsCount > 1) {
+          carrierCode = prefixMatch[1];
+        }
+      } // If there're no "capturing groups",
+      // or if there're "capturing groups" but no
+      // `national_prefix_transform_rule`,
+      // then just strip the national prefix from the number,
+      // and possibly a carrier code.
+      // Seems like there could be more.
+      else {
+        // `prefixBeforeNationalNumber` is the whole substring matched by
+        // the `national_prefix_for_parsing` regular expression.
+        // There seem to be no guarantees that it's just a national prefix.
+        // For example, if there's a carrier code, it's gonna be a
+        // part of `prefixBeforeNationalNumber` too.
+        var prefixBeforeNationalNumber = prefixMatch[0];
+        nationalNumber = number.slice(prefixBeforeNationalNumber.length); // If there's at least one captured group,
+        // then carrier code is the first one.
+
+        if (hasCapturedGroups) {
+          carrierCode = prefixMatch[1];
+        }
+      } // Tries to guess whether a national prefix was present in the input.
+      // This is not something copy-pasted from Google's library:
+      // they don't seem to have an equivalent for that.
+      // So this isn't an "officially approved" way of doing something like that.
+      // But since there seems no other existing method, this library uses it.
+
+
+      var nationalPrefix;
+
+      if (hasCapturedGroups) {
+        var possiblePositionOfTheFirstCapturedGroup = number.indexOf(prefixMatch[1]);
+        var possibleNationalPrefix = number.slice(0, possiblePositionOfTheFirstCapturedGroup); // Example: an Argentinian (AR) phone number `0111523456789`.
+        // `prefixMatch[0]` is `01115`, and `$1` is `11`,
+        // and the rest of the phone number is `23456789`.
+        // The national number is transformed via `9$1` to `91123456789`.
+        // National prefix `0` is detected being present at the start.
+        // if (possibleNationalPrefix.indexOf(metadata.numberingPlan.nationalPrefix()) === 0) {
+
+        if (possibleNationalPrefix === metadata.numberingPlan.nationalPrefix()) {
+          nationalPrefix = metadata.numberingPlan.nationalPrefix();
+        }
+      } else {
+        nationalPrefix = prefixMatch[0];
+      }
+
+      return {
+        nationalNumber: nationalNumber,
+        nationalPrefix: nationalPrefix,
+        carrierCode: carrierCode
+      };
+    }
+  }
+
+  return {
+    nationalNumber: number
+  };
+}
+//# sourceMappingURL=extractNationalNumberFromPossiblyIncompleteNumber.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractPhoneContext.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractPhoneContext.js
new file mode 100644
index 0000000..ec41804
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/extractPhoneContext.js
@@ -0,0 +1,82 @@
+// When phone numbers are written in `RFC3966` format — `"tel:+12133734253"` —
+// they can have their "calling code" part written separately in a `phone-context` parameter.
+// Example: `"tel:12133734253;phone-context=+1"`.
+// This function parses the full phone number from the local number and the `phone-context`
+// when the `phone-context` contains a `+` sign.
+import { VALID_DIGITS // PLUS_CHARS
+} from '../constants.js';
+export var PLUS_SIGN = '+';
+var RFC3966_VISUAL_SEPARATOR_ = '[\\-\\.\\(\\)]?';
+var RFC3966_PHONE_DIGIT_ = '(' + '[' + VALID_DIGITS + ']' + '|' + RFC3966_VISUAL_SEPARATOR_ + ')';
+var RFC3966_GLOBAL_NUMBER_DIGITS_ = '^' + '\\' + PLUS_SIGN + RFC3966_PHONE_DIGIT_ + '*' + '[' + VALID_DIGITS + ']' + RFC3966_PHONE_DIGIT_ + '*' + '$';
+/**
+ * Regular expression of valid global-number-digits for the phone-context
+ * parameter, following the syntax defined in RFC3966.
+ */
+
+var RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_ = new RegExp(RFC3966_GLOBAL_NUMBER_DIGITS_, 'g'); // In this port of Google's library, we don't accept alpha characters in phone numbers.
+// const ALPHANUM_ = VALID_ALPHA_ + VALID_DIGITS
+
+var ALPHANUM_ = VALID_DIGITS;
+var RFC3966_DOMAINLABEL_ = '[' + ALPHANUM_ + ']+((\\-)*[' + ALPHANUM_ + '])*';
+var VALID_ALPHA_ = 'a-zA-Z';
+var RFC3966_TOPLABEL_ = '[' + VALID_ALPHA_ + ']+((\\-)*[' + ALPHANUM_ + '])*';
+var RFC3966_DOMAINNAME_ = '^(' + RFC3966_DOMAINLABEL_ + '\\.)*' + RFC3966_TOPLABEL_ + '\\.?$';
+/**
+ * Regular expression of valid domainname for the phone-context parameter,
+ * following the syntax defined in RFC3966.
+ */
+
+var RFC3966_DOMAINNAME_PATTERN_ = new RegExp(RFC3966_DOMAINNAME_, 'g');
+export var RFC3966_PREFIX_ = 'tel:';
+export var RFC3966_PHONE_CONTEXT_ = ';phone-context=';
+export var RFC3966_ISDN_SUBADDRESS_ = ';isub=';
+/**
+ * Extracts the value of the phone-context parameter of `numberToExtractFrom`,
+ * following the syntax defined in RFC3966.
+ *
+ * @param {string} numberToExtractFrom
+ * @return {string|null} the extracted string (possibly empty), or `null` if no phone-context parameter is found.
+ */
+
+export default function extractPhoneContext(numberToExtractFrom) {
+  var indexOfPhoneContext = numberToExtractFrom.indexOf(RFC3966_PHONE_CONTEXT_); // If no phone-context parameter is present
+
+  if (indexOfPhoneContext < 0) {
+    return null;
+  }
+
+  var phoneContextStart = indexOfPhoneContext + RFC3966_PHONE_CONTEXT_.length; // If phone-context parameter is empty
+
+  if (phoneContextStart >= numberToExtractFrom.length) {
+    return '';
+  }
+
+  var phoneContextEnd = numberToExtractFrom.indexOf(';', phoneContextStart); // If phone-context is not the last parameter
+
+  if (phoneContextEnd >= 0) {
+    return numberToExtractFrom.substring(phoneContextStart, phoneContextEnd);
+  } else {
+    return numberToExtractFrom.substring(phoneContextStart);
+  }
+}
+/**
+ * Returns whether the value of phoneContext follows the syntax defined in RFC3966.
+ *
+ * @param {string|null} phoneContext
+ * @return {boolean}
+ */
+
+export function isPhoneContextValid(phoneContext) {
+  if (phoneContext === null) {
+    return true;
+  }
+
+  if (phoneContext.length === 0) {
+    return false;
+  } // Does phone-context value match pattern of global-number-digits or domainname.
+
+
+  return RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_.test(phoneContext) || RFC3966_DOMAINNAME_PATTERN_.test(phoneContext);
+}
+//# sourceMappingURL=extractPhoneContext.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/formatNationalNumberUsingFormat.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/formatNationalNumberUsingFormat.js
new file mode 100644
index 0000000..9faea50
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/formatNationalNumberUsingFormat.js
@@ -0,0 +1,33 @@
+import applyInternationalSeparatorStyle from './applyInternationalSeparatorStyle.js'; // This was originally set to $1 but there are some countries for which the
+// first group is not used in the national pattern (e.g. Argentina) so the $1
+// group does not match correctly. Therefore, we use `\d`, so that the first
+// group actually used in the pattern will be matched.
+
+export var FIRST_GROUP_PATTERN = /(\$\d)/;
+export default function formatNationalNumberUsingFormat(number, format, _ref) {
+  var useInternationalFormat = _ref.useInternationalFormat,
+      withNationalPrefix = _ref.withNationalPrefix,
+      carrierCode = _ref.carrierCode,
+      metadata = _ref.metadata;
+  var formattedNumber = number.replace(new RegExp(format.pattern()), useInternationalFormat ? format.internationalFormat() : // This library doesn't use `domestic_carrier_code_formatting_rule`,
+  // because that one is only used when formatting phone numbers
+  // for dialing from a mobile phone, and this is not a dialing library.
+  // carrierCode && format.domesticCarrierCodeFormattingRule()
+  // 	// First, replace the $CC in the formatting rule with the desired carrier code.
+  // 	// Then, replace the $FG in the formatting rule with the first group
+  // 	// and the carrier code combined in the appropriate way.
+  // 	? format.format().replace(FIRST_GROUP_PATTERN, format.domesticCarrierCodeFormattingRule().replace('$CC', carrierCode))
+  // 	: (
+  // 		withNationalPrefix && format.nationalPrefixFormattingRule()
+  // 			? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule())
+  // 			: format.format()
+  // 	)
+  withNationalPrefix && format.nationalPrefixFormattingRule() ? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule()) : format.format());
+
+  if (useInternationalFormat) {
+    return applyInternationalSeparatorStyle(formattedNumber);
+  }
+
+  return formattedNumber;
+}
+//# sourceMappingURL=formatNationalNumberUsingFormat.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/getCountryByCallingCode.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/getCountryByCallingCode.js
new file mode 100644
index 0000000..6f3424f
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/getCountryByCallingCode.js
@@ -0,0 +1,25 @@
+import getCountryByNationalNumber from './getCountryByNationalNumber.js';
+var USE_NON_GEOGRAPHIC_COUNTRY_CODE = false;
+export default function getCountryByCallingCode(callingCode, nationalPhoneNumber, metadata) {
+  /* istanbul ignore if */
+  if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {
+    if (metadata.isNonGeographicCallingCode(callingCode)) {
+      return '001';
+    }
+  }
+
+  var possibleCountries = metadata.getCountryCodesForCallingCode(callingCode);
+
+  if (!possibleCountries) {
+    return;
+  } // If there's just one country corresponding to the country code,
+  // then just return it, without further phone number digits validation.
+
+
+  if (possibleCountries.length === 1) {
+    return possibleCountries[0];
+  }
+
+  return getCountryByNationalNumber(possibleCountries, nationalPhoneNumber, metadata.metadata);
+}
+//# sourceMappingURL=getCountryByCallingCode.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/getCountryByNationalNumber.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/getCountryByNationalNumber.js
new file mode 100644
index 0000000..90b6ce4
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/getCountryByNationalNumber.js
@@ -0,0 +1,35 @@
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+import Metadata from '../metadata.js';
+import getNumberType from './getNumberType.js';
+export default function getCountryByNationalNumber(possibleCountries, nationalPhoneNumber, metadata) {
+  // Re-create `metadata` because it will be selecting a `country`.
+  metadata = new Metadata(metadata);
+
+  for (var _iterator = _createForOfIteratorHelperLoose(possibleCountries), _step; !(_step = _iterator()).done;) {
+    var country = _step.value;
+    metadata.country(country); // "Leading digits" patterns are only defined for about 20% of all countries.
+    // By definition, matching "leading digits" is a sufficient but not a necessary
+    // condition for a phone number to belong to a country.
+    // The point of "leading digits" check is that it's the fastest one to get a match.
+    // https://gitlab.com/catamphetamine/libphonenumber-js/blob/master/METADATA.md#leading_digits
+
+    if (metadata.leadingDigits()) {
+      if (nationalPhoneNumber && nationalPhoneNumber.search(metadata.leadingDigits()) === 0) {
+        return country;
+      }
+    } // Else perform full validation with all of those
+    // fixed-line/mobile/etc regular expressions.
+    else if (getNumberType({
+      phone: nationalPhoneNumber,
+      country: country
+    }, undefined, metadata.metadata)) {
+      return country;
+    }
+  }
+}
+//# sourceMappingURL=getCountryByNationalNumber.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/getIddPrefix.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/getIddPrefix.js
new file mode 100644
index 0000000..e10f77f
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/getIddPrefix.js
@@ -0,0 +1,27 @@
+import Metadata from '../metadata.js';
+/**
+ * Pattern that makes it easy to distinguish whether a region has a single
+ * international dialing prefix or not. If a region has a single international
+ * prefix (e.g. 011 in USA), it will be represented as a string that contains
+ * a sequence of ASCII digits, and possibly a tilde, which signals waiting for
+ * the tone. If there are multiple available international prefixes in a
+ * region, they will be represented as a regex string that always contains one
+ * or more characters that are not ASCII digits or a tilde.
+ */
+
+var SINGLE_IDD_PREFIX_REG_EXP = /^[\d]+(?:[~\u2053\u223C\uFF5E][\d]+)?$/; // For regions that have multiple IDD prefixes
+// a preferred IDD prefix is returned.
+
+export default function getIddPrefix(country, callingCode, metadata) {
+  var countryMetadata = new Metadata(metadata);
+  countryMetadata.selectNumberingPlan(country, callingCode);
+
+  if (countryMetadata.defaultIDDPrefix()) {
+    return countryMetadata.defaultIDDPrefix();
+  }
+
+  if (SINGLE_IDD_PREFIX_REG_EXP.test(countryMetadata.IDDPrefix())) {
+    return countryMetadata.IDDPrefix();
+  }
+}
+//# sourceMappingURL=getIddPrefix.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/getNumberType.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/getNumberType.js
new file mode 100644
index 0000000..d466da8
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/getNumberType.js
@@ -0,0 +1,90 @@
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+import Metadata from '../metadata.js';
+import matchesEntirely from './matchesEntirely.js';
+var NON_FIXED_LINE_PHONE_TYPES = ['MOBILE', 'PREMIUM_RATE', 'TOLL_FREE', 'SHARED_COST', 'VOIP', 'PERSONAL_NUMBER', 'PAGER', 'UAN', 'VOICEMAIL']; // Finds out national phone number type (fixed line, mobile, etc)
+
+export default function getNumberType(input, options, metadata) {
+  // If assigning the `{}` default value is moved to the arguments above,
+  // code coverage would decrease for some weird reason.
+  options = options || {}; // When `parse()` returned `{}`
+  // meaning that the phone number is not a valid one.
+
+  if (!input.country) {
+    return;
+  }
+
+  metadata = new Metadata(metadata);
+  metadata.selectNumberingPlan(input.country, input.countryCallingCode);
+  var nationalNumber = options.v2 ? input.nationalNumber : input.phone; // The following is copy-pasted from the original function:
+  // https://github.com/googlei18n/libphonenumber/blob/3ea547d4fbaa2d0b67588904dfa5d3f2557c27ff/javascript/i18n/phonenumbers/phonenumberutil.js#L2835
+  // Is this national number even valid for this country
+
+  if (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern())) {
+    return;
+  } // Is it fixed line number
+
+
+  if (isNumberTypeEqualTo(nationalNumber, 'FIXED_LINE', metadata)) {
+    // Because duplicate regular expressions are removed
+    // to reduce metadata size, if "mobile" pattern is ""
+    // then it means it was removed due to being a duplicate of the fixed-line pattern.
+    //
+    if (metadata.type('MOBILE') && metadata.type('MOBILE').pattern() === '') {
+      return 'FIXED_LINE_OR_MOBILE';
+    } // `MOBILE` type pattern isn't included if it matched `FIXED_LINE` one.
+    // For example, for "US" country.
+    // Old metadata (< `1.0.18`) had a specific "types" data structure
+    // that happened to be `undefined` for `MOBILE` in that case.
+    // Newer metadata (>= `1.0.18`) has another data structure that is
+    // not `undefined` for `MOBILE` in that case (it's just an empty array).
+    // So this `if` is just for backwards compatibility with old metadata.
+
+
+    if (!metadata.type('MOBILE')) {
+      return 'FIXED_LINE_OR_MOBILE';
+    } // Check if the number happens to qualify as both fixed line and mobile.
+    // (no such country in the minimal metadata set)
+
+    /* istanbul ignore if */
+
+
+    if (isNumberTypeEqualTo(nationalNumber, 'MOBILE', metadata)) {
+      return 'FIXED_LINE_OR_MOBILE';
+    }
+
+    return 'FIXED_LINE';
+  }
+
+  for (var _iterator = _createForOfIteratorHelperLoose(NON_FIXED_LINE_PHONE_TYPES), _step; !(_step = _iterator()).done;) {
+    var type = _step.value;
+
+    if (isNumberTypeEqualTo(nationalNumber, type, metadata)) {
+      return type;
+    }
+  }
+}
+export function isNumberTypeEqualTo(nationalNumber, type, metadata) {
+  type = metadata.type(type);
+
+  if (!type || !type.pattern()) {
+    return false;
+  } // Check if any possible number lengths are present;
+  // if so, we use them to avoid checking
+  // the validation pattern if they don't match.
+  // If they are absent, this means they match
+  // the general description, which we have
+  // already checked before a specific number type.
+
+
+  if (type.possibleLengths() && type.possibleLengths().indexOf(nationalNumber.length) < 0) {
+    return false;
+  }
+
+  return matchesEntirely(nationalNumber, type.pattern());
+}
+//# sourceMappingURL=getNumberType.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/getPossibleCountriesForNumber.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/getPossibleCountriesForNumber.js
new file mode 100644
index 0000000..ceea9cd
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/getPossibleCountriesForNumber.js
@@ -0,0 +1,35 @@
+import Metadata from '../metadata.js';
+/**
+ * Returns a list of countries that the phone number could potentially belong to.
+ * @param  {string} callingCode — Calling code.
+ * @param  {string} nationalNumber — National (significant) number.
+ * @param  {object} metadata — Metadata.
+ * @return {string[]} A list of possible countries.
+ */
+
+export default function getPossibleCountriesForNumber(callingCode, nationalNumber, metadata) {
+  var _metadata = new Metadata(metadata);
+
+  var possibleCountries = _metadata.getCountryCodesForCallingCode(callingCode);
+
+  if (!possibleCountries) {
+    return [];
+  }
+
+  return possibleCountries.filter(function (country) {
+    return couldNationalNumberBelongToCountry(nationalNumber, country, metadata);
+  });
+}
+
+function couldNationalNumberBelongToCountry(nationalNumber, country, metadata) {
+  var _metadata = new Metadata(metadata);
+
+  _metadata.selectNumberingPlan(country);
+
+  if (_metadata.numberingPlan.possibleLengths().indexOf(nationalNumber.length) >= 0) {
+    return true;
+  }
+
+  return false;
+}
+//# sourceMappingURL=getPossibleCountriesForNumber.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/isViablePhoneNumber.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/isViablePhoneNumber.js
new file mode 100644
index 0000000..2447c07
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/isViablePhoneNumber.js
@@ -0,0 +1,69 @@
+import { MIN_LENGTH_FOR_NSN, VALID_DIGITS, VALID_PUNCTUATION, PLUS_CHARS } from '../constants.js';
+import createExtensionPattern from './extension/createExtensionPattern.js'; //  Regular expression of viable phone numbers. This is location independent.
+//  Checks we have at least three leading digits, and only valid punctuation,
+//  alpha characters and digits in the phone number. Does not include extension
+//  data. The symbol 'x' is allowed here as valid punctuation since it is often
+//  used as a placeholder for carrier codes, for example in Brazilian phone
+//  numbers. We also allow multiple '+' characters at the start.
+//
+//  Corresponds to the following:
+//  [digits]{minLengthNsn}|
+//  plus_sign*
+//  (([punctuation]|[star])*[digits]){3,}([punctuation]|[star]|[digits]|[alpha])*
+//
+//  The first reg-ex is to allow short numbers (two digits long) to be parsed if
+//  they are entered as "15" etc, but only if there is no punctuation in them.
+//  The second expression restricts the number of digits to three or more, but
+//  then allows them to be in international form, and to have alpha-characters
+//  and punctuation. We split up the two reg-exes here and combine them when
+//  creating the reg-ex VALID_PHONE_NUMBER_PATTERN itself so we can prefix it
+//  with ^ and append $ to each branch.
+//
+//  "Note VALID_PUNCTUATION starts with a -,
+//   so must be the first in the range" (c) Google devs.
+//  (wtf did they mean by saying that; probably nothing)
+//
+
+var MIN_LENGTH_PHONE_NUMBER_PATTERN = '[' + VALID_DIGITS + ']{' + MIN_LENGTH_FOR_NSN + '}'; //
+// And this is the second reg-exp:
+// (see MIN_LENGTH_PHONE_NUMBER_PATTERN for a full description of this reg-exp)
+//
+
+export var VALID_PHONE_NUMBER = '[' + PLUS_CHARS + ']{0,1}' + '(?:' + '[' + VALID_PUNCTUATION + ']*' + '[' + VALID_DIGITS + ']' + '){3,}' + '[' + VALID_PUNCTUATION + VALID_DIGITS + ']*'; // This regular expression isn't present in Google's `libphonenumber`
+// and is only used to determine whether the phone number being input
+// is too short for it to even consider it a "valid" number.
+// This is just a way to differentiate between a really invalid phone
+// number like "abcde" and a valid phone number that a user has just
+// started inputting, like "+1" or "1": both these cases would be
+// considered `NOT_A_NUMBER` by Google's `libphonenumber`, but this
+// library can provide a more detailed error message — whether it's
+// really "not a number", or is it just a start of a valid phone number.
+
+var VALID_PHONE_NUMBER_START_REG_EXP = new RegExp('^' + '[' + PLUS_CHARS + ']{0,1}' + '(?:' + '[' + VALID_PUNCTUATION + ']*' + '[' + VALID_DIGITS + ']' + '){1,2}' + '$', 'i');
+export var VALID_PHONE_NUMBER_WITH_EXTENSION = VALID_PHONE_NUMBER + // Phone number extensions
+'(?:' + createExtensionPattern() + ')?'; // The combined regular expression for valid phone numbers:
+//
+
+var VALID_PHONE_NUMBER_PATTERN = new RegExp( // Either a short two-digit-only phone number
+'^' + MIN_LENGTH_PHONE_NUMBER_PATTERN + '$' + '|' + // Or a longer fully parsed phone number (min 3 characters)
+'^' + VALID_PHONE_NUMBER_WITH_EXTENSION + '$', 'i'); // Checks to see if the string of characters could possibly be a phone number at
+// all. At the moment, checks to see that the string begins with at least 2
+// digits, ignoring any punctuation commonly found in phone numbers. This method
+// does not require the number to be normalized in advance - but does assume
+// that leading non-number symbols have been removed, such as by the method
+// `extract_possible_number`.
+//
+
+export default function isViablePhoneNumber(number) {
+  return number.length >= MIN_LENGTH_FOR_NSN && VALID_PHONE_NUMBER_PATTERN.test(number);
+} // This is just a way to differentiate between a really invalid phone
+// number like "abcde" and a valid phone number that a user has just
+// started inputting, like "+1" or "1": both these cases would be
+// considered `NOT_A_NUMBER` by Google's `libphonenumber`, but this
+// library can provide a more detailed error message — whether it's
+// really "not a number", or is it just a start of a valid phone number.
+
+export function isViablePhoneNumberStart(number) {
+  return VALID_PHONE_NUMBER_START_REG_EXP.test(number);
+}
+//# sourceMappingURL=isViablePhoneNumber.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/matchesEntirely.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/matchesEntirely.js
new file mode 100644
index 0000000..6a116fd
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/matchesEntirely.js
@@ -0,0 +1,12 @@
+/**
+ * Checks whether the entire input sequence can be matched
+ * against the regular expression.
+ * @return {boolean}
+ */
+export default function matchesEntirely(text, regular_expression) {
+  // If assigning the `''` default value is moved to the arguments above,
+  // code coverage would decrease for some weird reason.
+  text = text || '';
+  return new RegExp('^(?:' + regular_expression + ')$').test(text);
+}
+//# sourceMappingURL=matchesEntirely.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/mergeArrays.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/mergeArrays.js
new file mode 100644
index 0000000..83dc97a
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/mergeArrays.js
@@ -0,0 +1,33 @@
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+/**
+ * Merges two arrays.
+ * @param  {*} a
+ * @param  {*} b
+ * @return {*}
+ */
+export default function mergeArrays(a, b) {
+  var merged = a.slice();
+
+  for (var _iterator = _createForOfIteratorHelperLoose(b), _step; !(_step = _iterator()).done;) {
+    var element = _step.value;
+
+    if (a.indexOf(element) < 0) {
+      merged.push(element);
+    }
+  }
+
+  return merged.sort(function (a, b) {
+    return a - b;
+  }); // ES6 version, requires Set polyfill.
+  // let merged = new Set(a)
+  // for (const element of b) {
+  // 	merged.add(i)
+  // }
+  // return Array.from(merged).sort((a, b) => a - b)
+}
+//# sourceMappingURL=mergeArrays.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/parseDigits.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/parseDigits.js
new file mode 100644
index 0000000..fed60ae
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/parseDigits.js
@@ -0,0 +1,121 @@
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+// These mappings map a character (key) to a specific digit that should
+// replace it for normalization purposes. Non-European digits that
+// may be used in phone numbers are mapped to a European equivalent.
+//
+// E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.
+//
+export var DIGITS = {
+  '0': '0',
+  '1': '1',
+  '2': '2',
+  '3': '3',
+  '4': '4',
+  '5': '5',
+  '6': '6',
+  '7': '7',
+  '8': '8',
+  '9': '9',
+  "\uFF10": '0',
+  // Fullwidth digit 0
+  "\uFF11": '1',
+  // Fullwidth digit 1
+  "\uFF12": '2',
+  // Fullwidth digit 2
+  "\uFF13": '3',
+  // Fullwidth digit 3
+  "\uFF14": '4',
+  // Fullwidth digit 4
+  "\uFF15": '5',
+  // Fullwidth digit 5
+  "\uFF16": '6',
+  // Fullwidth digit 6
+  "\uFF17": '7',
+  // Fullwidth digit 7
+  "\uFF18": '8',
+  // Fullwidth digit 8
+  "\uFF19": '9',
+  // Fullwidth digit 9
+  "\u0660": '0',
+  // Arabic-indic digit 0
+  "\u0661": '1',
+  // Arabic-indic digit 1
+  "\u0662": '2',
+  // Arabic-indic digit 2
+  "\u0663": '3',
+  // Arabic-indic digit 3
+  "\u0664": '4',
+  // Arabic-indic digit 4
+  "\u0665": '5',
+  // Arabic-indic digit 5
+  "\u0666": '6',
+  // Arabic-indic digit 6
+  "\u0667": '7',
+  // Arabic-indic digit 7
+  "\u0668": '8',
+  // Arabic-indic digit 8
+  "\u0669": '9',
+  // Arabic-indic digit 9
+  "\u06F0": '0',
+  // Eastern-Arabic digit 0
+  "\u06F1": '1',
+  // Eastern-Arabic digit 1
+  "\u06F2": '2',
+  // Eastern-Arabic digit 2
+  "\u06F3": '3',
+  // Eastern-Arabic digit 3
+  "\u06F4": '4',
+  // Eastern-Arabic digit 4
+  "\u06F5": '5',
+  // Eastern-Arabic digit 5
+  "\u06F6": '6',
+  // Eastern-Arabic digit 6
+  "\u06F7": '7',
+  // Eastern-Arabic digit 7
+  "\u06F8": '8',
+  // Eastern-Arabic digit 8
+  "\u06F9": '9' // Eastern-Arabic digit 9
+
+};
+export function parseDigit(character) {
+  return DIGITS[character];
+}
+/**
+ * Parses phone number digits from a string.
+ * Drops all punctuation leaving only digits.
+ * Also converts wide-ascii and arabic-indic numerals to conventional numerals.
+ * E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.
+ * @param  {string} string
+ * @return {string}
+ * @example
+ * ```js
+ * parseDigits('8 (800) 555')
+ * // Outputs '8800555'.
+ * ```
+ */
+
+export default function parseDigits(string) {
+  var result = ''; // Using `.split('')` here instead of normal `for ... of`
+  // because the importing application doesn't neccessarily include an ES6 polyfill.
+  // The `.split('')` approach discards "exotic" UTF-8 characters
+  // (the ones consisting of four bytes) but digits
+  // (including non-European ones) don't fall into that range
+  // so such "exotic" characters would be discarded anyway.
+
+  for (var _iterator = _createForOfIteratorHelperLoose(string.split('')), _step; !(_step = _iterator()).done;) {
+    var character = _step.value;
+    var digit = parseDigit(character);
+
+    if (digit) {
+      result += digit;
+    }
+  }
+
+  return result;
+}
+//# sourceMappingURL=parseDigits.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/helpers/stripIddPrefix.js b/parent_dir/node_modules/libphonenumber-js/es6/helpers/stripIddPrefix.js
new file mode 100644
index 0000000..c097b1f
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/helpers/stripIddPrefix.js
@@ -0,0 +1,34 @@
+import Metadata from '../metadata.js';
+import { VALID_DIGITS } from '../constants.js';
+var CAPTURING_DIGIT_PATTERN = new RegExp('([' + VALID_DIGITS + '])');
+export default function stripIddPrefix(number, country, callingCode, metadata) {
+  if (!country) {
+    return;
+  } // Check if the number is IDD-prefixed.
+
+
+  var countryMetadata = new Metadata(metadata);
+  countryMetadata.selectNumberingPlan(country, callingCode);
+  var IDDPrefixPattern = new RegExp(countryMetadata.IDDPrefix());
+
+  if (number.search(IDDPrefixPattern) !== 0) {
+    return;
+  } // Strip IDD prefix.
+
+
+  number = number.slice(number.match(IDDPrefixPattern)[0].length); // If there're any digits after an IDD prefix,
+  // then those digits are a country calling code.
+  // Since no country code starts with a `0`,
+  // the code below validates that the next digit (if present) is not `0`.
+
+  var matchedGroups = number.match(CAPTURING_DIGIT_PATTERN);
+
+  if (matchedGroups && matchedGroups[1] != null && matchedGroups[1].length > 0) {
+    if (matchedGroups[1] === '0') {
+      return;
+    }
+  }
+
+  return number;
+}
+//# sourceMappingURL=stripIddPrefix.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/isPossible.js b/parent_dir/node_modules/libphonenumber-js/es6/isPossible.js
new file mode 100644
index 0000000..9ee8fa0
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/isPossible.js
@@ -0,0 +1,84 @@
+import Metadata from './metadata.js';
+import checkNumberLength from './helpers/checkNumberLength.js';
+/**
+ * Checks if a phone number is "possible" (basically just checks its length).
+ *
+ * isPossible(phoneNumberInstance, { ..., v2: true }, metadata)
+ *
+ * isPossible({ phone: '8005553535', country: 'RU' }, { ... }, metadata)
+ * isPossible({ phone: '8005553535', country: 'RU' }, undefined, metadata)
+ *
+ * @param  {object|PhoneNumber} input — If `options.v2: true` flag is passed, the `input` should be a `PhoneNumber` instance. Otherwise, it should be an object of shape `{ phone: '...', country: '...' }`.
+ * @param  {object} [options]
+ * @param  {object} metadata
+ * @return {string}
+ */
+
+export default function isPossiblePhoneNumber(input, options, metadata) {
+  /* istanbul ignore if */
+  if (options === undefined) {
+    options = {};
+  }
+
+  metadata = new Metadata(metadata);
+
+  if (options.v2) {
+    if (!input.countryCallingCode) {
+      throw new Error('Invalid phone number object passed');
+    }
+
+    metadata.selectNumberingPlan(input.countryCallingCode);
+  } else {
+    if (!input.phone) {
+      return false;
+    }
+
+    if (input.country) {
+      if (!metadata.hasCountry(input.country)) {
+        throw new Error("Unknown country: ".concat(input.country));
+      }
+
+      metadata.country(input.country);
+    } else {
+      if (!input.countryCallingCode) {
+        throw new Error('Invalid phone number object passed');
+      }
+
+      metadata.selectNumberingPlan(input.countryCallingCode);
+    }
+  } // Old metadata (< 1.0.18) had no "possible length" data.
+
+
+  if (metadata.possibleLengths()) {
+    return isPossibleNumber(input.phone || input.nationalNumber, metadata);
+  } else {
+    // There was a bug between `1.7.35` and `1.7.37` where "possible_lengths"
+    // were missing for "non-geographical" numbering plans.
+    // Just assume the number is possible in such cases:
+    // it's unlikely that anyone generated their custom metadata
+    // in that short period of time (one day).
+    // This code can be removed in some future major version update.
+    if (input.countryCallingCode && metadata.isNonGeographicCallingCode(input.countryCallingCode)) {
+      // "Non-geographic entities" did't have `possibleLengths`
+      // due to a bug in metadata generation process.
+      return true;
+    } else {
+      throw new Error('Missing "possibleLengths" in metadata. Perhaps the metadata has been generated before v1.0.18.');
+    }
+  }
+}
+export function isPossibleNumber(nationalNumber, metadata) {
+  //, isInternational) {
+  switch (checkNumberLength(nationalNumber, metadata)) {
+    case 'IS_POSSIBLE':
+      return true;
+    // This library ignores "local-only" phone numbers (for simplicity).
+    // See the readme for more info on what are "local-only" phone numbers.
+    // case 'IS_POSSIBLE_LOCAL_ONLY':
+    // 	return !isInternational
+
+    default:
+      return false;
+  }
+}
+//# sourceMappingURL=isPossible.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/isValid.js b/parent_dir/node_modules/libphonenumber-js/es6/isValid.js
new file mode 100644
index 0000000..e7da158
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/isValid.js
@@ -0,0 +1,65 @@
+import Metadata from './metadata.js';
+import matchesEntirely from './helpers/matchesEntirely.js';
+import getNumberType from './helpers/getNumberType.js';
+/**
+ * Checks if a given phone number is valid.
+ *
+ * isValid(phoneNumberInstance, { ..., v2: true }, metadata)
+ *
+ * isPossible({ phone: '8005553535', country: 'RU' }, { ... }, metadata)
+ * isPossible({ phone: '8005553535', country: 'RU' }, undefined, metadata)
+ *
+ * If the `number` is a string, it will be parsed to an object,
+ * but only if it contains only valid phone number characters (including punctuation).
+ * If the `number` is an object, it is used as is.
+ *
+ * The optional `defaultCountry` argument is the default country.
+ * I.e. it does not restrict to just that country,
+ * e.g. in those cases where several countries share
+ * the same phone numbering rules (NANPA, Britain, etc).
+ * For example, even though the number `07624 369230`
+ * belongs to the Isle of Man ("IM" country code)
+ * calling `isValidNumber('07624369230', 'GB', metadata)`
+ * still returns `true` because the country is not restricted to `GB`,
+ * it's just that `GB` is the default one for the phone numbering rules.
+ * For restricting the country see `isValidNumberForRegion()`
+ * though restricting a country might not be a good idea.
+ * https://github.com/googlei18n/libphonenumber/blob/master/FAQ.md#when-should-i-use-isvalidnumberforregion
+ *
+ * Examples:
+ *
+ * ```js
+ * isValidNumber('+78005553535', metadata)
+ * isValidNumber('8005553535', 'RU', metadata)
+ * isValidNumber('88005553535', 'RU', metadata)
+ * isValidNumber({ phone: '8005553535', country: 'RU' }, metadata)
+ * ```
+ */
+
+export default function isValidNumber(input, options, metadata) {
+  // If assigning the `{}` default value is moved to the arguments above,
+  // code coverage would decrease for some weird reason.
+  options = options || {};
+  metadata = new Metadata(metadata);
+  /**
+   * Checks if a phone number is "possible" (basically just checks its length).
+   *
+   * @param  {object|PhoneNumber} input — If `options.v2: true` flag is passed, the `input` should be a `PhoneNumber` instance. Otherwise, it should be an object of shape `{ phone: '...', country: '...' }`.
+   * @param  {object} [options]
+   * @param  {object} metadata
+   * @return {string}
+   */
+
+  metadata.selectNumberingPlan(input.country, input.countryCallingCode); // By default, countries only have type regexps when it's required for
+  // distinguishing different countries having the same `countryCallingCode`.
+
+  if (metadata.hasTypes()) {
+    return getNumberType(input, options, metadata.metadata) !== undefined;
+  } // If there are no type regexps for this country in metadata then use
+  // `nationalNumberPattern` as a "better than nothing" replacement.
+
+
+  var nationalNumber = options.v2 ? input.nationalNumber : input.phone;
+  return matchesEntirely(nationalNumber, metadata.nationalNumberPattern());
+}
+//# sourceMappingURL=isValid.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/metadata.js b/parent_dir/node_modules/libphonenumber-js/es6/metadata.js
new file mode 100644
index 0000000..f1d80ba
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/metadata.js
@@ -0,0 +1,662 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+function _classCallCheck(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 _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+import compare from './tools/semver-compare.js'; // Added "possibleLengths" and renamed
+// "country_phone_code_to_countries" to "country_calling_codes".
+
+var V2 = '1.0.18'; // Added "idd_prefix" and "default_idd_prefix".
+
+var V3 = '1.2.0'; // Moved `001` country code to "nonGeographic" section of metadata.
+
+var V4 = '1.7.35';
+var DEFAULT_EXT_PREFIX = ' ext. ';
+var CALLING_CODE_REG_EXP = /^\d+$/;
+/**
+ * See: https://gitlab.com/catamphetamine/libphonenumber-js/blob/master/METADATA.md
+ */
+
+var Metadata = /*#__PURE__*/function () {
+  function Metadata(metadata) {
+    _classCallCheck(this, Metadata);
+
+    validateMetadata(metadata);
+    this.metadata = metadata;
+    setVersion.call(this, metadata);
+  }
+
+  _createClass(Metadata, [{
+    key: "getCountries",
+    value: function getCountries() {
+      return Object.keys(this.metadata.countries).filter(function (_) {
+        return _ !== '001';
+      });
+    }
+  }, {
+    key: "getCountryMetadata",
+    value: function getCountryMetadata(countryCode) {
+      return this.metadata.countries[countryCode];
+    }
+  }, {
+    key: "nonGeographic",
+    value: function nonGeographic() {
+      if (this.v1 || this.v2 || this.v3) return; // `nonGeographical` was a typo.
+      // It's present in metadata generated from `1.7.35` to `1.7.37`.
+      // The test case could be found by searching for "nonGeographical".
+
+      return this.metadata.nonGeographic || this.metadata.nonGeographical;
+    }
+  }, {
+    key: "hasCountry",
+    value: function hasCountry(country) {
+      return this.getCountryMetadata(country) !== undefined;
+    }
+  }, {
+    key: "hasCallingCode",
+    value: function hasCallingCode(callingCode) {
+      if (this.getCountryCodesForCallingCode(callingCode)) {
+        return true;
+      }
+
+      if (this.nonGeographic()) {
+        if (this.nonGeographic()[callingCode]) {
+          return true;
+        }
+      } else {
+        // A hacky workaround for old custom metadata (generated before V4).
+        var countryCodes = this.countryCallingCodes()[callingCode];
+
+        if (countryCodes && countryCodes.length === 1 && countryCodes[0] === '001') {
+          return true;
+        }
+      }
+    }
+  }, {
+    key: "isNonGeographicCallingCode",
+    value: function isNonGeographicCallingCode(callingCode) {
+      if (this.nonGeographic()) {
+        return this.nonGeographic()[callingCode] ? true : false;
+      } else {
+        return this.getCountryCodesForCallingCode(callingCode) ? false : true;
+      }
+    } // Deprecated.
+
+  }, {
+    key: "country",
+    value: function country(countryCode) {
+      return this.selectNumberingPlan(countryCode);
+    }
+  }, {
+    key: "selectNumberingPlan",
+    value: function selectNumberingPlan(countryCode, callingCode) {
+      // Supports just passing `callingCode` as the first argument.
+      if (countryCode && CALLING_CODE_REG_EXP.test(countryCode)) {
+        callingCode = countryCode;
+        countryCode = null;
+      }
+
+      if (countryCode && countryCode !== '001') {
+        if (!this.hasCountry(countryCode)) {
+          throw new Error("Unknown country: ".concat(countryCode));
+        }
+
+        this.numberingPlan = new NumberingPlan(this.getCountryMetadata(countryCode), this);
+      } else if (callingCode) {
+        if (!this.hasCallingCode(callingCode)) {
+          throw new Error("Unknown calling code: ".concat(callingCode));
+        }
+
+        this.numberingPlan = new NumberingPlan(this.getNumberingPlanMetadata(callingCode), this);
+      } else {
+        this.numberingPlan = undefined;
+      }
+
+      return this;
+    }
+  }, {
+    key: "getCountryCodesForCallingCode",
+    value: function getCountryCodesForCallingCode(callingCode) {
+      var countryCodes = this.countryCallingCodes()[callingCode];
+
+      if (countryCodes) {
+        // Metadata before V4 included "non-geographic entity" calling codes
+        // inside `country_calling_codes` (for example, `"881":["001"]`).
+        // Now the semantics of `country_calling_codes` has changed:
+        // it's specifically for "countries" now.
+        // Older versions of custom metadata will simply skip parsing
+        // "non-geographic entity" phone numbers with new versions
+        // of this library: it's not considered a bug,
+        // because such numbers are extremely rare,
+        // and developers extremely rarely use custom metadata.
+        if (countryCodes.length === 1 && countryCodes[0].length === 3) {
+          return;
+        }
+
+        return countryCodes;
+      }
+    }
+  }, {
+    key: "getCountryCodeForCallingCode",
+    value: function getCountryCodeForCallingCode(callingCode) {
+      var countryCodes = this.getCountryCodesForCallingCode(callingCode);
+
+      if (countryCodes) {
+        return countryCodes[0];
+      }
+    }
+  }, {
+    key: "getNumberingPlanMetadata",
+    value: function getNumberingPlanMetadata(callingCode) {
+      var countryCode = this.getCountryCodeForCallingCode(callingCode);
+
+      if (countryCode) {
+        return this.getCountryMetadata(countryCode);
+      }
+
+      if (this.nonGeographic()) {
+        var metadata = this.nonGeographic()[callingCode];
+
+        if (metadata) {
+          return metadata;
+        }
+      } else {
+        // A hacky workaround for old custom metadata (generated before V4).
+        // In that metadata, there was no concept of "non-geographic" metadata
+        // so metadata for `001` country code was stored along with other countries.
+        // The test case can be found by searching for:
+        // "should work around `nonGeographic` metadata not existing".
+        var countryCodes = this.countryCallingCodes()[callingCode];
+
+        if (countryCodes && countryCodes.length === 1 && countryCodes[0] === '001') {
+          return this.metadata.countries['001'];
+        }
+      }
+    } // Deprecated.
+
+  }, {
+    key: "countryCallingCode",
+    value: function countryCallingCode() {
+      return this.numberingPlan.callingCode();
+    } // Deprecated.
+
+  }, {
+    key: "IDDPrefix",
+    value: function IDDPrefix() {
+      return this.numberingPlan.IDDPrefix();
+    } // Deprecated.
+
+  }, {
+    key: "defaultIDDPrefix",
+    value: function defaultIDDPrefix() {
+      return this.numberingPlan.defaultIDDPrefix();
+    } // Deprecated.
+
+  }, {
+    key: "nationalNumberPattern",
+    value: function nationalNumberPattern() {
+      return this.numberingPlan.nationalNumberPattern();
+    } // Deprecated.
+
+  }, {
+    key: "possibleLengths",
+    value: function possibleLengths() {
+      return this.numberingPlan.possibleLengths();
+    } // Deprecated.
+
+  }, {
+    key: "formats",
+    value: function formats() {
+      return this.numberingPlan.formats();
+    } // Deprecated.
+
+  }, {
+    key: "nationalPrefixForParsing",
+    value: function nationalPrefixForParsing() {
+      return this.numberingPlan.nationalPrefixForParsing();
+    } // Deprecated.
+
+  }, {
+    key: "nationalPrefixTransformRule",
+    value: function nationalPrefixTransformRule() {
+      return this.numberingPlan.nationalPrefixTransformRule();
+    } // Deprecated.
+
+  }, {
+    key: "leadingDigits",
+    value: function leadingDigits() {
+      return this.numberingPlan.leadingDigits();
+    } // Deprecated.
+
+  }, {
+    key: "hasTypes",
+    value: function hasTypes() {
+      return this.numberingPlan.hasTypes();
+    } // Deprecated.
+
+  }, {
+    key: "type",
+    value: function type(_type) {
+      return this.numberingPlan.type(_type);
+    } // Deprecated.
+
+  }, {
+    key: "ext",
+    value: function ext() {
+      return this.numberingPlan.ext();
+    }
+  }, {
+    key: "countryCallingCodes",
+    value: function countryCallingCodes() {
+      if (this.v1) return this.metadata.country_phone_code_to_countries;
+      return this.metadata.country_calling_codes;
+    } // Deprecated.
+
+  }, {
+    key: "chooseCountryByCountryCallingCode",
+    value: function chooseCountryByCountryCallingCode(callingCode) {
+      return this.selectNumberingPlan(callingCode);
+    }
+  }, {
+    key: "hasSelectedNumberingPlan",
+    value: function hasSelectedNumberingPlan() {
+      return this.numberingPlan !== undefined;
+    }
+  }]);
+
+  return Metadata;
+}();
+
+export { Metadata as default };
+
+var NumberingPlan = /*#__PURE__*/function () {
+  function NumberingPlan(metadata, globalMetadataObject) {
+    _classCallCheck(this, NumberingPlan);
+
+    this.globalMetadataObject = globalMetadataObject;
+    this.metadata = metadata;
+    setVersion.call(this, globalMetadataObject.metadata);
+  }
+
+  _createClass(NumberingPlan, [{
+    key: "callingCode",
+    value: function callingCode() {
+      return this.metadata[0];
+    } // Formatting information for regions which share
+    // a country calling code is contained by only one region
+    // for performance reasons. For example, for NANPA region
+    // ("North American Numbering Plan Administration",
+    //  which includes USA, Canada, Cayman Islands, Bahamas, etc)
+    // it will be contained in the metadata for `US`.
+
+  }, {
+    key: "getDefaultCountryMetadataForRegion",
+    value: function getDefaultCountryMetadataForRegion() {
+      return this.globalMetadataObject.getNumberingPlanMetadata(this.callingCode());
+    } // Is always present.
+
+  }, {
+    key: "IDDPrefix",
+    value: function IDDPrefix() {
+      if (this.v1 || this.v2) return;
+      return this.metadata[1];
+    } // Is only present when a country supports multiple IDD prefixes.
+
+  }, {
+    key: "defaultIDDPrefix",
+    value: function defaultIDDPrefix() {
+      if (this.v1 || this.v2) return;
+      return this.metadata[12];
+    }
+  }, {
+    key: "nationalNumberPattern",
+    value: function nationalNumberPattern() {
+      if (this.v1 || this.v2) return this.metadata[1];
+      return this.metadata[2];
+    } // "possible length" data is always present in Google's metadata.
+
+  }, {
+    key: "possibleLengths",
+    value: function possibleLengths() {
+      if (this.v1) return;
+      return this.metadata[this.v2 ? 2 : 3];
+    }
+  }, {
+    key: "_getFormats",
+    value: function _getFormats(metadata) {
+      return metadata[this.v1 ? 2 : this.v2 ? 3 : 4];
+    } // For countries of the same region (e.g. NANPA)
+    // formats are all stored in the "main" country for that region.
+    // E.g. "RU" and "KZ", "US" and "CA".
+
+  }, {
+    key: "formats",
+    value: function formats() {
+      var _this = this;
+
+      var formats = this._getFormats(this.metadata) || this._getFormats(this.getDefaultCountryMetadataForRegion()) || [];
+      return formats.map(function (_) {
+        return new Format(_, _this);
+      });
+    }
+  }, {
+    key: "nationalPrefix",
+    value: function nationalPrefix() {
+      return this.metadata[this.v1 ? 3 : this.v2 ? 4 : 5];
+    }
+  }, {
+    key: "_getNationalPrefixFormattingRule",
+    value: function _getNationalPrefixFormattingRule(metadata) {
+      return metadata[this.v1 ? 4 : this.v2 ? 5 : 6];
+    } // For countries of the same region (e.g. NANPA)
+    // national prefix formatting rule is stored in the "main" country for that region.
+    // E.g. "RU" and "KZ", "US" and "CA".
+
+  }, {
+    key: "nationalPrefixFormattingRule",
+    value: function nationalPrefixFormattingRule() {
+      return this._getNationalPrefixFormattingRule(this.metadata) || this._getNationalPrefixFormattingRule(this.getDefaultCountryMetadataForRegion());
+    }
+  }, {
+    key: "_nationalPrefixForParsing",
+    value: function _nationalPrefixForParsing() {
+      return this.metadata[this.v1 ? 5 : this.v2 ? 6 : 7];
+    }
+  }, {
+    key: "nationalPrefixForParsing",
+    value: function nationalPrefixForParsing() {
+      // If `national_prefix_for_parsing` is not set explicitly,
+      // then infer it from `national_prefix` (if any)
+      return this._nationalPrefixForParsing() || this.nationalPrefix();
+    }
+  }, {
+    key: "nationalPrefixTransformRule",
+    value: function nationalPrefixTransformRule() {
+      return this.metadata[this.v1 ? 6 : this.v2 ? 7 : 8];
+    }
+  }, {
+    key: "_getNationalPrefixIsOptionalWhenFormatting",
+    value: function _getNationalPrefixIsOptionalWhenFormatting() {
+      return !!this.metadata[this.v1 ? 7 : this.v2 ? 8 : 9];
+    } // For countries of the same region (e.g. NANPA)
+    // "national prefix is optional when formatting" flag is
+    // stored in the "main" country for that region.
+    // E.g. "RU" and "KZ", "US" and "CA".
+
+  }, {
+    key: "nationalPrefixIsOptionalWhenFormattingInNationalFormat",
+    value: function nationalPrefixIsOptionalWhenFormattingInNationalFormat() {
+      return this._getNationalPrefixIsOptionalWhenFormatting(this.metadata) || this._getNationalPrefixIsOptionalWhenFormatting(this.getDefaultCountryMetadataForRegion());
+    }
+  }, {
+    key: "leadingDigits",
+    value: function leadingDigits() {
+      return this.metadata[this.v1 ? 8 : this.v2 ? 9 : 10];
+    }
+  }, {
+    key: "types",
+    value: function types() {
+      return this.metadata[this.v1 ? 9 : this.v2 ? 10 : 11];
+    }
+  }, {
+    key: "hasTypes",
+    value: function hasTypes() {
+      // Versions 1.2.0 - 1.2.4: can be `[]`.
+
+      /* istanbul ignore next */
+      if (this.types() && this.types().length === 0) {
+        return false;
+      } // Versions <= 1.2.4: can be `undefined`.
+      // Version >= 1.2.5: can be `0`.
+
+
+      return !!this.types();
+    }
+  }, {
+    key: "type",
+    value: function type(_type2) {
+      if (this.hasTypes() && getType(this.types(), _type2)) {
+        return new Type(getType(this.types(), _type2), this);
+      }
+    }
+  }, {
+    key: "ext",
+    value: function ext() {
+      if (this.v1 || this.v2) return DEFAULT_EXT_PREFIX;
+      return this.metadata[13] || DEFAULT_EXT_PREFIX;
+    }
+  }]);
+
+  return NumberingPlan;
+}();
+
+var Format = /*#__PURE__*/function () {
+  function Format(format, metadata) {
+    _classCallCheck(this, Format);
+
+    this._format = format;
+    this.metadata = metadata;
+  }
+
+  _createClass(Format, [{
+    key: "pattern",
+    value: function pattern() {
+      return this._format[0];
+    }
+  }, {
+    key: "format",
+    value: function format() {
+      return this._format[1];
+    }
+  }, {
+    key: "leadingDigitsPatterns",
+    value: function leadingDigitsPatterns() {
+      return this._format[2] || [];
+    }
+  }, {
+    key: "nationalPrefixFormattingRule",
+    value: function nationalPrefixFormattingRule() {
+      return this._format[3] || this.metadata.nationalPrefixFormattingRule();
+    }
+  }, {
+    key: "nationalPrefixIsOptionalWhenFormattingInNationalFormat",
+    value: function nationalPrefixIsOptionalWhenFormattingInNationalFormat() {
+      return !!this._format[4] || this.metadata.nationalPrefixIsOptionalWhenFormattingInNationalFormat();
+    }
+  }, {
+    key: "nationalPrefixIsMandatoryWhenFormattingInNationalFormat",
+    value: function nationalPrefixIsMandatoryWhenFormattingInNationalFormat() {
+      // National prefix is omitted if there's no national prefix formatting rule
+      // set for this country, or when the national prefix formatting rule
+      // contains no national prefix itself, or when this rule is set but
+      // national prefix is optional for this phone number format
+      // (and it is not enforced explicitly)
+      return this.usesNationalPrefix() && !this.nationalPrefixIsOptionalWhenFormattingInNationalFormat();
+    } // Checks whether national prefix formatting rule contains national prefix.
+
+  }, {
+    key: "usesNationalPrefix",
+    value: function usesNationalPrefix() {
+      return this.nationalPrefixFormattingRule() && // Check that national prefix formatting rule is not a "dummy" one.
+      !FIRST_GROUP_ONLY_PREFIX_PATTERN.test(this.nationalPrefixFormattingRule()) // In compressed metadata, `this.nationalPrefixFormattingRule()` is `0`
+      // when `national_prefix_formatting_rule` is not present.
+      // So, `true` or `false` are returned explicitly here, so that
+      // `0` number isn't returned.
+      ? true : false;
+    }
+  }, {
+    key: "internationalFormat",
+    value: function internationalFormat() {
+      return this._format[5] || this.format();
+    }
+  }]);
+
+  return Format;
+}();
+/**
+ * A pattern that is used to determine if the national prefix formatting rule
+ * has the first group only, i.e., does not start with the national prefix.
+ * Note that the pattern explicitly allows for unbalanced parentheses.
+ */
+
+
+var FIRST_GROUP_ONLY_PREFIX_PATTERN = /^\(?\$1\)?$/;
+
+var Type = /*#__PURE__*/function () {
+  function Type(type, metadata) {
+    _classCallCheck(this, Type);
+
+    this.type = type;
+    this.metadata = metadata;
+  }
+
+  _createClass(Type, [{
+    key: "pattern",
+    value: function pattern() {
+      if (this.metadata.v1) return this.type;
+      return this.type[0];
+    }
+  }, {
+    key: "possibleLengths",
+    value: function possibleLengths() {
+      if (this.metadata.v1) return;
+      return this.type[1] || this.metadata.possibleLengths();
+    }
+  }]);
+
+  return Type;
+}();
+
+function getType(types, type) {
+  switch (type) {
+    case 'FIXED_LINE':
+      return types[0];
+
+    case 'MOBILE':
+      return types[1];
+
+    case 'TOLL_FREE':
+      return types[2];
+
+    case 'PREMIUM_RATE':
+      return types[3];
+
+    case 'PERSONAL_NUMBER':
+      return types[4];
+
+    case 'VOICEMAIL':
+      return types[5];
+
+    case 'UAN':
+      return types[6];
+
+    case 'PAGER':
+      return types[7];
+
+    case 'VOIP':
+      return types[8];
+
+    case 'SHARED_COST':
+      return types[9];
+  }
+}
+
+export function validateMetadata(metadata) {
+  if (!metadata) {
+    throw new Error('[libphonenumber-js] `metadata` argument not passed. Check your arguments.');
+  } // `country_phone_code_to_countries` was renamed to
+  // `country_calling_codes` in `1.0.18`.
+
+
+  if (!is_object(metadata) || !is_object(metadata.countries)) {
+    throw new Error("[libphonenumber-js] `metadata` argument was passed but it's not a valid metadata. Must be an object having `.countries` child object property. Got ".concat(is_object(metadata) ? 'an object of shape: { ' + Object.keys(metadata).join(', ') + ' }' : 'a ' + type_of(metadata) + ': ' + metadata, "."));
+  }
+} // Babel transforms `typeof` into some "branches"
+// so istanbul will show this as "branch not covered".
+
+/* istanbul ignore next */
+
+var is_object = function is_object(_) {
+  return _typeof(_) === 'object';
+}; // Babel transforms `typeof` into some "branches"
+// so istanbul will show this as "branch not covered".
+
+/* istanbul ignore next */
+
+
+var type_of = function type_of(_) {
+  return _typeof(_);
+};
+/**
+ * Returns extension prefix for a country.
+ * @param  {string} country
+ * @param  {object} metadata
+ * @return {string?}
+ * @example
+ * // Returns " ext. "
+ * getExtPrefix("US")
+ */
+
+
+export function getExtPrefix(country, metadata) {
+  metadata = new Metadata(metadata);
+
+  if (metadata.hasCountry(country)) {
+    return metadata.country(country).ext();
+  }
+
+  return DEFAULT_EXT_PREFIX;
+}
+/**
+ * Returns "country calling code" for a country.
+ * Throws an error if the country doesn't exist or isn't supported by this library.
+ * @param  {string} country
+ * @param  {object} metadata
+ * @return {string}
+ * @example
+ * // Returns "44"
+ * getCountryCallingCode("GB")
+ */
+
+export function getCountryCallingCode(country, metadata) {
+  metadata = new Metadata(metadata);
+
+  if (metadata.hasCountry(country)) {
+    return metadata.country(country).countryCallingCode();
+  }
+
+  throw new Error("Unknown country: ".concat(country));
+}
+export function isSupportedCountry(country, metadata) {
+  // metadata = new Metadata(metadata)
+  // return metadata.hasCountry(country)
+  return metadata.countries[country] !== undefined;
+}
+
+function setVersion(metadata) {
+  var version = metadata.version;
+
+  if (typeof version === 'number') {
+    this.v1 = version === 1;
+    this.v2 = version === 2;
+    this.v3 = version === 3;
+    this.v4 = version === 4;
+  } else {
+    if (!version) {
+      this.v1 = true;
+    } else if (compare(version, V3) === -1) {
+      this.v2 = true;
+    } else if (compare(version, V4) === -1) {
+      this.v3 = true;
+    } else {
+      this.v4 = true;
+    }
+  }
+} // const ISO_COUNTRY_CODE = /^[A-Z]{2}$/
+// function isCountryCode(countryCode) {
+// 	return ISO_COUNTRY_CODE.test(countryCodeOrCountryCallingCode)
+// }
+//# sourceMappingURL=metadata.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/normalizeArguments.js b/parent_dir/node_modules/libphonenumber-js/es6/normalizeArguments.js
new file mode 100644
index 0000000..5e18407
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/normalizeArguments.js
@@ -0,0 +1,81 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+// Extracts the following properties from function arguments:
+// * input `text`
+// * `options` object
+// * `metadata` JSON
+export default function normalizeArguments(args) {
+  var _Array$prototype$slic = Array.prototype.slice.call(args),
+      _Array$prototype$slic2 = _slicedToArray(_Array$prototype$slic, 4),
+      arg_1 = _Array$prototype$slic2[0],
+      arg_2 = _Array$prototype$slic2[1],
+      arg_3 = _Array$prototype$slic2[2],
+      arg_4 = _Array$prototype$slic2[3];
+
+  var text;
+  var options;
+  var metadata; // If the phone number is passed as a string.
+  // `parsePhoneNumber('88005553535', ...)`.
+
+  if (typeof arg_1 === 'string') {
+    text = arg_1;
+  } else throw new TypeError('A text for parsing must be a string.'); // If "default country" argument is being passed then move it to `options`.
+  // `parsePhoneNumber('88005553535', 'RU', [options], metadata)`.
+
+
+  if (!arg_2 || typeof arg_2 === 'string') {
+    if (arg_4) {
+      options = arg_3;
+      metadata = arg_4;
+    } else {
+      options = undefined;
+      metadata = arg_3;
+    }
+
+    if (arg_2) {
+      options = _objectSpread({
+        defaultCountry: arg_2
+      }, options);
+    }
+  } // `defaultCountry` is not passed.
+  // Example: `parsePhoneNumber('+78005553535', [options], metadata)`.
+  else if (isObject(arg_2)) {
+    if (arg_3) {
+      options = arg_2;
+      metadata = arg_3;
+    } else {
+      metadata = arg_2;
+    }
+  } else throw new Error("Invalid second argument: ".concat(arg_2));
+
+  return {
+    text: text,
+    options: options,
+    metadata: metadata
+  };
+} // Otherwise istanbul would show this as "branch not covered".
+
+/* istanbul ignore next */
+
+var isObject = function isObject(_) {
+  return _typeof(_) === 'object';
+};
+//# sourceMappingURL=normalizeArguments.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/parse.js b/parent_dir/node_modules/libphonenumber-js/es6/parse.js
new file mode 100644
index 0000000..271e26f
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/parse.js
@@ -0,0 +1,361 @@
+// This is a port of Google Android `libphonenumber`'s
+// `phonenumberutil.js` of December 31th, 2018.
+//
+// https://github.com/googlei18n/libphonenumber/commits/master/javascript/i18n/phonenumbers/phonenumberutil.js
+import { VALID_DIGITS, PLUS_CHARS, MIN_LENGTH_FOR_NSN, MAX_LENGTH_FOR_NSN } from './constants.js';
+import ParseError from './ParseError.js';
+import Metadata from './metadata.js';
+import isViablePhoneNumber, { isViablePhoneNumberStart } from './helpers/isViablePhoneNumber.js';
+import extractExtension from './helpers/extension/extractExtension.js';
+import parseIncompletePhoneNumber from './parseIncompletePhoneNumber.js';
+import getCountryCallingCode from './getCountryCallingCode.js';
+import { isPossibleNumber } from './isPossible.js'; // import { parseRFC3966 } from './helpers/RFC3966.js'
+
+import PhoneNumber from './PhoneNumber.js';
+import matchesEntirely from './helpers/matchesEntirely.js';
+import extractCountryCallingCode from './helpers/extractCountryCallingCode.js';
+import extractNationalNumber from './helpers/extractNationalNumber.js';
+import stripIddPrefix from './helpers/stripIddPrefix.js';
+import getCountryByCallingCode from './helpers/getCountryByCallingCode.js';
+import extractFormattedPhoneNumberFromPossibleRfc3966NumberUri from './helpers/extractFormattedPhoneNumberFromPossibleRfc3966NumberUri.js'; // We don't allow input strings for parsing to be longer than 250 chars.
+// This prevents malicious input from consuming CPU.
+
+var MAX_INPUT_STRING_LENGTH = 250; // This consists of the plus symbol, digits, and arabic-indic digits.
+
+var PHONE_NUMBER_START_PATTERN = new RegExp('[' + PLUS_CHARS + VALID_DIGITS + ']'); // Regular expression of trailing characters that we want to remove.
+// A trailing `#` is sometimes used when writing phone numbers with extensions in US.
+// Example: "+1 (645) 123 1234-910#" number has extension "910".
+
+var AFTER_PHONE_NUMBER_END_PATTERN = new RegExp('[^' + VALID_DIGITS + '#' + ']+$');
+var USE_NON_GEOGRAPHIC_COUNTRY_CODE = false; // Examples:
+//
+// ```js
+// parse('8 (800) 555-35-35', 'RU')
+// parse('8 (800) 555-35-35', 'RU', metadata)
+// parse('8 (800) 555-35-35', { country: { default: 'RU' } })
+// parse('8 (800) 555-35-35', { country: { default: 'RU' } }, metadata)
+// parse('+7 800 555 35 35')
+// parse('+7 800 555 35 35', metadata)
+// ```
+//
+
+/**
+ * Parses a phone number.
+ *
+ * parse('123456789', { defaultCountry: 'RU', v2: true }, metadata)
+ * parse('123456789', { defaultCountry: 'RU' }, metadata)
+ * parse('123456789', undefined, metadata)
+ *
+ * @param  {string} input
+ * @param  {object} [options]
+ * @param  {object} metadata
+ * @return {object|PhoneNumber?} If `options.v2: true` flag is passed, it returns a `PhoneNumber?` instance. Otherwise, returns an object of shape `{ phone: '...', country: '...' }` (or just `{}` if no phone number was parsed).
+ */
+
+export default function parse(text, options, metadata) {
+  // If assigning the `{}` default value is moved to the arguments above,
+  // code coverage would decrease for some weird reason.
+  options = options || {};
+  metadata = new Metadata(metadata); // Validate `defaultCountry`.
+
+  if (options.defaultCountry && !metadata.hasCountry(options.defaultCountry)) {
+    if (options.v2) {
+      throw new ParseError('INVALID_COUNTRY');
+    }
+
+    throw new Error("Unknown country: ".concat(options.defaultCountry));
+  } // Parse the phone number.
+
+
+  var _parseInput = parseInput(text, options.v2, options.extract),
+      formattedPhoneNumber = _parseInput.number,
+      ext = _parseInput.ext,
+      error = _parseInput.error; // If the phone number is not viable then return nothing.
+
+
+  if (!formattedPhoneNumber) {
+    if (options.v2) {
+      if (error === 'TOO_SHORT') {
+        throw new ParseError('TOO_SHORT');
+      }
+
+      throw new ParseError('NOT_A_NUMBER');
+    }
+
+    return {};
+  }
+
+  var _parsePhoneNumber = parsePhoneNumber(formattedPhoneNumber, options.defaultCountry, options.defaultCallingCode, metadata),
+      country = _parsePhoneNumber.country,
+      nationalNumber = _parsePhoneNumber.nationalNumber,
+      countryCallingCode = _parsePhoneNumber.countryCallingCode,
+      countryCallingCodeSource = _parsePhoneNumber.countryCallingCodeSource,
+      carrierCode = _parsePhoneNumber.carrierCode;
+
+  if (!metadata.hasSelectedNumberingPlan()) {
+    if (options.v2) {
+      throw new ParseError('INVALID_COUNTRY');
+    }
+
+    return {};
+  } // Validate national (significant) number length.
+
+
+  if (!nationalNumber || nationalNumber.length < MIN_LENGTH_FOR_NSN) {
+    // Won't throw here because the regexp already demands length > 1.
+
+    /* istanbul ignore if */
+    if (options.v2) {
+      throw new ParseError('TOO_SHORT');
+    } // Google's demo just throws an error in this case.
+
+
+    return {};
+  } // Validate national (significant) number length.
+  //
+  // A sidenote:
+  //
+  // They say that sometimes national (significant) numbers
+  // can be longer than `MAX_LENGTH_FOR_NSN` (e.g. in Germany).
+  // https://github.com/googlei18n/libphonenumber/blob/7e1748645552da39c4e1ba731e47969d97bdb539/resources/phonenumber.proto#L36
+  // Such numbers will just be discarded.
+  //
+
+
+  if (nationalNumber.length > MAX_LENGTH_FOR_NSN) {
+    if (options.v2) {
+      throw new ParseError('TOO_LONG');
+    } // Google's demo just throws an error in this case.
+
+
+    return {};
+  }
+
+  if (options.v2) {
+    var phoneNumber = new PhoneNumber(countryCallingCode, nationalNumber, metadata.metadata);
+
+    if (country) {
+      phoneNumber.country = country;
+    }
+
+    if (carrierCode) {
+      phoneNumber.carrierCode = carrierCode;
+    }
+
+    if (ext) {
+      phoneNumber.ext = ext;
+    }
+
+    phoneNumber.__countryCallingCodeSource = countryCallingCodeSource;
+    return phoneNumber;
+  } // Check if national phone number pattern matches the number.
+  // National number pattern is different for each country,
+  // even for those ones which are part of the "NANPA" group.
+
+
+  var valid = (options.extended ? metadata.hasSelectedNumberingPlan() : country) ? matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) : false;
+
+  if (!options.extended) {
+    return valid ? result(country, nationalNumber, ext) : {};
+  } // isInternational: countryCallingCode !== undefined
+
+
+  return {
+    country: country,
+    countryCallingCode: countryCallingCode,
+    carrierCode: carrierCode,
+    valid: valid,
+    possible: valid ? true : options.extended === true && metadata.possibleLengths() && isPossibleNumber(nationalNumber, metadata) ? true : false,
+    phone: nationalNumber,
+    ext: ext
+  };
+}
+/**
+ * Extracts a formatted phone number from text.
+ * Doesn't guarantee that the extracted phone number
+ * is a valid phone number (for example, doesn't validate its length).
+ * @param  {string} text
+ * @param  {boolean} [extract] — If `false`, then will parse the entire `text` as a phone number.
+ * @param  {boolean} [throwOnError] — By default, it won't throw if the text is too long.
+ * @return {string}
+ * @example
+ * // Returns "(213) 373-4253".
+ * extractFormattedPhoneNumber("Call (213) 373-4253 for assistance.")
+ */
+
+function _extractFormattedPhoneNumber(text, extract, throwOnError) {
+  if (!text) {
+    return;
+  }
+
+  if (text.length > MAX_INPUT_STRING_LENGTH) {
+    if (throwOnError) {
+      throw new ParseError('TOO_LONG');
+    }
+
+    return;
+  }
+
+  if (extract === false) {
+    return text;
+  } // Attempt to extract a possible number from the string passed in
+
+
+  var startsAt = text.search(PHONE_NUMBER_START_PATTERN);
+
+  if (startsAt < 0) {
+    return;
+  }
+
+  return text // Trim everything to the left of the phone number
+  .slice(startsAt) // Remove trailing non-numerical characters
+  .replace(AFTER_PHONE_NUMBER_END_PATTERN, '');
+}
+/**
+ * @param  {string} text - Input.
+ * @param  {boolean} v2 - Legacy API functions don't pass `v2: true` flag.
+ * @param  {boolean} [extract] - Whether to extract a phone number from `text`, or attempt to parse the entire text as a phone number.
+ * @return {object} `{ ?number, ?ext }`.
+ */
+
+
+function parseInput(text, v2, extract) {
+  // // Parse RFC 3966 phone number URI.
+  // if (text && text.indexOf('tel:') === 0) {
+  // 	return parseRFC3966(text)
+  // }
+  // let number = extractFormattedPhoneNumber(text, extract, v2)
+  var number = extractFormattedPhoneNumberFromPossibleRfc3966NumberUri(text, {
+    extractFormattedPhoneNumber: function extractFormattedPhoneNumber(text) {
+      return _extractFormattedPhoneNumber(text, extract, v2);
+    }
+  }); // If the phone number is not viable, then abort.
+
+  if (!number) {
+    return {};
+  }
+
+  if (!isViablePhoneNumber(number)) {
+    if (isViablePhoneNumberStart(number)) {
+      return {
+        error: 'TOO_SHORT'
+      };
+    }
+
+    return {};
+  } // Attempt to parse extension first, since it doesn't require region-specific
+  // data and we want to have the non-normalised number here.
+
+
+  var withExtensionStripped = extractExtension(number);
+
+  if (withExtensionStripped.ext) {
+    return withExtensionStripped;
+  }
+
+  return {
+    number: number
+  };
+}
+/**
+ * Creates `parse()` result object.
+ */
+
+
+function result(country, nationalNumber, ext) {
+  var result = {
+    country: country,
+    phone: nationalNumber
+  };
+
+  if (ext) {
+    result.ext = ext;
+  }
+
+  return result;
+}
+/**
+ * Parses a viable phone number.
+ * @param {string} formattedPhoneNumber — Example: "(213) 373-4253".
+ * @param {string} [defaultCountry]
+ * @param {string} [defaultCallingCode]
+ * @param {Metadata} metadata
+ * @return {object} Returns `{ country: string?, countryCallingCode: string?, nationalNumber: string? }`.
+ */
+
+
+function parsePhoneNumber(formattedPhoneNumber, defaultCountry, defaultCallingCode, metadata) {
+  // Extract calling code from phone number.
+  var _extractCountryCallin = extractCountryCallingCode(parseIncompletePhoneNumber(formattedPhoneNumber), defaultCountry, defaultCallingCode, metadata.metadata),
+      countryCallingCodeSource = _extractCountryCallin.countryCallingCodeSource,
+      countryCallingCode = _extractCountryCallin.countryCallingCode,
+      number = _extractCountryCallin.number; // Choose a country by `countryCallingCode`.
+
+
+  var country;
+
+  if (countryCallingCode) {
+    metadata.selectNumberingPlan(countryCallingCode);
+  } // If `formattedPhoneNumber` is passed in "national" format
+  // then `number` is defined and `countryCallingCode` is `undefined`.
+  else if (number && (defaultCountry || defaultCallingCode)) {
+    metadata.selectNumberingPlan(defaultCountry, defaultCallingCode);
+
+    if (defaultCountry) {
+      country = defaultCountry;
+    } else {
+      /* istanbul ignore if */
+      if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {
+        if (metadata.isNonGeographicCallingCode(defaultCallingCode)) {
+          country = '001';
+        }
+      }
+    }
+
+    countryCallingCode = defaultCallingCode || getCountryCallingCode(defaultCountry, metadata.metadata);
+  } else return {};
+
+  if (!number) {
+    return {
+      countryCallingCodeSource: countryCallingCodeSource,
+      countryCallingCode: countryCallingCode
+    };
+  }
+
+  var _extractNationalNumbe = extractNationalNumber(parseIncompletePhoneNumber(number), metadata),
+      nationalNumber = _extractNationalNumbe.nationalNumber,
+      carrierCode = _extractNationalNumbe.carrierCode; // Sometimes there are several countries
+  // corresponding to the same country phone code
+  // (e.g. NANPA countries all having `1` country phone code).
+  // Therefore, to reliably determine the exact country,
+  // national (significant) number should have been parsed first.
+  //
+  // When `metadata.json` is generated, all "ambiguous" country phone codes
+  // get their countries populated with the full set of
+  // "phone number type" regular expressions.
+  //
+
+
+  var exactCountry = getCountryByCallingCode(countryCallingCode, nationalNumber, metadata);
+
+  if (exactCountry) {
+    country = exactCountry;
+    /* istanbul ignore if */
+
+    if (exactCountry === '001') {// Can't happen with `USE_NON_GEOGRAPHIC_COUNTRY_CODE` being `false`.
+      // If `USE_NON_GEOGRAPHIC_COUNTRY_CODE` is set to `true` for some reason,
+      // then remove the "istanbul ignore if".
+    } else {
+      metadata.country(country);
+    }
+  }
+
+  return {
+    country: country,
+    countryCallingCode: countryCallingCode,
+    countryCallingCodeSource: countryCallingCodeSource,
+    nationalNumber: nationalNumber,
+    carrierCode: carrierCode
+  };
+}
+//# sourceMappingURL=parse.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/parseIncompletePhoneNumber.js b/parent_dir/node_modules/libphonenumber-js/es6/parseIncompletePhoneNumber.js
new file mode 100644
index 0000000..8e65327
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/parseIncompletePhoneNumber.js
@@ -0,0 +1,66 @@
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+import { parseDigit } from './helpers/parseDigits.js';
+/**
+ * Parses phone number characters from a string.
+ * Drops all punctuation leaving only digits and the leading `+` sign (if any).
+ * Also converts wide-ascii and arabic-indic numerals to conventional numerals.
+ * E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.
+ * @param  {string} string
+ * @return {string}
+ * @example
+ * ```js
+ * // Outputs '8800555'.
+ * parseIncompletePhoneNumber('8 (800) 555')
+ * // Outputs '+7800555'.
+ * parseIncompletePhoneNumber('+7 800 555')
+ * ```
+ */
+
+export default function parseIncompletePhoneNumber(string) {
+  var result = ''; // Using `.split('')` here instead of normal `for ... of`
+  // because the importing application doesn't neccessarily include an ES6 polyfill.
+  // The `.split('')` approach discards "exotic" UTF-8 characters
+  // (the ones consisting of four bytes) but digits
+  // (including non-European ones) don't fall into that range
+  // so such "exotic" characters would be discarded anyway.
+
+  for (var _iterator = _createForOfIteratorHelperLoose(string.split('')), _step; !(_step = _iterator()).done;) {
+    var character = _step.value;
+    result += parsePhoneNumberCharacter(character, result) || '';
+  }
+
+  return result;
+}
+/**
+ * Parses next character while parsing phone number digits (including a `+`)
+ * from text: discards everything except `+` and digits, and `+` is only allowed
+ * at the start of a phone number.
+ * For example, is used in `react-phone-number-input` where it uses
+ * [`input-format`](https://gitlab.com/catamphetamine/input-format).
+ * @param  {string} character - Yet another character from raw input string.
+ * @param  {string?} prevParsedCharacters - Previous parsed characters.
+ * @param  {object} meta - Optional custom use-case-specific metadata.
+ * @return {string?} The parsed character.
+ */
+
+export function parsePhoneNumberCharacter(character, prevParsedCharacters) {
+  // Only allow a leading `+`.
+  if (character === '+') {
+    // If this `+` is not the first parsed character
+    // then discard it.
+    if (prevParsedCharacters) {
+      return;
+    }
+
+    return '+';
+  } // Allow digits.
+
+
+  return parseDigit(character);
+}
+//# sourceMappingURL=parseIncompletePhoneNumber.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/parsePhoneNumber.js b/parent_dir/node_modules/libphonenumber-js/es6/parsePhoneNumber.js
new file mode 100644
index 0000000..9ac6d18
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/parsePhoneNumber.js
@@ -0,0 +1,11 @@
+import normalizeArguments from './normalizeArguments.js';
+import parsePhoneNumber_ from './parsePhoneNumber_.js';
+export default function parsePhoneNumber() {
+  var _normalizeArguments = normalizeArguments(arguments),
+      text = _normalizeArguments.text,
+      options = _normalizeArguments.options,
+      metadata = _normalizeArguments.metadata;
+
+  return parsePhoneNumber_(text, options, metadata);
+}
+//# sourceMappingURL=parsePhoneNumber.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/parsePhoneNumberWithError_.js b/parent_dir/node_modules/libphonenumber-js/es6/parsePhoneNumberWithError_.js
new file mode 100644
index 0000000..50aab67
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/parsePhoneNumberWithError_.js
@@ -0,0 +1,13 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(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; }
+
+import parse from './parse.js';
+export default function parsePhoneNumberWithError(text, options, metadata) {
+  return parse(text, _objectSpread(_objectSpread({}, options), {}, {
+    v2: true
+  }), metadata);
+}
+//# sourceMappingURL=parsePhoneNumberWithError_.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/parsePhoneNumber_.js b/parent_dir/node_modules/libphonenumber-js/es6/parsePhoneNumber_.js
new file mode 100644
index 0000000..e77550e
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/parsePhoneNumber_.js
@@ -0,0 +1,29 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(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; }
+
+import parsePhoneNumberWithError from './parsePhoneNumberWithError_.js';
+import ParseError from './ParseError.js';
+import { isSupportedCountry } from './metadata.js';
+export default function parsePhoneNumber(text, options, metadata) {
+  // Validate `defaultCountry`.
+  if (options && options.defaultCountry && !isSupportedCountry(options.defaultCountry, metadata)) {
+    options = _objectSpread(_objectSpread({}, options), {}, {
+      defaultCountry: undefined
+    });
+  } // Parse phone number.
+
+
+  try {
+    return parsePhoneNumberWithError(text, options, metadata);
+  } catch (error) {
+    /* istanbul ignore else */
+    if (error instanceof ParseError) {//
+    } else {
+      throw error;
+    }
+  }
+}
+//# sourceMappingURL=parsePhoneNumber_.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/es6/tools/semver-compare.js b/parent_dir/node_modules/libphonenumber-js/es6/tools/semver-compare.js
new file mode 100644
index 0000000..f9c0b0e
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/es6/tools/semver-compare.js
@@ -0,0 +1,30 @@
+// Copy-pasted from:
+// https://github.com/substack/semver-compare/blob/master/index.js
+//
+// Inlining this function because some users reported issues with
+// importing from `semver-compare` in a browser with ES6 "native" modules.
+//
+// Fixes `semver-compare` not being able to compare versions with alpha/beta/etc "tags".
+// https://github.com/catamphetamine/libphonenumber-js/issues/381
+export default function (a, b) {
+  a = a.split('-');
+  b = b.split('-');
+  var pa = a[0].split('.');
+  var pb = b[0].split('.');
+
+  for (var i = 0; i < 3; i++) {
+    var na = Number(pa[i]);
+    var nb = Number(pb[i]);
+    if (na > nb) return 1;
+    if (nb > na) return -1;
+    if (!isNaN(na) && isNaN(nb)) return 1;
+    if (isNaN(na) && !isNaN(nb)) return -1;
+  }
+
+  if (a[1] && b[1]) {
+    return a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0;
+  }
+
+  return !a[1] && b[1] ? 1 : a[1] && !b[1] ? -1 : 0;
+}
+//# sourceMappingURL=semver-compare.js.map
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/max/exports/parsePhoneNumber.js b/parent_dir/node_modules/libphonenumber-js/max/exports/parsePhoneNumber.js
new file mode 100644
index 0000000..fefb661
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/max/exports/parsePhoneNumber.js
@@ -0,0 +1,6 @@
+import withMetadataArgument from './withMetadataArgument.js'
+import { default as _parsePhoneNumber } from '../../core/index.js'
+
+export function parsePhoneNumber() {
+	return withMetadataArgument(_parsePhoneNumber, arguments)
+}
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/max/exports/withMetadataArgument.js b/parent_dir/node_modules/libphonenumber-js/max/exports/withMetadataArgument.js
new file mode 100644
index 0000000..fe97cef
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/max/exports/withMetadataArgument.js
@@ -0,0 +1,9 @@
+// Importing from a ".js" file is a workaround for Node.js "ES Modules"
+// importing system which is even uncapable of importing "*.json" files.
+import metadata from '../../metadata.max.json.js'
+
+export default function withMetadataArgument(func, _arguments) {
+	var args = Array.prototype.slice.call(_arguments)
+	args.push(metadata)
+	return func.apply(this, args)
+}
\ No newline at end of file
diff --git a/parent_dir/node_modules/libphonenumber-js/metadata.max.json.js b/parent_dir/node_modules/libphonenumber-js/metadata.max.json.js
new file mode 100644
index 0000000..88febd7
--- /dev/null
+++ b/parent_dir/node_modules/libphonenumber-js/metadata.max.json.js
@@ -0,0 +1,4 @@
+// This file is a workaround for a bug in web browsers' "native"
+// ES6 importing system which is uncapable of importing "*.json" files.
+// https://github.com/catamphetamine/libphonenumber-js/issues/239
+export default {"version":4,"country_calling_codes":{"1":["US","AG","AI","AS","BB","BM","BS","CA","DM","DO","GD","GU","JM","KN","KY","LC","MP","MS","PR","SX","TC","TT","VC","VG","VI"],"7":["RU","KZ"],"20":["EG"],"27":["ZA"],"30":["GR"],"31":["NL"],"32":["BE"],"33":["FR"],"34":["ES"],"36":["HU"],"39":["IT","VA"],"40":["RO"],"41":["CH"],"43":["AT"],"44":["GB","GG","IM","JE"],"45":["DK"],"46":["SE"],"47":["NO","SJ"],"48":["PL"],"49":["DE"],"51":["PE"],"52":["MX"],"53":["CU"],"54":["AR"],"55":["BR"],"56":["CL"],"57":["CO"],"58":["VE"],"60":["MY"],"61":["AU","CC","CX"],"62":["ID"],"63":["PH"],"64":["NZ"],"65":["SG"],"66":["TH"],"81":["JP"],"82":["KR"],"84":["VN"],"86":["CN"],"90":["TR"],"91":["IN"],"92":["PK"],"93":["AF"],"94":["LK"],"95":["MM"],"98":["IR"],"211":["SS"],"212":["MA","EH"],"213":["DZ"],"216":["TN"],"218":["LY"],"220":["GM"],"221":["SN"],"222":["MR"],"223":["ML"],"224":["GN"],"225":["CI"],"226":["BF"],"227":["NE"],"228":["TG"],"229":["BJ"],"230":["MU"],"231":["LR"],"232":["SL"],"233":["GH"],"234":["NG"],"235":["TD"],"236":["CF"],"237":["CM"],"238":["CV"],"239":["ST"],"240":["GQ"],"241":["GA"],"242":["CG"],"243":["CD"],"244":["AO"],"245":["GW"],"246":["IO"],"247":["AC"],"248":["SC"],"249":["SD"],"250":["RW"],"251":["ET"],"252":["SO"],"253":["DJ"],"254":["KE"],"255":["TZ"],"256":["UG"],"257":["BI"],"258":["MZ"],"260":["ZM"],"261":["MG"],"262":["RE","YT"],"263":["ZW"],"264":["NA"],"265":["MW"],"266":["LS"],"267":["BW"],"268":["SZ"],"269":["KM"],"290":["SH","TA"],"291":["ER"],"297":["AW"],"298":["FO"],"299":["GL"],"350":["GI"],"351":["PT"],"352":["LU"],"353":["IE"],"354":["IS"],"355":["AL"],"356":["MT"],"357":["CY"],"358":["FI","AX"],"359":["BG"],"370":["LT"],"371":["LV"],"372":["EE"],"373":["MD"],"374":["AM"],"375":["BY"],"376":["AD"],"377":["MC"],"378":["SM"],"380":["UA"],"381":["RS"],"382":["ME"],"383":["XK"],"385":["HR"],"386":["SI"],"387":["BA"],"389":["MK"],"420":["CZ"],"421":["SK"],"423":["LI"],"500":["FK"],"501":["BZ"],"502":["GT"],"503":["SV"],"504":["HN"],"505":["NI"],"506":["CR"],"507":["PA"],"508":["PM"],"509":["HT"],"590":["GP","BL","MF"],"591":["BO"],"592":["GY"],"593":["EC"],"594":["GF"],"595":["PY"],"596":["MQ"],"597":["SR"],"598":["UY"],"599":["CW","BQ"],"670":["TL"],"672":["NF"],"673":["BN"],"674":["NR"],"675":["PG"],"676":["TO"],"677":["SB"],"678":["VU"],"679":["FJ"],"680":["PW"],"681":["WF"],"682":["CK"],"683":["NU"],"685":["WS"],"686":["KI"],"687":["NC"],"688":["TV"],"689":["PF"],"690":["TK"],"691":["FM"],"692":["MH"],"850":["KP"],"852":["HK"],"853":["MO"],"855":["KH"],"856":["LA"],"880":["BD"],"886":["TW"],"960":["MV"],"961":["LB"],"962":["JO"],"963":["SY"],"964":["IQ"],"965":["KW"],"966":["SA"],"967":["YE"],"968":["OM"],"970":["PS"],"971":["AE"],"972":["IL"],"973":["BH"],"974":["QA"],"975":["BT"],"976":["MN"],"977":["NP"],"992":["TJ"],"993":["TM"],"994":["AZ"],"995":["GE"],"996":["KG"],"998":["UZ"]},"countries":{"AC":["247","00","(?:[01589]\\d|[46])\\d{4}",[5,6],0,0,0,0,0,0,0,[["6[2-467]\\d{3}",[5]],["4\\d{4}",[5]],0,0,0,0,["(?:0[1-9]|[1589]\\d)\\d{4}",[6]]]],"AD":["376","00","(?:1|6\\d)\\d{7}|[135-9]\\d{5}",[6,8,9],[["(\\d{3})(\\d{3})","$1 $2",["[135-9]"]],["(\\d{4})(\\d{4})","$1 $2",["1"]],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["6"]]],0,0,0,0,0,0,[["[78]\\d{5}",[6]],["690\\d{6}|[356]\\d{5}",[6,9]],["180[02]\\d{4}",[8]],["[19]\\d{5}",[6]]]],"AE":["971","00","(?:[4-7]\\d|9[0-689])\\d{7}|800\\d{2,9}|[2-4679]\\d{7}",[5,6,7,8,9,10,11,12],[["(\\d{3})(\\d{2,9})","$1 $2",["60|8"]],["(\\d)(\\d{3})(\\d{4})","$1 $2 $3",["[236]|[479][2-8]"],"0$1"],["(\\d{3})(\\d)(\\d{5})","$1 $2 $3",["[479]"]],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["5"],"0$1"]],"0",0,0,0,0,0,[["[2-4679][2-8]\\d{6}",[8]],["5[024-68]\\d{7}",[9]],["400\\d{6}|800\\d{2,9}"],["900[02]\\d{5}",[9]],0,0,["600[25]\\d{5}",[9]],0,0,["700[05]\\d{5}",[9]]]],"AF":["93","00","[2-7]\\d{8}",[9],[["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["[2-7]"],"0$1"]],"0",0,0,0,0,0,[["(?:[25][0-8]|[34][0-4]|6[0-5])[2-9]\\d{6}"],["7\\d{8}"]]],"AG":["1","011","(?:268|[58]\\d\\d|900)\\d{7}",[10],0,"1",0,"([457]\\d{6})$|1","268$1",0,"268",[["268(?:4(?:6[0-38]|84)|56[0-2])\\d{4}"],["268(?:464|7(?:1[3-9]|[28]\\d|3[0246]|64|7[0-689]))\\d{4}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"],0,0,["26840[69]\\d{4}"],["26848[01]\\d{4}"]]],"AI":["1","011","(?:264|[58]\\d\\d|900)\\d{7}",[10],0,"1",0,"([2457]\\d{6})$|1","264$1",0,"264",[["264(?:292|4(?:6[12]|9[78]))\\d{4}"],["264(?:235|4(?:69|76)|5(?:3[6-9]|8[1-4])|7(?:29|72))\\d{4}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"],0,0,["264724\\d{4}"]]],"AL":["355","00","(?:700\\d\\d|900)\\d{3}|8\\d{5,7}|(?:[2-5]|6\\d)\\d{7}",[6,7,8,9],[["(\\d{3})(\\d{3,4})","$1 $2",["80|9"],"0$1"],["(\\d)(\\d{3})(\\d{4})","$1 $2 $3",["4[2-6]"],"0$1"],["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["[2358][2-5]|4"],"0$1"],["(\\d{3})(\\d{5})","$1 $2",["[23578]"],"0$1"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["6"],"0$1"]],"0",0,0,0,0,0,[["4505[0-2]\\d{3}|(?:[2358][16-9]\\d[2-9]|4410)\\d{4}|(?:[2358][2-5][2-9]|4(?:[2-57-9][2-9]|6\\d))\\d{5}",[8]],["6(?:[78][2-9]|9\\d)\\d{6}",[9]],["800\\d{4}",[7]],["900[1-9]\\d\\d",[6]],["700[2-9]\\d{4}",[8]],0,0,0,0,["808[1-9]\\d\\d",[6]]]],"AM":["374","00","(?:[1-489]\\d|55|60|77)\\d{6}",[8],[["(\\d{3})(\\d{2})(\\d{3})","$1 $2 $3",["[89]0"],"0 $1"],["(\\d{3})(\\d{5})","$1 $2",["2|3[12]"],"(0$1)"],["(\\d{2})(\\d{6})","$1 $2",["1|47"],"(0$1)"],["(\\d{2})(\\d{6})","$1 $2",["[3-9]"],"0$1"]],"0",0,0,0,0,0,[["(?:(?:1[0-25]|47)\\d|2(?:2[2-46]|3[1-8]|4[2-69]|5[2-7]|6[1-9]|8[1-7])|3[12]2)\\d{5}"],["(?:33|4[1349]|55|77|88|9[13-9])\\d{6}"],["800\\d{5}"],["90[016]\\d{5}"],0,0,0,0,["60(?:2[78]|3[5-9]|4[02-9]|5[0-46-9]|[6-8]\\d|9[01])\\d{4}"],["80[1-4]\\d{5}"]]],"AO":["244","00","[29]\\d{8}",[9],[["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[29]"]]],0,0,0,0,0,0,[["2\\d(?:[0134][25-9]|[25-9]\\d)\\d{5}"],["9[1-59]\\d{7}"]]],"AR":["54","00","(?:11|[89]\\d\\d)\\d{8}|[2368]\\d{9}",[10,11],[["(\\d{4})(\\d{2})(\\d{4})","$1 $2-$3",["2(?:2[024-9]|3[0-59]|47|6[245]|9[02-8])|3(?:3[28]|4[03-9]|5[2-46-8]|7[1-578]|8[2-9])","2(?:[23]02|6(?:[25]|4[6-8])|9(?:[02356]|4[02568]|72|8[23]))|3(?:3[28]|4(?:[04679]|3[5-8]|5[4-68]|8[2379])|5(?:[2467]|3[237]|8[2-5])|7[1-578]|8(?:[2469]|3[2578]|5[4-8]|7[36-8]|8[5-8]))|2(?:2[24-9]|3[1-59]|47)","2(?:[23]02|6(?:[25]|4(?:64|[78]))|9(?:[02356]|4(?:[0268]|5[2-6])|72|8[23]))|3(?:3[28]|4(?:[04679]|3[78]|5(?:4[46]|8)|8[2379])|5(?:[2467]|3[237]|8[23])|7[1-578]|8(?:[2469]|3[278]|5[56][46]|86[3-6]))|2(?:2[24-9]|3[1-59]|47)|38(?:[58][78]|7[378])|3(?:4[35][56]|58[45]|8(?:[38]5|54|76))[4-6]","2(?:[23]02|6(?:[25]|4(?:64|[78]))|9(?:[02356]|4(?:[0268]|5[2-6])|72|8[23]))|3(?:3[28]|4(?:[04679]|3(?:5(?:4[0-25689]|[56])|[78])|58|8[2379])|5(?:[2467]|3[237]|8(?:[23]|4(?:[45]|60)|5(?:4[0-39]|5|64)))|7[1-578]|8(?:[2469]|3[278]|54(?:4|5[13-7]|6[89])|86[3-6]))|2(?:2[24-9]|3[1-59]|47)|38(?:[58][78]|7[378])|3(?:454|85[56])[46]|3(?:4(?:36|5[56])|8(?:[38]5|76))[4-6]"],"0$1",1],["(\\d{2})(\\d{4})(\\d{4})","$1 $2-$3",["1"],"0$1",1],["(\\d{3})(\\d{3})(\\d{4})","$1-$2-$3",["[68]"],"0$1"],["(\\d{3})(\\d{3})(\\d{4})","$1 $2-$3",["[23]"],"0$1",1],["(\\d)(\\d{4})(\\d{2})(\\d{4})","$2 15-$3-$4",["9(?:2[2-469]|3[3-578])","9(?:2(?:2[024-9]|3[0-59]|47|6[245]|9[02-8])|3(?:3[28]|4[03-9]|5[2-46-8]|7[1-578]|8[2-9]))","9(?:2(?:[23]02|6(?:[25]|4[6-8])|9(?:[02356]|4[02568]|72|8[23]))|3(?:3[28]|4(?:[04679]|3[5-8]|5[4-68]|8[2379])|5(?:[2467]|3[237]|8[2-5])|7[1-578]|8(?:[2469]|3[2578]|5[4-8]|7[36-8]|8[5-8])))|92(?:2[24-9]|3[1-59]|47)","9(?:2(?:[23]02|6(?:[25]|4(?:64|[78]))|9(?:[02356]|4(?:[0268]|5[2-6])|72|8[23]))|3(?:3[28]|4(?:[04679]|3[78]|5(?:4[46]|8)|8[2379])|5(?:[2467]|3[237]|8[23])|7[1-578]|8(?:[2469]|3[278]|5(?:[56][46]|[78])|7[378]|8(?:6[3-6]|[78]))))|92(?:2[24-9]|3[1-59]|47)|93(?:4[35][56]|58[45]|8(?:[38]5|54|76))[4-6]","9(?:2(?:[23]02|6(?:[25]|4(?:64|[78]))|9(?:[02356]|4(?:[0268]|5[2-6])|72|8[23]))|3(?:3[28]|4(?:[04679]|3(?:5(?:4[0-25689]|[56])|[78])|5(?:4[46]|8)|8[2379])|5(?:[2467]|3[237]|8(?:[23]|4(?:[45]|60)|5(?:4[0-39]|5|64)))|7[1-578]|8(?:[2469]|3[278]|5(?:4(?:4|5[13-7]|6[89])|[56][46]|[78])|7[378]|8(?:6[3-6]|[78]))))|92(?:2[24-9]|3[1-59]|47)|93(?:4(?:36|5[56])|8(?:[38]5|76))[4-6]"],"0$1",0,"$1 $2 $3-$4"],["(\\d)(\\d{2})(\\d{4})(\\d{4})","$2 15-$3-$4",["91"],"0$1",0,"$1 $2 $3-$4"],["(\\d{3})(\\d{3})(\\d{5})","$1-$2-$3",["8"],"0$1"],["(\\d)(\\d{3})(\\d{3})(\\d{4})","$2 15-$3-$4",["9"],"0$1",0,"$1 $2 $3-$4"]],"0",0,"0?(?:(11|2(?:2(?:02?|[13]|2[13-79]|4[1-6]|5[2457]|6[124-8]|7[1-4]|8[13-6]|9[1267])|3(?:02?|1[467]|2[03-6]|3[13-8]|[49][2-6]|5[2-8]|[67])|4(?:7[3-578]|9)|6(?:[0136]|2[24-6]|4[6-8]?|5[15-8])|80|9(?:0[1-3]|[19]|2\\d|3[1-6]|4[02568]?|5[2-4]|6[2-46]|72?|8[23]?))|3(?:3(?:2[79]|6|8[2578])|4(?:0[0-24-9]|[12]|3[5-8]?|4[24-7]|5[4-68]?|6[02-9]|7[126]|8[2379]?|9[1-36-8])|5(?:1|2[1245]|3[237]?|4[1-46-9]|6[2-4]|7[1-6]|8[2-5]?)|6[24]|7(?:[069]|1[1568]|2[15]|3[145]|4[13]|5[14-8]|7[2-57]|8[126])|8(?:[01]|2[15-7]|3[2578]?|4[13-6]|5[4-8]?|6[1-357-9]|7[36-8]?|8[5-8]?|9[124])))15)?","9$1",0,0,[["3888[013-9]\\d{5}|3(?:7(?:1[15]|81)|8(?:21|4[16]|69|9[12]))[46]\\d{5}|(?:29(?:54|66)|3(?:7(?:55|77)|865))[2-8]\\d{5}|(?:2(?:2(?:2[59]|44|52)|3(?:26|44)|473|9(?:[07]2|2[26]|34|46))|3327)[45]\\d{5}|(?:2(?:284|3(?:02|23)|657|920)|3(?:4(?:8[27]|92)|541|878))[2-7]\\d{5}|(?:2(?:(?:26|62)2|320|477|9(?:42|83))|3(?:329|4(?:[47]6|62|89)|564))[2-6]\\d{5}|(?:(?:11[1-8]|670)\\d|2(?:2(?:0[45]|1[2-6]|3[3-6])|3(?:[06]4|7[45])|494|6(?:04|1[2-8]|[36][45]|4[3-6])|80[45]|9(?:[17][4-6]|[48][45]|9[3-6]))|3(?:364|4(?:1[2-7]|[235][4-6]|84)|5(?:1[2-9]|[38][4-6])|6(?:2[45]|44)|7[069][45]|8(?:0[45]|[17][2-6]|3[4-6]|[58][3-6])))\\d{6}|2(?:2(?:21|4[23]|6[145]|7[1-4]|8[356]|9[267])|3(?:16|3[13-8]|43|5[346-8]|9[3-5])|475|6(?:2[46]|4[78]|5[1568])|9(?:03|2[1457-9]|3[1356]|4[08]|[56][23]|82))4\\d{5}|(?:2(?:2(?:57|81)|3(?:24|46|92)|9(?:01|23|64))|3(?:4(?:42|71)|5(?:25|37|4[347]|71)|7(?:18|5[17])))[3-6]\\d{5}|(?:2(?:2(?:02|2[3467]|4[156]|5[45]|6[6-8]|91)|3(?:1[47]|25|[45][25]|96)|47[48]|625|932)|3(?:38[2578]|4(?:0[0-24-9]|3[78]|4[457]|58|6[03-9]|72|83|9[136-8])|5(?:2[124]|[368][23]|4[2689]|7[2-6])|7(?:16|2[15]|3[145]|4[13]|5[468]|7[2-5]|8[26])|8(?:2[5-7]|3[278]|4[3-5]|5[78]|6[1-378]|[78]7|94)))[4-6]\\d{5}",[10]],["93(?:7(?:1[15]|81)[46]|8(?:(?:21|4[16]|69|9[12])[46]|88[013-9]))\\d{5}|9(?:29(?:54|66)|3(?:7(?:55|77)|865))[2-8]\\d{5}|9(?:2(?:2(?:2[59]|44|52)|3(?:26|44)|473|9(?:[07]2|2[26]|34|46))|3327)[45]\\d{5}|9(?:2(?:284|3(?:02|23)|657|920)|3(?:4(?:8[27]|92)|541|878))[2-7]\\d{5}|9(?:2(?:(?:26|62)2|320|477|9(?:42|83))|3(?:329|4(?:[47]6|62|89)|564))[2-6]\\d{5}|(?:675\\d|9(?:11[1-8]\\d|2(?:2(?:0[45]|1[2-6]|3[3-6])|3(?:[06]4|7[45])|494|6(?:04|1[2-8]|[36][45]|4[3-6])|80[45]|9(?:[17][4-6]|[48][45]|9[3-6]))|3(?:364|4(?:1[2-7]|[235][4-6]|84)|5(?:1[2-9]|[38][4-6])|6(?:2[45]|44)|7[069][45]|8(?:0[45]|[17][2-6]|3[4-6]|[58][3-6]))))\\d{6}|92(?:2(?:21|4[23]|6[145]|7[1-4]|8[356]|9[267])|3(?:16|3[13-8]|43|5[346-8]|9[3-5])|475|6(?:2[46]|4[78]|5[1568])|9(?:03|2[1457-9]|3[1356]|4[08]|[56][23]|82))4\\d{5}|9(?:2(?:2(?:57|81)|3(?:24|46|92)|9(?:01|23|64))|3(?:4(?:42|71)|5(?:25|37|4[347]|71)|7(?:18|5[17])))[3-6]\\d{5}|9(?:2(?:2(?:02|2[3467]|4[156]|5[45]|6[6-8]|91)|3(?:1[47]|25|[45][25]|96)|47[48]|625|932)|3(?:38[2578]|4(?:0[0-24-9]|3[78]|4[457]|58|6[03-9]|72|83|9[136-8])|5(?:2[124]|[368][23]|4[2689]|7[2-6])|7(?:16|2[15]|3[145]|4[13]|5[468]|7[2-5]|8[26])|8(?:2[5-7]|3[278]|4[3-5]|5[78]|6[1-378]|[78]7|94)))[4-6]\\d{5}"],["800\\d{7,8}"],["60[04579]\\d{7}",[10]],0,0,["810\\d{7}",[10]]]],"AS":["1","011","(?:[58]\\d\\d|684|900)\\d{7}",[10],0,"1",0,"([267]\\d{6})$|1","684$1",0,"684",[["6846(?:22|33|44|55|77|88|9[19])\\d{4}"],["684(?:2(?:48|5[2468]|7[26])|7(?:3[13]|70|82))\\d{4}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"AT":["43","00","1\\d{3,12}|2\\d{6,12}|43(?:(?:0\\d|5[02-9])\\d{3,9}|2\\d{4,5}|[3467]\\d{4}|8\\d{4,6}|9\\d{4,7})|5\\d{4,12}|8\\d{7,12}|9\\d{8,12}|(?:[367]\\d|4[0-24-9])\\d{4,11}",[4,5,6,7,8,9,10,11,12,13],[["(\\d)(\\d{3,12})","$1 $2",["1(?:11|[2-9])"],"0$1"],["(\\d{3})(\\d{2})","$1 $2",["517"],"0$1"],["(\\d{2})(\\d{3,5})","$1 $2",["5[079]"],"0$1"],["(\\d{3})(\\d{3,10})","$1 $2",["(?:31|4)6|51|6(?:5[0-3579]|[6-9])|7(?:20|32|8)|[89]"],"0$1"],["(\\d{4})(\\d{3,9})","$1 $2",["[2-467]|5[2-6]"],"0$1"],["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["5"],"0$1"],["(\\d{2})(\\d{4})(\\d{4,7})","$1 $2 $3",["5"],"0$1"]],"0",0,0,0,0,0,[["1(?:11\\d|[2-9]\\d{3,11})|(?:316|463|(?:51|66|73)2)\\d{3,10}|(?:2(?:1[467]|2[13-8]|5[2357]|6[1-46-8]|7[1-8]|8[124-7]|9[1458])|3(?:1[1-578]|3[23568]|4[5-7]|5[1378]|6[1-38]|8[3-68])|4(?:2[1-8]|35|7[1368]|8[2457])|5(?:2[1-8]|3[357]|4[147]|5[12578]|6[37])|6(?:13|2[1-47]|4[135-8]|5[468])|7(?:2[1-8]|35|4[13478]|5[68]|6[16-8]|7[1-6]|9[45]))\\d{4,10}"],["6(?:5[0-3579]|6[013-9]|[7-9]\\d)\\d{4,10}",[7,8,9,10,11,12,13]],["800\\d{6,10}",[9,10,11,12,13]],["(?:8[69][2-68]|9(?:0[01]|3[019]))\\d{6,10}",[9,10,11,12,13]],0,0,0,0,["5(?:0[1-9]|17|[79]\\d)\\d{2,10}|7[28]0\\d{6,10}",[5,6,7,8,9,10,11,12,13]],["8(?:10|2[018])\\d{6,10}|828\\d{5}",[8,9,10,11,12,13]]]],"AU":["61","001[14-689]|14(?:1[14]|34|4[17]|[56]6|7[47]|88)0011","1(?:[0-79]\\d{7}(?:\\d(?:\\d{2})?)?|8[0-24-9]\\d{7})|[2-478]\\d{8}|1\\d{4,7}",[5,6,7,8,9,10,12],[["(\\d{2})(\\d{3,4})","$1 $2",["16"],"0$1"],["(\\d{2})(\\d{3})(\\d{2,4})","$1 $2 $3",["16"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["14|4"],"0$1"],["(\\d)(\\d{4})(\\d{4})","$1 $2 $3",["[2378]"],"(0$1)"],["(\\d{4})(\\d{3})(\\d{3})","$1 $2 $3",["1(?:30|[89])"]]],"0",0,"(183[12])|0",0,0,0,[["(?:(?:2(?:[0-26-9]\\d|3[0-8]|4[02-9]|5[0135-9])|3(?:[0-3589]\\d|4[0-578]|6[1-9]|7[0-35-9])|7(?:[013-57-9]\\d|2[0-8]))\\d{3}|8(?:51(?:0(?:0[03-9]|[12479]\\d|3[2-9]|5[0-8]|6[1-9]|8[0-7])|1(?:[0235689]\\d|1[0-69]|4[0-589]|7[0-47-9])|2(?:0[0-79]|[18][13579]|2[14-9]|3[0-46-9]|[4-6]\\d|7[89]|9[0-4]))|(?:6[0-8]|[78]\\d)\\d{3}|9(?:[02-9]\\d{3}|1(?:(?:[0-58]\\d|6[0135-9])\\d|7(?:0[0-24-9]|[1-9]\\d)|9(?:[0-46-9]\\d|5[0-79])))))\\d{3}",[9]],["4(?:79[01]|83[0-389]|93[0-6])\\d{5}|4(?:[0-3]\\d|4[047-9]|5[0-25-9]|6[016-9]|7[02-8]|8[0-24-9]|9[0-27-9])\\d{6}",[9]],["180(?:0\\d{3}|2)\\d{3}",[7,10]],["190[0-26]\\d{6}",[10]],0,0,0,["163\\d{2,6}",[5,6,7,8,9]],["14(?:5(?:1[0458]|[23][458])|71\\d)\\d{4}",[9]],["13(?:00\\d{6}(?:\\d{2})?|45[0-4]\\d{3})|13\\d{4}",[6,8,10,12]]],"0011"],"AW":["297","00","(?:[25-79]\\d\\d|800)\\d{4}",[7],[["(\\d{3})(\\d{4})","$1 $2",["[25-9]"]]],0,0,0,0,0,0,[["5(?:2\\d|8[1-9])\\d{4}"],["(?:290|5[69]\\d|6(?:[03]0|22|4[0-2]|[69]\\d)|7(?:[34]\\d|7[07])|9(?:6[45]|9[4-8]))\\d{4}"],["800\\d{4}"],["900\\d{4}"],0,0,0,0,["(?:28\\d|501)\\d{4}"]]],"AX":["358","00|99(?:[01469]|5(?:[14]1|3[23]|5[59]|77|88|9[09]))","2\\d{4,9}|35\\d{4,5}|(?:60\\d\\d|800)\\d{4,6}|7\\d{5,11}|(?:[14]\\d|3[0-46-9]|50)\\d{4,8}",[5,6,7,8,9,10,11,12],0,"0",0,0,0,0,"18",[["18[1-8]\\d{3,6}",[6,7,8,9]],["4946\\d{2,6}|(?:4[0-8]|50)\\d{4,8}",[6,7,8,9,10]],["800\\d{4,6}",[7,8,9]],["[67]00\\d{5,6}",[8,9]],0,0,["20\\d{4,8}|60[12]\\d{5,6}|7(?:099\\d{4,5}|5[03-9]\\d{3,7})|20[2-59]\\d\\d|(?:606|7(?:0[78]|1|3\\d))\\d{7}|(?:10|29|3[09]|70[1-5]\\d)\\d{4,8}"]],"00"],"AZ":["994","00","365\\d{6}|(?:[124579]\\d|60|88)\\d{7}",[9],[["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["90"],"0$1"],["(\\d{2})(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3 $4",["1[28]|2|365|46","1[28]|2|365[45]|46","1[28]|2|365(?:4|5[02])|46"],"(0$1)"],["(\\d{2})(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[13-9]"],"0$1"]],"0",0,0,0,0,0,[["(?:2[12]428|3655[02])\\d{4}|(?:2(?:22[0-79]|63[0-28])|3654)\\d{5}|(?:(?:1[28]|46)\\d|2(?:[014-6]2|[23]3))\\d{6}"],["36554\\d{4}|(?:[16]0|4[04]|5[015]|7[07]|99)\\d{7}"],["88\\d{7}"],["900200\\d{3}"]]],"BA":["387","00","6\\d{8}|(?:[35689]\\d|49|70)\\d{6}",[8,9],[["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["6[1-3]|[7-9]"],"0$1"],["(\\d{2})(\\d{3})(\\d{3})","$1 $2-$3",["[3-5]|6[56]"],"0$1"],["(\\d{2})(\\d{2})(\\d{2})(\\d{3})","$1 $2 $3 $4",["6"],"0$1"]],"0",0,0,0,0,0,[["(?:3(?:[05-79][2-9]|1[4579]|[23][24-9]|4[2-4689]|8[2457-9])|49[2-579]|5(?:0[2-49]|[13][2-9]|[268][2-4679]|4[4689]|5[2-79]|7[2-69]|9[2-4689]))\\d{5}",[8]],["6040\\d{5}|6(?:03|[1-356]|44|7\\d)\\d{6}"],["8[08]\\d{6}",[8]],["9[0246]\\d{6}",[8]],0,0,["703[235]0\\d{3}|70(?:2[0-5]|3[0146]|[56]0)\\d{4}",[8]],0,0,["8[12]\\d{6}",[8]]]],"BB":["1","011","(?:246|[58]\\d\\d|900)\\d{7}",[10],0,"1",0,"([2-9]\\d{6})$|1","246$1",0,"246",[["246521[0369]\\d{3}|246(?:2(?:2[78]|7[0-4])|4(?:1[024-6]|2\\d|3[2-9])|5(?:20|[34]\\d|54|7[1-3])|6(?:2\\d|38)|7[35]7|9(?:1[89]|63))\\d{4}"],["246(?:(?:2(?:[3568]\\d|4[0-57-9])|3(?:5[2-9]|6[0-6])|4(?:46|5\\d)|69[5-7]|8(?:[2-5]\\d|83))\\d|52(?:1[147]|20))\\d{3}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["(?:246976|900[2-9]\\d\\d)\\d{4}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"],0,["246(?:292|367|4(?:1[7-9]|3[01]|4[47-9]|67)|7(?:1[2-9]|2\\d|3[016]|53))\\d{4}"],0,["24631\\d{5}"]]],"BD":["880","00","[1-469]\\d{9}|8[0-79]\\d{7,8}|[2-79]\\d{8}|[2-9]\\d{7}|[3-9]\\d{6}|[57-9]\\d{5}",[6,7,8,9,10],[["(\\d{2})(\\d{4,6})","$1-$2",["31[5-8]|[459]1"],"0$1"],["(\\d{3})(\\d{3,7})","$1-$2",["3(?:[67]|8[013-9])|4(?:6[168]|7|[89][18])|5(?:6[128]|9)|6(?:28|4[14]|5)|7[2-589]|8(?:0[014-9]|[12])|9[358]|(?:3[2-5]|4[235]|5[2-578]|6[0389]|76|8[3-7]|9[24])1|(?:44|66)[01346-9]"],"0$1"],["(\\d{4})(\\d{3,6})","$1-$2",["[13-9]|22"],"0$1"],["(\\d)(\\d{7,8})","$1-$2",["2"],"0$1"]],"0",0,0,0,0,0,[["(?:4(?:31\\d\\d|423)|5222)\\d{3}(?:\\d{2})?|8332[6-9]\\d\\d|(?:3(?:03[56]|224)|4(?:22[25]|653))\\d{3,4}|(?:3(?:42[47]|529|823)|4(?:027|525|65(?:28|8))|562|6257|7(?:1(?:5[3-5]|6[12]|7[156]|89)|22[589]56|32|42675|52(?:[25689](?:56|8)|[347]8)|71(?:6[1267]|75|89)|92374)|82(?:2[59]|32)56|9(?:03[23]56|23(?:256|373)|31|5(?:1|2[4589]56)))\\d{3}|(?:3(?:02[348]|22[35]|324|422)|4(?:22[67]|32[236-9]|6(?:2[46]|5[57])|953)|5526|6(?:024|6655)|81)\\d{4,5}|(?:2(?:7(?:1[0-267]|2[0-289]|3[0-29]|4[01]|5[1-3]|6[013]|7[0178]|91)|8(?:0[125]|1[1-6]|2[0157-9]|3[1-69]|41|6[1-35]|7[1-5]|8[1-8]|9[0-6])|9(?:0[0-2]|1[0-4]|2[568]|3[3-6]|5[5-7]|6[0136-9]|7[0-7]|8[014-9]))|3(?:0(?:2[025-79]|3[2-4])|181|22[12]|32[2356]|824)|4(?:02[09]|22[348]|32[045]|523|6(?:27|54))|666(?:22|53)|7(?:22[57-9]|42[56]|82[35])8|8(?:0[124-9]|2(?:181|2[02-4679]8)|4[12]|[5-7]2)|9(?:[04]2|2(?:2|328)|81))\\d{4}|(?:2(?:222|[45]\\d)\\d|3(?:1(?:2[5-7]|[5-7])|425|822)|4(?:033|1\\d|[257]1|332|4(?:2[246]|5[25])|6(?:2[35]|56|62)|8(?:23|54)|92[2-5])|5(?:02[03489]|22[457]|32[35-79]|42[46]|6(?:[18]|53)|724|826)|6(?:023|2(?:2[2-5]|5[3-5]|8)|32[3478]|42[34]|52[47]|6(?:[18]|6(?:2[34]|5[24]))|[78]2[2-5]|92[2-6])|7(?:02|21\\d|[3-589]1|6[12]|72[24])|8(?:217|3[12]|[5-7]1)|9[24]1)\\d{5}|(?:(?:3[2-8]|5[2-57-9]|6[03-589])1|4[4689][18])\\d{5}|[59]1\\d{5}"],["(?:1[13-9]\\d|644)\\d{7}|(?:3[78]|44|66)[02-9]\\d{7}",[10]],["80[03]\\d{7}",[10]],0,0,0,0,0,["96(?:0[469]|1[0-47]|3[389]|6[69]|7[78])\\d{6}",[10]]]],"BE":["32","00","4\\d{8}|[1-9]\\d{7}",[8,9],[["(\\d{3})(\\d{2})(\\d{3})","$1 $2 $3",["(?:80|9)0"],"0$1"],["(\\d)(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[239]|4[23]"],"0$1"],["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[15-8]"],"0$1"],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["4"],"0$1"]],"0",0,0,0,0,0,[["80[2-8]\\d{5}|(?:1[0-69]|[23][2-8]|4[23]|5\\d|6[013-57-9]|71|8[1-79]|9[2-4])\\d{6}",[8]],["4[5-9]\\d{7}",[9]],["800[1-9]\\d{4}",[8]],["(?:70(?:2[0-57]|3[04-7]|44|6[569]|7[0579])|90(?:0[0-8]|1[36]|2[0-3568]|3[0-689]|4[02-68]|5[1-68]|6[0-378]|7[2-68]|9[34679]))\\d{4}",[8]],0,0,["78(?:0[57]|1[014-8]|2[25]|3[15-8]|48|[56]0|7[06-8]|9\\d)\\d{4}",[8]],0,0,["7879\\d{4}",[8]]]],"BF":["226","00","[025-7]\\d{7}",[8],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[025-7]"]]],0,0,0,0,0,0,[["2(?:0(?:49|5[23]|6[5-7]|9[016-9])|4(?:4[569]|5[4-6]|6[5-7]|7[0179])|5(?:[34]\\d|50|6[5-7]))\\d{4}"],["(?:0[1-35-7]|5[1-8]|[67]\\d)\\d{6}"]]],"BG":["359","00","00800\\d{7}|[2-7]\\d{6,7}|[89]\\d{6,8}|2\\d{5}",[6,7,8,9,12],[["(\\d)(\\d)(\\d{2})(\\d{2})","$1 $2 $3 $4",["2"],"0$1"],["(\\d{3})(\\d{4})","$1 $2",["43[1-6]|70[1-9]"],"0$1"],["(\\d)(\\d{3})(\\d{3,4})","$1 $2 $3",["2"],"0$1"],["(\\d{2})(\\d{3})(\\d{2,3})","$1 $2 $3",["[356]|4[124-7]|7[1-9]|8[1-6]|9[1-7]"],"0$1"],["(\\d{3})(\\d{2})(\\d{3})","$1 $2 $3",["(?:70|8)0"],"0$1"],["(\\d{3})(\\d{3})(\\d{2})","$1 $2 $3",["43[1-7]|7"],"0$1"],["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["[48]|9[08]"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["9"],"0$1"]],"0",0,0,0,0,0,[["2\\d{5,7}|(?:43[1-6]|70[1-9])\\d{4,5}|(?:[36]\\d|4[124-7]|[57][1-9]|8[1-6]|9[1-7])\\d{5,6}",[6,7,8]],["(?:43[07-9]|99[69]\\d)\\d{5}|(?:8[7-9]|98)\\d{7}",[8,9]],["(?:00800\\d\\d|800)\\d{5}",[8,12]],["90\\d{6}",[8]],0,0,0,0,0,["700\\d{5}",[8]]]],"BH":["973","00","[136-9]\\d{7}",[8],[["(\\d{4})(\\d{4})","$1 $2",["[13679]|8[047]"]]],0,0,0,0,0,0,[["(?:1(?:3[1356]|6[0156]|7\\d)\\d|6(?:1[16]\\d|500|6(?:0\\d|3[12]|44|7[7-9]|88)|9[69][69])|7(?:1(?:11|78)|7\\d\\d))\\d{4}"],["(?:3(?:[1-79]\\d|8[0-47-9])\\d|6(?:3(?:00|33|6[16])|6(?:3[03-9]|[69]\\d|7[0-6])))\\d{4}"],["80\\d{6}"],["(?:87|9[014578])\\d{6}"],0,0,0,0,0,["84\\d{6}"]]],"BI":["257","00","(?:[267]\\d|31)\\d{6}",[8],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[2367]"]]],0,0,0,0,0,0,[["(?:22|31)\\d{6}"],["(?:29|[67][125-9])\\d{6}"]]],"BJ":["229","00","[24-689]\\d{7}",[8],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[24-689]"]]],0,0,0,0,0,0,[["2(?:02|1[037]|2[45]|3[68]|4\\d)\\d{5}"],["(?:4[0-2]|[56]\\d|9[013-9])\\d{6}"],0,0,0,0,["81\\d{6}"],0,["857[58]\\d{4}"]]],"BL":["590","00","590\\d{6}|(?:69|80|9\\d)\\d{7}",[9],0,"0",0,0,0,0,0,[["590(?:2[7-9]|5[12]|87)\\d{4}"],["69(?:0\\d\\d|1(?:2[2-9]|3[0-5]))\\d{4}"],["80[0-5]\\d{6}"],0,0,0,0,0,["9(?:(?:395|76[018])\\d|475[01])\\d{4}"]]],"BM":["1","011","(?:441|[58]\\d\\d|900)\\d{7}",[10],0,"1",0,"([2-9]\\d{6})$|1","441$1",0,"441",[["441(?:[46]\\d\\d|5(?:4\\d|60|89))\\d{4}"],["441(?:[2378]\\d|5[0-39]|92)\\d{5}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"BN":["673","00","[2-578]\\d{6}",[7],[["(\\d{3})(\\d{4})","$1 $2",["[2-578]"]]],0,0,0,0,0,0,[["22[0-7]\\d{4}|(?:2[013-9]|[34]\\d|5[0-25-9])\\d{5}"],["(?:22[89]|[78]\\d\\d)\\d{4}"],0,0,0,0,0,0,["5[34]\\d{5}"]]],"BO":["591","00(?:1\\d)?","(?:[2-467]\\d\\d|8001)\\d{5}",[8,9],[["(\\d)(\\d{7})","$1 $2",["[23]|4[46]"]],["(\\d{8})","$1",["[67]"]],["(\\d{3})(\\d{2})(\\d{4})","$1 $2 $3",["8"]]],"0",0,"0(1\\d)?",0,0,0,[["(?:2(?:2\\d\\d|5(?:11|[258]\\d|9[67])|6(?:12|2\\d|9[34])|8(?:2[34]|39|62))|3(?:3\\d\\d|4(?:6\\d|8[24])|8(?:25|42|5[257]|86|9[25])|9(?:[27]\\d|3[2-4]|4[248]|5[24]|6[2-6]))|4(?:4\\d\\d|6(?:11|[24689]\\d|72)))\\d{4}",[8]],["[67]\\d{7}",[8]],["8001[07]\\d{4}",[9]]]],"BQ":["599","00","(?:[34]1|7\\d)\\d{5}",[7],0,0,0,0,0,0,"[347]",[["(?:318[023]|41(?:6[023]|70)|7(?:1[578]|2[05]|50)\\d)\\d{3}"],["(?:31(?:8[14-8]|9[14578])|416[14-9]|7(?:0[01]|7[07]|8\\d|9[056])\\d)\\d{3}"]]],"BR":["55","00(?:1[245]|2[1-35]|31|4[13]|[56]5|99)","(?:[1-46-9]\\d\\d|5(?:[0-46-9]\\d|5[0-46-9]))\\d{8}|[1-9]\\d{9}|[3589]\\d{8}|[34]\\d{7}",[8,9,10,11],[["(\\d{4})(\\d{4})","$1-$2",["300|4(?:0[02]|37)","4(?:02|37)0|[34]00"]],["(\\d{3})(\\d{2,3})(\\d{4})","$1 $2 $3",["(?:[358]|90)0"],"0$1"],["(\\d{2})(\\d{4})(\\d{4})","$1 $2-$3",["(?:[14689][1-9]|2[12478]|3[1-578]|5[13-5]|7[13-579])[2-57]"],"($1)"],["(\\d{2})(\\d{5})(\\d{4})","$1 $2-$3",["[16][1-9]|[2-57-9]"],"($1)"]],"0",0,"(?:0|90)(?:(1[245]|2[1-35]|31|4[13]|[56]5|99)(\\d{10,11}))?","$2",0,0,[["(?:[14689][1-9]|2[12478]|3[1-578]|5[13-5]|7[13-579])[2-5]\\d{7}",[10]],["(?:[14689][1-9]|2[12478]|3[1-578]|5[13-5]|7[13-579])(?:7|9\\d)\\d{7}",[10,11]],["800\\d{6,7}",[9,10]],["300\\d{6}|[59]00\\d{6,7}",[9,10]],0,0,0,0,0,["(?:30[03]\\d{3}|4(?:0(?:0\\d|20)|370))\\d{4}|300\\d{5}",[8,10]]]],"BS":["1","011","(?:242|[58]\\d\\d|900)\\d{7}",[10],0,"1",0,"([3-8]\\d{6})$|1","242$1",0,"242",[["242(?:3(?:02|[236][1-9]|4[0-24-9]|5[0-68]|7[347]|8[0-4]|9[2-467])|461|502|6(?:0[1-5]|12|2[013]|[45]0|7[67]|8[78]|9[89])|7(?:02|88))\\d{4}"],["242(?:3(?:5[79]|7[56]|95)|4(?:[23][1-9]|4[1-35-9]|5[1-8]|6[2-8]|7\\d|81)|5(?:2[45]|3[35]|44|5[1-46-9]|65|77)|6[34]6|7(?:27|38)|8(?:0[1-9]|1[02-9]|2\\d|[89]9))\\d{4}"],["242300\\d{4}|8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"],0,["242225\\d{4}"]]],"BT":["975","00","[17]\\d{7}|[2-8]\\d{6}",[7,8],[["(\\d)(\\d{3})(\\d{3})","$1 $2 $3",["[2-68]|7[246]"]],["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["1[67]|7"]]],0,0,0,0,0,0,[["(?:2[3-6]|[34][5-7]|5[236]|6[2-46]|7[246]|8[2-4])\\d{5}",[7]],["(?:1[67]|77)\\d{6}",[8]]]],"BW":["267","00","(?:0800|(?:[37]|800)\\d)\\d{6}|(?:[2-6]\\d|90)\\d{5}",[7,8,10],[["(\\d{2})(\\d{5})","$1 $2",["90"]],["(\\d{3})(\\d{4})","$1 $2",["[24-6]|3[15-79]"]],["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["[37]"]],["(\\d{4})(\\d{3})(\\d{3})","$1 $2 $3",["0"]],["(\\d{3})(\\d{4})(\\d{3})","$1 $2 $3",["8"]]],0,0,0,0,0,0,[["(?:2(?:4[0-48]|6[0-24]|9[0578])|3(?:1[0-35-9]|55|[69]\\d|7[013])|4(?:6[03]|7[1267]|9[0-5])|5(?:3[03489]|4[0489]|7[1-47]|88|9[0-49])|6(?:2[1-35]|5[149]|8[067]))\\d{4}",[7]],["(?:321|7(?:[1-7]\\d|8[0-4]))\\d{5}",[8]],["(?:0800|800\\d)\\d{6}",[10]],["90\\d{5}",[7]],0,0,0,0,["79(?:1(?:[01]\\d|2[0-7])|2[0-7]\\d)\\d{3}",[8]]]],"BY":["375","810","(?:[12]\\d|33|44|902)\\d{7}|8(?:0[0-79]\\d{5,7}|[1-7]\\d{9})|8(?:1[0-489]|[5-79]\\d)\\d{7}|8[1-79]\\d{6,7}|8[0-79]\\d{5}|8\\d{5}",[6,7,8,9,10,11],[["(\\d{3})(\\d{3})","$1 $2",["800"],"8 $1"],["(\\d{3})(\\d{2})(\\d{2,4})","$1 $2 $3",["800"],"8 $1"],["(\\d{4})(\\d{2})(\\d{3})","$1 $2-$3",["1(?:5[169]|6[3-5]|7[179])|2(?:1[35]|2[34]|3[3-5])","1(?:5[169]|6(?:3[1-3]|4|5[125])|7(?:1[3-9]|7[0-24-6]|9[2-7]))|2(?:1[35]|2[34]|3[3-5])"],"8 0$1"],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2-$3-$4",["1(?:[56]|7[467])|2[1-3]"],"8 0$1"],["(\\d{2})(\\d{3})(\\d{2})(\\d{2})","$1 $2-$3-$4",["[1-4]"],"8 0$1"],["(\\d{3})(\\d{3,4})(\\d{4})","$1 $2 $3",["[89]"],"8 $1"]],"8",0,"0|80?",0,0,0,[["(?:1(?:5(?:1[1-5]|[24]\\d|6[2-4]|9[1-7])|6(?:[235]\\d|4[1-7])|7\\d\\d)|2(?:1(?:[246]\\d|3[0-35-9]|5[1-9])|2(?:[235]\\d|4[0-8])|3(?:[26]\\d|3[02-79]|4[024-7]|5[03-7])))\\d{5}",[9]],["(?:2(?:5[5-79]|9[1-9])|(?:33|44)\\d)\\d{6}",[9]],["800\\d{3,7}|8(?:0[13]|20\\d)\\d{7}"],["(?:810|902)\\d{7}",[10]],0,0,0,0,["249\\d{6}",[9]]],"8~10"],"BZ":["501","00","(?:0800\\d|[2-8])\\d{6}",[7,11],[["(\\d{3})(\\d{4})","$1-$2",["[2-8]"]],["(\\d)(\\d{3})(\\d{4})(\\d{3})","$1-$2-$3-$4",["0"]]],0,0,0,0,0,0,[["(?:2(?:[02]\\d|36|[68]0)|[3-58](?:[02]\\d|[68]0)|7(?:[02]\\d|32|[68]0))\\d{4}",[7]],["6[0-35-7]\\d{5}",[7]],["0800\\d{7}",[11]]]],"CA":["1","011","(?:[2-8]\\d|90)\\d{8}|3\\d{6}",[7,10],0,"1",0,0,0,0,0,[["(?:2(?:04|[23]6|[48]9|50|63)|3(?:06|43|54|6[578]|82)|4(?:03|1[68]|[26]8|3[178]|50|74)|5(?:06|1[49]|48|79|8[147])|6(?:04|[18]3|39|47|72)|7(?:0[59]|42|53|78|8[02])|8(?:[06]7|19|25|73)|90[25])[2-9]\\d{6}",[10]],["",[10]],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}",[10]],["900[2-9]\\d{6}",[10]],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|(?:5(?:00|2[125-9]|33|44|66|77|88)|622)[2-9]\\d{6}",[10]],0,["310\\d{4}",[7]],0,["600[2-9]\\d{6}",[10]]]],"CC":["61","001[14-689]|14(?:1[14]|34|4[17]|[56]6|7[47]|88)0011","1(?:[0-79]\\d{8}(?:\\d{2})?|8[0-24-9]\\d{7})|[148]\\d{8}|1\\d{5,7}",[6,7,8,9,10,12],0,"0",0,"([59]\\d{7})$|0","8$1",0,0,[["8(?:51(?:0(?:02|31|60|89)|1(?:18|76)|223)|91(?:0(?:1[0-2]|29)|1(?:[28]2|50|79)|2(?:10|64)|3(?:[06]8|22)|4[29]8|62\\d|70[23]|959))\\d{3}",[9]],["4(?:79[01]|83[0-389]|93[0-6])\\d{5}|4(?:[0-3]\\d|4[047-9]|5[0-25-9]|6[016-9]|7[02-8]|8[0-24-9]|9[0-27-9])\\d{6}",[9]],["180(?:0\\d{3}|2)\\d{3}",[7,10]],["190[0-26]\\d{6}",[10]],0,0,0,0,["14(?:5(?:1[0458]|[23][458])|71\\d)\\d{4}",[9]],["13(?:00\\d{6}(?:\\d{2})?|45[0-4]\\d{3})|13\\d{4}",[6,8,10,12]]],"0011"],"CD":["243","00","[189]\\d{8}|[1-68]\\d{6}",[7,9],[["(\\d{2})(\\d{2})(\\d{3})","$1 $2 $3",["88"],"0$1"],["(\\d{2})(\\d{5})","$1 $2",["[1-6]"],"0$1"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["1"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[89]"],"0$1"]],"0",0,0,0,0,0,[["12\\d{7}|[1-6]\\d{6}"],["88\\d{5}|(?:8[0-59]|9[017-9])\\d{7}"]]],"CF":["236","00","(?:[27]\\d{3}|8776)\\d{4}",[8],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[278]"]]],0,0,0,0,0,0,[["2[12]\\d{6}"],["7[024-7]\\d{6}"],0,["8776\\d{4}"]]],"CG":["242","00","222\\d{6}|(?:0\\d|80)\\d{7}",[9],[["(\\d)(\\d{4})(\\d{4})","$1 $2 $3",["8"]],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["[02]"]]],0,0,0,0,0,0,[["222[1-589]\\d{5}"],["026(?:1[0-5]|6[6-9])\\d{4}|0(?:[14-6]\\d\\d|2(?:40|5[5-8]|6[07-9]))\\d{5}"],0,["80(?:0\\d\\d|120)\\d{4}"]]],"CH":["41","00","8\\d{11}|[2-9]\\d{8}",[9],[["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["8[047]|90"],"0$1"],["(\\d{2})(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[2-79]|81"],"0$1"],["(\\d{3})(\\d{2})(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3 $4 $5",["8"],"0$1"]],"0",0,0,0,0,0,[["(?:2[12467]|3[1-4]|4[134]|5[256]|6[12]|[7-9]1)\\d{7}"],["7[35-9]\\d{7}"],["800\\d{6}"],["90[016]\\d{6}"],["878\\d{6}"],0,["5[18]\\d{7}"],["74[0248]\\d{6}"],0,["84[0248]\\d{6}"]]],"CI":["225","00","[02]\\d{9}",[10],[["(\\d{2})(\\d{2})(\\d)(\\d{5})","$1 $2 $3 $4",["2"]],["(\\d{2})(\\d{2})(\\d{2})(\\d{4})","$1 $2 $3 $4",["0"]]],0,0,0,0,0,0,[["2(?:[15]\\d{3}|7(?:2(?:0[23]|1[2357]|2[245]|3[45]|4[3-5])|3(?:06|1[69]|[2-6]7)))\\d{5}"],["0[157]\\d{8}"]]],"CK":["682","00","[2-578]\\d{4}",[5],[["(\\d{2})(\\d{3})","$1 $2",["[2-578]"]]],0,0,0,0,0,0,[["(?:2\\d|3[13-7]|4[1-5])\\d{3}"],["[578]\\d{4}"]]],"CL":["56","(?:0|1(?:1[0-69]|2[02-5]|5[13-58]|69|7[0167]|8[018]))0","12300\\d{6}|6\\d{9,10}|[2-9]\\d{8}",[9,10,11],[["(\\d{5})(\\d{4})","$1 $2",["219","2196"],"($1)"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["44"]],["(\\d)(\\d{4})(\\d{4})","$1 $2 $3",["2[1-36]"],"($1)"],["(\\d)(\\d{4})(\\d{4})","$1 $2 $3",["9[2-9]"]],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["3[2-5]|[47]|5[1-3578]|6[13-57]|8(?:0[1-9]|[1-9])"],"($1)"],["(\\d{3})(\\d{3})(\\d{3,4})","$1 $2 $3",["60|8"]],["(\\d{4})(\\d{3})(\\d{4})","$1 $2 $3",["1"]],["(\\d{3})(\\d{3})(\\d{2})(\\d{3})","$1 $2 $3 $4",["60"]]],0,0,0,0,0,0,[["2(?:1982[0-6]|3314[05-9])\\d{3}|(?:2(?:1(?:160|962)|3(?:2\\d\\d|3(?:[03467]\\d|1[0-35-9]|2[1-9]|5[0-24-9]|8[0-3])|600)|646[59])|80[1-9]\\d\\d|9(?:3(?:[0-57-9]\\d\\d|6(?:0[02-9]|[1-9]\\d))|6(?:[0-8]\\d\\d|9(?:[02-79]\\d|1[05-9]))|7[1-9]\\d\\d|9(?:[03-9]\\d\\d|1(?:[0235-9]\\d|4[0-24-9])|2(?:[0-79]\\d|8[0-46-9]))))\\d{4}|(?:22|3[2-5]|[47][1-35]|5[1-3578]|6[13-57]|8[1-9]|9[2458])\\d{7}",[9]],["",[9]],["(?:123|8)00\\d{6}",[9,11]],0,0,0,0,0,["44\\d{7}",[9]],["600\\d{7,8}",[10,11]]]],"CM":["237","00","[26]\\d{8}|88\\d{6,7}",[8,9],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["88"]],["(\\d)(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4 $5",["[26]|88"]]],0,0,0,0,0,0,[["2(?:22|33)\\d{6}",[9]],["(?:24[23]|6[25-9]\\d)\\d{6}",[9]],["88\\d{6,7}"]]],"CN":["86","00|1(?:[12]\\d|79)\\d\\d00","1[127]\\d{8,9}|2\\d{9}(?:\\d{2})?|[12]\\d{6,7}|86\\d{6}|(?:1[03-689]\\d|6)\\d{7,9}|(?:[3-579]\\d|8[0-57-9])\\d{6,9}",[7,8,9,10,11,12],[["(\\d{2})(\\d{5,6})","$1 $2",["(?:10|2[0-57-9])[19]","(?:10|2[0-57-9])(?:10|9[56])","10(?:10|9[56])|2[0-57-9](?:100|9[56])"],"0$1"],["(\\d{3})(\\d{5,6})","$1 $2",["3(?:[157]|35|49|9[1-68])|4(?:[17]|2[179]|6[47-9]|8[23])|5(?:[1357]|2[37]|4[36]|6[1-46]|80)|6(?:3[1-5]|6[0238]|9[12])|7(?:01|[1579]|2[248]|3[014-9]|4[3-6]|6[023689])|8(?:1[236-8]|2[5-7]|[37]|8[36-8]|9[1-8])|9(?:0[1-3689]|1[1-79]|[379]|4[13]|5[1-5])|(?:4[35]|59|85)[1-9]","(?:3(?:[157]\\d|35|49|9[1-68])|4(?:[17]\\d|2[179]|[35][1-9]|6[47-9]|8[23])|5(?:[1357]\\d|2[37]|4[36]|6[1-46]|80|9[1-9])|6(?:3[1-5]|6[0238]|9[12])|7(?:01|[1579]\\d|2[248]|3[014-9]|4[3-6]|6[023689])|8(?:1[236-8]|2[5-7]|[37]\\d|5[1-9]|8[36-8]|9[1-8])|9(?:0[1-3689]|1[1-79]|[379]\\d|4[13]|5[1-5]))[19]","85[23](?:10|95)|(?:3(?:[157]\\d|35|49|9[1-68])|4(?:[17]\\d|2[179]|[35][1-9]|6[47-9]|8[23])|5(?:[1357]\\d|2[37]|4[36]|6[1-46]|80|9[1-9])|6(?:3[1-5]|6[0238]|9[12])|7(?:01|[1579]\\d|2[248]|3[014-9]|4[3-6]|6[023689])|8(?:1[236-8]|2[5-7]|[37]\\d|5[14-9]|8[36-8]|9[1-8])|9(?:0[1-3689]|1[1-79]|[379]\\d|4[13]|5[1-5]))(?:10|9[56])","85[23](?:100|95)|(?:3(?:[157]\\d|35|49|9[1-68])|4(?:[17]\\d|2[179]|[35][1-9]|6[47-9]|8[23])|5(?:[1357]\\d|2[37]|4[36]|6[1-46]|80|9[1-9])|6(?:3[1-5]|6[0238]|9[12])|7(?:01|[1579]\\d|2[248]|3[014-9]|4[3-6]|6[023689])|8(?:1[236-8]|2[5-7]|[37]\\d|5[14-9]|8[36-8]|9[1-8])|9(?:0[1-3689]|1[1-79]|[379]\\d|4[13]|5[1-5]))(?:100|9[56])"],"0$1"],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["(?:4|80)0"]],["(\\d{2})(\\d{4})(\\d{4})","$1 $2 $3",["10|2(?:[02-57-9]|1[1-9])","10|2(?:[02-57-9]|1[1-9])","10[0-79]|2(?:[02-57-9]|1[1-79])|(?:10|21)8(?:0[1-9]|[1-9])"],"0$1",1],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["3(?:[3-59]|7[02-68])|4(?:[26-8]|3[3-9]|5[2-9])|5(?:3[03-9]|[468]|7[028]|9[2-46-9])|6|7(?:[0-247]|3[04-9]|5[0-4689]|6[2368])|8(?:[1-358]|9[1-7])|9(?:[013479]|5[1-5])|(?:[34]1|55|79|87)[02-9]"],"0$1",1],["(\\d{3})(\\d{7,8})","$1 $2",["9"]],["(\\d{4})(\\d{3})(\\d{4})","$1 $2 $3",["80"],"0$1",1],["(\\d{3})(\\d{4})(\\d{4})","$1 $2 $3",["[3-578]"],"0$1",1],["(\\d{3})(\\d{4})(\\d{4})","$1 $2 $3",["1[3-9]"]],["(\\d{2})(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3 $4",["[12]"],"0$1",1]],"0",0,"(1(?:[12]\\d|79)\\d\\d)|0",0,0,0,[["(?:10(?:[02-79]\\d\\d|[18](?:0[1-9]|[1-9]\\d))|21(?:[18](?:0[1-9]|[1-9]\\d)|[2-79]\\d\\d))\\d{5}|(?:43[35]|754)\\d{7,8}|8(?:078\\d{7}|51\\d{7,8})|(?:10|(?:2|85)1|43[35]|754)(?:100\\d\\d|95\\d{3,4})|(?:2[02-57-9]|3(?:11|7[179])|4(?:[15]1|3[12])|5(?:1\\d|2[37]|3[12]|51|7[13-79]|9[15])|7(?:[39]1|5[57]|6[09])|8(?:71|98))(?:[02-8]\\d{7}|1(?:0(?:0\\d\\d(?:\\d{3})?|[1-9]\\d{5})|[1-9]\\d{6})|9(?:[0-46-9]\\d{6}|5\\d{3}(?:\\d(?:\\d{2})?)?))|(?:3(?:1[02-9]|35|49|5\\d|7[02-68]|9[1-68])|4(?:1[02-9]|2[179]|3[46-9]|5[2-9]|6[47-9]|7\\d|8[23])|5(?:3[03-9]|4[36]|5[02-9]|6[1-46]|7[028]|80|9[2-46-9])|6(?:3[1-5]|6[0238]|9[12])|7(?:01|[17]\\d|2[248]|3[04-9]|4[3-6]|5[0-3689]|6[2368]|9[02-9])|8(?:1[236-8]|2[5-7]|3\\d|5[2-9]|7[02-9]|8[36-8]|9[1-7])|9(?:0[1-3689]|1[1-79]|[379]\\d|4[13]|5[1-5]))(?:[02-8]\\d{6}|1(?:0(?:0\\d\\d(?:\\d{2})?|[1-9]\\d{4})|[1-9]\\d{5})|9(?:[0-46-9]\\d{5}|5\\d{3,5}))",[7,8,9,10,11]],["1740[0-5]\\d{6}|1(?:[38]\\d|4[57]|[59][0-35-9]|6[25-7]|7[0-35-8])\\d{8}",[11]],["(?:(?:10|21)8|8)00\\d{7}",[10,12]],["16[08]\\d{5}",[8]],0,0,0,0,0,["10(?:10\\d{4}|96\\d{3,4})|400\\d{7}|950\\d{7,8}|(?:2[0-57-9]|3(?:[157]\\d|35|49|9[1-68])|4(?:[17]\\d|2[179]|[35][1-9]|6[47-9]|8[23])|5(?:[1357]\\d|2[37]|4[36]|6[1-46]|80|9[1-9])|6(?:3[1-5]|6[0238]|9[12])|7(?:01|[1579]\\d|2[248]|3[014-9]|4[3-6]|6[023689])|8(?:1[236-8]|2[5-7]|[37]\\d|5[14-9]|8[36-8]|9[1-8])|9(?:0[1-3689]|1[1-79]|[379]\\d|4[13]|5[1-5]))96\\d{3,4}",[7,8,9,10,11]]],"00"],"CO":["57","00(?:4(?:[14]4|56)|[579])","(?:60\\d\\d|9101)\\d{6}|(?:1\\d|3)\\d{9}",[10,11],[["(\\d{3})(\\d{7})","$1 $2",["6"],"($1)"],["(\\d{3})(\\d{7})","$1 $2",["3[0-357]|91"]],["(\\d)(\\d{3})(\\d{7})","$1-$2-$3",["1"],"0$1",0,"$1 $2 $3"]],"0",0,"0(4(?:[14]4|56)|[579])?",0,0,0,[["601055(?:[0-4]\\d|50)\\d\\d|6010(?:[0-4]\\d|5[0-4])\\d{4}|60[124-8][2-9]\\d{6}",[10]],["3333(?:0(?:0\\d|1[0-5])|[4-9]\\d\\d)\\d{3}|(?:3(?:24[1-9]|3(?:00|3[0-24-9]))|9101)\\d{6}|3(?:0[0-5]|1\\d|2[0-3]|5[01]|70)\\d{7}",[10]],["1800\\d{7}",[11]],["19(?:0[01]|4[78])\\d{7}",[11]]]],"CR":["506","00","(?:8\\d|90)\\d{8}|(?:[24-8]\\d{3}|3005)\\d{4}",[8,10],[["(\\d{4})(\\d{4})","$1 $2",["[2-7]|8[3-9]"]],["(\\d{3})(\\d{3})(\\d{4})","$1-$2-$3",["[89]"]]],0,0,"(19(?:0[0-2468]|1[09]|20|66|77|99))",0,0,0,[["210[7-9]\\d{4}|2(?:[024-7]\\d|1[1-9])\\d{5}",[8]],["(?:3005\\d|6500[01])\\d{3}|(?:5[07]|6[0-4]|7[0-3]|8[3-9])\\d{6}",[8]],["800\\d{7}",[10]],["90[059]\\d{7}",[10]],0,0,0,0,["(?:210[0-6]|4\\d{3}|5100)\\d{4}",[8]]]],"CU":["53","119","[27]\\d{6,7}|[34]\\d{5,7}|(?:5|8\\d\\d)\\d{7}",[6,7,8,10],[["(\\d{2})(\\d{4,6})","$1 $2",["2[1-4]|[34]"],"(0$1)"],["(\\d)(\\d{6,7})","$1 $2",["7"],"(0$1)"],["(\\d)(\\d{7})","$1 $2",["5"],"0$1"],["(\\d{3})(\\d{7})","$1 $2",["8"],"0$1"]],"0",0,0,0,0,0,[["(?:3[23]|48)\\d{4,6}|(?:31|4[36]|8(?:0[25]|78)\\d)\\d{6}|(?:2[1-4]|4[1257]|7\\d)\\d{5,6}"],["5\\d{7}",[8]],["800\\d{7}",[10]],0,0,0,0,0,0,["807\\d{7}",[10]]]],"CV":["238","0","(?:[2-59]\\d\\d|800)\\d{4}",[7],[["(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3",["[2-589]"]]],0,0,0,0,0,0,[["2(?:2[1-7]|3[0-8]|4[12]|5[1256]|6\\d|7[1-3]|8[1-5])\\d{4}"],["(?:36|5[1-389]|9\\d)\\d{5}"],["800\\d{4}"],0,0,0,0,0,["(?:3[3-5]|4[356])\\d{5}"]]],"CW":["599","00","(?:[34]1|60|(?:7|9\\d)\\d)\\d{5}",[7,8],[["(\\d{3})(\\d{4})","$1 $2",["[3467]"]],["(\\d)(\\d{3})(\\d{4})","$1 $2 $3",["9[4-8]"]]],0,0,0,0,0,"[69]",[["9(?:4(?:3[0-5]|4[14]|6\\d)|50\\d|7(?:2[014]|3[02-9]|4[4-9]|6[357]|77|8[7-9])|8(?:3[39]|[46]\\d|7[01]|8[57-9]))\\d{4}"],["953[01]\\d{4}|9(?:5[12467]|6[5-9])\\d{5}"],0,0,0,0,0,["955\\d{5}",[8]],0,["60[0-2]\\d{4}",[7]]]],"CX":["61","001[14-689]|14(?:1[14]|34|4[17]|[56]6|7[47]|88)0011","1(?:[0-79]\\d{8}(?:\\d{2})?|8[0-24-9]\\d{7})|[148]\\d{8}|1\\d{5,7}",[6,7,8,9,10,12],0,"0",0,"([59]\\d{7})$|0","8$1",0,0,[["8(?:51(?:0(?:01|30|59|88)|1(?:17|46|75)|2(?:22|35))|91(?:00[6-9]|1(?:[28]1|49|78)|2(?:09|63)|3(?:12|26|75)|4(?:56|97)|64\\d|7(?:0[01]|1[0-2])|958))\\d{3}",[9]],["4(?:79[01]|83[0-389]|93[0-6])\\d{5}|4(?:[0-3]\\d|4[047-9]|5[0-25-9]|6[016-9]|7[02-8]|8[0-24-9]|9[0-27-9])\\d{6}",[9]],["180(?:0\\d{3}|2)\\d{3}",[7,10]],["190[0-26]\\d{6}",[10]],0,0,0,0,["14(?:5(?:1[0458]|[23][458])|71\\d)\\d{4}",[9]],["13(?:00\\d{6}(?:\\d{2})?|45[0-4]\\d{3})|13\\d{4}",[6,8,10,12]]],"0011"],"CY":["357","00","(?:[279]\\d|[58]0)\\d{6}",[8],[["(\\d{2})(\\d{6})","$1 $2",["[257-9]"]]],0,0,0,0,0,0,[["2[2-6]\\d{6}"],["9(?:10|[4-79]\\d)\\d{5}"],["800\\d{5}"],["90[09]\\d{5}"],["700\\d{5}"],0,["(?:50|77)\\d{6}"],0,0,["80[1-9]\\d{5}"]]],"CZ":["420","00","(?:[2-578]\\d|60)\\d{7}|9\\d{8,11}",[9],[["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[2-8]|9[015-7]"]],["(\\d{2})(\\d{3})(\\d{3})(\\d{2})","$1 $2 $3 $4",["96"]],["(\\d{2})(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3 $4",["9"]],["(\\d{3})(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3 $4",["9"]]],0,0,0,0,0,0,[["(?:2\\d|3[1257-9]|4[16-9]|5[13-9])\\d{7}"],["(?:60[1-8]|7(?:0[2-5]|[2379]\\d))\\d{6}"],["800\\d{6}"],["9(?:0[05689]|76)\\d{6}"],["70[01]\\d{6}"],0,["9(?:5\\d|7[2-4])\\d{6}"],0,["9[17]0\\d{6}"],["8[134]\\d{7}"]]],"DE":["49","00","[2579]\\d{5,14}|49(?:[34]0|69|8\\d)\\d\\d?|49(?:37|49|60|7[089]|9\\d)\\d{1,3}|49(?:2[024-9]|3[2-689]|7[1-7])\\d{1,8}|(?:1|[368]\\d|4[0-8])\\d{3,13}|49(?:[015]\\d|2[13]|31|[46][1-8])\\d{1,9}",[4,5,6,7,8,9,10,11,12,13,14,15],[["(\\d{2})(\\d{3,13})","$1 $2",["3[02]|40|[68]9"],"0$1"],["(\\d{3})(\\d{3,12})","$1 $2",["2(?:0[1-389]|1[124]|2[18]|3[14])|3(?:[35-9][15]|4[015])|906|(?:2[4-9]|4[2-9]|[579][1-9]|[68][1-8])1","2(?:0[1-389]|12[0-8])|3(?:[35-9][15]|4[015])|906|2(?:[13][14]|2[18])|(?:2[4-9]|4[2-9]|[579][1-9]|[68][1-8])1"],"0$1"],["(\\d{4})(\\d{2,11})","$1 $2",["[24-6]|3(?:[3569][02-46-9]|4[2-4679]|7[2-467]|8[2-46-8])|70[2-8]|8(?:0[2-9]|[1-8])|90[7-9]|[79][1-9]","[24-6]|3(?:3(?:0[1-467]|2[127-9]|3[124578]|7[1257-9]|8[1256]|9[145])|4(?:2[135]|4[13578]|9[1346])|5(?:0[14]|2[1-3589]|6[1-4]|7[13468]|8[13568])|6(?:2[1-489]|3[124-6]|6[13]|7[12579]|8[1-356]|9[135])|7(?:2[1-7]|4[145]|6[1-5]|7[1-4])|8(?:21|3[1468]|6|7[1467]|8[136])|9(?:0[12479]|2[1358]|4[134679]|6[1-9]|7[136]|8[147]|9[1468]))|70[2-8]|8(?:0[2-9]|[1-8])|90[7-9]|[79][1-9]|3[68]4[1347]|3(?:47|60)[1356]|3(?:3[46]|46|5[49])[1246]|3[4579]3[1357]"],"0$1"],["(\\d{3})(\\d{4})","$1 $2",["138"],"0$1"],["(\\d{5})(\\d{2,10})","$1 $2",["3"],"0$1"],["(\\d{3})(\\d{5,11})","$1 $2",["181"],"0$1"],["(\\d{3})(\\d)(\\d{4,10})","$1 $2 $3",["1(?:3|80)|9"],"0$1"],["(\\d{3})(\\d{7,8})","$1 $2",["1[67]"],"0$1"],["(\\d{3})(\\d{7,12})","$1 $2",["8"],"0$1"],["(\\d{5})(\\d{6})","$1 $2",["185","1850","18500"],"0$1"],["(\\d{3})(\\d{4})(\\d{4})","$1 $2 $3",["7"],"0$1"],["(\\d{4})(\\d{7})","$1 $2",["18[68]"],"0$1"],["(\\d{5})(\\d{6})","$1 $2",["15[0568]"],"0$1"],["(\\d{4})(\\d{7})","$1 $2",["15[1279]"],"0$1"],["(\\d{3})(\\d{8})","$1 $2",["18"],"0$1"],["(\\d{3})(\\d{2})(\\d{7,8})","$1 $2 $3",["1(?:6[023]|7)"],"0$1"],["(\\d{4})(\\d{2})(\\d{7})","$1 $2 $3",["15[279]"],"0$1"],["(\\d{3})(\\d{2})(\\d{8})","$1 $2 $3",["15"],"0$1"]],"0",0,0,0,0,0,[["32\\d{9,11}|49[1-6]\\d{10}|322\\d{6}|49[0-7]\\d{3,9}|(?:[34]0|[68]9)\\d{3,13}|(?:2(?:0[1-689]|[1-3569]\\d|4[0-8]|7[1-7]|8[0-7])|3(?:[3569]\\d|4[0-79]|7[1-7]|8[1-8])|4(?:1[02-9]|[2-48]\\d|5[0-6]|6[0-8]|7[0-79])|5(?:0[2-8]|[124-6]\\d|[38][0-8]|[79][0-7])|6(?:0[02-9]|[1-358]\\d|[47][0-8]|6[1-9])|7(?:0[2-8]|1[1-9]|[27][0-7]|3\\d|[4-6][0-8]|8[0-5]|9[013-7])|8(?:0[2-9]|1[0-79]|2\\d|3[0-46-9]|4[0-6]|5[013-9]|6[1-8]|7[0-8]|8[0-24-6])|9(?:0[6-9]|[1-4]\\d|[589][0-7]|6[0-8]|7[0-467]))\\d{3,12}",[5,6,7,8,9,10,11,12,13,14,15]],["15[0-25-9]\\d{8}|1(?:6[023]|7\\d)\\d{7,8}",[10,11]],["800\\d{7,12}",[10,11,12,13,14,15]],["(?:137[7-9]|900(?:[135]|9\\d))\\d{6}",[10,11]],["700\\d{8}",[11]],0,["18(?:1\\d{5,11}|[2-9]\\d{8})",[8,9,10,11,12,13,14]],["16(?:4\\d{1,10}|[89]\\d{1,11})",[4,5,6,7,8,9,10,11,12,13,14]],0,["180\\d{5,11}|13(?:7[1-6]\\d\\d|8)\\d{4}",[7,8,9,10,11,12,13,14]]]],"DJ":["253","00","(?:2\\d|77)\\d{6}",[8],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[27]"]]],0,0,0,0,0,0,[["2(?:1[2-5]|7[45])\\d{5}"],["77\\d{6}"]]],"DK":["45","00","[2-9]\\d{7}",[8],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[2-9]"]]],0,0,0,0,0,0,[["(?:[2-7]\\d|8[126-9]|9[1-46-9])\\d{6}"],[""],["80\\d{6}"],["90\\d{6}"]]],"DM":["1","011","(?:[58]\\d\\d|767|900)\\d{7}",[10],0,"1",0,"([2-7]\\d{6})$|1","767$1",0,"767",[["767(?:2(?:55|66)|4(?:2[01]|4[0-25-9])|50[0-4])\\d{4}"],["767(?:2(?:[2-4689]5|7[5-7])|31[5-7]|61[1-8]|70[1-6])\\d{4}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"DO":["1","011","(?:[58]\\d\\d|900)\\d{7}",[10],0,"1",0,0,0,0,"8001|8[024]9",[["8(?:[04]9[2-9]\\d\\d|29(?:2(?:[0-59]\\d|6[04-9]|7[0-27]|8[0237-9])|3(?:[0-35-9]\\d|4[7-9])|[45]\\d\\d|6(?:[0-27-9]\\d|[3-5][1-9]|6[0135-8])|7(?:0[013-9]|[1-37]\\d|4[1-35689]|5[1-4689]|6[1-57-9]|8[1-79]|9[1-8])|8(?:0[146-9]|1[0-48]|[248]\\d|3[1-79]|5[01589]|6[013-68]|7[124-8]|9[0-8])|9(?:[0-24]\\d|3[02-46-9]|5[0-79]|60|7[0169]|8[57-9]|9[02-9])))\\d{4}"],["8[024]9[2-9]\\d{6}"],["8(?:00(?:14|[2-9]\\d)|(?:33|44|55|66|77|88)[2-9]\\d)\\d{5}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"DZ":["213","00","(?:[1-4]|[5-79]\\d|80)\\d{7}",[8,9],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[1-4]"],"0$1"],["(\\d{2})(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3 $4",["9"],"0$1"],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[5-8]"],"0$1"]],"0",0,0,0,0,0,[["9619\\d{5}|(?:1\\d|2[013-79]|3[0-8]|4[013-689])\\d{6}"],["(?:5(?:4[0-29]|5\\d|6[0-2])|6(?:[569]\\d|7[0-6])|7[7-9]\\d)\\d{6}",[9]],["800\\d{6}",[9]],["80[3-689]1\\d{5}",[9]],0,0,0,0,["98[23]\\d{6}",[9]],["80[12]1\\d{5}",[9]]]],"EC":["593","00","1\\d{9,10}|(?:[2-7]|9\\d)\\d{7}",[8,9,10,11],[["(\\d)(\\d{3})(\\d{4})","$1 $2-$3",["[2-7]"],"(0$1)",0,"$1-$2-$3"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["9"],"0$1"],["(\\d{4})(\\d{3})(\\d{3,4})","$1 $2 $3",["1"]]],"0",0,0,0,0,0,[["[2-7][2-7]\\d{6}",[8]],["964[0-2]\\d{5}|9(?:39|[57][89]|6[0-36-9]|[89]\\d)\\d{6}",[9]],["1800\\d{7}|1[78]00\\d{6}",[10,11]],0,0,0,0,0,["[2-7]890\\d{4}",[8]]]],"EE":["372","00","8\\d{9}|[4578]\\d{7}|(?:[3-8]\\d|90)\\d{5}",[7,8,10],[["(\\d{3})(\\d{4})","$1 $2",["[369]|4[3-8]|5(?:[0-2]|5[0-478]|6[45])|7[1-9]|88","[369]|4[3-8]|5(?:[02]|1(?:[0-8]|95)|5[0-478]|6(?:4[0-4]|5[1-589]))|7[1-9]|88"]],["(\\d{4})(\\d{3,4})","$1 $2",["[45]|8(?:00|[1-49])","[45]|8(?:00[1-9]|[1-49])"]],["(\\d{2})(\\d{2})(\\d{4})","$1 $2 $3",["7"]],["(\\d{4})(\\d{3})(\\d{3})","$1 $2 $3",["8"]]],0,0,0,0,0,0,[["(?:3[23589]|4[3-8]|6\\d|7[1-9]|88)\\d{5}",[7]],["(?:5\\d{5}|8(?:1(?:0(?:000|[3-9]\\d\\d)|(?:1(?:0[236]|1\\d)|(?:2[0-59]|[3-79]\\d)\\d)\\d)|2(?:0(?:000|(?:19|[2-7]\\d)\\d)|(?:(?:[124-6]\\d|3[5-9])\\d|7(?:[3679]\\d|8[13-9])|8(?:[2-6]\\d|7[01]))\\d)|[349]\\d{4}))\\d\\d|5(?:(?:[02]\\d|5[0-478])\\d|1(?:[0-8]\\d|95)|6(?:4[0-4]|5[1-589]))\\d{3}",[7,8]],["800(?:(?:0\\d\\d|1)\\d|[2-9])\\d{3}"],["(?:40\\d\\d|900)\\d{4}",[7,8]],["70[0-2]\\d{5}",[8]]]],"EG":["20","00","[189]\\d{8,9}|[24-6]\\d{8}|[135]\\d{7}",[8,9,10],[["(\\d)(\\d{7,8})","$1 $2",["[23]"],"0$1"],["(\\d{2})(\\d{6,7})","$1 $2",["1[35]|[4-6]|8[2468]|9[235-7]"],"0$1"],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["[189]"],"0$1"]],"0",0,0,0,0,0,[["13[23]\\d{6}|(?:15|57)\\d{6,7}|(?:2[2-4]|3|4[05-8]|5[05]|6[24-689]|8[2468]|9[235-7])\\d{7}",[8,9]],["1[0-25]\\d{8}",[10]],["800\\d{7}",[10]],["900\\d{7}",[10]]]],"EH":["212","00","[5-8]\\d{8}",[9],0,"0",0,0,0,0,"528[89]",[["528[89]\\d{5}"],["(?:6(?:[0-79]\\d|8[0-247-9])|7(?:[017]\\d|2[0-2]|6[0-8]|8[0-3]))\\d{6}"],["80\\d{7}"],["89\\d{7}"],0,0,0,0,["592(?:4[0-2]|93)\\d{4}"]]],"ER":["291","00","[178]\\d{6}",[7],[["(\\d)(\\d{3})(\\d{3})","$1 $2 $3",["[178]"],"0$1"]],"0",0,0,0,0,0,[["(?:1(?:1[12568]|[24]0|55|6[146])|8\\d\\d)\\d{4}"],["(?:17[1-3]|7\\d\\d)\\d{4}"]]],"ES":["34","00","[5-9]\\d{8}",[9],[["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[89]00"]],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[5-9]"]]],0,0,0,0,0,0,[["96906(?:0[0-8]|1[1-9]|[2-9]\\d)\\d\\d|9(?:69(?:0[0-57-9]|[1-9]\\d)|73(?:[0-8]\\d|9[1-9]))\\d{4}|(?:8(?:[1356]\\d|[28][0-8]|[47][1-9])|9(?:[135]\\d|[268][0-8]|4[1-9]|7[124-9]))\\d{6}"],["(?:590[16]00\\d|9(?:6906(?:09|10)|7390\\d\\d))\\d\\d|(?:6\\d|7[1-48])\\d{7}"],["[89]00\\d{6}"],["80[367]\\d{6}"],["70\\d{7}"],0,["51\\d{7}"],0,0,["90[12]\\d{6}"]]],"ET":["251","00","(?:11|[2-579]\\d)\\d{7}",[9],[["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["[1-579]"],"0$1"]],"0",0,0,0,0,0,[["11667[01]\\d{3}|(?:11(?:1(?:1[124]|2[2-7]|3[1-5]|5[5-8]|8[6-8])|2(?:13|3[6-8]|5[89]|7[05-9]|8[2-6])|3(?:2[01]|3[0-289]|4[1289]|7[1-4]|87)|4(?:1[69]|3[2-49]|4[0-3]|6[5-8])|5(?:1[578]|44|5[0-4])|6(?:1[578]|2[69]|39|4[5-7]|5[0-5]|6[0-59]|8[015-8]))|2(?:2(?:11[1-9]|22[0-7]|33\\d|44[1467]|66[1-68])|5(?:11[124-6]|33[2-8]|44[1467]|55[14]|66[1-3679]|77[124-79]|880))|3(?:3(?:11[0-46-8]|(?:22|55)[0-6]|33[0134689]|44[04]|66[01467])|4(?:44[0-8]|55[0-69]|66[0-3]|77[1-5]))|4(?:6(?:119|22[0-24-7]|33[1-5]|44[13-69]|55[14-689]|660|88[1-4])|7(?:(?:11|22)[1-9]|33[13-7]|44[13-6]|55[1-689]))|5(?:7(?:227|55[05]|(?:66|77)[14-8])|8(?:11[149]|22[013-79]|33[0-68]|44[013-8]|550|66[1-5]|77\\d)))\\d{4}"],["7001\\d{5}|(?:7(?:0[1-9]|1[01]|77|86|99)|9\\d\\d)\\d{6}"]]],"FI":["358","00|99(?:[01469]|5(?:[14]1|3[23]|5[59]|77|88|9[09]))","[1-35689]\\d{4}|7\\d{10,11}|(?:[124-7]\\d|3[0-46-9])\\d{8}|[1-9]\\d{5,8}",[5,6,7,8,9,10,11,12],[["(\\d)(\\d{4,9})","$1 $2",["[2568][1-8]|3(?:0[1-9]|[1-9])|9"],"0$1"],["(\\d{3})(\\d{3,7})","$1 $2",["[12]00|[368]|70[07-9]"],"0$1"],["(\\d{2})(\\d{4,8})","$1 $2",["[1245]|7[135]"],"0$1"],["(\\d{2})(\\d{6,10})","$1 $2",["7"],"0$1"]],"0",0,0,0,0,"1[03-79]|[2-9]",[["(?:1[3-79][1-8]|[235689][1-8]\\d)\\d{2,6}",[5,6,7,8,9]],["4946\\d{2,6}|(?:4[0-8]|50)\\d{4,8}",[6,7,8,9,10]],["800\\d{4,6}",[7,8,9]],["[67]00\\d{5,6}",[8,9]],0,0,["20\\d{4,8}|60[12]\\d{5,6}|7(?:099\\d{4,5}|5[03-9]\\d{3,7})|20[2-59]\\d\\d|(?:606|7(?:0[78]|1|3\\d))\\d{7}|(?:10|29|3[09]|70[1-5]\\d)\\d{4,8}"]],"00"],"FJ":["679","0(?:0|52)","45\\d{5}|(?:0800\\d|[235-9])\\d{6}",[7,11],[["(\\d{3})(\\d{4})","$1 $2",["[235-9]|45"]],["(\\d{4})(\\d{3})(\\d{4})","$1 $2 $3",["0"]]],0,0,0,0,0,0,[["603\\d{4}|(?:3[0-5]|6[25-7]|8[58])\\d{5}",[7]],["(?:[279]\\d|45|5[01568]|8[034679])\\d{5}",[7]],["0800\\d{7}",[11]]],"00"],"FK":["500","00","[2-7]\\d{4}",[5],0,0,0,0,0,0,0,[["[2-47]\\d{4}"],["[56]\\d{4}"]]],"FM":["691","00","(?:[39]\\d\\d|820)\\d{4}",[7],[["(\\d{3})(\\d{4})","$1 $2",["[389]"]]],0,0,0,0,0,0,[["31(?:00[67]|208|309)\\d\\d|(?:3(?:[2357]0[1-9]|602|804|905)|(?:820|9[2-6]\\d)\\d)\\d{3}"],["31(?:00[67]|208|309)\\d\\d|(?:3(?:[2357]0[1-9]|602|804|905)|(?:820|9[2-7]\\d)\\d)\\d{3}"]]],"FO":["298","00","[2-9]\\d{5}",[6],[["(\\d{6})","$1",["[2-9]"]]],0,0,"(10(?:01|[12]0|88))",0,0,0,[["(?:20|[34]\\d|8[19])\\d{4}"],["(?:[27][1-9]|5\\d|9[16])\\d{4}"],["80[257-9]\\d{3}"],["90(?:[13-5][15-7]|2[125-7]|9\\d)\\d\\d"],0,0,0,0,["(?:6[0-36]|88)\\d{4}"]]],"FR":["33","00","[1-9]\\d{8}",[9],[["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["8"],"0 $1"],["(\\d)(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4 $5",["[1-79]"],"0$1"]],"0",0,0,0,0,0,[["(?:[1-35]\\d|4[1-9])\\d{7}"],["(?:6(?:[0-24-8]\\d|3[0-8]|9[589])|7[3-9]\\d)\\d{6}"],["80[0-5]\\d{6}"],["836(?:0[0-36-9]|[1-9]\\d)\\d{4}|8(?:1[2-9]|2[2-47-9]|3[0-57-9]|[569]\\d|8[0-35-9])\\d{6}"],0,0,["80[6-9]\\d{6}"],0,["9\\d{8}"],["8(?:1[01]|2[0156]|4[02]|84)\\d{6}"]]],"GA":["241","00","(?:[067]\\d|11)\\d{6}|[2-7]\\d{6}",[7,8],[["(\\d)(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[2-7]"],"0$1"],["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["0"]],["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["11|[67]"],"0$1"]],0,0,"0(11\\d{6}|60\\d{6}|61\\d{6}|6[256]\\d{6}|7[467]\\d{6})","$1",0,0,[["[01]1\\d{6}",[8]],["(?:(?:0[2-7]|7[467])\\d|6(?:0[0-4]|10|[256]\\d))\\d{5}|[2-7]\\d{6}"]]],"GB":["44","00","[1-357-9]\\d{9}|[18]\\d{8}|8\\d{6}",[7,9,10],[["(\\d{3})(\\d{4})","$1 $2",["800","8001","80011","800111","8001111"],"0$1"],["(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3",["845","8454","84546","845464"],"0$1"],["(\\d{3})(\\d{6})","$1 $2",["800"],"0$1"],["(\\d{5})(\\d{4,5})","$1 $2",["1(?:38|5[23]|69|76|94)","1(?:(?:38|69)7|5(?:24|39)|768|946)","1(?:3873|5(?:242|39[4-6])|(?:697|768)[347]|9467)"],"0$1"],["(\\d{4})(\\d{5,6})","$1 $2",["1(?:[2-69][02-9]|[78])"],"0$1"],["(\\d{2})(\\d{4})(\\d{4})","$1 $2 $3",["[25]|7(?:0|6[02-9])","[25]|7(?:0|6(?:[03-9]|2[356]))"],"0$1"],["(\\d{4})(\\d{6})","$1 $2",["7"],"0$1"],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["[1389]"],"0$1"]],"0",0,0,0,0,0,[["(?:1(?:1(?:3(?:[0-58]\\d\\d|73[0235])|4(?:[0-5]\\d\\d|69[7-9]|70[0-579])|(?:(?:5[0-26-9]|[78][0-49])\\d|6(?:[0-4]\\d|50))\\d)|2(?:(?:0[024-9]|2[3-9]|3[3-79]|4[1-689]|[58][02-9]|6[0-47-9]|7[013-9]|9\\d)\\d\\d|1(?:[0-7]\\d\\d|8(?:[02]\\d|1[0-246-9])))|(?:3(?:0\\d|1[0-8]|[25][02-9]|3[02-579]|[468][0-46-9]|7[1-35-79]|9[2-578])|4(?:0[03-9]|[137]\\d|[28][02-57-9]|4[02-69]|5[0-8]|[69][0-79])|5(?:0[1-35-9]|[16]\\d|2[024-9]|3[015689]|4[02-9]|5[03-9]|7[0-35-9]|8[0-468]|9[0-57-9])|6(?:0[034689]|1\\d|2[0-35689]|[38][013-9]|4[1-467]|5[0-69]|6[13-9]|7[0-8]|9[0-24578])|7(?:0[0246-9]|2\\d|3[0236-8]|4[03-9]|5[0-46-9]|6[013-9]|7[0-35-9]|8[024-9]|9[02-9])|8(?:0[35-9]|2[1-57-9]|3[02-578]|4[0-578]|5[124-9]|6[2-69]|7\\d|8[02-9]|9[02569])|9(?:0[02-589]|[18]\\d|2[02-689]|3[1-57-9]|4[2-9]|5[0-579]|6[2-47-9]|7[0-24578]|9[2-57]))\\d\\d)|2(?:0[013478]|3[0189]|4[017]|8[0-46-9]|9[0-2])\\d{3})\\d{4}|1(?:2(?:0(?:46[1-4]|87[2-9])|545[1-79]|76(?:2\\d|3[1-8]|6[1-6])|9(?:7(?:2[0-4]|3[2-5])|8(?:2[2-8]|7[0-47-9]|8[3-5])))|3(?:6(?:38[2-5]|47[23])|8(?:47[04-9]|64[0157-9]))|4(?:044[1-7]|20(?:2[23]|8\\d)|6(?:0(?:30|5[2-57]|6[1-8]|7[2-8])|140)|8(?:052|87[1-3]))|5(?:2(?:4(?:3[2-79]|6\\d)|76\\d)|6(?:26[06-9]|686))|6(?:06(?:4\\d|7[4-79])|295[5-7]|35[34]\\d|47(?:24|61)|59(?:5[08]|6[67]|74)|9(?:55[0-4]|77[23]))|7(?:26(?:6[13-9]|7[0-7])|(?:442|688)\\d|50(?:2[0-3]|[3-68]2|76))|8(?:27[56]\\d|37(?:5[2-5]|8[239])|843[2-58])|9(?:0(?:0(?:6[1-8]|85)|52\\d)|3583|4(?:66[1-8]|9(?:2[01]|81))|63(?:23|3[1-4])|9561))\\d{3}",[9,10]],["7(?:457[0-57-9]|700[01]|911[028])\\d{5}|7(?:[1-3]\\d\\d|4(?:[0-46-9]\\d|5[0-689])|5(?:0[0-8]|[13-9]\\d|2[0-35-9])|7(?:0[1-9]|[1-7]\\d|8[02-9]|9[0-689])|8(?:[014-9]\\d|[23][0-8])|9(?:[024-9]\\d|1[02-9]|3[0-689]))\\d{6}",[10]],["80[08]\\d{7}|800\\d{6}|8001111"],["(?:8(?:4[2-5]|7[0-3])|9(?:[01]\\d|8[2-49]))\\d{7}|845464\\d",[7,10]],["70\\d{8}",[10]],0,["(?:3[0347]|55)\\d{8}",[10]],["76(?:464|652)\\d{5}|76(?:0[0-28]|2[356]|34|4[01347]|5[49]|6[0-369]|77|8[14]|9[139])\\d{6}",[10]],["56\\d{8}",[10]]],0," x"],"GD":["1","011","(?:473|[58]\\d\\d|900)\\d{7}",[10],0,"1",0,"([2-9]\\d{6})$|1","473$1",0,"473",[["473(?:2(?:3[0-2]|69)|3(?:2[89]|86)|4(?:[06]8|3[5-9]|4[0-49]|5[5-79]|73|90)|63[68]|7(?:58|84)|800|938)\\d{4}"],["473(?:4(?:0[2-79]|1[04-9]|2[0-5]|58)|5(?:2[01]|3[3-8])|901)\\d{4}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"GE":["995","00","(?:[3-57]\\d\\d|800)\\d{6}",[9],[["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["70"],"0$1"],["(\\d{2})(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3 $4",["32"],"0$1"],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[57]"]],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[348]"],"0$1"]],"0",0,0,0,0,0,[["(?:3(?:[256]\\d|4[124-9]|7[0-4])|4(?:1\\d|2[2-7]|3[1-79]|4[2-8]|7[239]|9[1-7]))\\d{6}"],["5(?:(?:(?:0555|1(?:[17]77|555))[5-9]|757(?:7[7-9]|8[01]))\\d|22252[0-4])\\d\\d|(?:5(?:00(?:0\\d|44|5[05]|77|88|99)|1(?:1(?:00|[124]\\d|3[01])|4\\d\\d)|(?:44|68)\\d\\d|5(?:[0157-9]\\d\\d|200)|7(?:[0147-9]\\d\\d|5(?:00|[57]5))|8(?:0(?:[01]\\d|2[0-4])|58[89]|8(?:55|88))|9(?:090|[1-35-9]\\d\\d))|790\\d\\d)\\d{4}|5(?:0(?:070|505)|1(?:0[01]0|1(?:07|33|51))|2(?:0[02]0|2[25]2)|3(?:0[03]0|3[35]3)|(?:40[04]|900)0|5222)[0-4]\\d{3}"],["800\\d{6}"],0,0,0,0,0,["70[67]\\d{6}"]]],"GF":["594","00","[56]94\\d{6}|(?:80|9\\d)\\d{7}",[9],[["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[56]|9[47]"],"0$1"],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[89]"],"0$1"]],"0",0,0,0,0,0,[["594(?:[0239]\\d|1[0-2]|4[03-9]|5[6-9]|6[0-3]|80)\\d{4}"],["694(?:[0-249]\\d|3[0-8])\\d{4}"],["80[0-5]\\d{6}"],0,0,0,0,0,["9(?:(?:396|76\\d)\\d|476[01])\\d{4}"]]],"GG":["44","00","(?:1481|[357-9]\\d{3})\\d{6}|8\\d{6}(?:\\d{2})?",[7,9,10],0,"0",0,"([25-9]\\d{5})$|0","1481$1",0,0,[["1481[25-9]\\d{5}",[10]],["7(?:(?:781|839)\\d|911[17])\\d{5}",[10]],["80[08]\\d{7}|800\\d{6}|8001111"],["(?:8(?:4[2-5]|7[0-3])|9(?:[01]\\d|8[0-3]))\\d{7}|845464\\d",[7,10]],["70\\d{8}",[10]],0,["(?:3[0347]|55)\\d{8}",[10]],["76(?:464|652)\\d{5}|76(?:0[0-28]|2[356]|34|4[01347]|5[49]|6[0-369]|77|8[14]|9[139])\\d{6}",[10]],["56\\d{8}",[10]]]],"GH":["233","00","(?:[235]\\d{3}|800)\\d{5}",[8,9],[["(\\d{3})(\\d{5})","$1 $2",["8"],"0$1"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["[235]"],"0$1"]],"0",0,0,0,0,0,[["3082[0-5]\\d{4}|3(?:0(?:[237]\\d|8[01])|[167](?:2[0-6]|7\\d|80)|2(?:2[0-5]|7\\d|80)|3(?:2[0-3]|7\\d|80)|4(?:2[013-9]|3[01]|7\\d|80)|5(?:2[0-7]|7\\d|80)|8(?:2[0-2]|7\\d|80)|9(?:[28]0|7\\d))\\d{5}",[9]],["(?:2(?:[0346-9]\\d|5[67])|5(?:[03-7]\\d|9[1-9]))\\d{6}",[9]],["800\\d{5}",[8]]]],"GI":["350","00","(?:[25]\\d|60)\\d{6}",[8],[["(\\d{3})(\\d{5})","$1 $2",["2"]]],0,0,0,0,0,0,[["2190[0-2]\\d{3}|2(?:0(?:[02]\\d|3[01])|16[24-9]|2[2-5]\\d)\\d{4}"],["5251[0-4]\\d{3}|(?:5(?:[146-8]\\d\\d|250)|60(?:1[01]|6\\d))\\d{4}"]]],"GL":["299","00","(?:19|[2-689]\\d|70)\\d{4}",[6],[["(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3",["19|[2-9]"]]],0,0,0,0,0,0,[["(?:19|3[1-7]|6[14689]|70|8[14-79]|9\\d)\\d{4}"],["[245]\\d{5}"],["80\\d{4}"],0,0,0,0,0,["3[89]\\d{4}"]]],"GM":["220","00","[2-9]\\d{6}",[7],[["(\\d{3})(\\d{4})","$1 $2",["[2-9]"]]],0,0,0,0,0,0,[["(?:4(?:[23]\\d\\d|4(?:1[024679]|[6-9]\\d))|5(?:5(?:3\\d|4[0-7])|6[67]\\d|7(?:1[04]|2[035]|3[58]|48))|8\\d{3})\\d{3}"],["(?:[23679]\\d|5[0-489])\\d{5}"]]],"GN":["224","00","722\\d{6}|(?:3|6\\d)\\d{7}",[8,9],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["3"]],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[67]"]]],0,0,0,0,0,0,[["3(?:0(?:24|3[12]|4[1-35-7]|5[13]|6[189]|[78]1|9[1478])|1\\d\\d)\\d{4}",[8]],["6[0-356]\\d{7}",[9]],0,0,0,0,0,0,["722\\d{6}",[9]]]],"GP":["590","00","590\\d{6}|(?:69|80|9\\d)\\d{7}",[9],[["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[569]"],"0$1"],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["8"],"0$1"]],"0",0,0,0,0,0,[["590(?:0[1-68]|[14][0-24-9]|2[0-68]|3[1289]|5[3-579]|[68][0-689]|7[08]|9\\d)\\d{4}"],["69(?:0\\d\\d|1(?:2[2-9]|3[0-5]))\\d{4}"],["80[0-5]\\d{6}"],0,0,0,0,0,["9(?:(?:395|76[018])\\d|475[01])\\d{4}"]]],"GQ":["240","00","222\\d{6}|(?:3\\d|55|[89]0)\\d{7}",[9],[["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[235]"]],["(\\d{3})(\\d{6})","$1 $2",["[89]"]]],0,0,0,0,0,0,[["33[0-24-9]\\d[46]\\d{4}|3(?:33|5\\d)\\d[7-9]\\d{4}"],["(?:222|55\\d)\\d{6}"],["80\\d[1-9]\\d{5}"],["90\\d[1-9]\\d{5}"]]],"GR":["30","00","5005000\\d{3}|8\\d{9,11}|(?:[269]\\d|70)\\d{8}",[10,11,12],[["(\\d{2})(\\d{4})(\\d{4})","$1 $2 $3",["21|7"]],["(\\d{4})(\\d{6})","$1 $2",["2(?:2|3[2-57-9]|4[2-469]|5[2-59]|6[2-9]|7[2-69]|8[2-49])|5"]],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["[2689]"]],["(\\d{3})(\\d{3,4})(\\d{5})","$1 $2 $3",["8"]]],0,0,0,0,0,0,[["2(?:1\\d\\d|2(?:2[1-46-9]|[36][1-8]|4[1-7]|5[1-4]|7[1-5]|[89][1-9])|3(?:1\\d|2[1-57]|[35][1-3]|4[13]|7[1-7]|8[124-6]|9[1-79])|4(?:1\\d|2[1-8]|3[1-4]|4[13-5]|6[1-578]|9[1-5])|5(?:1\\d|[29][1-4]|3[1-5]|4[124]|5[1-6])|6(?:1\\d|[269][1-6]|3[1245]|4[1-7]|5[13-9]|7[14]|8[1-5])|7(?:1\\d|2[1-5]|3[1-6]|4[1-7]|5[1-57]|6[135]|9[125-7])|8(?:1\\d|2[1-5]|[34][1-4]|9[1-57]))\\d{6}",[10]],["68[57-9]\\d{7}|(?:69|94)\\d{8}",[10]],["800\\d{7,9}"],["90[19]\\d{7}",[10]],["70\\d{8}",[10]],0,["5005000\\d{3}",[10]],0,0,["8(?:0[16]|12|[27]5|50)\\d{7}",[10]]]],"GT":["502","00","(?:1\\d{3}|[2-7])\\d{7}",[8,11],[["(\\d{4})(\\d{4})","$1 $2",["[2-7]"]],["(\\d{4})(\\d{3})(\\d{4})","$1 $2 $3",["1"]]],0,0,0,0,0,0,[["[267][2-9]\\d{6}",[8]],["[3-5]\\d{7}",[8]],["18[01]\\d{8}",[11]],["19\\d{9}",[11]]]],"GU":["1","011","(?:[58]\\d\\d|671|900)\\d{7}",[10],0,"1",0,"([3-9]\\d{6})$|1","671$1",0,"671",[["671(?:3(?:00|3[39]|4[349]|55|6[26])|4(?:00|56|7[1-9]|8[02-46-9])|5(?:55|6[2-5]|88)|6(?:3[2-578]|4[24-9]|5[34]|78|8[235-9])|7(?:[0479]7|2[0167]|3[45]|8[7-9])|8(?:[2-57-9]8|6[48])|9(?:2[29]|6[79]|7[1279]|8[7-9]|9[78]))\\d{4}"],[""],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"GW":["245","00","[49]\\d{8}|4\\d{6}",[7,9],[["(\\d{3})(\\d{4})","$1 $2",["40"]],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[49]"]]],0,0,0,0,0,0,[["443\\d{6}",[9]],["9(?:5\\d|6[569]|77)\\d{6}",[9]],0,0,0,0,0,0,["40\\d{5}",[7]]]],"GY":["592","001","9008\\d{3}|(?:[2-467]\\d\\d|862)\\d{4}",[7],[["(\\d{3})(\\d{4})","$1 $2",["[2-46-9]"]]],0,0,0,0,0,0,[["(?:2(?:1[6-9]|2[0-35-9]|3[1-4]|5[3-9]|6\\d|7[0-24-79])|3(?:2[25-9]|3\\d)|4(?:4[0-24]|5[56])|77[1-57])\\d{4}"],["(?:6\\d\\d|70[0-35-7])\\d{4}"],["(?:289|862)\\d{4}"],["9008\\d{3}"]]],"HK":["852","00(?:30|5[09]|[126-9]?)","8[0-46-9]\\d{6,7}|9\\d{4,7}|(?:[2-7]|9\\d{3})\\d{7}",[5,6,7,8,9,11],[["(\\d{3})(\\d{2,5})","$1 $2",["900","9003"]],["(\\d{4})(\\d{4})","$1 $2",["[2-7]|8[1-4]|9(?:0[1-9]|[1-8])"]],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["8"]],["(\\d{3})(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3 $4",["9"]]],0,0,0,0,0,0,[["(?:2(?:[13-9]\\d|2[013-9])\\d|3(?:(?:[1569][0-24-9]|4[0-246-9]|7[0-24-69])\\d|8(?:[45][0-8]|6[01]|9\\d))|58(?:0[1-8]|1[2-9]))\\d{4}",[8]],["(?:4(?:44[5-9]|6(?:0[0-7]|1[0-6]|4[0-57-9]|6[0-4]|7[0-8]))|573[0-6]|6(?:26[013-8]|66[0-3])|70(?:7[1-5]|8[0-4])|848[015-9]|9(?:29[013-9]|59[0-4]))\\d{4}|(?:4(?:4[01]|6[2358])|5(?:[1-59][0-46-9]|6[0-4689]|7[0-246-9])|6(?:0[1-9]|[13-59]\\d|[268][0-57-9]|7[0-79])|84[09]|9(?:0[1-9]|1[02-9]|[2358][0-8]|[467]\\d))\\d{5}",[8]],["800\\d{6}",[9]],["900(?:[0-24-9]\\d{7}|3\\d{1,4})",[5,6,7,8,11]],["8(?:1[0-4679]\\d|2(?:[0-36]\\d|7[0-4])|3(?:[034]\\d|2[09]|70))\\d{4}",[8]],0,["30(?:0[1-9]|[15-7]\\d|2[047]|89)\\d{4}",[8]],["7(?:1(?:0[0-38]|1[0-3679]|3[013]|69|9[0136])|2(?:[02389]\\d|1[18]|7[27-9])|3(?:[0-38]\\d|7[0-369]|9[2357-9])|47\\d|5(?:[178]\\d|5[0-5])|6(?:0[0-7]|2[236-9]|[35]\\d)|7(?:[27]\\d|8[7-9])|8(?:[23689]\\d|7[1-9])|9(?:[025]\\d|6[0-246-8]|7[0-36-9]|8[238]))\\d{4}",[8]]],"00"],"HN":["504","00","8\\d{10}|[237-9]\\d{7}",[8,11],[["(\\d{4})(\\d{4})","$1-$2",["[237-9]"]]],0,0,0,0,0,0,[["2(?:2(?:0[0-59]|1[1-9]|[23]\\d|4[02-6]|5[57]|6[245]|7[0135689]|8[01346-9]|9[0-2])|4(?:0[578]|2[3-59]|3[13-9]|4[0-68]|5[1-3589])|5(?:0[2357-9]|1[1-356]|4[03-5]|5\\d|6[014-69]|7[04]|80)|6(?:[056]\\d|17|2[067]|3[047]|4[0-378]|[78][0-8]|9[01])|7(?:0[5-79]|6[46-9]|7[02-9]|8[034]|91)|8(?:79|8[0-357-9]|9[1-57-9]))\\d{4}",[8]],["[37-9]\\d{7}",[8]],["8002\\d{7}",[11]]]],"HR":["385","00","(?:[24-69]\\d|3[0-79])\\d{7}|80\\d{5,7}|[1-79]\\d{7}|6\\d{5,6}",[6,7,8,9],[["(\\d{2})(\\d{2})(\\d{2,3})","$1 $2 $3",["6[01]"],"0$1"],["(\\d{3})(\\d{2})(\\d{2,3})","$1 $2 $3",["8"],"0$1"],["(\\d)(\\d{4})(\\d{3})","$1 $2 $3",["1"],"0$1"],["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["[67]"],"0$1"],["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["9"],"0$1"],["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["[2-5]"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["8"],"0$1"]],"0",0,0,0,0,0,[["1\\d{7}|(?:2[0-3]|3[1-5]|4[02-47-9]|5[1-3])\\d{6,7}",[8,9]],["9(?:(?:0[1-9]|[12589]\\d)\\d\\d|7(?:[0679]\\d\\d|5(?:[01]\\d|44|77|9[67])))\\d{4}|98\\d{6}",[8,9]],["80[01]\\d{4,6}",[7,8,9]],["6[01459]\\d{6}|6[01]\\d{4,5}",[6,7,8]],["7[45]\\d{6}",[8]],0,["62\\d{6,7}|72\\d{6}",[8,9]]]],"HT":["509","00","(?:[2-489]\\d|55)\\d{6}",[8],[["(\\d{2})(\\d{2})(\\d{4})","$1 $2 $3",["[2-589]"]]],0,0,0,0,0,0,[["2(?:2\\d|5[1-5]|81|9[149])\\d{5}"],["(?:[34]\\d|55)\\d{6}"],["8\\d{7}"],0,0,0,0,0,["9(?:[67][0-4]|8[0-3589]|9\\d)\\d{5}"]]],"HU":["36","00","[235-7]\\d{8}|[1-9]\\d{7}",[8,9],[["(\\d)(\\d{3})(\\d{4})","$1 $2 $3",["1"],"(06 $1)"],["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["[27][2-9]|3[2-7]|4[24-9]|5[2-79]|6|8[2-57-9]|9[2-69]"],"(06 $1)"],["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["[2-9]"],"06 $1"]],"06",0,0,0,0,0,[["(?:1\\d|[27][2-9]|3[2-7]|4[24-9]|5[2-79]|6[23689]|8[2-57-9]|9[2-69])\\d{6}",[8]],["(?:[257]0|3[01])\\d{7}",[9]],["(?:[48]0\\d|680[29])\\d{5}"],["9[01]\\d{6}",[8]],0,0,["38\\d{7}",[9]],0,["21\\d{7}",[9]]]],"ID":["62","00[89]","(?:(?:00[1-9]|8\\d)\\d{4}|[1-36])\\d{6}|00\\d{10}|[1-9]\\d{8,10}|[2-9]\\d{7}",[7,8,9,10,11,12,13],[["(\\d)(\\d{3})(\\d{3})","$1 $2 $3",["15"]],["(\\d{2})(\\d{5,9})","$1 $2",["2[124]|[36]1"],"(0$1)"],["(\\d{3})(\\d{5,7})","$1 $2",["800"],"0$1"],["(\\d{3})(\\d{5,8})","$1 $2",["[2-79]"],"(0$1)"],["(\\d{3})(\\d{3,4})(\\d{3})","$1-$2-$3",["8[1-35-9]"],"0$1"],["(\\d{3})(\\d{6,8})","$1 $2",["1"],"0$1"],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["804"],"0$1"],["(\\d{3})(\\d)(\\d{3})(\\d{3})","$1 $2 $3 $4",["80"],"0$1"],["(\\d{3})(\\d{4})(\\d{4,5})","$1-$2-$3",["8"],"0$1"]],"0",0,0,0,0,0,[["2[124]\\d{7,8}|619\\d{8}|2(?:1(?:14|500)|2\\d{3})\\d{3}|61\\d{5,8}|(?:2(?:[35][1-4]|6[0-8]|7[1-6]|8\\d|9[1-8])|3(?:1|[25][1-8]|3[1-68]|4[1-3]|6[1-3568]|7[0-469]|8\\d)|4(?:0[1-589]|1[01347-9]|2[0-36-8]|3[0-24-68]|43|5[1-378]|6[1-5]|7[134]|8[1245])|5(?:1[1-35-9]|2[25-8]|3[124-9]|4[1-3589]|5[1-46]|6[1-8])|6(?:[25]\\d|3[1-69]|4[1-6])|7(?:02|[125][1-9]|[36]\\d|4[1-8]|7[0-36-9])|9(?:0[12]|1[013-8]|2[0-479]|5[125-8]|6[23679]|7[159]|8[01346]))\\d{5,8}",[7,8,9,10,11]],["8[1-35-9]\\d{7,10}",[9,10,11,12]],["00[17]803\\d{7}|(?:177\\d|800)\\d{5,7}|001803\\d{6}",[8,9,10,11,12,13]],["809\\d{7}",[10]],0,0,["(?:1500|8071\\d{3})\\d{3}",[7,10]],0,0,["804\\d{7}",[10]]]],"IE":["353","00","(?:1\\d|[2569])\\d{6,8}|4\\d{6,9}|7\\d{8}|8\\d{8,9}",[7,8,9,10],[["(\\d{2})(\\d{5})","$1 $2",["2[24-9]|47|58|6[237-9]|9[35-9]"],"(0$1)"],["(\\d{3})(\\d{5})","$1 $2",["[45]0"],"(0$1)"],["(\\d)(\\d{3,4})(\\d{4})","$1 $2 $3",["1"],"(0$1)"],["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["[2569]|4[1-69]|7[14]"],"(0$1)"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["70"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["81"],"(0$1)"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["[78]"],"0$1"],["(\\d{4})(\\d{3})(\\d{3})","$1 $2 $3",["1"]],["(\\d{2})(\\d{4})(\\d{4})","$1 $2 $3",["4"],"(0$1)"],["(\\d{2})(\\d)(\\d{3})(\\d{4})","$1 $2 $3 $4",["8"],"0$1"]],"0",0,0,0,0,0,[["(?:1\\d|21)\\d{6,7}|(?:2[24-9]|4(?:0[24]|5\\d|7)|5(?:0[45]|1\\d|8)|6(?:1\\d|[237-9])|9(?:1\\d|[35-9]))\\d{5}|(?:23|4(?:[1-469]|8\\d)|5[23679]|6[4-6]|7[14]|9[04])\\d{7}"],["8(?:22|[35-9]\\d)\\d{6}",[9]],["1800\\d{6}",[10]],["15(?:1[2-8]|[2-8]0|9[089])\\d{6}",[10]],["700\\d{6}",[9]],0,["818\\d{6}",[9]],0,["76\\d{7}",[9]],["18[59]0\\d{6}",[10]]]],"IL":["972","0(?:0|1[2-9])","1\\d{6}(?:\\d{3,5})?|[57]\\d{8}|[1-489]\\d{7}",[7,8,9,10,11,12],[["(\\d{4})(\\d{3})","$1-$2",["125"]],["(\\d{4})(\\d{2})(\\d{2})","$1-$2-$3",["121"]],["(\\d)(\\d{3})(\\d{4})","$1-$2-$3",["[2-489]"],"0$1"],["(\\d{2})(\\d{3})(\\d{4})","$1-$2-$3",["[57]"],"0$1"],["(\\d{4})(\\d{3})(\\d{3})","$1-$2-$3",["12"]],["(\\d{4})(\\d{6})","$1-$2",["159"]],["(\\d)(\\d{3})(\\d{3})(\\d{3})","$1-$2-$3-$4",["1[7-9]"]],["(\\d{3})(\\d{1,2})(\\d{3})(\\d{4})","$1-$2 $3-$4",["15"]]],"0",0,0,0,0,0,[["153\\d{8,9}|29[1-9]\\d{5}|(?:2[0-8]|[3489]\\d)\\d{6}",[8,11,12]],["5(?:(?:[02368]\\d|[19][2-9]|4[1-9])\\d|5(?:01|1[79]|2[2-9]|3[0-3]|4[34]|5[015689]|6[6-8]|7[0-267]|8[7-9]|9[1-9]))\\d{5}",[9]],["1(?:255|80[019]\\d{3})\\d{3}",[7,10]],["1212\\d{4}|1(?:200|9(?:0[0-2]|19))\\d{6}",[8,10]],0,0,["1599\\d{6}",[10]],0,["7(?:380|8(?:33|55|77|81))\\d{5}|7(?:18|2[23]|3[237]|47|6[258]|7\\d|82|9[2-9])\\d{6}",[9]],["1700\\d{6}",[10]]]],"IM":["44","00","1624\\d{6}|(?:[3578]\\d|90)\\d{8}",[10],0,"0",0,"([25-8]\\d{5})$|0","1624$1",0,"74576|(?:16|7[56])24",[["1624(?:230|[5-8]\\d\\d)\\d{3}"],["76245[06]\\d{4}|7(?:4576|[59]24\\d|624[0-4689])\\d{5}"],["808162\\d{4}"],["8(?:440[49]06|72299\\d)\\d{3}|(?:8(?:45|70)|90[0167])624\\d{4}"],["70\\d{8}"],0,["3440[49]06\\d{3}|(?:3(?:08162|3\\d{4}|45624|7(?:0624|2299))|55\\d{4})\\d{4}"],0,["56\\d{8}"]]],"IN":["91","00","(?:000800|[2-9]\\d\\d)\\d{7}|1\\d{7,12}",[8,9,10,11,12,13],[["(\\d{8})","$1",["5(?:0|2[23]|3[03]|[67]1|88)","5(?:0|2(?:21|3)|3(?:0|3[23])|616|717|888)","5(?:0|2(?:21|3)|3(?:0|3[23])|616|717|8888)"],0,1],["(\\d{4})(\\d{4,5})","$1 $2",["180","1800"],0,1],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["140"],0,1],["(\\d{2})(\\d{4})(\\d{4})","$1 $2 $3",["11|2[02]|33|4[04]|79[1-7]|80[2-46]","11|2[02]|33|4[04]|79(?:[1-6]|7[19])|80(?:[2-4]|6[0-589])","11|2[02]|33|4[04]|79(?:[124-6]|3(?:[02-9]|1[0-24-9])|7(?:1|9[1-6]))|80(?:[2-4]|6[0-589])"],"0$1",1],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["1(?:2[0-249]|3[0-25]|4[145]|[68]|7[1257])|2(?:1[257]|3[013]|4[01]|5[0137]|6[0158]|78|8[1568])|3(?:26|4[1-3]|5[34]|6[01489]|7[02-46]|8[159])|4(?:1[36]|2[1-47]|5[12]|6[0-26-9]|7[0-24-9]|8[013-57]|9[014-7])|5(?:1[025]|22|[36][25]|4[28]|5[12]|[78]1)|6(?:12|[2-4]1|5[17]|6[13]|80)|7(?:12|3[134]|4[47]|61|88)|8(?:16|2[014]|3[126]|6[136]|7[078]|8[34]|91)|(?:43|59|75)[15]|(?:1[59]|29|67|72)[14]","1(?:2[0-24]|3[0-25]|4[145]|[59][14]|6[1-9]|7[1257]|8[1-57-9])|2(?:1[257]|3[013]|4[01]|5[0137]|6[058]|78|8[1568]|9[14])|3(?:26|4[1-3]|5[34]|6[01489]|7[02-46]|8[159])|4(?:1[36]|2[1-47]|3[15]|5[12]|6[0-26-9]|7[0-24-9]|8[013-57]|9[014-7])|5(?:1[025]|22|[36][25]|4[28]|[578]1|9[15])|674|7(?:(?:2[14]|3[34]|5[15])[2-6]|61[346]|88[0-8])|8(?:70[2-6]|84[235-7]|91[3-7])|(?:1(?:29|60|8[06])|261|552|6(?:12|[2-47]1|5[17]|6[13]|80)|7(?:12|31|4[47])|8(?:16|2[014]|3[126]|6[136]|7[78]|83))[2-7]","1(?:2[0-24]|3[0-25]|4[145]|[59][14]|6[1-9]|7[1257]|8[1-57-9])|2(?:1[257]|3[013]|4[01]|5[0137]|6[058]|78|8[1568]|9[14])|3(?:26|4[1-3]|5[34]|6[01489]|7[02-46]|8[159])|4(?:1[36]|2[1-47]|3[15]|5[12]|6[0-26-9]|7[0-24-9]|8[013-57]|9[014-7])|5(?:1[025]|22|[36][25]|4[28]|[578]1|9[15])|6(?:12(?:[2-6]|7[0-8])|74[2-7])|7(?:(?:2[14]|5[15])[2-6]|3171|61[346]|88(?:[2-7]|82))|8(?:70[2-6]|84(?:[2356]|7[19])|91(?:[3-6]|7[19]))|73[134][2-6]|(?:74[47]|8(?:16|2[014]|3[126]|6[136]|7[78]|83))(?:[2-6]|7[19])|(?:1(?:29|60|8[06])|261|552|6(?:[2-4]1|5[17]|6[13]|7(?:1|4[0189])|80)|7(?:12|88[01]))[2-7]"],"0$1",1],["(\\d{4})(\\d{3})(\\d{3})","$1 $2 $3",["1(?:[2-479]|5[0235-9])|[2-5]|6(?:1[1358]|2[2457-9]|3[2-5]|4[235-7]|5[2-689]|6[24578]|7[235689]|8[1-6])|7(?:1[013-9]|28|3[129]|4[1-35689]|5[29]|6[02-5]|70)|807","1(?:[2-479]|5[0235-9])|[2-5]|6(?:1[1358]|2(?:[2457]|84|95)|3(?:[2-4]|55)|4[235-7]|5[2-689]|6[24578]|7[235689]|8[1-6])|7(?:1(?:[013-8]|9[6-9])|28[6-8]|3(?:17|2[0-49]|9[2-57])|4(?:1[2-4]|[29][0-7]|3[0-8]|[56]|8[0-24-7])|5(?:2[1-3]|9[0-6])|6(?:0[5689]|2[5-9]|3[02-8]|4|5[0-367])|70[13-7])|807[19]","1(?:[2-479]|5(?:[0236-9]|5[013-9]))|[2-5]|6(?:2(?:84|95)|355|83)|73179|807(?:1|9[1-3])|(?:1552|6(?:1[1358]|2[2457]|3[2-4]|4[235-7]|5[2-689]|6[24578]|7[235689]|8[124-6])\\d|7(?:1(?:[013-8]\\d|9[6-9])|28[6-8]|3(?:2[0-49]|9[2-57])|4(?:1[2-4]|[29][0-7]|3[0-8]|[56]\\d|8[0-24-7])|5(?:2[1-3]|9[0-6])|6(?:0[5689]|2[5-9]|3[02-8]|4\\d|5[0-367])|70[13-7]))[2-7]"],"0$1",1],["(\\d{5})(\\d{5})","$1 $2",["[6-9]"],"0$1",1],["(\\d{4})(\\d{2,4})(\\d{4})","$1 $2 $3",["1(?:6|8[06])","1(?:6|8[06]0)"],0,1],["(\\d{4})(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3 $4",["18"],0,1]],"0",0,0,0,0,0,[["2717(?:[2-7]\\d|95)\\d{4}|(?:271[0-689]|782[0-6])[2-7]\\d{5}|(?:170[24]|2(?:(?:[02][2-79]|90)\\d|80[13468])|(?:3(?:23|80)|683|79[1-7])\\d|4(?:20[24]|72[2-8])|552[1-7])\\d{6}|(?:11|33|4[04]|80)[2-7]\\d{7}|(?:342|674|788)(?:[0189][2-7]|[2-7]\\d)\\d{5}|(?:1(?:2[0-249]|3[0-25]|4[145]|[59][14]|6[014]|7[1257]|8[01346])|2(?:1[257]|3[013]|4[01]|5[0137]|6[0158]|78|8[1568]|9[14])|3(?:26|4[13]|5[34]|6[01489]|7[02-46]|8[159])|4(?:1[36]|2[1-47]|3[15]|5[12]|6[0-26-9]|7[014-9]|8[013-57]|9[014-7])|5(?:1[025]|22|[36][25]|4[28]|[578]1|9[15])|6(?:12|[2-47]1|5[17]|6[13]|80)|7(?:12|2[14]|3[134]|4[47]|5[15]|[67]1)|8(?:16|2[014]|3[126]|6[136]|7[078]|8[34]|91))[2-7]\\d{6}|(?:1(?:2[35-8]|3[346-9]|4[236-9]|[59][0235-9]|6[235-9]|7[34689]|8[257-9])|2(?:1[134689]|3[24-8]|4[2-8]|5[25689]|6[2-4679]|7[3-79]|8[2-479]|9[235-9])|3(?:01|1[79]|2[1245]|4[5-8]|5[125689]|6[235-7]|7[157-9]|8[2-46-8])|4(?:1[14578]|2[5689]|3[2-467]|5[4-7]|6[35]|73|8[2689]|9[2389])|5(?:[16][146-9]|2[14-8]|3[1346]|4[14-69]|5[46]|7[2-4]|8[2-8]|9[246])|6(?:1[1358]|2[2457]|3[2-4]|4[235-7]|5[2-689]|6[24578]|7[235689]|8[124-6])|7(?:1[013-9]|2[0235-9]|3[2679]|4[1-35689]|5[2-46-9]|[67][02-9]|8[013-7]|9[089])|8(?:1[1357-9]|2[235-8]|3[03-57-9]|4[0-24-9]|5\\d|6[2457-9]|7[1-6]|8[1256]|9[2-4]))\\d[2-7]\\d{5}",[10]],["(?:61279|7(?:887[02-9]|9(?:313|79[07-9]))|8(?:079[04-9]|(?:84|91)7[02-8]))\\d{5}|(?:6(?:12|[2-47]1|5[17]|6[13]|80)[0189]|7(?:1(?:2[0189]|9[0-5])|2(?:[14][017-9]|8[0-59])|3(?:2[5-8]|[34][017-9]|9[016-9])|4(?:1[015-9]|[29][89]|39|8[389])|5(?:[15][017-9]|2[04-9]|9[7-9])|6(?:0[0-47]|1[0-257-9]|2[0-4]|3[19]|5[4589])|70[0289]|88[089]|97[02-8])|8(?:0(?:6[67]|7[02-8])|70[017-9]|84[01489]|91[0-289]))\\d{6}|(?:7(?:31|4[47])|8(?:16|2[014]|3[126]|6[136]|7[78]|83))(?:[0189]\\d|7[02-8])\\d{5}|(?:6(?:[09]\\d|1[04679]|2[03689]|3[05-9]|4[0489]|50|6[069]|7[07]|8[7-9])|7(?:0\\d|2[0235-79]|3[05-8]|40|5[0346-8]|6[6-9]|7[1-9]|8[0-79]|9[089])|8(?:0[01589]|1[0-57-9]|2[235-9]|3[03-57-9]|[45]\\d|6[02457-9]|7[1-69]|8[0-25-9]|9[02-9])|9\\d\\d)\\d{7}|(?:6(?:(?:1[1358]|2[2457]|3[2-4]|4[235-7]|5[2-689]|6[24578]|8[124-6])\\d|7(?:[235689]\\d|4[0189]))|7(?:1(?:[013-8]\\d|9[6-9])|28[6-8]|3(?:2[0-49]|9[2-5])|4(?:1[2-4]|[29][0-7]|3[0-8]|[56]\\d|8[0-24-7])|5(?:2[1-3]|9[0-6])|6(?:0[5689]|2[5-9]|3[02-8]|4\\d|5[0-367])|70[13-7]|881))[0189]\\d{5}",[10]],["000800\\d{7}|1(?:600\\d{6}|80(?:0\\d{4,9}|3\\d{9}))"],["186[12]\\d{9}",[13]],0,0,["140\\d{7}",[10]],0,0,["1860\\d{7}",[11]]]],"IO":["246","00","3\\d{6}",[7],[["(\\d{3})(\\d{4})","$1 $2",["3"]]],0,0,0,0,0,0,[["37\\d{5}"],["38\\d{5}"]]],"IQ":["964","00","(?:1|7\\d\\d)\\d{7}|[2-6]\\d{7,8}",[8,9,10],[["(\\d)(\\d{3})(\\d{4})","$1 $2 $3",["1"],"0$1"],["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["[2-6]"],"0$1"],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["7"],"0$1"]],"0",0,0,0,0,0,[["1\\d{7}|(?:2[13-5]|3[02367]|4[023]|5[03]|6[026])\\d{6,7}",[8,9]],["7[3-9]\\d{8}",[10]]]],"IR":["98","00","[1-9]\\d{9}|(?:[1-8]\\d\\d|9)\\d{3,4}",[4,5,6,7,10],[["(\\d{4,5})","$1",["96"],"0$1"],["(\\d{2})(\\d{4,5})","$1 $2",["(?:1[137]|2[13-68]|3[1458]|4[145]|5[1468]|6[16]|7[1467]|8[13467])[12689]"],"0$1"],["(\\d{3})(\\d{3})(\\d{3,4})","$1 $2 $3",["9"],"0$1"],["(\\d{2})(\\d{4})(\\d{4})","$1 $2 $3",["[1-8]"],"0$1"]],"0",0,0,0,0,0,[["(?:1[137]|2[13-68]|3[1458]|4[145]|5[1468]|6[16]|7[1467]|8[13467])(?:[03-57]\\d{7}|[16]\\d{3}(?:\\d{4})?|[289]\\d{3}(?:\\d(?:\\d{3})?)?)|94(?:000[09]|2(?:121|[2689]0\\d)|30[0-2]\\d|4(?:111|40\\d))\\d{4}",[6,7,10]],["9(?:(?:0(?:[0-35]\\d|4[4-6])|(?:[13]\\d|2[0-3])\\d)\\d|9(?:[0-46]\\d\\d|5[15]0|8(?:1\\d|88)|9(?:0[0-3]|[19]\\d|21|77|8[7-9])))\\d{5}",[10]],0,0,0,0,["96(?:0[12]|2[16-8]|3(?:08|[14]5|[23]|66)|4(?:0|80)|5[01]|6[89]|86|9[19])",[4,5]]]],"IS":["354","00|1(?:0(?:01|[12]0)|100)","(?:38\\d|[4-9])\\d{6}",[7,9],[["(\\d{3})(\\d{4})","$1 $2",["[4-9]"]],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["3"]]],0,0,0,0,0,0,[["(?:4(?:1[0-24-69]|2[0-7]|[37][0-8]|4[0-24589]|5[0-68]|6\\d|8[0-36-8])|5(?:05|[156]\\d|2[02578]|3[0-579]|4[03-7]|7[0-2578]|8[0-35-9]|9[013-689])|872)\\d{4}",[7]],["(?:38[589]\\d\\d|6(?:1[1-8]|2[0-6]|3[026-9]|4[014679]|5[0159]|6[0-69]|70|8[06-8]|9\\d)|7(?:5[057]|[6-9]\\d)|8(?:2[0-59]|[3-69]\\d|8[238]))\\d{4}"],["80[0-8]\\d{4}",[7]],["90(?:0\\d|1[5-79]|2[015-79]|3[135-79]|4[125-7]|5[25-79]|7[1-37]|8[0-35-7])\\d{3}",[7]],0,0,["809\\d{4}",[7]],0,["49[0-24-79]\\d{4}",[7]]],"00"],"IT":["39","00","0\\d{5,10}|1\\d{8,10}|3(?:[0-8]\\d{7,10}|9\\d{7,8})|(?:55|70)\\d{8}|8\\d{5}(?:\\d{2,4})?",[6,7,8,9,10,11],[["(\\d{2})(\\d{4,6})","$1 $2",["0[26]"]],["(\\d{3})(\\d{3,6})","$1 $2",["0[13-57-9][0159]|8(?:03|4[17]|9[2-5])","0[13-57-9][0159]|8(?:03|4[17]|9(?:2|3[04]|[45][0-4]))"]],["(\\d{4})(\\d{2,6})","$1 $2",["0(?:[13-579][2-46-8]|8[236-8])"]],["(\\d{4})(\\d{4})","$1 $2",["894"]],["(\\d{2})(\\d{3,4})(\\d{4})","$1 $2 $3",["0[26]|5"]],["(\\d{3})(\\d{3})(\\d{3,4})","$1 $2 $3",["1(?:44|[679])|[378]"]],["(\\d{3})(\\d{3,4})(\\d{4})","$1 $2 $3",["0[13-57-9][0159]|14"]],["(\\d{2})(\\d{4})(\\d{5})","$1 $2 $3",["0[26]"]],["(\\d{4})(\\d{3})(\\d{4})","$1 $2 $3",["0"]],["(\\d{3})(\\d{4})(\\d{4,5})","$1 $2 $3",["3"]]],0,0,0,0,0,0,[["0669[0-79]\\d{1,6}|0(?:1(?:[0159]\\d|[27][1-5]|31|4[1-4]|6[1356]|8[2-57])|2\\d\\d|3(?:[0159]\\d|2[1-4]|3[12]|[48][1-6]|6[2-59]|7[1-7])|4(?:[0159]\\d|[23][1-9]|4[245]|6[1-5]|7[1-4]|81)|5(?:[0159]\\d|2[1-5]|3[2-6]|4[1-79]|6[4-6]|7[1-578]|8[3-8])|6(?:[0-57-9]\\d|6[0-8])|7(?:[0159]\\d|2[12]|3[1-7]|4[2-46]|6[13569]|7[13-6]|8[1-59])|8(?:[0159]\\d|2[3-578]|3[1-356]|[6-8][1-5])|9(?:[0159]\\d|[238][1-5]|4[12]|6[1-8]|7[1-6]))\\d{2,7}"],["3[1-9]\\d{8}|3[2-9]\\d{7}",[9,10]],["80(?:0\\d{3}|3)\\d{3}",[6,9]],["(?:0878\\d{3}|89(?:2\\d|3[04]|4(?:[0-4]|[5-9]\\d\\d)|5[0-4]))\\d\\d|(?:1(?:44|6[346])|89(?:38|5[5-9]|9))\\d{6}",[6,8,9,10]],["1(?:78\\d|99)\\d{6}",[9,10]],0,0,0,["55\\d{8}",[10]],["84(?:[08]\\d{3}|[17])\\d{3}",[6,9]]]],"JE":["44","00","1534\\d{6}|(?:[3578]\\d|90)\\d{8}",[10],0,"0",0,"([0-24-8]\\d{5})$|0","1534$1",0,0,[["1534[0-24-8]\\d{5}"],["7(?:(?:(?:50|82)9|937)\\d|7(?:00[378]|97[7-9]))\\d{5}"],["80(?:07(?:35|81)|8901)\\d{4}"],["(?:8(?:4(?:4(?:4(?:05|42|69)|703)|5(?:041|800))|7(?:0002|1206))|90(?:066[59]|1810|71(?:07|55)))\\d{4}"],["701511\\d{4}"],0,["(?:3(?:0(?:07(?:35|81)|8901)|3\\d{4}|4(?:4(?:4(?:05|42|69)|703)|5(?:041|800))|7(?:0002|1206))|55\\d{4})\\d{4}"],["76(?:464|652)\\d{5}|76(?:0[0-28]|2[356]|34|4[01347]|5[49]|6[0-369]|77|8[14]|9[139])\\d{6}"],["56\\d{8}"]]],"JM":["1","011","(?:[58]\\d\\d|658|900)\\d{7}",[10],0,"1",0,0,0,0,"658|876",[["8766060\\d{3}|(?:658(?:2(?:[0-8]\\d|9[0-46-9])|[3-9]\\d\\d)|876(?:52[35]|6(?:0[1-3579]|1[0235-9]|[23]\\d|40|5[06]|6[2-589]|7[025-9]|8[04]|9[4-9])|7(?:0[2-689]|[1-6]\\d|8[056]|9[45])|9(?:0[1-8]|1[02378]|[2-8]\\d|9[2-468])))\\d{4}"],["(?:658295|876(?:2(?:0[1-9]|[13-9]\\d|2[013-9])|[348]\\d\\d|5(?:0[1-9]|[1-9]\\d)|6(?:4[89]|6[67])|7(?:0[07]|7\\d|8[1-47-9]|9[0-36-9])|9(?:[01]9|9[0579])))\\d{4}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"JO":["962","00","(?:(?:[2689]|7\\d)\\d|32|53)\\d{6}",[8,9],[["(\\d)(\\d{3})(\\d{4})","$1 $2 $3",["[2356]|87"],"(0$1)"],["(\\d{3})(\\d{5,6})","$1 $2",["[89]"],"0$1"],["(\\d{2})(\\d{7})","$1 $2",["70"],"0$1"],["(\\d)(\\d{4})(\\d{4})","$1 $2 $3",["7"],"0$1"]],"0",0,0,0,0,0,[["87(?:000|90[01])\\d{3}|(?:2(?:6(?:2[0-35-9]|3[0-578]|4[24-7]|5[0-24-8]|[6-8][023]|9[0-3])|7(?:0[1-79]|10|2[014-7]|3[0-689]|4[019]|5[0-3578]))|32(?:0[1-69]|1[1-35-7]|2[024-7]|3\\d|4[0-3]|[5-7][023])|53(?:0[0-3]|[13][023]|2[0-59]|49|5[0-35-9]|6[15]|7[45]|8[1-6]|9[0-36-9])|6(?:2(?:[05]0|22)|3(?:00|33)|4(?:0[0-25]|1[2-7]|2[0569]|[38][07-9]|4[025689]|6[0-589]|7\\d|9[0-2])|5(?:[01][056]|2[034]|3[0-57-9]|4[178]|5[0-69]|6[0-35-9]|7[1-379]|8[0-68]|9[0239]))|87(?:20|7[078]|99))\\d{4}",[8]],["7(?:[78][0-25-9]|9\\d)\\d{6}",[9]],["80\\d{6}",[8]],["9\\d{7}",[8]],["70\\d{7}",[9]],0,["8(?:10|8\\d)\\d{5}",[8]],["74(?:66|77)\\d{5}",[9]],0,["85\\d{6}",[8]]]],"JP":["81","010","00[1-9]\\d{6,14}|[257-9]\\d{9}|(?:00|[1-9]\\d\\d)\\d{6}",[8,9,10,11,12,13,14,15,16,17],[["(\\d{3})(\\d{3})(\\d{3})","$1-$2-$3",["(?:12|57|99)0"],"0$1"],["(\\d{4})(\\d)(\\d{4})","$1-$2-$3",["1(?:26|3[79]|4[56]|5[4-68]|6[3-5])|499|5(?:76|97)|746|8(?:3[89]|47|51|63)|9(?:80|9[16])","1(?:267|3(?:7[247]|9[278])|466|5(?:47|58|64)|6(?:3[245]|48|5[4-68]))|499[2468]|5(?:76|97)9|7468|8(?:3(?:8[7-9]|96)|477|51[2-9]|636)|9(?:802|9(?:1[23]|69))|1(?:45|58)[67]","1(?:267|3(?:7[247]|9[278])|466|5(?:47|58|64)|6(?:3[245]|48|5[4-68]))|499[2468]|5(?:769|979[2-69])|7468|8(?:3(?:8[7-9]|96[2457-9])|477|51[2-9]|636[457-9])|9(?:802|9(?:1[23]|69))|1(?:45|58)[67]"],"0$1"],["(\\d{2})(\\d{3})(\\d{4})","$1-$2-$3",["60"],"0$1"],["(\\d)(\\d{4})(\\d{4})","$1-$2-$3",["[36]|4(?:2[09]|7[01])","[36]|4(?:2(?:0|9[02-69])|7(?:0[019]|1))"],"0$1"],["(\\d{2})(\\d{3})(\\d{4})","$1-$2-$3",["1(?:1|5[45]|77|88|9[69])|2(?:2[1-37]|3[0-269]|4[59]|5|6[24]|7[1-358]|8[1369]|9[0-38])|4(?:[28][1-9]|3[0-57]|[45]|6[248]|7[2-579]|9[29])|5(?:2|3[045]|4[0-369]|5[29]|8[02389]|9[0-389])|7(?:2[02-46-9]|34|[58]|6[0249]|7[57]|9[2-6])|8(?:2[124589]|3[27-9]|49|51|6|7[0-468]|8[68]|9[019])|9(?:[23][1-9]|4[15]|5[138]|6[1-3]|7[156]|8[189]|9[1-489])","1(?:1|5(?:4[018]|5[017])|77|88|9[69])|2(?:2(?:[127]|3[014-9])|3[0-269]|4[59]|5(?:[1-3]|5[0-69]|9[19])|62|7(?:[1-35]|8[0189])|8(?:[16]|3[0134]|9[0-5])|9(?:[028]|17))|4(?:2(?:[13-79]|8[014-6])|3[0-57]|[45]|6[248]|7[2-47]|8[1-9])|5(?:2|3[045]|4[0-369]|8[02389]|9[0-3])|7(?:2[02-46-9]|34|[58]|6[0249]|7[57]|9(?:[23]|4[0-59]|5[01569]|6[0167]))|8(?:2(?:[1258]|4[0-39]|9[0-2469])|49|51|6(?:[0-24]|36|5[0-3589]|72|9[01459])|7[0-468]|8[68])|9(?:[23][1-9]|4[15]|5[138]|6[1-3]|7[156]|8[189]|9(?:[1289]|3[34]|4[0178]))|(?:49|55|83)[29]|(?:264|837)[016-9]|2(?:57|93)[015-9]|(?:25[0468]|422|838)[01]|(?:47[59]|59[89]|8(?:6[68]|9))[019]","1(?:1|5(?:4[018]|5[017])|77|88|9[69])|2(?:2[127]|3[0-269]|4[59]|5(?:[1-3]|5[0-69]|9(?:17|99))|6(?:2|4[016-9])|7(?:[1-35]|8[0189])|8(?:[16]|3[0134]|9[0-5])|9(?:[028]|17))|4(?:2(?:[13-79]|8[014-6])|3[0-57]|[45]|6[248]|7[2-47]|9[29])|5(?:2|3[045]|4[0-369]|5[29]|8[02389]|9[0-3])|7(?:2[02-46-9]|34|[58]|6[0249]|7[57]|9(?:[23]|4[0-59]|5[01569]|6[0167]))|8(?:2(?:[1258]|4[0-39]|9[0169])|3(?:[29]|7(?:[017-9]|6[6-8]))|49|51|6(?:[0-24]|36[23]|5(?:[0-389]|5[23])|6(?:[01]|9[178])|72|9[0145])|7[0-468]|8[68])|9(?:4[15]|5[138]|7[156]|8[189]|9(?:[1289]|3(?:31|4[357])|4[0178]))|(?:8294|96)[1-3]|2(?:57|93)[015-9]|(?:223|8699)[014-9]|(?:25[0468]|422|838)[01]|(?:48|8292|9[23])[1-9]|(?:47[59]|59[89]|8(?:68|9))[019]","1(?:1|5(?:4[018]|5[017])|77|88|9[69])|2(?:2[127]|3[0-269]|4[59]|5(?:[1-3]|5[0-69]|7[015-9]|9(?:17|99))|6(?:2|4[016-9])|7(?:[1-35]|8[0189])|8(?:[16]|3[0134]|9[0-5])|9(?:[028]|17|3[015-9]))|4(?:2(?:[13-79]|8[014-6])|3[0-57]|[45]|6[248]|7[2-47]|9[29])|5(?:2|3[045]|4[0-369]|5[29]|8[02389]|9[0-3])|7(?:2[02-46-9]|34|[58]|6[0249]|7[57]|9(?:[23]|4[0-59]|5[01569]|6[0167]))|8(?:2(?:[1258]|4[0-39]|9(?:[019]|4[1-3]|6(?:[0-47-9]|5[01346-9])))|3(?:[29]|7(?:[017-9]|6[6-8]))|49|51|6(?:[0-24]|36[23]|5(?:[0-389]|5[23])|6(?:[01]|9[178])|72|9[0145])|7[0-468]|8[68])|9(?:4[15]|5[138]|6[1-3]|7[156]|8[189]|9(?:[1289]|3(?:31|4[357])|4[0178]))|(?:223|8699)[014-9]|(?:25[0468]|422|838)[01]|(?:48|829(?:2|66)|9[23])[1-9]|(?:47[59]|59[89]|8(?:68|9))[019]"],"0$1"],["(\\d{3})(\\d{2})(\\d{4})","$1-$2-$3",["[14]|[289][2-9]|5[3-9]|7[2-4679]"],"0$1"],["(\\d{3})(\\d{3})(\\d{4})","$1-$2-$3",["800"],"0$1"],["(\\d{2})(\\d{4})(\\d{4})","$1-$2-$3",["[257-9]"],"0$1"]],"0",0,0,0,0,0,[["(?:1(?:1[235-8]|2[3-6]|3[3-9]|4[2-6]|[58][2-8]|6[2-7]|7[2-9]|9[1-9])|(?:2[2-9]|[36][1-9])\\d|4(?:[2-578]\\d|6[02-8]|9[2-59])|5(?:[2-589]\\d|6[1-9]|7[2-8])|7(?:[25-9]\\d|3[4-9]|4[02-9])|8(?:[2679]\\d|3[2-9]|4[5-9]|5[1-9]|8[03-9])|9(?:[2-58]\\d|[679][1-9]))\\d{6}",[9]],["[7-9]0[1-9]\\d{7}",[10]],["00777(?:[01]|5\\d)\\d\\d|(?:00(?:7778|882[1245])|(?:120|800\\d)\\d\\d)\\d{4}|00(?:37|66|78)\\d{6,13}"],["990\\d{6}",[9]],["60\\d{7}",[9]],0,["570\\d{6}",[9]],["20\\d{8}",[10]],["50[1-9]\\d{7}",[10]]]],"KE":["254","000","(?:[17]\\d\\d|900)\\d{6}|(?:2|80)0\\d{6,7}|[4-6]\\d{6,8}",[7,8,9,10],[["(\\d{2})(\\d{5,7})","$1 $2",["[24-6]"],"0$1"],["(\\d{3})(\\d{6})","$1 $2",["[17]"],"0$1"],["(\\d{3})(\\d{3})(\\d{3,4})","$1 $2 $3",["[89]"],"0$1"]],"0",0,0,0,0,0,[["(?:4[245]|5[1-79]|6[01457-9])\\d{5,7}|(?:4[136]|5[08]|62)\\d{7}|(?:[24]0|66)\\d{6,7}",[7,8,9]],["(?:1(?:0[0-6]|1[0-5]|2[014]|30)|7\\d\\d)\\d{6}",[9]],["800[2-8]\\d{5,6}",[9,10]],["900[02-9]\\d{5}",[9]]]],"KG":["996","00","8\\d{9}|(?:[235-8]\\d|99)\\d{7}",[9,10],[["(\\d{4})(\\d{5})","$1 $2",["3(?:1[346]|[24-79])"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[235-79]|88"],"0$1"],["(\\d{3})(\\d{3})(\\d)(\\d{2,3})","$1 $2 $3 $4",["8"],"0$1"]],"0",0,0,0,0,0,[["312(?:5[0-79]\\d|9(?:[0-689]\\d|7[0-24-9]))\\d{3}|(?:3(?:1(?:2[0-46-8]|3[1-9]|47|[56]\\d)|2(?:22|3[0-479]|6[0-7])|4(?:22|5[6-9]|6\\d)|5(?:22|3[4-7]|59|6\\d)|6(?:22|5[35-7]|6\\d)|7(?:22|3[468]|4[1-9]|59|[67]\\d)|9(?:22|4[1-8]|6\\d))|6(?:09|12|2[2-4])\\d)\\d{5}",[9]],["312(?:58\\d|973)\\d{3}|(?:2(?:0[0-35]|2\\d)|5[0-24-7]\\d|600|7(?:[07]\\d|55)|88[08]|99[05-9])\\d{6}",[9]],["800\\d{6,7}"]]],"KH":["855","00[14-9]","1\\d{9}|[1-9]\\d{7,8}",[8,9,10],[["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["[1-9]"],"0$1"],["(\\d{4})(\\d{3})(\\d{3})","$1 $2 $3",["1"]]],"0",0,0,0,0,0,[["23(?:4(?:[2-4]|[56]\\d)|[568]\\d\\d)\\d{4}|23[236-9]\\d{5}|(?:2[4-6]|3[2-6]|4[2-4]|[5-7][2-5])(?:(?:[237-9]|4[56]|5\\d)\\d{5}|6\\d{5,6})",[8,9]],["(?:(?:1[28]|3[18]|9[67])\\d|6[016-9]|7(?:[07-9]|[16]\\d)|8(?:[013-79]|8\\d))\\d{6}|(?:1\\d|9[0-57-9])\\d{6}|(?:2[3-6]|3[2-6]|4[2-4]|[5-7][2-5])48\\d{5}",[8,9]],["1800(?:1\\d|2[019])\\d{4}",[10]],["1900(?:1\\d|2[09])\\d{4}",[10]]]],"KI":["686","00","(?:[37]\\d|6[0-79])\\d{6}|(?:[2-48]\\d|50)\\d{3}",[5,8],0,"0",0,0,0,0,0,[["(?:[24]\\d|3[1-9]|50|65(?:02[12]|12[56]|22[89]|[3-5]00)|7(?:27\\d\\d|3100|5(?:02[12]|12[56]|22[89]|[34](?:00|81)|500))|8[0-5])\\d{3}"],["(?:63\\d{3}|73(?:0[0-5]\\d|140))\\d{3}|[67]200[01]\\d{3}",[8]],0,0,0,0,0,0,["30(?:0[01]\\d\\d|12(?:11|20))\\d\\d",[8]]]],"KM":["269","00","[3478]\\d{6}",[7],[["(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3",["[3478]"]]],0,0,0,0,0,0,[["7[4-7]\\d{5}"],["[34]\\d{6}"],0,["8\\d{6}"]]],"KN":["1","011","(?:[58]\\d\\d|900)\\d{7}",[10],0,"1",0,"([2-7]\\d{6})$|1","869$1",0,"869",[["869(?:2(?:29|36)|302|4(?:6[015-9]|70)|56[5-7])\\d{4}"],["869(?:48[89]|55[6-8]|66\\d|76[02-7])\\d{4}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"KP":["850","00|99","85\\d{6}|(?:19\\d|[2-7])\\d{7}",[8,10],[["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["8"],"0$1"],["(\\d)(\\d{3})(\\d{4})","$1 $2 $3",["[2-7]"],"0$1"],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["1"],"0$1"]],"0",0,0,0,0,0,[["(?:(?:195|2)\\d|3[19]|4[159]|5[37]|6[17]|7[39]|85)\\d{6}"],["19[1-3]\\d{7}",[10]]]],"KR":["82","00(?:[125689]|3(?:[46]5|91)|7(?:00|27|3|55|6[126]))","00[1-9]\\d{8,11}|(?:[12]|5\\d{3})\\d{7}|[13-6]\\d{9}|(?:[1-6]\\d|80)\\d{7}|[3-6]\\d{4,5}|(?:00|7)0\\d{8}",[5,6,8,9,10,11,12,13,14],[["(\\d{2})(\\d{3,4})","$1-$2",["(?:3[1-3]|[46][1-4]|5[1-5])1"],"0$1"],["(\\d{4})(\\d{4})","$1-$2",["1"]],["(\\d)(\\d{3,4})(\\d{4})","$1-$2-$3",["2"],"0$1"],["(\\d{2})(\\d{3})(\\d{4})","$1-$2-$3",["60|8"],"0$1"],["(\\d{2})(\\d{3,4})(\\d{4})","$1-$2-$3",["[1346]|5[1-5]"],"0$1"],["(\\d{2})(\\d{4})(\\d{4})","$1-$2-$3",["[57]"],"0$1"],["(\\d{2})(\\d{5})(\\d{4})","$1-$2-$3",["5"],"0$1"]],"0",0,"0(8(?:[1-46-8]|5\\d\\d))?",0,0,0,[["(?:2|3[1-3]|[46][1-4]|5[1-5])[1-9]\\d{6,7}|(?:3[1-3]|[46][1-4]|5[1-5])1\\d{2,3}",[5,6,8,9,10]],["1(?:05(?:[0-8]\\d|9[0-6])|22[13]\\d)\\d{4,5}|1(?:0[1-46-9]|[16-9]\\d|2[013-9])\\d{6,7}",[9,10]],["00(?:308\\d{6,7}|798\\d{7,9})|(?:00368|80)\\d{7}",[9,11,12,13,14]],["60[2-9]\\d{6}",[9]],["50\\d{8,9}",[10,11]],0,["1(?:5(?:22|33|44|66|77|88|99)|6(?:[07]0|44|6[168]|88)|8(?:00|33|55|77|99))\\d{4}",[8]],["15\\d{7,8}",[9,10]],["70\\d{8}",[10]]]],"KW":["965","00","18\\d{5}|(?:[2569]\\d|41)\\d{6}",[7,8],[["(\\d{4})(\\d{3,4})","$1 $2",["[169]|2(?:[235]|4[1-35-9])|52"]],["(\\d{3})(\\d{5})","$1 $2",["[245]"]]],0,0,0,0,0,0,[["2(?:[23]\\d\\d|4(?:[1-35-9]\\d|44)|5(?:0[034]|[2-46]\\d|5[1-3]|7[1-7]))\\d{4}",[8]],["(?:41\\d\\d|5(?:(?:[05]\\d|1[0-7]|6[56])\\d|2(?:22|5[25])|7(?:55|77)|88[58])|6(?:(?:0[034679]|5[015-9]|6\\d)\\d|1(?:00|11|66)|222|3[36]3|444|7(?:0[013-9]|[67]\\d)|888|9(?:[069]\\d|3[039]))|9(?:(?:0[09]|[4679]\\d|8[057-9])\\d|1(?:1[01]|99)|2(?:00|2\\d)|3(?:00|3[03])|5(?:00|5\\d)))\\d{4}",[8]],["18\\d{5}",[7]]]],"KY":["1","011","(?:345|[58]\\d\\d|900)\\d{7}",[10],0,"1",0,"([2-9]\\d{6})$|1","345$1",0,"345",[["345(?:2(?:22|3[23]|44|66)|333|444|6(?:23|38|40)|7(?:30|4[35-79]|6[6-9]|77)|8(?:00|1[45]|[48]8)|9(?:14|4[035-9]))\\d{4}"],["345(?:32[1-9]|42[0-4]|5(?:1[67]|2[5-79]|4[6-9]|50|76)|649|82[56]|9(?:1[679]|2[2-9]|3[06-9]|90))\\d{4}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["(?:345976|900[2-9]\\d\\d)\\d{4}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"],0,0,["345849\\d{4}"]]],"KZ":["7","810","(?:33622|8\\d{8})\\d{5}|[78]\\d{9}",[10,14],0,"8",0,0,0,0,"33|7",[["(?:33622|7(?:1(?:0(?:[23]\\d|4[0-3]|59|63)|1(?:[23]\\d|4[0-79]|59)|2(?:[23]\\d|59)|3(?:2\\d|3[0-79]|4[0-35-9]|59)|4(?:[24]\\d|3[013-9]|5[1-9]|97)|5(?:2\\d|3[1-9]|4[0-7]|59)|6(?:[2-4]\\d|5[19]|61)|72\\d|8(?:[27]\\d|3[1-46-9]|4[0-5]|59))|2(?:1(?:[23]\\d|4[46-9]|5[3469])|2(?:2\\d|3[0679]|46|5[12679])|3(?:[2-4]\\d|5[139])|4(?:2\\d|3[1-35-9]|59)|5(?:[23]\\d|4[0-8]|59|61)|6(?:2\\d|3[1-9]|4[0-4]|59)|7(?:[2379]\\d|40|5[279])|8(?:[23]\\d|4[0-3]|59)|9(?:2\\d|3[124578]|59))))\\d{5}",[10]],["7(?:0[0-25-8]|47|6[0-4]|7[15-8]|85)\\d{7}",[10]],["8(?:00|108\\d{3})\\d{7}"],["809\\d{7}",[10]],["808\\d{7}",[10]],0,0,0,["751\\d{7}",[10]]],"8~10"],"LA":["856","00","[23]\\d{9}|3\\d{8}|(?:[235-8]\\d|41)\\d{6}",[8,9,10],[["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["2[13]|3[14]|[4-8]"],"0$1"],["(\\d{2})(\\d{2})(\\d{2})(\\d{3})","$1 $2 $3 $4",["30[013-9]"],"0$1"],["(\\d{2})(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3 $4",["[23]"],"0$1"]],"0",0,0,0,0,0,[["(?:2[13]|[35-7][14]|41|8[1468])\\d{6}",[8]],["(?:20(?:[2359]\\d|7[6-8]|88)|302\\d)\\d{6}",[10]],0,0,0,0,["30[013-9]\\d{6}",[9]]]],"LB":["961","00","[27-9]\\d{7}|[13-9]\\d{6}",[7,8],[["(\\d)(\\d{3})(\\d{3})","$1 $2 $3",["[13-69]|7(?:[2-57]|62|8[0-7]|9[04-9])|8[02-9]"],"0$1"],["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["[27-9]"]]],"0",0,0,0,0,0,[["7(?:62|8[0-7]|9[04-9])\\d{4}|(?:[14-69]\\d|2(?:[14-69]\\d|[78][1-9])|7[2-57]|8[02-9])\\d{5}"],["793(?:[01]\\d|2[0-4])\\d{3}|(?:(?:3|81)\\d|7(?:[01]\\d|6[013-9]|8[89]|9[12]))\\d{5}"],0,["9[01]\\d{6}",[8]],0,0,0,0,0,["80\\d{6}",[8]]]],"LC":["1","011","(?:[58]\\d\\d|758|900)\\d{7}",[10],0,"1",0,"([2-8]\\d{6})$|1","758$1",0,"758",[["758(?:234|4(?:30|5\\d|6[2-9]|8[0-2])|57[0-2]|(?:63|75)8)\\d{4}"],["758(?:28[4-7]|384|4(?:6[01]|8[4-9])|5(?:1[89]|20|84)|7(?:1[2-9]|2\\d|3[0-3])|812)\\d{4}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"LI":["423","00","[68]\\d{8}|(?:[2378]\\d|90)\\d{5}",[7,9],[["(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3",["[2379]|8(?:0[09]|7)","[2379]|8(?:0(?:02|9)|7)"]],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["8"]],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["69"]],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["6"]]],"0",0,"(1001)|0",0,0,0,[["(?:2(?:01|1[27]|2[02]|3\\d|6[02-578]|96)|3(?:[24]0|33|7[0135-7]|8[048]|9[0269]))\\d{4}",[7]],["(?:6(?:(?:4[5-9]|5[0-4])\\d|6(?:[0245]\\d|[17]0|3[7-9]))\\d|7(?:[37-9]\\d|42|56))\\d{4}"],["8002[28]\\d\\d|80(?:05\\d|9)\\d{4}"],["90(?:02[258]|1(?:23|3[14])|66[136])\\d\\d",[7]],0,0,["870(?:28|87)\\d\\d",[7]]]],"LK":["94","00","[1-9]\\d{8}",[9],[["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["7"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[1-689]"],"0$1"]],"0",0,0,0,0,0,[["(?:12[2-9]|602|8[12]\\d|9(?:1\\d|22|9[245]))\\d{6}|(?:11|2[13-7]|3[1-8]|4[157]|5[12457]|6[35-7])[2-57]\\d{6}"],["7(?:[0-25-8]\\d|4[0-4])\\d{6}"],0,0,0,0,["1973\\d{5}"]]],"LR":["231","00","(?:[25]\\d|33|77|88)\\d{7}|(?:2\\d|[4-6])\\d{6}",[7,8,9],[["(\\d)(\\d{3})(\\d{3})","$1 $2 $3",["[4-6]"],"0$1"],["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["2"],"0$1"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["[23578]"],"0$1"]],"0",0,0,0,0,0,[["(?:2\\d{3}|33333)\\d{4}",[8,9]],["(?:(?:(?:22|33)0|555|(?:77|88)\\d)\\d|4[67])\\d{5}|[56]\\d{6}",[7,9]],0,["332(?:02|[34]\\d)\\d{4}",[9]]]],"LS":["266","00","(?:[256]\\d\\d|800)\\d{5}",[8],[["(\\d{4})(\\d{4})","$1 $2",["[2568]"]]],0,0,0,0,0,0,[["2\\d{7}"],["[56]\\d{7}"],["800[256]\\d{4}"]]],"LT":["370","00","(?:[3469]\\d|52|[78]0)\\d{6}",[8],[["(\\d)(\\d{3})(\\d{4})","$1 $2 $3",["52[0-7]"],"(8-$1)",1],["(\\d{3})(\\d{2})(\\d{3})","$1 $2 $3",["[7-9]"],"8 $1",1],["(\\d{2})(\\d{6})","$1 $2",["37|4(?:[15]|6[1-8])"],"(8-$1)",1],["(\\d{3})(\\d{5})","$1 $2",["[3-6]"],"(8-$1)",1]],"8",0,"[08]",0,0,0,[["(?:3[1478]|4[124-6]|52)\\d{6}"],["6\\d{7}"],["80[02]\\d{5}"],["9(?:0[0239]|10)\\d{5}"],["70[05]\\d{5}"],0,["70[67]\\d{5}"],0,["[89]01\\d{5}"],["808\\d{5}"]]],"LU":["352","00","35[013-9]\\d{4,8}|6\\d{8}|35\\d{2,4}|(?:[2457-9]\\d|3[0-46-9])\\d{2,9}",[4,5,6,7,8,9,10,11],[["(\\d{2})(\\d{3})","$1 $2",["2(?:0[2-689]|[2-9])|[3-57]|8(?:0[2-9]|[13-9])|9(?:0[89]|[2-579])"]],["(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3",["2(?:0[2-689]|[2-9])|[3-57]|8(?:0[2-9]|[13-9])|9(?:0[89]|[2-579])"]],["(\\d{2})(\\d{2})(\\d{3})","$1 $2 $3",["20[2-689]"]],["(\\d{2})(\\d{2})(\\d{2})(\\d{1,2})","$1 $2 $3 $4",["2(?:[0367]|4[3-8])"]],["(\\d{3})(\\d{2})(\\d{3})","$1 $2 $3",["80[01]|90[015]"]],["(\\d{2})(\\d{2})(\\d{2})(\\d{3})","$1 $2 $3 $4",["20"]],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["6"]],["(\\d{2})(\\d{2})(\\d{2})(\\d{2})(\\d{1,2})","$1 $2 $3 $4 $5",["2(?:[0367]|4[3-8])"]],["(\\d{2})(\\d{2})(\\d{2})(\\d{1,5})","$1 $2 $3 $4",["[3-57]|8[13-9]|9(?:0[89]|[2-579])|(?:2|80)[2-9]"]]],0,0,"(15(?:0[06]|1[12]|[35]5|4[04]|6[26]|77|88|99)\\d)",0,0,0,[["(?:35[013-9]|80[2-9]|90[89])\\d{1,8}|(?:2[2-9]|3[0-46-9]|[457]\\d|8[13-9]|9[2-579])\\d{2,9}"],["6(?:[269][18]|5[1568]|7[189]|81)\\d{6}",[9]],["800\\d{5}",[8]],["90[015]\\d{5}",[8]],0,0,0,0,["20(?:1\\d{5}|[2-689]\\d{1,7})",[4,5,6,7,8,9,10]],["801\\d{5}",[8]]]],"LV":["371","00","(?:[268]\\d|90)\\d{6}",[8],[["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["[269]|8[01]"]]],0,0,0,0,0,0,[["6\\d{7}"],["23(?:23[0-57-9]|33[0238])\\d{3}|2(?:[0-24-9]\\d\\d|3(?:0[07]|[14-9]\\d|2[024-9]|3[0-24-9]))\\d{4}"],["80\\d{6}"],["90\\d{6}"],0,0,0,0,0,["81\\d{6}"]]],"LY":["218","00","[2-9]\\d{8}",[9],[["(\\d{2})(\\d{7})","$1-$2",["[2-9]"],"0$1"]],"0",0,0,0,0,0,[["(?:2(?:0[56]|[1-6]\\d|7[124579]|8[124])|3(?:1\\d|2[2356])|4(?:[17]\\d|2[1-357]|5[2-4]|8[124])|5(?:[1347]\\d|2[1-469]|5[13-5]|8[1-4])|6(?:[1-479]\\d|5[2-57]|8[1-5])|7(?:[13]\\d|2[13-79])|8(?:[124]\\d|5[124]|84))\\d{6}"],["9[1-6]\\d{7}"]]],"MA":["212","00","[5-8]\\d{8}",[9],[["(\\d{5})(\\d{4})","$1-$2",["5(?:29|38)","5(?:29[1289]|389)","529(?:1[1-46-9]|2[013-8]|90)|5(?:298|389)[0-46-9]"],"0$1"],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["5[45]"],"0$1"],["(\\d{4})(\\d{5})","$1-$2",["5(?:2[2-489]|3[5-9]|9)|892","5(?:2(?:[2-49]|8[235-9])|3[5-9]|9)|892"],"0$1"],["(\\d{2})(\\d{7})","$1-$2",["8"],"0$1"],["(\\d{3})(\\d{6})","$1-$2",["[5-7]"],"0$1"]],"0",0,0,0,0,0,[["5293[01]\\d{4}|5(?:2(?:[0-25-7]\\d|3[1-578]|4[02-46-8]|8[0235-7]|9[0-289])|3(?:[0-47]\\d|5[02-9]|6[02-8]|8[0189]|9[3-9])|(?:4[067]|5[03])\\d)\\d{5}"],["(?:6(?:[0-79]\\d|8[0-247-9])|7(?:[017]\\d|2[0-2]|6[0-8]|8[0-3]))\\d{6}"],["80\\d{7}"],["89\\d{7}"],0,0,0,0,["592(?:4[0-2]|93)\\d{4}"]]],"MC":["377","00","(?:[3489]|6\\d)\\d{7}",[8,9],[["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["4"],"0$1"],["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[389]"]],["(\\d)(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4 $5",["6"],"0$1"]],"0",0,0,0,0,0,[["(?:870|9[2-47-9]\\d)\\d{5}",[8]],["4(?:[46]\\d|5[1-9])\\d{5}|(?:3|6\\d)\\d{7}"],["(?:800|90\\d)\\d{5}",[8]]]],"MD":["373","00","(?:[235-7]\\d|[89]0)\\d{6}",[8],[["(\\d{3})(\\d{5})","$1 $2",["[89]"],"0$1"],["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["22|3"],"0$1"],["(\\d{3})(\\d{2})(\\d{3})","$1 $2 $3",["[25-7]"],"0$1"]],"0",0,0,0,0,0,[["(?:(?:2[1-9]|3[1-79])\\d|5(?:33|5[257]))\\d{5}"],["562\\d{5}|(?:6\\d|7[16-9])\\d{6}"],["800\\d{5}"],["90[056]\\d{5}"],0,0,["803\\d{5}"],0,["3[08]\\d{6}"],["808\\d{5}"]]],"ME":["382","00","(?:20|[3-79]\\d)\\d{6}|80\\d{6,7}",[8,9],[["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["[2-9]"],"0$1"]],"0",0,0,0,0,0,[["(?:20[2-8]|3(?:[0-2][2-7]|3[24-7])|4(?:0[2-467]|1[2467])|5(?:0[2467]|1[24-7]|2[2-467]))\\d{5}",[8]],["6(?:[07-9]\\d|3[024]|6[0-25])\\d{5}",[8]],["80(?:[0-2578]|9\\d)\\d{5}"],["9(?:4[1568]|5[178])\\d{5}",[8]],0,0,["77[1-9]\\d{5}",[8]],0,["78[1-49]\\d{5}",[8]]]],"MF":["590","00","590\\d{6}|(?:69|80|9\\d)\\d{7}",[9],0,"0",0,0,0,0,0,[["590(?:0[079]|[14]3|[27][79]|30|5[0-268]|87)\\d{4}"],["69(?:0\\d\\d|1(?:2[2-9]|3[0-5]))\\d{4}"],["80[0-5]\\d{6}"],0,0,0,0,0,["9(?:(?:395|76[018])\\d|475[01])\\d{4}"]]],"MG":["261","00","[23]\\d{8}",[9],[["(\\d{2})(\\d{2})(\\d{3})(\\d{2})","$1 $2 $3 $4",["[23]"],"0$1"]],"0",0,"([24-9]\\d{6})$|0","20$1",0,0,[["2072[29]\\d{4}|20(?:2\\d|4[47]|5[3467]|6[279]|7[35]|8[268]|9[245])\\d{5}"],["3[2-47-9]\\d{7}"],0,0,0,0,0,0,["22\\d{7}"]]],"MH":["692","011","329\\d{4}|(?:[256]\\d|45)\\d{5}",[7],[["(\\d{3})(\\d{4})","$1-$2",["[2-6]"]]],"1",0,0,0,0,0,[["(?:247|528|625)\\d{4}"],["(?:(?:23|54)5|329|45[356])\\d{4}"],0,0,0,0,0,0,["635\\d{4}"]]],"MK":["389","00","[2-578]\\d{7}",[8],[["(\\d)(\\d{3})(\\d{4})","$1 $2 $3",["2|34[47]|4(?:[37]7|5[47]|64)"],"0$1"],["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["[347]"],"0$1"],["(\\d{3})(\\d)(\\d{2})(\\d{2})","$1 $2 $3 $4",["[58]"],"0$1"]],"0",0,0,0,0,0,[["(?:(?:2(?:62|77)0|3444)\\d|4[56]440)\\d{3}|(?:34|4[357])700\\d{3}|(?:2(?:[0-3]\\d|5[0-578]|6[01]|82)|3(?:1[3-68]|[23][2-68]|4[23568])|4(?:[23][2-68]|4[3-68]|5[2568]|6[25-8]|7[24-68]|8[4-68]))\\d{5}"],["7(?:3555|(?:474|9[019]7)7)\\d{3}|7(?:[0-25-8]\\d\\d|3(?:[1-48]\\d|7[01578])|4(?:2\\d|60|7[01578])|9(?:[2-4]\\d|5[01]|7[015]))\\d{4}"],["800\\d{5}"],["5\\d{7}"],0,0,0,0,0,["8(?:0[1-9]|[1-9]\\d)\\d{5}"]]],"ML":["223","00","[24-9]\\d{7}",[8],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[24-9]"]]],0,0,0,0,0,0,[["2(?:07[0-8]|12[67])\\d{4}|(?:2(?:02|1[4-689])|4(?:0[0-4]|4[1-39]))\\d{5}"],["2(?:0(?:01|79)|17\\d)\\d{4}|(?:5[01]|[679]\\d|8[2-49])\\d{6}"],["80\\d{6}"]]],"MM":["95","00","1\\d{5,7}|95\\d{6}|(?:[4-7]|9[0-46-9])\\d{6,8}|(?:2|8\\d)\\d{5,8}",[6,7,8,9,10],[["(\\d)(\\d{2})(\\d{3})","$1 $2 $3",["16|2"],"0$1"],["(\\d{2})(\\d{2})(\\d{3})","$1 $2 $3",["[45]|6(?:0[23]|[1-689]|7[235-7])|7(?:[0-4]|5[2-7])|8[1-6]"],"0$1"],["(\\d)(\\d{3})(\\d{3,4})","$1 $2 $3",["[12]"],"0$1"],["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["[4-7]|8[1-35]"],"0$1"],["(\\d)(\\d{3})(\\d{4,6})","$1 $2 $3",["9(?:2[0-4]|[35-9]|4[137-9])"],"0$1"],["(\\d)(\\d{4})(\\d{4})","$1 $2 $3",["2"],"0$1"],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["8"],"0$1"],["(\\d)(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3 $4",["92"],"0$1"],["(\\d)(\\d{5})(\\d{4})","$1 $2 $3",["9"],"0$1"]],"0",0,0,0,0,0,[["(?:1(?:(?:2\\d|3[56]|[89][0-6])\\d|4(?:2[29]|39|62|7[0-2]|83)|6)|2(?:2(?:00|8[34])|4(?:0\\d|[26]2|39|7[0-2]|83)|51\\d\\d)|4(?:2(?:2\\d\\d|48[013])|3(?:20\\d|4(?:70|83)|56)|420\\d|5470)|6(?:0(?:[23]|88\\d)|(?:124|[56]2\\d)\\d|2472|3(?:20\\d|470)|4(?:2[04]\\d|472)|7(?:(?:3\\d|8[01459])\\d|4(?:39|[67]0))))\\d{4}|5(?:2(?:2\\d{5,6}|47[02]\\d{4})|(?:3472|4(?:2(?:1|86)|470)|522\\d|6(?:20\\d|483)|7(?:20\\d|48[01])|8(?:20\\d|47[02])|9(?:20\\d|470))\\d{4})|7(?:(?:0470|4(?:25\\d|470)|5(?:202|470|96\\d))\\d{4}|1(?:20\\d{4,5}|4(?:70|83)\\d{4}))|8(?:1(?:2\\d{5,6}|4(?:10|7[01]\\d)\\d{3})|2(?:2\\d{5,6}|(?:320|490\\d)\\d{3})|(?:3(?:2\\d\\d|470)|4[24-7]|5(?:(?:2\\d|51)\\d|4(?:[1-35-9]\\d|4[0-57-9]))|6[23])\\d{4})|(?:1[2-6]\\d|4(?:2[24-8]|3[2-7]|[46][2-6]|5[3-5])|5(?:[27][2-8]|3[2-68]|4[24-8]|5[23]|6[2-4]|8[24-7]|9[2-7])|6(?:[19]20|42[03-6]|(?:52|7[45])\\d)|7(?:[04][24-8]|[15][2-7]|22|3[2-4])|8(?:1[2-689]|2[2-8]|[35]2\\d))\\d{4}|25\\d{5,6}|(?:2[2-9]|6(?:1[2356]|[24][2-6]|3[24-6]|5[2-4]|6[2-8]|7[235-7]|8[245]|9[24])|8(?:3[24]|5[245]))\\d{4}",[6,7,8,9]],["(?:17[01]|9(?:2(?:[0-4]|[56]\\d\\d)|(?:3(?:[0-36]|4\\d)|(?:6\\d|8[89]|9[4-8])\\d|7(?:3|40|[5-9]\\d))\\d|4(?:(?:[0245]\\d|[1379])\\d|88)|5[0-6])\\d)\\d{4}|9[69]1\\d{6}|9(?:[68]\\d|9[089])\\d{5}",[7,8,9,10]],["80080(?:0[1-9]|2\\d)\\d{3}",[10]],0,0,0,0,0,["1333\\d{4}|[12]468\\d{4}",[8]]]],"MN":["976","001","[12]\\d{7,9}|[5-9]\\d{7}",[8,9,10],[["(\\d{2})(\\d{2})(\\d{4})","$1 $2 $3",["[12]1"],"0$1"],["(\\d{4})(\\d{4})","$1 $2",["[5-9]"]],["(\\d{3})(\\d{5,6})","$1 $2",["[12]2[1-3]"],"0$1"],["(\\d{4})(\\d{5,6})","$1 $2",["[12](?:27|3[2-8]|4[2-68]|5[1-4689])","[12](?:27|3[2-8]|4[2-68]|5[1-4689])[0-3]"],"0$1"],["(\\d{5})(\\d{4,5})","$1 $2",["[12]"],"0$1"]],"0",0,0,0,0,0,[["[12]2[1-3]\\d{5,6}|7(?:0[0-5]\\d|128)\\d{4}|(?:[12](?:1|27)|5[368])\\d{6}|[12](?:3[2-8]|4[2-68]|5[1-4689])\\d{6,7}"],["(?:83[01]|920)\\d{5}|(?:5[05]|6[069]|8[015689]|9[013-9])\\d{6}",[8]],0,0,0,0,0,0,["712[0-79]\\d{4}|7(?:1[013-9]|[25-9]\\d)\\d{5}",[8]]]],"MO":["853","00","0800\\d{3}|(?:28|[68]\\d)\\d{6}",[7,8],[["(\\d{4})(\\d{3})","$1 $2",["0"]],["(\\d{4})(\\d{4})","$1 $2",["[268]"]]],0,0,0,0,0,0,[["(?:28[2-9]|8(?:11|[2-57-9]\\d))\\d{5}",[8]],["6800[0-79]\\d{3}|6(?:[235]\\d\\d|6(?:0[0-5]|[1-9]\\d)|8(?:0[1-9]|[14-8]\\d|2[5-9]|[39][0-4]))\\d{4}",[8]],["0800\\d{3}",[7]]]],"MP":["1","011","[58]\\d{9}|(?:67|90)0\\d{7}",[10],0,"1",0,"([2-9]\\d{6})$|1","670$1",0,"670",[["670(?:2(?:3[3-7]|56|8[4-8])|32[1-38]|4(?:33|8[348])|5(?:32|55|88)|6(?:64|70|82)|78[3589]|8[3-9]8|989)\\d{4}"],[""],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"MQ":["596","00","596\\d{6}|(?:69|80|9\\d)\\d{7}",[9],[["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[569]"],"0$1"],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["8"],"0$1"]],"0",0,0,0,0,0,[["596(?:[03-7]\\d|10|2[7-9]|8[09]|9[4-9])\\d{4}"],["69(?:6(?:[0-46-9]\\d|5[0-6])|727)\\d{4}"],["80[0-5]\\d{6}"],0,0,0,0,0,["9(?:397[01]|477[0-2]|76(?:6\\d|7[0-367]))\\d{4}"]]],"MR":["222","00","(?:[2-4]\\d\\d|800)\\d{5}",[8],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[2-48]"]]],0,0,0,0,0,0,[["(?:25[08]|35\\d|45[1-7])\\d{5}"],["[2-4][0-46-9]\\d{6}"],["800\\d{5}"]]],"MS":["1","011","(?:[58]\\d\\d|664|900)\\d{7}",[10],0,"1",0,"([34]\\d{6})$|1","664$1",0,"664",[["6644(?:1[0-3]|91)\\d{4}"],["664(?:3(?:49|9[1-6])|49[2-6])\\d{4}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"MT":["356","00","3550\\d{4}|(?:[2579]\\d\\d|800)\\d{5}",[8],[["(\\d{4})(\\d{4})","$1 $2",["[2357-9]"]]],0,0,0,0,0,0,[["20(?:3[1-4]|6[059])\\d{4}|2(?:0[19]|[1-357]\\d|60)\\d{5}"],["(?:7(?:210|[79]\\d\\d)|9(?:[29]\\d\\d|69[67]|8(?:1[1-3]|89|97)))\\d{4}"],["800(?:02|[3467]\\d)\\d{3}"],["5(?:0(?:0(?:37|43)|(?:6\\d|70|9[0168])\\d)|[12]\\d0[1-5])\\d{3}"],0,0,["501\\d{5}"],["7117\\d{4}"],["3550\\d{4}"]]],"MU":["230","0(?:0|[24-7]0|3[03])","(?:[57]|8\\d\\d)\\d{7}|[2-468]\\d{6}",[7,8,10],[["(\\d{3})(\\d{4})","$1 $2",["[2-46]|8[013]"]],["(\\d{4})(\\d{4})","$1 $2",["[57]"]],["(\\d{5})(\\d{5})","$1 $2",["8"]]],0,0,0,0,0,0,[["(?:2(?:[0346-8]\\d|1[0-7])|4(?:[013568]\\d|2[4-7])|54(?:[3-5]\\d|71)|6\\d\\d|8(?:14|3[129]))\\d{4}",[7,8]],["5(?:4(?:2[1-389]|7[1-9])|87[15-8])\\d{4}|(?:5(?:2[5-9]|4[3-689]|[57]\\d|8[0-689]|9[0-8])|7(?:0[01]|3[03]))\\d{5}",[8]],["802\\d{7}|80[0-2]\\d{4}",[7,10]],["30\\d{5}",[7]],0,0,0,0,["3(?:20|9\\d)\\d{4}",[7]]],"020"],"MV":["960","0(?:0|19)","(?:800|9[0-57-9]\\d)\\d{7}|[34679]\\d{6}",[7,10],[["(\\d{3})(\\d{4})","$1-$2",["[34679]"]],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["[89]"]]],0,0,0,0,0,0,[["(?:3(?:0[0-3]|3[0-59])|6(?:[58][024689]|6[024-68]|7[02468]))\\d{4}",[7]],["(?:46[46]|[79]\\d\\d)\\d{4}",[7]],["800\\d{7}",[10]],["900\\d{7}",[10]],0,0,["4(?:0[01]|50)\\d{4}",[7]]],"00"],"MW":["265","00","(?:[1289]\\d|31|77)\\d{7}|1\\d{6}",[7,9],[["(\\d)(\\d{3})(\\d{3})","$1 $2 $3",["1[2-9]"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["2"],"0$1"],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[137-9]"],"0$1"]],"0",0,0,0,0,0,[["(?:1[2-9]|2[12]\\d\\d)\\d{5}"],["111\\d{6}|(?:31|77|[89][89])\\d{7}",[9]]]],"MX":["52","0[09]","1(?:(?:[27]2|44|99)[1-9]|65[0-689])\\d{7}|(?:1(?:[01]\\d|2[13-9]|[35][1-9]|4[0-35-9]|6[0-46-9]|7[013-9]|8[1-79]|9[1-8])|[2-9]\\d)\\d{8}",[10,11],[["(\\d{2})(\\d{4})(\\d{4})","$1 $2 $3",["33|5[56]|81"],0,1],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["[2-9]"],0,1],["(\\d)(\\d{2})(\\d{4})(\\d{4})","$2 $3 $4",["1(?:33|5[56]|81)"],0,1],["(\\d)(\\d{3})(\\d{3})(\\d{4})","$2 $3 $4",["1"],0,1]],"01",0,"0(?:[12]|4[45])|1",0,0,0,[["657[12]\\d{6}|(?:2(?:0[01]|2\\d|3[1-35-8]|4[13-9]|7[1-689]|8[1-578]|9[467])|3(?:1[1-79]|[2458][1-9]|3\\d|7[1-8]|9[1-5])|4(?:1[1-57-9]|[25-7][1-9]|3[1-8]|4\\d|8[1-35-9]|9[2-689])|5(?:[56]\\d|88|9[1-79])|6(?:1[2-68]|[2-4][1-9]|5[1-3689]|6[1-57-9]|7[1-7]|8[67]|9[4-8])|7(?:[13467][1-9]|2\\d|5[13-9]|8[1-69]|9[17])|8(?:1\\d|2[13-689]|3[1-6]|4[124-6]|6[1246-9]|7[1-378]|9[12479])|9(?:1[346-9]|2[1-4]|3[2-46-8]|5[1348]|6[1-9]|7[12]|8[1-8]|9\\d))\\d{7}",[10]],["657[12]\\d{6}|(?:1(?:2(?:2[1-9]|3[1-35-8]|4[13-9]|7[1-689]|8[1-578]|9[467])|3(?:1[1-79]|[2458][1-9]|3\\d|7[1-8]|9[1-5])|4(?:1[1-57-9]|[24-7][1-9]|3[1-8]|8[1-35-9]|9[2-689])|5(?:[56]\\d|88|9[1-79])|6(?:1[2-68]|[2-4][1-9]|5[1-3689]|6[1-57-9]|7[1-7]|8[67]|9[4-8])|7(?:[1-467][1-9]|5[13-9]|8[1-69]|9[17])|8(?:1\\d|2[13-689]|3[1-6]|4[124-6]|6[1246-9]|7[1-378]|9[12479])|9(?:1[346-9]|2[1-4]|3[2-46-8]|5[1348]|[69][1-9]|7[12]|8[1-8]))|2(?:2\\d|3[1-35-8]|4[13-9]|7[1-689]|8[1-578]|9[467])|3(?:1[1-79]|[2458][1-9]|3\\d|7[1-8]|9[1-5])|4(?:1[1-57-9]|[25-7][1-9]|3[1-8]|4\\d|8[1-35-9]|9[2-689])|5(?:[56]\\d|88|9[1-79])|6(?:1[2-68]|[2-4][1-9]|5[1-3689]|6[1-57-9]|7[1-7]|8[67]|9[4-8])|7(?:[13467][1-9]|2\\d|5[13-9]|8[1-69]|9[17])|8(?:1\\d|2[13-689]|3[1-6]|4[124-6]|6[1246-9]|7[1-378]|9[12479])|9(?:1[346-9]|2[1-4]|3[2-46-8]|5[1348]|6[1-9]|7[12]|8[1-8]|9\\d))\\d{7}"],["8(?:00|88)\\d{7}",[10]],["900\\d{7}",[10]],["500\\d{7}",[10]],0,0,0,0,["300\\d{7}",[10]]],"00"],"MY":["60","00","1\\d{8,9}|(?:3\\d|[4-9])\\d{7}",[8,9,10],[["(\\d)(\\d{3})(\\d{4})","$1-$2 $3",["[4-79]"],"0$1"],["(\\d{2})(\\d{3})(\\d{3,4})","$1-$2 $3",["1(?:[02469]|[378][1-9]|53)|8","1(?:[02469]|[37][1-9]|53|8(?:[1-46-9]|5[7-9]))|8"],"0$1"],["(\\d)(\\d{4})(\\d{4})","$1-$2 $3",["3"],"0$1"],["(\\d)(\\d{3})(\\d{2})(\\d{4})","$1-$2-$3-$4",["1(?:[367]|80)"]],["(\\d{3})(\\d{3})(\\d{4})","$1-$2 $3",["15"],"0$1"],["(\\d{2})(\\d{4})(\\d{4})","$1-$2 $3",["1"],"0$1"]],"0",0,0,0,0,0,[["(?:3(?:2[0-36-9]|3[0-368]|4[0-278]|5[0-24-8]|6[0-467]|7[1246-9]|8\\d|9[0-57])\\d|4(?:2[0-689]|[3-79]\\d|8[1-35689])|5(?:2[0-589]|[3468]\\d|5[0-489]|7[1-9]|9[23])|6(?:2[2-9]|3[1357-9]|[46]\\d|5[0-6]|7[0-35-9]|85|9[015-8])|7(?:[2579]\\d|3[03-68]|4[0-8]|6[5-9]|8[0-35-9])|8(?:[24][2-8]|3[2-5]|5[2-7]|6[2-589]|7[2-578]|[89][2-9])|9(?:0[57]|13|[25-7]\\d|[3489][0-8]))\\d{5}",[8,9]],["1(?:1888[689]|4400|8(?:47|8[27])[0-4])\\d{4}|1(?:0(?:[23568]\\d|4[0-6]|7[016-9]|9[0-8])|1(?:[1-5]\\d\\d|6(?:0[5-9]|[1-9]\\d)|7(?:[0-4]\\d|5[0-6]))|(?:[269]\\d|[37][1-9]|4[235-9])\\d|5(?:31|9\\d\\d)|8(?:1[23]|[236]\\d|4[06]|5(?:46|[7-9])|7[016-9]|8[01]|9[0-8]))\\d{5}",[9,10]],["1[378]00\\d{6}",[10]],["1600\\d{6}",[10]],0,0,0,0,["15(?:4(?:6[0-4]\\d|8(?:0[125]|[17]\\d|21|3[01]|4[01589]|5[014]|6[02]))|6(?:32[0-6]|78\\d))\\d{4}",[10]]]],"MZ":["258","00","(?:2|8\\d)\\d{7}",[8,9],[["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["2|8[2-79]"]],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["8"]]],0,0,0,0,0,0,[["2(?:[1346]\\d|5[0-2]|[78][12]|93)\\d{5}",[8]],["8[2-79]\\d{7}",[9]],["800\\d{6}",[9]]]],"NA":["264","00","[68]\\d{7,8}",[8,9],[["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["88"],"0$1"],["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["6"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["87"],"0$1"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["8"],"0$1"]],"0",0,0,0,0,0,[["64426\\d{3}|6(?:1(?:2[2-7]|3[01378]|4[0-4])|254|32[0237]|4(?:27|41|5[25])|52[236-8]|626|7(?:2[2-4]|30))\\d{4,5}|6(?:1(?:(?:0\\d|2[0189]|3[24-69]|4[5-9])\\d|17|69|7[014])|2(?:17|5[0-36-8]|69|70)|3(?:17|2[14-689]|34|6[289]|7[01]|81)|4(?:17|2[0-2]|4[06]|5[0137]|69|7[01])|5(?:17|2[0459]|69|7[01])|6(?:17|25|38|42|69|7[01])|7(?:17|2[569]|3[13]|6[89]|7[01]))\\d{4}"],["(?:60|8[1245])\\d{7}",[9]],["80\\d{7}",[9]],["8701\\d{5}",[9]],0,0,0,0,["8(?:3\\d\\d|86)\\d{5}"]]],"NC":["687","00","(?:050|[2-57-9]\\d\\d)\\d{3}",[6],[["(\\d{2})(\\d{2})(\\d{2})","$1.$2.$3",["[02-57-9]"]]],0,0,0,0,0,0,[["(?:2[03-9]|3[0-5]|4[1-7]|88)\\d{4}"],["(?:5[0-4]|[79]\\d|8[0-79])\\d{4}"],["050\\d{3}"],["36\\d{4}"]]],"NE":["227","00","[027-9]\\d{7}",[8],[["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["08"]],["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[089]|2[013]|7[04]"]]],0,0,0,0,0,0,[["2(?:0(?:20|3[1-8]|4[13-5]|5[14]|6[14578]|7[1-578])|1(?:4[145]|5[14]|6[14-68]|7[169]|88))\\d{4}"],["(?:23|7[04]|[89]\\d)\\d{6}"],["08\\d{6}"],["09\\d{6}"]]],"NF":["672","00","[13]\\d{5}",[6],[["(\\d{2})(\\d{4})","$1 $2",["1[0-3]"]],["(\\d)(\\d{5})","$1 $2",["[13]"]]],0,0,"([0-258]\\d{4})$","3$1",0,0,[["(?:1(?:06|17|28|39)|3[0-2]\\d)\\d{3}"],["(?:14|3[58])\\d{4}"]]],"NG":["234","009","(?:[124-7]|9\\d{3})\\d{6}|[1-9]\\d{7}|[78]\\d{9,13}",[7,8,10,11,12,13,14],[["(\\d{2})(\\d{2})(\\d{3})","$1 $2 $3",["78"],"0$1"],["(\\d)(\\d{3})(\\d{3,4})","$1 $2 $3",["[12]|9(?:0[3-9]|[1-9])"],"0$1"],["(\\d{2})(\\d{3})(\\d{2,3})","$1 $2 $3",["[3-7]|8[2-9]"],"0$1"],["(\\d{3})(\\d{3})(\\d{3,4})","$1 $2 $3",["[7-9]"],"0$1"],["(\\d{3})(\\d{4})(\\d{4,5})","$1 $2 $3",["[78]"],"0$1"],["(\\d{3})(\\d{5})(\\d{5,6})","$1 $2 $3",["[78]"],"0$1"]],"0",0,0,0,0,0,[["(?:(?:[1-356]\\d|4[02-8]|8[2-9])\\d|9(?:0[3-9]|[1-9]\\d))\\d{5}|7(?:0(?:[013-689]\\d|2[0-24-9])\\d{3,4}|[1-79]\\d{6})|(?:[12]\\d|4[147]|5[14579]|6[1578]|7[1-3578])\\d{5}",[7,8]],["(?:702[0-24-9]|819[01])\\d{6}|(?:70[13-689]|8(?:0[1-9]|1[0-8])|9(?:0[1-9]|1[1-356]))\\d{7}",[10]],["800\\d{7,11}",[10,11,12,13,14]],0,0,0,["700\\d{7,11}",[10,11,12,13,14]]]],"NI":["505","00","(?:1800|[25-8]\\d{3})\\d{4}",[8],[["(\\d{4})(\\d{4})","$1 $2",["[125-8]"]]],0,0,0,0,0,0,[["2\\d{7}"],["(?:5(?:5[0-7]|[78]\\d)|6(?:20|3[035]|4[045]|5[05]|77|8[1-9]|9[059])|(?:7[5-8]|8\\d)\\d)\\d{5}"],["1800\\d{4}"]]],"NL":["31","00","(?:[124-7]\\d\\d|3(?:[02-9]\\d|1[0-8]))\\d{6}|8\\d{6,9}|9\\d{6,10}|1\\d{4,5}",[5,6,7,8,9,10,11],[["(\\d{3})(\\d{4,7})","$1 $2",["[89]0"],"0$1"],["(\\d{2})(\\d{7})","$1 $2",["66"],"0$1"],["(\\d)(\\d{8})","$1 $2",["6"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["1[16-8]|2[259]|3[124]|4[17-9]|5[124679]"],"0$1"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["[1-578]|91"],"0$1"],["(\\d{3})(\\d{3})(\\d{5})","$1 $2 $3",["9"],"0$1"]],"0",0,0,0,0,0,[["(?:1(?:[035]\\d|1[13-578]|6[124-8]|7[24]|8[0-467])|2(?:[0346]\\d|2[2-46-9]|5[125]|9[479])|3(?:[03568]\\d|1[3-8]|2[01]|4[1-8])|4(?:[0356]\\d|1[1-368]|7[58]|8[15-8]|9[23579])|5(?:[0358]\\d|[19][1-9]|2[1-57-9]|4[13-8]|6[126]|7[0-3578])|7\\d\\d)\\d{6}",[9]],["(?:6[1-58]|970\\d)\\d{7}",[9,11]],["800\\d{4,7}",[7,8,9,10]],["90[069]\\d{4,7}",[7,8,9,10]],0,0,["140(?:1[035]|2[0346]|3[03568]|4[0356]|5[0358]|8[458])|(?:140(?:1[16-8]|2[259]|3[124]|4[17-9]|5[124679]|7)|8[478]\\d{6})\\d",[5,6,9]],["66\\d{7}",[9]],["(?:85|91)\\d{7}",[9]]]],"NO":["47","00","(?:0|[2-9]\\d{3})\\d{4}",[5,8],[["(\\d{3})(\\d{2})(\\d{3})","$1 $2 $3",["[489]|59"]],["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[235-7]"]]],0,0,0,0,0,"[02-689]|7[0-8]",[["(?:2[1-4]|3[1-3578]|5[1-35-7]|6[1-4679]|7[0-8])\\d{6}",[8]],["(?:4[015-8]|59|9\\d)\\d{6}",[8]],["80[01]\\d{5}",[8]],["82[09]\\d{5}",[8]],["880\\d{5}",[8]],0,["(?:0[2-9]|81(?:0(?:0[7-9]|1\\d)|5\\d\\d))\\d{3}"],0,["85[0-5]\\d{5}",[8]],["810(?:0[0-6]|[2-8]\\d)\\d{3}",[8]]]],"NP":["977","00","(?:1\\d|9)\\d{9}|[1-9]\\d{7}",[8,10,11],[["(\\d)(\\d{7})","$1-$2",["1[2-6]"],"0$1"],["(\\d{2})(\\d{6})","$1-$2",["1[01]|[2-8]|9(?:[1-59]|[67][2-6])"],"0$1"],["(\\d{3})(\\d{7})","$1-$2",["9"]]],"0",0,0,0,0,0,[["(?:1[0-6]\\d|99[02-6])\\d{5}|(?:2[13-79]|3[135-8]|4[146-9]|5[135-7]|6[13-9]|7[15-9]|8[1-46-9]|9[1-7])[2-6]\\d{5}",[8]],["9(?:6[0-3]|7[024-6]|8[0-24-68])\\d{7}",[10]],["1(?:66001|800\\d\\d)\\d{5}",[11]]]],"NR":["674","00","(?:444|(?:55|8\\d)\\d|666)\\d{4}",[7],[["(\\d{3})(\\d{4})","$1 $2",["[4-68]"]]],0,0,0,0,0,0,[["444\\d{4}"],["(?:55[3-9]|666|8\\d\\d)\\d{4}"]]],"NU":["683","00","(?:[47]|888\\d)\\d{3}",[4,7],[["(\\d{3})(\\d{4})","$1 $2",["8"]]],0,0,0,0,0,0,[["[47]\\d{3}",[4]],["888[4-9]\\d{3}",[7]]]],"NZ":["64","0(?:0|161)","[29]\\d{7,9}|50\\d{5}(?:\\d{2,3})?|6[0-35-9]\\d{6}|7\\d{7,8}|8\\d{4,9}|(?:11\\d|[34])\\d{7}",[5,6,7,8,9,10],[["(\\d{2})(\\d{3,8})","$1 $2",["8[1-579]"],"0$1"],["(\\d{3})(\\d{2})(\\d{2,3})","$1 $2 $3",["50[036-8]|[89]0","50(?:[0367]|88)|[89]0"],"0$1"],["(\\d)(\\d{3})(\\d{4})","$1 $2 $3",["24|[346]|7[2-57-9]|9[2-9]"],"0$1"],["(\\d{3})(\\d{3})(\\d{3,4})","$1 $2 $3",["2(?:10|74)|[59]|80"],"0$1"],["(\\d{2})(\\d{3,4})(\\d{4})","$1 $2 $3",["1|2[028]"],"0$1"],["(\\d{2})(\\d{3})(\\d{3,5})","$1 $2 $3",["2(?:[169]|7[0-35-9])|7|86"],"0$1"]],"0",0,0,0,0,0,[["24099\\d{3}|(?:3[2-79]|[49][2-9]|6[235-9]|7[2-57-9])\\d{6}",[8]],["2[0-27-9]\\d{7,8}|21\\d{6}",[8,9,10]],["508\\d{6,7}|80\\d{6,8}",[8,9,10]],["(?:11\\d{5}|50(?:0[08]|30|66|77|88))\\d{3}|90\\d{6,8}",[7,8,9,10]],["70\\d{7}",[9]],0,["8(?:1[6-9]|22|3\\d|4[045]|5[459]|7[0-3579]|90)\\d{2,7}"],["[28]6\\d{6,7}",[8,9]]],"00"],"OM":["968","00","(?:1505|[279]\\d{3}|500)\\d{4}|800\\d{5,6}",[7,8,9],[["(\\d{3})(\\d{4,6})","$1 $2",["[58]"]],["(\\d{2})(\\d{6})","$1 $2",["2"]],["(\\d{4})(\\d{4})","$1 $2",["[179]"]]],0,0,0,0,0,0,[["2[2-6]\\d{6}",[8]],["1505\\d{4}|(?:7(?:[1289]\\d|7[0-5])|9(?:0[1-9]|[1-9]\\d))\\d{5}",[8]],["8007\\d{4,5}|(?:500|800[05])\\d{4}"],["900\\d{5}",[8]]]],"PA":["507","00","(?:00800|8\\d{3})\\d{6}|[68]\\d{7}|[1-57-9]\\d{6}",[7,8,10,11],[["(\\d{3})(\\d{4})","$1-$2",["[1-57-9]"]],["(\\d{4})(\\d{4})","$1-$2",["[68]"]],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["8"]]],0,0,0,0,0,0,[["(?:1(?:0\\d|1[479]|2[37]|3[0137]|4[17]|5[05]|6[58]|7[0167]|8[2358]|9[1389])|2(?:[0235-79]\\d|1[0-7]|4[013-9]|8[02-9])|3(?:[089]\\d|1[0-7]|2[0-5]|33|4[0-79]|5[0-35]|6[068]|7[0-8])|4(?:00|3[0-579]|4\\d|7[0-57-9])|5(?:[01]\\d|2[0-7]|[56]0|79)|7(?:0[09]|2[0-26-8]|3[03]|4[04]|5[05-9]|6[056]|7[0-24-9]|8[5-9]|90)|8(?:09|2[89]|3\\d|4[0-24-689]|5[014]|8[02])|9(?:0[5-9]|1[0135-8]|2[036-9]|3[35-79]|40|5[0457-9]|6[05-9]|7[04-9]|8[35-8]|9\\d))\\d{4}",[7]],["(?:1[16]1|21[89]|6\\d{3}|8(?:1[01]|7[23]))\\d{4}",[7,8]],["800\\d{4,5}|(?:00800|800\\d)\\d{6}"],["(?:8(?:22|55|60|7[78]|86)|9(?:00|81))\\d{4}",[7]]]],"PE":["51","00|19(?:1[124]|77|90)00","(?:[14-8]|9\\d)\\d{7}",[8,9],[["(\\d{3})(\\d{5})","$1 $2",["80"],"(0$1)"],["(\\d)(\\d{7})","$1 $2",["1"],"(0$1)"],["(\\d{2})(\\d{6})","$1 $2",["[4-8]"],"(0$1)"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["9"]]],"0",0,0,0,0,0,[["(?:(?:4[34]|5[14])[0-8]\\d|7(?:173|3[0-8]\\d)|8(?:10[05689]|6(?:0[06-9]|1[6-9]|29)|7(?:0[569]|[56]0)))\\d{4}|(?:1[0-8]|4[12]|5[236]|6[1-7]|7[246]|8[2-4])\\d{6}",[8]],["9\\d{8}",[9]],["800\\d{5}",[8]],["805\\d{5}",[8]],["80[24]\\d{5}",[8]],0,0,0,0,["801\\d{5}",[8]]],"00"," Anexo "],"PF":["689","00","4\\d{5}(?:\\d{2})?|8\\d{7,8}",[6,8,9],[["(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3",["44"]],["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["4|8[7-9]"]],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["8"]]],0,0,0,0,0,0,[["4(?:0[4-689]|9[4-68])\\d{5}",[8]],["8[7-9]\\d{6}",[8]],["80[0-5]\\d{6}",[9]],0,0,0,["44\\d{4}",[6]],0,["499\\d{5}",[8]]]],"PG":["675","00|140[1-3]","(?:180|[78]\\d{3})\\d{4}|(?:[2-589]\\d|64)\\d{5}",[7,8],[["(\\d{3})(\\d{4})","$1 $2",["18|[2-69]|85"]],["(\\d{4})(\\d{4})","$1 $2",["[78]"]]],0,0,0,0,0,0,[["(?:(?:3[0-2]|4[257]|5[34]|9[78])\\d|64[1-9]|85[02-46-9])\\d{4}",[7]],["(?:7\\d|8[128])\\d{6}",[8]],["180\\d{4}",[7]],0,0,0,0,["27[01]\\d{4}",[7]],["2(?:0[0-57]|7[568])\\d{4}",[7]]],"00"],"PH":["63","00","(?:[2-7]|9\\d)\\d{8}|2\\d{5}|(?:1800|8)\\d{7,9}",[6,8,9,10,11,12,13],[["(\\d)(\\d{5})","$1 $2",["2"],"(0$1)"],["(\\d{4})(\\d{4,6})","$1 $2",["3(?:23|39|46)|4(?:2[3-6]|[35]9|4[26]|76)|544|88[245]|(?:52|64|86)2","3(?:230|397|461)|4(?:2(?:35|[46]4|51)|396|4(?:22|63)|59[347]|76[15])|5(?:221|446)|642[23]|8(?:622|8(?:[24]2|5[13]))"],"(0$1)"],["(\\d{5})(\\d{4})","$1 $2",["346|4(?:27|9[35])|883","3469|4(?:279|9(?:30|56))|8834"],"(0$1)"],["(\\d)(\\d{4})(\\d{4})","$1 $2 $3",["2"],"(0$1)"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["[3-7]|8[2-8]"],"(0$1)"],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["[89]"],"0$1"],["(\\d{4})(\\d{3})(\\d{4})","$1 $2 $3",["1"]],["(\\d{4})(\\d{1,2})(\\d{3})(\\d{4})","$1 $2 $3 $4",["1"]]],"0",0,0,0,0,0,[["(?:(?:2[3-8]|3[2-68]|4[2-9]|5[2-6]|6[2-58]|7[24578])\\d{3}|88(?:22\\d\\d|42))\\d{4}|(?:2|8[2-8]\\d\\d)\\d{5}",[6,8,9,10]],["(?:8(?:1[37]|9[5-8])|9(?:0[5-9]|1[0-24-9]|[235-7]\\d|4[2-9]|8[135-9]|9[1-9]))\\d{7}",[10]],["1800\\d{7,9}",[11,12,13]]]],"PK":["92","00","122\\d{6}|[24-8]\\d{10,11}|9(?:[013-9]\\d{8,10}|2(?:[01]\\d\\d|2(?:[06-8]\\d|1[01]))\\d{7})|(?:[2-8]\\d{3}|92(?:[0-7]\\d|8[1-9]))\\d{6}|[24-9]\\d{8}|[89]\\d{7}",[8,9,10,11,12],[["(\\d{3})(\\d{3})(\\d{2,7})","$1 $2 $3",["[89]0"],"0$1"],["(\\d{4})(\\d{5})","$1 $2",["1"]],["(\\d{3})(\\d{6,7})","$1 $2",["2(?:3[2358]|4[2-4]|9[2-8])|45[3479]|54[2-467]|60[468]|72[236]|8(?:2[2-689]|3[23578]|4[3478]|5[2356])|9(?:2[2-8]|3[27-9]|4[2-6]|6[3569]|9[25-8])","9(?:2[3-8]|98)|(?:2(?:3[2358]|4[2-4]|9[2-8])|45[3479]|54[2-467]|60[468]|72[236]|8(?:2[2-689]|3[23578]|4[3478]|5[2356])|9(?:22|3[27-9]|4[2-6]|6[3569]|9[25-7]))[2-9]"],"(0$1)"],["(\\d{2})(\\d{7,8})","$1 $2",["(?:2[125]|4[0-246-9]|5[1-35-7]|6[1-8]|7[14]|8[16]|91)[2-9]"],"(0$1)"],["(\\d{5})(\\d{5})","$1 $2",["58"],"(0$1)"],["(\\d{3})(\\d{7})","$1 $2",["3"],"0$1"],["(\\d{2})(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3 $4",["2[125]|4[0-246-9]|5[1-35-7]|6[1-8]|7[14]|8[16]|91"],"(0$1)"],["(\\d{3})(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3 $4",["[24-9]"],"(0$1)"]],"0",0,0,0,0,0,[["(?:(?:21|42)[2-9]|58[126])\\d{7}|(?:2[25]|4[0146-9]|5[1-35-7]|6[1-8]|7[14]|8[16]|91)[2-9]\\d{6,7}|(?:2(?:3[2358]|4[2-4]|9[2-8])|45[3479]|54[2-467]|60[468]|72[236]|8(?:2[2-689]|3[23578]|4[3478]|5[2356])|9(?:2[2-8]|3[27-9]|4[2-6]|6[3569]|9[25-8]))[2-9]\\d{5,6}",[9,10]],["3(?:[0-24]\\d|3[0-7]|55|64)\\d{7}",[10]],["800\\d{5}(?:\\d{3})?",[8,11]],["900\\d{5}",[8]],["122\\d{6}",[9]],0,["(?:2(?:[125]|3[2358]|4[2-4]|9[2-8])|4(?:[0-246-9]|5[3479])|5(?:[1-35-7]|4[2-467])|6(?:0[468]|[1-8])|7(?:[14]|2[236])|8(?:[16]|2[2-689]|3[23578]|4[3478]|5[2356])|9(?:1|22|3[27-9]|4[2-6]|6[3569]|9[2-7]))111\\d{6}",[11,12]]]],"PL":["48","00","(?:6|8\\d\\d)\\d{7}|[1-9]\\d{6}(?:\\d{2})?|[26]\\d{5}",[6,7,8,9,10],[["(\\d{5})","$1",["19"]],["(\\d{3})(\\d{3})","$1 $2",["11|20|64"]],["(\\d{2})(\\d{2})(\\d{3})","$1 $2 $3",["(?:1[2-8]|2[2-69]|3[2-4]|4[1-468]|5[24-689]|6[1-3578]|7[14-7]|8[1-79]|9[145])1","(?:1[2-8]|2[2-69]|3[2-4]|4[1-468]|5[24-689]|6[1-3578]|7[14-7]|8[1-79]|9[145])19"]],["(\\d{3})(\\d{2})(\\d{2,3})","$1 $2 $3",["64"]],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["21|39|45|5[0137]|6[0469]|7[02389]|8(?:0[14]|8)"]],["(\\d{2})(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3 $4",["1[2-8]|[2-7]|8[1-79]|9[145]"]],["(\\d{3})(\\d{3})(\\d{3,4})","$1 $2 $3",["8"]]],0,0,0,0,0,0,[["47\\d{7}|(?:1[2-8]|2[2-69]|3[2-4]|4[1-468]|5[24-689]|6[1-3578]|7[14-7]|8[1-79]|9[145])(?:[02-9]\\d{6}|1(?:[0-8]\\d{5}|9\\d{3}(?:\\d{2})?))",[7,9]],["21(?:1(?:[145]\\d|3[1-5])|2[0-4]\\d)\\d{4}|(?:45|5[0137]|6[069]|7[2389]|88)\\d{7}",[9]],["800\\d{6,7}",[9,10]],["70[01346-8]\\d{6}",[9]],0,0,["804\\d{6}",[9]],["64\\d{4,7}",[6,7,8,9]],["39\\d{7}",[9]],["801\\d{6}",[9]]]],"PM":["508","00","[45]\\d{5}|(?:708|80\\d)\\d{6}",[6,9],[["(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3",["[45]"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["7"]],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["8"],"0$1"]],"0",0,0,0,0,0,[["(?:4[1-356]|50)\\d{4}",[6]],["(?:4[02-4]|5[056]|708[45][0-5])\\d{4}"],["80[0-5]\\d{6}",[9]]]],"PR":["1","011","(?:[589]\\d\\d|787)\\d{7}",[10],0,"1",0,0,0,0,"787|939",[["(?:787|939)[2-9]\\d{6}"],[""],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"PS":["970","00","[2489]2\\d{6}|(?:1\\d|5)\\d{8}",[8,9,10],[["(\\d)(\\d{3})(\\d{4})","$1 $2 $3",["[2489]"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["5"],"0$1"],["(\\d{4})(\\d{3})(\\d{3})","$1 $2 $3",["1"]]],"0",0,0,0,0,0,[["(?:22[2-47-9]|42[45]|82[014-68]|92[3569])\\d{5}",[8]],["5[69]\\d{7}",[9]],["1800\\d{6}",[10]],0,0,0,0,0,0,["1700\\d{6}",[10]]]],"PT":["351","00","1693\\d{5}|(?:[26-9]\\d|30)\\d{7}",[9],[["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["2[12]"]],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["16|[236-9]"]]],0,0,0,0,0,0,[["2(?:[12]\\d|3[1-689]|4[1-59]|[57][1-9]|6[1-35689]|8[1-69]|9[1256])\\d{6}"],["6(?:[06]92(?:30|9\\d)|[35]92(?:3[03]|9\\d))\\d{3}|(?:(?:16|6[0356])93|9(?:[1-36]\\d\\d|480))\\d{5}"],["80[02]\\d{6}"],["(?:6(?:0[178]|4[68])\\d|76(?:0[1-57]|1[2-47]|2[237]))\\d{5}"],["884[0-4689]\\d{5}"],0,["70(?:38[01]|596|(?:7\\d|8[17])\\d)\\d{4}"],["6222\\d{5}"],["30\\d{7}"],["80(?:8\\d|9[1579])\\d{5}"]]],"PW":["680","01[12]","(?:[24-8]\\d\\d|345|900)\\d{4}",[7],[["(\\d{3})(\\d{4})","$1 $2",["[2-9]"]]],0,0,0,0,0,0,[["(?:2(?:55|77)|345|488|5(?:35|44|87)|6(?:22|54|79)|7(?:33|47)|8(?:24|55|76)|900)\\d{4}"],["(?:(?:46|83)[0-5]|6[2-4689]0)\\d{4}|(?:45|77|88)\\d{5}"]]],"PY":["595","00","59\\d{4,6}|9\\d{5,10}|(?:[2-46-8]\\d|5[0-8])\\d{4,7}",[6,7,8,9,10,11],[["(\\d{3})(\\d{3,6})","$1 $2",["[2-9]0"],"0$1"],["(\\d{2})(\\d{5})","$1 $2",["[26]1|3[289]|4[1246-8]|7[1-3]|8[1-36]"],"(0$1)"],["(\\d{3})(\\d{4,5})","$1 $2",["2[279]|3[13-5]|4[359]|5|6(?:[34]|7[1-46-8])|7[46-8]|85"],"(0$1)"],["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["2[14-68]|3[26-9]|4[1246-8]|6(?:1|75)|7[1-35]|8[1-36]"],"(0$1)"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["87"]],["(\\d{3})(\\d{6})","$1 $2",["9(?:[5-79]|8[1-6])"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[2-8]"],"0$1"],["(\\d{4})(\\d{3})(\\d{4})","$1 $2 $3",["9"]]],"0",0,0,0,0,0,[["(?:[26]1|3[289]|4[1246-8]|7[1-3]|8[1-36])\\d{5,7}|(?:2(?:2[4-68]|[4-68]\\d|7[15]|9[1-5])|3(?:18|3[167]|4[2357]|51|[67]\\d)|4(?:3[12]|5[13]|9[1-47])|5(?:[1-4]\\d|5[02-4])|6(?:3[1-3]|44|7[1-8])|7(?:4[0-4]|5\\d|6[1-578]|75|8[0-8])|858)\\d{5,6}",[7,8,9]],["9(?:51|6[129]|[78][1-6]|9[1-5])\\d{6}",[9]],["9800\\d{5,7}",[9,10,11]],0,0,0,["[2-9]0\\d{4,7}",[6,7,8,9]],0,["8700[0-4]\\d{4}",[9]]]],"QA":["974","00","800\\d{4}|(?:2|800)\\d{6}|(?:0080|[3-7])\\d{7}",[7,8,9,11],[["(\\d{3})(\\d{4})","$1 $2",["2[16]|8"]],["(\\d{4})(\\d{4})","$1 $2",["[3-7]"]]],0,0,0,0,0,0,[["4(?:1111|2022)\\d{3}|4(?:[04]\\d\\d|14[0-6]|999)\\d{4}",[8]],["[35-7]\\d{7}",[8]],["800\\d{4}|(?:0080[01]|800)\\d{6}",[7,9,11]],0,0,0,0,["2(?:1\\d|61)\\d{4}",[7]]]],"RE":["262","00","(?:26|[689]\\d)\\d{7}",[9],[["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[2689]"],"0$1"]],"0",0,0,0,0,0,[["26(?:2\\d\\d|3(?:0\\d|1[0-3]))\\d{4}"],["(?:69(?:2\\d\\d|3(?:0[0-46]|1[013]|2[0-2]|3[0-39]|4\\d|5[0-5]|6[0-6]|7[0-27]|8[0-8]|9[0-479]))|9(?:399[0-2]|479[01]|76(?:2[27]|3[0-37]|9\\d)))\\d{4}"],["80\\d{7}"],["89[1-37-9]\\d{6}"],0,0,0,0,0,["8(?:1[019]|2[0156]|84|90)\\d{6}"]]],"RO":["40","00","(?:[2378]\\d|90)\\d{7}|[23]\\d{5}",[6,9],[["(\\d{3})(\\d{3})","$1 $2",["2[3-6]","2[3-6]\\d9"],"0$1"],["(\\d{2})(\\d{4})","$1 $2",["219|31"],"0$1"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["[23]1"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[237-9]"],"0$1"]],"0",0,0,0,0,0,[["[23][13-6]\\d{7}|(?:2(?:19\\d|[3-6]\\d9)|31\\d\\d)\\d\\d"],["7020\\d{5}|7(?:0[013-9]|1[0-3]|[2-7]\\d|8[03-8]|9[0-29])\\d{6}",[9]],["800\\d{6}",[9]],["90[0136]\\d{6}",[9]],0,0,["(?:37\\d|80[578])\\d{6}",[9]],0,0,["801\\d{6}",[9]]],0," int "],"RS":["381","00","38[02-9]\\d{6,9}|6\\d{7,9}|90\\d{4,8}|38\\d{5,6}|(?:7\\d\\d|800)\\d{3,9}|(?:[12]\\d|3[0-79])\\d{5,10}",[6,7,8,9,10,11,12],[["(\\d{3})(\\d{3,9})","$1 $2",["(?:2[389]|39)0|[7-9]"],"0$1"],["(\\d{2})(\\d{5,10})","$1 $2",["[1-36]"],"0$1"]],"0",0,0,0,0,0,[["(?:11[1-9]\\d|(?:2[389]|39)(?:0[2-9]|[2-9]\\d))\\d{3,8}|(?:1[02-9]|2[0-24-7]|3[0-8])[2-9]\\d{4,9}",[7,8,9,10,11,12]],["6(?:[0-689]|7\\d)\\d{6,7}",[8,9,10]],["800\\d{3,9}"],["(?:78\\d|90[0169])\\d{3,7}",[6,7,8,9,10]],0,0,["7[06]\\d{4,10}"]]],"RU":["7","810","8\\d{13}|[347-9]\\d{9}",[10,14],[["(\\d{4})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["7(?:1[0-8]|2[1-9])","7(?:1(?:[0-356]2|4[29]|7|8[27])|2(?:1[23]|[2-9]2))","7(?:1(?:[0-356]2|4[29]|7|8[27])|2(?:13[03-69]|62[013-9]))|72[1-57-9]2"],"8 ($1)",1],["(\\d{5})(\\d)(\\d{2})(\\d{2})","$1 $2 $3 $4",["7(?:1[0-68]|2[1-9])","7(?:1(?:[06][3-6]|[18]|2[35]|[3-5][3-5])|2(?:[13][3-5]|[24-689]|7[457]))","7(?:1(?:0(?:[356]|4[023])|[18]|2(?:3[013-9]|5)|3[45]|43[013-79]|5(?:3[1-8]|4[1-7]|5)|6(?:3[0-35-9]|[4-6]))|2(?:1(?:3[178]|[45])|[24-689]|3[35]|7[457]))|7(?:14|23)4[0-8]|71(?:33|45)[1-79]"],"8 ($1)",1],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["7"],"8 ($1)",1],["(\\d{3})(\\d{3})(\\d{2})(\\d{2})","$1 $2-$3-$4",["[349]|8(?:[02-7]|1[1-8])"],"8 ($1)",1],["(\\d{4})(\\d{4})(\\d{3})(\\d{3})","$1 $2 $3 $4",["8"],"8 ($1)"]],"8",0,0,0,0,"3[04-689]|[489]",[["(?:3(?:0[12]|4[1-35-79]|5[1-3]|65|8[1-58]|9[0145])|4(?:01|1[1356]|2[13467]|7[1-5]|8[1-7]|9[1-689])|8(?:1[1-8]|2[01]|3[13-6]|4[0-8]|5[15]|6[1-35-79]|7[1-37-9]))\\d{7}",[10]],["9\\d{9}",[10]],["8(?:0[04]|108\\d{3})\\d{7}"],["80[39]\\d{7}",[10]],["808\\d{7}",[10]]],"8~10"],"RW":["250","00","(?:06|[27]\\d\\d|[89]00)\\d{6}",[8,9],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["0"]],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[7-9]"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["2"]]],"0",0,0,0,0,0,[["(?:06|2[23568]\\d)\\d{6}"],["7[2389]\\d{7}",[9]],["800\\d{6}",[9]],["900\\d{6}",[9]]]],"SA":["966","00","92\\d{7}|(?:[15]|8\\d)\\d{8}",[9,10],[["(\\d{4})(\\d{5})","$1 $2",["9"]],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["1"],"0$1"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["5"],"0$1"],["(\\d{3})(\\d{3})(\\d{3,4})","$1 $2 $3",["81"],"0$1"],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["8"]]],"0",0,0,0,0,0,[["1(?:1\\d|2[24-8]|3[35-8]|4[3-68]|6[2-5]|7[235-7])\\d{6}",[9]],["579[01]\\d{5}|5(?:[013-689]\\d|7[0-35-8])\\d{6}",[9]],["800\\d{7}",[10]],["925\\d{6}",[9]],0,0,["811\\d{7}",[10]],0,0,["920\\d{6}",[9]]]],"SB":["677","0[01]","(?:[1-6]|[7-9]\\d\\d)\\d{4}",[5,7],[["(\\d{2})(\\d{5})","$1 $2",["7|8[4-9]|9(?:[1-8]|9[0-8])"]]],0,0,0,0,0,0,[["(?:1[4-79]|[23]\\d|4[0-2]|5[03]|6[0-37])\\d{3}",[5]],["48\\d{3}|(?:(?:7[1-9]|8[4-9])\\d|9(?:1[2-9]|2[013-9]|3[0-2]|[46]\\d|5[0-46-9]|7[0-689]|8[0-79]|9[0-8]))\\d{4}"],["1[38]\\d{3}",[5]],0,0,0,0,0,["5[12]\\d{3}",[5]]]],"SC":["248","010|0[0-2]","800\\d{4}|(?:[249]\\d|64)\\d{5}",[7],[["(\\d)(\\d{3})(\\d{3})","$1 $2 $3",["[246]|9[57]"]]],0,0,0,0,0,0,[["4[2-46]\\d{5}"],["2[125-8]\\d{5}"],["800[08]\\d{3}"],0,0,0,0,0,["971\\d{4}|(?:64|95)\\d{5}"]],"00"],"SD":["249","00","[19]\\d{8}",[9],[["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["[19]"],"0$1"]],"0",0,0,0,0,0,[["1(?:5\\d|8[35-7])\\d{6}"],["(?:1[0-2]|9[0-3569])\\d{7}"]]],"SE":["46","00","(?:[26]\\d\\d|9)\\d{9}|[1-9]\\d{8}|[1-689]\\d{7}|[1-4689]\\d{6}|2\\d{5}",[6,7,8,9,10],[["(\\d{2})(\\d{2,3})(\\d{2})","$1-$2 $3",["20"],"0$1",0,"$1 $2 $3"],["(\\d{3})(\\d{4})","$1-$2",["9(?:00|39|44|9)"],"0$1",0,"$1 $2"],["(\\d{2})(\\d{3})(\\d{2})","$1-$2 $3",["[12][136]|3[356]|4[0246]|6[03]|90[1-9]"],"0$1",0,"$1 $2 $3"],["(\\d)(\\d{2,3})(\\d{2})(\\d{2})","$1-$2 $3 $4",["8"],"0$1",0,"$1 $2 $3 $4"],["(\\d{3})(\\d{2,3})(\\d{2})","$1-$2 $3",["1[2457]|2(?:[247-9]|5[0138])|3[0247-9]|4[1357-9]|5[0-35-9]|6(?:[125689]|4[02-57]|7[0-2])|9(?:[125-8]|3[02-5]|4[0-3])"],"0$1",0,"$1 $2 $3"],["(\\d{3})(\\d{2,3})(\\d{3})","$1-$2 $3",["9(?:00|39|44)"],"0$1",0,"$1 $2 $3"],["(\\d{2})(\\d{2,3})(\\d{2})(\\d{2})","$1-$2 $3 $4",["1[13689]|2[0136]|3[1356]|4[0246]|54|6[03]|90[1-9]"],"0$1",0,"$1 $2 $3 $4"],["(\\d{2})(\\d{3})(\\d{2})(\\d{2})","$1-$2 $3 $4",["10|7"],"0$1",0,"$1 $2 $3 $4"],["(\\d)(\\d{3})(\\d{3})(\\d{2})","$1-$2 $3 $4",["8"],"0$1",0,"$1 $2 $3 $4"],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1-$2 $3 $4",["[13-5]|2(?:[247-9]|5[0138])|6(?:[124-689]|7[0-2])|9(?:[125-8]|3[02-5]|4[0-3])"],"0$1",0,"$1 $2 $3 $4"],["(\\d{3})(\\d{2})(\\d{2})(\\d{3})","$1-$2 $3 $4",["9"],"0$1",0,"$1 $2 $3 $4"],["(\\d{3})(\\d{2})(\\d{3})(\\d{2})(\\d{2})","$1-$2 $3 $4 $5",["[26]"],"0$1",0,"$1 $2 $3 $4 $5"]],"0",0,0,0,0,0,[["(?:(?:[12][136]|3[356]|4[0246]|6[03]|8\\d)\\d|90[1-9])\\d{4,6}|(?:1(?:2[0-35]|4[0-4]|5[0-25-9]|7[13-6]|[89]\\d)|2(?:2[0-7]|4[0136-8]|5[0138]|7[018]|8[01]|9[0-57])|3(?:0[0-4]|1\\d|2[0-25]|4[056]|7[0-2]|8[0-3]|9[023])|4(?:1[013-8]|3[0135]|5[14-79]|7[0-246-9]|8[0156]|9[0-689])|5(?:0[0-6]|[15][0-5]|2[0-68]|3[0-4]|4\\d|6[03-5]|7[013]|8[0-79]|9[01])|6(?:1[1-3]|2[0-4]|4[02-57]|5[0-37]|6[0-3]|7[0-2]|8[0247]|9[0-356])|9(?:1[0-68]|2\\d|3[02-5]|4[0-3]|5[0-4]|[68][01]|7[0135-8]))\\d{5,6}",[7,8,9]],["7[02369]\\d{7}",[9]],["20\\d{4,7}",[6,7,8,9]],["649\\d{6}|99[1-59]\\d{4}(?:\\d{3})?|9(?:00|39|44)[1-8]\\d{3,6}",[7,8,9,10]],["75[1-8]\\d{6}",[9]],0,["10[1-8]\\d{6}",[9]],["74[02-9]\\d{6}",[9]],0,["77[0-7]\\d{6}",[9]]]],"SG":["65","0[0-3]\\d","(?:(?:1\\d|8)\\d\\d|7000)\\d{7}|[3689]\\d{7}",[8,10,11],[["(\\d{4})(\\d{4})","$1 $2",["[369]|8(?:0[1-6]|[1-9])"]],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["8"]],["(\\d{4})(\\d{4})(\\d{3})","$1 $2 $3",["7"]],["(\\d{4})(\\d{3})(\\d{4})","$1 $2 $3",["1"]]],0,0,0,0,0,0,[["662[0-24-9]\\d{4}|6(?:[0-578]\\d|6[013-57-9]|9[0-35-9])\\d{5}",[8]],["8(?:06[0-6]|95[0-2])\\d{4}|(?:8(?:0[1-5]|[1-8]\\d|9[0-4])|9[0-8]\\d)\\d{5}",[8]],["(?:18|8)00\\d{7}",[10,11]],["1900\\d{7}",[11]],0,0,["7000\\d{7}",[11]],0,["(?:3[12]\\d|666)\\d{5}",[8]]]],"SH":["290","00","(?:[256]\\d|8)\\d{3}",[4,5],0,0,0,0,0,0,"[256]",[["2(?:[0-57-9]\\d|6[4-9])\\d\\d"],["[56]\\d{4}",[5]],0,0,0,0,0,0,["262\\d\\d",[5]]]],"SI":["386","00|10(?:22|66|88|99)","[1-7]\\d{7}|8\\d{4,7}|90\\d{4,6}",[5,6,7,8],[["(\\d{2})(\\d{3,6})","$1 $2",["8[09]|9"],"0$1"],["(\\d{3})(\\d{5})","$1 $2",["59|8"],"0$1"],["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["[37][01]|4[0139]|51|6"],"0$1"],["(\\d)(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[1-57]"],"(0$1)"]],"0",0,0,0,0,0,[["(?:[1-357][2-8]|4[24-8])\\d{6}",[8]],["65(?:[178]\\d|5[56]|6[01])\\d{4}|(?:[37][01]|4[0139]|51|6[489])\\d{6}",[8]],["80\\d{4,6}",[6,7,8]],["89[1-3]\\d{2,5}|90\\d{4,6}"],0,0,0,0,["(?:59\\d\\d|8(?:1(?:[67]\\d|8[0-589])|2(?:0\\d|2[0-37-9]|8[0-2489])|3[389]\\d))\\d{4}",[8]]],"00"],"SJ":["47","00","0\\d{4}|(?:[489]\\d|[57]9)\\d{6}",[5,8],0,0,0,0,0,0,"79",[["79\\d{6}",[8]],["(?:4[015-8]|59|9\\d)\\d{6}",[8]],["80[01]\\d{5}",[8]],["82[09]\\d{5}",[8]],["880\\d{5}",[8]],0,["(?:0[2-9]|81(?:0(?:0[7-9]|1\\d)|5\\d\\d))\\d{3}"],0,["85[0-5]\\d{5}",[8]],["810(?:0[0-6]|[2-8]\\d)\\d{3}",[8]]]],"SK":["421","00","[2-689]\\d{8}|[2-59]\\d{6}|[2-5]\\d{5}",[6,7,9],[["(\\d)(\\d{2})(\\d{3,4})","$1 $2 $3",["21"],"0$1"],["(\\d{2})(\\d{2})(\\d{2,3})","$1 $2 $3",["[3-5][1-8]1","[3-5][1-8]1[67]"],"0$1"],["(\\d)(\\d{3})(\\d{3})(\\d{2})","$1/$2 $3 $4",["2"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[689]"],"0$1"],["(\\d{2})(\\d{3})(\\d{2})(\\d{2})","$1/$2 $3 $4",["[3-5]"],"0$1"]],"0",0,0,0,0,0,[["(?:2(?:16|[2-9]\\d{3})|(?:(?:[3-5][1-8]\\d|819)\\d|601[1-5])\\d)\\d{4}|(?:2|[3-5][1-8])1[67]\\d{3}|[3-5][1-8]16\\d\\d"],["909[1-9]\\d{5}|9(?:0[1-8]|1[0-24-9]|4[03-57-9]|5\\d)\\d{6}",[9]],["800\\d{6}",[9]],["9(?:00|[78]\\d)\\d{6}",[9]],0,0,["96\\d{7}",[9]],["9090\\d{3}",[7]],["6(?:02|5[0-4]|9[0-6])\\d{6}",[9]],["8[5-9]\\d{7}",[9]]]],"SL":["232","00","(?:[237-9]\\d|66)\\d{6}",[8],[["(\\d{2})(\\d{6})","$1 $2",["[236-9]"],"(0$1)"]],"0",0,0,0,0,0,[["22[2-4][2-9]\\d{4}"],["(?:25|3[0-5]|66|7[2-9]|8[08]|9[09])\\d{6}"]]],"SM":["378","00","(?:0549|[5-7]\\d)\\d{6}",[8,10],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[5-7]"]],["(\\d{4})(\\d{6})","$1 $2",["0"]]],0,0,"([89]\\d{5})$","0549$1",0,0,[["0549(?:8[0157-9]|9\\d)\\d{4}",[10]],["6[16]\\d{6}",[8]],0,["7[178]\\d{6}",[8]],0,0,0,0,["5[158]\\d{6}",[8]]]],"SN":["221","00","(?:[378]\\d|93)\\d{7}",[9],[["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["8"]],["(\\d{2})(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[379]"]]],0,0,0,0,0,0,[["3(?:0(?:1[0-2]|80)|282|3(?:8[1-9]|9[3-9])|611)\\d{5}"],["7(?:(?:[06-8]\\d|21|90)\\d|5(?:01|[19]0|25|[38]3|[4-7]\\d))\\d{5}"],["800\\d{6}"],["88[4689]\\d{6}"],0,0,0,0,["(?:3(?:392|9[01]\\d)\\d|93(?:3[13]0|929))\\d{4}"],["81[02468]\\d{6}"]]],"SO":["252","00","[346-9]\\d{8}|[12679]\\d{7}|[1-5]\\d{6}|[1348]\\d{5}",[6,7,8,9],[["(\\d{2})(\\d{4})","$1 $2",["8[125]"]],["(\\d{6})","$1",["[134]"]],["(\\d)(\\d{6})","$1 $2",["[15]|2[0-79]|3[0-46-8]|4[0-7]"]],["(\\d)(\\d{7})","$1 $2",["(?:2|90)4|[67]"]],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[3478]|64|90"]],["(\\d{2})(\\d{5,7})","$1 $2",["1|28|6(?:0[5-7]|[1-35-9])|9[2-9]"]]],"0",0,0,0,0,0,[["(?:1\\d|2[0-79]|3[0-46-8]|4[0-7]|5[57-9])\\d{5}|(?:[134]\\d|8[125])\\d{4}",[6,7]],["(?:(?:15|(?:3[59]|4[89]|79|8[08])\\d|6(?:0[5-7]|[1-9]\\d)|9(?:0\\d|[2-9]))\\d|2(?:4\\d|8))\\d{5}|(?:[67]\\d\\d|904)\\d{5}",[7,8,9]]]],"SR":["597","00","(?:[2-5]|68|[78]\\d)\\d{5}",[6,7],[["(\\d{2})(\\d{2})(\\d{2})","$1-$2-$3",["56"]],["(\\d{3})(\\d{3})","$1-$2",["[2-5]"]],["(\\d{3})(\\d{4})","$1-$2",["[6-8]"]]],0,0,0,0,0,0,[["(?:2[1-3]|3[0-7]|(?:4|68)\\d|5[2-58])\\d{4}"],["(?:7[124-7]|8[124-9])\\d{5}",[7]],0,0,0,0,0,0,["56\\d{4}",[6]]]],"SS":["211","00","[19]\\d{8}",[9],[["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[19]"],"0$1"]],"0",0,0,0,0,0,[["1[89]\\d{7}"],["(?:12|9[1257-9])\\d{7}"]]],"ST":["239","00","(?:22|9\\d)\\d{5}",[7],[["(\\d{3})(\\d{4})","$1 $2",["[29]"]]],0,0,0,0,0,0,[["22\\d{5}"],["900[5-9]\\d{3}|9(?:0[1-9]|[89]\\d)\\d{4}"]]],"SV":["503","00","[267]\\d{7}|[89]00\\d{4}(?:\\d{4})?",[7,8,11],[["(\\d{3})(\\d{4})","$1 $2",["[89]"]],["(\\d{4})(\\d{4})","$1 $2",["[267]"]],["(\\d{3})(\\d{4})(\\d{4})","$1 $2 $3",["[89]"]]],0,0,0,0,0,0,[["2(?:[1-6]\\d{3}|[79]90[034]|890[0245])\\d{3}",[8]],["66(?:[02-9]\\d\\d|1(?:[02-9]\\d|16))\\d{3}|(?:6[0-57-9]|7\\d)\\d{6}",[8]],["800\\d{4}(?:\\d{4})?",[7,11]],["900\\d{4}(?:\\d{4})?",[7,11]]]],"SX":["1","011","7215\\d{6}|(?:[58]\\d\\d|900)\\d{7}",[10],0,"1",0,"(5\\d{6})$|1","721$1",0,"721",[["7215(?:4[2-8]|8[239]|9[056])\\d{4}"],["7215(?:1[02]|2\\d|5[034679]|8[014-8])\\d{4}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"SY":["963","00","[1-39]\\d{8}|[1-5]\\d{7}",[8,9],[["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["[1-5]"],"0$1",1],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["9"],"0$1",1]],"0",0,0,0,0,0,[["21\\d{6,7}|(?:1(?:[14]\\d|[2356])|2[235]|3(?:[13]\\d|4)|4[134]|5[1-3])\\d{6}"],["9[1-689]\\d{7}",[9]]]],"SZ":["268","00","0800\\d{4}|(?:[237]\\d|900)\\d{6}",[8,9],[["(\\d{4})(\\d{4})","$1 $2",["[0237]"]],["(\\d{5})(\\d{4})","$1 $2",["9"]]],0,0,0,0,0,0,[["[23][2-5]\\d{6}",[8]],["7[6-9]\\d{6}",[8]],["0800\\d{4}",[8]],["900\\d{6}",[9]],0,0,0,0,["70\\d{6}",[8]]]],"TA":["290","00","8\\d{3}",[4],0,0,0,0,0,0,"8",[["8\\d{3}"]]],"TC":["1","011","(?:[58]\\d\\d|649|900)\\d{7}",[10],0,"1",0,"([2-479]\\d{6})$|1","649$1",0,"649",[["649(?:266|712|9(?:4\\d|50))\\d{4}"],["649(?:2(?:3[129]|4[1-79])|3\\d\\d|4[34][1-3])\\d{4}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"],0,0,0,["649(?:71[01]|966)\\d{4}"]]],"TD":["235","00|16","(?:22|[69]\\d|77)\\d{6}",[8],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[2679]"]]],0,0,0,0,0,0,[["22(?:[37-9]0|5[0-5]|6[89])\\d{4}"],["(?:6[0235689]|77|9\\d)\\d{6}"]],"00"],"TG":["228","00","[279]\\d{7}",[8],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[279]"]]],0,0,0,0,0,0,[["2(?:2[2-7]|3[23]|4[45]|55|6[67]|77)\\d{5}"],["(?:7[019]|9[0-36-9])\\d{6}"]]],"TH":["66","00[1-9]","(?:001800|[2-57]|[689]\\d)\\d{7}|1\\d{7,9}",[8,9,10,13],[["(\\d)(\\d{3})(\\d{4})","$1 $2 $3",["2"],"0$1"],["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["[13-9]"],"0$1"],["(\\d{4})(\\d{3})(\\d{3})","$1 $2 $3",["1"]]],"0",0,0,0,0,0,[["(?:1[0689]|2\\d|3[2-9]|4[2-5]|5[2-6]|7[3-7])\\d{6}",[8]],["671[0-8]\\d{5}|(?:14|6[1-6]|[89]\\d)\\d{7}",[9]],["(?:001800\\d|1800)\\d{6}",[10,13]],["1900\\d{6}",[10]],0,0,0,0,["6[08]\\d{7}",[9]]]],"TJ":["992","810","(?:00|[1-57-9]\\d)\\d{7}",[9],[["(\\d{6})(\\d)(\\d{2})","$1 $2 $3",["331","3317"]],["(\\d{3})(\\d{2})(\\d{4})","$1 $2 $3",["[34]7|91[78]"]],["(\\d{4})(\\d)(\\d{4})","$1 $2 $3",["3[1-5]"]],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["[0-57-9]"]]],0,0,0,0,0,0,[["(?:3(?:1[3-5]|2[245]|3[12]|4[24-7]|5[25]|72)|4(?:46|74|87))\\d{6}"],["41[18]\\d{6}|(?:[034]0|1[017]|2[02]|5[05]|7[0178]|8[078]|9\\d)\\d{7}"]],"8~10"],"TK":["690","00","[2-47]\\d{3,6}",[4,5,6,7],0,0,0,0,0,0,0,[["(?:2[2-4]|[34]\\d)\\d{2,5}"],["7[2-4]\\d{2,5}"]]],"TL":["670","00","7\\d{7}|(?:[2-47]\\d|[89]0)\\d{5}",[7,8],[["(\\d{3})(\\d{4})","$1 $2",["[2-489]|70"]],["(\\d{4})(\\d{4})","$1 $2",["7"]]],0,0,0,0,0,0,[["(?:2[1-5]|3[1-9]|4[1-4])\\d{5}",[7]],["7[2-8]\\d{6}",[8]],["80\\d{5}",[7]],["90\\d{5}",[7]],["70\\d{5}",[7]]]],"TM":["993","810","[1-6]\\d{7}",[8],[["(\\d{2})(\\d{2})(\\d{2})(\\d{2})","$1 $2-$3-$4",["12"],"(8 $1)"],["(\\d{3})(\\d)(\\d{2})(\\d{2})","$1 $2-$3-$4",["[1-5]"],"(8 $1)"],["(\\d{2})(\\d{6})","$1 $2",["6"],"8 $1"]],"8",0,0,0,0,0,[["(?:1(?:2\\d|3[1-9])|2(?:22|4[0-35-8])|3(?:22|4[03-9])|4(?:22|3[128]|4\\d|6[15])|5(?:22|5[7-9]|6[014-689]))\\d{5}"],["6\\d{7}"]],"8~10"],"TN":["216","00","[2-57-9]\\d{7}",[8],[["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["[2-57-9]"]]],0,0,0,0,0,0,[["81200\\d{3}|(?:3[0-2]|7\\d)\\d{6}"],["3(?:001|[12]40)\\d{4}|(?:(?:[259]\\d|4[0-7])\\d|3(?:1[1-35]|6[0-4]|91))\\d{5}"],["8010\\d{4}"],["88\\d{6}"],0,0,0,0,0,["8[12]10\\d{4}"]]],"TO":["676","00","(?:0800|(?:[5-8]\\d\\d|999)\\d)\\d{3}|[2-8]\\d{4}",[5,7],[["(\\d{2})(\\d{3})","$1-$2",["[2-4]|50|6[09]|7[0-24-69]|8[05]"]],["(\\d{4})(\\d{3})","$1 $2",["0"]],["(\\d{3})(\\d{4})","$1 $2",["[5-9]"]]],0,0,0,0,0,0,[["(?:2\\d|3[0-8]|4[0-4]|50|6[09]|7[0-24-69]|8[05])\\d{3}",[5]],["(?:55[4-6]|6(?:[09]\\d|3[02]|8[15-9])|(?:7\\d|8[46-9])\\d|999)\\d{4}",[7]],["0800\\d{3}",[7]],0,0,0,0,0,["55[0-37-9]\\d{4}",[7]]]],"TR":["90","00","4\\d{6}|8\\d{11,12}|(?:[2-58]\\d\\d|900)\\d{7}",[7,10,12,13],[["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["512|8[01589]|90"],"0$1",1],["(\\d{3})(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3 $4",["5(?:[0-59]|61)","5(?:[0-59]|616)","5(?:[0-59]|6161)"],"0$1",1],["(\\d{3})(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[24][1-8]|3[1-9]"],"(0$1)",1],["(\\d{3})(\\d{3})(\\d{6,7})","$1 $2 $3",["80"],"0$1",1]],"0",0,0,0,0,0,[["(?:2(?:[13][26]|[28][2468]|[45][268]|[67][246])|3(?:[13][28]|[24-6][2468]|[78][02468]|92)|4(?:[16][246]|[23578][2468]|4[26]))\\d{7}",[10]],["56161\\d{5}|5(?:0[15-7]|1[06]|24|[34]\\d|5[1-59]|9[46])\\d{7}",[10]],["8(?:00\\d{7}(?:\\d{2,3})?|11\\d{7})",[10,12,13]],["(?:8[89]8|900)\\d{7}",[10]],["592(?:21[12]|461)\\d{4}",[10]],0,["444\\d{4}",[7]],["512\\d{7}",[10]],["850\\d{7}",[10]]]],"TT":["1","011","(?:[58]\\d\\d|900)\\d{7}",[10],0,"1",0,"([2-46-8]\\d{6})$|1","868$1",0,"868",[["868(?:2(?:01|1[5-9]|[23]\\d|4[0-2])|6(?:0[7-9]|1[02-8]|2[1-9]|[3-69]\\d|7[0-79])|82[124])\\d{4}"],["868(?:(?:2[5-9]|3\\d)\\d|4(?:3[0-6]|[6-9]\\d)|6(?:20|78|8\\d)|7(?:0[1-9]|1[02-9]|[2-9]\\d))\\d{4}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"TV":["688","00","(?:2|7\\d\\d|90)\\d{4}",[5,6,7],[["(\\d{2})(\\d{3})","$1 $2",["2"]],["(\\d{2})(\\d{4})","$1 $2",["90"]],["(\\d{2})(\\d{5})","$1 $2",["7"]]],0,0,0,0,0,0,[["2[02-9]\\d{3}",[5]],["(?:7[01]\\d|90)\\d{4}",[6,7]]]],"TW":["886","0(?:0[25-79]|19)","[2-689]\\d{8}|7\\d{9,10}|[2-8]\\d{7}|2\\d{6}",[7,8,9,10,11],[["(\\d{2})(\\d)(\\d{4})","$1 $2 $3",["202"],"0$1"],["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["[258]0"],"0$1"],["(\\d)(\\d{3,4})(\\d{4})","$1 $2 $3",["[23568]|4(?:0[02-48]|[1-47-9])|7[1-9]","[23568]|4(?:0[2-48]|[1-47-9])|(?:400|7)[1-9]"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[49]"],"0$1"],["(\\d{2})(\\d{4})(\\d{4,5})","$1 $2 $3",["7"],"0$1"]],"0",0,0,0,0,0,[["(?:2[2-8]\\d|370|55[01]|7[1-9])\\d{6}|4(?:(?:0(?:0[1-9]|[2-48]\\d)|1[023]\\d)\\d{4,5}|(?:[239]\\d\\d|4(?:0[56]|12|49))\\d{5})|6(?:[01]\\d{7}|4(?:0[56]|12|24|4[09])\\d{4,5})|8(?:(?:2(?:3\\d|4[0-269]|[578]0|66)|36[24-9]|90\\d\\d)\\d{4}|4(?:0[56]|12|24|4[09])\\d{4,5})|(?:2(?:2(?:0\\d\\d|4(?:0[68]|[249]0|3[0-467]|5[0-25-9]|6[0235689]))|(?:3(?:[09]\\d|1[0-4])|(?:4\\d|5[0-49]|6[0-29]|7[0-5])\\d)\\d)|(?:(?:3[2-9]|5[2-8]|6[0-35-79]|8[7-9])\\d\\d|4(?:2(?:[089]\\d|7[1-9])|(?:3[0-4]|[78]\\d|9[01])\\d))\\d)\\d{3}",[8,9]],["(?:40001[0-2]|9[0-8]\\d{4})\\d{3}",[9]],["80[0-79]\\d{6}|800\\d{5}",[8,9]],["20(?:[013-9]\\d\\d|2)\\d{4}",[7,9]],["99\\d{7}",[9]],0,["50[0-46-9]\\d{6}",[9]],0,["7010(?:[0-2679]\\d|3[0-7]|8[0-5])\\d{5}|70\\d{8}",[10,11]]],0,"#"],"TZ":["255","00[056]","(?:[25-8]\\d|41|90)\\d{7}",[9],[["(\\d{3})(\\d{2})(\\d{4})","$1 $2 $3",["[89]"],"0$1"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["[24]"],"0$1"],["(\\d{2})(\\d{7})","$1 $2",["5"]],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[67]"],"0$1"]],"0",0,0,0,0,0,[["2[2-8]\\d{7}"],["77[2-9]\\d{6}|(?:6[125-9]|7[13-689])\\d{7}"],["80[08]\\d{6}"],["90\\d{7}"],0,0,0,0,["41\\d{7}"],["8(?:40|6[01])\\d{6}"]]],"UA":["380","00","[89]\\d{9}|[3-9]\\d{8}",[9,10],[["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["6[12][29]|(?:3[1-8]|4[136-8]|5[12457]|6[49])2|(?:56|65)[24]","6[12][29]|(?:35|4[1378]|5[12457]|6[49])2|(?:56|65)[24]|(?:3[1-46-8]|46)2[013-9]"],"0$1"],["(\\d{4})(\\d{5})","$1 $2",["3[1-8]|4(?:[1367]|[45][6-9]|8[4-6])|5(?:[1-5]|6[0135689]|7[4-6])|6(?:[12][3-7]|[459])","3[1-8]|4(?:[1367]|[45][6-9]|8[4-6])|5(?:[1-5]|6(?:[015689]|3[02389])|7[4-6])|6(?:[12][3-7]|[459])"],"0$1"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["[3-7]|89|9[1-9]"],"0$1"],["(\\d{3})(\\d{3})(\\d{3,4})","$1 $2 $3",["[89]"],"0$1"]],"0",0,0,0,0,0,[["(?:3[1-8]|4[13-8]|5[1-7]|6[12459])\\d{7}",[9]],["(?:39|50|6[36-8]|7[1-3]|9[1-9])\\d{7}",[9]],["800[1-8]\\d{5,6}"],["900[239]\\d{5,6}"],0,0,0,0,["89[1-579]\\d{6}",[9]]],"0~0"],"UG":["256","00[057]","800\\d{6}|(?:[29]0|[347]\\d)\\d{7}",[9],[["(\\d{4})(\\d{5})","$1 $2",["202","2024"],"0$1"],["(\\d{3})(\\d{6})","$1 $2",["[27-9]|4(?:6[45]|[7-9])"],"0$1"],["(\\d{2})(\\d{7})","$1 $2",["[34]"],"0$1"]],"0",0,0,0,0,0,[["20(?:(?:240|30[67])\\d|6(?:00[0-2]|30[0-4]))\\d{3}|(?:20(?:[017]\\d|2[5-9]|32|5[0-4]|6[15-9])|[34]\\d{3})\\d{5}"],["726[01]\\d{5}|7(?:[01578]\\d|20|36|[46][0-4]|9[89])\\d{6}"],["800[1-3]\\d{5}"],["90[1-3]\\d{6}"]]],"US":["1","011","[2-9]\\d{9}|3\\d{6}",[10],[["(\\d{3})(\\d{4})","$1-$2",["310"],0,1],["(\\d{3})(\\d{3})(\\d{4})","($1) $2-$3",["[2-9]"],0,1,"$1-$2-$3"]],"1",0,0,0,0,0,[["(?:4722(?:0[0-35]|27)|505(?:[2-57-9]\\d\\d|6(?:[0-35-9]\\d|4[46])))\\d{4}|(?:2(?:0[1-35-9]|1[02-9]|2[03-589]|3[149]|4[08]|5[1-46]|6[0279]|7[0269]|8[13])|3(?:0[1-57-9]|1[02-9]|2[01356]|3[0-24679]|4[167]|5[0-2]|6[014]|8[056])|4(?:0[124-9]|1[02-579]|2[3-5]|3[0245]|4[023578]|58|6[349]|7[0589]|8[04])|5(?:0[1-47-9]|1[0235-8]|20|3[0149]|4[01]|5[179]|6[1-47]|7[0-5]|8[0256])|6(?:0[1-35-9]|1[024-9]|2[03689]|[34][016]|5[01679]|6[0-279]|78|8[0-29])|7(?:0[1-46-8]|1[2-9]|2[04-7]|3[1247]|4[037]|5[47]|6[02359]|7[0-59]|8[156])|8(?:0[1-68]|1[02-8]|2[068]|3[0-2589]|4[03578]|5[046-9]|6[02-5]|7[028])|9(?:0[1346-9]|1[02-9]|2[0589]|3[0146-8]|4[01357-9]|5[12469]|7[0-389]|8[04-69]))[2-9]\\d{6}"],[""],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"UY":["598","0(?:0|1[3-9]\\d)","(?:0004|4)\\d{9}|[1249]\\d{7}|(?:[49]\\d|80)\\d{5}",[7,8,10,13],[["(\\d{3})(\\d{4})","$1 $2",["405|8|90"],"0$1"],["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["9"],"0$1"],["(\\d{4})(\\d{4})","$1 $2",["[124]"]],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["4"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3 $4",["0"]]],"0",0,0,0,0,0,[["(?:1(?:770|987)|(?:2\\d|4[2-7])\\d\\d)\\d{4}",[8]],["9[1-9]\\d{6}",[8]],["(?:(?:0004|4)\\d{5}|80[05])\\d{4}|405\\d{4}",[7,10,13]],["90[0-8]\\d{4}",[7]]],"00"," int. "],"UZ":["998","810","(?:33|[5-79]\\d|88)\\d{7}",[9],[["(\\d{2})(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[35-9]"],"8 $1"]],"8",0,0,0,0,0,[["(?:55\\d\\d|6(?:1(?:22|3[124]|4[1-4]|5[1-3578]|64)|2(?:22|3[0-57-9]|41)|5(?:22|3[3-7]|5[024-8])|6\\d\\d|7(?:[23]\\d|7[69])|9(?:22|4[1-8]|6[135]))|7(?:0(?:5[4-9]|6[0146]|7[124-6]|9[135-8])|(?:1[12]|8\\d)\\d|2(?:22|3[13-57-9]|4[1-3579]|5[14])|3(?:2\\d|3[1578]|4[1-35-7]|5[1-57]|61)|4(?:2\\d|3[1-579]|7[1-79])|5(?:22|5[1-9]|6[1457])|6(?:22|3[12457]|4[13-8])|9(?:22|5[1-9])))\\d{5}"],["(?:(?:33|50|88|9[0-57-9])\\d{3}|6(?:1(?:2(?:2[01]|98)|35[0-4]|50\\d|61[23]|7(?:[01][017]|4\\d|55|9[5-9]))|2(?:(?:11|7\\d)\\d|2(?:[12]1|9[01379])|5(?:[126]\\d|3[0-4]))|5(?:19[01]|2(?:27|9[26])|(?:30|59|7\\d)\\d)|6(?:2(?:1[5-9]|2[0367]|38|41|52|60)|(?:3[79]|9[0-3])\\d|4(?:56|83)|7(?:[07]\\d|1[017]|3[07]|4[047]|5[057]|67|8[0178]|9[79]))|7(?:2(?:24|3[237]|4[5-9]|7[15-8])|5(?:7[12]|8[0589])|7(?:0\\d|[39][07])|9(?:0\\d|7[079]))|9(?:2(?:1[1267]|3[01]|5\\d|7[0-4])|(?:5[67]|7\\d)\\d|6(?:2[0-26]|8\\d)))|7(?:[07]\\d{3}|1(?:13[01]|6(?:0[47]|1[67]|66)|71[3-69]|98\\d)|2(?:2(?:2[79]|95)|3(?:2[5-9]|6[0-6])|57\\d|7(?:0\\d|1[17]|2[27]|3[37]|44|5[057]|66|88))|3(?:2(?:1[0-6]|21|3[469]|7[159])|(?:33|9[4-6])\\d|5(?:0[0-4]|5[579]|9\\d)|7(?:[0-3579]\\d|4[0467]|6[67]|8[078]))|4(?:2(?:29|5[0257]|6[0-7]|7[1-57])|5(?:1[0-4]|8\\d|9[5-9])|7(?:0\\d|1[024589]|2[0-27]|3[0137]|[46][07]|5[01]|7[5-9]|9[079])|9(?:7[015-9]|[89]\\d))|5(?:112|2(?:0\\d|2[29]|[49]4)|3[1568]\\d|52[6-9]|7(?:0[01578]|1[017]|[23]7|4[047]|[5-7]\\d|8[78]|9[079]))|6(?:2(?:2[1245]|4[2-4])|39\\d|41[179]|5(?:[349]\\d|5[0-2])|7(?:0[017]|[13]\\d|22|44|55|67|88))|9(?:22[128]|3(?:2[0-4]|7\\d)|57[02569]|7(?:2[05-9]|3[37]|4\\d|60|7[2579]|87|9[07]))))\\d{4}"]],"8~10"],"VA":["39","00","0\\d{5,10}|3[0-8]\\d{7,10}|55\\d{8}|8\\d{5}(?:\\d{2,4})?|(?:1\\d|39)\\d{7,8}",[6,7,8,9,10,11],0,0,0,0,0,0,"06698",[["06698\\d{1,6}"],["3[1-9]\\d{8}|3[2-9]\\d{7}",[9,10]],["80(?:0\\d{3}|3)\\d{3}",[6,9]],["(?:0878\\d{3}|89(?:2\\d|3[04]|4(?:[0-4]|[5-9]\\d\\d)|5[0-4]))\\d\\d|(?:1(?:44|6[346])|89(?:38|5[5-9]|9))\\d{6}",[6,8,9,10]],["1(?:78\\d|99)\\d{6}",[9,10]],0,0,0,["55\\d{8}",[10]],["84(?:[08]\\d{3}|[17])\\d{3}",[6,9]]]],"VC":["1","011","(?:[58]\\d\\d|784|900)\\d{7}",[10],0,"1",0,"([2-7]\\d{6})$|1","784$1",0,"784",[["784(?:266|3(?:6[6-9]|7\\d|8[0-6])|4(?:38|5[0-36-8]|8[0-8])|5(?:55|7[0-2]|93)|638|784)\\d{4}"],["784(?:4(?:3[0-5]|5[45]|89|9[0-8])|5(?:2[6-9]|3[0-4])|720)\\d{4}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"],0,0,0,["78451[0-2]\\d{4}"]]],"VE":["58","00","[68]00\\d{7}|(?:[24]\\d|[59]0)\\d{8}",[10],[["(\\d{3})(\\d{7})","$1-$2",["[24-689]"],"0$1"]],"0",0,0,0,0,0,[["(?:2(?:12|3[457-9]|[467]\\d|[58][1-9]|9[1-6])|[4-6]00)\\d{7}"],["4(?:1[24-8]|2[46])\\d{7}"],["800\\d{7}"],["90[01]\\d{7}"],0,0,["501\\d{7}"]]],"VG":["1","011","(?:284|[58]\\d\\d|900)\\d{7}",[10],0,"1",0,"([2-578]\\d{6})$|1","284$1",0,"284",[["284(?:229|4(?:22|9[45])|774|8(?:52|6[459]))\\d{4}"],["284(?:245|3(?:0[0-3]|4[0-7]|68|9[34])|4(?:4[0-6]|68|9[69])|5(?:4[0-7]|68|9[69]))\\d{4}"],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"VI":["1","011","[58]\\d{9}|(?:34|90)0\\d{7}",[10],0,"1",0,"([2-9]\\d{6})$|1","340$1",0,"340",[["340(?:2(?:0[0-368]|2[06-8]|4[49]|77)|3(?:32|44)|4(?:2[23]|44|7[34]|89)|5(?:1[34]|55)|6(?:2[56]|4[23]|77|9[023])|7(?:1[2-57-9]|2[57]|7\\d)|884|998)\\d{4}"],[""],["8(?:00|33|44|55|66|77|88)[2-9]\\d{6}"],["900[2-9]\\d{6}"],["52(?:3(?:[2-46-9][02-9]\\d|5(?:[02-46-9]\\d|5[0-46-9]))|4(?:[2-478][02-9]\\d|5(?:[034]\\d|2[024-9]|5[0-46-9])|6(?:0[1-9]|[2-9]\\d)|9(?:[05-9]\\d|2[0-5]|49)))\\d{4}|52[34][2-9]1[02-9]\\d{4}|5(?:00|2[125-9]|33|44|66|77|88)[2-9]\\d{6}"]]],"VN":["84","00","[12]\\d{9}|[135-9]\\d{8}|[16]\\d{7}|[16-8]\\d{6}",[7,8,9,10],[["(\\d{2})(\\d{5})","$1 $2",["80"],"0$1",1],["(\\d{4})(\\d{4,6})","$1 $2",["1"],0,1],["(\\d{2})(\\d{3})(\\d{2})(\\d{2})","$1 $2 $3 $4",["[69]"],"0$1",1],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[3578]"],"0$1",1],["(\\d{2})(\\d{4})(\\d{4})","$1 $2 $3",["2[48]"],"0$1",1],["(\\d{3})(\\d{4})(\\d{3})","$1 $2 $3",["2"],"0$1",1]],"0",0,0,0,0,0,[["2(?:0[3-9]|1[0-689]|2[0-25-9]|[38][2-9]|4[2-8]|5[124-9]|6[0-39]|7[0-7]|9[0-4679])\\d{7}",[10]],["(?:5(?:2[238]|59)|89[6-9]|99[013-9])\\d{6}|(?:3\\d|5[689]|7[06-9]|8[1-8]|9[0-8])\\d{7}",[9]],["1800\\d{4,6}|12(?:0[13]|28)\\d{4}",[8,9,10]],["1900\\d{4,6}",[8,9,10]],0,0,["(?:[17]99|80\\d)\\d{4}|69\\d{5,6}",[7,8]],0,["672\\d{6}",[9]]]],"VU":["678","00","[57-9]\\d{6}|(?:[238]\\d|48)\\d{3}",[5,7],[["(\\d{3})(\\d{4})","$1 $2",["[57-9]"]]],0,0,0,0,0,0,[["(?:38[0-8]|48[4-9])\\d\\d|(?:2[02-9]|3[4-7]|88)\\d{3}",[5]],["(?:[58]\\d|7[013-7])\\d{5}",[7]],["81[18]\\d\\d",[5]],0,0,0,["(?:3[03]|900\\d)\\d{3}"],0,["9(?:0[1-9]|1[01])\\d{4}",[7]]]],"WF":["681","00","(?:40|72)\\d{4}|8\\d{5}(?:\\d{3})?",[6,9],[["(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3",["[478]"]],["(\\d{3})(\\d{2})(\\d{2})(\\d{2})","$1 $2 $3 $4",["8"]]],0,0,0,0,0,0,[["72\\d{4}",[6]],["(?:72|8[23])\\d{4}",[6]],["80[0-5]\\d{6}",[9]]]],"WS":["685","0","(?:[2-6]|8\\d{5})\\d{4}|[78]\\d{6}|[68]\\d{5}",[5,6,7,10],[["(\\d{5})","$1",["[2-5]|6[1-9]"]],["(\\d{3})(\\d{3,7})","$1 $2",["[68]"]],["(\\d{2})(\\d{5})","$1 $2",["7"]]],0,0,0,0,0,0,[["6[1-9]\\d{3}|(?:[2-5]|60)\\d{4}",[5,6]],["(?:7[1-35-7]|8(?:[3-7]|9\\d{3}))\\d{5}",[7,10]],["800\\d{3}",[6]]]],"XK":["383","00","[23]\\d{7,8}|(?:4\\d\\d|[89]00)\\d{5}",[8,9],[["(\\d{3})(\\d{5})","$1 $2",["[89]"],"0$1"],["(\\d{2})(\\d{3})(\\d{3})","$1 $2 $3",["[2-4]"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[23]"],"0$1"]],"0",0,0,0,0,0,[["(?:2[89]|39)0\\d{6}|[23][89]\\d{6}"],["4[3-9]\\d{6}",[8]],["800\\d{5}",[8]],["900\\d{5}",[8]]]],"YE":["967","00","(?:1|7\\d)\\d{7}|[1-7]\\d{6}",[7,8,9],[["(\\d)(\\d{3})(\\d{3,4})","$1 $2 $3",["[1-6]|7(?:[24-6]|8[0-7])"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["7"],"0$1"]],"0",0,0,0,0,0,[["78[0-7]\\d{4}|17\\d{6}|(?:[12][2-68]|3[2358]|4[2-58]|5[2-6]|6[3-58]|7[24-6])\\d{5}",[7,8]],["7[01378]\\d{7}",[9]]]],"YT":["262","00","(?:(?:(?:26|63)9|80\\d)\\d\\d|93980)\\d{4}",[9],0,"0",0,0,0,0,"269|63|9398",[["269(?:0[0-467]|5[0-3]|6\\d|[78]0)\\d{4}"],["(?:639(?:0[0-79]|1[019]|[267]\\d|3[09]|40|5[05-9]|9[04-79])|93980)\\d{4}"],["80\\d{7}"]]],"ZA":["27","00","[1-79]\\d{8}|8\\d{4,9}",[5,6,7,8,9,10],[["(\\d{2})(\\d{3,4})","$1 $2",["8[1-4]"],"0$1"],["(\\d{2})(\\d{3})(\\d{2,3})","$1 $2 $3",["8[1-4]"],"0$1"],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["860"],"0$1"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["[1-9]"],"0$1"],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["8"],"0$1"]],"0",0,0,0,0,0,[["(?:2(?:0330|4302)|52087)0\\d{3}|(?:1[0-8]|2[1-378]|3[1-69]|4\\d|5[1346-8])\\d{7}",[9]],["(?:1(?:3492[0-25]|4495[0235]|549(?:20|5[01]))|4[34]492[01])\\d{3}|8[1-4]\\d{3,7}|(?:2[27]|47|54)4950\\d{3}|(?:1(?:049[2-4]|9[12]\\d\\d)|(?:6\\d|7[0-46-9])\\d{3}|8(?:5\\d{3}|7(?:08[67]|158|28[5-9]|310)))\\d{4}|(?:1[6-8]|28|3[2-69]|4[025689]|5[36-8])4920\\d{3}|(?:12|[2-5]1)492\\d{4}",[5,6,7,8,9]],["80\\d{7}",[9]],["(?:86[2-9]|9[0-2]\\d)\\d{6}",[9]],0,0,["861\\d{6,7}",[9,10]],0,["87(?:08[0-589]|15[0-79]|28[0-4]|31[1-9])\\d{4}|87(?:[02][0-79]|1[0-46-9]|3[02-9]|[4-9]\\d)\\d{5}",[9]],["860\\d{6}",[9]]]],"ZM":["260","00","800\\d{6}|(?:21|63|[79]\\d)\\d{7}",[9],[["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[28]"],"0$1"],["(\\d{2})(\\d{7})","$1 $2",["[79]"],"0$1"]],"0",0,0,0,0,0,[["21[1-8]\\d{6}"],["(?:7[5-79]|9[5-8])\\d{7}"],["800\\d{6}"],0,0,0,0,0,["63\\d{7}"]]],"ZW":["263","00","2(?:[0-57-9]\\d{6,8}|6[0-24-9]\\d{6,7})|[38]\\d{9}|[35-8]\\d{8}|[3-6]\\d{7}|[1-689]\\d{6}|[1-3569]\\d{5}|[1356]\\d{4}",[5,6,7,8,9,10],[["(\\d{3})(\\d{3,5})","$1 $2",["2(?:0[45]|2[278]|[49]8)|3(?:[09]8|17)|6(?:[29]8|37|75)|[23][78]|(?:33|5[15]|6[68])[78]"],"0$1"],["(\\d)(\\d{3})(\\d{2,4})","$1 $2 $3",["[49]"],"0$1"],["(\\d{3})(\\d{4})","$1 $2",["80"],"0$1"],["(\\d{2})(\\d{7})","$1 $2",["24|8[13-59]|(?:2[05-79]|39|5[45]|6[15-8])2","2(?:02[014]|4|[56]20|[79]2)|392|5(?:42|525)|6(?:[16-8]21|52[013])|8[13-59]"],"(0$1)"],["(\\d{2})(\\d{3})(\\d{4})","$1 $2 $3",["7"],"0$1"],["(\\d{3})(\\d{3})(\\d{3,4})","$1 $2 $3",["2(?:1[39]|2[0157]|[378]|[56][14])|3(?:12|29)","2(?:1[39]|2[0157]|[378]|[56][14])|3(?:123|29)"],"0$1"],["(\\d{4})(\\d{6})","$1 $2",["8"],"0$1"],["(\\d{2})(\\d{3,5})","$1 $2",["1|2(?:0[0-36-9]|12|29|[56])|3(?:1[0-689]|[24-6])|5(?:[0236-9]|1[2-4])|6(?:[013-59]|7[0-46-9])|(?:33|55|6[68])[0-69]|(?:29|3[09]|62)[0-79]"],"0$1"],["(\\d{2})(\\d{3})(\\d{3,4})","$1 $2 $3",["29[013-9]|39|54"],"0$1"],["(\\d{4})(\\d{3,5})","$1 $2",["(?:25|54)8","258|5483"],"0$1"]],"0",0,0,0,0,0,[["(?:1(?:(?:3\\d|9)\\d|[4-8])|2(?:(?:(?:0(?:2[014]|5)|(?:2[0157]|31|84|9)\\d\\d|[56](?:[14]\\d\\d|20)|7(?:[089]|2[03]|[35]\\d\\d))\\d|4(?:2\\d\\d|8))\\d|1(?:2|[39]\\d{4}))|3(?:(?:123|(?:29\\d|92)\\d)\\d\\d|7(?:[19]|[56]\\d))|5(?:0|1[2-478]|26|[37]2|4(?:2\\d{3}|83)|5(?:25\\d\\d|[78])|[689]\\d)|6(?:(?:[16-8]21|28|52[013])\\d\\d|[39])|8(?:[1349]28|523)\\d\\d)\\d{3}|(?:4\\d\\d|9[2-9])\\d{4,5}|(?:(?:2(?:(?:(?:0|8[146])\\d|7[1-7])\\d|2(?:[278]\\d|92)|58(?:2\\d|3))|3(?:[26]|9\\d{3})|5(?:4\\d|5)\\d\\d)\\d|6(?:(?:(?:[0-246]|[78]\\d)\\d|37)\\d|5[2-8]))\\d\\d|(?:2(?:[569]\\d|8[2-57-9])|3(?:[013-59]\\d|8[37])|6[89]8)\\d{3}"],["7(?:[178]\\d|3[1-9])\\d{6}",[9]],["80(?:[01]\\d|20|8[0-8])\\d{3}",[7]],0,0,0,0,0,["86(?:1[12]|22|30|44|55|77|8[368])\\d{6}",[10]]]]},"nonGeographic":{"800":["800",0,"(?:00|[1-9]\\d)\\d{6}",[8],[["(\\d{4})(\\d{4})","$1 $2",["\\d"]]],0,0,0,0,0,0,[0,0,["(?:00|[1-9]\\d)\\d{6}"]]],"808":["808",0,"[1-9]\\d{7}",[8],[["(\\d{4})(\\d{4})","$1 $2",["[1-9]"]]],0,0,0,0,0,0,[0,0,0,0,0,0,0,0,0,["[1-9]\\d{7}"]]],"870":["870",0,"7\\d{11}|[35-7]\\d{8}",[9,12],[["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["[35-7]"]]],0,0,0,0,0,0,[0,["(?:[356]|774[45])\\d{8}|7[6-8]\\d{7}"]]],"878":["878",0,"10\\d{10}",[12],[["(\\d{2})(\\d{5})(\\d{5})","$1 $2 $3",["1"]]],0,0,0,0,0,0,[0,0,0,0,0,0,0,0,["10\\d{10}"]]],"881":["881",0,"[0-36-9]\\d{8}",[9],[["(\\d)(\\d{3})(\\d{5})","$1 $2 $3",["[0-36-9]"]]],0,0,0,0,0,0,[0,["[0-36-9]\\d{8}"]]],"882":["882",0,"[13]\\d{6}(?:\\d{2,5})?|[19]\\d{7}|(?:[25]\\d\\d|4)\\d{7}(?:\\d{2})?",[7,8,9,10,11,12],[["(\\d{2})(\\d{5})","$1 $2",["16|342"]],["(\\d{2})(\\d{6})","$1 $2",["49"]],["(\\d{2})(\\d{2})(\\d{4})","$1 $2 $3",["1[36]|9"]],["(\\d{2})(\\d{4})(\\d{3})","$1 $2 $3",["3[23]"]],["(\\d{2})(\\d{3,4})(\\d{4})","$1 $2 $3",["16"]],["(\\d{2})(\\d{4})(\\d{4})","$1 $2 $3",["10|23|3(?:[15]|4[57])|4|51"]],["(\\d{3})(\\d{4})(\\d{4})","$1 $2 $3",["34"]],["(\\d{2})(\\d{4,5})(\\d{5})","$1 $2 $3",["[1-35]"]]],0,0,0,0,0,0,[0,["342\\d{4}|(?:337|49)\\d{6}|(?:3(?:2|47|7\\d{3})|50\\d{3})\\d{7}",[7,8,9,10,12]],0,0,0,0,0,0,["1(?:3(?:0[0347]|[13][0139]|2[035]|4[013568]|6[0459]|7[06]|8[15-8]|9[0689])\\d{4}|6\\d{5,10})|(?:345\\d|9[89])\\d{6}|(?:10|2(?:3|85\\d)|3(?:[15]|[69]\\d\\d)|4[15-8]|51)\\d{8}"]]],"883":["883",0,"(?:[1-4]\\d|51)\\d{6,10}",[8,9,10,11,12],[["(\\d{3})(\\d{3})(\\d{2,8})","$1 $2 $3",["[14]|2[24-689]|3[02-689]|51[24-9]"]],["(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3",["510"]],["(\\d{3})(\\d{3})(\\d{4})","$1 $2 $3",["21"]],["(\\d{4})(\\d{4})(\\d{4})","$1 $2 $3",["51[13]"]],["(\\d{3})(\\d{3})(\\d{3})(\\d{3})","$1 $2 $3 $4",["[235]"]]],0,0,0,0,0,0,[0,0,0,0,0,0,0,0,["(?:2(?:00\\d\\d|10)|(?:370[1-9]|51\\d0)\\d)\\d{7}|51(?:00\\d{5}|[24-9]0\\d{4,7})|(?:1[013-79]|2[24-689]|3[02-689]|4[0-4])0\\d{5,9}"]]],"888":["888",0,"\\d{11}",[11],[["(\\d{3})(\\d{3})(\\d{5})","$1 $2 $3"]],0,0,0,0,0,0,[0,0,0,0,0,0,["\\d{11}"]]],"979":["979",0,"[1359]\\d{8}",[9],[["(\\d)(\\d{4})(\\d{4})","$1 $2 $3",["[1359]"]]],0,0,0,0,0,0,[0,0,0,["[1359]\\d{8}"]]]}}
\ No newline at end of file
diff --git a/parent_dir/node_modules/lodash.throttle/index.js b/parent_dir/node_modules/lodash.throttle/index.js
new file mode 100644
index 0000000..eb401f9
--- /dev/null
+++ b/parent_dir/node_modules/lodash.throttle/index.js
@@ -0,0 +1,439 @@
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as the `TypeError` message for "Functions" methods. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/** Used as references for various `Number` constants. */
+var NAN = 0 / 0;
+
+/** `Object#toString` result references. */
+var symbolTag = '[object Symbol]';
+
+/** Used to match leading and trailing whitespace. */
+var reTrim = /^\s+|\s+$/g;
+
+/** Used to detect bad signed hexadecimal string values. */
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+/** Used to detect binary string values. */
+var reIsBinary = /^0b[01]+$/i;
+
+/** Used to detect octal string values. */
+var reIsOctal = /^0o[0-7]+$/i;
+
+/** Built-in method references without a dependency on `root`. */
+var freeParseInt = parseInt;
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root = freeGlobal || freeSelf || Function('return this')();
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max,
+    nativeMin = Math.min;
+
+/**
+ * Gets the timestamp of the number of milliseconds that have elapsed since
+ * the Unix epoch (1 January 1970 00:00:00 UTC).
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Date
+ * @returns {number} Returns the timestamp.
+ * @example
+ *
+ * _.defer(function(stamp) {
+ *   console.log(_.now() - stamp);
+ * }, _.now());
+ * // => Logs the number of milliseconds it took for the deferred invocation.
+ */
+var now = function() {
+  return root.Date.now();
+};
+
+/**
+ * Creates a debounced function that delays invoking `func` until after `wait`
+ * milliseconds have elapsed since the last time the debounced function was
+ * invoked. The debounced function comes with a `cancel` method to cancel
+ * delayed `func` invocations and a `flush` method to immediately invoke them.
+ * Provide `options` to indicate whether `func` should be invoked on the
+ * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
+ * with the last arguments provided to the debounced function. Subsequent
+ * calls to the debounced function return the result of the last `func`
+ * invocation.
+ *
+ * **Note:** If `leading` and `trailing` options are `true`, `func` is
+ * invoked on the trailing edge of the timeout only if the debounced function
+ * is invoked more than once during the `wait` timeout.
+ *
+ * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+ * until to the next tick, similar to `setTimeout` with a timeout of `0`.
+ *
+ * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+ * for details over the differences between `_.debounce` and `_.throttle`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to debounce.
+ * @param {number} [wait=0] The number of milliseconds to delay.
+ * @param {Object} [options={}] The options object.
+ * @param {boolean} [options.leading=false]
+ *  Specify invoking on the leading edge of the timeout.
+ * @param {number} [options.maxWait]
+ *  The maximum time `func` is allowed to be delayed before it's invoked.
+ * @param {boolean} [options.trailing=true]
+ *  Specify invoking on the trailing edge of the timeout.
+ * @returns {Function} Returns the new debounced function.
+ * @example
+ *
+ * // Avoid costly calculations while the window size is in flux.
+ * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
+ *
+ * // Invoke `sendMail` when clicked, debouncing subsequent calls.
+ * jQuery(element).on('click', _.debounce(sendMail, 300, {
+ *   'leading': true,
+ *   'trailing': false
+ * }));
+ *
+ * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
+ * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
+ * var source = new EventSource('/stream');
+ * jQuery(source).on('message', debounced);
+ *
+ * // Cancel the trailing debounced invocation.
+ * jQuery(window).on('popstate', debounced.cancel);
+ */
+function debounce(func, wait, options) {
+  var lastArgs,
+      lastThis,
+      maxWait,
+      result,
+      timerId,
+      lastCallTime,
+      lastInvokeTime = 0,
+      leading = false,
+      maxing = false,
+      trailing = true;
+
+  if (typeof func != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  wait = toNumber(wait) || 0;
+  if (isObject(options)) {
+    leading = !!options.leading;
+    maxing = 'maxWait' in options;
+    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+    trailing = 'trailing' in options ? !!options.trailing : trailing;
+  }
+
+  function invokeFunc(time) {
+    var args = lastArgs,
+        thisArg = lastThis;
+
+    lastArgs = lastThis = undefined;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+
+  function leadingEdge(time) {
+    // Reset any `maxWait` timer.
+    lastInvokeTime = time;
+    // Start the timer for the trailing edge.
+    timerId = setTimeout(timerExpired, wait);
+    // Invoke the leading edge.
+    return leading ? invokeFunc(time) : result;
+  }
+
+  function remainingWait(time) {
+    var timeSinceLastCall = time - lastCallTime,
+        timeSinceLastInvoke = time - lastInvokeTime,
+        result = wait - timeSinceLastCall;
+
+    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
+  }
+
+  function shouldInvoke(time) {
+    var timeSinceLastCall = time - lastCallTime,
+        timeSinceLastInvoke = time - lastInvokeTime;
+
+    // Either this is the first call, activity has stopped and we're at the
+    // trailing edge, the system time has gone backwards and we're treating
+    // it as the trailing edge, or we've hit the `maxWait` limit.
+    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
+      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
+  }
+
+  function timerExpired() {
+    var time = now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    // Restart the timer.
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+
+  function trailingEdge(time) {
+    timerId = undefined;
+
+    // Only invoke if we have `lastArgs` which means `func` has been
+    // debounced at least once.
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = undefined;
+    return result;
+  }
+
+  function cancel() {
+    if (timerId !== undefined) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = undefined;
+  }
+
+  function flush() {
+    return timerId === undefined ? result : trailingEdge(now());
+  }
+
+  function debounced() {
+    var time = now(),
+        isInvoking = shouldInvoke(time);
+
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+
+    if (isInvoking) {
+      if (timerId === undefined) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        // Handle invocations in a tight loop.
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === undefined) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+
+/**
+ * Creates a throttled function that only invokes `func` at most once per
+ * every `wait` milliseconds. The throttled function comes with a `cancel`
+ * method to cancel delayed `func` invocations and a `flush` method to
+ * immediately invoke them. Provide `options` to indicate whether `func`
+ * should be invoked on the leading and/or trailing edge of the `wait`
+ * timeout. The `func` is invoked with the last arguments provided to the
+ * throttled function. Subsequent calls to the throttled function return the
+ * result of the last `func` invocation.
+ *
+ * **Note:** If `leading` and `trailing` options are `true`, `func` is
+ * invoked on the trailing edge of the timeout only if the throttled function
+ * is invoked more than once during the `wait` timeout.
+ *
+ * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+ * until to the next tick, similar to `setTimeout` with a timeout of `0`.
+ *
+ * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+ * for details over the differences between `_.throttle` and `_.debounce`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to throttle.
+ * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
+ * @param {Object} [options={}] The options object.
+ * @param {boolean} [options.leading=true]
+ *  Specify invoking on the leading edge of the timeout.
+ * @param {boolean} [options.trailing=true]
+ *  Specify invoking on the trailing edge of the timeout.
+ * @returns {Function} Returns the new throttled function.
+ * @example
+ *
+ * // Avoid excessively updating the position while scrolling.
+ * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
+ *
+ * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
+ * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
+ * jQuery(element).on('click', throttled);
+ *
+ * // Cancel the trailing throttled invocation.
+ * jQuery(window).on('popstate', throttled.cancel);
+ */
+function throttle(func, wait, options) {
+  var leading = true,
+      trailing = true;
+
+  if (typeof func != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  if (isObject(options)) {
+    leading = 'leading' in options ? !!options.leading : leading;
+    trailing = 'trailing' in options ? !!options.trailing : trailing;
+  }
+  return debounce(func, wait, {
+    'leading': leading,
+    'maxWait': wait,
+    'trailing': trailing
+  });
+}
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+  var type = typeof value;
+  return !!value && (type == 'object' || type == 'function');
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+  return !!value && typeof value == 'object';
+}
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+  return typeof value == 'symbol' ||
+    (isObjectLike(value) && objectToString.call(value) == symbolTag);
+}
+
+/**
+ * Converts `value` to a number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {number} Returns the number.
+ * @example
+ *
+ * _.toNumber(3.2);
+ * // => 3.2
+ *
+ * _.toNumber(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toNumber(Infinity);
+ * // => Infinity
+ *
+ * _.toNumber('3.2');
+ * // => 3.2
+ */
+function toNumber(value) {
+  if (typeof value == 'number') {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return NAN;
+  }
+  if (isObject(value)) {
+    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+    value = isObject(other) ? (other + '') : other;
+  }
+  if (typeof value != 'string') {
+    return value === 0 ? value : +value;
+  }
+  value = value.replace(reTrim, '');
+  var isBinary = reIsBinary.test(value);
+  return (isBinary || reIsOctal.test(value))
+    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+    : (reIsBadHex.test(value) ? NAN : +value);
+}
+
+module.exports = throttle;
diff --git a/parent_dir/node_modules/lodash/_DataView.js b/parent_dir/node_modules/lodash/_DataView.js
new file mode 100644
index 0000000..ac2d57c
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_DataView.js
@@ -0,0 +1,7 @@
+var getNative = require('./_getNative'),
+    root = require('./_root');
+
+/* Built-in method references that are verified to be native. */
+var DataView = getNative(root, 'DataView');
+
+module.exports = DataView;
diff --git a/parent_dir/node_modules/lodash/_Hash.js b/parent_dir/node_modules/lodash/_Hash.js
new file mode 100644
index 0000000..b504fe3
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_Hash.js
@@ -0,0 +1,32 @@
+var hashClear = require('./_hashClear'),
+    hashDelete = require('./_hashDelete'),
+    hashGet = require('./_hashGet'),
+    hashHas = require('./_hashHas'),
+    hashSet = require('./_hashSet');
+
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Hash(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `Hash`.
+Hash.prototype.clear = hashClear;
+Hash.prototype['delete'] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+
+module.exports = Hash;
diff --git a/parent_dir/node_modules/lodash/_ListCache.js b/parent_dir/node_modules/lodash/_ListCache.js
new file mode 100644
index 0000000..26895c3
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_ListCache.js
@@ -0,0 +1,32 @@
+var listCacheClear = require('./_listCacheClear'),
+    listCacheDelete = require('./_listCacheDelete'),
+    listCacheGet = require('./_listCacheGet'),
+    listCacheHas = require('./_listCacheHas'),
+    listCacheSet = require('./_listCacheSet');
+
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function ListCache(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `ListCache`.
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype['delete'] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+
+module.exports = ListCache;
diff --git a/parent_dir/node_modules/lodash/_Map.js b/parent_dir/node_modules/lodash/_Map.js
new file mode 100644
index 0000000..b73f29a
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_Map.js
@@ -0,0 +1,7 @@
+var getNative = require('./_getNative'),
+    root = require('./_root');
+
+/* Built-in method references that are verified to be native. */
+var Map = getNative(root, 'Map');
+
+module.exports = Map;
diff --git a/parent_dir/node_modules/lodash/_MapCache.js b/parent_dir/node_modules/lodash/_MapCache.js
new file mode 100644
index 0000000..4a4eea7
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_MapCache.js
@@ -0,0 +1,32 @@
+var mapCacheClear = require('./_mapCacheClear'),
+    mapCacheDelete = require('./_mapCacheDelete'),
+    mapCacheGet = require('./_mapCacheGet'),
+    mapCacheHas = require('./_mapCacheHas'),
+    mapCacheSet = require('./_mapCacheSet');
+
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function MapCache(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `MapCache`.
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype['delete'] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+
+module.exports = MapCache;
diff --git a/parent_dir/node_modules/lodash/_Promise.js b/parent_dir/node_modules/lodash/_Promise.js
new file mode 100644
index 0000000..247b9e1
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_Promise.js
@@ -0,0 +1,7 @@
+var getNative = require('./_getNative'),
+    root = require('./_root');
+
+/* Built-in method references that are verified to be native. */
+var Promise = getNative(root, 'Promise');
+
+module.exports = Promise;
diff --git a/parent_dir/node_modules/lodash/_Set.js b/parent_dir/node_modules/lodash/_Set.js
new file mode 100644
index 0000000..b3c8dcb
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_Set.js
@@ -0,0 +1,7 @@
+var getNative = require('./_getNative'),
+    root = require('./_root');
+
+/* Built-in method references that are verified to be native. */
+var Set = getNative(root, 'Set');
+
+module.exports = Set;
diff --git a/parent_dir/node_modules/lodash/_SetCache.js b/parent_dir/node_modules/lodash/_SetCache.js
new file mode 100644
index 0000000..6468b06
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_SetCache.js
@@ -0,0 +1,27 @@
+var MapCache = require('./_MapCache'),
+    setCacheAdd = require('./_setCacheAdd'),
+    setCacheHas = require('./_setCacheHas');
+
+/**
+ *
+ * Creates an array cache object to store unique values.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [values] The values to cache.
+ */
+function SetCache(values) {
+  var index = -1,
+      length = values == null ? 0 : values.length;
+
+  this.__data__ = new MapCache;
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+
+// Add methods to `SetCache`.
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+
+module.exports = SetCache;
diff --git a/parent_dir/node_modules/lodash/_Stack.js b/parent_dir/node_modules/lodash/_Stack.js
new file mode 100644
index 0000000..80b2cf1
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_Stack.js
@@ -0,0 +1,27 @@
+var ListCache = require('./_ListCache'),
+    stackClear = require('./_stackClear'),
+    stackDelete = require('./_stackDelete'),
+    stackGet = require('./_stackGet'),
+    stackHas = require('./_stackHas'),
+    stackSet = require('./_stackSet');
+
+/**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+
+// Add methods to `Stack`.
+Stack.prototype.clear = stackClear;
+Stack.prototype['delete'] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+
+module.exports = Stack;
diff --git a/parent_dir/node_modules/lodash/_Symbol.js b/parent_dir/node_modules/lodash/_Symbol.js
new file mode 100644
index 0000000..a013f7c
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_Symbol.js
@@ -0,0 +1,6 @@
+var root = require('./_root');
+
+/** Built-in value references. */
+var Symbol = root.Symbol;
+
+module.exports = Symbol;
diff --git a/parent_dir/node_modules/lodash/_Uint8Array.js b/parent_dir/node_modules/lodash/_Uint8Array.js
new file mode 100644
index 0000000..2fb30e1
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_Uint8Array.js
@@ -0,0 +1,6 @@
+var root = require('./_root');
+
+/** Built-in value references. */
+var Uint8Array = root.Uint8Array;
+
+module.exports = Uint8Array;
diff --git a/parent_dir/node_modules/lodash/_WeakMap.js b/parent_dir/node_modules/lodash/_WeakMap.js
new file mode 100644
index 0000000..567f86c
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_WeakMap.js
@@ -0,0 +1,7 @@
+var getNative = require('./_getNative'),
+    root = require('./_root');
+
+/* Built-in method references that are verified to be native. */
+var WeakMap = getNative(root, 'WeakMap');
+
+module.exports = WeakMap;
diff --git a/parent_dir/node_modules/lodash/_apply.js b/parent_dir/node_modules/lodash/_apply.js
new file mode 100644
index 0000000..36436dd
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_apply.js
@@ -0,0 +1,21 @@
+/**
+ * A faster alternative to `Function#apply`, this function invokes `func`
+ * with the `this` binding of `thisArg` and the arguments of `args`.
+ *
+ * @private
+ * @param {Function} func The function to invoke.
+ * @param {*} thisArg The `this` binding of `func`.
+ * @param {Array} args The arguments to invoke `func` with.
+ * @returns {*} Returns the result of `func`.
+ */
+function apply(func, thisArg, args) {
+  switch (args.length) {
+    case 0: return func.call(thisArg);
+    case 1: return func.call(thisArg, args[0]);
+    case 2: return func.call(thisArg, args[0], args[1]);
+    case 3: return func.call(thisArg, args[0], args[1], args[2]);
+  }
+  return func.apply(thisArg, args);
+}
+
+module.exports = apply;
diff --git a/parent_dir/node_modules/lodash/_arrayAggregator.js b/parent_dir/node_modules/lodash/_arrayAggregator.js
new file mode 100644
index 0000000..d96c3ca
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_arrayAggregator.js
@@ -0,0 +1,22 @@
+/**
+ * A specialized version of `baseAggregator` for arrays.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} setter The function to set `accumulator` values.
+ * @param {Function} iteratee The iteratee to transform keys.
+ * @param {Object} accumulator The initial aggregated object.
+ * @returns {Function} Returns `accumulator`.
+ */
+function arrayAggregator(array, setter, iteratee, accumulator) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    var value = array[index];
+    setter(accumulator, value, iteratee(value), array);
+  }
+  return accumulator;
+}
+
+module.exports = arrayAggregator;
diff --git a/parent_dir/node_modules/lodash/_arrayEach.js b/parent_dir/node_modules/lodash/_arrayEach.js
new file mode 100644
index 0000000..2c5f579
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_arrayEach.js
@@ -0,0 +1,22 @@
+/**
+ * A specialized version of `_.forEach` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns `array`.
+ */
+function arrayEach(array, iteratee) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (iteratee(array[index], index, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+
+module.exports = arrayEach;
diff --git a/parent_dir/node_modules/lodash/_arrayFilter.js b/parent_dir/node_modules/lodash/_arrayFilter.js
new file mode 100644
index 0000000..75ea254
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_arrayFilter.js
@@ -0,0 +1,25 @@
+/**
+ * A specialized version of `_.filter` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ */
+function arrayFilter(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length,
+      resIndex = 0,
+      result = [];
+
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+
+module.exports = arrayFilter;
diff --git a/parent_dir/node_modules/lodash/_arrayLikeKeys.js b/parent_dir/node_modules/lodash/_arrayLikeKeys.js
new file mode 100644
index 0000000..b2ec9ce
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_arrayLikeKeys.js
@@ -0,0 +1,49 @@
+var baseTimes = require('./_baseTimes'),
+    isArguments = require('./isArguments'),
+    isArray = require('./isArray'),
+    isBuffer = require('./isBuffer'),
+    isIndex = require('./_isIndex'),
+    isTypedArray = require('./isTypedArray');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray(value),
+      isArg = !isArr && isArguments(value),
+      isBuff = !isArr && !isArg && isBuffer(value),
+      isType = !isArr && !isArg && !isBuff && isTypedArray(value),
+      skipIndexes = isArr || isArg || isBuff || isType,
+      result = skipIndexes ? baseTimes(value.length, String) : [],
+      length = result.length;
+
+  for (var key in value) {
+    if ((inherited || hasOwnProperty.call(value, key)) &&
+        !(skipIndexes && (
+           // Safari 9 has enumerable `arguments.length` in strict mode.
+           key == 'length' ||
+           // Node.js 0.10 has enumerable non-index properties on buffers.
+           (isBuff && (key == 'offset' || key == 'parent')) ||
+           // PhantomJS 2 has enumerable non-index properties on typed arrays.
+           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
+           // Skip index properties.
+           isIndex(key, length)
+        ))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+module.exports = arrayLikeKeys;
diff --git a/parent_dir/node_modules/lodash/_arrayMap.js b/parent_dir/node_modules/lodash/_arrayMap.js
new file mode 100644
index 0000000..22b2246
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_arrayMap.js
@@ -0,0 +1,21 @@
+/**
+ * A specialized version of `_.map` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function arrayMap(array, iteratee) {
+  var index = -1,
+      length = array == null ? 0 : array.length,
+      result = Array(length);
+
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+
+module.exports = arrayMap;
diff --git a/parent_dir/node_modules/lodash/_arrayPush.js b/parent_dir/node_modules/lodash/_arrayPush.js
new file mode 100644
index 0000000..7d742b3
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_arrayPush.js
@@ -0,0 +1,20 @@
+/**
+ * Appends the elements of `values` to `array`.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to append.
+ * @returns {Array} Returns `array`.
+ */
+function arrayPush(array, values) {
+  var index = -1,
+      length = values.length,
+      offset = array.length;
+
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+
+module.exports = arrayPush;
diff --git a/parent_dir/node_modules/lodash/_arraySome.js b/parent_dir/node_modules/lodash/_arraySome.js
new file mode 100644
index 0000000..6fd02fd
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_arraySome.js
@@ -0,0 +1,23 @@
+/**
+ * A specialized version of `_.some` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ *  else `false`.
+ */
+function arraySome(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+module.exports = arraySome;
diff --git a/parent_dir/node_modules/lodash/_assignMergeValue.js b/parent_dir/node_modules/lodash/_assignMergeValue.js
new file mode 100644
index 0000000..cb1185e
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_assignMergeValue.js
@@ -0,0 +1,20 @@
+var baseAssignValue = require('./_baseAssignValue'),
+    eq = require('./eq');
+
+/**
+ * This function is like `assignValue` except that it doesn't assign
+ * `undefined` values.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function assignMergeValue(object, key, value) {
+  if ((value !== undefined && !eq(object[key], value)) ||
+      (value === undefined && !(key in object))) {
+    baseAssignValue(object, key, value);
+  }
+}
+
+module.exports = assignMergeValue;
diff --git a/parent_dir/node_modules/lodash/_assignValue.js b/parent_dir/node_modules/lodash/_assignValue.js
new file mode 100644
index 0000000..4083957
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_assignValue.js
@@ -0,0 +1,28 @@
+var baseAssignValue = require('./_baseAssignValue'),
+    eq = require('./eq');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Assigns `value` to `key` of `object` if the existing value is not equivalent
+ * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function assignValue(object, key, value) {
+  var objValue = object[key];
+  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
+      (value === undefined && !(key in object))) {
+    baseAssignValue(object, key, value);
+  }
+}
+
+module.exports = assignValue;
diff --git a/parent_dir/node_modules/lodash/_assocIndexOf.js b/parent_dir/node_modules/lodash/_assocIndexOf.js
new file mode 100644
index 0000000..5b77a2b
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_assocIndexOf.js
@@ -0,0 +1,21 @@
+var eq = require('./eq');
+
+/**
+ * Gets the index at which the `key` is found in `array` of key-value pairs.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} key The key to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+
+module.exports = assocIndexOf;
diff --git a/parent_dir/node_modules/lodash/_baseAggregator.js b/parent_dir/node_modules/lodash/_baseAggregator.js
new file mode 100644
index 0000000..4bc9e91
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseAggregator.js
@@ -0,0 +1,21 @@
+var baseEach = require('./_baseEach');
+
+/**
+ * Aggregates elements of `collection` on `accumulator` with keys transformed
+ * by `iteratee` and values set by `setter`.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} setter The function to set `accumulator` values.
+ * @param {Function} iteratee The iteratee to transform keys.
+ * @param {Object} accumulator The initial aggregated object.
+ * @returns {Function} Returns `accumulator`.
+ */
+function baseAggregator(collection, setter, iteratee, accumulator) {
+  baseEach(collection, function(value, key, collection) {
+    setter(accumulator, value, iteratee(value), collection);
+  });
+  return accumulator;
+}
+
+module.exports = baseAggregator;
diff --git a/parent_dir/node_modules/lodash/_baseAssign.js b/parent_dir/node_modules/lodash/_baseAssign.js
new file mode 100644
index 0000000..e5c4a1a
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseAssign.js
@@ -0,0 +1,17 @@
+var copyObject = require('./_copyObject'),
+    keys = require('./keys');
+
+/**
+ * The base implementation of `_.assign` without support for multiple sources
+ * or `customizer` functions.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @returns {Object} Returns `object`.
+ */
+function baseAssign(object, source) {
+  return object && copyObject(source, keys(source), object);
+}
+
+module.exports = baseAssign;
diff --git a/parent_dir/node_modules/lodash/_baseAssignIn.js b/parent_dir/node_modules/lodash/_baseAssignIn.js
new file mode 100644
index 0000000..6624f90
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseAssignIn.js
@@ -0,0 +1,17 @@
+var copyObject = require('./_copyObject'),
+    keysIn = require('./keysIn');
+
+/**
+ * The base implementation of `_.assignIn` without support for multiple sources
+ * or `customizer` functions.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @returns {Object} Returns `object`.
+ */
+function baseAssignIn(object, source) {
+  return object && copyObject(source, keysIn(source), object);
+}
+
+module.exports = baseAssignIn;
diff --git a/parent_dir/node_modules/lodash/_baseAssignValue.js b/parent_dir/node_modules/lodash/_baseAssignValue.js
new file mode 100644
index 0000000..d6f66ef
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseAssignValue.js
@@ -0,0 +1,25 @@
+var defineProperty = require('./_defineProperty');
+
+/**
+ * The base implementation of `assignValue` and `assignMergeValue` without
+ * value checks.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function baseAssignValue(object, key, value) {
+  if (key == '__proto__' && defineProperty) {
+    defineProperty(object, key, {
+      'configurable': true,
+      'enumerable': true,
+      'value': value,
+      'writable': true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+
+module.exports = baseAssignValue;
diff --git a/parent_dir/node_modules/lodash/_baseClone.js b/parent_dir/node_modules/lodash/_baseClone.js
new file mode 100644
index 0000000..69f8705
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseClone.js
@@ -0,0 +1,166 @@
+var Stack = require('./_Stack'),
+    arrayEach = require('./_arrayEach'),
+    assignValue = require('./_assignValue'),
+    baseAssign = require('./_baseAssign'),
+    baseAssignIn = require('./_baseAssignIn'),
+    cloneBuffer = require('./_cloneBuffer'),
+    copyArray = require('./_copyArray'),
+    copySymbols = require('./_copySymbols'),
+    copySymbolsIn = require('./_copySymbolsIn'),
+    getAllKeys = require('./_getAllKeys'),
+    getAllKeysIn = require('./_getAllKeysIn'),
+    getTag = require('./_getTag'),
+    initCloneArray = require('./_initCloneArray'),
+    initCloneByTag = require('./_initCloneByTag'),
+    initCloneObject = require('./_initCloneObject'),
+    isArray = require('./isArray'),
+    isBuffer = require('./isBuffer'),
+    isMap = require('./isMap'),
+    isObject = require('./isObject'),
+    isSet = require('./isSet'),
+    keys = require('./keys'),
+    keysIn = require('./keysIn');
+
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1,
+    CLONE_FLAT_FLAG = 2,
+    CLONE_SYMBOLS_FLAG = 4;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    funcTag = '[object Function]',
+    genTag = '[object GeneratorFunction]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    objectTag = '[object Object]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    symbolTag = '[object Symbol]',
+    weakMapTag = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[object DataView]',
+    float32Tag = '[object Float32Array]',
+    float64Tag = '[object Float64Array]',
+    int8Tag = '[object Int8Array]',
+    int16Tag = '[object Int16Array]',
+    int32Tag = '[object Int32Array]',
+    uint8Tag = '[object Uint8Array]',
+    uint8ClampedTag = '[object Uint8ClampedArray]',
+    uint16Tag = '[object Uint16Array]',
+    uint32Tag = '[object Uint32Array]';
+
+/** Used to identify `toStringTag` values supported by `_.clone`. */
+var cloneableTags = {};
+cloneableTags[argsTag] = cloneableTags[arrayTag] =
+cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
+cloneableTags[boolTag] = cloneableTags[dateTag] =
+cloneableTags[float32Tag] = cloneableTags[float64Tag] =
+cloneableTags[int8Tag] = cloneableTags[int16Tag] =
+cloneableTags[int32Tag] = cloneableTags[mapTag] =
+cloneableTags[numberTag] = cloneableTags[objectTag] =
+cloneableTags[regexpTag] = cloneableTags[setTag] =
+cloneableTags[stringTag] = cloneableTags[symbolTag] =
+cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
+cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+cloneableTags[errorTag] = cloneableTags[funcTag] =
+cloneableTags[weakMapTag] = false;
+
+/**
+ * The base implementation of `_.clone` and `_.cloneDeep` which tracks
+ * traversed objects.
+ *
+ * @private
+ * @param {*} value The value to clone.
+ * @param {boolean} bitmask The bitmask flags.
+ *  1 - Deep clone
+ *  2 - Flatten inherited properties
+ *  4 - Clone symbols
+ * @param {Function} [customizer] The function to customize cloning.
+ * @param {string} [key] The key of `value`.
+ * @param {Object} [object] The parent object of `value`.
+ * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
+ * @returns {*} Returns the cloned value.
+ */
+function baseClone(value, bitmask, customizer, key, object, stack) {
+  var result,
+      isDeep = bitmask & CLONE_DEEP_FLAG,
+      isFlat = bitmask & CLONE_FLAT_FLAG,
+      isFull = bitmask & CLONE_SYMBOLS_FLAG;
+
+  if (customizer) {
+    result = object ? customizer(value, key, object, stack) : customizer(value);
+  }
+  if (result !== undefined) {
+    return result;
+  }
+  if (!isObject(value)) {
+    return value;
+  }
+  var isArr = isArray(value);
+  if (isArr) {
+    result = initCloneArray(value);
+    if (!isDeep) {
+      return copyArray(value, result);
+    }
+  } else {
+    var tag = getTag(value),
+        isFunc = tag == funcTag || tag == genTag;
+
+    if (isBuffer(value)) {
+      return cloneBuffer(value, isDeep);
+    }
+    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
+      result = (isFlat || isFunc) ? {} : initCloneObject(value);
+      if (!isDeep) {
+        return isFlat
+          ? copySymbolsIn(value, baseAssignIn(result, value))
+          : copySymbols(value, baseAssign(result, value));
+      }
+    } else {
+      if (!cloneableTags[tag]) {
+        return object ? value : {};
+      }
+      result = initCloneByTag(value, tag, isDeep);
+    }
+  }
+  // Check for circular references and return its corresponding clone.
+  stack || (stack = new Stack);
+  var stacked = stack.get(value);
+  if (stacked) {
+    return stacked;
+  }
+  stack.set(value, result);
+
+  if (isSet(value)) {
+    value.forEach(function(subValue) {
+      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+    });
+  } else if (isMap(value)) {
+    value.forEach(function(subValue, key) {
+      result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
+    });
+  }
+
+  var keysFunc = isFull
+    ? (isFlat ? getAllKeysIn : getAllKeys)
+    : (isFlat ? keysIn : keys);
+
+  var props = isArr ? undefined : keysFunc(value);
+  arrayEach(props || value, function(subValue, key) {
+    if (props) {
+      key = subValue;
+      subValue = value[key];
+    }
+    // Recursively populate clone (susceptible to call stack limits).
+    assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
+  });
+  return result;
+}
+
+module.exports = baseClone;
diff --git a/parent_dir/node_modules/lodash/_baseCreate.js b/parent_dir/node_modules/lodash/_baseCreate.js
new file mode 100644
index 0000000..ffa6a52
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseCreate.js
@@ -0,0 +1,30 @@
+var isObject = require('./isObject');
+
+/** Built-in value references. */
+var objectCreate = Object.create;
+
+/**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} proto The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+var baseCreate = (function() {
+  function object() {}
+  return function(proto) {
+    if (!isObject(proto)) {
+      return {};
+    }
+    if (objectCreate) {
+      return objectCreate(proto);
+    }
+    object.prototype = proto;
+    var result = new object;
+    object.prototype = undefined;
+    return result;
+  };
+}());
+
+module.exports = baseCreate;
diff --git a/parent_dir/node_modules/lodash/_baseEach.js b/parent_dir/node_modules/lodash/_baseEach.js
new file mode 100644
index 0000000..512c067
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseEach.js
@@ -0,0 +1,14 @@
+var baseForOwn = require('./_baseForOwn'),
+    createBaseEach = require('./_createBaseEach');
+
+/**
+ * The base implementation of `_.forEach` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ */
+var baseEach = createBaseEach(baseForOwn);
+
+module.exports = baseEach;
diff --git a/parent_dir/node_modules/lodash/_baseFindIndex.js b/parent_dir/node_modules/lodash/_baseFindIndex.js
new file mode 100644
index 0000000..e3f5d8a
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseFindIndex.js
@@ -0,0 +1,24 @@
+/**
+ * The base implementation of `_.findIndex` and `_.findLastIndex` without
+ * support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Function} predicate The function invoked per iteration.
+ * @param {number} fromIndex The index to search from.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function baseFindIndex(array, predicate, fromIndex, fromRight) {
+  var length = array.length,
+      index = fromIndex + (fromRight ? 1 : -1);
+
+  while ((fromRight ? index-- : ++index < length)) {
+    if (predicate(array[index], index, array)) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+module.exports = baseFindIndex;
diff --git a/parent_dir/node_modules/lodash/_baseFlatten.js b/parent_dir/node_modules/lodash/_baseFlatten.js
new file mode 100644
index 0000000..4b1e009
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseFlatten.js
@@ -0,0 +1,38 @@
+var arrayPush = require('./_arrayPush'),
+    isFlattenable = require('./_isFlattenable');
+
+/**
+ * The base implementation of `_.flatten` with support for restricting flattening.
+ *
+ * @private
+ * @param {Array} array The array to flatten.
+ * @param {number} depth The maximum recursion depth.
+ * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
+ * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
+ * @param {Array} [result=[]] The initial result value.
+ * @returns {Array} Returns the new flattened array.
+ */
+function baseFlatten(array, depth, predicate, isStrict, result) {
+  var index = -1,
+      length = array.length;
+
+  predicate || (predicate = isFlattenable);
+  result || (result = []);
+
+  while (++index < length) {
+    var value = array[index];
+    if (depth > 0 && predicate(value)) {
+      if (depth > 1) {
+        // Recursively flatten arrays (susceptible to call stack limits).
+        baseFlatten(value, depth - 1, predicate, isStrict, result);
+      } else {
+        arrayPush(result, value);
+      }
+    } else if (!isStrict) {
+      result[result.length] = value;
+    }
+  }
+  return result;
+}
+
+module.exports = baseFlatten;
diff --git a/parent_dir/node_modules/lodash/_baseFor.js b/parent_dir/node_modules/lodash/_baseFor.js
new file mode 100644
index 0000000..d946590
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseFor.js
@@ -0,0 +1,16 @@
+var createBaseFor = require('./_createBaseFor');
+
+/**
+ * The base implementation of `baseForOwn` which iterates over `object`
+ * properties returned by `keysFunc` and invokes `iteratee` for each property.
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @returns {Object} Returns `object`.
+ */
+var baseFor = createBaseFor();
+
+module.exports = baseFor;
diff --git a/parent_dir/node_modules/lodash/_baseForOwn.js b/parent_dir/node_modules/lodash/_baseForOwn.js
new file mode 100644
index 0000000..503d523
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseForOwn.js
@@ -0,0 +1,16 @@
+var baseFor = require('./_baseFor'),
+    keys = require('./keys');
+
+/**
+ * The base implementation of `_.forOwn` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ */
+function baseForOwn(object, iteratee) {
+  return object && baseFor(object, iteratee, keys);
+}
+
+module.exports = baseForOwn;
diff --git a/parent_dir/node_modules/lodash/_baseGet.js b/parent_dir/node_modules/lodash/_baseGet.js
new file mode 100644
index 0000000..a194913
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseGet.js
@@ -0,0 +1,24 @@
+var castPath = require('./_castPath'),
+    toKey = require('./_toKey');
+
+/**
+ * The base implementation of `_.get` without support for default values.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @returns {*} Returns the resolved value.
+ */
+function baseGet(object, path) {
+  path = castPath(path, object);
+
+  var index = 0,
+      length = path.length;
+
+  while (object != null && index < length) {
+    object = object[toKey(path[index++])];
+  }
+  return (index && index == length) ? object : undefined;
+}
+
+module.exports = baseGet;
diff --git a/parent_dir/node_modules/lodash/_baseGetAllKeys.js b/parent_dir/node_modules/lodash/_baseGetAllKeys.js
new file mode 100644
index 0000000..8ad204e
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseGetAllKeys.js
@@ -0,0 +1,20 @@
+var arrayPush = require('./_arrayPush'),
+    isArray = require('./isArray');
+
+/**
+ * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+ * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+ * symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @param {Function} symbolsFunc The function to get the symbols of `object`.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+
+module.exports = baseGetAllKeys;
diff --git a/parent_dir/node_modules/lodash/_baseGetTag.js b/parent_dir/node_modules/lodash/_baseGetTag.js
new file mode 100644
index 0000000..b927ccc
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseGetTag.js
@@ -0,0 +1,28 @@
+var Symbol = require('./_Symbol'),
+    getRawTag = require('./_getRawTag'),
+    objectToString = require('./_objectToString');
+
+/** `Object#toString` result references. */
+var nullTag = '[object Null]',
+    undefinedTag = '[object Undefined]';
+
+/** Built-in value references. */
+var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+/**
+ * The base implementation of `getTag` without fallbacks for buggy environments.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return (symToStringTag && symToStringTag in Object(value))
+    ? getRawTag(value)
+    : objectToString(value);
+}
+
+module.exports = baseGetTag;
diff --git a/parent_dir/node_modules/lodash/_baseHasIn.js b/parent_dir/node_modules/lodash/_baseHasIn.js
new file mode 100644
index 0000000..2e0d042
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseHasIn.js
@@ -0,0 +1,13 @@
+/**
+ * The base implementation of `_.hasIn` without support for deep paths.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {Array|string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` exists, else `false`.
+ */
+function baseHasIn(object, key) {
+  return object != null && key in Object(object);
+}
+
+module.exports = baseHasIn;
diff --git a/parent_dir/node_modules/lodash/_baseIsArguments.js b/parent_dir/node_modules/lodash/_baseIsArguments.js
new file mode 100644
index 0000000..b3562cc
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseIsArguments.js
@@ -0,0 +1,18 @@
+var baseGetTag = require('./_baseGetTag'),
+    isObjectLike = require('./isObjectLike');
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]';
+
+/**
+ * The base implementation of `_.isArguments`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ */
+function baseIsArguments(value) {
+  return isObjectLike(value) && baseGetTag(value) == argsTag;
+}
+
+module.exports = baseIsArguments;
diff --git a/parent_dir/node_modules/lodash/_baseIsEqual.js b/parent_dir/node_modules/lodash/_baseIsEqual.js
new file mode 100644
index 0000000..00a68a4
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseIsEqual.js
@@ -0,0 +1,28 @@
+var baseIsEqualDeep = require('./_baseIsEqualDeep'),
+    isObjectLike = require('./isObjectLike');
+
+/**
+ * The base implementation of `_.isEqual` which supports partial comparisons
+ * and tracks traversed objects.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @param {boolean} bitmask The bitmask flags.
+ *  1 - Unordered comparison
+ *  2 - Partial comparison
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @param {Object} [stack] Tracks traversed `value` and `other` objects.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ */
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
+    return value !== value && other !== other;
+  }
+  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+
+module.exports = baseIsEqual;
diff --git a/parent_dir/node_modules/lodash/_baseIsEqualDeep.js b/parent_dir/node_modules/lodash/_baseIsEqualDeep.js
new file mode 100644
index 0000000..e3cfd6a
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseIsEqualDeep.js
@@ -0,0 +1,83 @@
+var Stack = require('./_Stack'),
+    equalArrays = require('./_equalArrays'),
+    equalByTag = require('./_equalByTag'),
+    equalObjects = require('./_equalObjects'),
+    getTag = require('./_getTag'),
+    isArray = require('./isArray'),
+    isBuffer = require('./isBuffer'),
+    isTypedArray = require('./isTypedArray');
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG = 1;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    objectTag = '[object Object]';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * A specialized version of `baseIsEqual` for arrays and objects which performs
+ * deep comparisons and tracks traversed objects enabling objects with circular
+ * references to be compared.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray(object),
+      othIsArr = isArray(other),
+      objTag = objIsArr ? arrayTag : getTag(object),
+      othTag = othIsArr ? arrayTag : getTag(other);
+
+  objTag = objTag == argsTag ? objectTag : objTag;
+  othTag = othTag == argsTag ? objectTag : othTag;
+
+  var objIsObj = objTag == objectTag,
+      othIsObj = othTag == objectTag,
+      isSameTag = objTag == othTag;
+
+  if (isSameTag && isBuffer(object)) {
+    if (!isBuffer(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack);
+    return (objIsArr || isTypedArray(object))
+      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
+      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
+        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
+
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object,
+          othUnwrapped = othIsWrapped ? other.value() : other;
+
+      stack || (stack = new Stack);
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack);
+  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+
+module.exports = baseIsEqualDeep;
diff --git a/parent_dir/node_modules/lodash/_baseIsMap.js b/parent_dir/node_modules/lodash/_baseIsMap.js
new file mode 100644
index 0000000..02a4021
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseIsMap.js
@@ -0,0 +1,18 @@
+var getTag = require('./_getTag'),
+    isObjectLike = require('./isObjectLike');
+
+/** `Object#toString` result references. */
+var mapTag = '[object Map]';
+
+/**
+ * The base implementation of `_.isMap` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a map, else `false`.
+ */
+function baseIsMap(value) {
+  return isObjectLike(value) && getTag(value) == mapTag;
+}
+
+module.exports = baseIsMap;
diff --git a/parent_dir/node_modules/lodash/_baseIsMatch.js b/parent_dir/node_modules/lodash/_baseIsMatch.js
new file mode 100644
index 0000000..72494be
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseIsMatch.js
@@ -0,0 +1,62 @@
+var Stack = require('./_Stack'),
+    baseIsEqual = require('./_baseIsEqual');
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG = 1,
+    COMPARE_UNORDERED_FLAG = 2;
+
+/**
+ * The base implementation of `_.isMatch` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property values to match.
+ * @param {Array} matchData The property names, values, and compare flags to match.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+ */
+function baseIsMatch(object, source, matchData, customizer) {
+  var index = matchData.length,
+      length = index,
+      noCustomizer = !customizer;
+
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (index--) {
+    var data = matchData[index];
+    if ((noCustomizer && data[2])
+          ? data[1] !== object[data[0]]
+          : !(data[0] in object)
+        ) {
+      return false;
+    }
+  }
+  while (++index < length) {
+    data = matchData[index];
+    var key = data[0],
+        objValue = object[key],
+        srcValue = data[1];
+
+    if (noCustomizer && data[2]) {
+      if (objValue === undefined && !(key in object)) {
+        return false;
+      }
+    } else {
+      var stack = new Stack;
+      if (customizer) {
+        var result = customizer(objValue, srcValue, key, object, source, stack);
+      }
+      if (!(result === undefined
+            ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
+            : result
+          )) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+module.exports = baseIsMatch;
diff --git a/parent_dir/node_modules/lodash/_baseIsNative.js b/parent_dir/node_modules/lodash/_baseIsNative.js
new file mode 100644
index 0000000..8702330
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseIsNative.js
@@ -0,0 +1,47 @@
+var isFunction = require('./isFunction'),
+    isMasked = require('./_isMasked'),
+    isObject = require('./isObject'),
+    toSource = require('./_toSource');
+
+/**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+    objectProto = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/** Used to detect if a method is native. */
+var reIsNative = RegExp('^' +
+  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+);
+
+/**
+ * The base implementation of `_.isNative` without bad shim checks.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function,
+ *  else `false`.
+ */
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+
+module.exports = baseIsNative;
diff --git a/parent_dir/node_modules/lodash/_baseIsSet.js b/parent_dir/node_modules/lodash/_baseIsSet.js
new file mode 100644
index 0000000..6dee367
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseIsSet.js
@@ -0,0 +1,18 @@
+var getTag = require('./_getTag'),
+    isObjectLike = require('./isObjectLike');
+
+/** `Object#toString` result references. */
+var setTag = '[object Set]';
+
+/**
+ * The base implementation of `_.isSet` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+ */
+function baseIsSet(value) {
+  return isObjectLike(value) && getTag(value) == setTag;
+}
+
+module.exports = baseIsSet;
diff --git a/parent_dir/node_modules/lodash/_baseIsTypedArray.js b/parent_dir/node_modules/lodash/_baseIsTypedArray.js
new file mode 100644
index 0000000..1edb32f
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseIsTypedArray.js
@@ -0,0 +1,60 @@
+var baseGetTag = require('./_baseGetTag'),
+    isLength = require('./isLength'),
+    isObjectLike = require('./isObjectLike');
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    funcTag = '[object Function]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    objectTag = '[object Object]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    weakMapTag = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[object DataView]',
+    float32Tag = '[object Float32Array]',
+    float64Tag = '[object Float64Array]',
+    int8Tag = '[object Int8Array]',
+    int16Tag = '[object Int16Array]',
+    int32Tag = '[object Int32Array]',
+    uint8Tag = '[object Uint8Array]',
+    uint8ClampedTag = '[object Uint8ClampedArray]',
+    uint16Tag = '[object Uint16Array]',
+    uint32Tag = '[object Uint32Array]';
+
+/** Used to identify `toStringTag` values of typed arrays. */
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
+typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
+typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
+typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
+typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
+typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
+typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
+typedArrayTags[errorTag] = typedArrayTags[funcTag] =
+typedArrayTags[mapTag] = typedArrayTags[numberTag] =
+typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
+typedArrayTags[setTag] = typedArrayTags[stringTag] =
+typedArrayTags[weakMapTag] = false;
+
+/**
+ * The base implementation of `_.isTypedArray` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ */
+function baseIsTypedArray(value) {
+  return isObjectLike(value) &&
+    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+}
+
+module.exports = baseIsTypedArray;
diff --git a/parent_dir/node_modules/lodash/_baseIteratee.js b/parent_dir/node_modules/lodash/_baseIteratee.js
new file mode 100644
index 0000000..995c257
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseIteratee.js
@@ -0,0 +1,31 @@
+var baseMatches = require('./_baseMatches'),
+    baseMatchesProperty = require('./_baseMatchesProperty'),
+    identity = require('./identity'),
+    isArray = require('./isArray'),
+    property = require('./property');
+
+/**
+ * The base implementation of `_.iteratee`.
+ *
+ * @private
+ * @param {*} [value=_.identity] The value to convert to an iteratee.
+ * @returns {Function} Returns the iteratee.
+ */
+function baseIteratee(value) {
+  // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
+  // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
+  if (typeof value == 'function') {
+    return value;
+  }
+  if (value == null) {
+    return identity;
+  }
+  if (typeof value == 'object') {
+    return isArray(value)
+      ? baseMatchesProperty(value[0], value[1])
+      : baseMatches(value);
+  }
+  return property(value);
+}
+
+module.exports = baseIteratee;
diff --git a/parent_dir/node_modules/lodash/_baseKeys.js b/parent_dir/node_modules/lodash/_baseKeys.js
new file mode 100644
index 0000000..45e9e6f
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseKeys.js
@@ -0,0 +1,30 @@
+var isPrototype = require('./_isPrototype'),
+    nativeKeys = require('./_nativeKeys');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeys(object) {
+  if (!isPrototype(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty.call(object, key) && key != 'constructor') {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+module.exports = baseKeys;
diff --git a/parent_dir/node_modules/lodash/_baseKeysIn.js b/parent_dir/node_modules/lodash/_baseKeysIn.js
new file mode 100644
index 0000000..ea8a0a1
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseKeysIn.js
@@ -0,0 +1,33 @@
+var isObject = require('./isObject'),
+    isPrototype = require('./_isPrototype'),
+    nativeKeysIn = require('./_nativeKeysIn');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeysIn(object) {
+  if (!isObject(object)) {
+    return nativeKeysIn(object);
+  }
+  var isProto = isPrototype(object),
+      result = [];
+
+  for (var key in object) {
+    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+module.exports = baseKeysIn;
diff --git a/parent_dir/node_modules/lodash/_baseMap.js b/parent_dir/node_modules/lodash/_baseMap.js
new file mode 100644
index 0000000..0bf5cea
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseMap.js
@@ -0,0 +1,22 @@
+var baseEach = require('./_baseEach'),
+    isArrayLike = require('./isArrayLike');
+
+/**
+ * The base implementation of `_.map` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function baseMap(collection, iteratee) {
+  var index = -1,
+      result = isArrayLike(collection) ? Array(collection.length) : [];
+
+  baseEach(collection, function(value, key, collection) {
+    result[++index] = iteratee(value, key, collection);
+  });
+  return result;
+}
+
+module.exports = baseMap;
diff --git a/parent_dir/node_modules/lodash/_baseMatches.js b/parent_dir/node_modules/lodash/_baseMatches.js
new file mode 100644
index 0000000..e56582a
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseMatches.js
@@ -0,0 +1,22 @@
+var baseIsMatch = require('./_baseIsMatch'),
+    getMatchData = require('./_getMatchData'),
+    matchesStrictComparable = require('./_matchesStrictComparable');
+
+/**
+ * The base implementation of `_.matches` which doesn't clone `source`.
+ *
+ * @private
+ * @param {Object} source The object of property values to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatches(source) {
+  var matchData = getMatchData(source);
+  if (matchData.length == 1 && matchData[0][2]) {
+    return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+  }
+  return function(object) {
+    return object === source || baseIsMatch(object, source, matchData);
+  };
+}
+
+module.exports = baseMatches;
diff --git a/parent_dir/node_modules/lodash/_baseMatchesProperty.js b/parent_dir/node_modules/lodash/_baseMatchesProperty.js
new file mode 100644
index 0000000..24afd89
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseMatchesProperty.js
@@ -0,0 +1,33 @@
+var baseIsEqual = require('./_baseIsEqual'),
+    get = require('./get'),
+    hasIn = require('./hasIn'),
+    isKey = require('./_isKey'),
+    isStrictComparable = require('./_isStrictComparable'),
+    matchesStrictComparable = require('./_matchesStrictComparable'),
+    toKey = require('./_toKey');
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG = 1,
+    COMPARE_UNORDERED_FLAG = 2;
+
+/**
+ * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
+ *
+ * @private
+ * @param {string} path The path of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatchesProperty(path, srcValue) {
+  if (isKey(path) && isStrictComparable(srcValue)) {
+    return matchesStrictComparable(toKey(path), srcValue);
+  }
+  return function(object) {
+    var objValue = get(object, path);
+    return (objValue === undefined && objValue === srcValue)
+      ? hasIn(object, path)
+      : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+  };
+}
+
+module.exports = baseMatchesProperty;
diff --git a/parent_dir/node_modules/lodash/_baseMerge.js b/parent_dir/node_modules/lodash/_baseMerge.js
new file mode 100644
index 0000000..c98b5eb
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseMerge.js
@@ -0,0 +1,42 @@
+var Stack = require('./_Stack'),
+    assignMergeValue = require('./_assignMergeValue'),
+    baseFor = require('./_baseFor'),
+    baseMergeDeep = require('./_baseMergeDeep'),
+    isObject = require('./isObject'),
+    keysIn = require('./keysIn'),
+    safeGet = require('./_safeGet');
+
+/**
+ * The base implementation of `_.merge` without support for multiple sources.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {number} srcIndex The index of `source`.
+ * @param {Function} [customizer] The function to customize merged values.
+ * @param {Object} [stack] Tracks traversed source values and their merged
+ *  counterparts.
+ */
+function baseMerge(object, source, srcIndex, customizer, stack) {
+  if (object === source) {
+    return;
+  }
+  baseFor(source, function(srcValue, key) {
+    stack || (stack = new Stack);
+    if (isObject(srcValue)) {
+      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
+    }
+    else {
+      var newValue = customizer
+        ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
+        : undefined;
+
+      if (newValue === undefined) {
+        newValue = srcValue;
+      }
+      assignMergeValue(object, key, newValue);
+    }
+  }, keysIn);
+}
+
+module.exports = baseMerge;
diff --git a/parent_dir/node_modules/lodash/_baseMergeDeep.js b/parent_dir/node_modules/lodash/_baseMergeDeep.js
new file mode 100644
index 0000000..4679e8d
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseMergeDeep.js
@@ -0,0 +1,94 @@
+var assignMergeValue = require('./_assignMergeValue'),
+    cloneBuffer = require('./_cloneBuffer'),
+    cloneTypedArray = require('./_cloneTypedArray'),
+    copyArray = require('./_copyArray'),
+    initCloneObject = require('./_initCloneObject'),
+    isArguments = require('./isArguments'),
+    isArray = require('./isArray'),
+    isArrayLikeObject = require('./isArrayLikeObject'),
+    isBuffer = require('./isBuffer'),
+    isFunction = require('./isFunction'),
+    isObject = require('./isObject'),
+    isPlainObject = require('./isPlainObject'),
+    isTypedArray = require('./isTypedArray'),
+    safeGet = require('./_safeGet'),
+    toPlainObject = require('./toPlainObject');
+
+/**
+ * A specialized version of `baseMerge` for arrays and objects which performs
+ * deep merges and tracks traversed objects enabling objects with circular
+ * references to be merged.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {string} key The key of the value to merge.
+ * @param {number} srcIndex The index of `source`.
+ * @param {Function} mergeFunc The function to merge values.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @param {Object} [stack] Tracks traversed source values and their merged
+ *  counterparts.
+ */
+function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+  var objValue = safeGet(object, key),
+      srcValue = safeGet(source, key),
+      stacked = stack.get(srcValue);
+
+  if (stacked) {
+    assignMergeValue(object, key, stacked);
+    return;
+  }
+  var newValue = customizer
+    ? customizer(objValue, srcValue, (key + ''), object, source, stack)
+    : undefined;
+
+  var isCommon = newValue === undefined;
+
+  if (isCommon) {
+    var isArr = isArray(srcValue),
+        isBuff = !isArr && isBuffer(srcValue),
+        isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+
+    newValue = srcValue;
+    if (isArr || isBuff || isTyped) {
+      if (isArray(objValue)) {
+        newValue = objValue;
+      }
+      else if (isArrayLikeObject(objValue)) {
+        newValue = copyArray(objValue);
+      }
+      else if (isBuff) {
+        isCommon = false;
+        newValue = cloneBuffer(srcValue, true);
+      }
+      else if (isTyped) {
+        isCommon = false;
+        newValue = cloneTypedArray(srcValue, true);
+      }
+      else {
+        newValue = [];
+      }
+    }
+    else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+      newValue = objValue;
+      if (isArguments(objValue)) {
+        newValue = toPlainObject(objValue);
+      }
+      else if (!isObject(objValue) || isFunction(objValue)) {
+        newValue = initCloneObject(srcValue);
+      }
+    }
+    else {
+      isCommon = false;
+    }
+  }
+  if (isCommon) {
+    // Recursively merge objects and arrays (susceptible to call stack limits).
+    stack.set(srcValue, newValue);
+    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+    stack['delete'](srcValue);
+  }
+  assignMergeValue(object, key, newValue);
+}
+
+module.exports = baseMergeDeep;
diff --git a/parent_dir/node_modules/lodash/_baseOrderBy.js b/parent_dir/node_modules/lodash/_baseOrderBy.js
new file mode 100644
index 0000000..775a017
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseOrderBy.js
@@ -0,0 +1,49 @@
+var arrayMap = require('./_arrayMap'),
+    baseGet = require('./_baseGet'),
+    baseIteratee = require('./_baseIteratee'),
+    baseMap = require('./_baseMap'),
+    baseSortBy = require('./_baseSortBy'),
+    baseUnary = require('./_baseUnary'),
+    compareMultiple = require('./_compareMultiple'),
+    identity = require('./identity'),
+    isArray = require('./isArray');
+
+/**
+ * The base implementation of `_.orderBy` without param guards.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
+ * @param {string[]} orders The sort orders of `iteratees`.
+ * @returns {Array} Returns the new sorted array.
+ */
+function baseOrderBy(collection, iteratees, orders) {
+  if (iteratees.length) {
+    iteratees = arrayMap(iteratees, function(iteratee) {
+      if (isArray(iteratee)) {
+        return function(value) {
+          return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
+        }
+      }
+      return iteratee;
+    });
+  } else {
+    iteratees = [identity];
+  }
+
+  var index = -1;
+  iteratees = arrayMap(iteratees, baseUnary(baseIteratee));
+
+  var result = baseMap(collection, function(value, key, collection) {
+    var criteria = arrayMap(iteratees, function(iteratee) {
+      return iteratee(value);
+    });
+    return { 'criteria': criteria, 'index': ++index, 'value': value };
+  });
+
+  return baseSortBy(result, function(object, other) {
+    return compareMultiple(object, other, orders);
+  });
+}
+
+module.exports = baseOrderBy;
diff --git a/parent_dir/node_modules/lodash/_baseProperty.js b/parent_dir/node_modules/lodash/_baseProperty.js
new file mode 100644
index 0000000..496281e
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseProperty.js
@@ -0,0 +1,14 @@
+/**
+ * The base implementation of `_.property` without support for deep paths.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+function baseProperty(key) {
+  return function(object) {
+    return object == null ? undefined : object[key];
+  };
+}
+
+module.exports = baseProperty;
diff --git a/parent_dir/node_modules/lodash/_basePropertyDeep.js b/parent_dir/node_modules/lodash/_basePropertyDeep.js
new file mode 100644
index 0000000..1e5aae5
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_basePropertyDeep.js
@@ -0,0 +1,16 @@
+var baseGet = require('./_baseGet');
+
+/**
+ * A specialized version of `baseProperty` which supports deep paths.
+ *
+ * @private
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+function basePropertyDeep(path) {
+  return function(object) {
+    return baseGet(object, path);
+  };
+}
+
+module.exports = basePropertyDeep;
diff --git a/parent_dir/node_modules/lodash/_baseRandom.js b/parent_dir/node_modules/lodash/_baseRandom.js
new file mode 100644
index 0000000..94f76a7
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseRandom.js
@@ -0,0 +1,18 @@
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeFloor = Math.floor,
+    nativeRandom = Math.random;
+
+/**
+ * The base implementation of `_.random` without support for returning
+ * floating-point numbers.
+ *
+ * @private
+ * @param {number} lower The lower bound.
+ * @param {number} upper The upper bound.
+ * @returns {number} Returns the random number.
+ */
+function baseRandom(lower, upper) {
+  return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
+}
+
+module.exports = baseRandom;
diff --git a/parent_dir/node_modules/lodash/_baseRest.js b/parent_dir/node_modules/lodash/_baseRest.js
new file mode 100644
index 0000000..d0dc4bd
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseRest.js
@@ -0,0 +1,17 @@
+var identity = require('./identity'),
+    overRest = require('./_overRest'),
+    setToString = require('./_setToString');
+
+/**
+ * The base implementation of `_.rest` which doesn't validate or coerce arguments.
+ *
+ * @private
+ * @param {Function} func The function to apply a rest parameter to.
+ * @param {number} [start=func.length-1] The start position of the rest parameter.
+ * @returns {Function} Returns the new function.
+ */
+function baseRest(func, start) {
+  return setToString(overRest(func, start, identity), func + '');
+}
+
+module.exports = baseRest;
diff --git a/parent_dir/node_modules/lodash/_baseSetToString.js b/parent_dir/node_modules/lodash/_baseSetToString.js
new file mode 100644
index 0000000..89eaca3
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseSetToString.js
@@ -0,0 +1,22 @@
+var constant = require('./constant'),
+    defineProperty = require('./_defineProperty'),
+    identity = require('./identity');
+
+/**
+ * The base implementation of `setToString` without support for hot loop shorting.
+ *
+ * @private
+ * @param {Function} func The function to modify.
+ * @param {Function} string The `toString` result.
+ * @returns {Function} Returns `func`.
+ */
+var baseSetToString = !defineProperty ? identity : function(func, string) {
+  return defineProperty(func, 'toString', {
+    'configurable': true,
+    'enumerable': false,
+    'value': constant(string),
+    'writable': true
+  });
+};
+
+module.exports = baseSetToString;
diff --git a/parent_dir/node_modules/lodash/_baseSortBy.js b/parent_dir/node_modules/lodash/_baseSortBy.js
new file mode 100644
index 0000000..a25c92e
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseSortBy.js
@@ -0,0 +1,21 @@
+/**
+ * The base implementation of `_.sortBy` which uses `comparer` to define the
+ * sort order of `array` and replaces criteria objects with their corresponding
+ * values.
+ *
+ * @private
+ * @param {Array} array The array to sort.
+ * @param {Function} comparer The function to define sort order.
+ * @returns {Array} Returns `array`.
+ */
+function baseSortBy(array, comparer) {
+  var length = array.length;
+
+  array.sort(comparer);
+  while (length--) {
+    array[length] = array[length].value;
+  }
+  return array;
+}
+
+module.exports = baseSortBy;
diff --git a/parent_dir/node_modules/lodash/_baseTimes.js b/parent_dir/node_modules/lodash/_baseTimes.js
new file mode 100644
index 0000000..0603fc3
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseTimes.js
@@ -0,0 +1,20 @@
+/**
+ * The base implementation of `_.times` without support for iteratee shorthands
+ * or max array length checks.
+ *
+ * @private
+ * @param {number} n The number of times to invoke `iteratee`.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the array of results.
+ */
+function baseTimes(n, iteratee) {
+  var index = -1,
+      result = Array(n);
+
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+
+module.exports = baseTimes;
diff --git a/parent_dir/node_modules/lodash/_baseToString.js b/parent_dir/node_modules/lodash/_baseToString.js
new file mode 100644
index 0000000..ada6ad2
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseToString.js
@@ -0,0 +1,37 @@
+var Symbol = require('./_Symbol'),
+    arrayMap = require('./_arrayMap'),
+    isArray = require('./isArray'),
+    isSymbol = require('./isSymbol');
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : undefined,
+    symbolToString = symbolProto ? symbolProto.toString : undefined;
+
+/**
+ * The base implementation of `_.toString` which doesn't convert nullish
+ * values to empty strings.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ */
+function baseToString(value) {
+  // Exit early for strings to avoid a performance hit in some environments.
+  if (typeof value == 'string') {
+    return value;
+  }
+  if (isArray(value)) {
+    // Recursively convert values (susceptible to call stack limits).
+    return arrayMap(value, baseToString) + '';
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : '';
+  }
+  var result = (value + '');
+  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+}
+
+module.exports = baseToString;
diff --git a/parent_dir/node_modules/lodash/_baseTrim.js b/parent_dir/node_modules/lodash/_baseTrim.js
new file mode 100644
index 0000000..3e2797d
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseTrim.js
@@ -0,0 +1,19 @@
+var trimmedEndIndex = require('./_trimmedEndIndex');
+
+/** Used to match leading whitespace. */
+var reTrimStart = /^\s+/;
+
+/**
+ * The base implementation of `_.trim`.
+ *
+ * @private
+ * @param {string} string The string to trim.
+ * @returns {string} Returns the trimmed string.
+ */
+function baseTrim(string) {
+  return string
+    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')
+    : string;
+}
+
+module.exports = baseTrim;
diff --git a/parent_dir/node_modules/lodash/_baseUnary.js b/parent_dir/node_modules/lodash/_baseUnary.js
new file mode 100644
index 0000000..98639e9
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_baseUnary.js
@@ -0,0 +1,14 @@
+/**
+ * The base implementation of `_.unary` without support for storing metadata.
+ *
+ * @private
+ * @param {Function} func The function to cap arguments for.
+ * @returns {Function} Returns the new capped function.
+ */
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+
+module.exports = baseUnary;
diff --git a/parent_dir/node_modules/lodash/_cacheHas.js b/parent_dir/node_modules/lodash/_cacheHas.js
new file mode 100644
index 0000000..2dec892
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_cacheHas.js
@@ -0,0 +1,13 @@
+/**
+ * Checks if a `cache` value for `key` exists.
+ *
+ * @private
+ * @param {Object} cache The cache to query.
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+
+module.exports = cacheHas;
diff --git a/parent_dir/node_modules/lodash/_castPath.js b/parent_dir/node_modules/lodash/_castPath.js
new file mode 100644
index 0000000..017e4c1
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_castPath.js
@@ -0,0 +1,21 @@
+var isArray = require('./isArray'),
+    isKey = require('./_isKey'),
+    stringToPath = require('./_stringToPath'),
+    toString = require('./toString');
+
+/**
+ * Casts `value` to a path array if it's not one.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {Array} Returns the cast property path array.
+ */
+function castPath(value, object) {
+  if (isArray(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : stringToPath(toString(value));
+}
+
+module.exports = castPath;
diff --git a/parent_dir/node_modules/lodash/_cloneArrayBuffer.js b/parent_dir/node_modules/lodash/_cloneArrayBuffer.js
new file mode 100644
index 0000000..c3d8f6e
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_cloneArrayBuffer.js
@@ -0,0 +1,16 @@
+var Uint8Array = require('./_Uint8Array');
+
+/**
+ * Creates a clone of `arrayBuffer`.
+ *
+ * @private
+ * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
+ * @returns {ArrayBuffer} Returns the cloned array buffer.
+ */
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+  return result;
+}
+
+module.exports = cloneArrayBuffer;
diff --git a/parent_dir/node_modules/lodash/_cloneBuffer.js b/parent_dir/node_modules/lodash/_cloneBuffer.js
new file mode 100644
index 0000000..27c4810
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_cloneBuffer.js
@@ -0,0 +1,35 @@
+var root = require('./_root');
+
+/** Detect free variable `exports`. */
+var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/** Built-in value references. */
+var Buffer = moduleExports ? root.Buffer : undefined,
+    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;
+
+/**
+ * Creates a clone of  `buffer`.
+ *
+ * @private
+ * @param {Buffer} buffer The buffer to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Buffer} Returns the cloned buffer.
+ */
+function cloneBuffer(buffer, isDeep) {
+  if (isDeep) {
+    return buffer.slice();
+  }
+  var length = buffer.length,
+      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+
+  buffer.copy(result);
+  return result;
+}
+
+module.exports = cloneBuffer;
diff --git a/parent_dir/node_modules/lodash/_cloneDataView.js b/parent_dir/node_modules/lodash/_cloneDataView.js
new file mode 100644
index 0000000..9c9b7b0
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_cloneDataView.js
@@ -0,0 +1,16 @@
+var cloneArrayBuffer = require('./_cloneArrayBuffer');
+
+/**
+ * Creates a clone of `dataView`.
+ *
+ * @private
+ * @param {Object} dataView The data view to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the cloned data view.
+ */
+function cloneDataView(dataView, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+
+module.exports = cloneDataView;
diff --git a/parent_dir/node_modules/lodash/_cloneRegExp.js b/parent_dir/node_modules/lodash/_cloneRegExp.js
new file mode 100644
index 0000000..64a30df
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_cloneRegExp.js
@@ -0,0 +1,17 @@
+/** Used to match `RegExp` flags from their coerced string values. */
+var reFlags = /\w*$/;
+
+/**
+ * Creates a clone of `regexp`.
+ *
+ * @private
+ * @param {Object} regexp The regexp to clone.
+ * @returns {Object} Returns the cloned regexp.
+ */
+function cloneRegExp(regexp) {
+  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+  result.lastIndex = regexp.lastIndex;
+  return result;
+}
+
+module.exports = cloneRegExp;
diff --git a/parent_dir/node_modules/lodash/_cloneSymbol.js b/parent_dir/node_modules/lodash/_cloneSymbol.js
new file mode 100644
index 0000000..bede39f
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_cloneSymbol.js
@@ -0,0 +1,18 @@
+var Symbol = require('./_Symbol');
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : undefined,
+    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+/**
+ * Creates a clone of the `symbol` object.
+ *
+ * @private
+ * @param {Object} symbol The symbol object to clone.
+ * @returns {Object} Returns the cloned symbol object.
+ */
+function cloneSymbol(symbol) {
+  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+}
+
+module.exports = cloneSymbol;
diff --git a/parent_dir/node_modules/lodash/_cloneTypedArray.js b/parent_dir/node_modules/lodash/_cloneTypedArray.js
new file mode 100644
index 0000000..7aad84d
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_cloneTypedArray.js
@@ -0,0 +1,16 @@
+var cloneArrayBuffer = require('./_cloneArrayBuffer');
+
+/**
+ * Creates a clone of `typedArray`.
+ *
+ * @private
+ * @param {Object} typedArray The typed array to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the cloned typed array.
+ */
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+
+module.exports = cloneTypedArray;
diff --git a/parent_dir/node_modules/lodash/_compareAscending.js b/parent_dir/node_modules/lodash/_compareAscending.js
new file mode 100644
index 0000000..8dc2791
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_compareAscending.js
@@ -0,0 +1,41 @@
+var isSymbol = require('./isSymbol');
+
+/**
+ * Compares values to sort them in ascending order.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {number} Returns the sort order indicator for `value`.
+ */
+function compareAscending(value, other) {
+  if (value !== other) {
+    var valIsDefined = value !== undefined,
+        valIsNull = value === null,
+        valIsReflexive = value === value,
+        valIsSymbol = isSymbol(value);
+
+    var othIsDefined = other !== undefined,
+        othIsNull = other === null,
+        othIsReflexive = other === other,
+        othIsSymbol = isSymbol(other);
+
+    if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
+        (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
+        (valIsNull && othIsDefined && othIsReflexive) ||
+        (!valIsDefined && othIsReflexive) ||
+        !valIsReflexive) {
+      return 1;
+    }
+    if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
+        (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
+        (othIsNull && valIsDefined && valIsReflexive) ||
+        (!othIsDefined && valIsReflexive) ||
+        !othIsReflexive) {
+      return -1;
+    }
+  }
+  return 0;
+}
+
+module.exports = compareAscending;
diff --git a/parent_dir/node_modules/lodash/_compareMultiple.js b/parent_dir/node_modules/lodash/_compareMultiple.js
new file mode 100644
index 0000000..ad61f0f
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_compareMultiple.js
@@ -0,0 +1,44 @@
+var compareAscending = require('./_compareAscending');
+
+/**
+ * Used by `_.orderBy` to compare multiple properties of a value to another
+ * and stable sort them.
+ *
+ * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,
+ * specify an order of "desc" for descending or "asc" for ascending sort order
+ * of corresponding values.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {boolean[]|string[]} orders The order to sort by for each property.
+ * @returns {number} Returns the sort order indicator for `object`.
+ */
+function compareMultiple(object, other, orders) {
+  var index = -1,
+      objCriteria = object.criteria,
+      othCriteria = other.criteria,
+      length = objCriteria.length,
+      ordersLength = orders.length;
+
+  while (++index < length) {
+    var result = compareAscending(objCriteria[index], othCriteria[index]);
+    if (result) {
+      if (index >= ordersLength) {
+        return result;
+      }
+      var order = orders[index];
+      return result * (order == 'desc' ? -1 : 1);
+    }
+  }
+  // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
+  // that causes it, under certain circumstances, to provide the same value for
+  // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247
+  // for more details.
+  //
+  // This also ensures a stable sort in V8 and other engines.
+  // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
+  return object.index - other.index;
+}
+
+module.exports = compareMultiple;
diff --git a/parent_dir/node_modules/lodash/_copyArray.js b/parent_dir/node_modules/lodash/_copyArray.js
new file mode 100644
index 0000000..cd94d5d
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_copyArray.js
@@ -0,0 +1,20 @@
+/**
+ * Copies the values of `source` to `array`.
+ *
+ * @private
+ * @param {Array} source The array to copy values from.
+ * @param {Array} [array=[]] The array to copy values to.
+ * @returns {Array} Returns `array`.
+ */
+function copyArray(source, array) {
+  var index = -1,
+      length = source.length;
+
+  array || (array = Array(length));
+  while (++index < length) {
+    array[index] = source[index];
+  }
+  return array;
+}
+
+module.exports = copyArray;
diff --git a/parent_dir/node_modules/lodash/_copyObject.js b/parent_dir/node_modules/lodash/_copyObject.js
new file mode 100644
index 0000000..2f2a5c2
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_copyObject.js
@@ -0,0 +1,40 @@
+var assignValue = require('./_assignValue'),
+    baseAssignValue = require('./_baseAssignValue');
+
+/**
+ * Copies properties of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy properties from.
+ * @param {Array} props The property identifiers to copy.
+ * @param {Object} [object={}] The object to copy properties to.
+ * @param {Function} [customizer] The function to customize copied values.
+ * @returns {Object} Returns `object`.
+ */
+function copyObject(source, props, object, customizer) {
+  var isNew = !object;
+  object || (object = {});
+
+  var index = -1,
+      length = props.length;
+
+  while (++index < length) {
+    var key = props[index];
+
+    var newValue = customizer
+      ? customizer(object[key], source[key], key, object, source)
+      : undefined;
+
+    if (newValue === undefined) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      baseAssignValue(object, key, newValue);
+    } else {
+      assignValue(object, key, newValue);
+    }
+  }
+  return object;
+}
+
+module.exports = copyObject;
diff --git a/parent_dir/node_modules/lodash/_copySymbols.js b/parent_dir/node_modules/lodash/_copySymbols.js
new file mode 100644
index 0000000..c35944a
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_copySymbols.js
@@ -0,0 +1,16 @@
+var copyObject = require('./_copyObject'),
+    getSymbols = require('./_getSymbols');
+
+/**
+ * Copies own symbols of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy symbols from.
+ * @param {Object} [object={}] The object to copy symbols to.
+ * @returns {Object} Returns `object`.
+ */
+function copySymbols(source, object) {
+  return copyObject(source, getSymbols(source), object);
+}
+
+module.exports = copySymbols;
diff --git a/parent_dir/node_modules/lodash/_copySymbolsIn.js b/parent_dir/node_modules/lodash/_copySymbolsIn.js
new file mode 100644
index 0000000..fdf20a7
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_copySymbolsIn.js
@@ -0,0 +1,16 @@
+var copyObject = require('./_copyObject'),
+    getSymbolsIn = require('./_getSymbolsIn');
+
+/**
+ * Copies own and inherited symbols of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy symbols from.
+ * @param {Object} [object={}] The object to copy symbols to.
+ * @returns {Object} Returns `object`.
+ */
+function copySymbolsIn(source, object) {
+  return copyObject(source, getSymbolsIn(source), object);
+}
+
+module.exports = copySymbolsIn;
diff --git a/parent_dir/node_modules/lodash/_coreJsData.js b/parent_dir/node_modules/lodash/_coreJsData.js
new file mode 100644
index 0000000..f8e5b4e
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_coreJsData.js
@@ -0,0 +1,6 @@
+var root = require('./_root');
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData = root['__core-js_shared__'];
+
+module.exports = coreJsData;
diff --git a/parent_dir/node_modules/lodash/_createAggregator.js b/parent_dir/node_modules/lodash/_createAggregator.js
new file mode 100644
index 0000000..0be42c4
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_createAggregator.js
@@ -0,0 +1,23 @@
+var arrayAggregator = require('./_arrayAggregator'),
+    baseAggregator = require('./_baseAggregator'),
+    baseIteratee = require('./_baseIteratee'),
+    isArray = require('./isArray');
+
+/**
+ * Creates a function like `_.groupBy`.
+ *
+ * @private
+ * @param {Function} setter The function to set accumulator values.
+ * @param {Function} [initializer] The accumulator object initializer.
+ * @returns {Function} Returns the new aggregator function.
+ */
+function createAggregator(setter, initializer) {
+  return function(collection, iteratee) {
+    var func = isArray(collection) ? arrayAggregator : baseAggregator,
+        accumulator = initializer ? initializer() : {};
+
+    return func(collection, setter, baseIteratee(iteratee, 2), accumulator);
+  };
+}
+
+module.exports = createAggregator;
diff --git a/parent_dir/node_modules/lodash/_createAssigner.js b/parent_dir/node_modules/lodash/_createAssigner.js
new file mode 100644
index 0000000..1f904c5
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_createAssigner.js
@@ -0,0 +1,37 @@
+var baseRest = require('./_baseRest'),
+    isIterateeCall = require('./_isIterateeCall');
+
+/**
+ * Creates a function like `_.assign`.
+ *
+ * @private
+ * @param {Function} assigner The function to assign values.
+ * @returns {Function} Returns the new assigner function.
+ */
+function createAssigner(assigner) {
+  return baseRest(function(object, sources) {
+    var index = -1,
+        length = sources.length,
+        customizer = length > 1 ? sources[length - 1] : undefined,
+        guard = length > 2 ? sources[2] : undefined;
+
+    customizer = (assigner.length > 3 && typeof customizer == 'function')
+      ? (length--, customizer)
+      : undefined;
+
+    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+      customizer = length < 3 ? undefined : customizer;
+      length = 1;
+    }
+    object = Object(object);
+    while (++index < length) {
+      var source = sources[index];
+      if (source) {
+        assigner(object, source, index, customizer);
+      }
+    }
+    return object;
+  });
+}
+
+module.exports = createAssigner;
diff --git a/parent_dir/node_modules/lodash/_createBaseEach.js b/parent_dir/node_modules/lodash/_createBaseEach.js
new file mode 100644
index 0000000..d24fdd1
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_createBaseEach.js
@@ -0,0 +1,32 @@
+var isArrayLike = require('./isArrayLike');
+
+/**
+ * Creates a `baseEach` or `baseEachRight` function.
+ *
+ * @private
+ * @param {Function} eachFunc The function to iterate over a collection.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+function createBaseEach(eachFunc, fromRight) {
+  return function(collection, iteratee) {
+    if (collection == null) {
+      return collection;
+    }
+    if (!isArrayLike(collection)) {
+      return eachFunc(collection, iteratee);
+    }
+    var length = collection.length,
+        index = fromRight ? length : -1,
+        iterable = Object(collection);
+
+    while ((fromRight ? index-- : ++index < length)) {
+      if (iteratee(iterable[index], index, iterable) === false) {
+        break;
+      }
+    }
+    return collection;
+  };
+}
+
+module.exports = createBaseEach;
diff --git a/parent_dir/node_modules/lodash/_createBaseFor.js b/parent_dir/node_modules/lodash/_createBaseFor.js
new file mode 100644
index 0000000..94cbf29
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_createBaseFor.js
@@ -0,0 +1,25 @@
+/**
+ * Creates a base function for methods like `_.forIn` and `_.forOwn`.
+ *
+ * @private
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+function createBaseFor(fromRight) {
+  return function(object, iteratee, keysFunc) {
+    var index = -1,
+        iterable = Object(object),
+        props = keysFunc(object),
+        length = props.length;
+
+    while (length--) {
+      var key = props[fromRight ? length : ++index];
+      if (iteratee(iterable[key], key, iterable) === false) {
+        break;
+      }
+    }
+    return object;
+  };
+}
+
+module.exports = createBaseFor;
diff --git a/parent_dir/node_modules/lodash/_createFind.js b/parent_dir/node_modules/lodash/_createFind.js
new file mode 100644
index 0000000..8859ff8
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_createFind.js
@@ -0,0 +1,25 @@
+var baseIteratee = require('./_baseIteratee'),
+    isArrayLike = require('./isArrayLike'),
+    keys = require('./keys');
+
+/**
+ * Creates a `_.find` or `_.findLast` function.
+ *
+ * @private
+ * @param {Function} findIndexFunc The function to find the collection index.
+ * @returns {Function} Returns the new find function.
+ */
+function createFind(findIndexFunc) {
+  return function(collection, predicate, fromIndex) {
+    var iterable = Object(collection);
+    if (!isArrayLike(collection)) {
+      var iteratee = baseIteratee(predicate, 3);
+      collection = keys(collection);
+      predicate = function(key) { return iteratee(iterable[key], key, iterable); };
+    }
+    var index = findIndexFunc(collection, predicate, fromIndex);
+    return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
+  };
+}
+
+module.exports = createFind;
diff --git a/parent_dir/node_modules/lodash/_defineProperty.js b/parent_dir/node_modules/lodash/_defineProperty.js
new file mode 100644
index 0000000..b6116d9
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_defineProperty.js
@@ -0,0 +1,11 @@
+var getNative = require('./_getNative');
+
+var defineProperty = (function() {
+  try {
+    var func = getNative(Object, 'defineProperty');
+    func({}, '', {});
+    return func;
+  } catch (e) {}
+}());
+
+module.exports = defineProperty;
diff --git a/parent_dir/node_modules/lodash/_equalArrays.js b/parent_dir/node_modules/lodash/_equalArrays.js
new file mode 100644
index 0000000..824228c
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_equalArrays.js
@@ -0,0 +1,84 @@
+var SetCache = require('./_SetCache'),
+    arraySome = require('./_arraySome'),
+    cacheHas = require('./_cacheHas');
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG = 1,
+    COMPARE_UNORDERED_FLAG = 2;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for arrays with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Array} array The array to compare.
+ * @param {Array} other The other array to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `array` and `other` objects.
+ * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
+ */
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
+      arrLength = array.length,
+      othLength = other.length;
+
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  // Check that cyclic values are equal.
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+  var index = -1,
+      result = true,
+      seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;
+
+  stack.set(array, other);
+  stack.set(other, array);
+
+  // Ignore non-index properties.
+  while (++index < arrLength) {
+    var arrValue = array[index],
+        othValue = other[index];
+
+    if (customizer) {
+      var compared = isPartial
+        ? customizer(othValue, arrValue, index, other, array, stack)
+        : customizer(arrValue, othValue, index, array, other, stack);
+    }
+    if (compared !== undefined) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    // Recursively compare arrays (susceptible to call stack limits).
+    if (seen) {
+      if (!arraySome(other, function(othValue, othIndex) {
+            if (!cacheHas(seen, othIndex) &&
+                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+              return seen.push(othIndex);
+            }
+          })) {
+        result = false;
+        break;
+      }
+    } else if (!(
+          arrValue === othValue ||
+            equalFunc(arrValue, othValue, bitmask, customizer, stack)
+        )) {
+      result = false;
+      break;
+    }
+  }
+  stack['delete'](array);
+  stack['delete'](other);
+  return result;
+}
+
+module.exports = equalArrays;
diff --git a/parent_dir/node_modules/lodash/_equalByTag.js b/parent_dir/node_modules/lodash/_equalByTag.js
new file mode 100644
index 0000000..71919e8
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_equalByTag.js
@@ -0,0 +1,112 @@
+var Symbol = require('./_Symbol'),
+    Uint8Array = require('./_Uint8Array'),
+    eq = require('./eq'),
+    equalArrays = require('./_equalArrays'),
+    mapToArray = require('./_mapToArray'),
+    setToArray = require('./_setToArray');
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG = 1,
+    COMPARE_UNORDERED_FLAG = 2;
+
+/** `Object#toString` result references. */
+var boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    symbolTag = '[object Symbol]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[object DataView]';
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : undefined,
+    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for comparing objects of
+ * the same `toStringTag`.
+ *
+ * **Note:** This function only supports comparing values with tags of
+ * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {string} tag The `toStringTag` of the objects to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag:
+      if ((object.byteLength != other.byteLength) ||
+          (object.byteOffset != other.byteOffset)) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+
+    case arrayBufferTag:
+      if ((object.byteLength != other.byteLength) ||
+          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+        return false;
+      }
+      return true;
+
+    case boolTag:
+    case dateTag:
+    case numberTag:
+      // Coerce booleans to `1` or `0` and dates to milliseconds.
+      // Invalid dates are coerced to `NaN`.
+      return eq(+object, +other);
+
+    case errorTag:
+      return object.name == other.name && object.message == other.message;
+
+    case regexpTag:
+    case stringTag:
+      // Coerce regexes to strings and treat strings, primitives and objects,
+      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
+      // for more details.
+      return object == (other + '');
+
+    case mapTag:
+      var convert = mapToArray;
+
+    case setTag:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+      convert || (convert = setToArray);
+
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      // Assume cyclic values are equal.
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG;
+
+      // Recursively compare objects (susceptible to call stack limits).
+      stack.set(object, other);
+      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack['delete'](object);
+      return result;
+
+    case symbolTag:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+
+module.exports = equalByTag;
diff --git a/parent_dir/node_modules/lodash/_equalObjects.js b/parent_dir/node_modules/lodash/_equalObjects.js
new file mode 100644
index 0000000..cdaacd2
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_equalObjects.js
@@ -0,0 +1,90 @@
+var getAllKeys = require('./_getAllKeys');
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG = 1;
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for objects with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
+      objProps = getAllKeys(object),
+      objLength = objProps.length,
+      othProps = getAllKeys(other),
+      othLength = othProps.length;
+
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+      return false;
+    }
+  }
+  // Check that cyclic values are equal.
+  var objStacked = stack.get(object);
+  var othStacked = stack.get(other);
+  if (objStacked && othStacked) {
+    return objStacked == other && othStacked == object;
+  }
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key],
+        othValue = other[key];
+
+    if (customizer) {
+      var compared = isPartial
+        ? customizer(othValue, objValue, key, other, object, stack)
+        : customizer(objValue, othValue, key, object, other, stack);
+    }
+    // Recursively compare objects (susceptible to call stack limits).
+    if (!(compared === undefined
+          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
+          : compared
+        )) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == 'constructor');
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor,
+        othCtor = other.constructor;
+
+    // Non `Object` object instances with different constructors are not equal.
+    if (objCtor != othCtor &&
+        ('constructor' in object && 'constructor' in other) &&
+        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
+          typeof othCtor == 'function' && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+  stack['delete'](object);
+  stack['delete'](other);
+  return result;
+}
+
+module.exports = equalObjects;
diff --git a/parent_dir/node_modules/lodash/_freeGlobal.js b/parent_dir/node_modules/lodash/_freeGlobal.js
new file mode 100644
index 0000000..bbec998
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_freeGlobal.js
@@ -0,0 +1,4 @@
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+
+module.exports = freeGlobal;
diff --git a/parent_dir/node_modules/lodash/_getAllKeys.js b/parent_dir/node_modules/lodash/_getAllKeys.js
new file mode 100644
index 0000000..a9ce699
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_getAllKeys.js
@@ -0,0 +1,16 @@
+var baseGetAllKeys = require('./_baseGetAllKeys'),
+    getSymbols = require('./_getSymbols'),
+    keys = require('./keys');
+
+/**
+ * Creates an array of own enumerable property names and symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function getAllKeys(object) {
+  return baseGetAllKeys(object, keys, getSymbols);
+}
+
+module.exports = getAllKeys;
diff --git a/parent_dir/node_modules/lodash/_getAllKeysIn.js b/parent_dir/node_modules/lodash/_getAllKeysIn.js
new file mode 100644
index 0000000..1b46678
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_getAllKeysIn.js
@@ -0,0 +1,17 @@
+var baseGetAllKeys = require('./_baseGetAllKeys'),
+    getSymbolsIn = require('./_getSymbolsIn'),
+    keysIn = require('./keysIn');
+
+/**
+ * Creates an array of own and inherited enumerable property names and
+ * symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function getAllKeysIn(object) {
+  return baseGetAllKeys(object, keysIn, getSymbolsIn);
+}
+
+module.exports = getAllKeysIn;
diff --git a/parent_dir/node_modules/lodash/_getMapData.js b/parent_dir/node_modules/lodash/_getMapData.js
new file mode 100644
index 0000000..17f6303
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_getMapData.js
@@ -0,0 +1,18 @@
+var isKeyable = require('./_isKeyable');
+
+/**
+ * Gets the data for `map`.
+ *
+ * @private
+ * @param {Object} map The map to query.
+ * @param {string} key The reference key.
+ * @returns {*} Returns the map data.
+ */
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable(key)
+    ? data[typeof key == 'string' ? 'string' : 'hash']
+    : data.map;
+}
+
+module.exports = getMapData;
diff --git a/parent_dir/node_modules/lodash/_getMatchData.js b/parent_dir/node_modules/lodash/_getMatchData.js
new file mode 100644
index 0000000..2cc70f9
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_getMatchData.js
@@ -0,0 +1,24 @@
+var isStrictComparable = require('./_isStrictComparable'),
+    keys = require('./keys');
+
+/**
+ * Gets the property names, values, and compare flags of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the match data of `object`.
+ */
+function getMatchData(object) {
+  var result = keys(object),
+      length = result.length;
+
+  while (length--) {
+    var key = result[length],
+        value = object[key];
+
+    result[length] = [key, value, isStrictComparable(value)];
+  }
+  return result;
+}
+
+module.exports = getMatchData;
diff --git a/parent_dir/node_modules/lodash/_getNative.js b/parent_dir/node_modules/lodash/_getNative.js
new file mode 100644
index 0000000..97a622b
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_getNative.js
@@ -0,0 +1,17 @@
+var baseIsNative = require('./_baseIsNative'),
+    getValue = require('./_getValue');
+
+/**
+ * Gets the native function at `key` of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the method to get.
+ * @returns {*} Returns the function if it's native, else `undefined`.
+ */
+function getNative(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : undefined;
+}
+
+module.exports = getNative;
diff --git a/parent_dir/node_modules/lodash/_getPrototype.js b/parent_dir/node_modules/lodash/_getPrototype.js
new file mode 100644
index 0000000..e808612
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_getPrototype.js
@@ -0,0 +1,6 @@
+var overArg = require('./_overArg');
+
+/** Built-in value references. */
+var getPrototype = overArg(Object.getPrototypeOf, Object);
+
+module.exports = getPrototype;
diff --git a/parent_dir/node_modules/lodash/_getRawTag.js b/parent_dir/node_modules/lodash/_getRawTag.js
new file mode 100644
index 0000000..49a95c9
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_getRawTag.js
@@ -0,0 +1,46 @@
+var Symbol = require('./_Symbol');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString = objectProto.toString;
+
+/** Built-in value references. */
+var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+/**
+ * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the raw `toStringTag`.
+ */
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag),
+      tag = value[symToStringTag];
+
+  try {
+    value[symToStringTag] = undefined;
+    var unmasked = true;
+  } catch (e) {}
+
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+
+module.exports = getRawTag;
diff --git a/parent_dir/node_modules/lodash/_getSymbols.js b/parent_dir/node_modules/lodash/_getSymbols.js
new file mode 100644
index 0000000..7d6eafe
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_getSymbols.js
@@ -0,0 +1,30 @@
+var arrayFilter = require('./_arrayFilter'),
+    stubArray = require('./stubArray');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+
+/**
+ * Creates an array of the own enumerable symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of symbols.
+ */
+var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+
+module.exports = getSymbols;
diff --git a/parent_dir/node_modules/lodash/_getSymbolsIn.js b/parent_dir/node_modules/lodash/_getSymbolsIn.js
new file mode 100644
index 0000000..cec0855
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_getSymbolsIn.js
@@ -0,0 +1,25 @@
+var arrayPush = require('./_arrayPush'),
+    getPrototype = require('./_getPrototype'),
+    getSymbols = require('./_getSymbols'),
+    stubArray = require('./stubArray');
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+
+/**
+ * Creates an array of the own and inherited enumerable symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of symbols.
+ */
+var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
+  var result = [];
+  while (object) {
+    arrayPush(result, getSymbols(object));
+    object = getPrototype(object);
+  }
+  return result;
+};
+
+module.exports = getSymbolsIn;
diff --git a/parent_dir/node_modules/lodash/_getTag.js b/parent_dir/node_modules/lodash/_getTag.js
new file mode 100644
index 0000000..deaf89d
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_getTag.js
@@ -0,0 +1,58 @@
+var DataView = require('./_DataView'),
+    Map = require('./_Map'),
+    Promise = require('./_Promise'),
+    Set = require('./_Set'),
+    WeakMap = require('./_WeakMap'),
+    baseGetTag = require('./_baseGetTag'),
+    toSource = require('./_toSource');
+
+/** `Object#toString` result references. */
+var mapTag = '[object Map]',
+    objectTag = '[object Object]',
+    promiseTag = '[object Promise]',
+    setTag = '[object Set]',
+    weakMapTag = '[object WeakMap]';
+
+var dataViewTag = '[object DataView]';
+
+/** Used to detect maps, sets, and weakmaps. */
+var dataViewCtorString = toSource(DataView),
+    mapCtorString = toSource(Map),
+    promiseCtorString = toSource(Promise),
+    setCtorString = toSource(Set),
+    weakMapCtorString = toSource(WeakMap);
+
+/**
+ * Gets the `toStringTag` of `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+var getTag = baseGetTag;
+
+// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
+if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
+    (Map && getTag(new Map) != mapTag) ||
+    (Promise && getTag(Promise.resolve()) != promiseTag) ||
+    (Set && getTag(new Set) != setTag) ||
+    (WeakMap && getTag(new WeakMap) != weakMapTag)) {
+  getTag = function(value) {
+    var result = baseGetTag(value),
+        Ctor = result == objectTag ? value.constructor : undefined,
+        ctorString = Ctor ? toSource(Ctor) : '';
+
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString: return dataViewTag;
+        case mapCtorString: return mapTag;
+        case promiseCtorString: return promiseTag;
+        case setCtorString: return setTag;
+        case weakMapCtorString: return weakMapTag;
+      }
+    }
+    return result;
+  };
+}
+
+module.exports = getTag;
diff --git a/parent_dir/node_modules/lodash/_getValue.js b/parent_dir/node_modules/lodash/_getValue.js
new file mode 100644
index 0000000..5f7d773
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_getValue.js
@@ -0,0 +1,13 @@
+/**
+ * Gets the value at `key` of `object`.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function getValue(object, key) {
+  return object == null ? undefined : object[key];
+}
+
+module.exports = getValue;
diff --git a/parent_dir/node_modules/lodash/_hasPath.js b/parent_dir/node_modules/lodash/_hasPath.js
new file mode 100644
index 0000000..93dbde1
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_hasPath.js
@@ -0,0 +1,39 @@
+var castPath = require('./_castPath'),
+    isArguments = require('./isArguments'),
+    isArray = require('./isArray'),
+    isIndex = require('./_isIndex'),
+    isLength = require('./isLength'),
+    toKey = require('./_toKey');
+
+/**
+ * Checks if `path` exists on `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @param {Function} hasFunc The function to check properties.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ */
+function hasPath(object, path, hasFunc) {
+  path = castPath(path, object);
+
+  var index = -1,
+      length = path.length,
+      result = false;
+
+  while (++index < length) {
+    var key = toKey(path[index]);
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+    object = object[key];
+  }
+  if (result || ++index != length) {
+    return result;
+  }
+  length = object == null ? 0 : object.length;
+  return !!length && isLength(length) && isIndex(key, length) &&
+    (isArray(object) || isArguments(object));
+}
+
+module.exports = hasPath;
diff --git a/parent_dir/node_modules/lodash/_hashClear.js b/parent_dir/node_modules/lodash/_hashClear.js
new file mode 100644
index 0000000..5d4b70c
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_hashClear.js
@@ -0,0 +1,15 @@
+var nativeCreate = require('./_nativeCreate');
+
+/**
+ * Removes all key-value entries from the hash.
+ *
+ * @private
+ * @name clear
+ * @memberOf Hash
+ */
+function hashClear() {
+  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+  this.size = 0;
+}
+
+module.exports = hashClear;
diff --git a/parent_dir/node_modules/lodash/_hashDelete.js b/parent_dir/node_modules/lodash/_hashDelete.js
new file mode 100644
index 0000000..ea9dabf
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_hashDelete.js
@@ -0,0 +1,17 @@
+/**
+ * Removes `key` and its value from the hash.
+ *
+ * @private
+ * @name delete
+ * @memberOf Hash
+ * @param {Object} hash The hash to modify.
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+
+module.exports = hashDelete;
diff --git a/parent_dir/node_modules/lodash/_hashGet.js b/parent_dir/node_modules/lodash/_hashGet.js
new file mode 100644
index 0000000..1fc2f34
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_hashGet.js
@@ -0,0 +1,30 @@
+var nativeCreate = require('./_nativeCreate');
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Gets the hash value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Hash
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? undefined : result;
+  }
+  return hasOwnProperty.call(data, key) ? data[key] : undefined;
+}
+
+module.exports = hashGet;
diff --git a/parent_dir/node_modules/lodash/_hashHas.js b/parent_dir/node_modules/lodash/_hashHas.js
new file mode 100644
index 0000000..281a551
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_hashHas.js
@@ -0,0 +1,23 @@
+var nativeCreate = require('./_nativeCreate');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Checks if a hash value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Hash
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
+}
+
+module.exports = hashHas;
diff --git a/parent_dir/node_modules/lodash/_hashSet.js b/parent_dir/node_modules/lodash/_hashSet.js
new file mode 100644
index 0000000..e105528
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_hashSet.js
@@ -0,0 +1,23 @@
+var nativeCreate = require('./_nativeCreate');
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/**
+ * Sets the hash `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Hash
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the hash instance.
+ */
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+  return this;
+}
+
+module.exports = hashSet;
diff --git a/parent_dir/node_modules/lodash/_initCloneArray.js b/parent_dir/node_modules/lodash/_initCloneArray.js
new file mode 100644
index 0000000..078c15a
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_initCloneArray.js
@@ -0,0 +1,26 @@
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Initializes an array clone.
+ *
+ * @private
+ * @param {Array} array The array to clone.
+ * @returns {Array} Returns the initialized clone.
+ */
+function initCloneArray(array) {
+  var length = array.length,
+      result = new array.constructor(length);
+
+  // Add properties assigned by `RegExp#exec`.
+  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
+    result.index = array.index;
+    result.input = array.input;
+  }
+  return result;
+}
+
+module.exports = initCloneArray;
diff --git a/parent_dir/node_modules/lodash/_initCloneByTag.js b/parent_dir/node_modules/lodash/_initCloneByTag.js
new file mode 100644
index 0000000..f69a008
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_initCloneByTag.js
@@ -0,0 +1,77 @@
+var cloneArrayBuffer = require('./_cloneArrayBuffer'),
+    cloneDataView = require('./_cloneDataView'),
+    cloneRegExp = require('./_cloneRegExp'),
+    cloneSymbol = require('./_cloneSymbol'),
+    cloneTypedArray = require('./_cloneTypedArray');
+
+/** `Object#toString` result references. */
+var boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    symbolTag = '[object Symbol]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[object DataView]',
+    float32Tag = '[object Float32Array]',
+    float64Tag = '[object Float64Array]',
+    int8Tag = '[object Int8Array]',
+    int16Tag = '[object Int16Array]',
+    int32Tag = '[object Int32Array]',
+    uint8Tag = '[object Uint8Array]',
+    uint8ClampedTag = '[object Uint8ClampedArray]',
+    uint16Tag = '[object Uint16Array]',
+    uint32Tag = '[object Uint32Array]';
+
+/**
+ * Initializes an object clone based on its `toStringTag`.
+ *
+ * **Note:** This function only supports cloning values with tags of
+ * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
+ *
+ * @private
+ * @param {Object} object The object to clone.
+ * @param {string} tag The `toStringTag` of the object to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the initialized clone.
+ */
+function initCloneByTag(object, tag, isDeep) {
+  var Ctor = object.constructor;
+  switch (tag) {
+    case arrayBufferTag:
+      return cloneArrayBuffer(object);
+
+    case boolTag:
+    case dateTag:
+      return new Ctor(+object);
+
+    case dataViewTag:
+      return cloneDataView(object, isDeep);
+
+    case float32Tag: case float64Tag:
+    case int8Tag: case int16Tag: case int32Tag:
+    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
+      return cloneTypedArray(object, isDeep);
+
+    case mapTag:
+      return new Ctor;
+
+    case numberTag:
+    case stringTag:
+      return new Ctor(object);
+
+    case regexpTag:
+      return cloneRegExp(object);
+
+    case setTag:
+      return new Ctor;
+
+    case symbolTag:
+      return cloneSymbol(object);
+  }
+}
+
+module.exports = initCloneByTag;
diff --git a/parent_dir/node_modules/lodash/_initCloneObject.js b/parent_dir/node_modules/lodash/_initCloneObject.js
new file mode 100644
index 0000000..5a13e64
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_initCloneObject.js
@@ -0,0 +1,18 @@
+var baseCreate = require('./_baseCreate'),
+    getPrototype = require('./_getPrototype'),
+    isPrototype = require('./_isPrototype');
+
+/**
+ * Initializes an object clone.
+ *
+ * @private
+ * @param {Object} object The object to clone.
+ * @returns {Object} Returns the initialized clone.
+ */
+function initCloneObject(object) {
+  return (typeof object.constructor == 'function' && !isPrototype(object))
+    ? baseCreate(getPrototype(object))
+    : {};
+}
+
+module.exports = initCloneObject;
diff --git a/parent_dir/node_modules/lodash/_isFlattenable.js b/parent_dir/node_modules/lodash/_isFlattenable.js
new file mode 100644
index 0000000..4cc2c24
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_isFlattenable.js
@@ -0,0 +1,20 @@
+var Symbol = require('./_Symbol'),
+    isArguments = require('./isArguments'),
+    isArray = require('./isArray');
+
+/** Built-in value references. */
+var spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;
+
+/**
+ * Checks if `value` is a flattenable `arguments` object or array.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
+ */
+function isFlattenable(value) {
+  return isArray(value) || isArguments(value) ||
+    !!(spreadableSymbol && value && value[spreadableSymbol]);
+}
+
+module.exports = isFlattenable;
diff --git a/parent_dir/node_modules/lodash/_isIndex.js b/parent_dir/node_modules/lodash/_isIndex.js
new file mode 100644
index 0000000..061cd39
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_isIndex.js
@@ -0,0 +1,25 @@
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER = 9007199254740991;
+
+/** Used to detect unsigned integer values. */
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+/**
+ * Checks if `value` is a valid array-like index.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+ * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+ */
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER : length;
+
+  return !!length &&
+    (type == 'number' ||
+      (type != 'symbol' && reIsUint.test(value))) &&
+        (value > -1 && value % 1 == 0 && value < length);
+}
+
+module.exports = isIndex;
diff --git a/parent_dir/node_modules/lodash/_isIterateeCall.js b/parent_dir/node_modules/lodash/_isIterateeCall.js
new file mode 100644
index 0000000..a0bb5a9
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_isIterateeCall.js
@@ -0,0 +1,30 @@
+var eq = require('./eq'),
+    isArrayLike = require('./isArrayLike'),
+    isIndex = require('./_isIndex'),
+    isObject = require('./isObject');
+
+/**
+ * Checks if the given arguments are from an iteratee call.
+ *
+ * @private
+ * @param {*} value The potential iteratee value argument.
+ * @param {*} index The potential iteratee index or key argument.
+ * @param {*} object The potential iteratee object argument.
+ * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
+ *  else `false`.
+ */
+function isIterateeCall(value, index, object) {
+  if (!isObject(object)) {
+    return false;
+  }
+  var type = typeof index;
+  if (type == 'number'
+        ? (isArrayLike(object) && isIndex(index, object.length))
+        : (type == 'string' && index in object)
+      ) {
+    return eq(object[index], value);
+  }
+  return false;
+}
+
+module.exports = isIterateeCall;
diff --git a/parent_dir/node_modules/lodash/_isKey.js b/parent_dir/node_modules/lodash/_isKey.js
new file mode 100644
index 0000000..ff08b06
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_isKey.js
@@ -0,0 +1,29 @@
+var isArray = require('./isArray'),
+    isSymbol = require('./isSymbol');
+
+/** Used to match property names within property paths. */
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
+    reIsPlainProp = /^\w*$/;
+
+/**
+ * Checks if `value` is a property name and not a property path.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ */
+function isKey(value, object) {
+  if (isArray(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == 'number' || type == 'symbol' || type == 'boolean' ||
+      value == null || isSymbol(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
+    (object != null && value in Object(object));
+}
+
+module.exports = isKey;
diff --git a/parent_dir/node_modules/lodash/_isKeyable.js b/parent_dir/node_modules/lodash/_isKeyable.js
new file mode 100644
index 0000000..39f1828
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_isKeyable.js
@@ -0,0 +1,15 @@
+/**
+ * Checks if `value` is suitable for use as unique object key.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+ */
+function isKeyable(value) {
+  var type = typeof value;
+  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+    ? (value !== '__proto__')
+    : (value === null);
+}
+
+module.exports = isKeyable;
diff --git a/parent_dir/node_modules/lodash/_isMasked.js b/parent_dir/node_modules/lodash/_isMasked.js
new file mode 100644
index 0000000..4b0f21b
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_isMasked.js
@@ -0,0 +1,20 @@
+var coreJsData = require('./_coreJsData');
+
+/** Used to detect methods masquerading as native. */
+var maskSrcKey = (function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+  return uid ? ('Symbol(src)_1.' + uid) : '';
+}());
+
+/**
+ * Checks if `func` has its source masked.
+ *
+ * @private
+ * @param {Function} func The function to check.
+ * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+ */
+function isMasked(func) {
+  return !!maskSrcKey && (maskSrcKey in func);
+}
+
+module.exports = isMasked;
diff --git a/parent_dir/node_modules/lodash/_isPrototype.js b/parent_dir/node_modules/lodash/_isPrototype.js
new file mode 100644
index 0000000..0f29498
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_isPrototype.js
@@ -0,0 +1,18 @@
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Checks if `value` is likely a prototype object.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+ */
+function isPrototype(value) {
+  var Ctor = value && value.constructor,
+      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+
+  return value === proto;
+}
+
+module.exports = isPrototype;
diff --git a/parent_dir/node_modules/lodash/_isStrictComparable.js b/parent_dir/node_modules/lodash/_isStrictComparable.js
new file mode 100644
index 0000000..b59f40b
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_isStrictComparable.js
@@ -0,0 +1,15 @@
+var isObject = require('./isObject');
+
+/**
+ * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` if suitable for strict
+ *  equality comparisons, else `false`.
+ */
+function isStrictComparable(value) {
+  return value === value && !isObject(value);
+}
+
+module.exports = isStrictComparable;
diff --git a/parent_dir/node_modules/lodash/_listCacheClear.js b/parent_dir/node_modules/lodash/_listCacheClear.js
new file mode 100644
index 0000000..acbe39a
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_listCacheClear.js
@@ -0,0 +1,13 @@
+/**
+ * Removes all key-value entries from the list cache.
+ *
+ * @private
+ * @name clear
+ * @memberOf ListCache
+ */
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+
+module.exports = listCacheClear;
diff --git a/parent_dir/node_modules/lodash/_listCacheDelete.js b/parent_dir/node_modules/lodash/_listCacheDelete.js
new file mode 100644
index 0000000..b1384ad
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_listCacheDelete.js
@@ -0,0 +1,35 @@
+var assocIndexOf = require('./_assocIndexOf');
+
+/** Used for built-in method references. */
+var arrayProto = Array.prototype;
+
+/** Built-in value references. */
+var splice = arrayProto.splice;
+
+/**
+ * Removes `key` and its value from the list cache.
+ *
+ * @private
+ * @name delete
+ * @memberOf ListCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function listCacheDelete(key) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+
+module.exports = listCacheDelete;
diff --git a/parent_dir/node_modules/lodash/_listCacheGet.js b/parent_dir/node_modules/lodash/_listCacheGet.js
new file mode 100644
index 0000000..f8192fc
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_listCacheGet.js
@@ -0,0 +1,19 @@
+var assocIndexOf = require('./_assocIndexOf');
+
+/**
+ * Gets the list cache value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf ListCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function listCacheGet(key) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  return index < 0 ? undefined : data[index][1];
+}
+
+module.exports = listCacheGet;
diff --git a/parent_dir/node_modules/lodash/_listCacheHas.js b/parent_dir/node_modules/lodash/_listCacheHas.js
new file mode 100644
index 0000000..2adf671
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_listCacheHas.js
@@ -0,0 +1,16 @@
+var assocIndexOf = require('./_assocIndexOf');
+
+/**
+ * Checks if a list cache value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf ListCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function listCacheHas(key) {
+  return assocIndexOf(this.__data__, key) > -1;
+}
+
+module.exports = listCacheHas;
diff --git a/parent_dir/node_modules/lodash/_listCacheSet.js b/parent_dir/node_modules/lodash/_listCacheSet.js
new file mode 100644
index 0000000..5855c95
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_listCacheSet.js
@@ -0,0 +1,26 @@
+var assocIndexOf = require('./_assocIndexOf');
+
+/**
+ * Sets the list cache `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf ListCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the list cache instance.
+ */
+function listCacheSet(key, value) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+
+module.exports = listCacheSet;
diff --git a/parent_dir/node_modules/lodash/_mapCacheClear.js b/parent_dir/node_modules/lodash/_mapCacheClear.js
new file mode 100644
index 0000000..bc9ca20
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_mapCacheClear.js
@@ -0,0 +1,21 @@
+var Hash = require('./_Hash'),
+    ListCache = require('./_ListCache'),
+    Map = require('./_Map');
+
+/**
+ * Removes all key-value entries from the map.
+ *
+ * @private
+ * @name clear
+ * @memberOf MapCache
+ */
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    'hash': new Hash,
+    'map': new (Map || ListCache),
+    'string': new Hash
+  };
+}
+
+module.exports = mapCacheClear;
diff --git a/parent_dir/node_modules/lodash/_mapCacheDelete.js b/parent_dir/node_modules/lodash/_mapCacheDelete.js
new file mode 100644
index 0000000..946ca3c
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_mapCacheDelete.js
@@ -0,0 +1,18 @@
+var getMapData = require('./_getMapData');
+
+/**
+ * Removes `key` and its value from the map.
+ *
+ * @private
+ * @name delete
+ * @memberOf MapCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function mapCacheDelete(key) {
+  var result = getMapData(this, key)['delete'](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+
+module.exports = mapCacheDelete;
diff --git a/parent_dir/node_modules/lodash/_mapCacheGet.js b/parent_dir/node_modules/lodash/_mapCacheGet.js
new file mode 100644
index 0000000..f29f55c
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_mapCacheGet.js
@@ -0,0 +1,16 @@
+var getMapData = require('./_getMapData');
+
+/**
+ * Gets the map value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf MapCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function mapCacheGet(key) {
+  return getMapData(this, key).get(key);
+}
+
+module.exports = mapCacheGet;
diff --git a/parent_dir/node_modules/lodash/_mapCacheHas.js b/parent_dir/node_modules/lodash/_mapCacheHas.js
new file mode 100644
index 0000000..a1214c0
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_mapCacheHas.js
@@ -0,0 +1,16 @@
+var getMapData = require('./_getMapData');
+
+/**
+ * Checks if a map value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf MapCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function mapCacheHas(key) {
+  return getMapData(this, key).has(key);
+}
+
+module.exports = mapCacheHas;
diff --git a/parent_dir/node_modules/lodash/_mapCacheSet.js b/parent_dir/node_modules/lodash/_mapCacheSet.js
new file mode 100644
index 0000000..7346849
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_mapCacheSet.js
@@ -0,0 +1,22 @@
+var getMapData = require('./_getMapData');
+
+/**
+ * Sets the map `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf MapCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the map cache instance.
+ */
+function mapCacheSet(key, value) {
+  var data = getMapData(this, key),
+      size = data.size;
+
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+
+module.exports = mapCacheSet;
diff --git a/parent_dir/node_modules/lodash/_mapToArray.js b/parent_dir/node_modules/lodash/_mapToArray.js
new file mode 100644
index 0000000..fe3dd53
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_mapToArray.js
@@ -0,0 +1,18 @@
+/**
+ * Converts `map` to its key-value pairs.
+ *
+ * @private
+ * @param {Object} map The map to convert.
+ * @returns {Array} Returns the key-value pairs.
+ */
+function mapToArray(map) {
+  var index = -1,
+      result = Array(map.size);
+
+  map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+
+module.exports = mapToArray;
diff --git a/parent_dir/node_modules/lodash/_matchesStrictComparable.js b/parent_dir/node_modules/lodash/_matchesStrictComparable.js
new file mode 100644
index 0000000..f608af9
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_matchesStrictComparable.js
@@ -0,0 +1,20 @@
+/**
+ * A specialized version of `matchesProperty` for source values suitable
+ * for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function matchesStrictComparable(key, srcValue) {
+  return function(object) {
+    if (object == null) {
+      return false;
+    }
+    return object[key] === srcValue &&
+      (srcValue !== undefined || (key in Object(object)));
+  };
+}
+
+module.exports = matchesStrictComparable;
diff --git a/parent_dir/node_modules/lodash/_memoizeCapped.js b/parent_dir/node_modules/lodash/_memoizeCapped.js
new file mode 100644
index 0000000..7f71c8f
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_memoizeCapped.js
@@ -0,0 +1,26 @@
+var memoize = require('./memoize');
+
+/** Used as the maximum memoize cache size. */
+var MAX_MEMOIZE_SIZE = 500;
+
+/**
+ * A specialized version of `_.memoize` which clears the memoized function's
+ * cache when it exceeds `MAX_MEMOIZE_SIZE`.
+ *
+ * @private
+ * @param {Function} func The function to have its output memoized.
+ * @returns {Function} Returns the new memoized function.
+ */
+function memoizeCapped(func) {
+  var result = memoize(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+
+  var cache = result.cache;
+  return result;
+}
+
+module.exports = memoizeCapped;
diff --git a/parent_dir/node_modules/lodash/_nativeCreate.js b/parent_dir/node_modules/lodash/_nativeCreate.js
new file mode 100644
index 0000000..c7aede8
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_nativeCreate.js
@@ -0,0 +1,6 @@
+var getNative = require('./_getNative');
+
+/* Built-in method references that are verified to be native. */
+var nativeCreate = getNative(Object, 'create');
+
+module.exports = nativeCreate;
diff --git a/parent_dir/node_modules/lodash/_nativeKeys.js b/parent_dir/node_modules/lodash/_nativeKeys.js
new file mode 100644
index 0000000..479a104
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_nativeKeys.js
@@ -0,0 +1,6 @@
+var overArg = require('./_overArg');
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeKeys = overArg(Object.keys, Object);
+
+module.exports = nativeKeys;
diff --git a/parent_dir/node_modules/lodash/_nativeKeysIn.js b/parent_dir/node_modules/lodash/_nativeKeysIn.js
new file mode 100644
index 0000000..00ee505
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_nativeKeysIn.js
@@ -0,0 +1,20 @@
+/**
+ * This function is like
+ * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * except that it includes inherited enumerable properties.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function nativeKeysIn(object) {
+  var result = [];
+  if (object != null) {
+    for (var key in Object(object)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+module.exports = nativeKeysIn;
diff --git a/parent_dir/node_modules/lodash/_nodeUtil.js b/parent_dir/node_modules/lodash/_nodeUtil.js
new file mode 100644
index 0000000..983d78f
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_nodeUtil.js
@@ -0,0 +1,30 @@
+var freeGlobal = require('./_freeGlobal');
+
+/** Detect free variable `exports`. */
+var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/** Detect free variable `process` from Node.js. */
+var freeProcess = moduleExports && freeGlobal.process;
+
+/** Used to access faster Node.js helpers. */
+var nodeUtil = (function() {
+  try {
+    // Use `util.types` for Node.js 10+.
+    var types = freeModule && freeModule.require && freeModule.require('util').types;
+
+    if (types) {
+      return types;
+    }
+
+    // Legacy `process.binding('util')` for Node.js < 10.
+    return freeProcess && freeProcess.binding && freeProcess.binding('util');
+  } catch (e) {}
+}());
+
+module.exports = nodeUtil;
diff --git a/parent_dir/node_modules/lodash/_objectToString.js b/parent_dir/node_modules/lodash/_objectToString.js
new file mode 100644
index 0000000..c614ec0
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_objectToString.js
@@ -0,0 +1,22 @@
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString = objectProto.toString;
+
+/**
+ * Converts `value` to a string using `Object.prototype.toString`.
+ *
+ * @private
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ */
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+
+module.exports = objectToString;
diff --git a/parent_dir/node_modules/lodash/_overArg.js b/parent_dir/node_modules/lodash/_overArg.js
new file mode 100644
index 0000000..651c5c5
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_overArg.js
@@ -0,0 +1,15 @@
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+
+module.exports = overArg;
diff --git a/parent_dir/node_modules/lodash/_overRest.js b/parent_dir/node_modules/lodash/_overRest.js
new file mode 100644
index 0000000..c7cdef3
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_overRest.js
@@ -0,0 +1,36 @@
+var apply = require('./_apply');
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;
+
+/**
+ * A specialized version of `baseRest` which transforms the rest array.
+ *
+ * @private
+ * @param {Function} func The function to apply a rest parameter to.
+ * @param {number} [start=func.length-1] The start position of the rest parameter.
+ * @param {Function} transform The rest array transform.
+ * @returns {Function} Returns the new function.
+ */
+function overRest(func, start, transform) {
+  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
+  return function() {
+    var args = arguments,
+        index = -1,
+        length = nativeMax(args.length - start, 0),
+        array = Array(length);
+
+    while (++index < length) {
+      array[index] = args[start + index];
+    }
+    index = -1;
+    var otherArgs = Array(start + 1);
+    while (++index < start) {
+      otherArgs[index] = args[index];
+    }
+    otherArgs[start] = transform(array);
+    return apply(func, this, otherArgs);
+  };
+}
+
+module.exports = overRest;
diff --git a/parent_dir/node_modules/lodash/_root.js b/parent_dir/node_modules/lodash/_root.js
new file mode 100644
index 0000000..d2852be
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_root.js
@@ -0,0 +1,9 @@
+var freeGlobal = require('./_freeGlobal');
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root = freeGlobal || freeSelf || Function('return this')();
+
+module.exports = root;
diff --git a/parent_dir/node_modules/lodash/_safeGet.js b/parent_dir/node_modules/lodash/_safeGet.js
new file mode 100644
index 0000000..b070897
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_safeGet.js
@@ -0,0 +1,21 @@
+/**
+ * Gets the value at `key`, unless `key` is "__proto__" or "constructor".
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function safeGet(object, key) {
+  if (key === 'constructor' && typeof object[key] === 'function') {
+    return;
+  }
+
+  if (key == '__proto__') {
+    return;
+  }
+
+  return object[key];
+}
+
+module.exports = safeGet;
diff --git a/parent_dir/node_modules/lodash/_setCacheAdd.js b/parent_dir/node_modules/lodash/_setCacheAdd.js
new file mode 100644
index 0000000..1081a74
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_setCacheAdd.js
@@ -0,0 +1,19 @@
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/**
+ * Adds `value` to the array cache.
+ *
+ * @private
+ * @name add
+ * @memberOf SetCache
+ * @alias push
+ * @param {*} value The value to cache.
+ * @returns {Object} Returns the cache instance.
+ */
+function setCacheAdd(value) {
+  this.__data__.set(value, HASH_UNDEFINED);
+  return this;
+}
+
+module.exports = setCacheAdd;
diff --git a/parent_dir/node_modules/lodash/_setCacheHas.js b/parent_dir/node_modules/lodash/_setCacheHas.js
new file mode 100644
index 0000000..9a49255
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_setCacheHas.js
@@ -0,0 +1,14 @@
+/**
+ * Checks if `value` is in the array cache.
+ *
+ * @private
+ * @name has
+ * @memberOf SetCache
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `true` if `value` is found, else `false`.
+ */
+function setCacheHas(value) {
+  return this.__data__.has(value);
+}
+
+module.exports = setCacheHas;
diff --git a/parent_dir/node_modules/lodash/_setToArray.js b/parent_dir/node_modules/lodash/_setToArray.js
new file mode 100644
index 0000000..b87f074
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_setToArray.js
@@ -0,0 +1,18 @@
+/**
+ * Converts `set` to an array of its values.
+ *
+ * @private
+ * @param {Object} set The set to convert.
+ * @returns {Array} Returns the values.
+ */
+function setToArray(set) {
+  var index = -1,
+      result = Array(set.size);
+
+  set.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+
+module.exports = setToArray;
diff --git a/parent_dir/node_modules/lodash/_setToString.js b/parent_dir/node_modules/lodash/_setToString.js
new file mode 100644
index 0000000..6ca8419
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_setToString.js
@@ -0,0 +1,14 @@
+var baseSetToString = require('./_baseSetToString'),
+    shortOut = require('./_shortOut');
+
+/**
+ * Sets the `toString` method of `func` to return `string`.
+ *
+ * @private
+ * @param {Function} func The function to modify.
+ * @param {Function} string The `toString` result.
+ * @returns {Function} Returns `func`.
+ */
+var setToString = shortOut(baseSetToString);
+
+module.exports = setToString;
diff --git a/parent_dir/node_modules/lodash/_shortOut.js b/parent_dir/node_modules/lodash/_shortOut.js
new file mode 100644
index 0000000..3300a07
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_shortOut.js
@@ -0,0 +1,37 @@
+/** Used to detect hot functions by number of calls within a span of milliseconds. */
+var HOT_COUNT = 800,
+    HOT_SPAN = 16;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeNow = Date.now;
+
+/**
+ * Creates a function that'll short out and invoke `identity` instead
+ * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
+ * milliseconds.
+ *
+ * @private
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new shortable function.
+ */
+function shortOut(func) {
+  var count = 0,
+      lastCalled = 0;
+
+  return function() {
+    var stamp = nativeNow(),
+        remaining = HOT_SPAN - (stamp - lastCalled);
+
+    lastCalled = stamp;
+    if (remaining > 0) {
+      if (++count >= HOT_COUNT) {
+        return arguments[0];
+      }
+    } else {
+      count = 0;
+    }
+    return func.apply(undefined, arguments);
+  };
+}
+
+module.exports = shortOut;
diff --git a/parent_dir/node_modules/lodash/_stackClear.js b/parent_dir/node_modules/lodash/_stackClear.js
new file mode 100644
index 0000000..ce8e5a9
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_stackClear.js
@@ -0,0 +1,15 @@
+var ListCache = require('./_ListCache');
+
+/**
+ * Removes all key-value entries from the stack.
+ *
+ * @private
+ * @name clear
+ * @memberOf Stack
+ */
+function stackClear() {
+  this.__data__ = new ListCache;
+  this.size = 0;
+}
+
+module.exports = stackClear;
diff --git a/parent_dir/node_modules/lodash/_stackDelete.js b/parent_dir/node_modules/lodash/_stackDelete.js
new file mode 100644
index 0000000..ff9887a
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_stackDelete.js
@@ -0,0 +1,18 @@
+/**
+ * Removes `key` and its value from the stack.
+ *
+ * @private
+ * @name delete
+ * @memberOf Stack
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function stackDelete(key) {
+  var data = this.__data__,
+      result = data['delete'](key);
+
+  this.size = data.size;
+  return result;
+}
+
+module.exports = stackDelete;
diff --git a/parent_dir/node_modules/lodash/_stackGet.js b/parent_dir/node_modules/lodash/_stackGet.js
new file mode 100644
index 0000000..1cdf004
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_stackGet.js
@@ -0,0 +1,14 @@
+/**
+ * Gets the stack value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Stack
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+
+module.exports = stackGet;
diff --git a/parent_dir/node_modules/lodash/_stackHas.js b/parent_dir/node_modules/lodash/_stackHas.js
new file mode 100644
index 0000000..16a3ad1
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_stackHas.js
@@ -0,0 +1,14 @@
+/**
+ * Checks if a stack value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Stack
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+
+module.exports = stackHas;
diff --git a/parent_dir/node_modules/lodash/_stackSet.js b/parent_dir/node_modules/lodash/_stackSet.js
new file mode 100644
index 0000000..b790ac5
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_stackSet.js
@@ -0,0 +1,34 @@
+var ListCache = require('./_ListCache'),
+    Map = require('./_Map'),
+    MapCache = require('./_MapCache');
+
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+
+/**
+ * Sets the stack `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Stack
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the stack cache instance.
+ */
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache) {
+    var pairs = data.__data__;
+    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+
+module.exports = stackSet;
diff --git a/parent_dir/node_modules/lodash/_stringToPath.js b/parent_dir/node_modules/lodash/_stringToPath.js
new file mode 100644
index 0000000..8f39f8a
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_stringToPath.js
@@ -0,0 +1,27 @@
+var memoizeCapped = require('./_memoizeCapped');
+
+/** Used to match property names within property paths. */
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+
+/** Used to match backslashes in property paths. */
+var reEscapeChar = /\\(\\)?/g;
+
+/**
+ * Converts `string` to a property path array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the property path array.
+ */
+var stringToPath = memoizeCapped(function(string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46 /* . */) {
+    result.push('');
+  }
+  string.replace(rePropName, function(match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
+  });
+  return result;
+});
+
+module.exports = stringToPath;
diff --git a/parent_dir/node_modules/lodash/_toKey.js b/parent_dir/node_modules/lodash/_toKey.js
new file mode 100644
index 0000000..c6d645c
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_toKey.js
@@ -0,0 +1,21 @@
+var isSymbol = require('./isSymbol');
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/**
+ * Converts `value` to a string key if it's not a string or symbol.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {string|symbol} Returns the key.
+ */
+function toKey(value) {
+  if (typeof value == 'string' || isSymbol(value)) {
+    return value;
+  }
+  var result = (value + '');
+  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+}
+
+module.exports = toKey;
diff --git a/parent_dir/node_modules/lodash/_toSource.js b/parent_dir/node_modules/lodash/_toSource.js
new file mode 100644
index 0000000..a020b38
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_toSource.js
@@ -0,0 +1,26 @@
+/** Used for built-in method references. */
+var funcProto = Function.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to convert.
+ * @returns {string} Returns the source code.
+ */
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {}
+    try {
+      return (func + '');
+    } catch (e) {}
+  }
+  return '';
+}
+
+module.exports = toSource;
diff --git a/parent_dir/node_modules/lodash/_trimmedEndIndex.js b/parent_dir/node_modules/lodash/_trimmedEndIndex.js
new file mode 100644
index 0000000..139439a
--- /dev/null
+++ b/parent_dir/node_modules/lodash/_trimmedEndIndex.js
@@ -0,0 +1,19 @@
+/** Used to match a single whitespace character. */
+var reWhitespace = /\s/;
+
+/**
+ * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
+ * character of `string`.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {number} Returns the index of the last non-whitespace character.
+ */
+function trimmedEndIndex(string) {
+  var index = string.length;
+
+  while (index-- && reWhitespace.test(string.charAt(index))) {}
+  return index;
+}
+
+module.exports = trimmedEndIndex;
diff --git a/parent_dir/node_modules/lodash/cloneDeep.js b/parent_dir/node_modules/lodash/cloneDeep.js
new file mode 100644
index 0000000..4425fbe
--- /dev/null
+++ b/parent_dir/node_modules/lodash/cloneDeep.js
@@ -0,0 +1,29 @@
+var baseClone = require('./_baseClone');
+
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1,
+    CLONE_SYMBOLS_FLAG = 4;
+
+/**
+ * This method is like `_.clone` except that it recursively clones `value`.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.0.0
+ * @category Lang
+ * @param {*} value The value to recursively clone.
+ * @returns {*} Returns the deep cloned value.
+ * @see _.clone
+ * @example
+ *
+ * var objects = [{ 'a': 1 }, { 'b': 2 }];
+ *
+ * var deep = _.cloneDeep(objects);
+ * console.log(deep[0] === objects[0]);
+ * // => false
+ */
+function cloneDeep(value) {
+  return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
+}
+
+module.exports = cloneDeep;
diff --git a/parent_dir/node_modules/lodash/constant.js b/parent_dir/node_modules/lodash/constant.js
new file mode 100644
index 0000000..655ece3
--- /dev/null
+++ b/parent_dir/node_modules/lodash/constant.js
@@ -0,0 +1,26 @@
+/**
+ * Creates a function that returns `value`.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Util
+ * @param {*} value The value to return from the new function.
+ * @returns {Function} Returns the new constant function.
+ * @example
+ *
+ * var objects = _.times(2, _.constant({ 'a': 1 }));
+ *
+ * console.log(objects);
+ * // => [{ 'a': 1 }, { 'a': 1 }]
+ *
+ * console.log(objects[0] === objects[1]);
+ * // => true
+ */
+function constant(value) {
+  return function() {
+    return value;
+  };
+}
+
+module.exports = constant;
diff --git a/parent_dir/node_modules/lodash/debounce.js b/parent_dir/node_modules/lodash/debounce.js
new file mode 100644
index 0000000..8f751d5
--- /dev/null
+++ b/parent_dir/node_modules/lodash/debounce.js
@@ -0,0 +1,191 @@
+var isObject = require('./isObject'),
+    now = require('./now'),
+    toNumber = require('./toNumber');
+
+/** Error message constants. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max,
+    nativeMin = Math.min;
+
+/**
+ * Creates a debounced function that delays invoking `func` until after `wait`
+ * milliseconds have elapsed since the last time the debounced function was
+ * invoked. The debounced function comes with a `cancel` method to cancel
+ * delayed `func` invocations and a `flush` method to immediately invoke them.
+ * Provide `options` to indicate whether `func` should be invoked on the
+ * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
+ * with the last arguments provided to the debounced function. Subsequent
+ * calls to the debounced function return the result of the last `func`
+ * invocation.
+ *
+ * **Note:** If `leading` and `trailing` options are `true`, `func` is
+ * invoked on the trailing edge of the timeout only if the debounced function
+ * is invoked more than once during the `wait` timeout.
+ *
+ * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+ * until to the next tick, similar to `setTimeout` with a timeout of `0`.
+ *
+ * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+ * for details over the differences between `_.debounce` and `_.throttle`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to debounce.
+ * @param {number} [wait=0] The number of milliseconds to delay.
+ * @param {Object} [options={}] The options object.
+ * @param {boolean} [options.leading=false]
+ *  Specify invoking on the leading edge of the timeout.
+ * @param {number} [options.maxWait]
+ *  The maximum time `func` is allowed to be delayed before it's invoked.
+ * @param {boolean} [options.trailing=true]
+ *  Specify invoking on the trailing edge of the timeout.
+ * @returns {Function} Returns the new debounced function.
+ * @example
+ *
+ * // Avoid costly calculations while the window size is in flux.
+ * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
+ *
+ * // Invoke `sendMail` when clicked, debouncing subsequent calls.
+ * jQuery(element).on('click', _.debounce(sendMail, 300, {
+ *   'leading': true,
+ *   'trailing': false
+ * }));
+ *
+ * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
+ * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
+ * var source = new EventSource('/stream');
+ * jQuery(source).on('message', debounced);
+ *
+ * // Cancel the trailing debounced invocation.
+ * jQuery(window).on('popstate', debounced.cancel);
+ */
+function debounce(func, wait, options) {
+  var lastArgs,
+      lastThis,
+      maxWait,
+      result,
+      timerId,
+      lastCallTime,
+      lastInvokeTime = 0,
+      leading = false,
+      maxing = false,
+      trailing = true;
+
+  if (typeof func != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  wait = toNumber(wait) || 0;
+  if (isObject(options)) {
+    leading = !!options.leading;
+    maxing = 'maxWait' in options;
+    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+    trailing = 'trailing' in options ? !!options.trailing : trailing;
+  }
+
+  function invokeFunc(time) {
+    var args = lastArgs,
+        thisArg = lastThis;
+
+    lastArgs = lastThis = undefined;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+
+  function leadingEdge(time) {
+    // Reset any `maxWait` timer.
+    lastInvokeTime = time;
+    // Start the timer for the trailing edge.
+    timerId = setTimeout(timerExpired, wait);
+    // Invoke the leading edge.
+    return leading ? invokeFunc(time) : result;
+  }
+
+  function remainingWait(time) {
+    var timeSinceLastCall = time - lastCallTime,
+        timeSinceLastInvoke = time - lastInvokeTime,
+        timeWaiting = wait - timeSinceLastCall;
+
+    return maxing
+      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
+      : timeWaiting;
+  }
+
+  function shouldInvoke(time) {
+    var timeSinceLastCall = time - lastCallTime,
+        timeSinceLastInvoke = time - lastInvokeTime;
+
+    // Either this is the first call, activity has stopped and we're at the
+    // trailing edge, the system time has gone backwards and we're treating
+    // it as the trailing edge, or we've hit the `maxWait` limit.
+    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
+      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
+  }
+
+  function timerExpired() {
+    var time = now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    // Restart the timer.
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+
+  function trailingEdge(time) {
+    timerId = undefined;
+
+    // Only invoke if we have `lastArgs` which means `func` has been
+    // debounced at least once.
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = undefined;
+    return result;
+  }
+
+  function cancel() {
+    if (timerId !== undefined) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = undefined;
+  }
+
+  function flush() {
+    return timerId === undefined ? result : trailingEdge(now());
+  }
+
+  function debounced() {
+    var time = now(),
+        isInvoking = shouldInvoke(time);
+
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+
+    if (isInvoking) {
+      if (timerId === undefined) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        // Handle invocations in a tight loop.
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === undefined) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+
+module.exports = debounce;
diff --git a/parent_dir/node_modules/lodash/eq.js b/parent_dir/node_modules/lodash/eq.js
new file mode 100644
index 0000000..a940688
--- /dev/null
+++ b/parent_dir/node_modules/lodash/eq.js
@@ -0,0 +1,37 @@
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+function eq(value, other) {
+  return value === other || (value !== value && other !== other);
+}
+
+module.exports = eq;
diff --git a/parent_dir/node_modules/lodash/find.js b/parent_dir/node_modules/lodash/find.js
new file mode 100644
index 0000000..de732cc
--- /dev/null
+++ b/parent_dir/node_modules/lodash/find.js
@@ -0,0 +1,42 @@
+var createFind = require('./_createFind'),
+    findIndex = require('./findIndex');
+
+/**
+ * Iterates over elements of `collection`, returning the first element
+ * `predicate` returns truthy for. The predicate is invoked with three
+ * arguments: (value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to inspect.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {*} Returns the matched element, else `undefined`.
+ * @example
+ *
+ * var users = [
+ *   { 'user': 'barney',  'age': 36, 'active': true },
+ *   { 'user': 'fred',    'age': 40, 'active': false },
+ *   { 'user': 'pebbles', 'age': 1,  'active': true }
+ * ];
+ *
+ * _.find(users, function(o) { return o.age < 40; });
+ * // => object for 'barney'
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.find(users, { 'age': 1, 'active': true });
+ * // => object for 'pebbles'
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.find(users, ['active', false]);
+ * // => object for 'fred'
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.find(users, 'active');
+ * // => object for 'barney'
+ */
+var find = createFind(findIndex);
+
+module.exports = find;
diff --git a/parent_dir/node_modules/lodash/findIndex.js b/parent_dir/node_modules/lodash/findIndex.js
new file mode 100644
index 0000000..4689069
--- /dev/null
+++ b/parent_dir/node_modules/lodash/findIndex.js
@@ -0,0 +1,55 @@
+var baseFindIndex = require('./_baseFindIndex'),
+    baseIteratee = require('./_baseIteratee'),
+    toInteger = require('./toInteger');
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;
+
+/**
+ * This method is like `_.find` except that it returns the index of the first
+ * element `predicate` returns truthy for instead of the element itself.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.1.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {number} Returns the index of the found element, else `-1`.
+ * @example
+ *
+ * var users = [
+ *   { 'user': 'barney',  'active': false },
+ *   { 'user': 'fred',    'active': false },
+ *   { 'user': 'pebbles', 'active': true }
+ * ];
+ *
+ * _.findIndex(users, function(o) { return o.user == 'barney'; });
+ * // => 0
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.findIndex(users, { 'user': 'fred', 'active': false });
+ * // => 1
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.findIndex(users, ['active', false]);
+ * // => 0
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.findIndex(users, 'active');
+ * // => 2
+ */
+function findIndex(array, predicate, fromIndex) {
+  var length = array == null ? 0 : array.length;
+  if (!length) {
+    return -1;
+  }
+  var index = fromIndex == null ? 0 : toInteger(fromIndex);
+  if (index < 0) {
+    index = nativeMax(length + index, 0);
+  }
+  return baseFindIndex(array, baseIteratee(predicate, 3), index);
+}
+
+module.exports = findIndex;
diff --git a/parent_dir/node_modules/lodash/get.js b/parent_dir/node_modules/lodash/get.js
new file mode 100644
index 0000000..8805ff9
--- /dev/null
+++ b/parent_dir/node_modules/lodash/get.js
@@ -0,0 +1,33 @@
+var baseGet = require('./_baseGet');
+
+/**
+ * Gets the value at `path` of `object`. If the resolved value is
+ * `undefined`, the `defaultValue` is returned in its place.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.7.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * _.get(object, 'a[0].b.c');
+ * // => 3
+ *
+ * _.get(object, ['a', '0', 'b', 'c']);
+ * // => 3
+ *
+ * _.get(object, 'a.b.c', 'default');
+ * // => 'default'
+ */
+function get(object, path, defaultValue) {
+  var result = object == null ? undefined : baseGet(object, path);
+  return result === undefined ? defaultValue : result;
+}
+
+module.exports = get;
diff --git a/parent_dir/node_modules/lodash/groupBy.js b/parent_dir/node_modules/lodash/groupBy.js
new file mode 100644
index 0000000..babf4f6
--- /dev/null
+++ b/parent_dir/node_modules/lodash/groupBy.js
@@ -0,0 +1,41 @@
+var baseAssignValue = require('./_baseAssignValue'),
+    createAggregator = require('./_createAggregator');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` thru `iteratee`. The order of grouped values
+ * is determined by the order they occur in `collection`. The corresponding
+ * value of each key is an array of elements responsible for generating the
+ * key. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * _.groupBy([6.1, 4.2, 6.3], Math.floor);
+ * // => { '4': [4.2], '6': [6.1, 6.3] }
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.groupBy(['one', 'two', 'three'], 'length');
+ * // => { '3': ['one', 'two'], '5': ['three'] }
+ */
+var groupBy = createAggregator(function(result, value, key) {
+  if (hasOwnProperty.call(result, key)) {
+    result[key].push(value);
+  } else {
+    baseAssignValue(result, key, [value]);
+  }
+});
+
+module.exports = groupBy;
diff --git a/parent_dir/node_modules/lodash/hasIn.js b/parent_dir/node_modules/lodash/hasIn.js
new file mode 100644
index 0000000..06a3686
--- /dev/null
+++ b/parent_dir/node_modules/lodash/hasIn.js
@@ -0,0 +1,34 @@
+var baseHasIn = require('./_baseHasIn'),
+    hasPath = require('./_hasPath');
+
+/**
+ * Checks if `path` is a direct or inherited property of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.hasIn(object, 'a');
+ * // => true
+ *
+ * _.hasIn(object, 'a.b');
+ * // => true
+ *
+ * _.hasIn(object, ['a', 'b']);
+ * // => true
+ *
+ * _.hasIn(object, 'b');
+ * // => false
+ */
+function hasIn(object, path) {
+  return object != null && hasPath(object, path, baseHasIn);
+}
+
+module.exports = hasIn;
diff --git a/parent_dir/node_modules/lodash/identity.js b/parent_dir/node_modules/lodash/identity.js
new file mode 100644
index 0000000..2d5d963
--- /dev/null
+++ b/parent_dir/node_modules/lodash/identity.js
@@ -0,0 +1,21 @@
+/**
+ * This method returns the first argument it receives.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Util
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ *
+ * console.log(_.identity(object) === object);
+ * // => true
+ */
+function identity(value) {
+  return value;
+}
+
+module.exports = identity;
diff --git a/parent_dir/node_modules/lodash/isArguments.js b/parent_dir/node_modules/lodash/isArguments.js
new file mode 100644
index 0000000..8b9ed66
--- /dev/null
+++ b/parent_dir/node_modules/lodash/isArguments.js
@@ -0,0 +1,36 @@
+var baseIsArguments = require('./_baseIsArguments'),
+    isObjectLike = require('./isObjectLike');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+/**
+ * Checks if `value` is likely an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ *  else `false`.
+ * @example
+ *
+ * _.isArguments(function() { return arguments; }());
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
+  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
+    !propertyIsEnumerable.call(value, 'callee');
+};
+
+module.exports = isArguments;
diff --git a/parent_dir/node_modules/lodash/isArray.js b/parent_dir/node_modules/lodash/isArray.js
new file mode 100644
index 0000000..88ab55f
--- /dev/null
+++ b/parent_dir/node_modules/lodash/isArray.js
@@ -0,0 +1,26 @@
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+var isArray = Array.isArray;
+
+module.exports = isArray;
diff --git a/parent_dir/node_modules/lodash/isArrayLike.js b/parent_dir/node_modules/lodash/isArrayLike.js
new file mode 100644
index 0000000..0f96680
--- /dev/null
+++ b/parent_dir/node_modules/lodash/isArrayLike.js
@@ -0,0 +1,33 @@
+var isFunction = require('./isFunction'),
+    isLength = require('./isLength');
+
+/**
+ * Checks if `value` is array-like. A value is considered array-like if it's
+ * not a function and has a `value.length` that's an integer greater than or
+ * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+ * @example
+ *
+ * _.isArrayLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLike(document.body.children);
+ * // => true
+ *
+ * _.isArrayLike('abc');
+ * // => true
+ *
+ * _.isArrayLike(_.noop);
+ * // => false
+ */
+function isArrayLike(value) {
+  return value != null && isLength(value.length) && !isFunction(value);
+}
+
+module.exports = isArrayLike;
diff --git a/parent_dir/node_modules/lodash/isArrayLikeObject.js b/parent_dir/node_modules/lodash/isArrayLikeObject.js
new file mode 100644
index 0000000..6c4812a
--- /dev/null
+++ b/parent_dir/node_modules/lodash/isArrayLikeObject.js
@@ -0,0 +1,33 @@
+var isArrayLike = require('./isArrayLike'),
+    isObjectLike = require('./isObjectLike');
+
+/**
+ * This method is like `_.isArrayLike` except that it also checks if `value`
+ * is an object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array-like object,
+ *  else `false`.
+ * @example
+ *
+ * _.isArrayLikeObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLikeObject(document.body.children);
+ * // => true
+ *
+ * _.isArrayLikeObject('abc');
+ * // => false
+ *
+ * _.isArrayLikeObject(_.noop);
+ * // => false
+ */
+function isArrayLikeObject(value) {
+  return isObjectLike(value) && isArrayLike(value);
+}
+
+module.exports = isArrayLikeObject;
diff --git a/parent_dir/node_modules/lodash/isBuffer.js b/parent_dir/node_modules/lodash/isBuffer.js
new file mode 100644
index 0000000..c103cc7
--- /dev/null
+++ b/parent_dir/node_modules/lodash/isBuffer.js
@@ -0,0 +1,38 @@
+var root = require('./_root'),
+    stubFalse = require('./stubFalse');
+
+/** Detect free variable `exports`. */
+var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/** Built-in value references. */
+var Buffer = moduleExports ? root.Buffer : undefined;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
+
+/**
+ * Checks if `value` is a buffer.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+ * @example
+ *
+ * _.isBuffer(new Buffer(2));
+ * // => true
+ *
+ * _.isBuffer(new Uint8Array(2));
+ * // => false
+ */
+var isBuffer = nativeIsBuffer || stubFalse;
+
+module.exports = isBuffer;
diff --git a/parent_dir/node_modules/lodash/isFunction.js b/parent_dir/node_modules/lodash/isFunction.js
new file mode 100644
index 0000000..907a8cd
--- /dev/null
+++ b/parent_dir/node_modules/lodash/isFunction.js
@@ -0,0 +1,37 @@
+var baseGetTag = require('./_baseGetTag'),
+    isObject = require('./isObject');
+
+/** `Object#toString` result references. */
+var asyncTag = '[object AsyncFunction]',
+    funcTag = '[object Function]',
+    genTag = '[object GeneratorFunction]',
+    proxyTag = '[object Proxy]';
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  // The use of `Object#toString` avoids issues with the `typeof` operator
+  // in Safari 9 which returns 'object' for typed arrays and other constructors.
+  var tag = baseGetTag(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+
+module.exports = isFunction;
diff --git a/parent_dir/node_modules/lodash/isLength.js b/parent_dir/node_modules/lodash/isLength.js
new file mode 100644
index 0000000..3a95caa
--- /dev/null
+++ b/parent_dir/node_modules/lodash/isLength.js
@@ -0,0 +1,35 @@
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER = 9007199254740991;
+
+/**
+ * Checks if `value` is a valid array-like length.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ * @example
+ *
+ * _.isLength(3);
+ * // => true
+ *
+ * _.isLength(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isLength(Infinity);
+ * // => false
+ *
+ * _.isLength('3');
+ * // => false
+ */
+function isLength(value) {
+  return typeof value == 'number' &&
+    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+
+module.exports = isLength;
diff --git a/parent_dir/node_modules/lodash/isMap.js b/parent_dir/node_modules/lodash/isMap.js
new file mode 100644
index 0000000..44f8517
--- /dev/null
+++ b/parent_dir/node_modules/lodash/isMap.js
@@ -0,0 +1,27 @@
+var baseIsMap = require('./_baseIsMap'),
+    baseUnary = require('./_baseUnary'),
+    nodeUtil = require('./_nodeUtil');
+
+/* Node.js helper references. */
+var nodeIsMap = nodeUtil && nodeUtil.isMap;
+
+/**
+ * Checks if `value` is classified as a `Map` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a map, else `false`.
+ * @example
+ *
+ * _.isMap(new Map);
+ * // => true
+ *
+ * _.isMap(new WeakMap);
+ * // => false
+ */
+var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
+
+module.exports = isMap;
diff --git a/parent_dir/node_modules/lodash/isObject.js b/parent_dir/node_modules/lodash/isObject.js
new file mode 100644
index 0000000..1dc8939
--- /dev/null
+++ b/parent_dir/node_modules/lodash/isObject.js
@@ -0,0 +1,31 @@
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == 'object' || type == 'function');
+}
+
+module.exports = isObject;
diff --git a/parent_dir/node_modules/lodash/isObjectLike.js b/parent_dir/node_modules/lodash/isObjectLike.js
new file mode 100644
index 0000000..301716b
--- /dev/null
+++ b/parent_dir/node_modules/lodash/isObjectLike.js
@@ -0,0 +1,29 @@
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+  return value != null && typeof value == 'object';
+}
+
+module.exports = isObjectLike;
diff --git a/parent_dir/node_modules/lodash/isPlainObject.js b/parent_dir/node_modules/lodash/isPlainObject.js
new file mode 100644
index 0000000..2387373
--- /dev/null
+++ b/parent_dir/node_modules/lodash/isPlainObject.js
@@ -0,0 +1,62 @@
+var baseGetTag = require('./_baseGetTag'),
+    getPrototype = require('./_getPrototype'),
+    isObjectLike = require('./isObjectLike');
+
+/** `Object#toString` result references. */
+var objectTag = '[object Object]';
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+    objectProto = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/** Used to infer the `Object` constructor. */
+var objectCtorString = funcToString.call(Object);
+
+/**
+ * Checks if `value` is a plain object, that is, an object created by the
+ * `Object` constructor or one with a `[[Prototype]]` of `null`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.8.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ * }
+ *
+ * _.isPlainObject(new Foo);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ *
+ * _.isPlainObject(Object.create(null));
+ * // => true
+ */
+function isPlainObject(value) {
+  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
+    return false;
+  }
+  var proto = getPrototype(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+  return typeof Ctor == 'function' && Ctor instanceof Ctor &&
+    funcToString.call(Ctor) == objectCtorString;
+}
+
+module.exports = isPlainObject;
diff --git a/parent_dir/node_modules/lodash/isSet.js b/parent_dir/node_modules/lodash/isSet.js
new file mode 100644
index 0000000..ab88bdf
--- /dev/null
+++ b/parent_dir/node_modules/lodash/isSet.js
@@ -0,0 +1,27 @@
+var baseIsSet = require('./_baseIsSet'),
+    baseUnary = require('./_baseUnary'),
+    nodeUtil = require('./_nodeUtil');
+
+/* Node.js helper references. */
+var nodeIsSet = nodeUtil && nodeUtil.isSet;
+
+/**
+ * Checks if `value` is classified as a `Set` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+ * @example
+ *
+ * _.isSet(new Set);
+ * // => true
+ *
+ * _.isSet(new WeakSet);
+ * // => false
+ */
+var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
+
+module.exports = isSet;
diff --git a/parent_dir/node_modules/lodash/isSymbol.js b/parent_dir/node_modules/lodash/isSymbol.js
new file mode 100644
index 0000000..dfb60b9
--- /dev/null
+++ b/parent_dir/node_modules/lodash/isSymbol.js
@@ -0,0 +1,29 @@
+var baseGetTag = require('./_baseGetTag'),
+    isObjectLike = require('./isObjectLike');
+
+/** `Object#toString` result references. */
+var symbolTag = '[object Symbol]';
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+  return typeof value == 'symbol' ||
+    (isObjectLike(value) && baseGetTag(value) == symbolTag);
+}
+
+module.exports = isSymbol;
diff --git a/parent_dir/node_modules/lodash/isTypedArray.js b/parent_dir/node_modules/lodash/isTypedArray.js
new file mode 100644
index 0000000..da3f8dd
--- /dev/null
+++ b/parent_dir/node_modules/lodash/isTypedArray.js
@@ -0,0 +1,27 @@
+var baseIsTypedArray = require('./_baseIsTypedArray'),
+    baseUnary = require('./_baseUnary'),
+    nodeUtil = require('./_nodeUtil');
+
+/* Node.js helper references. */
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+
+/**
+ * Checks if `value` is classified as a typed array.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ * @example
+ *
+ * _.isTypedArray(new Uint8Array);
+ * // => true
+ *
+ * _.isTypedArray([]);
+ * // => false
+ */
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+module.exports = isTypedArray;
diff --git a/parent_dir/node_modules/lodash/keys.js b/parent_dir/node_modules/lodash/keys.js
new file mode 100644
index 0000000..d143c71
--- /dev/null
+++ b/parent_dir/node_modules/lodash/keys.js
@@ -0,0 +1,37 @@
+var arrayLikeKeys = require('./_arrayLikeKeys'),
+    baseKeys = require('./_baseKeys'),
+    isArrayLike = require('./isArrayLike');
+
+/**
+ * Creates an array of the own enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects. See the
+ * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * for more details.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keys(new Foo);
+ * // => ['a', 'b'] (iteration order is not guaranteed)
+ *
+ * _.keys('hi');
+ * // => ['0', '1']
+ */
+function keys(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+
+module.exports = keys;
diff --git a/parent_dir/node_modules/lodash/keysIn.js b/parent_dir/node_modules/lodash/keysIn.js
new file mode 100644
index 0000000..a62308f
--- /dev/null
+++ b/parent_dir/node_modules/lodash/keysIn.js
@@ -0,0 +1,32 @@
+var arrayLikeKeys = require('./_arrayLikeKeys'),
+    baseKeysIn = require('./_baseKeysIn'),
+    isArrayLike = require('./isArrayLike');
+
+/**
+ * Creates an array of the own and inherited enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keysIn(new Foo);
+ * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+ */
+function keysIn(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+}
+
+module.exports = keysIn;
diff --git a/parent_dir/node_modules/lodash/memoize.js b/parent_dir/node_modules/lodash/memoize.js
new file mode 100644
index 0000000..d6035af
--- /dev/null
+++ b/parent_dir/node_modules/lodash/memoize.js
@@ -0,0 +1,73 @@
+var MapCache = require('./_MapCache');
+
+/** Error message constants. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is used as the map cache key. The `func`
+ * is invoked with the `this` binding of the memoized function.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `_.memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `clear`, `delete`, `get`, `has`, and `set`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] The function to resolve the cache key.
+ * @returns {Function} Returns the new memoized function.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2 };
+ * var other = { 'c': 3, 'd': 4 };
+ *
+ * var values = _.memoize(_.values);
+ * values(object);
+ * // => [1, 2]
+ *
+ * values(other);
+ * // => [3, 4]
+ *
+ * object.a = 2;
+ * values(object);
+ * // => [1, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b']);
+ * values(object);
+ * // => ['a', 'b']
+ *
+ * // Replace `_.memoize.Cache`.
+ * _.memoize.Cache = WeakMap;
+ */
+function memoize(func, resolver) {
+  if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments,
+        key = resolver ? resolver.apply(this, args) : args[0],
+        cache = memoized.cache;
+
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize.Cache || MapCache);
+  return memoized;
+}
+
+// Expose `MapCache`.
+memoize.Cache = MapCache;
+
+module.exports = memoize;
diff --git a/parent_dir/node_modules/lodash/merge.js b/parent_dir/node_modules/lodash/merge.js
new file mode 100644
index 0000000..4bbc3a1
--- /dev/null
+++ b/parent_dir/node_modules/lodash/merge.js
@@ -0,0 +1,39 @@
+var baseMerge = require('./_baseMerge'),
+    createAssigner = require('./_createAssigner');
+
+/**
+ * This method is like `_.assign` except that it recursively merges own and
+ * inherited enumerable string keyed properties of source objects into the
+ * destination object. Source properties that resolve to `undefined` are
+ * skipped if a destination value exists. Array and plain object properties
+ * are merged recursively. Other objects and value types are overridden by
+ * assignment. Source objects are applied from left to right. Subsequent
+ * sources overwrite property assignments of previous sources.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.5.0
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var object = {
+ *   'a': [{ 'b': 2 }, { 'd': 4 }]
+ * };
+ *
+ * var other = {
+ *   'a': [{ 'c': 3 }, { 'e': 5 }]
+ * };
+ *
+ * _.merge(object, other);
+ * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
+ */
+var merge = createAssigner(function(object, source, srcIndex) {
+  baseMerge(object, source, srcIndex);
+});
+
+module.exports = merge;
diff --git a/parent_dir/node_modules/lodash/now.js b/parent_dir/node_modules/lodash/now.js
new file mode 100644
index 0000000..44a0562
--- /dev/null
+++ b/parent_dir/node_modules/lodash/now.js
@@ -0,0 +1,23 @@
+var root = require('./_root');
+
+/**
+ * Gets the timestamp of the number of milliseconds that have elapsed since
+ * the Unix epoch (1 January 1970 00:00:00 UTC).
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Date
+ * @returns {number} Returns the timestamp.
+ * @example
+ *
+ * _.defer(function(stamp) {
+ *   console.log(_.now() - stamp);
+ * }, _.now());
+ * // => Logs the number of milliseconds it took for the deferred invocation.
+ */
+var now = function() {
+  return root.Date.now();
+};
+
+module.exports = now;
diff --git a/parent_dir/node_modules/lodash/property.js b/parent_dir/node_modules/lodash/property.js
new file mode 100644
index 0000000..ca8202f
--- /dev/null
+++ b/parent_dir/node_modules/lodash/property.js
@@ -0,0 +1,32 @@
+var baseProperty = require('./_baseProperty'),
+    basePropertyDeep = require('./_basePropertyDeep'),
+    isKey = require('./_isKey'),
+    toKey = require('./_toKey');
+
+/**
+ * Creates a function that returns the value at `path` of a given object.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Util
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ * @example
+ *
+ * var objects = [
+ *   { 'a': { 'b': 2 } },
+ *   { 'a': { 'b': 1 } }
+ * ];
+ *
+ * _.map(objects, _.property('a.b'));
+ * // => [2, 1]
+ *
+ * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
+ * // => [1, 2]
+ */
+function property(path) {
+  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+}
+
+module.exports = property;
diff --git a/parent_dir/node_modules/lodash/random.js b/parent_dir/node_modules/lodash/random.js
new file mode 100644
index 0000000..8067711
--- /dev/null
+++ b/parent_dir/node_modules/lodash/random.js
@@ -0,0 +1,82 @@
+var baseRandom = require('./_baseRandom'),
+    isIterateeCall = require('./_isIterateeCall'),
+    toFinite = require('./toFinite');
+
+/** Built-in method references without a dependency on `root`. */
+var freeParseFloat = parseFloat;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMin = Math.min,
+    nativeRandom = Math.random;
+
+/**
+ * Produces a random number between the inclusive `lower` and `upper` bounds.
+ * If only one argument is provided a number between `0` and the given number
+ * is returned. If `floating` is `true`, or either `lower` or `upper` are
+ * floats, a floating-point number is returned instead of an integer.
+ *
+ * **Note:** JavaScript follows the IEEE-754 standard for resolving
+ * floating-point values which can produce unexpected results.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.7.0
+ * @category Number
+ * @param {number} [lower=0] The lower bound.
+ * @param {number} [upper=1] The upper bound.
+ * @param {boolean} [floating] Specify returning a floating-point number.
+ * @returns {number} Returns the random number.
+ * @example
+ *
+ * _.random(0, 5);
+ * // => an integer between 0 and 5
+ *
+ * _.random(5);
+ * // => also an integer between 0 and 5
+ *
+ * _.random(5, true);
+ * // => a floating-point number between 0 and 5
+ *
+ * _.random(1.2, 5.2);
+ * // => a floating-point number between 1.2 and 5.2
+ */
+function random(lower, upper, floating) {
+  if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {
+    upper = floating = undefined;
+  }
+  if (floating === undefined) {
+    if (typeof upper == 'boolean') {
+      floating = upper;
+      upper = undefined;
+    }
+    else if (typeof lower == 'boolean') {
+      floating = lower;
+      lower = undefined;
+    }
+  }
+  if (lower === undefined && upper === undefined) {
+    lower = 0;
+    upper = 1;
+  }
+  else {
+    lower = toFinite(lower);
+    if (upper === undefined) {
+      upper = lower;
+      lower = 0;
+    } else {
+      upper = toFinite(upper);
+    }
+  }
+  if (lower > upper) {
+    var temp = lower;
+    lower = upper;
+    upper = temp;
+  }
+  if (floating || lower % 1 || upper % 1) {
+    var rand = nativeRandom();
+    return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);
+  }
+  return baseRandom(lower, upper);
+}
+
+module.exports = random;
diff --git a/parent_dir/node_modules/lodash/sortBy.js b/parent_dir/node_modules/lodash/sortBy.js
new file mode 100644
index 0000000..d756aba
--- /dev/null
+++ b/parent_dir/node_modules/lodash/sortBy.js
@@ -0,0 +1,48 @@
+var baseFlatten = require('./_baseFlatten'),
+    baseOrderBy = require('./_baseOrderBy'),
+    baseRest = require('./_baseRest'),
+    isIterateeCall = require('./_isIterateeCall');
+
+/**
+ * Creates an array of elements, sorted in ascending order by the results of
+ * running each element in a collection thru each iteratee. This method
+ * performs a stable sort, that is, it preserves the original sort order of
+ * equal elements. The iteratees are invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {...(Function|Function[])} [iteratees=[_.identity]]
+ *  The iteratees to sort by.
+ * @returns {Array} Returns the new sorted array.
+ * @example
+ *
+ * var users = [
+ *   { 'user': 'fred',   'age': 48 },
+ *   { 'user': 'barney', 'age': 36 },
+ *   { 'user': 'fred',   'age': 30 },
+ *   { 'user': 'barney', 'age': 34 }
+ * ];
+ *
+ * _.sortBy(users, [function(o) { return o.user; }]);
+ * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]]
+ *
+ * _.sortBy(users, ['user', 'age']);
+ * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]]
+ */
+var sortBy = baseRest(function(collection, iteratees) {
+  if (collection == null) {
+    return [];
+  }
+  var length = iteratees.length;
+  if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
+    iteratees = [];
+  } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
+    iteratees = [iteratees[0]];
+  }
+  return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
+});
+
+module.exports = sortBy;
diff --git a/parent_dir/node_modules/lodash/stubArray.js b/parent_dir/node_modules/lodash/stubArray.js
new file mode 100644
index 0000000..f460c15
--- /dev/null
+++ b/parent_dir/node_modules/lodash/stubArray.js
@@ -0,0 +1,23 @@
+/**
+ * This method returns a new empty array.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {Array} Returns the new empty array.
+ * @example
+ *
+ * var arrays = _.times(2, _.stubArray);
+ *
+ * console.log(arrays);
+ * // => [[], []]
+ *
+ * console.log(arrays[0] === arrays[1]);
+ * // => false
+ */
+function stubArray() {
+  return [];
+}
+
+module.exports = stubArray;
diff --git a/parent_dir/node_modules/lodash/stubFalse.js b/parent_dir/node_modules/lodash/stubFalse.js
new file mode 100644
index 0000000..9b346fc
--- /dev/null
+++ b/parent_dir/node_modules/lodash/stubFalse.js
@@ -0,0 +1,18 @@
+/**
+ * This method returns `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {boolean} Returns `false`.
+ * @example
+ *
+ * _.times(2, _.stubFalse);
+ * // => [false, false]
+ */
+function stubFalse() {
+  return false;
+}
+
+module.exports = stubFalse;
diff --git a/parent_dir/node_modules/lodash/toFinite.js b/parent_dir/node_modules/lodash/toFinite.js
new file mode 100644
index 0000000..3b5bba6
--- /dev/null
+++ b/parent_dir/node_modules/lodash/toFinite.js
@@ -0,0 +1,42 @@
+var toNumber = require('./toNumber');
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0,
+    MAX_INTEGER = 1.7976931348623157e+308;
+
+/**
+ * Converts `value` to a finite number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.12.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted number.
+ * @example
+ *
+ * _.toFinite(3.2);
+ * // => 3.2
+ *
+ * _.toFinite(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toFinite(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toFinite('3.2');
+ * // => 3.2
+ */
+function toFinite(value) {
+  if (!value) {
+    return value === 0 ? value : 0;
+  }
+  value = toNumber(value);
+  if (value === INFINITY || value === -INFINITY) {
+    var sign = (value < 0 ? -1 : 1);
+    return sign * MAX_INTEGER;
+  }
+  return value === value ? value : 0;
+}
+
+module.exports = toFinite;
diff --git a/parent_dir/node_modules/lodash/toInteger.js b/parent_dir/node_modules/lodash/toInteger.js
new file mode 100644
index 0000000..c6aadf8
--- /dev/null
+++ b/parent_dir/node_modules/lodash/toInteger.js
@@ -0,0 +1,36 @@
+var toFinite = require('./toFinite');
+
+/**
+ * Converts `value` to an integer.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted integer.
+ * @example
+ *
+ * _.toInteger(3.2);
+ * // => 3
+ *
+ * _.toInteger(Number.MIN_VALUE);
+ * // => 0
+ *
+ * _.toInteger(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toInteger('3.2');
+ * // => 3
+ */
+function toInteger(value) {
+  var result = toFinite(value),
+      remainder = result % 1;
+
+  return result === result ? (remainder ? result - remainder : result) : 0;
+}
+
+module.exports = toInteger;
diff --git a/parent_dir/node_modules/lodash/toNumber.js b/parent_dir/node_modules/lodash/toNumber.js
new file mode 100644
index 0000000..cf46f10
--- /dev/null
+++ b/parent_dir/node_modules/lodash/toNumber.js
@@ -0,0 +1,64 @@
+var baseTrim = require('./_baseTrim'),
+    isObject = require('./isObject'),
+    isSymbol = require('./isSymbol');
+
+/** Used as references for various `Number` constants. */
+var NAN = 0 / 0;
+
+/** Used to detect bad signed hexadecimal string values. */
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+/** Used to detect binary string values. */
+var reIsBinary = /^0b[01]+$/i;
+
+/** Used to detect octal string values. */
+var reIsOctal = /^0o[0-7]+$/i;
+
+/** Built-in method references without a dependency on `root`. */
+var freeParseInt = parseInt;
+
+/**
+ * Converts `value` to a number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {number} Returns the number.
+ * @example
+ *
+ * _.toNumber(3.2);
+ * // => 3.2
+ *
+ * _.toNumber(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toNumber(Infinity);
+ * // => Infinity
+ *
+ * _.toNumber('3.2');
+ * // => 3.2
+ */
+function toNumber(value) {
+  if (typeof value == 'number') {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return NAN;
+  }
+  if (isObject(value)) {
+    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+    value = isObject(other) ? (other + '') : other;
+  }
+  if (typeof value != 'string') {
+    return value === 0 ? value : +value;
+  }
+  value = baseTrim(value);
+  var isBinary = reIsBinary.test(value);
+  return (isBinary || reIsOctal.test(value))
+    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+    : (reIsBadHex.test(value) ? NAN : +value);
+}
+
+module.exports = toNumber;
diff --git a/parent_dir/node_modules/lodash/toPlainObject.js b/parent_dir/node_modules/lodash/toPlainObject.js
new file mode 100644
index 0000000..5de79b8
--- /dev/null
+++ b/parent_dir/node_modules/lodash/toPlainObject.js
@@ -0,0 +1,32 @@
+var copyObject = require('./_copyObject'),
+    keysIn = require('./keysIn');
+
+/**
+ * Converts `value` to a plain object flattening inherited enumerable string
+ * keyed properties of `value` to own properties of the plain object.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {Object} Returns the converted plain object.
+ * @example
+ *
+ * function Foo() {
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.assign({ 'a': 1 }, new Foo);
+ * // => { 'a': 1, 'b': 2 }
+ *
+ * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
+ * // => { 'a': 1, 'b': 2, 'c': 3 }
+ */
+function toPlainObject(value) {
+  return copyObject(value, keysIn(value));
+}
+
+module.exports = toPlainObject;
diff --git a/parent_dir/node_modules/lodash/toString.js b/parent_dir/node_modules/lodash/toString.js
new file mode 100644
index 0000000..daaf681
--- /dev/null
+++ b/parent_dir/node_modules/lodash/toString.js
@@ -0,0 +1,28 @@
+var baseToString = require('./_baseToString');
+
+/**
+ * Converts `value` to a string. An empty string is returned for `null`
+ * and `undefined` values. The sign of `-0` is preserved.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ * @example
+ *
+ * _.toString(null);
+ * // => ''
+ *
+ * _.toString(-0);
+ * // => '-0'
+ *
+ * _.toString([1, 2, 3]);
+ * // => '1,2,3'
+ */
+function toString(value) {
+  return value == null ? '' : baseToString(value);
+}
+
+module.exports = toString;
diff --git a/parent_dir/node_modules/mitt/dist/mitt.mjs b/parent_dir/node_modules/mitt/dist/mitt.mjs
new file mode 100644
index 0000000..5a2e73a
--- /dev/null
+++ b/parent_dir/node_modules/mitt/dist/mitt.mjs
@@ -0,0 +1,2 @@
+export default function(n){return{all:n=n||new Map,on:function(t,e){var i=n.get(t);i?i.push(e):n.set(t,[e])},off:function(t,e){var i=n.get(t);i&&(e?i.splice(i.indexOf(e)>>>0,1):n.set(t,[]))},emit:function(t,e){var i=n.get(t);i&&i.slice().map(function(n){n(e)}),(i=n.get("*"))&&i.slice().map(function(n){n(t,e)})}}}
+//# sourceMappingURL=mitt.mjs.map
diff --git a/parent_dir/node_modules/moment/dist/moment.js b/parent_dir/node_modules/moment/dist/moment.js
new file mode 100644
index 0000000..0d69633
--- /dev/null
+++ b/parent_dir/node_modules/moment/dist/moment.js
@@ -0,0 +1,5677 @@
+//! moment.js
+//! version : 2.29.4
+//! authors : Tim Wood, Iskren Chernev, Moment.js contributors
+//! license : MIT
+//! momentjs.com
+
+var hookCallback;
+
+function hooks() {
+    return hookCallback.apply(null, arguments);
+}
+
+// This is done to register the method called with moment()
+// without creating circular dependencies.
+function setHookCallback(callback) {
+    hookCallback = callback;
+}
+
+function isArray(input) {
+    return (
+        input instanceof Array ||
+        Object.prototype.toString.call(input) === '[object Array]'
+    );
+}
+
+function isObject(input) {
+    // IE8 will treat undefined and null as object if it wasn't for
+    // input != null
+    return (
+        input != null &&
+        Object.prototype.toString.call(input) === '[object Object]'
+    );
+}
+
+function hasOwnProp(a, b) {
+    return Object.prototype.hasOwnProperty.call(a, b);
+}
+
+function isObjectEmpty(obj) {
+    if (Object.getOwnPropertyNames) {
+        return Object.getOwnPropertyNames(obj).length === 0;
+    } else {
+        var k;
+        for (k in obj) {
+            if (hasOwnProp(obj, k)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+function isUndefined(input) {
+    return input === void 0;
+}
+
+function isNumber(input) {
+    return (
+        typeof input === 'number' ||
+        Object.prototype.toString.call(input) === '[object Number]'
+    );
+}
+
+function isDate(input) {
+    return (
+        input instanceof Date ||
+        Object.prototype.toString.call(input) === '[object Date]'
+    );
+}
+
+function map(arr, fn) {
+    var res = [],
+        i,
+        arrLen = arr.length;
+    for (i = 0; i < arrLen; ++i) {
+        res.push(fn(arr[i], i));
+    }
+    return res;
+}
+
+function extend(a, b) {
+    for (var i in b) {
+        if (hasOwnProp(b, i)) {
+            a[i] = b[i];
+        }
+    }
+
+    if (hasOwnProp(b, 'toString')) {
+        a.toString = b.toString;
+    }
+
+    if (hasOwnProp(b, 'valueOf')) {
+        a.valueOf = b.valueOf;
+    }
+
+    return a;
+}
+
+function createUTC(input, format, locale, strict) {
+    return createLocalOrUTC(input, format, locale, strict, true).utc();
+}
+
+function defaultParsingFlags() {
+    // We need to deep clone this object.
+    return {
+        empty: false,
+        unusedTokens: [],
+        unusedInput: [],
+        overflow: -2,
+        charsLeftOver: 0,
+        nullInput: false,
+        invalidEra: null,
+        invalidMonth: null,
+        invalidFormat: false,
+        userInvalidated: false,
+        iso: false,
+        parsedDateParts: [],
+        era: null,
+        meridiem: null,
+        rfc2822: false,
+        weekdayMismatch: false,
+    };
+}
+
+function getParsingFlags(m) {
+    if (m._pf == null) {
+        m._pf = defaultParsingFlags();
+    }
+    return m._pf;
+}
+
+var some;
+if (Array.prototype.some) {
+    some = Array.prototype.some;
+} else {
+    some = function (fun) {
+        var t = Object(this),
+            len = t.length >>> 0,
+            i;
+
+        for (i = 0; i < len; i++) {
+            if (i in t && fun.call(this, t[i], i, t)) {
+                return true;
+            }
+        }
+
+        return false;
+    };
+}
+
+function isValid(m) {
+    if (m._isValid == null) {
+        var flags = getParsingFlags(m),
+            parsedParts = some.call(flags.parsedDateParts, function (i) {
+                return i != null;
+            }),
+            isNowValid =
+                !isNaN(m._d.getTime()) &&
+                flags.overflow < 0 &&
+                !flags.empty &&
+                !flags.invalidEra &&
+                !flags.invalidMonth &&
+                !flags.invalidWeekday &&
+                !flags.weekdayMismatch &&
+                !flags.nullInput &&
+                !flags.invalidFormat &&
+                !flags.userInvalidated &&
+                (!flags.meridiem || (flags.meridiem && parsedParts));
+
+        if (m._strict) {
+            isNowValid =
+                isNowValid &&
+                flags.charsLeftOver === 0 &&
+                flags.unusedTokens.length === 0 &&
+                flags.bigHour === undefined;
+        }
+
+        if (Object.isFrozen == null || !Object.isFrozen(m)) {
+            m._isValid = isNowValid;
+        } else {
+            return isNowValid;
+        }
+    }
+    return m._isValid;
+}
+
+function createInvalid(flags) {
+    var m = createUTC(NaN);
+    if (flags != null) {
+        extend(getParsingFlags(m), flags);
+    } else {
+        getParsingFlags(m).userInvalidated = true;
+    }
+
+    return m;
+}
+
+// Plugins that add properties should also add the key here (null value),
+// so we can properly clone ourselves.
+var momentProperties = (hooks.momentProperties = []),
+    updateInProgress = false;
+
+function copyConfig(to, from) {
+    var i,
+        prop,
+        val,
+        momentPropertiesLen = momentProperties.length;
+
+    if (!isUndefined(from._isAMomentObject)) {
+        to._isAMomentObject = from._isAMomentObject;
+    }
+    if (!isUndefined(from._i)) {
+        to._i = from._i;
+    }
+    if (!isUndefined(from._f)) {
+        to._f = from._f;
+    }
+    if (!isUndefined(from._l)) {
+        to._l = from._l;
+    }
+    if (!isUndefined(from._strict)) {
+        to._strict = from._strict;
+    }
+    if (!isUndefined(from._tzm)) {
+        to._tzm = from._tzm;
+    }
+    if (!isUndefined(from._isUTC)) {
+        to._isUTC = from._isUTC;
+    }
+    if (!isUndefined(from._offset)) {
+        to._offset = from._offset;
+    }
+    if (!isUndefined(from._pf)) {
+        to._pf = getParsingFlags(from);
+    }
+    if (!isUndefined(from._locale)) {
+        to._locale = from._locale;
+    }
+
+    if (momentPropertiesLen > 0) {
+        for (i = 0; i < momentPropertiesLen; i++) {
+            prop = momentProperties[i];
+            val = from[prop];
+            if (!isUndefined(val)) {
+                to[prop] = val;
+            }
+        }
+    }
+
+    return to;
+}
+
+// Moment prototype object
+function Moment(config) {
+    copyConfig(this, config);
+    this._d = new Date(config._d != null ? config._d.getTime() : NaN);
+    if (!this.isValid()) {
+        this._d = new Date(NaN);
+    }
+    // Prevent infinite loop in case updateOffset creates new moment
+    // objects.
+    if (updateInProgress === false) {
+        updateInProgress = true;
+        hooks.updateOffset(this);
+        updateInProgress = false;
+    }
+}
+
+function isMoment(obj) {
+    return (
+        obj instanceof Moment || (obj != null && obj._isAMomentObject != null)
+    );
+}
+
+function warn(msg) {
+    if (
+        hooks.suppressDeprecationWarnings === false &&
+        typeof console !== 'undefined' &&
+        console.warn
+    ) {
+        console.warn('Deprecation warning: ' + msg);
+    }
+}
+
+function deprecate(msg, fn) {
+    var firstTime = true;
+
+    return extend(function () {
+        if (hooks.deprecationHandler != null) {
+            hooks.deprecationHandler(null, msg);
+        }
+        if (firstTime) {
+            var args = [],
+                arg,
+                i,
+                key,
+                argLen = arguments.length;
+            for (i = 0; i < argLen; i++) {
+                arg = '';
+                if (typeof arguments[i] === 'object') {
+                    arg += '\n[' + i + '] ';
+                    for (key in arguments[0]) {
+                        if (hasOwnProp(arguments[0], key)) {
+                            arg += key + ': ' + arguments[0][key] + ', ';
+                        }
+                    }
+                    arg = arg.slice(0, -2); // Remove trailing comma and space
+                } else {
+                    arg = arguments[i];
+                }
+                args.push(arg);
+            }
+            warn(
+                msg +
+                    '\nArguments: ' +
+                    Array.prototype.slice.call(args).join('') +
+                    '\n' +
+                    new Error().stack
+            );
+            firstTime = false;
+        }
+        return fn.apply(this, arguments);
+    }, fn);
+}
+
+var deprecations = {};
+
+function deprecateSimple(name, msg) {
+    if (hooks.deprecationHandler != null) {
+        hooks.deprecationHandler(name, msg);
+    }
+    if (!deprecations[name]) {
+        warn(msg);
+        deprecations[name] = true;
+    }
+}
+
+hooks.suppressDeprecationWarnings = false;
+hooks.deprecationHandler = null;
+
+function isFunction(input) {
+    return (
+        (typeof Function !== 'undefined' && input instanceof Function) ||
+        Object.prototype.toString.call(input) === '[object Function]'
+    );
+}
+
+function set(config) {
+    var prop, i;
+    for (i in config) {
+        if (hasOwnProp(config, i)) {
+            prop = config[i];
+            if (isFunction(prop)) {
+                this[i] = prop;
+            } else {
+                this['_' + i] = prop;
+            }
+        }
+    }
+    this._config = config;
+    // Lenient ordinal parsing accepts just a number in addition to
+    // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
+    // TODO: Remove "ordinalParse" fallback in next major release.
+    this._dayOfMonthOrdinalParseLenient = new RegExp(
+        (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
+            '|' +
+            /\d{1,2}/.source
+    );
+}
+
+function mergeConfigs(parentConfig, childConfig) {
+    var res = extend({}, parentConfig),
+        prop;
+    for (prop in childConfig) {
+        if (hasOwnProp(childConfig, prop)) {
+            if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
+                res[prop] = {};
+                extend(res[prop], parentConfig[prop]);
+                extend(res[prop], childConfig[prop]);
+            } else if (childConfig[prop] != null) {
+                res[prop] = childConfig[prop];
+            } else {
+                delete res[prop];
+            }
+        }
+    }
+    for (prop in parentConfig) {
+        if (
+            hasOwnProp(parentConfig, prop) &&
+            !hasOwnProp(childConfig, prop) &&
+            isObject(parentConfig[prop])
+        ) {
+            // make sure changes to properties don't modify parent config
+            res[prop] = extend({}, res[prop]);
+        }
+    }
+    return res;
+}
+
+function Locale(config) {
+    if (config != null) {
+        this.set(config);
+    }
+}
+
+var keys;
+
+if (Object.keys) {
+    keys = Object.keys;
+} else {
+    keys = function (obj) {
+        var i,
+            res = [];
+        for (i in obj) {
+            if (hasOwnProp(obj, i)) {
+                res.push(i);
+            }
+        }
+        return res;
+    };
+}
+
+var defaultCalendar = {
+    sameDay: '[Today at] LT',
+    nextDay: '[Tomorrow at] LT',
+    nextWeek: 'dddd [at] LT',
+    lastDay: '[Yesterday at] LT',
+    lastWeek: '[Last] dddd [at] LT',
+    sameElse: 'L',
+};
+
+function calendar(key, mom, now) {
+    var output = this._calendar[key] || this._calendar['sameElse'];
+    return isFunction(output) ? output.call(mom, now) : output;
+}
+
+function zeroFill(number, targetLength, forceSign) {
+    var absNumber = '' + Math.abs(number),
+        zerosToFill = targetLength - absNumber.length,
+        sign = number >= 0;
+    return (
+        (sign ? (forceSign ? '+' : '') : '-') +
+        Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) +
+        absNumber
+    );
+}
+
+var formattingTokens =
+        /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,
+    localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,
+    formatFunctions = {},
+    formatTokenFunctions = {};
+
+// token:    'M'
+// padded:   ['MM', 2]
+// ordinal:  'Mo'
+// callback: function () { this.month() + 1 }
+function addFormatToken(token, padded, ordinal, callback) {
+    var func = callback;
+    if (typeof callback === 'string') {
+        func = function () {
+            return this[callback]();
+        };
+    }
+    if (token) {
+        formatTokenFunctions[token] = func;
+    }
+    if (padded) {
+        formatTokenFunctions[padded[0]] = function () {
+            return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
+        };
+    }
+    if (ordinal) {
+        formatTokenFunctions[ordinal] = function () {
+            return this.localeData().ordinal(
+                func.apply(this, arguments),
+                token
+            );
+        };
+    }
+}
+
+function removeFormattingTokens(input) {
+    if (input.match(/\[[\s\S]/)) {
+        return input.replace(/^\[|\]$/g, '');
+    }
+    return input.replace(/\\/g, '');
+}
+
+function makeFormatFunction(format) {
+    var array = format.match(formattingTokens),
+        i,
+        length;
+
+    for (i = 0, length = array.length; i < length; i++) {
+        if (formatTokenFunctions[array[i]]) {
+            array[i] = formatTokenFunctions[array[i]];
+        } else {
+            array[i] = removeFormattingTokens(array[i]);
+        }
+    }
+
+    return function (mom) {
+        var output = '',
+            i;
+        for (i = 0; i < length; i++) {
+            output += isFunction(array[i])
+                ? array[i].call(mom, format)
+                : array[i];
+        }
+        return output;
+    };
+}
+
+// format date using native date object
+function formatMoment(m, format) {
+    if (!m.isValid()) {
+        return m.localeData().invalidDate();
+    }
+
+    format = expandFormat(format, m.localeData());
+    formatFunctions[format] =
+        formatFunctions[format] || makeFormatFunction(format);
+
+    return formatFunctions[format](m);
+}
+
+function expandFormat(format, locale) {
+    var i = 5;
+
+    function replaceLongDateFormatTokens(input) {
+        return locale.longDateFormat(input) || input;
+    }
+
+    localFormattingTokens.lastIndex = 0;
+    while (i >= 0 && localFormattingTokens.test(format)) {
+        format = format.replace(
+            localFormattingTokens,
+            replaceLongDateFormatTokens
+        );
+        localFormattingTokens.lastIndex = 0;
+        i -= 1;
+    }
+
+    return format;
+}
+
+var defaultLongDateFormat = {
+    LTS: 'h:mm:ss A',
+    LT: 'h:mm A',
+    L: 'MM/DD/YYYY',
+    LL: 'MMMM D, YYYY',
+    LLL: 'MMMM D, YYYY h:mm A',
+    LLLL: 'dddd, MMMM D, YYYY h:mm A',
+};
+
+function longDateFormat(key) {
+    var format = this._longDateFormat[key],
+        formatUpper = this._longDateFormat[key.toUpperCase()];
+
+    if (format || !formatUpper) {
+        return format;
+    }
+
+    this._longDateFormat[key] = formatUpper
+        .match(formattingTokens)
+        .map(function (tok) {
+            if (
+                tok === 'MMMM' ||
+                tok === 'MM' ||
+                tok === 'DD' ||
+                tok === 'dddd'
+            ) {
+                return tok.slice(1);
+            }
+            return tok;
+        })
+        .join('');
+
+    return this._longDateFormat[key];
+}
+
+var defaultInvalidDate = 'Invalid date';
+
+function invalidDate() {
+    return this._invalidDate;
+}
+
+var defaultOrdinal = '%d',
+    defaultDayOfMonthOrdinalParse = /\d{1,2}/;
+
+function ordinal(number) {
+    return this._ordinal.replace('%d', number);
+}
+
+var defaultRelativeTime = {
+    future: 'in %s',
+    past: '%s ago',
+    s: 'a few seconds',
+    ss: '%d seconds',
+    m: 'a minute',
+    mm: '%d minutes',
+    h: 'an hour',
+    hh: '%d hours',
+    d: 'a day',
+    dd: '%d days',
+    w: 'a week',
+    ww: '%d weeks',
+    M: 'a month',
+    MM: '%d months',
+    y: 'a year',
+    yy: '%d years',
+};
+
+function relativeTime(number, withoutSuffix, string, isFuture) {
+    var output = this._relativeTime[string];
+    return isFunction(output)
+        ? output(number, withoutSuffix, string, isFuture)
+        : output.replace(/%d/i, number);
+}
+
+function pastFuture(diff, output) {
+    var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
+    return isFunction(format) ? format(output) : format.replace(/%s/i, output);
+}
+
+var aliases = {};
+
+function addUnitAlias(unit, shorthand) {
+    var lowerCase = unit.toLowerCase();
+    aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
+}
+
+function normalizeUnits(units) {
+    return typeof units === 'string'
+        ? aliases[units] || aliases[units.toLowerCase()]
+        : undefined;
+}
+
+function normalizeObjectUnits(inputObject) {
+    var normalizedInput = {},
+        normalizedProp,
+        prop;
+
+    for (prop in inputObject) {
+        if (hasOwnProp(inputObject, prop)) {
+            normalizedProp = normalizeUnits(prop);
+            if (normalizedProp) {
+                normalizedInput[normalizedProp] = inputObject[prop];
+            }
+        }
+    }
+
+    return normalizedInput;
+}
+
+var priorities = {};
+
+function addUnitPriority(unit, priority) {
+    priorities[unit] = priority;
+}
+
+function getPrioritizedUnits(unitsObj) {
+    var units = [],
+        u;
+    for (u in unitsObj) {
+        if (hasOwnProp(unitsObj, u)) {
+            units.push({ unit: u, priority: priorities[u] });
+        }
+    }
+    units.sort(function (a, b) {
+        return a.priority - b.priority;
+    });
+    return units;
+}
+
+function isLeapYear(year) {
+    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+}
+
+function absFloor(number) {
+    if (number < 0) {
+        // -0 -> 0
+        return Math.ceil(number) || 0;
+    } else {
+        return Math.floor(number);
+    }
+}
+
+function toInt(argumentForCoercion) {
+    var coercedNumber = +argumentForCoercion,
+        value = 0;
+
+    if (coercedNumber !== 0 && isFinite(coercedNumber)) {
+        value = absFloor(coercedNumber);
+    }
+
+    return value;
+}
+
+function makeGetSet(unit, keepTime) {
+    return function (value) {
+        if (value != null) {
+            set$1(this, unit, value);
+            hooks.updateOffset(this, keepTime);
+            return this;
+        } else {
+            return get(this, unit);
+        }
+    };
+}
+
+function get(mom, unit) {
+    return mom.isValid()
+        ? mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]()
+        : NaN;
+}
+
+function set$1(mom, unit, value) {
+    if (mom.isValid() && !isNaN(value)) {
+        if (
+            unit === 'FullYear' &&
+            isLeapYear(mom.year()) &&
+            mom.month() === 1 &&
+            mom.date() === 29
+        ) {
+            value = toInt(value);
+            mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](
+                value,
+                mom.month(),
+                daysInMonth(value, mom.month())
+            );
+        } else {
+            mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
+        }
+    }
+}
+
+// MOMENTS
+
+function stringGet(units) {
+    units = normalizeUnits(units);
+    if (isFunction(this[units])) {
+        return this[units]();
+    }
+    return this;
+}
+
+function stringSet(units, value) {
+    if (typeof units === 'object') {
+        units = normalizeObjectUnits(units);
+        var prioritized = getPrioritizedUnits(units),
+            i,
+            prioritizedLen = prioritized.length;
+        for (i = 0; i < prioritizedLen; i++) {
+            this[prioritized[i].unit](units[prioritized[i].unit]);
+        }
+    } else {
+        units = normalizeUnits(units);
+        if (isFunction(this[units])) {
+            return this[units](value);
+        }
+    }
+    return this;
+}
+
+var match1 = /\d/, //       0 - 9
+    match2 = /\d\d/, //      00 - 99
+    match3 = /\d{3}/, //     000 - 999
+    match4 = /\d{4}/, //    0000 - 9999
+    match6 = /[+-]?\d{6}/, // -999999 - 999999
+    match1to2 = /\d\d?/, //       0 - 99
+    match3to4 = /\d\d\d\d?/, //     999 - 9999
+    match5to6 = /\d\d\d\d\d\d?/, //   99999 - 999999
+    match1to3 = /\d{1,3}/, //       0 - 999
+    match1to4 = /\d{1,4}/, //       0 - 9999
+    match1to6 = /[+-]?\d{1,6}/, // -999999 - 999999
+    matchUnsigned = /\d+/, //       0 - inf
+    matchSigned = /[+-]?\d+/, //    -inf - inf
+    matchOffset = /Z|[+-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z
+    matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, // +00 -00 +00:00 -00:00 +0000 -0000 or Z
+    matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
+    // any word (or two) characters or numbers including two/three word month in arabic.
+    // includes scottish gaelic two word and hyphenated months
+    matchWord =
+        /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i,
+    regexes;
+
+regexes = {};
+
+function addRegexToken(token, regex, strictRegex) {
+    regexes[token] = isFunction(regex)
+        ? regex
+        : function (isStrict, localeData) {
+              return isStrict && strictRegex ? strictRegex : regex;
+          };
+}
+
+function getParseRegexForToken(token, config) {
+    if (!hasOwnProp(regexes, token)) {
+        return new RegExp(unescapeFormat(token));
+    }
+
+    return regexes[token](config._strict, config._locale);
+}
+
+// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
+function unescapeFormat(s) {
+    return regexEscape(
+        s
+            .replace('\\', '')
+            .replace(
+                /\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,
+                function (matched, p1, p2, p3, p4) {
+                    return p1 || p2 || p3 || p4;
+                }
+            )
+    );
+}
+
+function regexEscape(s) {
+    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+
+var tokens = {};
+
+function addParseToken(token, callback) {
+    var i,
+        func = callback,
+        tokenLen;
+    if (typeof token === 'string') {
+        token = [token];
+    }
+    if (isNumber(callback)) {
+        func = function (input, array) {
+            array[callback] = toInt(input);
+        };
+    }
+    tokenLen = token.length;
+    for (i = 0; i < tokenLen; i++) {
+        tokens[token[i]] = func;
+    }
+}
+
+function addWeekParseToken(token, callback) {
+    addParseToken(token, function (input, array, config, token) {
+        config._w = config._w || {};
+        callback(input, config._w, config, token);
+    });
+}
+
+function addTimeToArrayFromToken(token, input, config) {
+    if (input != null && hasOwnProp(tokens, token)) {
+        tokens[token](input, config._a, config, token);
+    }
+}
+
+var YEAR = 0,
+    MONTH = 1,
+    DATE = 2,
+    HOUR = 3,
+    MINUTE = 4,
+    SECOND = 5,
+    MILLISECOND = 6,
+    WEEK = 7,
+    WEEKDAY = 8;
+
+function mod(n, x) {
+    return ((n % x) + x) % x;
+}
+
+var indexOf;
+
+if (Array.prototype.indexOf) {
+    indexOf = Array.prototype.indexOf;
+} else {
+    indexOf = function (o) {
+        // I know
+        var i;
+        for (i = 0; i < this.length; ++i) {
+            if (this[i] === o) {
+                return i;
+            }
+        }
+        return -1;
+    };
+}
+
+function daysInMonth(year, month) {
+    if (isNaN(year) || isNaN(month)) {
+        return NaN;
+    }
+    var modMonth = mod(month, 12);
+    year += (month - modMonth) / 12;
+    return modMonth === 1
+        ? isLeapYear(year)
+            ? 29
+            : 28
+        : 31 - ((modMonth % 7) % 2);
+}
+
+// FORMATTING
+
+addFormatToken('M', ['MM', 2], 'Mo', function () {
+    return this.month() + 1;
+});
+
+addFormatToken('MMM', 0, 0, function (format) {
+    return this.localeData().monthsShort(this, format);
+});
+
+addFormatToken('MMMM', 0, 0, function (format) {
+    return this.localeData().months(this, format);
+});
+
+// ALIASES
+
+addUnitAlias('month', 'M');
+
+// PRIORITY
+
+addUnitPriority('month', 8);
+
+// PARSING
+
+addRegexToken('M', match1to2);
+addRegexToken('MM', match1to2, match2);
+addRegexToken('MMM', function (isStrict, locale) {
+    return locale.monthsShortRegex(isStrict);
+});
+addRegexToken('MMMM', function (isStrict, locale) {
+    return locale.monthsRegex(isStrict);
+});
+
+addParseToken(['M', 'MM'], function (input, array) {
+    array[MONTH] = toInt(input) - 1;
+});
+
+addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
+    var month = config._locale.monthsParse(input, token, config._strict);
+    // if we didn't find a month name, mark the date as invalid.
+    if (month != null) {
+        array[MONTH] = month;
+    } else {
+        getParsingFlags(config).invalidMonth = input;
+    }
+});
+
+// LOCALES
+
+var defaultLocaleMonths =
+        'January_February_March_April_May_June_July_August_September_October_November_December'.split(
+            '_'
+        ),
+    defaultLocaleMonthsShort =
+        'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+    MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,
+    defaultMonthsShortRegex = matchWord,
+    defaultMonthsRegex = matchWord;
+
+function localeMonths(m, format) {
+    if (!m) {
+        return isArray(this._months)
+            ? this._months
+            : this._months['standalone'];
+    }
+    return isArray(this._months)
+        ? this._months[m.month()]
+        : this._months[
+              (this._months.isFormat || MONTHS_IN_FORMAT).test(format)
+                  ? 'format'
+                  : 'standalone'
+          ][m.month()];
+}
+
+function localeMonthsShort(m, format) {
+    if (!m) {
+        return isArray(this._monthsShort)
+            ? this._monthsShort
+            : this._monthsShort['standalone'];
+    }
+    return isArray(this._monthsShort)
+        ? this._monthsShort[m.month()]
+        : this._monthsShort[
+              MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'
+          ][m.month()];
+}
+
+function handleStrictParse(monthName, format, strict) {
+    var i,
+        ii,
+        mom,
+        llc = monthName.toLocaleLowerCase();
+    if (!this._monthsParse) {
+        // this is not used
+        this._monthsParse = [];
+        this._longMonthsParse = [];
+        this._shortMonthsParse = [];
+        for (i = 0; i < 12; ++i) {
+            mom = createUTC([2000, i]);
+            this._shortMonthsParse[i] = this.monthsShort(
+                mom,
+                ''
+            ).toLocaleLowerCase();
+            this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
+        }
+    }
+
+    if (strict) {
+        if (format === 'MMM') {
+            ii = indexOf.call(this._shortMonthsParse, llc);
+            return ii !== -1 ? ii : null;
+        } else {
+            ii = indexOf.call(this._longMonthsParse, llc);
+            return ii !== -1 ? ii : null;
+        }
+    } else {
+        if (format === 'MMM') {
+            ii = indexOf.call(this._shortMonthsParse, llc);
+            if (ii !== -1) {
+                return ii;
+            }
+            ii = indexOf.call(this._longMonthsParse, llc);
+            return ii !== -1 ? ii : null;
+        } else {
+            ii = indexOf.call(this._longMonthsParse, llc);
+            if (ii !== -1) {
+                return ii;
+            }
+            ii = indexOf.call(this._shortMonthsParse, llc);
+            return ii !== -1 ? ii : null;
+        }
+    }
+}
+
+function localeMonthsParse(monthName, format, strict) {
+    var i, mom, regex;
+
+    if (this._monthsParseExact) {
+        return handleStrictParse.call(this, monthName, format, strict);
+    }
+
+    if (!this._monthsParse) {
+        this._monthsParse = [];
+        this._longMonthsParse = [];
+        this._shortMonthsParse = [];
+    }
+
+    // TODO: add sorting
+    // Sorting makes sure if one month (or abbr) is a prefix of another
+    // see sorting in computeMonthsParse
+    for (i = 0; i < 12; i++) {
+        // make the regex if we don't have it already
+        mom = createUTC([2000, i]);
+        if (strict && !this._longMonthsParse[i]) {
+            this._longMonthsParse[i] = new RegExp(
+                '^' + this.months(mom, '').replace('.', '') + '$',
+                'i'
+            );
+            this._shortMonthsParse[i] = new RegExp(
+                '^' + this.monthsShort(mom, '').replace('.', '') + '$',
+                'i'
+            );
+        }
+        if (!strict && !this._monthsParse[i]) {
+            regex =
+                '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
+            this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
+        }
+        // test the regex
+        if (
+            strict &&
+            format === 'MMMM' &&
+            this._longMonthsParse[i].test(monthName)
+        ) {
+            return i;
+        } else if (
+            strict &&
+            format === 'MMM' &&
+            this._shortMonthsParse[i].test(monthName)
+        ) {
+            return i;
+        } else if (!strict && this._monthsParse[i].test(monthName)) {
+            return i;
+        }
+    }
+}
+
+// MOMENTS
+
+function setMonth(mom, value) {
+    var dayOfMonth;
+
+    if (!mom.isValid()) {
+        // No op
+        return mom;
+    }
+
+    if (typeof value === 'string') {
+        if (/^\d+$/.test(value)) {
+            value = toInt(value);
+        } else {
+            value = mom.localeData().monthsParse(value);
+            // TODO: Another silent failure?
+            if (!isNumber(value)) {
+                return mom;
+            }
+        }
+    }
+
+    dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
+    mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
+    return mom;
+}
+
+function getSetMonth(value) {
+    if (value != null) {
+        setMonth(this, value);
+        hooks.updateOffset(this, true);
+        return this;
+    } else {
+        return get(this, 'Month');
+    }
+}
+
+function getDaysInMonth() {
+    return daysInMonth(this.year(), this.month());
+}
+
+function monthsShortRegex(isStrict) {
+    if (this._monthsParseExact) {
+        if (!hasOwnProp(this, '_monthsRegex')) {
+            computeMonthsParse.call(this);
+        }
+        if (isStrict) {
+            return this._monthsShortStrictRegex;
+        } else {
+            return this._monthsShortRegex;
+        }
+    } else {
+        if (!hasOwnProp(this, '_monthsShortRegex')) {
+            this._monthsShortRegex = defaultMonthsShortRegex;
+        }
+        return this._monthsShortStrictRegex && isStrict
+            ? this._monthsShortStrictRegex
+            : this._monthsShortRegex;
+    }
+}
+
+function monthsRegex(isStrict) {
+    if (this._monthsParseExact) {
+        if (!hasOwnProp(this, '_monthsRegex')) {
+            computeMonthsParse.call(this);
+        }
+        if (isStrict) {
+            return this._monthsStrictRegex;
+        } else {
+            return this._monthsRegex;
+        }
+    } else {
+        if (!hasOwnProp(this, '_monthsRegex')) {
+            this._monthsRegex = defaultMonthsRegex;
+        }
+        return this._monthsStrictRegex && isStrict
+            ? this._monthsStrictRegex
+            : this._monthsRegex;
+    }
+}
+
+function computeMonthsParse() {
+    function cmpLenRev(a, b) {
+        return b.length - a.length;
+    }
+
+    var shortPieces = [],
+        longPieces = [],
+        mixedPieces = [],
+        i,
+        mom;
+    for (i = 0; i < 12; i++) {
+        // make the regex if we don't have it already
+        mom = createUTC([2000, i]);
+        shortPieces.push(this.monthsShort(mom, ''));
+        longPieces.push(this.months(mom, ''));
+        mixedPieces.push(this.months(mom, ''));
+        mixedPieces.push(this.monthsShort(mom, ''));
+    }
+    // Sorting makes sure if one month (or abbr) is a prefix of another it
+    // will match the longer piece.
+    shortPieces.sort(cmpLenRev);
+    longPieces.sort(cmpLenRev);
+    mixedPieces.sort(cmpLenRev);
+    for (i = 0; i < 12; i++) {
+        shortPieces[i] = regexEscape(shortPieces[i]);
+        longPieces[i] = regexEscape(longPieces[i]);
+    }
+    for (i = 0; i < 24; i++) {
+        mixedPieces[i] = regexEscape(mixedPieces[i]);
+    }
+
+    this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
+    this._monthsShortRegex = this._monthsRegex;
+    this._monthsStrictRegex = new RegExp(
+        '^(' + longPieces.join('|') + ')',
+        'i'
+    );
+    this._monthsShortStrictRegex = new RegExp(
+        '^(' + shortPieces.join('|') + ')',
+        'i'
+    );
+}
+
+// FORMATTING
+
+addFormatToken('Y', 0, 0, function () {
+    var y = this.year();
+    return y <= 9999 ? zeroFill(y, 4) : '+' + y;
+});
+
+addFormatToken(0, ['YY', 2], 0, function () {
+    return this.year() % 100;
+});
+
+addFormatToken(0, ['YYYY', 4], 0, 'year');
+addFormatToken(0, ['YYYYY', 5], 0, 'year');
+addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
+
+// ALIASES
+
+addUnitAlias('year', 'y');
+
+// PRIORITIES
+
+addUnitPriority('year', 1);
+
+// PARSING
+
+addRegexToken('Y', matchSigned);
+addRegexToken('YY', match1to2, match2);
+addRegexToken('YYYY', match1to4, match4);
+addRegexToken('YYYYY', match1to6, match6);
+addRegexToken('YYYYYY', match1to6, match6);
+
+addParseToken(['YYYYY', 'YYYYYY'], YEAR);
+addParseToken('YYYY', function (input, array) {
+    array[YEAR] =
+        input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
+});
+addParseToken('YY', function (input, array) {
+    array[YEAR] = hooks.parseTwoDigitYear(input);
+});
+addParseToken('Y', function (input, array) {
+    array[YEAR] = parseInt(input, 10);
+});
+
+// HELPERS
+
+function daysInYear(year) {
+    return isLeapYear(year) ? 366 : 365;
+}
+
+// HOOKS
+
+hooks.parseTwoDigitYear = function (input) {
+    return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
+};
+
+// MOMENTS
+
+var getSetYear = makeGetSet('FullYear', true);
+
+function getIsLeapYear() {
+    return isLeapYear(this.year());
+}
+
+function createDate(y, m, d, h, M, s, ms) {
+    // can't just apply() to create a date:
+    // https://stackoverflow.com/q/181348
+    var date;
+    // the date constructor remaps years 0-99 to 1900-1999
+    if (y < 100 && y >= 0) {
+        // preserve leap years using a full 400 year cycle, then reset
+        date = new Date(y + 400, m, d, h, M, s, ms);
+        if (isFinite(date.getFullYear())) {
+            date.setFullYear(y);
+        }
+    } else {
+        date = new Date(y, m, d, h, M, s, ms);
+    }
+
+    return date;
+}
+
+function createUTCDate(y) {
+    var date, args;
+    // the Date.UTC function remaps years 0-99 to 1900-1999
+    if (y < 100 && y >= 0) {
+        args = Array.prototype.slice.call(arguments);
+        // preserve leap years using a full 400 year cycle, then reset
+        args[0] = y + 400;
+        date = new Date(Date.UTC.apply(null, args));
+        if (isFinite(date.getUTCFullYear())) {
+            date.setUTCFullYear(y);
+        }
+    } else {
+        date = new Date(Date.UTC.apply(null, arguments));
+    }
+
+    return date;
+}
+
+// start-of-first-week - start-of-year
+function firstWeekOffset(year, dow, doy) {
+    var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
+        fwd = 7 + dow - doy,
+        // first-week day local weekday -- which local weekday is fwd
+        fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
+
+    return -fwdlw + fwd - 1;
+}
+
+// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
+function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
+    var localWeekday = (7 + weekday - dow) % 7,
+        weekOffset = firstWeekOffset(year, dow, doy),
+        dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
+        resYear,
+        resDayOfYear;
+
+    if (dayOfYear <= 0) {
+        resYear = year - 1;
+        resDayOfYear = daysInYear(resYear) + dayOfYear;
+    } else if (dayOfYear > daysInYear(year)) {
+        resYear = year + 1;
+        resDayOfYear = dayOfYear - daysInYear(year);
+    } else {
+        resYear = year;
+        resDayOfYear = dayOfYear;
+    }
+
+    return {
+        year: resYear,
+        dayOfYear: resDayOfYear,
+    };
+}
+
+function weekOfYear(mom, dow, doy) {
+    var weekOffset = firstWeekOffset(mom.year(), dow, doy),
+        week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
+        resWeek,
+        resYear;
+
+    if (week < 1) {
+        resYear = mom.year() - 1;
+        resWeek = week + weeksInYear(resYear, dow, doy);
+    } else if (week > weeksInYear(mom.year(), dow, doy)) {
+        resWeek = week - weeksInYear(mom.year(), dow, doy);
+        resYear = mom.year() + 1;
+    } else {
+        resYear = mom.year();
+        resWeek = week;
+    }
+
+    return {
+        week: resWeek,
+        year: resYear,
+    };
+}
+
+function weeksInYear(year, dow, doy) {
+    var weekOffset = firstWeekOffset(year, dow, doy),
+        weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
+    return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
+}
+
+// FORMATTING
+
+addFormatToken('w', ['ww', 2], 'wo', 'week');
+addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
+
+// ALIASES
+
+addUnitAlias('week', 'w');
+addUnitAlias('isoWeek', 'W');
+
+// PRIORITIES
+
+addUnitPriority('week', 5);
+addUnitPriority('isoWeek', 5);
+
+// PARSING
+
+addRegexToken('w', match1to2);
+addRegexToken('ww', match1to2, match2);
+addRegexToken('W', match1to2);
+addRegexToken('WW', match1to2, match2);
+
+addWeekParseToken(
+    ['w', 'ww', 'W', 'WW'],
+    function (input, week, config, token) {
+        week[token.substr(0, 1)] = toInt(input);
+    }
+);
+
+// HELPERS
+
+// LOCALES
+
+function localeWeek(mom) {
+    return weekOfYear(mom, this._week.dow, this._week.doy).week;
+}
+
+var defaultLocaleWeek = {
+    dow: 0, // Sunday is the first day of the week.
+    doy: 6, // The week that contains Jan 6th is the first week of the year.
+};
+
+function localeFirstDayOfWeek() {
+    return this._week.dow;
+}
+
+function localeFirstDayOfYear() {
+    return this._week.doy;
+}
+
+// MOMENTS
+
+function getSetWeek(input) {
+    var week = this.localeData().week(this);
+    return input == null ? week : this.add((input - week) * 7, 'd');
+}
+
+function getSetISOWeek(input) {
+    var week = weekOfYear(this, 1, 4).week;
+    return input == null ? week : this.add((input - week) * 7, 'd');
+}
+
+// FORMATTING
+
+addFormatToken('d', 0, 'do', 'day');
+
+addFormatToken('dd', 0, 0, function (format) {
+    return this.localeData().weekdaysMin(this, format);
+});
+
+addFormatToken('ddd', 0, 0, function (format) {
+    return this.localeData().weekdaysShort(this, format);
+});
+
+addFormatToken('dddd', 0, 0, function (format) {
+    return this.localeData().weekdays(this, format);
+});
+
+addFormatToken('e', 0, 0, 'weekday');
+addFormatToken('E', 0, 0, 'isoWeekday');
+
+// ALIASES
+
+addUnitAlias('day', 'd');
+addUnitAlias('weekday', 'e');
+addUnitAlias('isoWeekday', 'E');
+
+// PRIORITY
+addUnitPriority('day', 11);
+addUnitPriority('weekday', 11);
+addUnitPriority('isoWeekday', 11);
+
+// PARSING
+
+addRegexToken('d', match1to2);
+addRegexToken('e', match1to2);
+addRegexToken('E', match1to2);
+addRegexToken('dd', function (isStrict, locale) {
+    return locale.weekdaysMinRegex(isStrict);
+});
+addRegexToken('ddd', function (isStrict, locale) {
+    return locale.weekdaysShortRegex(isStrict);
+});
+addRegexToken('dddd', function (isStrict, locale) {
+    return locale.weekdaysRegex(isStrict);
+});
+
+addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
+    var weekday = config._locale.weekdaysParse(input, token, config._strict);
+    // if we didn't get a weekday name, mark the date as invalid
+    if (weekday != null) {
+        week.d = weekday;
+    } else {
+        getParsingFlags(config).invalidWeekday = input;
+    }
+});
+
+addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
+    week[token] = toInt(input);
+});
+
+// HELPERS
+
+function parseWeekday(input, locale) {
+    if (typeof input !== 'string') {
+        return input;
+    }
+
+    if (!isNaN(input)) {
+        return parseInt(input, 10);
+    }
+
+    input = locale.weekdaysParse(input);
+    if (typeof input === 'number') {
+        return input;
+    }
+
+    return null;
+}
+
+function parseIsoWeekday(input, locale) {
+    if (typeof input === 'string') {
+        return locale.weekdaysParse(input) % 7 || 7;
+    }
+    return isNaN(input) ? null : input;
+}
+
+// LOCALES
+function shiftWeekdays(ws, n) {
+    return ws.slice(n, 7).concat(ws.slice(0, n));
+}
+
+var defaultLocaleWeekdays =
+        'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
+    defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+    defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+    defaultWeekdaysRegex = matchWord,
+    defaultWeekdaysShortRegex = matchWord,
+    defaultWeekdaysMinRegex = matchWord;
+
+function localeWeekdays(m, format) {
+    var weekdays = isArray(this._weekdays)
+        ? this._weekdays
+        : this._weekdays[
+              m && m !== true && this._weekdays.isFormat.test(format)
+                  ? 'format'
+                  : 'standalone'
+          ];
+    return m === true
+        ? shiftWeekdays(weekdays, this._week.dow)
+        : m
+        ? weekdays[m.day()]
+        : weekdays;
+}
+
+function localeWeekdaysShort(m) {
+    return m === true
+        ? shiftWeekdays(this._weekdaysShort, this._week.dow)
+        : m
+        ? this._weekdaysShort[m.day()]
+        : this._weekdaysShort;
+}
+
+function localeWeekdaysMin(m) {
+    return m === true
+        ? shiftWeekdays(this._weekdaysMin, this._week.dow)
+        : m
+        ? this._weekdaysMin[m.day()]
+        : this._weekdaysMin;
+}
+
+function handleStrictParse$1(weekdayName, format, strict) {
+    var i,
+        ii,
+        mom,
+        llc = weekdayName.toLocaleLowerCase();
+    if (!this._weekdaysParse) {
+        this._weekdaysParse = [];
+        this._shortWeekdaysParse = [];
+        this._minWeekdaysParse = [];
+
+        for (i = 0; i < 7; ++i) {
+            mom = createUTC([2000, 1]).day(i);
+            this._minWeekdaysParse[i] = this.weekdaysMin(
+                mom,
+                ''
+            ).toLocaleLowerCase();
+            this._shortWeekdaysParse[i] = this.weekdaysShort(
+                mom,
+                ''
+            ).toLocaleLowerCase();
+            this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
+        }
+    }
+
+    if (strict) {
+        if (format === 'dddd') {
+            ii = indexOf.call(this._weekdaysParse, llc);
+            return ii !== -1 ? ii : null;
+        } else if (format === 'ddd') {
+            ii = indexOf.call(this._shortWeekdaysParse, llc);
+            return ii !== -1 ? ii : null;
+        } else {
+            ii = indexOf.call(this._minWeekdaysParse, llc);
+            return ii !== -1 ? ii : null;
+        }
+    } else {
+        if (format === 'dddd') {
+            ii = indexOf.call(this._weekdaysParse, llc);
+            if (ii !== -1) {
+                return ii;
+            }
+            ii = indexOf.call(this._shortWeekdaysParse, llc);
+            if (ii !== -1) {
+                return ii;
+            }
+            ii = indexOf.call(this._minWeekdaysParse, llc);
+            return ii !== -1 ? ii : null;
+        } else if (format === 'ddd') {
+            ii = indexOf.call(this._shortWeekdaysParse, llc);
+            if (ii !== -1) {
+                return ii;
+            }
+            ii = indexOf.call(this._weekdaysParse, llc);
+            if (ii !== -1) {
+                return ii;
+            }
+            ii = indexOf.call(this._minWeekdaysParse, llc);
+            return ii !== -1 ? ii : null;
+        } else {
+            ii = indexOf.call(this._minWeekdaysParse, llc);
+            if (ii !== -1) {
+                return ii;
+            }
+            ii = indexOf.call(this._weekdaysParse, llc);
+            if (ii !== -1) {
+                return ii;
+            }
+            ii = indexOf.call(this._shortWeekdaysParse, llc);
+            return ii !== -1 ? ii : null;
+        }
+    }
+}
+
+function localeWeekdaysParse(weekdayName, format, strict) {
+    var i, mom, regex;
+
+    if (this._weekdaysParseExact) {
+        return handleStrictParse$1.call(this, weekdayName, format, strict);
+    }
+
+    if (!this._weekdaysParse) {
+        this._weekdaysParse = [];
+        this._minWeekdaysParse = [];
+        this._shortWeekdaysParse = [];
+        this._fullWeekdaysParse = [];
+    }
+
+    for (i = 0; i < 7; i++) {
+        // make the regex if we don't have it already
+
+        mom = createUTC([2000, 1]).day(i);
+        if (strict && !this._fullWeekdaysParse[i]) {
+            this._fullWeekdaysParse[i] = new RegExp(
+                '^' + this.weekdays(mom, '').replace('.', '\\.?') + '$',
+                'i'
+            );
+            this._shortWeekdaysParse[i] = new RegExp(
+                '^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$',
+                'i'
+            );
+            this._minWeekdaysParse[i] = new RegExp(
+                '^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$',
+                'i'
+            );
+        }
+        if (!this._weekdaysParse[i]) {
+            regex =
+                '^' +
+                this.weekdays(mom, '') +
+                '|^' +
+                this.weekdaysShort(mom, '') +
+                '|^' +
+                this.weekdaysMin(mom, '');
+            this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
+        }
+        // test the regex
+        if (
+            strict &&
+            format === 'dddd' &&
+            this._fullWeekdaysParse[i].test(weekdayName)
+        ) {
+            return i;
+        } else if (
+            strict &&
+            format === 'ddd' &&
+            this._shortWeekdaysParse[i].test(weekdayName)
+        ) {
+            return i;
+        } else if (
+            strict &&
+            format === 'dd' &&
+            this._minWeekdaysParse[i].test(weekdayName)
+        ) {
+            return i;
+        } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
+            return i;
+        }
+    }
+}
+
+// MOMENTS
+
+function getSetDayOfWeek(input) {
+    if (!this.isValid()) {
+        return input != null ? this : NaN;
+    }
+    var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
+    if (input != null) {
+        input = parseWeekday(input, this.localeData());
+        return this.add(input - day, 'd');
+    } else {
+        return day;
+    }
+}
+
+function getSetLocaleDayOfWeek(input) {
+    if (!this.isValid()) {
+        return input != null ? this : NaN;
+    }
+    var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
+    return input == null ? weekday : this.add(input - weekday, 'd');
+}
+
+function getSetISODayOfWeek(input) {
+    if (!this.isValid()) {
+        return input != null ? this : NaN;
+    }
+
+    // behaves the same as moment#day except
+    // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
+    // as a setter, sunday should belong to the previous week.
+
+    if (input != null) {
+        var weekday = parseIsoWeekday(input, this.localeData());
+        return this.day(this.day() % 7 ? weekday : weekday - 7);
+    } else {
+        return this.day() || 7;
+    }
+}
+
+function weekdaysRegex(isStrict) {
+    if (this._weekdaysParseExact) {
+        if (!hasOwnProp(this, '_weekdaysRegex')) {
+            computeWeekdaysParse.call(this);
+        }
+        if (isStrict) {
+            return this._weekdaysStrictRegex;
+        } else {
+            return this._weekdaysRegex;
+        }
+    } else {
+        if (!hasOwnProp(this, '_weekdaysRegex')) {
+            this._weekdaysRegex = defaultWeekdaysRegex;
+        }
+        return this._weekdaysStrictRegex && isStrict
+            ? this._weekdaysStrictRegex
+            : this._weekdaysRegex;
+    }
+}
+
+function weekdaysShortRegex(isStrict) {
+    if (this._weekdaysParseExact) {
+        if (!hasOwnProp(this, '_weekdaysRegex')) {
+            computeWeekdaysParse.call(this);
+        }
+        if (isStrict) {
+            return this._weekdaysShortStrictRegex;
+        } else {
+            return this._weekdaysShortRegex;
+        }
+    } else {
+        if (!hasOwnProp(this, '_weekdaysShortRegex')) {
+            this._weekdaysShortRegex = defaultWeekdaysShortRegex;
+        }
+        return this._weekdaysShortStrictRegex && isStrict
+            ? this._weekdaysShortStrictRegex
+            : this._weekdaysShortRegex;
+    }
+}
+
+function weekdaysMinRegex(isStrict) {
+    if (this._weekdaysParseExact) {
+        if (!hasOwnProp(this, '_weekdaysRegex')) {
+            computeWeekdaysParse.call(this);
+        }
+        if (isStrict) {
+            return this._weekdaysMinStrictRegex;
+        } else {
+            return this._weekdaysMinRegex;
+        }
+    } else {
+        if (!hasOwnProp(this, '_weekdaysMinRegex')) {
+            this._weekdaysMinRegex = defaultWeekdaysMinRegex;
+        }
+        return this._weekdaysMinStrictRegex && isStrict
+            ? this._weekdaysMinStrictRegex
+            : this._weekdaysMinRegex;
+    }
+}
+
+function computeWeekdaysParse() {
+    function cmpLenRev(a, b) {
+        return b.length - a.length;
+    }
+
+    var minPieces = [],
+        shortPieces = [],
+        longPieces = [],
+        mixedPieces = [],
+        i,
+        mom,
+        minp,
+        shortp,
+        longp;
+    for (i = 0; i < 7; i++) {
+        // make the regex if we don't have it already
+        mom = createUTC([2000, 1]).day(i);
+        minp = regexEscape(this.weekdaysMin(mom, ''));
+        shortp = regexEscape(this.weekdaysShort(mom, ''));
+        longp = regexEscape(this.weekdays(mom, ''));
+        minPieces.push(minp);
+        shortPieces.push(shortp);
+        longPieces.push(longp);
+        mixedPieces.push(minp);
+        mixedPieces.push(shortp);
+        mixedPieces.push(longp);
+    }
+    // Sorting makes sure if one weekday (or abbr) is a prefix of another it
+    // will match the longer piece.
+    minPieces.sort(cmpLenRev);
+    shortPieces.sort(cmpLenRev);
+    longPieces.sort(cmpLenRev);
+    mixedPieces.sort(cmpLenRev);
+
+    this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
+    this._weekdaysShortRegex = this._weekdaysRegex;
+    this._weekdaysMinRegex = this._weekdaysRegex;
+
+    this._weekdaysStrictRegex = new RegExp(
+        '^(' + longPieces.join('|') + ')',
+        'i'
+    );
+    this._weekdaysShortStrictRegex = new RegExp(
+        '^(' + shortPieces.join('|') + ')',
+        'i'
+    );
+    this._weekdaysMinStrictRegex = new RegExp(
+        '^(' + minPieces.join('|') + ')',
+        'i'
+    );
+}
+
+// FORMATTING
+
+function hFormat() {
+    return this.hours() % 12 || 12;
+}
+
+function kFormat() {
+    return this.hours() || 24;
+}
+
+addFormatToken('H', ['HH', 2], 0, 'hour');
+addFormatToken('h', ['hh', 2], 0, hFormat);
+addFormatToken('k', ['kk', 2], 0, kFormat);
+
+addFormatToken('hmm', 0, 0, function () {
+    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
+});
+
+addFormatToken('hmmss', 0, 0, function () {
+    return (
+        '' +
+        hFormat.apply(this) +
+        zeroFill(this.minutes(), 2) +
+        zeroFill(this.seconds(), 2)
+    );
+});
+
+addFormatToken('Hmm', 0, 0, function () {
+    return '' + this.hours() + zeroFill(this.minutes(), 2);
+});
+
+addFormatToken('Hmmss', 0, 0, function () {
+    return (
+        '' +
+        this.hours() +
+        zeroFill(this.minutes(), 2) +
+        zeroFill(this.seconds(), 2)
+    );
+});
+
+function meridiem(token, lowercase) {
+    addFormatToken(token, 0, 0, function () {
+        return this.localeData().meridiem(
+            this.hours(),
+            this.minutes(),
+            lowercase
+        );
+    });
+}
+
+meridiem('a', true);
+meridiem('A', false);
+
+// ALIASES
+
+addUnitAlias('hour', 'h');
+
+// PRIORITY
+addUnitPriority('hour', 13);
+
+// PARSING
+
+function matchMeridiem(isStrict, locale) {
+    return locale._meridiemParse;
+}
+
+addRegexToken('a', matchMeridiem);
+addRegexToken('A', matchMeridiem);
+addRegexToken('H', match1to2);
+addRegexToken('h', match1to2);
+addRegexToken('k', match1to2);
+addRegexToken('HH', match1to2, match2);
+addRegexToken('hh', match1to2, match2);
+addRegexToken('kk', match1to2, match2);
+
+addRegexToken('hmm', match3to4);
+addRegexToken('hmmss', match5to6);
+addRegexToken('Hmm', match3to4);
+addRegexToken('Hmmss', match5to6);
+
+addParseToken(['H', 'HH'], HOUR);
+addParseToken(['k', 'kk'], function (input, array, config) {
+    var kInput = toInt(input);
+    array[HOUR] = kInput === 24 ? 0 : kInput;
+});
+addParseToken(['a', 'A'], function (input, array, config) {
+    config._isPm = config._locale.isPM(input);
+    config._meridiem = input;
+});
+addParseToken(['h', 'hh'], function (input, array, config) {
+    array[HOUR] = toInt(input);
+    getParsingFlags(config).bigHour = true;
+});
+addParseToken('hmm', function (input, array, config) {
+    var pos = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos));
+    array[MINUTE] = toInt(input.substr(pos));
+    getParsingFlags(config).bigHour = true;
+});
+addParseToken('hmmss', function (input, array, config) {
+    var pos1 = input.length - 4,
+        pos2 = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos1));
+    array[MINUTE] = toInt(input.substr(pos1, 2));
+    array[SECOND] = toInt(input.substr(pos2));
+    getParsingFlags(config).bigHour = true;
+});
+addParseToken('Hmm', function (input, array, config) {
+    var pos = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos));
+    array[MINUTE] = toInt(input.substr(pos));
+});
+addParseToken('Hmmss', function (input, array, config) {
+    var pos1 = input.length - 4,
+        pos2 = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos1));
+    array[MINUTE] = toInt(input.substr(pos1, 2));
+    array[SECOND] = toInt(input.substr(pos2));
+});
+
+// LOCALES
+
+function localeIsPM(input) {
+    // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
+    // Using charAt should be more compatible.
+    return (input + '').toLowerCase().charAt(0) === 'p';
+}
+
+var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i,
+    // Setting the hour should keep the time, because the user explicitly
+    // specified which hour they want. So trying to maintain the same hour (in
+    // a new timezone) makes sense. Adding/subtracting hours does not follow
+    // this rule.
+    getSetHour = makeGetSet('Hours', true);
+
+function localeMeridiem(hours, minutes, isLower) {
+    if (hours > 11) {
+        return isLower ? 'pm' : 'PM';
+    } else {
+        return isLower ? 'am' : 'AM';
+    }
+}
+
+var baseConfig = {
+    calendar: defaultCalendar,
+    longDateFormat: defaultLongDateFormat,
+    invalidDate: defaultInvalidDate,
+    ordinal: defaultOrdinal,
+    dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
+    relativeTime: defaultRelativeTime,
+
+    months: defaultLocaleMonths,
+    monthsShort: defaultLocaleMonthsShort,
+
+    week: defaultLocaleWeek,
+
+    weekdays: defaultLocaleWeekdays,
+    weekdaysMin: defaultLocaleWeekdaysMin,
+    weekdaysShort: defaultLocaleWeekdaysShort,
+
+    meridiemParse: defaultLocaleMeridiemParse,
+};
+
+// internal storage for locale config files
+var locales = {},
+    localeFamilies = {},
+    globalLocale;
+
+function commonPrefix(arr1, arr2) {
+    var i,
+        minl = Math.min(arr1.length, arr2.length);
+    for (i = 0; i < minl; i += 1) {
+        if (arr1[i] !== arr2[i]) {
+            return i;
+        }
+    }
+    return minl;
+}
+
+function normalizeLocale(key) {
+    return key ? key.toLowerCase().replace('_', '-') : key;
+}
+
+// pick the locale from the array
+// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
+// substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
+function chooseLocale(names) {
+    var i = 0,
+        j,
+        next,
+        locale,
+        split;
+
+    while (i < names.length) {
+        split = normalizeLocale(names[i]).split('-');
+        j = split.length;
+        next = normalizeLocale(names[i + 1]);
+        next = next ? next.split('-') : null;
+        while (j > 0) {
+            locale = loadLocale(split.slice(0, j).join('-'));
+            if (locale) {
+                return locale;
+            }
+            if (
+                next &&
+                next.length >= j &&
+                commonPrefix(split, next) >= j - 1
+            ) {
+                //the next array item is better than a shallower substring of this one
+                break;
+            }
+            j--;
+        }
+        i++;
+    }
+    return globalLocale;
+}
+
+function isLocaleNameSane(name) {
+    // Prevent names that look like filesystem paths, i.e contain '/' or '\'
+    return name.match('^[^/\\\\]*$') != null;
+}
+
+function loadLocale(name) {
+    var oldLocale = null,
+        aliasedRequire;
+    // TODO: Find a better way to register and load all the locales in Node
+    if (
+        locales[name] === undefined &&
+        typeof module !== 'undefined' &&
+        module &&
+        module.exports &&
+        isLocaleNameSane(name)
+    ) {
+        try {
+            oldLocale = globalLocale._abbr;
+            aliasedRequire = require;
+            aliasedRequire('./locale/' + name);
+            getSetGlobalLocale(oldLocale);
+        } catch (e) {
+            // mark as not found to avoid repeating expensive file require call causing high CPU
+            // when trying to find en-US, en_US, en-us for every format call
+            locales[name] = null; // null means not found
+        }
+    }
+    return locales[name];
+}
+
+// This function will load locale and then set the global locale.  If
+// no arguments are passed in, it will simply return the current global
+// locale key.
+function getSetGlobalLocale(key, values) {
+    var data;
+    if (key) {
+        if (isUndefined(values)) {
+            data = getLocale(key);
+        } else {
+            data = defineLocale(key, values);
+        }
+
+        if (data) {
+            // moment.duration._locale = moment._locale = data;
+            globalLocale = data;
+        } else {
+            if (typeof console !== 'undefined' && console.warn) {
+                //warn user if arguments are passed but the locale could not be set
+                console.warn(
+                    'Locale ' + key + ' not found. Did you forget to load it?'
+                );
+            }
+        }
+    }
+
+    return globalLocale._abbr;
+}
+
+function defineLocale(name, config) {
+    if (config !== null) {
+        var locale,
+            parentConfig = baseConfig;
+        config.abbr = name;
+        if (locales[name] != null) {
+            deprecateSimple(
+                'defineLocaleOverride',
+                'use moment.updateLocale(localeName, config) to change ' +
+                    'an existing locale. moment.defineLocale(localeName, ' +
+                    'config) should only be used for creating a new locale ' +
+                    'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.'
+            );
+            parentConfig = locales[name]._config;
+        } else if (config.parentLocale != null) {
+            if (locales[config.parentLocale] != null) {
+                parentConfig = locales[config.parentLocale]._config;
+            } else {
+                locale = loadLocale(config.parentLocale);
+                if (locale != null) {
+                    parentConfig = locale._config;
+                } else {
+                    if (!localeFamilies[config.parentLocale]) {
+                        localeFamilies[config.parentLocale] = [];
+                    }
+                    localeFamilies[config.parentLocale].push({
+                        name: name,
+                        config: config,
+                    });
+                    return null;
+                }
+            }
+        }
+        locales[name] = new Locale(mergeConfigs(parentConfig, config));
+
+        if (localeFamilies[name]) {
+            localeFamilies[name].forEach(function (x) {
+                defineLocale(x.name, x.config);
+            });
+        }
+
+        // backwards compat for now: also set the locale
+        // make sure we set the locale AFTER all child locales have been
+        // created, so we won't end up with the child locale set.
+        getSetGlobalLocale(name);
+
+        return locales[name];
+    } else {
+        // useful for testing
+        delete locales[name];
+        return null;
+    }
+}
+
+function updateLocale(name, config) {
+    if (config != null) {
+        var locale,
+            tmpLocale,
+            parentConfig = baseConfig;
+
+        if (locales[name] != null && locales[name].parentLocale != null) {
+            // Update existing child locale in-place to avoid memory-leaks
+            locales[name].set(mergeConfigs(locales[name]._config, config));
+        } else {
+            // MERGE
+            tmpLocale = loadLocale(name);
+            if (tmpLocale != null) {
+                parentConfig = tmpLocale._config;
+            }
+            config = mergeConfigs(parentConfig, config);
+            if (tmpLocale == null) {
+                // updateLocale is called for creating a new locale
+                // Set abbr so it will have a name (getters return
+                // undefined otherwise).
+                config.abbr = name;
+            }
+            locale = new Locale(config);
+            locale.parentLocale = locales[name];
+            locales[name] = locale;
+        }
+
+        // backwards compat for now: also set the locale
+        getSetGlobalLocale(name);
+    } else {
+        // pass null for config to unupdate, useful for tests
+        if (locales[name] != null) {
+            if (locales[name].parentLocale != null) {
+                locales[name] = locales[name].parentLocale;
+                if (name === getSetGlobalLocale()) {
+                    getSetGlobalLocale(name);
+                }
+            } else if (locales[name] != null) {
+                delete locales[name];
+            }
+        }
+    }
+    return locales[name];
+}
+
+// returns locale data
+function getLocale(key) {
+    var locale;
+
+    if (key && key._locale && key._locale._abbr) {
+        key = key._locale._abbr;
+    }
+
+    if (!key) {
+        return globalLocale;
+    }
+
+    if (!isArray(key)) {
+        //short-circuit everything else
+        locale = loadLocale(key);
+        if (locale) {
+            return locale;
+        }
+        key = [key];
+    }
+
+    return chooseLocale(key);
+}
+
+function listLocales() {
+    return keys(locales);
+}
+
+function checkOverflow(m) {
+    var overflow,
+        a = m._a;
+
+    if (a && getParsingFlags(m).overflow === -2) {
+        overflow =
+            a[MONTH] < 0 || a[MONTH] > 11
+                ? MONTH
+                : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH])
+                ? DATE
+                : a[HOUR] < 0 ||
+                  a[HOUR] > 24 ||
+                  (a[HOUR] === 24 &&
+                      (a[MINUTE] !== 0 ||
+                          a[SECOND] !== 0 ||
+                          a[MILLISECOND] !== 0))
+                ? HOUR
+                : a[MINUTE] < 0 || a[MINUTE] > 59
+                ? MINUTE
+                : a[SECOND] < 0 || a[SECOND] > 59
+                ? SECOND
+                : a[MILLISECOND] < 0 || a[MILLISECOND] > 999
+                ? MILLISECOND
+                : -1;
+
+        if (
+            getParsingFlags(m)._overflowDayOfYear &&
+            (overflow < YEAR || overflow > DATE)
+        ) {
+            overflow = DATE;
+        }
+        if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
+            overflow = WEEK;
+        }
+        if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
+            overflow = WEEKDAY;
+        }
+
+        getParsingFlags(m).overflow = overflow;
+    }
+
+    return m;
+}
+
+// iso 8601 regex
+// 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
+var extendedIsoRegex =
+        /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
+    basicIsoRegex =
+        /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
+    tzRegex = /Z|[+-]\d\d(?::?\d\d)?/,
+    isoDates = [
+        ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
+        ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
+        ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
+        ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
+        ['YYYY-DDD', /\d{4}-\d{3}/],
+        ['YYYY-MM', /\d{4}-\d\d/, false],
+        ['YYYYYYMMDD', /[+-]\d{10}/],
+        ['YYYYMMDD', /\d{8}/],
+        ['GGGG[W]WWE', /\d{4}W\d{3}/],
+        ['GGGG[W]WW', /\d{4}W\d{2}/, false],
+        ['YYYYDDD', /\d{7}/],
+        ['YYYYMM', /\d{6}/, false],
+        ['YYYY', /\d{4}/, false],
+    ],
+    // iso time formats and regexes
+    isoTimes = [
+        ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
+        ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
+        ['HH:mm:ss', /\d\d:\d\d:\d\d/],
+        ['HH:mm', /\d\d:\d\d/],
+        ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
+        ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
+        ['HHmmss', /\d\d\d\d\d\d/],
+        ['HHmm', /\d\d\d\d/],
+        ['HH', /\d\d/],
+    ],
+    aspNetJsonRegex = /^\/?Date\((-?\d+)/i,
+    // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
+    rfc2822 =
+        /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/,
+    obsOffsets = {
+        UT: 0,
+        GMT: 0,
+        EDT: -4 * 60,
+        EST: -5 * 60,
+        CDT: -5 * 60,
+        CST: -6 * 60,
+        MDT: -6 * 60,
+        MST: -7 * 60,
+        PDT: -7 * 60,
+        PST: -8 * 60,
+    };
+
+// date from iso format
+function configFromISO(config) {
+    var i,
+        l,
+        string = config._i,
+        match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
+        allowTime,
+        dateFormat,
+        timeFormat,
+        tzFormat,
+        isoDatesLen = isoDates.length,
+        isoTimesLen = isoTimes.length;
+
+    if (match) {
+        getParsingFlags(config).iso = true;
+        for (i = 0, l = isoDatesLen; i < l; i++) {
+            if (isoDates[i][1].exec(match[1])) {
+                dateFormat = isoDates[i][0];
+                allowTime = isoDates[i][2] !== false;
+                break;
+            }
+        }
+        if (dateFormat == null) {
+            config._isValid = false;
+            return;
+        }
+        if (match[3]) {
+            for (i = 0, l = isoTimesLen; i < l; i++) {
+                if (isoTimes[i][1].exec(match[3])) {
+                    // match[2] should be 'T' or space
+                    timeFormat = (match[2] || ' ') + isoTimes[i][0];
+                    break;
+                }
+            }
+            if (timeFormat == null) {
+                config._isValid = false;
+                return;
+            }
+        }
+        if (!allowTime && timeFormat != null) {
+            config._isValid = false;
+            return;
+        }
+        if (match[4]) {
+            if (tzRegex.exec(match[4])) {
+                tzFormat = 'Z';
+            } else {
+                config._isValid = false;
+                return;
+            }
+        }
+        config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
+        configFromStringAndFormat(config);
+    } else {
+        config._isValid = false;
+    }
+}
+
+function extractFromRFC2822Strings(
+    yearStr,
+    monthStr,
+    dayStr,
+    hourStr,
+    minuteStr,
+    secondStr
+) {
+    var result = [
+        untruncateYear(yearStr),
+        defaultLocaleMonthsShort.indexOf(monthStr),
+        parseInt(dayStr, 10),
+        parseInt(hourStr, 10),
+        parseInt(minuteStr, 10),
+    ];
+
+    if (secondStr) {
+        result.push(parseInt(secondStr, 10));
+    }
+
+    return result;
+}
+
+function untruncateYear(yearStr) {
+    var year = parseInt(yearStr, 10);
+    if (year <= 49) {
+        return 2000 + year;
+    } else if (year <= 999) {
+        return 1900 + year;
+    }
+    return year;
+}
+
+function preprocessRFC2822(s) {
+    // Remove comments and folding whitespace and replace multiple-spaces with a single space
+    return s
+        .replace(/\([^()]*\)|[\n\t]/g, ' ')
+        .replace(/(\s\s+)/g, ' ')
+        .replace(/^\s\s*/, '')
+        .replace(/\s\s*$/, '');
+}
+
+function checkWeekday(weekdayStr, parsedInput, config) {
+    if (weekdayStr) {
+        // TODO: Replace the vanilla JS Date object with an independent day-of-week check.
+        var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),
+            weekdayActual = new Date(
+                parsedInput[0],
+                parsedInput[1],
+                parsedInput[2]
+            ).getDay();
+        if (weekdayProvided !== weekdayActual) {
+            getParsingFlags(config).weekdayMismatch = true;
+            config._isValid = false;
+            return false;
+        }
+    }
+    return true;
+}
+
+function calculateOffset(obsOffset, militaryOffset, numOffset) {
+    if (obsOffset) {
+        return obsOffsets[obsOffset];
+    } else if (militaryOffset) {
+        // the only allowed military tz is Z
+        return 0;
+    } else {
+        var hm = parseInt(numOffset, 10),
+            m = hm % 100,
+            h = (hm - m) / 100;
+        return h * 60 + m;
+    }
+}
+
+// date and time from ref 2822 format
+function configFromRFC2822(config) {
+    var match = rfc2822.exec(preprocessRFC2822(config._i)),
+        parsedArray;
+    if (match) {
+        parsedArray = extractFromRFC2822Strings(
+            match[4],
+            match[3],
+            match[2],
+            match[5],
+            match[6],
+            match[7]
+        );
+        if (!checkWeekday(match[1], parsedArray, config)) {
+            return;
+        }
+
+        config._a = parsedArray;
+        config._tzm = calculateOffset(match[8], match[9], match[10]);
+
+        config._d = createUTCDate.apply(null, config._a);
+        config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
+
+        getParsingFlags(config).rfc2822 = true;
+    } else {
+        config._isValid = false;
+    }
+}
+
+// date from 1) ASP.NET, 2) ISO, 3) RFC 2822 formats, or 4) optional fallback if parsing isn't strict
+function configFromString(config) {
+    var matched = aspNetJsonRegex.exec(config._i);
+    if (matched !== null) {
+        config._d = new Date(+matched[1]);
+        return;
+    }
+
+    configFromISO(config);
+    if (config._isValid === false) {
+        delete config._isValid;
+    } else {
+        return;
+    }
+
+    configFromRFC2822(config);
+    if (config._isValid === false) {
+        delete config._isValid;
+    } else {
+        return;
+    }
+
+    if (config._strict) {
+        config._isValid = false;
+    } else {
+        // Final attempt, use Input Fallback
+        hooks.createFromInputFallback(config);
+    }
+}
+
+hooks.createFromInputFallback = deprecate(
+    'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
+        'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
+        'discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.',
+    function (config) {
+        config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
+    }
+);
+
+// Pick the first defined of two or three arguments.
+function defaults(a, b, c) {
+    if (a != null) {
+        return a;
+    }
+    if (b != null) {
+        return b;
+    }
+    return c;
+}
+
+function currentDateArray(config) {
+    // hooks is actually the exported moment object
+    var nowValue = new Date(hooks.now());
+    if (config._useUTC) {
+        return [
+            nowValue.getUTCFullYear(),
+            nowValue.getUTCMonth(),
+            nowValue.getUTCDate(),
+        ];
+    }
+    return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
+}
+
+// convert an array to a date.
+// the array should mirror the parameters below
+// note: all values past the year are optional and will default to the lowest possible value.
+// [year, month, day , hour, minute, second, millisecond]
+function configFromArray(config) {
+    var i,
+        date,
+        input = [],
+        currentDate,
+        expectedWeekday,
+        yearToUse;
+
+    if (config._d) {
+        return;
+    }
+
+    currentDate = currentDateArray(config);
+
+    //compute day of the year from weeks and weekdays
+    if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
+        dayOfYearFromWeekInfo(config);
+    }
+
+    //if the day of the year is set, figure out what it is
+    if (config._dayOfYear != null) {
+        yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
+
+        if (
+            config._dayOfYear > daysInYear(yearToUse) ||
+            config._dayOfYear === 0
+        ) {
+            getParsingFlags(config)._overflowDayOfYear = true;
+        }
+
+        date = createUTCDate(yearToUse, 0, config._dayOfYear);
+        config._a[MONTH] = date.getUTCMonth();
+        config._a[DATE] = date.getUTCDate();
+    }
+
+    // Default to current date.
+    // * if no year, month, day of month are given, default to today
+    // * if day of month is given, default month and year
+    // * if month is given, default only year
+    // * if year is given, don't default anything
+    for (i = 0; i < 3 && config._a[i] == null; ++i) {
+        config._a[i] = input[i] = currentDate[i];
+    }
+
+    // Zero out whatever was not defaulted, including time
+    for (; i < 7; i++) {
+        config._a[i] = input[i] =
+            config._a[i] == null ? (i === 2 ? 1 : 0) : config._a[i];
+    }
+
+    // Check for 24:00:00.000
+    if (
+        config._a[HOUR] === 24 &&
+        config._a[MINUTE] === 0 &&
+        config._a[SECOND] === 0 &&
+        config._a[MILLISECOND] === 0
+    ) {
+        config._nextDay = true;
+        config._a[HOUR] = 0;
+    }
+
+    config._d = (config._useUTC ? createUTCDate : createDate).apply(
+        null,
+        input
+    );
+    expectedWeekday = config._useUTC
+        ? config._d.getUTCDay()
+        : config._d.getDay();
+
+    // Apply timezone offset from input. The actual utcOffset can be changed
+    // with parseZone.
+    if (config._tzm != null) {
+        config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
+    }
+
+    if (config._nextDay) {
+        config._a[HOUR] = 24;
+    }
+
+    // check for mismatching day of week
+    if (
+        config._w &&
+        typeof config._w.d !== 'undefined' &&
+        config._w.d !== expectedWeekday
+    ) {
+        getParsingFlags(config).weekdayMismatch = true;
+    }
+}
+
+function dayOfYearFromWeekInfo(config) {
+    var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek;
+
+    w = config._w;
+    if (w.GG != null || w.W != null || w.E != null) {
+        dow = 1;
+        doy = 4;
+
+        // TODO: We need to take the current isoWeekYear, but that depends on
+        // how we interpret now (local, utc, fixed offset). So create
+        // a now version of current config (take local/utc/offset flags, and
+        // create now).
+        weekYear = defaults(
+            w.GG,
+            config._a[YEAR],
+            weekOfYear(createLocal(), 1, 4).year
+        );
+        week = defaults(w.W, 1);
+        weekday = defaults(w.E, 1);
+        if (weekday < 1 || weekday > 7) {
+            weekdayOverflow = true;
+        }
+    } else {
+        dow = config._locale._week.dow;
+        doy = config._locale._week.doy;
+
+        curWeek = weekOfYear(createLocal(), dow, doy);
+
+        weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
+
+        // Default to current week.
+        week = defaults(w.w, curWeek.week);
+
+        if (w.d != null) {
+            // weekday -- low day numbers are considered next week
+            weekday = w.d;
+            if (weekday < 0 || weekday > 6) {
+                weekdayOverflow = true;
+            }
+        } else if (w.e != null) {
+            // local weekday -- counting starts from beginning of week
+            weekday = w.e + dow;
+            if (w.e < 0 || w.e > 6) {
+                weekdayOverflow = true;
+            }
+        } else {
+            // default to beginning of week
+            weekday = dow;
+        }
+    }
+    if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
+        getParsingFlags(config)._overflowWeeks = true;
+    } else if (weekdayOverflow != null) {
+        getParsingFlags(config)._overflowWeekday = true;
+    } else {
+        temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
+        config._a[YEAR] = temp.year;
+        config._dayOfYear = temp.dayOfYear;
+    }
+}
+
+// constant that refers to the ISO standard
+hooks.ISO_8601 = function () {};
+
+// constant that refers to the RFC 2822 form
+hooks.RFC_2822 = function () {};
+
+// date from string and format string
+function configFromStringAndFormat(config) {
+    // TODO: Move this to another part of the creation flow to prevent circular deps
+    if (config._f === hooks.ISO_8601) {
+        configFromISO(config);
+        return;
+    }
+    if (config._f === hooks.RFC_2822) {
+        configFromRFC2822(config);
+        return;
+    }
+    config._a = [];
+    getParsingFlags(config).empty = true;
+
+    // This array is used to make a Date, either with `new Date` or `Date.UTC`
+    var string = '' + config._i,
+        i,
+        parsedInput,
+        tokens,
+        token,
+        skipped,
+        stringLength = string.length,
+        totalParsedInputLength = 0,
+        era,
+        tokenLen;
+
+    tokens =
+        expandFormat(config._f, config._locale).match(formattingTokens) || [];
+    tokenLen = tokens.length;
+    for (i = 0; i < tokenLen; i++) {
+        token = tokens[i];
+        parsedInput = (string.match(getParseRegexForToken(token, config)) ||
+            [])[0];
+        if (parsedInput) {
+            skipped = string.substr(0, string.indexOf(parsedInput));
+            if (skipped.length > 0) {
+                getParsingFlags(config).unusedInput.push(skipped);
+            }
+            string = string.slice(
+                string.indexOf(parsedInput) + parsedInput.length
+            );
+            totalParsedInputLength += parsedInput.length;
+        }
+        // don't parse if it's not a known token
+        if (formatTokenFunctions[token]) {
+            if (parsedInput) {
+                getParsingFlags(config).empty = false;
+            } else {
+                getParsingFlags(config).unusedTokens.push(token);
+            }
+            addTimeToArrayFromToken(token, parsedInput, config);
+        } else if (config._strict && !parsedInput) {
+            getParsingFlags(config).unusedTokens.push(token);
+        }
+    }
+
+    // add remaining unparsed input length to the string
+    getParsingFlags(config).charsLeftOver =
+        stringLength - totalParsedInputLength;
+    if (string.length > 0) {
+        getParsingFlags(config).unusedInput.push(string);
+    }
+
+    // clear _12h flag if hour is <= 12
+    if (
+        config._a[HOUR] <= 12 &&
+        getParsingFlags(config).bigHour === true &&
+        config._a[HOUR] > 0
+    ) {
+        getParsingFlags(config).bigHour = undefined;
+    }
+
+    getParsingFlags(config).parsedDateParts = config._a.slice(0);
+    getParsingFlags(config).meridiem = config._meridiem;
+    // handle meridiem
+    config._a[HOUR] = meridiemFixWrap(
+        config._locale,
+        config._a[HOUR],
+        config._meridiem
+    );
+
+    // handle era
+    era = getParsingFlags(config).era;
+    if (era !== null) {
+        config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]);
+    }
+
+    configFromArray(config);
+    checkOverflow(config);
+}
+
+function meridiemFixWrap(locale, hour, meridiem) {
+    var isPm;
+
+    if (meridiem == null) {
+        // nothing to do
+        return hour;
+    }
+    if (locale.meridiemHour != null) {
+        return locale.meridiemHour(hour, meridiem);
+    } else if (locale.isPM != null) {
+        // Fallback
+        isPm = locale.isPM(meridiem);
+        if (isPm && hour < 12) {
+            hour += 12;
+        }
+        if (!isPm && hour === 12) {
+            hour = 0;
+        }
+        return hour;
+    } else {
+        // this is not supposed to happen
+        return hour;
+    }
+}
+
+// date from string and array of format strings
+function configFromStringAndArray(config) {
+    var tempConfig,
+        bestMoment,
+        scoreToBeat,
+        i,
+        currentScore,
+        validFormatFound,
+        bestFormatIsValid = false,
+        configfLen = config._f.length;
+
+    if (configfLen === 0) {
+        getParsingFlags(config).invalidFormat = true;
+        config._d = new Date(NaN);
+        return;
+    }
+
+    for (i = 0; i < configfLen; i++) {
+        currentScore = 0;
+        validFormatFound = false;
+        tempConfig = copyConfig({}, config);
+        if (config._useUTC != null) {
+            tempConfig._useUTC = config._useUTC;
+        }
+        tempConfig._f = config._f[i];
+        configFromStringAndFormat(tempConfig);
+
+        if (isValid(tempConfig)) {
+            validFormatFound = true;
+        }
+
+        // if there is any input that was not parsed add a penalty for that format
+        currentScore += getParsingFlags(tempConfig).charsLeftOver;
+
+        //or tokens
+        currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
+
+        getParsingFlags(tempConfig).score = currentScore;
+
+        if (!bestFormatIsValid) {
+            if (
+                scoreToBeat == null ||
+                currentScore < scoreToBeat ||
+                validFormatFound
+            ) {
+                scoreToBeat = currentScore;
+                bestMoment = tempConfig;
+                if (validFormatFound) {
+                    bestFormatIsValid = true;
+                }
+            }
+        } else {
+            if (currentScore < scoreToBeat) {
+                scoreToBeat = currentScore;
+                bestMoment = tempConfig;
+            }
+        }
+    }
+
+    extend(config, bestMoment || tempConfig);
+}
+
+function configFromObject(config) {
+    if (config._d) {
+        return;
+    }
+
+    var i = normalizeObjectUnits(config._i),
+        dayOrDate = i.day === undefined ? i.date : i.day;
+    config._a = map(
+        [i.year, i.month, dayOrDate, i.hour, i.minute, i.second, i.millisecond],
+        function (obj) {
+            return obj && parseInt(obj, 10);
+        }
+    );
+
+    configFromArray(config);
+}
+
+function createFromConfig(config) {
+    var res = new Moment(checkOverflow(prepareConfig(config)));
+    if (res._nextDay) {
+        // Adding is smart enough around DST
+        res.add(1, 'd');
+        res._nextDay = undefined;
+    }
+
+    return res;
+}
+
+function prepareConfig(config) {
+    var input = config._i,
+        format = config._f;
+
+    config._locale = config._locale || getLocale(config._l);
+
+    if (input === null || (format === undefined && input === '')) {
+        return createInvalid({ nullInput: true });
+    }
+
+    if (typeof input === 'string') {
+        config._i = input = config._locale.preparse(input);
+    }
+
+    if (isMoment(input)) {
+        return new Moment(checkOverflow(input));
+    } else if (isDate(input)) {
+        config._d = input;
+    } else if (isArray(format)) {
+        configFromStringAndArray(config);
+    } else if (format) {
+        configFromStringAndFormat(config);
+    } else {
+        configFromInput(config);
+    }
+
+    if (!isValid(config)) {
+        config._d = null;
+    }
+
+    return config;
+}
+
+function configFromInput(config) {
+    var input = config._i;
+    if (isUndefined(input)) {
+        config._d = new Date(hooks.now());
+    } else if (isDate(input)) {
+        config._d = new Date(input.valueOf());
+    } else if (typeof input === 'string') {
+        configFromString(config);
+    } else if (isArray(input)) {
+        config._a = map(input.slice(0), function (obj) {
+            return parseInt(obj, 10);
+        });
+        configFromArray(config);
+    } else if (isObject(input)) {
+        configFromObject(config);
+    } else if (isNumber(input)) {
+        // from milliseconds
+        config._d = new Date(input);
+    } else {
+        hooks.createFromInputFallback(config);
+    }
+}
+
+function createLocalOrUTC(input, format, locale, strict, isUTC) {
+    var c = {};
+
+    if (format === true || format === false) {
+        strict = format;
+        format = undefined;
+    }
+
+    if (locale === true || locale === false) {
+        strict = locale;
+        locale = undefined;
+    }
+
+    if (
+        (isObject(input) && isObjectEmpty(input)) ||
+        (isArray(input) && input.length === 0)
+    ) {
+        input = undefined;
+    }
+    // object construction must be done this way.
+    // https://github.com/moment/moment/issues/1423
+    c._isAMomentObject = true;
+    c._useUTC = c._isUTC = isUTC;
+    c._l = locale;
+    c._i = input;
+    c._f = format;
+    c._strict = strict;
+
+    return createFromConfig(c);
+}
+
+function createLocal(input, format, locale, strict) {
+    return createLocalOrUTC(input, format, locale, strict, false);
+}
+
+var prototypeMin = deprecate(
+        'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
+        function () {
+            var other = createLocal.apply(null, arguments);
+            if (this.isValid() && other.isValid()) {
+                return other < this ? this : other;
+            } else {
+                return createInvalid();
+            }
+        }
+    ),
+    prototypeMax = deprecate(
+        'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
+        function () {
+            var other = createLocal.apply(null, arguments);
+            if (this.isValid() && other.isValid()) {
+                return other > this ? this : other;
+            } else {
+                return createInvalid();
+            }
+        }
+    );
+
+// Pick a moment m from moments so that m[fn](other) is true for all
+// other. This relies on the function fn to be transitive.
+//
+// moments should either be an array of moment objects or an array, whose
+// first element is an array of moment objects.
+function pickBy(fn, moments) {
+    var res, i;
+    if (moments.length === 1 && isArray(moments[0])) {
+        moments = moments[0];
+    }
+    if (!moments.length) {
+        return createLocal();
+    }
+    res = moments[0];
+    for (i = 1; i < moments.length; ++i) {
+        if (!moments[i].isValid() || moments[i][fn](res)) {
+            res = moments[i];
+        }
+    }
+    return res;
+}
+
+// TODO: Use [].sort instead?
+function min() {
+    var args = [].slice.call(arguments, 0);
+
+    return pickBy('isBefore', args);
+}
+
+function max() {
+    var args = [].slice.call(arguments, 0);
+
+    return pickBy('isAfter', args);
+}
+
+var now = function () {
+    return Date.now ? Date.now() : +new Date();
+};
+
+var ordering = [
+    'year',
+    'quarter',
+    'month',
+    'week',
+    'day',
+    'hour',
+    'minute',
+    'second',
+    'millisecond',
+];
+
+function isDurationValid(m) {
+    var key,
+        unitHasDecimal = false,
+        i,
+        orderLen = ordering.length;
+    for (key in m) {
+        if (
+            hasOwnProp(m, key) &&
+            !(
+                indexOf.call(ordering, key) !== -1 &&
+                (m[key] == null || !isNaN(m[key]))
+            )
+        ) {
+            return false;
+        }
+    }
+
+    for (i = 0; i < orderLen; ++i) {
+        if (m[ordering[i]]) {
+            if (unitHasDecimal) {
+                return false; // only allow non-integers for smallest unit
+            }
+            if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
+                unitHasDecimal = true;
+            }
+        }
+    }
+
+    return true;
+}
+
+function isValid$1() {
+    return this._isValid;
+}
+
+function createInvalid$1() {
+    return createDuration(NaN);
+}
+
+function Duration(duration) {
+    var normalizedInput = normalizeObjectUnits(duration),
+        years = normalizedInput.year || 0,
+        quarters = normalizedInput.quarter || 0,
+        months = normalizedInput.month || 0,
+        weeks = normalizedInput.week || normalizedInput.isoWeek || 0,
+        days = normalizedInput.day || 0,
+        hours = normalizedInput.hour || 0,
+        minutes = normalizedInput.minute || 0,
+        seconds = normalizedInput.second || 0,
+        milliseconds = normalizedInput.millisecond || 0;
+
+    this._isValid = isDurationValid(normalizedInput);
+
+    // representation for dateAddRemove
+    this._milliseconds =
+        +milliseconds +
+        seconds * 1e3 + // 1000
+        minutes * 6e4 + // 1000 * 60
+        hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
+    // Because of dateAddRemove treats 24 hours as different from a
+    // day when working around DST, we need to store them separately
+    this._days = +days + weeks * 7;
+    // It is impossible to translate months into days without knowing
+    // which months you are are talking about, so we have to store
+    // it separately.
+    this._months = +months + quarters * 3 + years * 12;
+
+    this._data = {};
+
+    this._locale = getLocale();
+
+    this._bubble();
+}
+
+function isDuration(obj) {
+    return obj instanceof Duration;
+}
+
+function absRound(number) {
+    if (number < 0) {
+        return Math.round(-1 * number) * -1;
+    } else {
+        return Math.round(number);
+    }
+}
+
+// compare two arrays, return the number of differences
+function compareArrays(array1, array2, dontConvert) {
+    var len = Math.min(array1.length, array2.length),
+        lengthDiff = Math.abs(array1.length - array2.length),
+        diffs = 0,
+        i;
+    for (i = 0; i < len; i++) {
+        if (
+            (dontConvert && array1[i] !== array2[i]) ||
+            (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))
+        ) {
+            diffs++;
+        }
+    }
+    return diffs + lengthDiff;
+}
+
+// FORMATTING
+
+function offset(token, separator) {
+    addFormatToken(token, 0, 0, function () {
+        var offset = this.utcOffset(),
+            sign = '+';
+        if (offset < 0) {
+            offset = -offset;
+            sign = '-';
+        }
+        return (
+            sign +
+            zeroFill(~~(offset / 60), 2) +
+            separator +
+            zeroFill(~~offset % 60, 2)
+        );
+    });
+}
+
+offset('Z', ':');
+offset('ZZ', '');
+
+// PARSING
+
+addRegexToken('Z', matchShortOffset);
+addRegexToken('ZZ', matchShortOffset);
+addParseToken(['Z', 'ZZ'], function (input, array, config) {
+    config._useUTC = true;
+    config._tzm = offsetFromString(matchShortOffset, input);
+});
+
+// HELPERS
+
+// timezone chunker
+// '+10:00' > ['10',  '00']
+// '-1530'  > ['-15', '30']
+var chunkOffset = /([\+\-]|\d\d)/gi;
+
+function offsetFromString(matcher, string) {
+    var matches = (string || '').match(matcher),
+        chunk,
+        parts,
+        minutes;
+
+    if (matches === null) {
+        return null;
+    }
+
+    chunk = matches[matches.length - 1] || [];
+    parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
+    minutes = +(parts[1] * 60) + toInt(parts[2]);
+
+    return minutes === 0 ? 0 : parts[0] === '+' ? minutes : -minutes;
+}
+
+// Return a moment from input, that is local/utc/zone equivalent to model.
+function cloneWithOffset(input, model) {
+    var res, diff;
+    if (model._isUTC) {
+        res = model.clone();
+        diff =
+            (isMoment(input) || isDate(input)
+                ? input.valueOf()
+                : createLocal(input).valueOf()) - res.valueOf();
+        // Use low-level api, because this fn is low-level api.
+        res._d.setTime(res._d.valueOf() + diff);
+        hooks.updateOffset(res, false);
+        return res;
+    } else {
+        return createLocal(input).local();
+    }
+}
+
+function getDateOffset(m) {
+    // On Firefox.24 Date#getTimezoneOffset returns a floating point.
+    // https://github.com/moment/moment/pull/1871
+    return -Math.round(m._d.getTimezoneOffset());
+}
+
+// HOOKS
+
+// This function will be called whenever a moment is mutated.
+// It is intended to keep the offset in sync with the timezone.
+hooks.updateOffset = function () {};
+
+// MOMENTS
+
+// keepLocalTime = true means only change the timezone, without
+// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
+// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
+// +0200, so we adjust the time as needed, to be valid.
+//
+// Keeping the time actually adds/subtracts (one hour)
+// from the actual represented time. That is why we call updateOffset
+// a second time. In case it wants us to change the offset again
+// _changeInProgress == true case, then we have to adjust, because
+// there is no such time in the given timezone.
+function getSetOffset(input, keepLocalTime, keepMinutes) {
+    var offset = this._offset || 0,
+        localAdjust;
+    if (!this.isValid()) {
+        return input != null ? this : NaN;
+    }
+    if (input != null) {
+        if (typeof input === 'string') {
+            input = offsetFromString(matchShortOffset, input);
+            if (input === null) {
+                return this;
+            }
+        } else if (Math.abs(input) < 16 && !keepMinutes) {
+            input = input * 60;
+        }
+        if (!this._isUTC && keepLocalTime) {
+            localAdjust = getDateOffset(this);
+        }
+        this._offset = input;
+        this._isUTC = true;
+        if (localAdjust != null) {
+            this.add(localAdjust, 'm');
+        }
+        if (offset !== input) {
+            if (!keepLocalTime || this._changeInProgress) {
+                addSubtract(
+                    this,
+                    createDuration(input - offset, 'm'),
+                    1,
+                    false
+                );
+            } else if (!this._changeInProgress) {
+                this._changeInProgress = true;
+                hooks.updateOffset(this, true);
+                this._changeInProgress = null;
+            }
+        }
+        return this;
+    } else {
+        return this._isUTC ? offset : getDateOffset(this);
+    }
+}
+
+function getSetZone(input, keepLocalTime) {
+    if (input != null) {
+        if (typeof input !== 'string') {
+            input = -input;
+        }
+
+        this.utcOffset(input, keepLocalTime);
+
+        return this;
+    } else {
+        return -this.utcOffset();
+    }
+}
+
+function setOffsetToUTC(keepLocalTime) {
+    return this.utcOffset(0, keepLocalTime);
+}
+
+function setOffsetToLocal(keepLocalTime) {
+    if (this._isUTC) {
+        this.utcOffset(0, keepLocalTime);
+        this._isUTC = false;
+
+        if (keepLocalTime) {
+            this.subtract(getDateOffset(this), 'm');
+        }
+    }
+    return this;
+}
+
+function setOffsetToParsedOffset() {
+    if (this._tzm != null) {
+        this.utcOffset(this._tzm, false, true);
+    } else if (typeof this._i === 'string') {
+        var tZone = offsetFromString(matchOffset, this._i);
+        if (tZone != null) {
+            this.utcOffset(tZone);
+        } else {
+            this.utcOffset(0, true);
+        }
+    }
+    return this;
+}
+
+function hasAlignedHourOffset(input) {
+    if (!this.isValid()) {
+        return false;
+    }
+    input = input ? createLocal(input).utcOffset() : 0;
+
+    return (this.utcOffset() - input) % 60 === 0;
+}
+
+function isDaylightSavingTime() {
+    return (
+        this.utcOffset() > this.clone().month(0).utcOffset() ||
+        this.utcOffset() > this.clone().month(5).utcOffset()
+    );
+}
+
+function isDaylightSavingTimeShifted() {
+    if (!isUndefined(this._isDSTShifted)) {
+        return this._isDSTShifted;
+    }
+
+    var c = {},
+        other;
+
+    copyConfig(c, this);
+    c = prepareConfig(c);
+
+    if (c._a) {
+        other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
+        this._isDSTShifted =
+            this.isValid() && compareArrays(c._a, other.toArray()) > 0;
+    } else {
+        this._isDSTShifted = false;
+    }
+
+    return this._isDSTShifted;
+}
+
+function isLocal() {
+    return this.isValid() ? !this._isUTC : false;
+}
+
+function isUtcOffset() {
+    return this.isValid() ? this._isUTC : false;
+}
+
+function isUtc() {
+    return this.isValid() ? this._isUTC && this._offset === 0 : false;
+}
+
+// ASP.NET json date format regex
+var aspNetRegex = /^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/,
+    // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
+    // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
+    // and further modified to allow for strings containing both week and day
+    isoRegex =
+        /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
+
+function createDuration(input, key) {
+    var duration = input,
+        // matching against regexp is expensive, do it on demand
+        match = null,
+        sign,
+        ret,
+        diffRes;
+
+    if (isDuration(input)) {
+        duration = {
+            ms: input._milliseconds,
+            d: input._days,
+            M: input._months,
+        };
+    } else if (isNumber(input) || !isNaN(+input)) {
+        duration = {};
+        if (key) {
+            duration[key] = +input;
+        } else {
+            duration.milliseconds = +input;
+        }
+    } else if ((match = aspNetRegex.exec(input))) {
+        sign = match[1] === '-' ? -1 : 1;
+        duration = {
+            y: 0,
+            d: toInt(match[DATE]) * sign,
+            h: toInt(match[HOUR]) * sign,
+            m: toInt(match[MINUTE]) * sign,
+            s: toInt(match[SECOND]) * sign,
+            ms: toInt(absRound(match[MILLISECOND] * 1000)) * sign, // the millisecond decimal point is included in the match
+        };
+    } else if ((match = isoRegex.exec(input))) {
+        sign = match[1] === '-' ? -1 : 1;
+        duration = {
+            y: parseIso(match[2], sign),
+            M: parseIso(match[3], sign),
+            w: parseIso(match[4], sign),
+            d: parseIso(match[5], sign),
+            h: parseIso(match[6], sign),
+            m: parseIso(match[7], sign),
+            s: parseIso(match[8], sign),
+        };
+    } else if (duration == null) {
+        // checks for null or undefined
+        duration = {};
+    } else if (
+        typeof duration === 'object' &&
+        ('from' in duration || 'to' in duration)
+    ) {
+        diffRes = momentsDifference(
+            createLocal(duration.from),
+            createLocal(duration.to)
+        );
+
+        duration = {};
+        duration.ms = diffRes.milliseconds;
+        duration.M = diffRes.months;
+    }
+
+    ret = new Duration(duration);
+
+    if (isDuration(input) && hasOwnProp(input, '_locale')) {
+        ret._locale = input._locale;
+    }
+
+    if (isDuration(input) && hasOwnProp(input, '_isValid')) {
+        ret._isValid = input._isValid;
+    }
+
+    return ret;
+}
+
+createDuration.fn = Duration.prototype;
+createDuration.invalid = createInvalid$1;
+
+function parseIso(inp, sign) {
+    // We'd normally use ~~inp for this, but unfortunately it also
+    // converts floats to ints.
+    // inp may be undefined, so careful calling replace on it.
+    var res = inp && parseFloat(inp.replace(',', '.'));
+    // apply sign while we're at it
+    return (isNaN(res) ? 0 : res) * sign;
+}
+
+function positiveMomentsDifference(base, other) {
+    var res = {};
+
+    res.months =
+        other.month() - base.month() + (other.year() - base.year()) * 12;
+    if (base.clone().add(res.months, 'M').isAfter(other)) {
+        --res.months;
+    }
+
+    res.milliseconds = +other - +base.clone().add(res.months, 'M');
+
+    return res;
+}
+
+function momentsDifference(base, other) {
+    var res;
+    if (!(base.isValid() && other.isValid())) {
+        return { milliseconds: 0, months: 0 };
+    }
+
+    other = cloneWithOffset(other, base);
+    if (base.isBefore(other)) {
+        res = positiveMomentsDifference(base, other);
+    } else {
+        res = positiveMomentsDifference(other, base);
+        res.milliseconds = -res.milliseconds;
+        res.months = -res.months;
+    }
+
+    return res;
+}
+
+// TODO: remove 'name' arg after deprecation is removed
+function createAdder(direction, name) {
+    return function (val, period) {
+        var dur, tmp;
+        //invert the arguments, but complain about it
+        if (period !== null && !isNaN(+period)) {
+            deprecateSimple(
+                name,
+                'moment().' +
+                    name +
+                    '(period, number) is deprecated. Please use moment().' +
+                    name +
+                    '(number, period). ' +
+                    'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.'
+            );
+            tmp = val;
+            val = period;
+            period = tmp;
+        }
+
+        dur = createDuration(val, period);
+        addSubtract(this, dur, direction);
+        return this;
+    };
+}
+
+function addSubtract(mom, duration, isAdding, updateOffset) {
+    var milliseconds = duration._milliseconds,
+        days = absRound(duration._days),
+        months = absRound(duration._months);
+
+    if (!mom.isValid()) {
+        // No op
+        return;
+    }
+
+    updateOffset = updateOffset == null ? true : updateOffset;
+
+    if (months) {
+        setMonth(mom, get(mom, 'Month') + months * isAdding);
+    }
+    if (days) {
+        set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
+    }
+    if (milliseconds) {
+        mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
+    }
+    if (updateOffset) {
+        hooks.updateOffset(mom, days || months);
+    }
+}
+
+var add = createAdder(1, 'add'),
+    subtract = createAdder(-1, 'subtract');
+
+function isString(input) {
+    return typeof input === 'string' || input instanceof String;
+}
+
+// type MomentInput = Moment | Date | string | number | (number | string)[] | MomentInputObject | void; // null | undefined
+function isMomentInput(input) {
+    return (
+        isMoment(input) ||
+        isDate(input) ||
+        isString(input) ||
+        isNumber(input) ||
+        isNumberOrStringArray(input) ||
+        isMomentInputObject(input) ||
+        input === null ||
+        input === undefined
+    );
+}
+
+function isMomentInputObject(input) {
+    var objectTest = isObject(input) && !isObjectEmpty(input),
+        propertyTest = false,
+        properties = [
+            'years',
+            'year',
+            'y',
+            'months',
+            'month',
+            'M',
+            'days',
+            'day',
+            'd',
+            'dates',
+            'date',
+            'D',
+            'hours',
+            'hour',
+            'h',
+            'minutes',
+            'minute',
+            'm',
+            'seconds',
+            'second',
+            's',
+            'milliseconds',
+            'millisecond',
+            'ms',
+        ],
+        i,
+        property,
+        propertyLen = properties.length;
+
+    for (i = 0; i < propertyLen; i += 1) {
+        property = properties[i];
+        propertyTest = propertyTest || hasOwnProp(input, property);
+    }
+
+    return objectTest && propertyTest;
+}
+
+function isNumberOrStringArray(input) {
+    var arrayTest = isArray(input),
+        dataTypeTest = false;
+    if (arrayTest) {
+        dataTypeTest =
+            input.filter(function (item) {
+                return !isNumber(item) && isString(input);
+            }).length === 0;
+    }
+    return arrayTest && dataTypeTest;
+}
+
+function isCalendarSpec(input) {
+    var objectTest = isObject(input) && !isObjectEmpty(input),
+        propertyTest = false,
+        properties = [
+            'sameDay',
+            'nextDay',
+            'lastDay',
+            'nextWeek',
+            'lastWeek',
+            'sameElse',
+        ],
+        i,
+        property;
+
+    for (i = 0; i < properties.length; i += 1) {
+        property = properties[i];
+        propertyTest = propertyTest || hasOwnProp(input, property);
+    }
+
+    return objectTest && propertyTest;
+}
+
+function getCalendarFormat(myMoment, now) {
+    var diff = myMoment.diff(now, 'days', true);
+    return diff < -6
+        ? 'sameElse'
+        : diff < -1
+        ? 'lastWeek'
+        : diff < 0
+        ? 'lastDay'
+        : diff < 1
+        ? 'sameDay'
+        : diff < 2
+        ? 'nextDay'
+        : diff < 7
+        ? 'nextWeek'
+        : 'sameElse';
+}
+
+function calendar$1(time, formats) {
+    // Support for single parameter, formats only overload to the calendar function
+    if (arguments.length === 1) {
+        if (!arguments[0]) {
+            time = undefined;
+            formats = undefined;
+        } else if (isMomentInput(arguments[0])) {
+            time = arguments[0];
+            formats = undefined;
+        } else if (isCalendarSpec(arguments[0])) {
+            formats = arguments[0];
+            time = undefined;
+        }
+    }
+    // We want to compare the start of today, vs this.
+    // Getting start-of-today depends on whether we're local/utc/offset or not.
+    var now = time || createLocal(),
+        sod = cloneWithOffset(now, this).startOf('day'),
+        format = hooks.calendarFormat(this, sod) || 'sameElse',
+        output =
+            formats &&
+            (isFunction(formats[format])
+                ? formats[format].call(this, now)
+                : formats[format]);
+
+    return this.format(
+        output || this.localeData().calendar(format, this, createLocal(now))
+    );
+}
+
+function clone() {
+    return new Moment(this);
+}
+
+function isAfter(input, units) {
+    var localInput = isMoment(input) ? input : createLocal(input);
+    if (!(this.isValid() && localInput.isValid())) {
+        return false;
+    }
+    units = normalizeUnits(units) || 'millisecond';
+    if (units === 'millisecond') {
+        return this.valueOf() > localInput.valueOf();
+    } else {
+        return localInput.valueOf() < this.clone().startOf(units).valueOf();
+    }
+}
+
+function isBefore(input, units) {
+    var localInput = isMoment(input) ? input : createLocal(input);
+    if (!(this.isValid() && localInput.isValid())) {
+        return false;
+    }
+    units = normalizeUnits(units) || 'millisecond';
+    if (units === 'millisecond') {
+        return this.valueOf() < localInput.valueOf();
+    } else {
+        return this.clone().endOf(units).valueOf() < localInput.valueOf();
+    }
+}
+
+function isBetween(from, to, units, inclusivity) {
+    var localFrom = isMoment(from) ? from : createLocal(from),
+        localTo = isMoment(to) ? to : createLocal(to);
+    if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {
+        return false;
+    }
+    inclusivity = inclusivity || '()';
+    return (
+        (inclusivity[0] === '('
+            ? this.isAfter(localFrom, units)
+            : !this.isBefore(localFrom, units)) &&
+        (inclusivity[1] === ')'
+            ? this.isBefore(localTo, units)
+            : !this.isAfter(localTo, units))
+    );
+}
+
+function isSame(input, units) {
+    var localInput = isMoment(input) ? input : createLocal(input),
+        inputMs;
+    if (!(this.isValid() && localInput.isValid())) {
+        return false;
+    }
+    units = normalizeUnits(units) || 'millisecond';
+    if (units === 'millisecond') {
+        return this.valueOf() === localInput.valueOf();
+    } else {
+        inputMs = localInput.valueOf();
+        return (
+            this.clone().startOf(units).valueOf() <= inputMs &&
+            inputMs <= this.clone().endOf(units).valueOf()
+        );
+    }
+}
+
+function isSameOrAfter(input, units) {
+    return this.isSame(input, units) || this.isAfter(input, units);
+}
+
+function isSameOrBefore(input, units) {
+    return this.isSame(input, units) || this.isBefore(input, units);
+}
+
+function diff(input, units, asFloat) {
+    var that, zoneDelta, output;
+
+    if (!this.isValid()) {
+        return NaN;
+    }
+
+    that = cloneWithOffset(input, this);
+
+    if (!that.isValid()) {
+        return NaN;
+    }
+
+    zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
+
+    units = normalizeUnits(units);
+
+    switch (units) {
+        case 'year':
+            output = monthDiff(this, that) / 12;
+            break;
+        case 'month':
+            output = monthDiff(this, that);
+            break;
+        case 'quarter':
+            output = monthDiff(this, that) / 3;
+            break;
+        case 'second':
+            output = (this - that) / 1e3;
+            break; // 1000
+        case 'minute':
+            output = (this - that) / 6e4;
+            break; // 1000 * 60
+        case 'hour':
+            output = (this - that) / 36e5;
+            break; // 1000 * 60 * 60
+        case 'day':
+            output = (this - that - zoneDelta) / 864e5;
+            break; // 1000 * 60 * 60 * 24, negate dst
+        case 'week':
+            output = (this - that - zoneDelta) / 6048e5;
+            break; // 1000 * 60 * 60 * 24 * 7, negate dst
+        default:
+            output = this - that;
+    }
+
+    return asFloat ? output : absFloor(output);
+}
+
+function monthDiff(a, b) {
+    if (a.date() < b.date()) {
+        // end-of-month calculations work correct when the start month has more
+        // days than the end month.
+        return -monthDiff(b, a);
+    }
+    // difference in months
+    var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()),
+        // b is in (anchor - 1 month, anchor + 1 month)
+        anchor = a.clone().add(wholeMonthDiff, 'months'),
+        anchor2,
+        adjust;
+
+    if (b - anchor < 0) {
+        anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
+        // linear across the month
+        adjust = (b - anchor) / (anchor - anchor2);
+    } else {
+        anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
+        // linear across the month
+        adjust = (b - anchor) / (anchor2 - anchor);
+    }
+
+    //check for negative zero, return zero if negative zero
+    return -(wholeMonthDiff + adjust) || 0;
+}
+
+hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
+hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';
+
+function toString() {
+    return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
+}
+
+function toISOString(keepOffset) {
+    if (!this.isValid()) {
+        return null;
+    }
+    var utc = keepOffset !== true,
+        m = utc ? this.clone().utc() : this;
+    if (m.year() < 0 || m.year() > 9999) {
+        return formatMoment(
+            m,
+            utc
+                ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]'
+                : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ'
+        );
+    }
+    if (isFunction(Date.prototype.toISOString)) {
+        // native implementation is ~50x faster, use it when we can
+        if (utc) {
+            return this.toDate().toISOString();
+        } else {
+            return new Date(this.valueOf() + this.utcOffset() * 60 * 1000)
+                .toISOString()
+                .replace('Z', formatMoment(m, 'Z'));
+        }
+    }
+    return formatMoment(
+        m,
+        utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ'
+    );
+}
+
+/**
+ * Return a human readable representation of a moment that can
+ * also be evaluated to get a new moment which is the same
+ *
+ * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
+ */
+function inspect() {
+    if (!this.isValid()) {
+        return 'moment.invalid(/* ' + this._i + ' */)';
+    }
+    var func = 'moment',
+        zone = '',
+        prefix,
+        year,
+        datetime,
+        suffix;
+    if (!this.isLocal()) {
+        func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
+        zone = 'Z';
+    }
+    prefix = '[' + func + '("]';
+    year = 0 <= this.year() && this.year() <= 9999 ? 'YYYY' : 'YYYYYY';
+    datetime = '-MM-DD[T]HH:mm:ss.SSS';
+    suffix = zone + '[")]';
+
+    return this.format(prefix + year + datetime + suffix);
+}
+
+function format(inputString) {
+    if (!inputString) {
+        inputString = this.isUtc()
+            ? hooks.defaultFormatUtc
+            : hooks.defaultFormat;
+    }
+    var output = formatMoment(this, inputString);
+    return this.localeData().postformat(output);
+}
+
+function from(time, withoutSuffix) {
+    if (
+        this.isValid() &&
+        ((isMoment(time) && time.isValid()) || createLocal(time).isValid())
+    ) {
+        return createDuration({ to: this, from: time })
+            .locale(this.locale())
+            .humanize(!withoutSuffix);
+    } else {
+        return this.localeData().invalidDate();
+    }
+}
+
+function fromNow(withoutSuffix) {
+    return this.from(createLocal(), withoutSuffix);
+}
+
+function to(time, withoutSuffix) {
+    if (
+        this.isValid() &&
+        ((isMoment(time) && time.isValid()) || createLocal(time).isValid())
+    ) {
+        return createDuration({ from: this, to: time })
+            .locale(this.locale())
+            .humanize(!withoutSuffix);
+    } else {
+        return this.localeData().invalidDate();
+    }
+}
+
+function toNow(withoutSuffix) {
+    return this.to(createLocal(), withoutSuffix);
+}
+
+// If passed a locale key, it will set the locale for this
+// instance.  Otherwise, it will return the locale configuration
+// variables for this instance.
+function locale(key) {
+    var newLocaleData;
+
+    if (key === undefined) {
+        return this._locale._abbr;
+    } else {
+        newLocaleData = getLocale(key);
+        if (newLocaleData != null) {
+            this._locale = newLocaleData;
+        }
+        return this;
+    }
+}
+
+var lang = deprecate(
+    'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
+    function (key) {
+        if (key === undefined) {
+            return this.localeData();
+        } else {
+            return this.locale(key);
+        }
+    }
+);
+
+function localeData() {
+    return this._locale;
+}
+
+var MS_PER_SECOND = 1000,
+    MS_PER_MINUTE = 60 * MS_PER_SECOND,
+    MS_PER_HOUR = 60 * MS_PER_MINUTE,
+    MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;
+
+// actual modulo - handles negative numbers (for dates before 1970):
+function mod$1(dividend, divisor) {
+    return ((dividend % divisor) + divisor) % divisor;
+}
+
+function localStartOfDate(y, m, d) {
+    // the date constructor remaps years 0-99 to 1900-1999
+    if (y < 100 && y >= 0) {
+        // preserve leap years using a full 400 year cycle, then reset
+        return new Date(y + 400, m, d) - MS_PER_400_YEARS;
+    } else {
+        return new Date(y, m, d).valueOf();
+    }
+}
+
+function utcStartOfDate(y, m, d) {
+    // Date.UTC remaps years 0-99 to 1900-1999
+    if (y < 100 && y >= 0) {
+        // preserve leap years using a full 400 year cycle, then reset
+        return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;
+    } else {
+        return Date.UTC(y, m, d);
+    }
+}
+
+function startOf(units) {
+    var time, startOfDate;
+    units = normalizeUnits(units);
+    if (units === undefined || units === 'millisecond' || !this.isValid()) {
+        return this;
+    }
+
+    startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
+
+    switch (units) {
+        case 'year':
+            time = startOfDate(this.year(), 0, 1);
+            break;
+        case 'quarter':
+            time = startOfDate(
+                this.year(),
+                this.month() - (this.month() % 3),
+                1
+            );
+            break;
+        case 'month':
+            time = startOfDate(this.year(), this.month(), 1);
+            break;
+        case 'week':
+            time = startOfDate(
+                this.year(),
+                this.month(),
+                this.date() - this.weekday()
+            );
+            break;
+        case 'isoWeek':
+            time = startOfDate(
+                this.year(),
+                this.month(),
+                this.date() - (this.isoWeekday() - 1)
+            );
+            break;
+        case 'day':
+        case 'date':
+            time = startOfDate(this.year(), this.month(), this.date());
+            break;
+        case 'hour':
+            time = this._d.valueOf();
+            time -= mod$1(
+                time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
+                MS_PER_HOUR
+            );
+            break;
+        case 'minute':
+            time = this._d.valueOf();
+            time -= mod$1(time, MS_PER_MINUTE);
+            break;
+        case 'second':
+            time = this._d.valueOf();
+            time -= mod$1(time, MS_PER_SECOND);
+            break;
+    }
+
+    this._d.setTime(time);
+    hooks.updateOffset(this, true);
+    return this;
+}
+
+function endOf(units) {
+    var time, startOfDate;
+    units = normalizeUnits(units);
+    if (units === undefined || units === 'millisecond' || !this.isValid()) {
+        return this;
+    }
+
+    startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
+
+    switch (units) {
+        case 'year':
+            time = startOfDate(this.year() + 1, 0, 1) - 1;
+            break;
+        case 'quarter':
+            time =
+                startOfDate(
+                    this.year(),
+                    this.month() - (this.month() % 3) + 3,
+                    1
+                ) - 1;
+            break;
+        case 'month':
+            time = startOfDate(this.year(), this.month() + 1, 1) - 1;
+            break;
+        case 'week':
+            time =
+                startOfDate(
+                    this.year(),
+                    this.month(),
+                    this.date() - this.weekday() + 7
+                ) - 1;
+            break;
+        case 'isoWeek':
+            time =
+                startOfDate(
+                    this.year(),
+                    this.month(),
+                    this.date() - (this.isoWeekday() - 1) + 7
+                ) - 1;
+            break;
+        case 'day':
+        case 'date':
+            time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;
+            break;
+        case 'hour':
+            time = this._d.valueOf();
+            time +=
+                MS_PER_HOUR -
+                mod$1(
+                    time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
+                    MS_PER_HOUR
+                ) -
+                1;
+            break;
+        case 'minute':
+            time = this._d.valueOf();
+            time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;
+            break;
+        case 'second':
+            time = this._d.valueOf();
+            time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;
+            break;
+    }
+
+    this._d.setTime(time);
+    hooks.updateOffset(this, true);
+    return this;
+}
+
+function valueOf() {
+    return this._d.valueOf() - (this._offset || 0) * 60000;
+}
+
+function unix() {
+    return Math.floor(this.valueOf() / 1000);
+}
+
+function toDate() {
+    return new Date(this.valueOf());
+}
+
+function toArray() {
+    var m = this;
+    return [
+        m.year(),
+        m.month(),
+        m.date(),
+        m.hour(),
+        m.minute(),
+        m.second(),
+        m.millisecond(),
+    ];
+}
+
+function toObject() {
+    var m = this;
+    return {
+        years: m.year(),
+        months: m.month(),
+        date: m.date(),
+        hours: m.hours(),
+        minutes: m.minutes(),
+        seconds: m.seconds(),
+        milliseconds: m.milliseconds(),
+    };
+}
+
+function toJSON() {
+    // new Date(NaN).toJSON() === null
+    return this.isValid() ? this.toISOString() : null;
+}
+
+function isValid$2() {
+    return isValid(this);
+}
+
+function parsingFlags() {
+    return extend({}, getParsingFlags(this));
+}
+
+function invalidAt() {
+    return getParsingFlags(this).overflow;
+}
+
+function creationData() {
+    return {
+        input: this._i,
+        format: this._f,
+        locale: this._locale,
+        isUTC: this._isUTC,
+        strict: this._strict,
+    };
+}
+
+addFormatToken('N', 0, 0, 'eraAbbr');
+addFormatToken('NN', 0, 0, 'eraAbbr');
+addFormatToken('NNN', 0, 0, 'eraAbbr');
+addFormatToken('NNNN', 0, 0, 'eraName');
+addFormatToken('NNNNN', 0, 0, 'eraNarrow');
+
+addFormatToken('y', ['y', 1], 'yo', 'eraYear');
+addFormatToken('y', ['yy', 2], 0, 'eraYear');
+addFormatToken('y', ['yyy', 3], 0, 'eraYear');
+addFormatToken('y', ['yyyy', 4], 0, 'eraYear');
+
+addRegexToken('N', matchEraAbbr);
+addRegexToken('NN', matchEraAbbr);
+addRegexToken('NNN', matchEraAbbr);
+addRegexToken('NNNN', matchEraName);
+addRegexToken('NNNNN', matchEraNarrow);
+
+addParseToken(
+    ['N', 'NN', 'NNN', 'NNNN', 'NNNNN'],
+    function (input, array, config, token) {
+        var era = config._locale.erasParse(input, token, config._strict);
+        if (era) {
+            getParsingFlags(config).era = era;
+        } else {
+            getParsingFlags(config).invalidEra = input;
+        }
+    }
+);
+
+addRegexToken('y', matchUnsigned);
+addRegexToken('yy', matchUnsigned);
+addRegexToken('yyy', matchUnsigned);
+addRegexToken('yyyy', matchUnsigned);
+addRegexToken('yo', matchEraYearOrdinal);
+
+addParseToken(['y', 'yy', 'yyy', 'yyyy'], YEAR);
+addParseToken(['yo'], function (input, array, config, token) {
+    var match;
+    if (config._locale._eraYearOrdinalRegex) {
+        match = input.match(config._locale._eraYearOrdinalRegex);
+    }
+
+    if (config._locale.eraYearOrdinalParse) {
+        array[YEAR] = config._locale.eraYearOrdinalParse(input, match);
+    } else {
+        array[YEAR] = parseInt(input, 10);
+    }
+});
+
+function localeEras(m, format) {
+    var i,
+        l,
+        date,
+        eras = this._eras || getLocale('en')._eras;
+    for (i = 0, l = eras.length; i < l; ++i) {
+        switch (typeof eras[i].since) {
+            case 'string':
+                // truncate time
+                date = hooks(eras[i].since).startOf('day');
+                eras[i].since = date.valueOf();
+                break;
+        }
+
+        switch (typeof eras[i].until) {
+            case 'undefined':
+                eras[i].until = +Infinity;
+                break;
+            case 'string':
+                // truncate time
+                date = hooks(eras[i].until).startOf('day').valueOf();
+                eras[i].until = date.valueOf();
+                break;
+        }
+    }
+    return eras;
+}
+
+function localeErasParse(eraName, format, strict) {
+    var i,
+        l,
+        eras = this.eras(),
+        name,
+        abbr,
+        narrow;
+    eraName = eraName.toUpperCase();
+
+    for (i = 0, l = eras.length; i < l; ++i) {
+        name = eras[i].name.toUpperCase();
+        abbr = eras[i].abbr.toUpperCase();
+        narrow = eras[i].narrow.toUpperCase();
+
+        if (strict) {
+            switch (format) {
+                case 'N':
+                case 'NN':
+                case 'NNN':
+                    if (abbr === eraName) {
+                        return eras[i];
+                    }
+                    break;
+
+                case 'NNNN':
+                    if (name === eraName) {
+                        return eras[i];
+                    }
+                    break;
+
+                case 'NNNNN':
+                    if (narrow === eraName) {
+                        return eras[i];
+                    }
+                    break;
+            }
+        } else if ([name, abbr, narrow].indexOf(eraName) >= 0) {
+            return eras[i];
+        }
+    }
+}
+
+function localeErasConvertYear(era, year) {
+    var dir = era.since <= era.until ? +1 : -1;
+    if (year === undefined) {
+        return hooks(era.since).year();
+    } else {
+        return hooks(era.since).year() + (year - era.offset) * dir;
+    }
+}
+
+function getEraName() {
+    var i,
+        l,
+        val,
+        eras = this.localeData().eras();
+    for (i = 0, l = eras.length; i < l; ++i) {
+        // truncate time
+        val = this.clone().startOf('day').valueOf();
+
+        if (eras[i].since <= val && val <= eras[i].until) {
+            return eras[i].name;
+        }
+        if (eras[i].until <= val && val <= eras[i].since) {
+            return eras[i].name;
+        }
+    }
+
+    return '';
+}
+
+function getEraNarrow() {
+    var i,
+        l,
+        val,
+        eras = this.localeData().eras();
+    for (i = 0, l = eras.length; i < l; ++i) {
+        // truncate time
+        val = this.clone().startOf('day').valueOf();
+
+        if (eras[i].since <= val && val <= eras[i].until) {
+            return eras[i].narrow;
+        }
+        if (eras[i].until <= val && val <= eras[i].since) {
+            return eras[i].narrow;
+        }
+    }
+
+    return '';
+}
+
+function getEraAbbr() {
+    var i,
+        l,
+        val,
+        eras = this.localeData().eras();
+    for (i = 0, l = eras.length; i < l; ++i) {
+        // truncate time
+        val = this.clone().startOf('day').valueOf();
+
+        if (eras[i].since <= val && val <= eras[i].until) {
+            return eras[i].abbr;
+        }
+        if (eras[i].until <= val && val <= eras[i].since) {
+            return eras[i].abbr;
+        }
+    }
+
+    return '';
+}
+
+function getEraYear() {
+    var i,
+        l,
+        dir,
+        val,
+        eras = this.localeData().eras();
+    for (i = 0, l = eras.length; i < l; ++i) {
+        dir = eras[i].since <= eras[i].until ? +1 : -1;
+
+        // truncate time
+        val = this.clone().startOf('day').valueOf();
+
+        if (
+            (eras[i].since <= val && val <= eras[i].until) ||
+            (eras[i].until <= val && val <= eras[i].since)
+        ) {
+            return (
+                (this.year() - hooks(eras[i].since).year()) * dir +
+                eras[i].offset
+            );
+        }
+    }
+
+    return this.year();
+}
+
+function erasNameRegex(isStrict) {
+    if (!hasOwnProp(this, '_erasNameRegex')) {
+        computeErasParse.call(this);
+    }
+    return isStrict ? this._erasNameRegex : this._erasRegex;
+}
+
+function erasAbbrRegex(isStrict) {
+    if (!hasOwnProp(this, '_erasAbbrRegex')) {
+        computeErasParse.call(this);
+    }
+    return isStrict ? this._erasAbbrRegex : this._erasRegex;
+}
+
+function erasNarrowRegex(isStrict) {
+    if (!hasOwnProp(this, '_erasNarrowRegex')) {
+        computeErasParse.call(this);
+    }
+    return isStrict ? this._erasNarrowRegex : this._erasRegex;
+}
+
+function matchEraAbbr(isStrict, locale) {
+    return locale.erasAbbrRegex(isStrict);
+}
+
+function matchEraName(isStrict, locale) {
+    return locale.erasNameRegex(isStrict);
+}
+
+function matchEraNarrow(isStrict, locale) {
+    return locale.erasNarrowRegex(isStrict);
+}
+
+function matchEraYearOrdinal(isStrict, locale) {
+    return locale._eraYearOrdinalRegex || matchUnsigned;
+}
+
+function computeErasParse() {
+    var abbrPieces = [],
+        namePieces = [],
+        narrowPieces = [],
+        mixedPieces = [],
+        i,
+        l,
+        eras = this.eras();
+
+    for (i = 0, l = eras.length; i < l; ++i) {
+        namePieces.push(regexEscape(eras[i].name));
+        abbrPieces.push(regexEscape(eras[i].abbr));
+        narrowPieces.push(regexEscape(eras[i].narrow));
+
+        mixedPieces.push(regexEscape(eras[i].name));
+        mixedPieces.push(regexEscape(eras[i].abbr));
+        mixedPieces.push(regexEscape(eras[i].narrow));
+    }
+
+    this._erasRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
+    this._erasNameRegex = new RegExp('^(' + namePieces.join('|') + ')', 'i');
+    this._erasAbbrRegex = new RegExp('^(' + abbrPieces.join('|') + ')', 'i');
+    this._erasNarrowRegex = new RegExp(
+        '^(' + narrowPieces.join('|') + ')',
+        'i'
+    );
+}
+
+// FORMATTING
+
+addFormatToken(0, ['gg', 2], 0, function () {
+    return this.weekYear() % 100;
+});
+
+addFormatToken(0, ['GG', 2], 0, function () {
+    return this.isoWeekYear() % 100;
+});
+
+function addWeekYearFormatToken(token, getter) {
+    addFormatToken(0, [token, token.length], 0, getter);
+}
+
+addWeekYearFormatToken('gggg', 'weekYear');
+addWeekYearFormatToken('ggggg', 'weekYear');
+addWeekYearFormatToken('GGGG', 'isoWeekYear');
+addWeekYearFormatToken('GGGGG', 'isoWeekYear');
+
+// ALIASES
+
+addUnitAlias('weekYear', 'gg');
+addUnitAlias('isoWeekYear', 'GG');
+
+// PRIORITY
+
+addUnitPriority('weekYear', 1);
+addUnitPriority('isoWeekYear', 1);
+
+// PARSING
+
+addRegexToken('G', matchSigned);
+addRegexToken('g', matchSigned);
+addRegexToken('GG', match1to2, match2);
+addRegexToken('gg', match1to2, match2);
+addRegexToken('GGGG', match1to4, match4);
+addRegexToken('gggg', match1to4, match4);
+addRegexToken('GGGGG', match1to6, match6);
+addRegexToken('ggggg', match1to6, match6);
+
+addWeekParseToken(
+    ['gggg', 'ggggg', 'GGGG', 'GGGGG'],
+    function (input, week, config, token) {
+        week[token.substr(0, 2)] = toInt(input);
+    }
+);
+
+addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
+    week[token] = hooks.parseTwoDigitYear(input);
+});
+
+// MOMENTS
+
+function getSetWeekYear(input) {
+    return getSetWeekYearHelper.call(
+        this,
+        input,
+        this.week(),
+        this.weekday(),
+        this.localeData()._week.dow,
+        this.localeData()._week.doy
+    );
+}
+
+function getSetISOWeekYear(input) {
+    return getSetWeekYearHelper.call(
+        this,
+        input,
+        this.isoWeek(),
+        this.isoWeekday(),
+        1,
+        4
+    );
+}
+
+function getISOWeeksInYear() {
+    return weeksInYear(this.year(), 1, 4);
+}
+
+function getISOWeeksInISOWeekYear() {
+    return weeksInYear(this.isoWeekYear(), 1, 4);
+}
+
+function getWeeksInYear() {
+    var weekInfo = this.localeData()._week;
+    return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
+}
+
+function getWeeksInWeekYear() {
+    var weekInfo = this.localeData()._week;
+    return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy);
+}
+
+function getSetWeekYearHelper(input, week, weekday, dow, doy) {
+    var weeksTarget;
+    if (input == null) {
+        return weekOfYear(this, dow, doy).year;
+    } else {
+        weeksTarget = weeksInYear(input, dow, doy);
+        if (week > weeksTarget) {
+            week = weeksTarget;
+        }
+        return setWeekAll.call(this, input, week, weekday, dow, doy);
+    }
+}
+
+function setWeekAll(weekYear, week, weekday, dow, doy) {
+    var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
+        date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
+
+    this.year(date.getUTCFullYear());
+    this.month(date.getUTCMonth());
+    this.date(date.getUTCDate());
+    return this;
+}
+
+// FORMATTING
+
+addFormatToken('Q', 0, 'Qo', 'quarter');
+
+// ALIASES
+
+addUnitAlias('quarter', 'Q');
+
+// PRIORITY
+
+addUnitPriority('quarter', 7);
+
+// PARSING
+
+addRegexToken('Q', match1);
+addParseToken('Q', function (input, array) {
+    array[MONTH] = (toInt(input) - 1) * 3;
+});
+
+// MOMENTS
+
+function getSetQuarter(input) {
+    return input == null
+        ? Math.ceil((this.month() + 1) / 3)
+        : this.month((input - 1) * 3 + (this.month() % 3));
+}
+
+// FORMATTING
+
+addFormatToken('D', ['DD', 2], 'Do', 'date');
+
+// ALIASES
+
+addUnitAlias('date', 'D');
+
+// PRIORITY
+addUnitPriority('date', 9);
+
+// PARSING
+
+addRegexToken('D', match1to2);
+addRegexToken('DD', match1to2, match2);
+addRegexToken('Do', function (isStrict, locale) {
+    // TODO: Remove "ordinalParse" fallback in next major release.
+    return isStrict
+        ? locale._dayOfMonthOrdinalParse || locale._ordinalParse
+        : locale._dayOfMonthOrdinalParseLenient;
+});
+
+addParseToken(['D', 'DD'], DATE);
+addParseToken('Do', function (input, array) {
+    array[DATE] = toInt(input.match(match1to2)[0]);
+});
+
+// MOMENTS
+
+var getSetDayOfMonth = makeGetSet('Date', true);
+
+// FORMATTING
+
+addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
+
+// ALIASES
+
+addUnitAlias('dayOfYear', 'DDD');
+
+// PRIORITY
+addUnitPriority('dayOfYear', 4);
+
+// PARSING
+
+addRegexToken('DDD', match1to3);
+addRegexToken('DDDD', match3);
+addParseToken(['DDD', 'DDDD'], function (input, array, config) {
+    config._dayOfYear = toInt(input);
+});
+
+// HELPERS
+
+// MOMENTS
+
+function getSetDayOfYear(input) {
+    var dayOfYear =
+        Math.round(
+            (this.clone().startOf('day') - this.clone().startOf('year')) / 864e5
+        ) + 1;
+    return input == null ? dayOfYear : this.add(input - dayOfYear, 'd');
+}
+
+// FORMATTING
+
+addFormatToken('m', ['mm', 2], 0, 'minute');
+
+// ALIASES
+
+addUnitAlias('minute', 'm');
+
+// PRIORITY
+
+addUnitPriority('minute', 14);
+
+// PARSING
+
+addRegexToken('m', match1to2);
+addRegexToken('mm', match1to2, match2);
+addParseToken(['m', 'mm'], MINUTE);
+
+// MOMENTS
+
+var getSetMinute = makeGetSet('Minutes', false);
+
+// FORMATTING
+
+addFormatToken('s', ['ss', 2], 0, 'second');
+
+// ALIASES
+
+addUnitAlias('second', 's');
+
+// PRIORITY
+
+addUnitPriority('second', 15);
+
+// PARSING
+
+addRegexToken('s', match1to2);
+addRegexToken('ss', match1to2, match2);
+addParseToken(['s', 'ss'], SECOND);
+
+// MOMENTS
+
+var getSetSecond = makeGetSet('Seconds', false);
+
+// FORMATTING
+
+addFormatToken('S', 0, 0, function () {
+    return ~~(this.millisecond() / 100);
+});
+
+addFormatToken(0, ['SS', 2], 0, function () {
+    return ~~(this.millisecond() / 10);
+});
+
+addFormatToken(0, ['SSS', 3], 0, 'millisecond');
+addFormatToken(0, ['SSSS', 4], 0, function () {
+    return this.millisecond() * 10;
+});
+addFormatToken(0, ['SSSSS', 5], 0, function () {
+    return this.millisecond() * 100;
+});
+addFormatToken(0, ['SSSSSS', 6], 0, function () {
+    return this.millisecond() * 1000;
+});
+addFormatToken(0, ['SSSSSSS', 7], 0, function () {
+    return this.millisecond() * 10000;
+});
+addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
+    return this.millisecond() * 100000;
+});
+addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
+    return this.millisecond() * 1000000;
+});
+
+// ALIASES
+
+addUnitAlias('millisecond', 'ms');
+
+// PRIORITY
+
+addUnitPriority('millisecond', 16);
+
+// PARSING
+
+addRegexToken('S', match1to3, match1);
+addRegexToken('SS', match1to3, match2);
+addRegexToken('SSS', match1to3, match3);
+
+var token, getSetMillisecond;
+for (token = 'SSSS'; token.length <= 9; token += 'S') {
+    addRegexToken(token, matchUnsigned);
+}
+
+function parseMs(input, array) {
+    array[MILLISECOND] = toInt(('0.' + input) * 1000);
+}
+
+for (token = 'S'; token.length <= 9; token += 'S') {
+    addParseToken(token, parseMs);
+}
+
+getSetMillisecond = makeGetSet('Milliseconds', false);
+
+// FORMATTING
+
+addFormatToken('z', 0, 0, 'zoneAbbr');
+addFormatToken('zz', 0, 0, 'zoneName');
+
+// MOMENTS
+
+function getZoneAbbr() {
+    return this._isUTC ? 'UTC' : '';
+}
+
+function getZoneName() {
+    return this._isUTC ? 'Coordinated Universal Time' : '';
+}
+
+var proto = Moment.prototype;
+
+proto.add = add;
+proto.calendar = calendar$1;
+proto.clone = clone;
+proto.diff = diff;
+proto.endOf = endOf;
+proto.format = format;
+proto.from = from;
+proto.fromNow = fromNow;
+proto.to = to;
+proto.toNow = toNow;
+proto.get = stringGet;
+proto.invalidAt = invalidAt;
+proto.isAfter = isAfter;
+proto.isBefore = isBefore;
+proto.isBetween = isBetween;
+proto.isSame = isSame;
+proto.isSameOrAfter = isSameOrAfter;
+proto.isSameOrBefore = isSameOrBefore;
+proto.isValid = isValid$2;
+proto.lang = lang;
+proto.locale = locale;
+proto.localeData = localeData;
+proto.max = prototypeMax;
+proto.min = prototypeMin;
+proto.parsingFlags = parsingFlags;
+proto.set = stringSet;
+proto.startOf = startOf;
+proto.subtract = subtract;
+proto.toArray = toArray;
+proto.toObject = toObject;
+proto.toDate = toDate;
+proto.toISOString = toISOString;
+proto.inspect = inspect;
+if (typeof Symbol !== 'undefined' && Symbol.for != null) {
+    proto[Symbol.for('nodejs.util.inspect.custom')] = function () {
+        return 'Moment<' + this.format() + '>';
+    };
+}
+proto.toJSON = toJSON;
+proto.toString = toString;
+proto.unix = unix;
+proto.valueOf = valueOf;
+proto.creationData = creationData;
+proto.eraName = getEraName;
+proto.eraNarrow = getEraNarrow;
+proto.eraAbbr = getEraAbbr;
+proto.eraYear = getEraYear;
+proto.year = getSetYear;
+proto.isLeapYear = getIsLeapYear;
+proto.weekYear = getSetWeekYear;
+proto.isoWeekYear = getSetISOWeekYear;
+proto.quarter = proto.quarters = getSetQuarter;
+proto.month = getSetMonth;
+proto.daysInMonth = getDaysInMonth;
+proto.week = proto.weeks = getSetWeek;
+proto.isoWeek = proto.isoWeeks = getSetISOWeek;
+proto.weeksInYear = getWeeksInYear;
+proto.weeksInWeekYear = getWeeksInWeekYear;
+proto.isoWeeksInYear = getISOWeeksInYear;
+proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;
+proto.date = getSetDayOfMonth;
+proto.day = proto.days = getSetDayOfWeek;
+proto.weekday = getSetLocaleDayOfWeek;
+proto.isoWeekday = getSetISODayOfWeek;
+proto.dayOfYear = getSetDayOfYear;
+proto.hour = proto.hours = getSetHour;
+proto.minute = proto.minutes = getSetMinute;
+proto.second = proto.seconds = getSetSecond;
+proto.millisecond = proto.milliseconds = getSetMillisecond;
+proto.utcOffset = getSetOffset;
+proto.utc = setOffsetToUTC;
+proto.local = setOffsetToLocal;
+proto.parseZone = setOffsetToParsedOffset;
+proto.hasAlignedHourOffset = hasAlignedHourOffset;
+proto.isDST = isDaylightSavingTime;
+proto.isLocal = isLocal;
+proto.isUtcOffset = isUtcOffset;
+proto.isUtc = isUtc;
+proto.isUTC = isUtc;
+proto.zoneAbbr = getZoneAbbr;
+proto.zoneName = getZoneName;
+proto.dates = deprecate(
+    'dates accessor is deprecated. Use date instead.',
+    getSetDayOfMonth
+);
+proto.months = deprecate(
+    'months accessor is deprecated. Use month instead',
+    getSetMonth
+);
+proto.years = deprecate(
+    'years accessor is deprecated. Use year instead',
+    getSetYear
+);
+proto.zone = deprecate(
+    'moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/',
+    getSetZone
+);
+proto.isDSTShifted = deprecate(
+    'isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information',
+    isDaylightSavingTimeShifted
+);
+
+function createUnix(input) {
+    return createLocal(input * 1000);
+}
+
+function createInZone() {
+    return createLocal.apply(null, arguments).parseZone();
+}
+
+function preParsePostFormat(string) {
+    return string;
+}
+
+var proto$1 = Locale.prototype;
+
+proto$1.calendar = calendar;
+proto$1.longDateFormat = longDateFormat;
+proto$1.invalidDate = invalidDate;
+proto$1.ordinal = ordinal;
+proto$1.preparse = preParsePostFormat;
+proto$1.postformat = preParsePostFormat;
+proto$1.relativeTime = relativeTime;
+proto$1.pastFuture = pastFuture;
+proto$1.set = set;
+proto$1.eras = localeEras;
+proto$1.erasParse = localeErasParse;
+proto$1.erasConvertYear = localeErasConvertYear;
+proto$1.erasAbbrRegex = erasAbbrRegex;
+proto$1.erasNameRegex = erasNameRegex;
+proto$1.erasNarrowRegex = erasNarrowRegex;
+
+proto$1.months = localeMonths;
+proto$1.monthsShort = localeMonthsShort;
+proto$1.monthsParse = localeMonthsParse;
+proto$1.monthsRegex = monthsRegex;
+proto$1.monthsShortRegex = monthsShortRegex;
+proto$1.week = localeWeek;
+proto$1.firstDayOfYear = localeFirstDayOfYear;
+proto$1.firstDayOfWeek = localeFirstDayOfWeek;
+
+proto$1.weekdays = localeWeekdays;
+proto$1.weekdaysMin = localeWeekdaysMin;
+proto$1.weekdaysShort = localeWeekdaysShort;
+proto$1.weekdaysParse = localeWeekdaysParse;
+
+proto$1.weekdaysRegex = weekdaysRegex;
+proto$1.weekdaysShortRegex = weekdaysShortRegex;
+proto$1.weekdaysMinRegex = weekdaysMinRegex;
+
+proto$1.isPM = localeIsPM;
+proto$1.meridiem = localeMeridiem;
+
+function get$1(format, index, field, setter) {
+    var locale = getLocale(),
+        utc = createUTC().set(setter, index);
+    return locale[field](utc, format);
+}
+
+function listMonthsImpl(format, index, field) {
+    if (isNumber(format)) {
+        index = format;
+        format = undefined;
+    }
+
+    format = format || '';
+
+    if (index != null) {
+        return get$1(format, index, field, 'month');
+    }
+
+    var i,
+        out = [];
+    for (i = 0; i < 12; i++) {
+        out[i] = get$1(format, i, field, 'month');
+    }
+    return out;
+}
+
+// ()
+// (5)
+// (fmt, 5)
+// (fmt)
+// (true)
+// (true, 5)
+// (true, fmt, 5)
+// (true, fmt)
+function listWeekdaysImpl(localeSorted, format, index, field) {
+    if (typeof localeSorted === 'boolean') {
+        if (isNumber(format)) {
+            index = format;
+            format = undefined;
+        }
+
+        format = format || '';
+    } else {
+        format = localeSorted;
+        index = format;
+        localeSorted = false;
+
+        if (isNumber(format)) {
+            index = format;
+            format = undefined;
+        }
+
+        format = format || '';
+    }
+
+    var locale = getLocale(),
+        shift = localeSorted ? locale._week.dow : 0,
+        i,
+        out = [];
+
+    if (index != null) {
+        return get$1(format, (index + shift) % 7, field, 'day');
+    }
+
+    for (i = 0; i < 7; i++) {
+        out[i] = get$1(format, (i + shift) % 7, field, 'day');
+    }
+    return out;
+}
+
+function listMonths(format, index) {
+    return listMonthsImpl(format, index, 'months');
+}
+
+function listMonthsShort(format, index) {
+    return listMonthsImpl(format, index, 'monthsShort');
+}
+
+function listWeekdays(localeSorted, format, index) {
+    return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
+}
+
+function listWeekdaysShort(localeSorted, format, index) {
+    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
+}
+
+function listWeekdaysMin(localeSorted, format, index) {
+    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
+}
+
+getSetGlobalLocale('en', {
+    eras: [
+        {
+            since: '0001-01-01',
+            until: +Infinity,
+            offset: 1,
+            name: 'Anno Domini',
+            narrow: 'AD',
+            abbr: 'AD',
+        },
+        {
+            since: '0000-12-31',
+            until: -Infinity,
+            offset: 1,
+            name: 'Before Christ',
+            narrow: 'BC',
+            abbr: 'BC',
+        },
+    ],
+    dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
+    ordinal: function (number) {
+        var b = number % 10,
+            output =
+                toInt((number % 100) / 10) === 1
+                    ? 'th'
+                    : b === 1
+                    ? 'st'
+                    : b === 2
+                    ? 'nd'
+                    : b === 3
+                    ? 'rd'
+                    : 'th';
+        return number + output;
+    },
+});
+
+// Side effect imports
+
+hooks.lang = deprecate(
+    'moment.lang is deprecated. Use moment.locale instead.',
+    getSetGlobalLocale
+);
+hooks.langData = deprecate(
+    'moment.langData is deprecated. Use moment.localeData instead.',
+    getLocale
+);
+
+var mathAbs = Math.abs;
+
+function abs() {
+    var data = this._data;
+
+    this._milliseconds = mathAbs(this._milliseconds);
+    this._days = mathAbs(this._days);
+    this._months = mathAbs(this._months);
+
+    data.milliseconds = mathAbs(data.milliseconds);
+    data.seconds = mathAbs(data.seconds);
+    data.minutes = mathAbs(data.minutes);
+    data.hours = mathAbs(data.hours);
+    data.months = mathAbs(data.months);
+    data.years = mathAbs(data.years);
+
+    return this;
+}
+
+function addSubtract$1(duration, input, value, direction) {
+    var other = createDuration(input, value);
+
+    duration._milliseconds += direction * other._milliseconds;
+    duration._days += direction * other._days;
+    duration._months += direction * other._months;
+
+    return duration._bubble();
+}
+
+// supports only 2.0-style add(1, 's') or add(duration)
+function add$1(input, value) {
+    return addSubtract$1(this, input, value, 1);
+}
+
+// supports only 2.0-style subtract(1, 's') or subtract(duration)
+function subtract$1(input, value) {
+    return addSubtract$1(this, input, value, -1);
+}
+
+function absCeil(number) {
+    if (number < 0) {
+        return Math.floor(number);
+    } else {
+        return Math.ceil(number);
+    }
+}
+
+function bubble() {
+    var milliseconds = this._milliseconds,
+        days = this._days,
+        months = this._months,
+        data = this._data,
+        seconds,
+        minutes,
+        hours,
+        years,
+        monthsFromDays;
+
+    // if we have a mix of positive and negative values, bubble down first
+    // check: https://github.com/moment/moment/issues/2166
+    if (
+        !(
+            (milliseconds >= 0 && days >= 0 && months >= 0) ||
+            (milliseconds <= 0 && days <= 0 && months <= 0)
+        )
+    ) {
+        milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
+        days = 0;
+        months = 0;
+    }
+
+    // The following code bubbles up values, see the tests for
+    // examples of what that means.
+    data.milliseconds = milliseconds % 1000;
+
+    seconds = absFloor(milliseconds / 1000);
+    data.seconds = seconds % 60;
+
+    minutes = absFloor(seconds / 60);
+    data.minutes = minutes % 60;
+
+    hours = absFloor(minutes / 60);
+    data.hours = hours % 24;
+
+    days += absFloor(hours / 24);
+
+    // convert days to months
+    monthsFromDays = absFloor(daysToMonths(days));
+    months += monthsFromDays;
+    days -= absCeil(monthsToDays(monthsFromDays));
+
+    // 12 months -> 1 year
+    years = absFloor(months / 12);
+    months %= 12;
+
+    data.days = days;
+    data.months = months;
+    data.years = years;
+
+    return this;
+}
+
+function daysToMonths(days) {
+    // 400 years have 146097 days (taking into account leap year rules)
+    // 400 years have 12 months === 4800
+    return (days * 4800) / 146097;
+}
+
+function monthsToDays(months) {
+    // the reverse of daysToMonths
+    return (months * 146097) / 4800;
+}
+
+function as(units) {
+    if (!this.isValid()) {
+        return NaN;
+    }
+    var days,
+        months,
+        milliseconds = this._milliseconds;
+
+    units = normalizeUnits(units);
+
+    if (units === 'month' || units === 'quarter' || units === 'year') {
+        days = this._days + milliseconds / 864e5;
+        months = this._months + daysToMonths(days);
+        switch (units) {
+            case 'month':
+                return months;
+            case 'quarter':
+                return months / 3;
+            case 'year':
+                return months / 12;
+        }
+    } else {
+        // handle milliseconds separately because of floating point math errors (issue #1867)
+        days = this._days + Math.round(monthsToDays(this._months));
+        switch (units) {
+            case 'week':
+                return days / 7 + milliseconds / 6048e5;
+            case 'day':
+                return days + milliseconds / 864e5;
+            case 'hour':
+                return days * 24 + milliseconds / 36e5;
+            case 'minute':
+                return days * 1440 + milliseconds / 6e4;
+            case 'second':
+                return days * 86400 + milliseconds / 1000;
+            // Math.floor prevents floating point math errors here
+            case 'millisecond':
+                return Math.floor(days * 864e5) + milliseconds;
+            default:
+                throw new Error('Unknown unit ' + units);
+        }
+    }
+}
+
+// TODO: Use this.as('ms')?
+function valueOf$1() {
+    if (!this.isValid()) {
+        return NaN;
+    }
+    return (
+        this._milliseconds +
+        this._days * 864e5 +
+        (this._months % 12) * 2592e6 +
+        toInt(this._months / 12) * 31536e6
+    );
+}
+
+function makeAs(alias) {
+    return function () {
+        return this.as(alias);
+    };
+}
+
+var asMilliseconds = makeAs('ms'),
+    asSeconds = makeAs('s'),
+    asMinutes = makeAs('m'),
+    asHours = makeAs('h'),
+    asDays = makeAs('d'),
+    asWeeks = makeAs('w'),
+    asMonths = makeAs('M'),
+    asQuarters = makeAs('Q'),
+    asYears = makeAs('y');
+
+function clone$1() {
+    return createDuration(this);
+}
+
+function get$2(units) {
+    units = normalizeUnits(units);
+    return this.isValid() ? this[units + 's']() : NaN;
+}
+
+function makeGetter(name) {
+    return function () {
+        return this.isValid() ? this._data[name] : NaN;
+    };
+}
+
+var milliseconds = makeGetter('milliseconds'),
+    seconds = makeGetter('seconds'),
+    minutes = makeGetter('minutes'),
+    hours = makeGetter('hours'),
+    days = makeGetter('days'),
+    months = makeGetter('months'),
+    years = makeGetter('years');
+
+function weeks() {
+    return absFloor(this.days() / 7);
+}
+
+var round = Math.round,
+    thresholds = {
+        ss: 44, // a few seconds to seconds
+        s: 45, // seconds to minute
+        m: 45, // minutes to hour
+        h: 22, // hours to day
+        d: 26, // days to month/week
+        w: null, // weeks to month
+        M: 11, // months to year
+    };
+
+// helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
+function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
+    return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
+}
+
+function relativeTime$1(posNegDuration, withoutSuffix, thresholds, locale) {
+    var duration = createDuration(posNegDuration).abs(),
+        seconds = round(duration.as('s')),
+        minutes = round(duration.as('m')),
+        hours = round(duration.as('h')),
+        days = round(duration.as('d')),
+        months = round(duration.as('M')),
+        weeks = round(duration.as('w')),
+        years = round(duration.as('y')),
+        a =
+            (seconds <= thresholds.ss && ['s', seconds]) ||
+            (seconds < thresholds.s && ['ss', seconds]) ||
+            (minutes <= 1 && ['m']) ||
+            (minutes < thresholds.m && ['mm', minutes]) ||
+            (hours <= 1 && ['h']) ||
+            (hours < thresholds.h && ['hh', hours]) ||
+            (days <= 1 && ['d']) ||
+            (days < thresholds.d && ['dd', days]);
+
+    if (thresholds.w != null) {
+        a =
+            a ||
+            (weeks <= 1 && ['w']) ||
+            (weeks < thresholds.w && ['ww', weeks]);
+    }
+    a = a ||
+        (months <= 1 && ['M']) ||
+        (months < thresholds.M && ['MM', months]) ||
+        (years <= 1 && ['y']) || ['yy', years];
+
+    a[2] = withoutSuffix;
+    a[3] = +posNegDuration > 0;
+    a[4] = locale;
+    return substituteTimeAgo.apply(null, a);
+}
+
+// This function allows you to set the rounding function for relative time strings
+function getSetRelativeTimeRounding(roundingFunction) {
+    if (roundingFunction === undefined) {
+        return round;
+    }
+    if (typeof roundingFunction === 'function') {
+        round = roundingFunction;
+        return true;
+    }
+    return false;
+}
+
+// This function allows you to set a threshold for relative time strings
+function getSetRelativeTimeThreshold(threshold, limit) {
+    if (thresholds[threshold] === undefined) {
+        return false;
+    }
+    if (limit === undefined) {
+        return thresholds[threshold];
+    }
+    thresholds[threshold] = limit;
+    if (threshold === 's') {
+        thresholds.ss = limit - 1;
+    }
+    return true;
+}
+
+function humanize(argWithSuffix, argThresholds) {
+    if (!this.isValid()) {
+        return this.localeData().invalidDate();
+    }
+
+    var withSuffix = false,
+        th = thresholds,
+        locale,
+        output;
+
+    if (typeof argWithSuffix === 'object') {
+        argThresholds = argWithSuffix;
+        argWithSuffix = false;
+    }
+    if (typeof argWithSuffix === 'boolean') {
+        withSuffix = argWithSuffix;
+    }
+    if (typeof argThresholds === 'object') {
+        th = Object.assign({}, thresholds, argThresholds);
+        if (argThresholds.s != null && argThresholds.ss == null) {
+            th.ss = argThresholds.s - 1;
+        }
+    }
+
+    locale = this.localeData();
+    output = relativeTime$1(this, !withSuffix, th, locale);
+
+    if (withSuffix) {
+        output = locale.pastFuture(+this, output);
+    }
+
+    return locale.postformat(output);
+}
+
+var abs$1 = Math.abs;
+
+function sign(x) {
+    return (x > 0) - (x < 0) || +x;
+}
+
+function toISOString$1() {
+    // for ISO strings we do not use the normal bubbling rules:
+    //  * milliseconds bubble up until they become hours
+    //  * days do not bubble at all
+    //  * months bubble up until they become years
+    // This is because there is no context-free conversion between hours and days
+    // (think of clock changes)
+    // and also not between days and months (28-31 days per month)
+    if (!this.isValid()) {
+        return this.localeData().invalidDate();
+    }
+
+    var seconds = abs$1(this._milliseconds) / 1000,
+        days = abs$1(this._days),
+        months = abs$1(this._months),
+        minutes,
+        hours,
+        years,
+        s,
+        total = this.asSeconds(),
+        totalSign,
+        ymSign,
+        daysSign,
+        hmsSign;
+
+    if (!total) {
+        // this is the same as C#'s (Noda) and python (isodate)...
+        // but not other JS (goog.date)
+        return 'P0D';
+    }
+
+    // 3600 seconds -> 60 minutes -> 1 hour
+    minutes = absFloor(seconds / 60);
+    hours = absFloor(minutes / 60);
+    seconds %= 60;
+    minutes %= 60;
+
+    // 12 months -> 1 year
+    years = absFloor(months / 12);
+    months %= 12;
+
+    // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
+    s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : '';
+
+    totalSign = total < 0 ? '-' : '';
+    ymSign = sign(this._months) !== sign(total) ? '-' : '';
+    daysSign = sign(this._days) !== sign(total) ? '-' : '';
+    hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : '';
+
+    return (
+        totalSign +
+        'P' +
+        (years ? ymSign + years + 'Y' : '') +
+        (months ? ymSign + months + 'M' : '') +
+        (days ? daysSign + days + 'D' : '') +
+        (hours || minutes || seconds ? 'T' : '') +
+        (hours ? hmsSign + hours + 'H' : '') +
+        (minutes ? hmsSign + minutes + 'M' : '') +
+        (seconds ? hmsSign + s + 'S' : '')
+    );
+}
+
+var proto$2 = Duration.prototype;
+
+proto$2.isValid = isValid$1;
+proto$2.abs = abs;
+proto$2.add = add$1;
+proto$2.subtract = subtract$1;
+proto$2.as = as;
+proto$2.asMilliseconds = asMilliseconds;
+proto$2.asSeconds = asSeconds;
+proto$2.asMinutes = asMinutes;
+proto$2.asHours = asHours;
+proto$2.asDays = asDays;
+proto$2.asWeeks = asWeeks;
+proto$2.asMonths = asMonths;
+proto$2.asQuarters = asQuarters;
+proto$2.asYears = asYears;
+proto$2.valueOf = valueOf$1;
+proto$2._bubble = bubble;
+proto$2.clone = clone$1;
+proto$2.get = get$2;
+proto$2.milliseconds = milliseconds;
+proto$2.seconds = seconds;
+proto$2.minutes = minutes;
+proto$2.hours = hours;
+proto$2.days = days;
+proto$2.weeks = weeks;
+proto$2.months = months;
+proto$2.years = years;
+proto$2.humanize = humanize;
+proto$2.toISOString = toISOString$1;
+proto$2.toString = toISOString$1;
+proto$2.toJSON = toISOString$1;
+proto$2.locale = locale;
+proto$2.localeData = localeData;
+
+proto$2.toIsoString = deprecate(
+    'toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)',
+    toISOString$1
+);
+proto$2.lang = lang;
+
+// FORMATTING
+
+addFormatToken('X', 0, 0, 'unix');
+addFormatToken('x', 0, 0, 'valueOf');
+
+// PARSING
+
+addRegexToken('x', matchSigned);
+addRegexToken('X', matchTimestamp);
+addParseToken('X', function (input, array, config) {
+    config._d = new Date(parseFloat(input) * 1000);
+});
+addParseToken('x', function (input, array, config) {
+    config._d = new Date(toInt(input));
+});
+
+//! moment.js
+
+hooks.version = '2.29.4';
+
+setHookCallback(createLocal);
+
+hooks.fn = proto;
+hooks.min = min;
+hooks.max = max;
+hooks.now = now;
+hooks.utc = createUTC;
+hooks.unix = createUnix;
+hooks.months = listMonths;
+hooks.isDate = isDate;
+hooks.locale = getSetGlobalLocale;
+hooks.invalid = createInvalid;
+hooks.duration = createDuration;
+hooks.isMoment = isMoment;
+hooks.weekdays = listWeekdays;
+hooks.parseZone = createInZone;
+hooks.localeData = getLocale;
+hooks.isDuration = isDuration;
+hooks.monthsShort = listMonthsShort;
+hooks.weekdaysMin = listWeekdaysMin;
+hooks.defineLocale = defineLocale;
+hooks.updateLocale = updateLocale;
+hooks.locales = listLocales;
+hooks.weekdaysShort = listWeekdaysShort;
+hooks.normalizeUnits = normalizeUnits;
+hooks.relativeTimeRounding = getSetRelativeTimeRounding;
+hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
+hooks.calendarFormat = getCalendarFormat;
+hooks.prototype = proto;
+
+// currently HTML5 input type only supports 24-hour formats
+hooks.HTML5_FMT = {
+    DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm', // <input type="datetime-local" />
+    DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss', // <input type="datetime-local" step="1" />
+    DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS', // <input type="datetime-local" step="0.001" />
+    DATE: 'YYYY-MM-DD', // <input type="date" />
+    TIME: 'HH:mm', // <input type="time" />
+    TIME_SECONDS: 'HH:mm:ss', // <input type="time" step="1" />
+    TIME_MS: 'HH:mm:ss.SSS', // <input type="time" step="0.001" />
+    WEEK: 'GGGG-[W]WW', // <input type="week" />
+    MONTH: 'YYYY-MM', // <input type="month" />
+};
+
+export default hooks;
diff --git a/parent_dir/node_modules/pinia/dist/pinia.mjs b/parent_dir/node_modules/pinia/dist/pinia.mjs
new file mode 100644
index 0000000..92e71e7
--- /dev/null
+++ b/parent_dir/node_modules/pinia/dist/pinia.mjs
@@ -0,0 +1,2004 @@
+/*!
+ * pinia v2.1.6
+ * (c) 2023 Eduardo San Martin Morote
+ * @license MIT
+ */
+import { hasInjectionContext, inject, toRaw, watch, unref, markRaw, effectScope, ref, isVue2, isRef, isReactive, set, getCurrentScope, onScopeDispose, getCurrentInstance, reactive, toRef, del, nextTick, computed, toRefs } from 'vue-demi';
+import { setupDevtoolsPlugin } from '@vue/devtools-api';
+
+/**
+ * setActivePinia must be called to handle SSR at the top of functions like
+ * `fetch`, `setup`, `serverPrefetch` and others
+ */
+let activePinia;
+/**
+ * Sets or unsets the active pinia. Used in SSR and internally when calling
+ * actions and getters
+ *
+ * @param pinia - Pinia instance
+ */
+// @ts-expect-error: cannot constrain the type of the return
+const setActivePinia = (pinia) => (activePinia = pinia);
+/**
+ * Get the currently active pinia if there is any.
+ */
+const getActivePinia = () => (hasInjectionContext() && inject(piniaSymbol)) || activePinia;
+const piniaSymbol = ((process.env.NODE_ENV !== 'production') ? Symbol('pinia') : /* istanbul ignore next */ Symbol());
+
+function isPlainObject(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+o) {
+    return (o &&
+        typeof o === 'object' &&
+        Object.prototype.toString.call(o) === '[object Object]' &&
+        typeof o.toJSON !== 'function');
+}
+// type DeepReadonly<T> = { readonly [P in keyof T]: DeepReadonly<T[P]> }
+// TODO: can we change these to numbers?
+/**
+ * Possible types for SubscriptionCallback
+ */
+var MutationType;
+(function (MutationType) {
+    /**
+     * Direct mutation of the state:
+     *
+     * - `store.name = 'new name'`
+     * - `store.$state.name = 'new name'`
+     * - `store.list.push('new item')`
+     */
+    MutationType["direct"] = "direct";
+    /**
+     * Mutated the state with `$patch` and an object
+     *
+     * - `store.$patch({ name: 'newName' })`
+     */
+    MutationType["patchObject"] = "patch object";
+    /**
+     * Mutated the state with `$patch` and a function
+     *
+     * - `store.$patch(state => state.name = 'newName')`
+     */
+    MutationType["patchFunction"] = "patch function";
+    // maybe reset? for $state = {} and $reset
+})(MutationType || (MutationType = {}));
+
+const IS_CLIENT = typeof window !== 'undefined';
+/**
+ * Should we add the devtools plugins.
+ * - only if dev mode or forced through the prod devtools flag
+ * - not in test
+ * - only if window exists (could change in the future)
+ */
+const USE_DEVTOOLS = ((process.env.NODE_ENV !== 'production') || (typeof __VUE_PROD_DEVTOOLS__ !== 'undefined' && __VUE_PROD_DEVTOOLS__)) && !(process.env.NODE_ENV === 'test') && IS_CLIENT;
+
+/*
+ * FileSaver.js A saveAs() FileSaver implementation.
+ *
+ * Originally by Eli Grey, adapted as an ESM module by Eduardo San Martin
+ * Morote.
+ *
+ * License : MIT
+ */
+// The one and only way of getting global scope in all environments
+// https://stackoverflow.com/q/3277182/1008999
+const _global = /*#__PURE__*/ (() => typeof window === 'object' && window.window === window
+    ? window
+    : typeof self === 'object' && self.self === self
+        ? self
+        : typeof global === 'object' && global.global === global
+            ? global
+            : typeof globalThis === 'object'
+                ? globalThis
+                : { HTMLElement: null })();
+function bom(blob, { autoBom = false } = {}) {
+    // prepend BOM for UTF-8 XML and text/* types (including HTML)
+    // note: your browser will automatically convert UTF-16 U+FEFF to EF BB BF
+    if (autoBom &&
+        /^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(blob.type)) {
+        return new Blob([String.fromCharCode(0xfeff), blob], { type: blob.type });
+    }
+    return blob;
+}
+function download(url, name, opts) {
+    const xhr = new XMLHttpRequest();
+    xhr.open('GET', url);
+    xhr.responseType = 'blob';
+    xhr.onload = function () {
+        saveAs(xhr.response, name, opts);
+    };
+    xhr.onerror = function () {
+        console.error('could not download file');
+    };
+    xhr.send();
+}
+function corsEnabled(url) {
+    const xhr = new XMLHttpRequest();
+    // use sync to avoid popup blocker
+    xhr.open('HEAD', url, false);
+    try {
+        xhr.send();
+    }
+    catch (e) { }
+    return xhr.status >= 200 && xhr.status <= 299;
+}
+// `a.click()` doesn't work for all browsers (#465)
+function click(node) {
+    try {
+        node.dispatchEvent(new MouseEvent('click'));
+    }
+    catch (e) {
+        const evt = document.createEvent('MouseEvents');
+        evt.initMouseEvent('click', true, true, window, 0, 0, 0, 80, 20, false, false, false, false, 0, null);
+        node.dispatchEvent(evt);
+    }
+}
+const _navigator = 
+ typeof navigator === 'object' ? navigator : { userAgent: '' };
+// Detect WebView inside a native macOS app by ruling out all browsers
+// We just need to check for 'Safari' because all other browsers (besides Firefox) include that too
+// https://www.whatismybrowser.com/guides/the-latest-user-agent/macos
+const isMacOSWebView = /*#__PURE__*/ (() => /Macintosh/.test(_navigator.userAgent) &&
+    /AppleWebKit/.test(_navigator.userAgent) &&
+    !/Safari/.test(_navigator.userAgent))();
+const saveAs = !IS_CLIENT
+    ? () => { } // noop
+    : // Use download attribute first if possible (#193 Lumia mobile) unless this is a macOS WebView or mini program
+        typeof HTMLAnchorElement !== 'undefined' &&
+            'download' in HTMLAnchorElement.prototype &&
+            !isMacOSWebView
+            ? downloadSaveAs
+            : // Use msSaveOrOpenBlob as a second approach
+                'msSaveOrOpenBlob' in _navigator
+                    ? msSaveAs
+                    : // Fallback to using FileReader and a popup
+                        fileSaverSaveAs;
+function downloadSaveAs(blob, name = 'download', opts) {
+    const a = document.createElement('a');
+    a.download = name;
+    a.rel = 'noopener'; // tabnabbing
+    // TODO: detect chrome extensions & packaged apps
+    // a.target = '_blank'
+    if (typeof blob === 'string') {
+        // Support regular links
+        a.href = blob;
+        if (a.origin !== location.origin) {
+            if (corsEnabled(a.href)) {
+                download(blob, name, opts);
+            }
+            else {
+                a.target = '_blank';
+                click(a);
+            }
+        }
+        else {
+            click(a);
+        }
+    }
+    else {
+        // Support blobs
+        a.href = URL.createObjectURL(blob);
+        setTimeout(function () {
+            URL.revokeObjectURL(a.href);
+        }, 4e4); // 40s
+        setTimeout(function () {
+            click(a);
+        }, 0);
+    }
+}
+function msSaveAs(blob, name = 'download', opts) {
+    if (typeof blob === 'string') {
+        if (corsEnabled(blob)) {
+            download(blob, name, opts);
+        }
+        else {
+            const a = document.createElement('a');
+            a.href = blob;
+            a.target = '_blank';
+            setTimeout(function () {
+                click(a);
+            });
+        }
+    }
+    else {
+        // @ts-ignore: works on windows
+        navigator.msSaveOrOpenBlob(bom(blob, opts), name);
+    }
+}
+function fileSaverSaveAs(blob, name, opts, popup) {
+    // Open a popup immediately do go around popup blocker
+    // Mostly only available on user interaction and the fileReader is async so...
+    popup = popup || open('', '_blank');
+    if (popup) {
+        popup.document.title = popup.document.body.innerText = 'downloading...';
+    }
+    if (typeof blob === 'string')
+        return download(blob, name, opts);
+    const force = blob.type === 'application/octet-stream';
+    const isSafari = /constructor/i.test(String(_global.HTMLElement)) || 'safari' in _global;
+    const isChromeIOS = /CriOS\/[\d]+/.test(navigator.userAgent);
+    if ((isChromeIOS || (force && isSafari) || isMacOSWebView) &&
+        typeof FileReader !== 'undefined') {
+        // Safari doesn't allow downloading of blob URLs
+        const reader = new FileReader();
+        reader.onloadend = function () {
+            let url = reader.result;
+            if (typeof url !== 'string') {
+                popup = null;
+                throw new Error('Wrong reader.result type');
+            }
+            url = isChromeIOS
+                ? url
+                : url.replace(/^data:[^;]*;/, 'data:attachment/file;');
+            if (popup) {
+                popup.location.href = url;
+            }
+            else {
+                location.assign(url);
+            }
+            popup = null; // reverse-tabnabbing #460
+        };
+        reader.readAsDataURL(blob);
+    }
+    else {
+        const url = URL.createObjectURL(blob);
+        if (popup)
+            popup.location.assign(url);
+        else
+            location.href = url;
+        popup = null; // reverse-tabnabbing #460
+        setTimeout(function () {
+            URL.revokeObjectURL(url);
+        }, 4e4); // 40s
+    }
+}
+
+/**
+ * Shows a toast or console.log
+ *
+ * @param message - message to log
+ * @param type - different color of the tooltip
+ */
+function toastMessage(message, type) {
+    const piniaMessage = '� ' + message;
+    if (typeof __VUE_DEVTOOLS_TOAST__ === 'function') {
+        // No longer available :(
+        __VUE_DEVTOOLS_TOAST__(piniaMessage, type);
+    }
+    else if (type === 'error') {
+        console.error(piniaMessage);
+    }
+    else if (type === 'warn') {
+        console.warn(piniaMessage);
+    }
+    else {
+        console.log(piniaMessage);
+    }
+}
+function isPinia(o) {
+    return '_a' in o && 'install' in o;
+}
+
+/**
+ * This file contain devtools actions, they are not Pinia actions.
+ */
+// ---
+function checkClipboardAccess() {
+    if (!('clipboard' in navigator)) {
+        toastMessage(`Your browser doesn't support the Clipboard API`, 'error');
+        return true;
+    }
+}
+function checkNotFocusedError(error) {
+    if (error instanceof Error &&
+        error.message.toLowerCase().includes('document is not focused')) {
+        toastMessage('You need to activate the "Emulate a focused page" setting in the "Rendering" panel of devtools.', 'warn');
+        return true;
+    }
+    return false;
+}
+async function actionGlobalCopyState(pinia) {
+    if (checkClipboardAccess())
+        return;
+    try {
+        await navigator.clipboard.writeText(JSON.stringify(pinia.state.value));
+        toastMessage('Global state copied to clipboard.');
+    }
+    catch (error) {
+        if (checkNotFocusedError(error))
+            return;
+        toastMessage(`Failed to serialize the state. Check the console for more details.`, 'error');
+        console.error(error);
+    }
+}
+async function actionGlobalPasteState(pinia) {
+    if (checkClipboardAccess())
+        return;
+    try {
+        loadStoresState(pinia, JSON.parse(await navigator.clipboard.readText()));
+        toastMessage('Global state pasted from clipboard.');
+    }
+    catch (error) {
+        if (checkNotFocusedError(error))
+            return;
+        toastMessage(`Failed to deserialize the state from clipboard. Check the console for more details.`, 'error');
+        console.error(error);
+    }
+}
+async function actionGlobalSaveState(pinia) {
+    try {
+        saveAs(new Blob([JSON.stringify(pinia.state.value)], {
+            type: 'text/plain;charset=utf-8',
+        }), 'pinia-state.json');
+    }
+    catch (error) {
+        toastMessage(`Failed to export the state as JSON. Check the console for more details.`, 'error');
+        console.error(error);
+    }
+}
+let fileInput;
+function getFileOpener() {
+    if (!fileInput) {
+        fileInput = document.createElement('input');
+        fileInput.type = 'file';
+        fileInput.accept = '.json';
+    }
+    function openFile() {
+        return new Promise((resolve, reject) => {
+            fileInput.onchange = async () => {
+                const files = fileInput.files;
+                if (!files)
+                    return resolve(null);
+                const file = files.item(0);
+                if (!file)
+                    return resolve(null);
+                return resolve({ text: await file.text(), file });
+            };
+            // @ts-ignore: TODO: changed from 4.3 to 4.4
+            fileInput.oncancel = () => resolve(null);
+            fileInput.onerror = reject;
+            fileInput.click();
+        });
+    }
+    return openFile;
+}
+async function actionGlobalOpenStateFile(pinia) {
+    try {
+        const open = getFileOpener();
+        const result = await open();
+        if (!result)
+            return;
+        const { text, file } = result;
+        loadStoresState(pinia, JSON.parse(text));
+        toastMessage(`Global state imported from "${file.name}".`);
+    }
+    catch (error) {
+        toastMessage(`Failed to import the state from JSON. Check the console for more details.`, 'error');
+        console.error(error);
+    }
+}
+function loadStoresState(pinia, state) {
+    for (const key in state) {
+        const storeState = pinia.state.value[key];
+        if (storeState) {
+            Object.assign(storeState, state[key]);
+        }
+    }
+}
+
+function formatDisplay(display) {
+    return {
+        _custom: {
+            display,
+        },
+    };
+}
+const PINIA_ROOT_LABEL = '� Pinia (root)';
+const PINIA_ROOT_ID = '_root';
+function formatStoreForInspectorTree(store) {
+    return isPinia(store)
+        ? {
+            id: PINIA_ROOT_ID,
+            label: PINIA_ROOT_LABEL,
+        }
+        : {
+            id: store.$id,
+            label: store.$id,
+        };
+}
+function formatStoreForInspectorState(store) {
+    if (isPinia(store)) {
+        const storeNames = Array.from(store._s.keys());
+        const storeMap = store._s;
+        const state = {
+            state: storeNames.map((storeId) => ({
+                editable: true,
+                key: storeId,
+                value: store.state.value[storeId],
+            })),
+            getters: storeNames
+                .filter((id) => storeMap.get(id)._getters)
+                .map((id) => {
+                const store = storeMap.get(id);
+                return {
+                    editable: false,
+                    key: id,
+                    value: store._getters.reduce((getters, key) => {
+                        getters[key] = store[key];
+                        return getters;
+                    }, {}),
+                };
+            }),
+        };
+        return state;
+    }
+    const state = {
+        state: Object.keys(store.$state).map((key) => ({
+            editable: true,
+            key,
+            value: store.$state[key],
+        })),
+    };
+    // avoid adding empty getters
+    if (store._getters && store._getters.length) {
+        state.getters = store._getters.map((getterName) => ({
+            editable: false,
+            key: getterName,
+            value: store[getterName],
+        }));
+    }
+    if (store._customProperties.size) {
+        state.customProperties = Array.from(store._customProperties).map((key) => ({
+            editable: true,
+            key,
+            value: store[key],
+        }));
+    }
+    return state;
+}
+function formatEventData(events) {
+    if (!events)
+        return {};
+    if (Array.isArray(events)) {
+        // TODO: handle add and delete for arrays and objects
+        return events.reduce((data, event) => {
+            data.keys.push(event.key);
+            data.operations.push(event.type);
+            data.oldValue[event.key] = event.oldValue;
+            data.newValue[event.key] = event.newValue;
+            return data;
+        }, {
+            oldValue: {},
+            keys: [],
+            operations: [],
+            newValue: {},
+        });
+    }
+    else {
+        return {
+            operation: formatDisplay(events.type),
+            key: formatDisplay(events.key),
+            oldValue: events.oldValue,
+            newValue: events.newValue,
+        };
+    }
+}
+function formatMutationType(type) {
+    switch (type) {
+        case MutationType.direct:
+            return 'mutation';
+        case MutationType.patchFunction:
+            return '$patch';
+        case MutationType.patchObject:
+            return '$patch';
+        default:
+            return 'unknown';
+    }
+}
+
+// timeline can be paused when directly changing the state
+let isTimelineActive = true;
+const componentStateTypes = [];
+const MUTATIONS_LAYER_ID = 'pinia:mutations';
+const INSPECTOR_ID = 'pinia';
+const { assign: assign$1 } = Object;
+/**
+ * Gets the displayed name of a store in devtools
+ *
+ * @param id - id of the store
+ * @returns a formatted string
+ */
+const getStoreType = (id) => '� ' + id;
+/**
+ * Add the pinia plugin without any store. Allows displaying a Pinia plugin tab
+ * as soon as it is added to the application.
+ *
+ * @param app - Vue application
+ * @param pinia - pinia instance
+ */
+function registerPiniaDevtools(app, pinia) {
+    setupDevtoolsPlugin({
+        id: 'dev.esm.pinia',
+        label: 'Pinia �',
+        logo: 'https://pinia.vuejs.org/logo.svg',
+        packageName: 'pinia',
+        homepage: 'https://pinia.vuejs.org',
+        componentStateTypes,
+        app,
+    }, (api) => {
+        if (typeof api.now !== 'function') {
+            toastMessage('You seem to be using an outdated version of Vue Devtools. Are you still using the Beta release instead of the stable one? You can find the links at https://devtools.vuejs.org/guide/installation.html.');
+        }
+        api.addTimelineLayer({
+            id: MUTATIONS_LAYER_ID,
+            label: `Pinia �`,
+            color: 0xe5df88,
+        });
+        api.addInspector({
+            id: INSPECTOR_ID,
+            label: 'Pinia �',
+            icon: 'storage',
+            treeFilterPlaceholder: 'Search stores',
+            actions: [
+                {
+                    icon: 'content_copy',
+                    action: () => {
+                        actionGlobalCopyState(pinia);
+                    },
+                    tooltip: 'Serialize and copy the state',
+                },
+                {
+                    icon: 'content_paste',
+                    action: async () => {
+                        await actionGlobalPasteState(pinia);
+                        api.sendInspectorTree(INSPECTOR_ID);
+                        api.sendInspectorState(INSPECTOR_ID);
+                    },
+                    tooltip: 'Replace the state with the content of your clipboard',
+                },
+                {
+                    icon: 'save',
+                    action: () => {
+                        actionGlobalSaveState(pinia);
+                    },
+                    tooltip: 'Save the state as a JSON file',
+                },
+                {
+                    icon: 'folder_open',
+                    action: async () => {
+                        await actionGlobalOpenStateFile(pinia);
+                        api.sendInspectorTree(INSPECTOR_ID);
+                        api.sendInspectorState(INSPECTOR_ID);
+                    },
+                    tooltip: 'Import the state from a JSON file',
+                },
+            ],
+            nodeActions: [
+                {
+                    icon: 'restore',
+                    tooltip: 'Reset the state (with "$reset")',
+                    action: (nodeId) => {
+                        const store = pinia._s.get(nodeId);
+                        if (!store) {
+                            toastMessage(`Cannot reset "${nodeId}" store because it wasn't found.`, 'warn');
+                        }
+                        else if (typeof store.$reset !== 'function') {
+                            toastMessage(`Cannot reset "${nodeId}" store because it doesn't have a "$reset" method implemented.`, 'warn');
+                        }
+                        else {
+                            store.$reset();
+                            toastMessage(`Store "${nodeId}" reset.`);
+                        }
+                    },
+                },
+            ],
+        });
+        api.on.inspectComponent((payload, ctx) => {
+            const proxy = (payload.componentInstance &&
+                payload.componentInstance.proxy);
+            if (proxy && proxy._pStores) {
+                const piniaStores = payload.componentInstance.proxy._pStores;
+                Object.values(piniaStores).forEach((store) => {
+                    payload.instanceData.state.push({
+                        type: getStoreType(store.$id),
+                        key: 'state',
+                        editable: true,
+                        value: store._isOptionsAPI
+                            ? {
+                                _custom: {
+                                    value: toRaw(store.$state),
+                                    actions: [
+                                        {
+                                            icon: 'restore',
+                                            tooltip: 'Reset the state of this store',
+                                            action: () => store.$reset(),
+                                        },
+                                    ],
+                                },
+                            }
+                            : // NOTE: workaround to unwrap transferred refs
+                                Object.keys(store.$state).reduce((state, key) => {
+                                    state[key] = store.$state[key];
+                                    return state;
+                                }, {}),
+                    });
+                    if (store._getters && store._getters.length) {
+                        payload.instanceData.state.push({
+                            type: getStoreType(store.$id),
+                            key: 'getters',
+                            editable: false,
+                            value: store._getters.reduce((getters, key) => {
+                                try {
+                                    getters[key] = store[key];
+                                }
+                                catch (error) {
+                                    // @ts-expect-error: we just want to show it in devtools
+                                    getters[key] = error;
+                                }
+                                return getters;
+                            }, {}),
+                        });
+                    }
+                });
+            }
+        });
+        api.on.getInspectorTree((payload) => {
+            if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
+                let stores = [pinia];
+                stores = stores.concat(Array.from(pinia._s.values()));
+                payload.rootNodes = (payload.filter
+                    ? stores.filter((store) => '$id' in store
+                        ? store.$id
+                            .toLowerCase()
+                            .includes(payload.filter.toLowerCase())
+                        : PINIA_ROOT_LABEL.toLowerCase().includes(payload.filter.toLowerCase()))
+                    : stores).map(formatStoreForInspectorTree);
+            }
+        });
+        api.on.getInspectorState((payload) => {
+            if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
+                const inspectedStore = payload.nodeId === PINIA_ROOT_ID
+                    ? pinia
+                    : pinia._s.get(payload.nodeId);
+                if (!inspectedStore) {
+                    // this could be the selected store restored for a different project
+                    // so it's better not to say anything here
+                    return;
+                }
+                if (inspectedStore) {
+                    payload.state = formatStoreForInspectorState(inspectedStore);
+                }
+            }
+        });
+        api.on.editInspectorState((payload, ctx) => {
+            if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
+                const inspectedStore = payload.nodeId === PINIA_ROOT_ID
+                    ? pinia
+                    : pinia._s.get(payload.nodeId);
+                if (!inspectedStore) {
+                    return toastMessage(`store "${payload.nodeId}" not found`, 'error');
+                }
+                const { path } = payload;
+                if (!isPinia(inspectedStore)) {
+                    // access only the state
+                    if (path.length !== 1 ||
+                        !inspectedStore._customProperties.has(path[0]) ||
+                        path[0] in inspectedStore.$state) {
+                        path.unshift('$state');
+                    }
+                }
+                else {
+                    // Root access, we can omit the `.value` because the devtools API does it for us
+                    path.unshift('state');
+                }
+                isTimelineActive = false;
+                payload.set(inspectedStore, path, payload.state.value);
+                isTimelineActive = true;
+            }
+        });
+        api.on.editComponentState((payload) => {
+            if (payload.type.startsWith('�')) {
+                const storeId = payload.type.replace(/^�\s*/, '');
+                const store = pinia._s.get(storeId);
+                if (!store) {
+                    return toastMessage(`store "${storeId}" not found`, 'error');
+                }
+                const { path } = payload;
+                if (path[0] !== 'state') {
+                    return toastMessage(`Invalid path for store "${storeId}":\n${path}\nOnly state can be modified.`);
+                }
+                // rewrite the first entry to be able to directly set the state as
+                // well as any other path
+                path[0] = '$state';
+                isTimelineActive = false;
+                payload.set(store, path, payload.state.value);
+                isTimelineActive = true;
+            }
+        });
+    });
+}
+function addStoreToDevtools(app, store) {
+    if (!componentStateTypes.includes(getStoreType(store.$id))) {
+        componentStateTypes.push(getStoreType(store.$id));
+    }
+    setupDevtoolsPlugin({
+        id: 'dev.esm.pinia',
+        label: 'Pinia �',
+        logo: 'https://pinia.vuejs.org/logo.svg',
+        packageName: 'pinia',
+        homepage: 'https://pinia.vuejs.org',
+        componentStateTypes,
+        app,
+        settings: {
+            logStoreChanges: {
+                label: 'Notify about new/deleted stores',
+                type: 'boolean',
+                defaultValue: true,
+            },
+            // useEmojis: {
+            //   label: 'Use emojis in messages ⚡�',
+            //   type: 'boolean',
+            //   defaultValue: true,
+            // },
+        },
+    }, (api) => {
+        // gracefully handle errors
+        const now = typeof api.now === 'function' ? api.now.bind(api) : Date.now;
+        store.$onAction(({ after, onError, name, args }) => {
+            const groupId = runningActionId++;
+            api.addTimelineEvent({
+                layerId: MUTATIONS_LAYER_ID,
+                event: {
+                    time: now(),
+                    title: '🛫 ' + name,
+                    subtitle: 'start',
+                    data: {
+                        store: formatDisplay(store.$id),
+                        action: formatDisplay(name),
+                        args,
+                    },
+                    groupId,
+                },
+            });
+            after((result) => {
+                activeAction = undefined;
+                api.addTimelineEvent({
+                    layerId: MUTATIONS_LAYER_ID,
+                    event: {
+                        time: now(),
+                        title: '🛬 ' + name,
+                        subtitle: 'end',
+                        data: {
+                            store: formatDisplay(store.$id),
+                            action: formatDisplay(name),
+                            args,
+                            result,
+                        },
+                        groupId,
+                    },
+                });
+            });
+            onError((error) => {
+                activeAction = undefined;
+                api.addTimelineEvent({
+                    layerId: MUTATIONS_LAYER_ID,
+                    event: {
+                        time: now(),
+                        logType: 'error',
+                        title: '💥 ' + name,
+                        subtitle: 'end',
+                        data: {
+                            store: formatDisplay(store.$id),
+                            action: formatDisplay(name),
+                            args,
+                            error,
+                        },
+                        groupId,
+                    },
+                });
+            });
+        }, true);
+        store._customProperties.forEach((name) => {
+            watch(() => unref(store[name]), (newValue, oldValue) => {
+                api.notifyComponentUpdate();
+                api.sendInspectorState(INSPECTOR_ID);
+                if (isTimelineActive) {
+                    api.addTimelineEvent({
+                        layerId: MUTATIONS_LAYER_ID,
+                        event: {
+                            time: now(),
+                            title: 'Change',
+                            subtitle: name,
+                            data: {
+                                newValue,
+                                oldValue,
+                            },
+                            groupId: activeAction,
+                        },
+                    });
+                }
+            }, { deep: true });
+        });
+        store.$subscribe(({ events, type }, state) => {
+            api.notifyComponentUpdate();
+            api.sendInspectorState(INSPECTOR_ID);
+            if (!isTimelineActive)
+                return;
+            // rootStore.state[store.id] = state
+            const eventData = {
+                time: now(),
+                title: formatMutationType(type),
+                data: assign$1({ store: formatDisplay(store.$id) }, formatEventData(events)),
+                groupId: activeAction,
+            };
+            if (type === MutationType.patchFunction) {
+                eventData.subtitle = '⤵�';
+            }
+            else if (type === MutationType.patchObject) {
+                eventData.subtitle = '🧩';
+            }
+            else if (events && !Array.isArray(events)) {
+                eventData.subtitle = events.type;
+            }
+            if (events) {
+                eventData.data['rawEvent(s)'] = {
+                    _custom: {
+                        display: 'DebuggerEvent',
+                        type: 'object',
+                        tooltip: 'raw DebuggerEvent[]',
+                        value: events,
+                    },
+                };
+            }
+            api.addTimelineEvent({
+                layerId: MUTATIONS_LAYER_ID,
+                event: eventData,
+            });
+        }, { detached: true, flush: 'sync' });
+        const hotUpdate = store._hotUpdate;
+        store._hotUpdate = markRaw((newStore) => {
+            hotUpdate(newStore);
+            api.addTimelineEvent({
+                layerId: MUTATIONS_LAYER_ID,
+                event: {
+                    time: now(),
+                    title: '🔥 ' + store.$id,
+                    subtitle: 'HMR update',
+                    data: {
+                        store: formatDisplay(store.$id),
+                        info: formatDisplay(`HMR update`),
+                    },
+                },
+            });
+            // update the devtools too
+            api.notifyComponentUpdate();
+            api.sendInspectorTree(INSPECTOR_ID);
+            api.sendInspectorState(INSPECTOR_ID);
+        });
+        const { $dispose } = store;
+        store.$dispose = () => {
+            $dispose();
+            api.notifyComponentUpdate();
+            api.sendInspectorTree(INSPECTOR_ID);
+            api.sendInspectorState(INSPECTOR_ID);
+            api.getSettings().logStoreChanges &&
+                toastMessage(`Disposed "${store.$id}" store 🗑`);
+        };
+        // trigger an update so it can display new registered stores
+        api.notifyComponentUpdate();
+        api.sendInspectorTree(INSPECTOR_ID);
+        api.sendInspectorState(INSPECTOR_ID);
+        api.getSettings().logStoreChanges &&
+            toastMessage(`"${store.$id}" store installed 🆕`);
+    });
+}
+let runningActionId = 0;
+let activeAction;
+/**
+ * Patches a store to enable action grouping in devtools by wrapping the store with a Proxy that is passed as the
+ * context of all actions, allowing us to set `runningAction` on each access and effectively associating any state
+ * mutation to the action.
+ *
+ * @param store - store to patch
+ * @param actionNames - list of actionst to patch
+ */
+function patchActionForGrouping(store, actionNames, wrapWithProxy) {
+    // original actions of the store as they are given by pinia. We are going to override them
+    const actions = actionNames.reduce((storeActions, actionName) => {
+        // use toRaw to avoid tracking #541
+        storeActions[actionName] = toRaw(store)[actionName];
+        return storeActions;
+    }, {});
+    for (const actionName in actions) {
+        store[actionName] = function () {
+            // the running action id is incremented in a before action hook
+            const _actionId = runningActionId;
+            const trackedStore = wrapWithProxy
+                ? new Proxy(store, {
+                    get(...args) {
+                        activeAction = _actionId;
+                        return Reflect.get(...args);
+                    },
+                    set(...args) {
+                        activeAction = _actionId;
+                        return Reflect.set(...args);
+                    },
+                })
+                : store;
+            // For Setup Stores we need https://github.com/tc39/proposal-async-context
+            activeAction = _actionId;
+            const retValue = actions[actionName].apply(trackedStore, arguments);
+            // this is safer as async actions in Setup Stores would associate mutations done outside of the action
+            activeAction = undefined;
+            return retValue;
+        };
+    }
+}
+/**
+ * pinia.use(devtoolsPlugin)
+ */
+function devtoolsPlugin({ app, store, options }) {
+    // HMR module
+    if (store.$id.startsWith('__hot:')) {
+        return;
+    }
+    // detect option api vs setup api
+    store._isOptionsAPI = !!options.state;
+    patchActionForGrouping(store, Object.keys(options.actions), store._isOptionsAPI);
+    // Upgrade the HMR to also update the new actions
+    const originalHotUpdate = store._hotUpdate;
+    toRaw(store)._hotUpdate = function (newStore) {
+        originalHotUpdate.apply(this, arguments);
+        patchActionForGrouping(store, Object.keys(newStore._hmrPayload.actions), !!store._isOptionsAPI);
+    };
+    addStoreToDevtools(app, 
+    // FIXME: is there a way to allow the assignment from Store<Id, S, G, A> to StoreGeneric?
+    store);
+}
+
+/**
+ * Creates a Pinia instance to be used by the application
+ */
+function createPinia() {
+    const scope = effectScope(true);
+    // NOTE: here we could check the window object for a state and directly set it
+    // if there is anything like it with Vue 3 SSR
+    const state = scope.run(() => ref({}));
+    let _p = [];
+    // plugins added before calling app.use(pinia)
+    let toBeInstalled = [];
+    const pinia = markRaw({
+        install(app) {
+            // this allows calling useStore() outside of a component setup after
+            // installing pinia's plugin
+            setActivePinia(pinia);
+            if (!isVue2) {
+                pinia._a = app;
+                app.provide(piniaSymbol, pinia);
+                app.config.globalProperties.$pinia = pinia;
+                /* istanbul ignore else */
+                if (USE_DEVTOOLS) {
+                    registerPiniaDevtools(app, pinia);
+                }
+                toBeInstalled.forEach((plugin) => _p.push(plugin));
+                toBeInstalled = [];
+            }
+        },
+        use(plugin) {
+            if (!this._a && !isVue2) {
+                toBeInstalled.push(plugin);
+            }
+            else {
+                _p.push(plugin);
+            }
+            return this;
+        },
+        _p,
+        // it's actually undefined here
+        // @ts-expect-error
+        _a: null,
+        _e: scope,
+        _s: new Map(),
+        state,
+    });
+    // pinia devtools rely on dev only features so they cannot be forced unless
+    // the dev build of Vue is used. Avoid old browsers like IE11.
+    if (USE_DEVTOOLS && typeof Proxy !== 'undefined') {
+        pinia.use(devtoolsPlugin);
+    }
+    return pinia;
+}
+
+/**
+ * Checks if a function is a `StoreDefinition`.
+ *
+ * @param fn - object to test
+ * @returns true if `fn` is a StoreDefinition
+ */
+const isUseStore = (fn) => {
+    return typeof fn === 'function' && typeof fn.$id === 'string';
+};
+/**
+ * Mutates in place `newState` with `oldState` to _hot update_ it. It will
+ * remove any key not existing in `newState` and recursively merge plain
+ * objects.
+ *
+ * @param newState - new state object to be patched
+ * @param oldState - old state that should be used to patch newState
+ * @returns - newState
+ */
+function patchObject(newState, oldState) {
+    // no need to go through symbols because they cannot be serialized anyway
+    for (const key in oldState) {
+        const subPatch = oldState[key];
+        // skip the whole sub tree
+        if (!(key in newState)) {
+            continue;
+        }
+        const targetValue = newState[key];
+        if (isPlainObject(targetValue) &&
+            isPlainObject(subPatch) &&
+            !isRef(subPatch) &&
+            !isReactive(subPatch)) {
+            newState[key] = patchObject(targetValue, subPatch);
+        }
+        else {
+            // objects are either a bit more complex (e.g. refs) or primitives, so we
+            // just set the whole thing
+            if (isVue2) {
+                set(newState, key, subPatch);
+            }
+            else {
+                newState[key] = subPatch;
+            }
+        }
+    }
+    return newState;
+}
+/**
+ * Creates an _accept_ function to pass to `import.meta.hot` in Vite applications.
+ *
+ * @example
+ * ```js
+ * const useUser = defineStore(...)
+ * if (import.meta.hot) {
+ *   import.meta.hot.accept(acceptHMRUpdate(useUser, import.meta.hot))
+ * }
+ * ```
+ *
+ * @param initialUseStore - return of the defineStore to hot update
+ * @param hot - `import.meta.hot`
+ */
+function acceptHMRUpdate(initialUseStore, hot) {
+    // strip as much as possible from iife.prod
+    if (!(process.env.NODE_ENV !== 'production')) {
+        return () => { };
+    }
+    return (newModule) => {
+        const pinia = hot.data.pinia || initialUseStore._pinia;
+        if (!pinia) {
+            // this store is still not used
+            return;
+        }
+        // preserve the pinia instance across loads
+        hot.data.pinia = pinia;
+        // console.log('got data', newStore)
+        for (const exportName in newModule) {
+            const useStore = newModule[exportName];
+            // console.log('checking for', exportName)
+            if (isUseStore(useStore) && pinia._s.has(useStore.$id)) {
+                // console.log('Accepting update for', useStore.$id)
+                const id = useStore.$id;
+                if (id !== initialUseStore.$id) {
+                    console.warn(`The id of the store changed from "${initialUseStore.$id}" to "${id}". Reloading.`);
+                    // return import.meta.hot.invalidate()
+                    return hot.invalidate();
+                }
+                const existingStore = pinia._s.get(id);
+                if (!existingStore) {
+                    console.log(`[Pinia]: skipping hmr because store doesn't exist yet`);
+                    return;
+                }
+                useStore(pinia, existingStore);
+            }
+        }
+    };
+}
+
+const noop = () => { };
+function addSubscription(subscriptions, callback, detached, onCleanup = noop) {
+    subscriptions.push(callback);
+    const removeSubscription = () => {
+        const idx = subscriptions.indexOf(callback);
+        if (idx > -1) {
+            subscriptions.splice(idx, 1);
+            onCleanup();
+        }
+    };
+    if (!detached && getCurrentScope()) {
+        onScopeDispose(removeSubscription);
+    }
+    return removeSubscription;
+}
+function triggerSubscriptions(subscriptions, ...args) {
+    subscriptions.slice().forEach((callback) => {
+        callback(...args);
+    });
+}
+
+const fallbackRunWithContext = (fn) => fn();
+function mergeReactiveObjects(target, patchToApply) {
+    // Handle Map instances
+    if (target instanceof Map && patchToApply instanceof Map) {
+        patchToApply.forEach((value, key) => target.set(key, value));
+    }
+    // Handle Set instances
+    if (target instanceof Set && patchToApply instanceof Set) {
+        patchToApply.forEach(target.add, target);
+    }
+    // no need to go through symbols because they cannot be serialized anyway
+    for (const key in patchToApply) {
+        if (!patchToApply.hasOwnProperty(key))
+            continue;
+        const subPatch = patchToApply[key];
+        const targetValue = target[key];
+        if (isPlainObject(targetValue) &&
+            isPlainObject(subPatch) &&
+            target.hasOwnProperty(key) &&
+            !isRef(subPatch) &&
+            !isReactive(subPatch)) {
+            // NOTE: here I wanted to warn about inconsistent types but it's not possible because in setup stores one might
+            // start the value of a property as a certain type e.g. a Map, and then for some reason, during SSR, change that
+            // to `undefined`. When trying to hydrate, we want to override the Map with `undefined`.
+            target[key] = mergeReactiveObjects(targetValue, subPatch);
+        }
+        else {
+            // @ts-expect-error: subPatch is a valid value
+            target[key] = subPatch;
+        }
+    }
+    return target;
+}
+const skipHydrateSymbol = (process.env.NODE_ENV !== 'production')
+    ? Symbol('pinia:skipHydration')
+    : /* istanbul ignore next */ Symbol();
+const skipHydrateMap = /*#__PURE__*/ new WeakMap();
+/**
+ * Tells Pinia to skip the hydration process of a given object. This is useful in setup stores (only) when you return a
+ * stateful object in the store but it isn't really state. e.g. returning a router instance in a setup store.
+ *
+ * @param obj - target object
+ * @returns obj
+ */
+function skipHydrate(obj) {
+    return isVue2
+        ? // in @vue/composition-api, the refs are sealed so defineProperty doesn't work...
+            /* istanbul ignore next */ skipHydrateMap.set(obj, 1) && obj
+        : Object.defineProperty(obj, skipHydrateSymbol, {});
+}
+/**
+ * Returns whether a value should be hydrated
+ *
+ * @param obj - target variable
+ * @returns true if `obj` should be hydrated
+ */
+function shouldHydrate(obj) {
+    return isVue2
+        ? /* istanbul ignore next */ !skipHydrateMap.has(obj)
+        : !isPlainObject(obj) || !obj.hasOwnProperty(skipHydrateSymbol);
+}
+const { assign } = Object;
+function isComputed(o) {
+    return !!(isRef(o) && o.effect);
+}
+function createOptionsStore(id, options, pinia, hot) {
+    const { state, actions, getters } = options;
+    const initialState = pinia.state.value[id];
+    let store;
+    function setup() {
+        if (!initialState && (!(process.env.NODE_ENV !== 'production') || !hot)) {
+            /* istanbul ignore if */
+            if (isVue2) {
+                set(pinia.state.value, id, state ? state() : {});
+            }
+            else {
+                pinia.state.value[id] = state ? state() : {};
+            }
+        }
+        // avoid creating a state in pinia.state.value
+        const localState = (process.env.NODE_ENV !== 'production') && hot
+            ? // use ref() to unwrap refs inside state TODO: check if this is still necessary
+                toRefs(ref(state ? state() : {}).value)
+            : toRefs(pinia.state.value[id]);
+        return assign(localState, actions, Object.keys(getters || {}).reduce((computedGetters, name) => {
+            if ((process.env.NODE_ENV !== 'production') && name in localState) {
+                console.warn(`[�]: A getter cannot have the same name as another state property. Rename one of them. Found with "${name}" in store "${id}".`);
+            }
+            computedGetters[name] = markRaw(computed(() => {
+                setActivePinia(pinia);
+                // it was created just before
+                const store = pinia._s.get(id);
+                // allow cross using stores
+                /* istanbul ignore next */
+                if (isVue2 && !store._r)
+                    return;
+                // @ts-expect-error
+                // return getters![name].call(context, context)
+                // TODO: avoid reading the getter while assigning with a global variable
+                return getters[name].call(store, store);
+            }));
+            return computedGetters;
+        }, {}));
+    }
+    store = createSetupStore(id, setup, options, pinia, hot, true);
+    return store;
+}
+function createSetupStore($id, setup, options = {}, pinia, hot, isOptionsStore) {
+    let scope;
+    const optionsForPlugin = assign({ actions: {} }, options);
+    /* istanbul ignore if */
+    if ((process.env.NODE_ENV !== 'production') && !pinia._e.active) {
+        throw new Error('Pinia destroyed');
+    }
+    // watcher options for $subscribe
+    const $subscribeOptions = {
+        deep: true,
+        // flush: 'post',
+    };
+    /* istanbul ignore else */
+    if ((process.env.NODE_ENV !== 'production') && !isVue2) {
+        $subscribeOptions.onTrigger = (event) => {
+            /* istanbul ignore else */
+            if (isListening) {
+                debuggerEvents = event;
+                // avoid triggering this while the store is being built and the state is being set in pinia
+            }
+            else if (isListening == false && !store._hotUpdating) {
+                // let patch send all the events together later
+                /* istanbul ignore else */
+                if (Array.isArray(debuggerEvents)) {
+                    debuggerEvents.push(event);
+                }
+                else {
+                    console.error('� debuggerEvents should be an array. This is most likely an internal Pinia bug.');
+                }
+            }
+        };
+    }
+    // internal state
+    let isListening; // set to true at the end
+    let isSyncListening; // set to true at the end
+    let subscriptions = [];
+    let actionSubscriptions = [];
+    let debuggerEvents;
+    const initialState = pinia.state.value[$id];
+    // avoid setting the state for option stores if it is set
+    // by the setup
+    if (!isOptionsStore && !initialState && (!(process.env.NODE_ENV !== 'production') || !hot)) {
+        /* istanbul ignore if */
+        if (isVue2) {
+            set(pinia.state.value, $id, {});
+        }
+        else {
+            pinia.state.value[$id] = {};
+        }
+    }
+    const hotState = ref({});
+    // avoid triggering too many listeners
+    // https://github.com/vuejs/pinia/issues/1129
+    let activeListener;
+    function $patch(partialStateOrMutator) {
+        let subscriptionMutation;
+        isListening = isSyncListening = false;
+        // reset the debugger events since patches are sync
+        /* istanbul ignore else */
+        if ((process.env.NODE_ENV !== 'production')) {
+            debuggerEvents = [];
+        }
+        if (typeof partialStateOrMutator === 'function') {
+            partialStateOrMutator(pinia.state.value[$id]);
+            subscriptionMutation = {
+                type: MutationType.patchFunction,
+                storeId: $id,
+                events: debuggerEvents,
+            };
+        }
+        else {
+            mergeReactiveObjects(pinia.state.value[$id], partialStateOrMutator);
+            subscriptionMutation = {
+                type: MutationType.patchObject,
+                payload: partialStateOrMutator,
+                storeId: $id,
+                events: debuggerEvents,
+            };
+        }
+        const myListenerId = (activeListener = Symbol());
+        nextTick().then(() => {
+            if (activeListener === myListenerId) {
+                isListening = true;
+            }
+        });
+        isSyncListening = true;
+        // because we paused the watcher, we need to manually call the subscriptions
+        triggerSubscriptions(subscriptions, subscriptionMutation, pinia.state.value[$id]);
+    }
+    const $reset = isOptionsStore
+        ? function $reset() {
+            const { state } = options;
+            const newState = state ? state() : {};
+            // we use a patch to group all changes into one single subscription
+            this.$patch(($state) => {
+                assign($state, newState);
+            });
+        }
+        : /* istanbul ignore next */
+            (process.env.NODE_ENV !== 'production')
+                ? () => {
+                    throw new Error(`�: Store "${$id}" is built using the setup syntax and does not implement $reset().`);
+                }
+                : noop;
+    function $dispose() {
+        scope.stop();
+        subscriptions = [];
+        actionSubscriptions = [];
+        pinia._s.delete($id);
+    }
+    /**
+     * Wraps an action to handle subscriptions.
+     *
+     * @param name - name of the action
+     * @param action - action to wrap
+     * @returns a wrapped action to handle subscriptions
+     */
+    function wrapAction(name, action) {
+        return function () {
+            setActivePinia(pinia);
+            const args = Array.from(arguments);
+            const afterCallbackList = [];
+            const onErrorCallbackList = [];
+            function after(callback) {
+                afterCallbackList.push(callback);
+            }
+            function onError(callback) {
+                onErrorCallbackList.push(callback);
+            }
+            // @ts-expect-error
+            triggerSubscriptions(actionSubscriptions, {
+                args,
+                name,
+                store,
+                after,
+                onError,
+            });
+            let ret;
+            try {
+                ret = action.apply(this && this.$id === $id ? this : store, args);
+                // handle sync errors
+            }
+            catch (error) {
+                triggerSubscriptions(onErrorCallbackList, error);
+                throw error;
+            }
+            if (ret instanceof Promise) {
+                return ret
+                    .then((value) => {
+                    triggerSubscriptions(afterCallbackList, value);
+                    return value;
+                })
+                    .catch((error) => {
+                    triggerSubscriptions(onErrorCallbackList, error);
+                    return Promise.reject(error);
+                });
+            }
+            // trigger after callbacks
+            triggerSubscriptions(afterCallbackList, ret);
+            return ret;
+        };
+    }
+    const _hmrPayload = /*#__PURE__*/ markRaw({
+        actions: {},
+        getters: {},
+        state: [],
+        hotState,
+    });
+    const partialStore = {
+        _p: pinia,
+        // _s: scope,
+        $id,
+        $onAction: addSubscription.bind(null, actionSubscriptions),
+        $patch,
+        $reset,
+        $subscribe(callback, options = {}) {
+            const removeSubscription = addSubscription(subscriptions, callback, options.detached, () => stopWatcher());
+            const stopWatcher = scope.run(() => watch(() => pinia.state.value[$id], (state) => {
+                if (options.flush === 'sync' ? isSyncListening : isListening) {
+                    callback({
+                        storeId: $id,
+                        type: MutationType.direct,
+                        events: debuggerEvents,
+                    }, state);
+                }
+            }, assign({}, $subscribeOptions, options)));
+            return removeSubscription;
+        },
+        $dispose,
+    };
+    /* istanbul ignore if */
+    if (isVue2) {
+        // start as non ready
+        partialStore._r = false;
+    }
+    const store = reactive((process.env.NODE_ENV !== 'production') || USE_DEVTOOLS
+        ? assign({
+            _hmrPayload,
+            _customProperties: markRaw(new Set()), // devtools custom properties
+        }, partialStore
+        // must be added later
+        // setupStore
+        )
+        : partialStore);
+    // store the partial store now so the setup of stores can instantiate each other before they are finished without
+    // creating infinite loops.
+    pinia._s.set($id, store);
+    const runWithContext = (pinia._a && pinia._a.runWithContext) || fallbackRunWithContext;
+    // TODO: idea create skipSerialize that marks properties as non serializable and they are skipped
+    const setupStore = pinia._e.run(() => {
+        scope = effectScope();
+        return runWithContext(() => scope.run(setup));
+    });
+    // overwrite existing actions to support $onAction
+    for (const key in setupStore) {
+        const prop = setupStore[key];
+        if ((isRef(prop) && !isComputed(prop)) || isReactive(prop)) {
+            // mark it as a piece of state to be serialized
+            if ((process.env.NODE_ENV !== 'production') && hot) {
+                set(hotState.value, key, toRef(setupStore, key));
+                // createOptionStore directly sets the state in pinia.state.value so we
+                // can just skip that
+            }
+            else if (!isOptionsStore) {
+                // in setup stores we must hydrate the state and sync pinia state tree with the refs the user just created
+                if (initialState && shouldHydrate(prop)) {
+                    if (isRef(prop)) {
+                        prop.value = initialState[key];
+                    }
+                    else {
+                        // probably a reactive object, lets recursively assign
+                        // @ts-expect-error: prop is unknown
+                        mergeReactiveObjects(prop, initialState[key]);
+                    }
+                }
+                // transfer the ref to the pinia state to keep everything in sync
+                /* istanbul ignore if */
+                if (isVue2) {
+                    set(pinia.state.value[$id], key, prop);
+                }
+                else {
+                    pinia.state.value[$id][key] = prop;
+                }
+            }
+            /* istanbul ignore else */
+            if ((process.env.NODE_ENV !== 'production')) {
+                _hmrPayload.state.push(key);
+            }
+            // action
+        }
+        else if (typeof prop === 'function') {
+            // @ts-expect-error: we are overriding the function we avoid wrapping if
+            const actionValue = (process.env.NODE_ENV !== 'production') && hot ? prop : wrapAction(key, prop);
+            // this a hot module replacement store because the hotUpdate method needs
+            // to do it with the right context
+            /* istanbul ignore if */
+            if (isVue2) {
+                set(setupStore, key, actionValue);
+            }
+            else {
+                // @ts-expect-error
+                setupStore[key] = actionValue;
+            }
+            /* istanbul ignore else */
+            if ((process.env.NODE_ENV !== 'production')) {
+                _hmrPayload.actions[key] = prop;
+            }
+            // list actions so they can be used in plugins
+            // @ts-expect-error
+            optionsForPlugin.actions[key] = prop;
+        }
+        else if ((process.env.NODE_ENV !== 'production')) {
+            // add getters for devtools
+            if (isComputed(prop)) {
+                _hmrPayload.getters[key] = isOptionsStore
+                    ? // @ts-expect-error
+                        options.getters[key]
+                    : prop;
+                if (IS_CLIENT) {
+                    const getters = setupStore._getters ||
+                        // @ts-expect-error: same
+                        (setupStore._getters = markRaw([]));
+                    getters.push(key);
+                }
+            }
+        }
+    }
+    // add the state, getters, and action properties
+    /* istanbul ignore if */
+    if (isVue2) {
+        Object.keys(setupStore).forEach((key) => {
+            set(store, key, setupStore[key]);
+        });
+    }
+    else {
+        assign(store, setupStore);
+        // allows retrieving reactive objects with `storeToRefs()`. Must be called after assigning to the reactive object.
+        // Make `storeToRefs()` work with `reactive()` #799
+        assign(toRaw(store), setupStore);
+    }
+    // use this instead of a computed with setter to be able to create it anywhere
+    // without linking the computed lifespan to wherever the store is first
+    // created.
+    Object.defineProperty(store, '$state', {
+        get: () => ((process.env.NODE_ENV !== 'production') && hot ? hotState.value : pinia.state.value[$id]),
+        set: (state) => {
+            /* istanbul ignore if */
+            if ((process.env.NODE_ENV !== 'production') && hot) {
+                throw new Error('cannot set hotState');
+            }
+            $patch(($state) => {
+                assign($state, state);
+            });
+        },
+    });
+    // add the hotUpdate before plugins to allow them to override it
+    /* istanbul ignore else */
+    if ((process.env.NODE_ENV !== 'production')) {
+        store._hotUpdate = markRaw((newStore) => {
+            store._hotUpdating = true;
+            newStore._hmrPayload.state.forEach((stateKey) => {
+                if (stateKey in store.$state) {
+                    const newStateTarget = newStore.$state[stateKey];
+                    const oldStateSource = store.$state[stateKey];
+                    if (typeof newStateTarget === 'object' &&
+                        isPlainObject(newStateTarget) &&
+                        isPlainObject(oldStateSource)) {
+                        patchObject(newStateTarget, oldStateSource);
+                    }
+                    else {
+                        // transfer the ref
+                        newStore.$state[stateKey] = oldStateSource;
+                    }
+                }
+                // patch direct access properties to allow store.stateProperty to work as
+                // store.$state.stateProperty
+                set(store, stateKey, toRef(newStore.$state, stateKey));
+            });
+            // remove deleted state properties
+            Object.keys(store.$state).forEach((stateKey) => {
+                if (!(stateKey in newStore.$state)) {
+                    del(store, stateKey);
+                }
+            });
+            // avoid devtools logging this as a mutation
+            isListening = false;
+            isSyncListening = false;
+            pinia.state.value[$id] = toRef(newStore._hmrPayload, 'hotState');
+            isSyncListening = true;
+            nextTick().then(() => {
+                isListening = true;
+            });
+            for (const actionName in newStore._hmrPayload.actions) {
+                const action = newStore[actionName];
+                set(store, actionName, wrapAction(actionName, action));
+            }
+            // TODO: does this work in both setup and option store?
+            for (const getterName in newStore._hmrPayload.getters) {
+                const getter = newStore._hmrPayload.getters[getterName];
+                const getterValue = isOptionsStore
+                    ? // special handling of options api
+                        computed(() => {
+                            setActivePinia(pinia);
+                            return getter.call(store, store);
+                        })
+                    : getter;
+                set(store, getterName, getterValue);
+            }
+            // remove deleted getters
+            Object.keys(store._hmrPayload.getters).forEach((key) => {
+                if (!(key in newStore._hmrPayload.getters)) {
+                    del(store, key);
+                }
+            });
+            // remove old actions
+            Object.keys(store._hmrPayload.actions).forEach((key) => {
+                if (!(key in newStore._hmrPayload.actions)) {
+                    del(store, key);
+                }
+            });
+            // update the values used in devtools and to allow deleting new properties later on
+            store._hmrPayload = newStore._hmrPayload;
+            store._getters = newStore._getters;
+            store._hotUpdating = false;
+        });
+    }
+    if (USE_DEVTOOLS) {
+        const nonEnumerable = {
+            writable: true,
+            configurable: true,
+            // avoid warning on devtools trying to display this property
+            enumerable: false,
+        };
+        ['_p', '_hmrPayload', '_getters', '_customProperties'].forEach((p) => {
+            Object.defineProperty(store, p, assign({ value: store[p] }, nonEnumerable));
+        });
+    }
+    /* istanbul ignore if */
+    if (isVue2) {
+        // mark the store as ready before plugins
+        store._r = true;
+    }
+    // apply all plugins
+    pinia._p.forEach((extender) => {
+        /* istanbul ignore else */
+        if (USE_DEVTOOLS) {
+            const extensions = scope.run(() => extender({
+                store,
+                app: pinia._a,
+                pinia,
+                options: optionsForPlugin,
+            }));
+            Object.keys(extensions || {}).forEach((key) => store._customProperties.add(key));
+            assign(store, extensions);
+        }
+        else {
+            assign(store, scope.run(() => extender({
+                store,
+                app: pinia._a,
+                pinia,
+                options: optionsForPlugin,
+            })));
+        }
+    });
+    if ((process.env.NODE_ENV !== 'production') &&
+        store.$state &&
+        typeof store.$state === 'object' &&
+        typeof store.$state.constructor === 'function' &&
+        !store.$state.constructor.toString().includes('[native code]')) {
+        console.warn(`[�]: The "state" must be a plain object. It cannot be\n` +
+            `\tstate: () => new MyClass()\n` +
+            `Found in store "${store.$id}".`);
+    }
+    // only apply hydrate to option stores with an initial state in pinia
+    if (initialState &&
+        isOptionsStore &&
+        options.hydrate) {
+        options.hydrate(store.$state, initialState);
+    }
+    isListening = true;
+    isSyncListening = true;
+    return store;
+}
+function defineStore(
+// TODO: add proper types from above
+idOrOptions, setup, setupOptions) {
+    let id;
+    let options;
+    const isSetupStore = typeof setup === 'function';
+    if (typeof idOrOptions === 'string') {
+        id = idOrOptions;
+        // the option store setup will contain the actual options in this case
+        options = isSetupStore ? setupOptions : setup;
+    }
+    else {
+        options = idOrOptions;
+        id = idOrOptions.id;
+        if ((process.env.NODE_ENV !== 'production') && typeof id !== 'string') {
+            throw new Error(`[�]: "defineStore()" must be passed a store id as its first argument.`);
+        }
+    }
+    function useStore(pinia, hot) {
+        const hasContext = hasInjectionContext();
+        pinia =
+            // in test mode, ignore the argument provided as we can always retrieve a
+            // pinia instance with getActivePinia()
+            ((process.env.NODE_ENV === 'test') && activePinia && activePinia._testing ? null : pinia) ||
+                (hasContext ? inject(piniaSymbol, null) : null);
+        if (pinia)
+            setActivePinia(pinia);
+        if ((process.env.NODE_ENV !== 'production') && !activePinia) {
+            throw new Error(`[�]: "getActivePinia()" was called but there was no active Pinia. Did you forget to install pinia?\n` +
+                `\tconst pinia = createPinia()\n` +
+                `\tapp.use(pinia)\n` +
+                `This will fail in production.`);
+        }
+        pinia = activePinia;
+        if (!pinia._s.has(id)) {
+            // creating the store registers it in `pinia._s`
+            if (isSetupStore) {
+                createSetupStore(id, setup, options, pinia);
+            }
+            else {
+                createOptionsStore(id, options, pinia);
+            }
+            /* istanbul ignore else */
+            if ((process.env.NODE_ENV !== 'production')) {
+                // @ts-expect-error: not the right inferred type
+                useStore._pinia = pinia;
+            }
+        }
+        const store = pinia._s.get(id);
+        if ((process.env.NODE_ENV !== 'production') && hot) {
+            const hotId = '__hot:' + id;
+            const newStore = isSetupStore
+                ? createSetupStore(hotId, setup, options, pinia, true)
+                : createOptionsStore(hotId, assign({}, options), pinia, true);
+            hot._hotUpdate(newStore);
+            // cleanup the state properties and the store from the cache
+            delete pinia.state.value[hotId];
+            pinia._s.delete(hotId);
+        }
+        if ((process.env.NODE_ENV !== 'production') && IS_CLIENT) {
+            const currentInstance = getCurrentInstance();
+            // save stores in instances to access them devtools
+            if (currentInstance &&
+                currentInstance.proxy &&
+                // avoid adding stores that are just built for hot module replacement
+                !hot) {
+                const vm = currentInstance.proxy;
+                const cache = '_pStores' in vm ? vm._pStores : (vm._pStores = {});
+                cache[id] = store;
+            }
+        }
+        // StoreGeneric cannot be casted towards Store
+        return store;
+    }
+    useStore.$id = id;
+    return useStore;
+}
+
+let mapStoreSuffix = 'Store';
+/**
+ * Changes the suffix added by `mapStores()`. Can be set to an empty string.
+ * Defaults to `"Store"`. Make sure to extend the MapStoresCustomization
+ * interface if you are using TypeScript.
+ *
+ * @param suffix - new suffix
+ */
+function setMapStoreSuffix(suffix // could be 'Store' but that would be annoying for JS
+) {
+    mapStoreSuffix = suffix;
+}
+/**
+ * Allows using stores without the composition API (`setup()`) by generating an
+ * object to be spread in the `computed` field of a component. It accepts a list
+ * of store definitions.
+ *
+ * @example
+ * ```js
+ * export default {
+ *   computed: {
+ *     // other computed properties
+ *     ...mapStores(useUserStore, useCartStore)
+ *   },
+ *
+ *   created() {
+ *     this.userStore // store with id "user"
+ *     this.cartStore // store with id "cart"
+ *   }
+ * }
+ * ```
+ *
+ * @param stores - list of stores to map to an object
+ */
+function mapStores(...stores) {
+    if ((process.env.NODE_ENV !== 'production') && Array.isArray(stores[0])) {
+        console.warn(`[�]: Directly pass all stores to "mapStores()" without putting them in an array:\n` +
+            `Replace\n` +
+            `\tmapStores([useAuthStore, useCartStore])\n` +
+            `with\n` +
+            `\tmapStores(useAuthStore, useCartStore)\n` +
+            `This will fail in production if not fixed.`);
+        stores = stores[0];
+    }
+    return stores.reduce((reduced, useStore) => {
+        // @ts-expect-error: $id is added by defineStore
+        reduced[useStore.$id + mapStoreSuffix] = function () {
+            return useStore(this.$pinia);
+        };
+        return reduced;
+    }, {});
+}
+/**
+ * Allows using state and getters from one store without using the composition
+ * API (`setup()`) by generating an object to be spread in the `computed` field
+ * of a component.
+ *
+ * @param useStore - store to map from
+ * @param keysOrMapper - array or object
+ */
+function mapState(useStore, keysOrMapper) {
+    return Array.isArray(keysOrMapper)
+        ? keysOrMapper.reduce((reduced, key) => {
+            reduced[key] = function () {
+                return useStore(this.$pinia)[key];
+            };
+            return reduced;
+        }, {})
+        : Object.keys(keysOrMapper).reduce((reduced, key) => {
+            // @ts-expect-error
+            reduced[key] = function () {
+                const store = useStore(this.$pinia);
+                const storeKey = keysOrMapper[key];
+                // for some reason TS is unable to infer the type of storeKey to be a
+                // function
+                return typeof storeKey === 'function'
+                    ? storeKey.call(this, store)
+                    : store[storeKey];
+            };
+            return reduced;
+        }, {});
+}
+/**
+ * Alias for `mapState()`. You should use `mapState()` instead.
+ * @deprecated use `mapState()` instead.
+ */
+const mapGetters = mapState;
+/**
+ * Allows directly using actions from your store without using the composition
+ * API (`setup()`) by generating an object to be spread in the `methods` field
+ * of a component.
+ *
+ * @param useStore - store to map from
+ * @param keysOrMapper - array or object
+ */
+function mapActions(useStore, keysOrMapper) {
+    return Array.isArray(keysOrMapper)
+        ? keysOrMapper.reduce((reduced, key) => {
+            // @ts-expect-error
+            reduced[key] = function (...args) {
+                return useStore(this.$pinia)[key](...args);
+            };
+            return reduced;
+        }, {})
+        : Object.keys(keysOrMapper).reduce((reduced, key) => {
+            // @ts-expect-error
+            reduced[key] = function (...args) {
+                return useStore(this.$pinia)[keysOrMapper[key]](...args);
+            };
+            return reduced;
+        }, {});
+}
+/**
+ * Allows using state and getters from one store without using the composition
+ * API (`setup()`) by generating an object to be spread in the `computed` field
+ * of a component.
+ *
+ * @param useStore - store to map from
+ * @param keysOrMapper - array or object
+ */
+function mapWritableState(useStore, keysOrMapper) {
+    return Array.isArray(keysOrMapper)
+        ? keysOrMapper.reduce((reduced, key) => {
+            // @ts-ignore
+            reduced[key] = {
+                get() {
+                    return useStore(this.$pinia)[key];
+                },
+                set(value) {
+                    // it's easier to type it here as any
+                    return (useStore(this.$pinia)[key] = value);
+                },
+            };
+            return reduced;
+        }, {})
+        : Object.keys(keysOrMapper).reduce((reduced, key) => {
+            // @ts-ignore
+            reduced[key] = {
+                get() {
+                    return useStore(this.$pinia)[keysOrMapper[key]];
+                },
+                set(value) {
+                    // it's easier to type it here as any
+                    return (useStore(this.$pinia)[keysOrMapper[key]] = value);
+                },
+            };
+            return reduced;
+        }, {});
+}
+
+/**
+ * Creates an object of references with all the state, getters, and plugin-added
+ * state properties of the store. Similar to `toRefs()` but specifically
+ * designed for Pinia stores so methods and non reactive properties are
+ * completely ignored.
+ *
+ * @param store - store to extract the refs from
+ */
+function storeToRefs(store) {
+    // See https://github.com/vuejs/pinia/issues/852
+    // It's easier to just use toRefs() even if it includes more stuff
+    if (isVue2) {
+        // @ts-expect-error: toRefs include methods and others
+        return toRefs(store);
+    }
+    else {
+        store = toRaw(store);
+        const refs = {};
+        for (const key in store) {
+            const value = store[key];
+            if (isRef(value) || isReactive(value)) {
+                // @ts-expect-error: the key is state or getter
+                refs[key] =
+                    // ---
+                    toRef(store, key);
+            }
+        }
+        return refs;
+    }
+}
+
+/**
+ * Vue 2 Plugin that must be installed for pinia to work. Note **you don't need
+ * this plugin if you are using Nuxt.js**. Use the `buildModule` instead:
+ * https://pinia.vuejs.org/ssr/nuxt.html.
+ *
+ * @example
+ * ```js
+ * import Vue from 'vue'
+ * import { PiniaVuePlugin, createPinia } from 'pinia'
+ *
+ * Vue.use(PiniaVuePlugin)
+ * const pinia = createPinia()
+ *
+ * new Vue({
+ *   el: '#app',
+ *   // ...
+ *   pinia,
+ * })
+ * ```
+ *
+ * @param _Vue - `Vue` imported from 'vue'.
+ */
+const PiniaVuePlugin = function (_Vue) {
+    // Equivalent of
+    // app.config.globalProperties.$pinia = pinia
+    _Vue.mixin({
+        beforeCreate() {
+            const options = this.$options;
+            if (options.pinia) {
+                const pinia = options.pinia;
+                // HACK: taken from provide(): https://github.com/vuejs/composition-api/blob/main/src/apis/inject.ts#L31
+                /* istanbul ignore else */
+                if (!this._provided) {
+                    const provideCache = {};
+                    Object.defineProperty(this, '_provided', {
+                        get: () => provideCache,
+                        set: (v) => Object.assign(provideCache, v),
+                    });
+                }
+                this._provided[piniaSymbol] = pinia;
+                // propagate the pinia instance in an SSR friendly way
+                // avoid adding it to nuxt twice
+                /* istanbul ignore else */
+                if (!this.$pinia) {
+                    this.$pinia = pinia;
+                }
+                pinia._a = this;
+                if (IS_CLIENT) {
+                    // this allows calling useStore() outside of a component setup after
+                    // installing pinia's plugin
+                    setActivePinia(pinia);
+                }
+                if (USE_DEVTOOLS) {
+                    registerPiniaDevtools(pinia._a, pinia);
+                }
+            }
+            else if (!this.$pinia && options.parent && options.parent.$pinia) {
+                this.$pinia = options.parent.$pinia;
+            }
+        },
+        destroyed() {
+            delete this._pStores;
+        },
+    });
+};
+
+export { MutationType, PiniaVuePlugin, acceptHMRUpdate, createPinia, defineStore, getActivePinia, mapActions, mapGetters, mapState, mapStores, mapWritableState, setActivePinia, setMapStoreSuffix, skipHydrate, storeToRefs };
diff --git a/parent_dir/node_modules/pinia/node_modules/vue-demi/lib/index.mjs b/parent_dir/node_modules/pinia/node_modules/vue-demi/lib/index.mjs
new file mode 100644
index 0000000..be3a96d
--- /dev/null
+++ b/parent_dir/node_modules/pinia/node_modules/vue-demi/lib/index.mjs
@@ -0,0 +1,34 @@
+import * as Vue from 'vue'
+
+var isVue2 = false
+var isVue3 = true
+var Vue2 = undefined
+
+function install() {}
+
+export function set(target, key, val) {
+  if (Array.isArray(target)) {
+    target.length = Math.max(target.length, key)
+    target.splice(key, 1, val)
+    return val
+  }
+  target[key] = val
+  return val
+}
+
+export function del(target, key) {
+  if (Array.isArray(target)) {
+    target.splice(key, 1)
+    return
+  }
+  delete target[key]
+}
+
+export * from 'vue'
+export {
+  Vue,
+  Vue2,
+  isVue2,
+  isVue3,
+  install,
+}
diff --git a/parent_dir/node_modules/process/browser.js b/parent_dir/node_modules/process/browser.js
new file mode 100644
index 0000000..d059362
--- /dev/null
+++ b/parent_dir/node_modules/process/browser.js
@@ -0,0 +1,184 @@
+// shim for using process in browser
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
+// don't break things.  But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals.  It's inside a
+// function because try/catches deoptimize in certain engines.
+
+var cachedSetTimeout;
+var cachedClearTimeout;
+
+function defaultSetTimout() {
+    throw new Error('setTimeout has not been defined');
+}
+function defaultClearTimeout () {
+    throw new Error('clearTimeout has not been defined');
+}
+(function () {
+    try {
+        if (typeof setTimeout === 'function') {
+            cachedSetTimeout = setTimeout;
+        } else {
+            cachedSetTimeout = defaultSetTimout;
+        }
+    } catch (e) {
+        cachedSetTimeout = defaultSetTimout;
+    }
+    try {
+        if (typeof clearTimeout === 'function') {
+            cachedClearTimeout = clearTimeout;
+        } else {
+            cachedClearTimeout = defaultClearTimeout;
+        }
+    } catch (e) {
+        cachedClearTimeout = defaultClearTimeout;
+    }
+} ())
+function runTimeout(fun) {
+    if (cachedSetTimeout === setTimeout) {
+        //normal enviroments in sane situations
+        return setTimeout(fun, 0);
+    }
+    // if setTimeout wasn't available but was latter defined
+    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+        cachedSetTimeout = setTimeout;
+        return setTimeout(fun, 0);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedSetTimeout(fun, 0);
+    } catch(e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+            return cachedSetTimeout.call(null, fun, 0);
+        } catch(e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+            return cachedSetTimeout.call(this, fun, 0);
+        }
+    }
+
+
+}
+function runClearTimeout(marker) {
+    if (cachedClearTimeout === clearTimeout) {
+        //normal enviroments in sane situations
+        return clearTimeout(marker);
+    }
+    // if clearTimeout wasn't available but was latter defined
+    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+        cachedClearTimeout = clearTimeout;
+        return clearTimeout(marker);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedClearTimeout(marker);
+    } catch (e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+            return cachedClearTimeout.call(null, marker);
+        } catch (e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+            return cachedClearTimeout.call(this, marker);
+        }
+    }
+
+
+
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+    if (!draining || !currentQueue) {
+        return;
+    }
+    draining = false;
+    if (currentQueue.length) {
+        queue = currentQueue.concat(queue);
+    } else {
+        queueIndex = -1;
+    }
+    if (queue.length) {
+        drainQueue();
+    }
+}
+
+function drainQueue() {
+    if (draining) {
+        return;
+    }
+    var timeout = runTimeout(cleanUpNextTick);
+    draining = true;
+
+    var len = queue.length;
+    while(len) {
+        currentQueue = queue;
+        queue = [];
+        while (++queueIndex < len) {
+            if (currentQueue) {
+                currentQueue[queueIndex].run();
+            }
+        }
+        queueIndex = -1;
+        len = queue.length;
+    }
+    currentQueue = null;
+    draining = false;
+    runClearTimeout(timeout);
+}
+
+process.nextTick = function (fun) {
+    var args = new Array(arguments.length - 1);
+    if (arguments.length > 1) {
+        for (var i = 1; i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+        }
+    }
+    queue.push(new Item(fun, args));
+    if (queue.length === 1 && !draining) {
+        runTimeout(drainQueue);
+    }
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+    this.fun = fun;
+    this.array = array;
+}
+Item.prototype.run = function () {
+    this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+process.prependListener = noop;
+process.prependOnceListener = noop;
+
+process.listeners = function (name) { return [] }
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+};
+
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };
diff --git a/parent_dir/node_modules/sentry/browser/esm/client.js b/parent_dir/node_modules/sentry/browser/esm/client.js
new file mode 100644
index 0000000..f7f1bf4
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/client.js
@@ -0,0 +1,118 @@
+import { BaseClient, SDK_VERSION } from '@sentry/core';
+import { getSDKSource, logger, createClientReportEnvelope, dsnToString } from '@sentry/utils';
+import { eventFromException, eventFromMessage } from './eventbuilder.js';
+import { WINDOW } from './helpers.js';
+import { createUserFeedbackEnvelope } from './userfeedback.js';
+
+/**
+ * Configuration options for the Sentry Browser SDK.
+ * @see @sentry/types Options for more information.
+ */
+
+/**
+ * The Sentry Browser SDK Client.
+ *
+ * @see BrowserOptions for documentation on configuration options.
+ * @see SentryClient for usage documentation.
+ */
+class BrowserClient extends BaseClient {
+  /**
+   * Creates a new Browser SDK instance.
+   *
+   * @param options Configuration options for this SDK.
+   */
+   constructor(options) {
+    const sdkSource = WINDOW.SENTRY_SDK_SOURCE || getSDKSource();
+
+    options._metadata = options._metadata || {};
+    options._metadata.sdk = options._metadata.sdk || {
+      name: 'sentry.javascript.browser',
+      packages: [
+        {
+          name: `${sdkSource}:@sentry/browser`,
+          version: SDK_VERSION,
+        },
+      ],
+      version: SDK_VERSION,
+    };
+
+    super(options);
+
+    if (options.sendClientReports && WINDOW.document) {
+      WINDOW.document.addEventListener('visibilitychange', () => {
+        if (WINDOW.document.visibilityState === 'hidden') {
+          this._flushOutcomes();
+        }
+      });
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+   eventFromException(exception, hint) {
+    return eventFromException(this._options.stackParser, exception, hint, this._options.attachStacktrace);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   eventFromMessage(
+    message,
+    // eslint-disable-next-line deprecation/deprecation
+    level = 'info',
+    hint,
+  ) {
+    return eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);
+  }
+
+  /**
+   * Sends user feedback to Sentry.
+   */
+   captureUserFeedback(feedback) {
+    if (!this._isEnabled()) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('SDK not enabled, will not capture user feedback.');
+      return;
+    }
+
+    const envelope = createUserFeedbackEnvelope(feedback, {
+      metadata: this.getSdkMetadata(),
+      dsn: this.getDsn(),
+      tunnel: this.getOptions().tunnel,
+    });
+    void this._sendEnvelope(envelope);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   _prepareEvent(event, hint, scope) {
+    event.platform = event.platform || 'javascript';
+    return super._prepareEvent(event, hint, scope);
+  }
+
+  /**
+   * Sends client reports as an envelope.
+   */
+   _flushOutcomes() {
+    const outcomes = this._clearOutcomes();
+
+    if (outcomes.length === 0) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('No outcomes to send');
+      return;
+    }
+
+    if (!this._dsn) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('No dsn provided, will not send outcomes');
+      return;
+    }
+
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('Sending outcomes:', outcomes);
+
+    const envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));
+    void this._sendEnvelope(envelope);
+  }
+}
+
+export { BrowserClient };
+//# sourceMappingURL=client.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/eventbuilder.js b/parent_dir/node_modules/sentry/browser/esm/eventbuilder.js
new file mode 100644
index 0000000..08e5653
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/eventbuilder.js
@@ -0,0 +1,304 @@
+import { getCurrentHub } from '@sentry/core';
+import { addExceptionMechanism, resolvedSyncPromise, isErrorEvent, isDOMError, isDOMException, addExceptionTypeValue, isError, isPlainObject, isEvent, normalizeToSize, extractExceptionKeysForMessage } from '@sentry/utils';
+
+/**
+ * This function creates an exception from a JavaScript Error
+ */
+function exceptionFromError(stackParser, ex) {
+  // Get the frames first since Opera can lose the stack if we touch anything else first
+  const frames = parseStackFrames(stackParser, ex);
+
+  const exception = {
+    type: ex && ex.name,
+    value: extractMessage(ex),
+  };
+
+  if (frames.length) {
+    exception.stacktrace = { frames };
+  }
+
+  if (exception.type === undefined && exception.value === '') {
+    exception.value = 'Unrecoverable error caught';
+  }
+
+  return exception;
+}
+
+/**
+ * @hidden
+ */
+function eventFromPlainObject(
+  stackParser,
+  exception,
+  syntheticException,
+  isUnhandledRejection,
+) {
+  const hub = getCurrentHub();
+  const client = hub.getClient();
+  const normalizeDepth = client && client.getOptions().normalizeDepth;
+
+  const event = {
+    exception: {
+      values: [
+        {
+          type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',
+          value: getNonErrorObjectExceptionValue(exception, { isUnhandledRejection }),
+        },
+      ],
+    },
+    extra: {
+      __serialized__: normalizeToSize(exception, normalizeDepth),
+    },
+  };
+
+  if (syntheticException) {
+    const frames = parseStackFrames(stackParser, syntheticException);
+    if (frames.length) {
+      // event.exception.values[0] has been set above
+      (event.exception ).values[0].stacktrace = { frames };
+    }
+  }
+
+  return event;
+}
+
+/**
+ * @hidden
+ */
+function eventFromError(stackParser, ex) {
+  return {
+    exception: {
+      values: [exceptionFromError(stackParser, ex)],
+    },
+  };
+}
+
+/** Parses stack frames from an error */
+function parseStackFrames(
+  stackParser,
+  ex,
+) {
+  // Access and store the stacktrace property before doing ANYTHING
+  // else to it because Opera is not very good at providing it
+  // reliably in other circumstances.
+  const stacktrace = ex.stacktrace || ex.stack || '';
+
+  const popSize = getPopSize(ex);
+
+  try {
+    return stackParser(stacktrace, popSize);
+  } catch (e) {
+    // no-empty
+  }
+
+  return [];
+}
+
+// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108
+const reactMinifiedRegexp = /Minified React error #\d+;/i;
+
+function getPopSize(ex) {
+  if (ex) {
+    if (typeof ex.framesToPop === 'number') {
+      return ex.framesToPop;
+    }
+
+    if (reactMinifiedRegexp.test(ex.message)) {
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+/**
+ * There are cases where stacktrace.message is an Event object
+ * https://github.com/getsentry/sentry-javascript/issues/1949
+ * In this specific case we try to extract stacktrace.message.error.message
+ */
+function extractMessage(ex) {
+  const message = ex && ex.message;
+  if (!message) {
+    return 'No error message';
+  }
+  if (message.error && typeof message.error.message === 'string') {
+    return message.error.message;
+  }
+  return message;
+}
+
+/**
+ * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.
+ * @hidden
+ */
+function eventFromException(
+  stackParser,
+  exception,
+  hint,
+  attachStacktrace,
+) {
+  const syntheticException = (hint && hint.syntheticException) || undefined;
+  const event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);
+  addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }
+  event.level = 'error';
+  if (hint && hint.event_id) {
+    event.event_id = hint.event_id;
+  }
+  return resolvedSyncPromise(event);
+}
+
+/**
+ * Builds and Event from a Message
+ * @hidden
+ */
+function eventFromMessage(
+  stackParser,
+  message,
+  // eslint-disable-next-line deprecation/deprecation
+  level = 'info',
+  hint,
+  attachStacktrace,
+) {
+  const syntheticException = (hint && hint.syntheticException) || undefined;
+  const event = eventFromString(stackParser, message, syntheticException, attachStacktrace);
+  event.level = level;
+  if (hint && hint.event_id) {
+    event.event_id = hint.event_id;
+  }
+  return resolvedSyncPromise(event);
+}
+
+/**
+ * @hidden
+ */
+function eventFromUnknownInput(
+  stackParser,
+  exception,
+  syntheticException,
+  attachStacktrace,
+  isUnhandledRejection,
+) {
+  let event;
+
+  if (isErrorEvent(exception ) && (exception ).error) {
+    // If it is an ErrorEvent with `error` property, extract it to get actual Error
+    const errorEvent = exception ;
+    return eventFromError(stackParser, errorEvent.error );
+  }
+
+  // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name
+  // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be
+  // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.
+  //
+  // https://developer.mozilla.org/en-US/docs/Web/API/DOMError
+  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException
+  // https://webidl.spec.whatwg.org/#es-DOMException-specialness
+  if (isDOMError(exception) || isDOMException(exception )) {
+    const domException = exception ;
+
+    if ('stack' in (exception )) {
+      event = eventFromError(stackParser, exception );
+    } else {
+      const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');
+      const message = domException.message ? `${name}: ${domException.message}` : name;
+      event = eventFromString(stackParser, message, syntheticException, attachStacktrace);
+      addExceptionTypeValue(event, message);
+    }
+    if ('code' in domException) {
+      // eslint-disable-next-line deprecation/deprecation
+      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };
+    }
+
+    return event;
+  }
+  if (isError(exception)) {
+    // we have a real Error object, do nothing
+    return eventFromError(stackParser, exception);
+  }
+  if (isPlainObject(exception) || isEvent(exception)) {
+    // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize
+    // it manually. This will allow us to group events based on top-level keys which is much better than creating a new
+    // group on any key/value change.
+    const objectException = exception ;
+    event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);
+    addExceptionMechanism(event, {
+      synthetic: true,
+    });
+    return event;
+  }
+
+  // If none of previous checks were valid, then it means that it's not:
+  // - an instance of DOMError
+  // - an instance of DOMException
+  // - an instance of Event
+  // - an instance of Error
+  // - a valid ErrorEvent (one with an error property)
+  // - a plain Object
+  //
+  // So bail out and capture it as a simple message:
+  event = eventFromString(stackParser, exception , syntheticException, attachStacktrace);
+  addExceptionTypeValue(event, `${exception}`, undefined);
+  addExceptionMechanism(event, {
+    synthetic: true,
+  });
+
+  return event;
+}
+
+/**
+ * @hidden
+ */
+function eventFromString(
+  stackParser,
+  input,
+  syntheticException,
+  attachStacktrace,
+) {
+  const event = {
+    message: input,
+  };
+
+  if (attachStacktrace && syntheticException) {
+    const frames = parseStackFrames(stackParser, syntheticException);
+    if (frames.length) {
+      event.exception = {
+        values: [{ value: input, stacktrace: { frames } }],
+      };
+    }
+  }
+
+  return event;
+}
+
+function getNonErrorObjectExceptionValue(
+  exception,
+  { isUnhandledRejection },
+) {
+  const keys = extractExceptionKeysForMessage(exception);
+  const captureType = isUnhandledRejection ? 'promise rejection' : 'exception';
+
+  // Some ErrorEvent instances do not have an `error` property, which is why they are not handled before
+  // We still want to try to get a decent message for these cases
+  if (isErrorEvent(exception)) {
+    return `Event \`ErrorEvent\` captured as ${captureType} with message \`${exception.message}\``;
+  }
+
+  if (isEvent(exception)) {
+    const className = getObjectClassName(exception);
+    return `Event \`${className}\` (type=${exception.type}) captured as ${captureType}`;
+  }
+
+  return `Object captured as ${captureType} with keys: ${keys}`;
+}
+
+function getObjectClassName(obj) {
+  try {
+    const prototype = Object.getPrototypeOf(obj);
+    return prototype ? prototype.constructor.name : undefined;
+  } catch (e) {
+    // ignore errors here
+  }
+}
+
+export { eventFromError, eventFromException, eventFromMessage, eventFromPlainObject, eventFromString, eventFromUnknownInput, exceptionFromError, parseStackFrames };
+//# sourceMappingURL=eventbuilder.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/helpers.js b/parent_dir/node_modules/sentry/browser/esm/helpers.js
new file mode 100644
index 0000000..cfa1229
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/helpers.js
@@ -0,0 +1,154 @@
+import { withScope, captureException } from '@sentry/core';
+import { GLOBAL_OBJ, getOriginalFunction, markFunctionWrapped, addNonEnumerableProperty, addExceptionTypeValue, addExceptionMechanism } from '@sentry/utils';
+
+const WINDOW = GLOBAL_OBJ ;
+
+let ignoreOnError = 0;
+
+/**
+ * @hidden
+ */
+function shouldIgnoreOnError() {
+  return ignoreOnError > 0;
+}
+
+/**
+ * @hidden
+ */
+function ignoreNextOnError() {
+  // onerror should trigger before setTimeout
+  ignoreOnError++;
+  setTimeout(() => {
+    ignoreOnError--;
+  });
+}
+
+/**
+ * Instruments the given function and sends an event to Sentry every time the
+ * function throws an exception.
+ *
+ * @param fn A function to wrap. It is generally safe to pass an unbound function, because the returned wrapper always
+ * has a correct `this` context.
+ * @returns The wrapped function.
+ * @hidden
+ */
+function wrap(
+  fn,
+  options
+
+ = {},
+  before,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+  // for future readers what this does is wrap a function and then create
+  // a bi-directional wrapping between them.
+  //
+  // example: wrapped = wrap(original);
+  //  original.__sentry_wrapped__ -> wrapped
+  //  wrapped.__sentry_original__ -> original
+
+  if (typeof fn !== 'function') {
+    return fn;
+  }
+
+  try {
+    // if we're dealing with a function that was previously wrapped, return
+    // the original wrapper.
+    const wrapper = fn.__sentry_wrapped__;
+    if (wrapper) {
+      return wrapper;
+    }
+
+    // We don't wanna wrap it twice
+    if (getOriginalFunction(fn)) {
+      return fn;
+    }
+  } catch (e) {
+    // Just accessing custom props in some Selenium environments
+    // can cause a "Permission denied" exception (see raven-js#495).
+    // Bail on wrapping and return the function as-is (defers to window.onerror).
+    return fn;
+  }
+
+  /* eslint-disable prefer-rest-params */
+  // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`
+  const sentryWrapped = function () {
+    const args = Array.prototype.slice.call(arguments);
+
+    try {
+      if (before && typeof before === 'function') {
+        before.apply(this, arguments);
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+      const wrappedArguments = args.map((arg) => wrap(arg, options));
+
+      // Attempt to invoke user-land function
+      // NOTE: If you are a Sentry user, and you are seeing this stack frame, it
+      //       means the sentry.javascript SDK caught an error invoking your application code. This
+      //       is expected behavior and NOT indicative of a bug with sentry.javascript.
+      return fn.apply(this, wrappedArguments);
+    } catch (ex) {
+      ignoreNextOnError();
+
+      withScope((scope) => {
+        scope.addEventProcessor((event) => {
+          if (options.mechanism) {
+            addExceptionTypeValue(event, undefined, undefined);
+            addExceptionMechanism(event, options.mechanism);
+          }
+
+          event.extra = {
+            ...event.extra,
+            arguments: args,
+          };
+
+          return event;
+        });
+
+        captureException(ex);
+      });
+
+      throw ex;
+    }
+  };
+  /* eslint-enable prefer-rest-params */
+
+  // Accessing some objects may throw
+  // ref: https://github.com/getsentry/sentry-javascript/issues/1168
+  try {
+    for (const property in fn) {
+      if (Object.prototype.hasOwnProperty.call(fn, property)) {
+        sentryWrapped[property] = fn[property];
+      }
+    }
+  } catch (_oO) {} // eslint-disable-line no-empty
+
+  // Signal that this function has been wrapped/filled already
+  // for both debugging and to prevent it to being wrapped/filled twice
+  markFunctionWrapped(sentryWrapped, fn);
+
+  addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);
+
+  // Restore original function name (not all browsers allow that)
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name') ;
+    if (descriptor.configurable) {
+      Object.defineProperty(sentryWrapped, 'name', {
+        get() {
+          return fn.name;
+        },
+      });
+    }
+    // eslint-disable-next-line no-empty
+  } catch (_oO) {}
+
+  return sentryWrapped;
+}
+
+/**
+ * All properties the report dialog supports
+ */
+
+export { WINDOW, ignoreNextOnError, shouldIgnoreOnError, wrap };
+//# sourceMappingURL=helpers.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/index.js b/parent_dir/node_modules/sentry/browser/esm/index.js
new file mode 100644
index 0000000..d6513a6
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/index.js
@@ -0,0 +1,39 @@
+import { Integrations } from '@sentry/core';
+export { FunctionToString, Hub, InboundFilters, ModuleMetadata, SDK_VERSION, Scope, addBreadcrumb, addGlobalEventProcessor, addTracingExtensions, captureEvent, captureException, captureMessage, close, configureScope, createTransport, extractTraceparentData, flush, getActiveSpan, getActiveTransaction, getCurrentHub, getHubFromCarrier, lastEventId, makeMain, makeMultiplexedTransport, setContext, setExtra, setExtras, setMeasurement, setTag, setTags, setUser, spanStatusfromHttpCode, startInactiveSpan, startSpan, startSpanManual, startTransaction, trace, withScope } from '@sentry/core';
+import { WINDOW } from './helpers.js';
+export { WINDOW } from './helpers.js';
+export { BrowserClient } from './client.js';
+export { makeFetchTransport } from './transports/fetch.js';
+export { makeXHRTransport } from './transports/xhr.js';
+export { chromeStackLineParser, defaultStackLineParsers, defaultStackParser, geckoStackLineParser, opera10StackLineParser, opera11StackLineParser, winjsStackLineParser } from './stack-parsers.js';
+export { eventFromException, eventFromMessage, exceptionFromError } from './eventbuilder.js';
+export { createUserFeedbackEnvelope } from './userfeedback.js';
+export { captureUserFeedback, defaultIntegrations, forceLoad, init, onLoad, showReportDialog, wrap } from './sdk.js';
+import * as index from './integrations/index.js';
+export { Replay } from '@sentry/replay';
+export { BrowserTracing, defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from '@sentry-internal/tracing';
+export { makeBrowserOfflineTransport } from './transports/offline.js';
+export { onProfilingStartRouteTransaction } from './profiling/hubextensions.js';
+export { BrowserProfilingIntegration } from './profiling/integration.js';
+export { GlobalHandlers } from './integrations/globalhandlers.js';
+export { TryCatch } from './integrations/trycatch.js';
+export { Breadcrumbs } from './integrations/breadcrumbs.js';
+export { LinkedErrors } from './integrations/linkederrors.js';
+export { HttpContext } from './integrations/httpcontext.js';
+export { Dedupe } from './integrations/dedupe.js';
+
+let windowIntegrations = {};
+
+// This block is needed to add compatibility with the integrations packages when used with a CDN
+if (WINDOW.Sentry && WINDOW.Sentry.Integrations) {
+  windowIntegrations = WINDOW.Sentry.Integrations;
+}
+
+const INTEGRATIONS = {
+  ...windowIntegrations,
+  ...Integrations,
+  ...index,
+};
+
+export { INTEGRATIONS as Integrations };
+//# sourceMappingURL=index.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/integrations/breadcrumbs.js b/parent_dir/node_modules/sentry/browser/esm/integrations/breadcrumbs.js
new file mode 100644
index 0000000..d0e8eea
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/integrations/breadcrumbs.js
@@ -0,0 +1,308 @@
+import { getCurrentHub } from '@sentry/core';
+import { addInstrumentationHandler, getEventDescription, severityLevelFromString, safeJoin, SENTRY_XHR_DATA_KEY, parseUrl, logger, htmlTreeAsString } from '@sentry/utils';
+import { WINDOW } from '../helpers.js';
+
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+
+/** maxStringLength gets capped to prevent 100 breadcrumbs exceeding 1MB event payload size */
+const MAX_ALLOWED_STRING_LENGTH = 1024;
+
+/**
+ * Default Breadcrumbs instrumentations
+ * TODO: Deprecated - with v6, this will be renamed to `Instrument`
+ */
+class Breadcrumbs  {
+  /**
+   * @inheritDoc
+   */
+   static __initStatic() {this.id = 'Breadcrumbs';}
+
+  /**
+   * @inheritDoc
+   */
+
+  /**
+   * Options of the breadcrumbs integration.
+   */
+  // This field is public, because we use it in the browser client to check if the `sentry` option is enabled.
+
+  /**
+   * @inheritDoc
+   */
+   constructor(options) {
+    this.name = Breadcrumbs.id;
+    this.options = {
+      console: true,
+      dom: true,
+      fetch: true,
+      history: true,
+      sentry: true,
+      xhr: true,
+      ...options,
+    };
+  }
+
+  /**
+   * Instrument browser built-ins w/ breadcrumb capturing
+   *  - Console API
+   *  - DOM API (click/typing)
+   *  - XMLHttpRequest API
+   *  - Fetch API
+   *  - History API
+   */
+   setupOnce() {
+    if (this.options.console) {
+      addInstrumentationHandler('console', _consoleBreadcrumb);
+    }
+    if (this.options.dom) {
+      addInstrumentationHandler('dom', _domBreadcrumb(this.options.dom));
+    }
+    if (this.options.xhr) {
+      addInstrumentationHandler('xhr', _xhrBreadcrumb);
+    }
+    if (this.options.fetch) {
+      addInstrumentationHandler('fetch', _fetchBreadcrumb);
+    }
+    if (this.options.history) {
+      addInstrumentationHandler('history', _historyBreadcrumb);
+    }
+    if (this.options.sentry) {
+      const client = getCurrentHub().getClient();
+      client && client.on && client.on('beforeSendEvent', addSentryBreadcrumb);
+    }
+  }
+} Breadcrumbs.__initStatic();
+
+/**
+ * Adds a breadcrumb for Sentry events or transactions if this option is enabled.
+ */
+function addSentryBreadcrumb(event) {
+  getCurrentHub().addBreadcrumb(
+    {
+      category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,
+      event_id: event.event_id,
+      level: event.level,
+      message: getEventDescription(event),
+    },
+    {
+      event,
+    },
+  );
+}
+
+/**
+ * A HOC that creaes a function that creates breadcrumbs from DOM API calls.
+ * This is a HOC so that we get access to dom options in the closure.
+ */
+function _domBreadcrumb(dom) {
+  function _innerDomBreadcrumb(handlerData) {
+    let target;
+    let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;
+
+    let maxStringLength =
+      typeof dom === 'object' && typeof dom.maxStringLength === 'number' ? dom.maxStringLength : undefined;
+    if (maxStringLength && maxStringLength > MAX_ALLOWED_STRING_LENGTH) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        logger.warn(
+          `\`dom.maxStringLength\` cannot exceed ${MAX_ALLOWED_STRING_LENGTH}, but a value of ${maxStringLength} was configured. Sentry will use ${MAX_ALLOWED_STRING_LENGTH} instead.`,
+        );
+      maxStringLength = MAX_ALLOWED_STRING_LENGTH;
+    }
+
+    if (typeof keyAttrs === 'string') {
+      keyAttrs = [keyAttrs];
+    }
+
+    // Accessing event.target can throw (see getsentry/raven-js#838, #768)
+    try {
+      const event = handlerData.event ;
+      target = _isEvent(event)
+        ? htmlTreeAsString(event.target, { keyAttrs, maxStringLength })
+        : htmlTreeAsString(event, { keyAttrs, maxStringLength });
+    } catch (e) {
+      target = '<unknown>';
+    }
+
+    if (target.length === 0) {
+      return;
+    }
+
+    getCurrentHub().addBreadcrumb(
+      {
+        category: `ui.${handlerData.name}`,
+        message: target,
+      },
+      {
+        event: handlerData.event,
+        name: handlerData.name,
+        global: handlerData.global,
+      },
+    );
+  }
+
+  return _innerDomBreadcrumb;
+}
+
+/**
+ * Creates breadcrumbs from console API calls
+ */
+function _consoleBreadcrumb(handlerData) {
+  const breadcrumb = {
+    category: 'console',
+    data: {
+      arguments: handlerData.args,
+      logger: 'console',
+    },
+    level: severityLevelFromString(handlerData.level),
+    message: safeJoin(handlerData.args, ' '),
+  };
+
+  if (handlerData.level === 'assert') {
+    if (handlerData.args[0] === false) {
+      breadcrumb.message = `Assertion failed: ${safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;
+      breadcrumb.data.arguments = handlerData.args.slice(1);
+    } else {
+      // Don't capture a breadcrumb for passed assertions
+      return;
+    }
+  }
+
+  getCurrentHub().addBreadcrumb(breadcrumb, {
+    input: handlerData.args,
+    level: handlerData.level,
+  });
+}
+
+/**
+ * Creates breadcrumbs from XHR API calls
+ */
+function _xhrBreadcrumb(handlerData) {
+  const { startTimestamp, endTimestamp } = handlerData;
+
+  const sentryXhrData = handlerData.xhr[SENTRY_XHR_DATA_KEY];
+
+  // We only capture complete, non-sentry requests
+  if (!startTimestamp || !endTimestamp || !sentryXhrData) {
+    return;
+  }
+
+  const { method, url, status_code, body } = sentryXhrData;
+
+  const data = {
+    method,
+    url,
+    status_code,
+  };
+
+  const hint = {
+    xhr: handlerData.xhr,
+    input: body,
+    startTimestamp,
+    endTimestamp,
+  };
+
+  getCurrentHub().addBreadcrumb(
+    {
+      category: 'xhr',
+      data,
+      type: 'http',
+    },
+    hint,
+  );
+}
+
+/**
+ * Creates breadcrumbs from fetch API calls
+ */
+function _fetchBreadcrumb(handlerData) {
+  const { startTimestamp, endTimestamp } = handlerData;
+
+  // We only capture complete fetch requests
+  if (!endTimestamp) {
+    return;
+  }
+
+  if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {
+    // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)
+    return;
+  }
+
+  if (handlerData.error) {
+    const data = handlerData.fetchData;
+    const hint = {
+      data: handlerData.error,
+      input: handlerData.args,
+      startTimestamp,
+      endTimestamp,
+    };
+
+    getCurrentHub().addBreadcrumb(
+      {
+        category: 'fetch',
+        data,
+        level: 'error',
+        type: 'http',
+      },
+      hint,
+    );
+  } else {
+    const data = {
+      ...handlerData.fetchData,
+      status_code: handlerData.response && handlerData.response.status,
+    };
+    const hint = {
+      input: handlerData.args,
+      response: handlerData.response,
+      startTimestamp,
+      endTimestamp,
+    };
+    getCurrentHub().addBreadcrumb(
+      {
+        category: 'fetch',
+        data,
+        type: 'http',
+      },
+      hint,
+    );
+  }
+}
+
+/**
+ * Creates breadcrumbs from history API calls
+ */
+function _historyBreadcrumb(handlerData) {
+  let from = handlerData.from;
+  let to = handlerData.to;
+  const parsedLoc = parseUrl(WINDOW.location.href);
+  let parsedFrom = parseUrl(from);
+  const parsedTo = parseUrl(to);
+
+  // Initial pushState doesn't provide `from` information
+  if (!parsedFrom.path) {
+    parsedFrom = parsedLoc;
+  }
+
+  // Use only the path component of the URL if the URL matches the current
+  // document (almost all the time when using pushState)
+  if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {
+    to = parsedTo.relative;
+  }
+  if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {
+    from = parsedFrom.relative;
+  }
+
+  getCurrentHub().addBreadcrumb({
+    category: 'navigation',
+    data: {
+      from,
+      to,
+    },
+  });
+}
+
+function _isEvent(event) {
+  return !!event && !!(event ).target;
+}
+
+export { Breadcrumbs };
+//# sourceMappingURL=breadcrumbs.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/integrations/dedupe.js b/parent_dir/node_modules/sentry/browser/esm/integrations/dedupe.js
new file mode 100644
index 0000000..606054b
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/integrations/dedupe.js
@@ -0,0 +1,214 @@
+import { logger } from '@sentry/utils';
+
+/** Deduplication filter */
+class Dedupe  {
+  /**
+   * @inheritDoc
+   */
+   static __initStatic() {this.id = 'Dedupe';}
+
+  /**
+   * @inheritDoc
+   */
+
+  /**
+   * @inheritDoc
+   */
+
+   constructor() {
+    this.name = Dedupe.id;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setupOnce(addGlobalEventProcessor, getCurrentHub) {
+    const eventProcessor = currentEvent => {
+      // We want to ignore any non-error type events, e.g. transactions or replays
+      // These should never be deduped, and also not be compared against as _previousEvent.
+      if (currentEvent.type) {
+        return currentEvent;
+      }
+
+      const self = getCurrentHub().getIntegration(Dedupe);
+      if (self) {
+        // Juuust in case something goes wrong
+        try {
+          if (_shouldDropEvent(currentEvent, self._previousEvent)) {
+            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Event dropped due to being a duplicate of previously captured event.');
+            return null;
+          }
+        } catch (_oO) {
+          return (self._previousEvent = currentEvent);
+        }
+
+        return (self._previousEvent = currentEvent);
+      }
+      return currentEvent;
+    };
+
+    eventProcessor.id = this.name;
+    addGlobalEventProcessor(eventProcessor);
+  }
+} Dedupe.__initStatic();
+
+/** JSDoc */
+function _shouldDropEvent(currentEvent, previousEvent) {
+  if (!previousEvent) {
+    return false;
+  }
+
+  if (_isSameMessageEvent(currentEvent, previousEvent)) {
+    return true;
+  }
+
+  if (_isSameExceptionEvent(currentEvent, previousEvent)) {
+    return true;
+  }
+
+  return false;
+}
+
+/** JSDoc */
+function _isSameMessageEvent(currentEvent, previousEvent) {
+  const currentMessage = currentEvent.message;
+  const previousMessage = previousEvent.message;
+
+  // If neither event has a message property, they were both exceptions, so bail out
+  if (!currentMessage && !previousMessage) {
+    return false;
+  }
+
+  // If only one event has a stacktrace, but not the other one, they are not the same
+  if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {
+    return false;
+  }
+
+  if (currentMessage !== previousMessage) {
+    return false;
+  }
+
+  if (!_isSameFingerprint(currentEvent, previousEvent)) {
+    return false;
+  }
+
+  if (!_isSameStacktrace(currentEvent, previousEvent)) {
+    return false;
+  }
+
+  return true;
+}
+
+/** JSDoc */
+function _isSameExceptionEvent(currentEvent, previousEvent) {
+  const previousException = _getExceptionFromEvent(previousEvent);
+  const currentException = _getExceptionFromEvent(currentEvent);
+
+  if (!previousException || !currentException) {
+    return false;
+  }
+
+  if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
+    return false;
+  }
+
+  if (!_isSameFingerprint(currentEvent, previousEvent)) {
+    return false;
+  }
+
+  if (!_isSameStacktrace(currentEvent, previousEvent)) {
+    return false;
+  }
+
+  return true;
+}
+
+/** JSDoc */
+function _isSameStacktrace(currentEvent, previousEvent) {
+  let currentFrames = _getFramesFromEvent(currentEvent);
+  let previousFrames = _getFramesFromEvent(previousEvent);
+
+  // If neither event has a stacktrace, they are assumed to be the same
+  if (!currentFrames && !previousFrames) {
+    return true;
+  }
+
+  // If only one event has a stacktrace, but not the other one, they are not the same
+  if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {
+    return false;
+  }
+
+  currentFrames = currentFrames ;
+  previousFrames = previousFrames ;
+
+  // If number of frames differ, they are not the same
+  if (previousFrames.length !== currentFrames.length) {
+    return false;
+  }
+
+  // Otherwise, compare the two
+  for (let i = 0; i < previousFrames.length; i++) {
+    const frameA = previousFrames[i];
+    const frameB = currentFrames[i];
+
+    if (
+      frameA.filename !== frameB.filename ||
+      frameA.lineno !== frameB.lineno ||
+      frameA.colno !== frameB.colno ||
+      frameA.function !== frameB.function
+    ) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/** JSDoc */
+function _isSameFingerprint(currentEvent, previousEvent) {
+  let currentFingerprint = currentEvent.fingerprint;
+  let previousFingerprint = previousEvent.fingerprint;
+
+  // If neither event has a fingerprint, they are assumed to be the same
+  if (!currentFingerprint && !previousFingerprint) {
+    return true;
+  }
+
+  // If only one event has a fingerprint, but not the other one, they are not the same
+  if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {
+    return false;
+  }
+
+  currentFingerprint = currentFingerprint ;
+  previousFingerprint = previousFingerprint ;
+
+  // Otherwise, compare the two
+  try {
+    return !!(currentFingerprint.join('') === previousFingerprint.join(''));
+  } catch (_oO) {
+    return false;
+  }
+}
+
+/** JSDoc */
+function _getExceptionFromEvent(event) {
+  return event.exception && event.exception.values && event.exception.values[0];
+}
+
+/** JSDoc */
+function _getFramesFromEvent(event) {
+  const exception = event.exception;
+
+  if (exception) {
+    try {
+      // @ts-expect-error Object could be undefined
+      return exception.values[0].stacktrace.frames;
+    } catch (_oO) {
+      return undefined;
+    }
+  }
+  return undefined;
+}
+
+export { Dedupe };
+//# sourceMappingURL=dedupe.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/integrations/globalhandlers.js b/parent_dir/node_modules/sentry/browser/esm/integrations/globalhandlers.js
new file mode 100644
index 0000000..f3f3e56
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/integrations/globalhandlers.js
@@ -0,0 +1,249 @@
+import { getCurrentHub } from '@sentry/core';
+import { addInstrumentationHandler, isString, isPrimitive, isErrorEvent, getLocationHref, logger, addExceptionMechanism } from '@sentry/utils';
+import { eventFromUnknownInput } from '../eventbuilder.js';
+import { shouldIgnoreOnError } from '../helpers.js';
+
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+
+/** Global handlers */
+class GlobalHandlers  {
+  /**
+   * @inheritDoc
+   */
+   static __initStatic() {this.id = 'GlobalHandlers';}
+
+  /**
+   * @inheritDoc
+   */
+
+  /** JSDoc */
+
+  /**
+   * Stores references functions to installing handlers. Will set to undefined
+   * after they have been run so that they are not used twice.
+   */
+
+  /** JSDoc */
+   constructor(options) {
+    this.name = GlobalHandlers.id;
+    this._options = {
+      onerror: true,
+      onunhandledrejection: true,
+      ...options,
+    };
+
+    this._installFunc = {
+      onerror: _installGlobalOnErrorHandler,
+      onunhandledrejection: _installGlobalOnUnhandledRejectionHandler,
+    };
+  }
+  /**
+   * @inheritDoc
+   */
+   setupOnce() {
+    Error.stackTraceLimit = 50;
+    const options = this._options;
+
+    // We can disable guard-for-in as we construct the options object above + do checks against
+    // `this._installFunc` for the property.
+    // eslint-disable-next-line guard-for-in
+    for (const key in options) {
+      const installFunc = this._installFunc[key ];
+      if (installFunc && options[key ]) {
+        globalHandlerLog(key);
+        installFunc();
+        this._installFunc[key ] = undefined;
+      }
+    }
+  }
+} GlobalHandlers.__initStatic();
+
+/** JSDoc */
+function _installGlobalOnErrorHandler() {
+  addInstrumentationHandler(
+    'error',
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (data) => {
+      const [hub, stackParser, attachStacktrace] = getHubAndOptions();
+      if (!hub.getIntegration(GlobalHandlers)) {
+        return;
+      }
+      const { msg, url, line, column, error } = data;
+      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {
+        return;
+      }
+
+      const event =
+        error === undefined && isString(msg)
+          ? _eventFromIncompleteOnError(msg, url, line, column)
+          : _enhanceEventWithInitialFrame(
+              eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false),
+              url,
+              line,
+              column,
+            );
+
+      event.level = 'error';
+
+      addMechanismAndCapture(hub, error, event, 'onerror');
+    },
+  );
+}
+
+/** JSDoc */
+function _installGlobalOnUnhandledRejectionHandler() {
+  addInstrumentationHandler(
+    'unhandledrejection',
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (e) => {
+      const [hub, stackParser, attachStacktrace] = getHubAndOptions();
+      if (!hub.getIntegration(GlobalHandlers)) {
+        return;
+      }
+      let error = e;
+
+      // dig the object of the rejection out of known event types
+      try {
+        // PromiseRejectionEvents store the object of the rejection under 'reason'
+        // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent
+        if ('reason' in e) {
+          error = e.reason;
+        }
+        // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents
+        // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into
+        // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec
+        // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and
+        // https://github.com/getsentry/sentry-javascript/issues/2380
+        else if ('detail' in e && 'reason' in e.detail) {
+          error = e.detail.reason;
+        }
+      } catch (_oO) {
+        // no-empty
+      }
+
+      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {
+        return true;
+      }
+
+      const event = isPrimitive(error)
+        ? _eventFromRejectionWithPrimitive(error)
+        : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);
+
+      event.level = 'error';
+
+      addMechanismAndCapture(hub, error, event, 'onunhandledrejection');
+      return;
+    },
+  );
+}
+
+/**
+ * Create an event from a promise rejection where the `reason` is a primitive.
+ *
+ * @param reason: The `reason` property of the promise rejection
+ * @returns An Event object with an appropriate `exception` value
+ */
+function _eventFromRejectionWithPrimitive(reason) {
+  return {
+    exception: {
+      values: [
+        {
+          type: 'UnhandledRejection',
+          // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)
+          value: `Non-Error promise rejection captured with value: ${String(reason)}`,
+        },
+      ],
+    },
+  };
+}
+
+/**
+ * This function creates a stack from an old, error-less onerror handler.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _eventFromIncompleteOnError(msg, url, line, column) {
+  const ERROR_TYPES_RE =
+    /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;
+
+  // If 'message' is ErrorEvent, get real message from inside
+  let message = isErrorEvent(msg) ? msg.message : msg;
+  let name = 'Error';
+
+  const groups = message.match(ERROR_TYPES_RE);
+  if (groups) {
+    name = groups[1];
+    message = groups[2];
+  }
+
+  const event = {
+    exception: {
+      values: [
+        {
+          type: name,
+          value: message,
+        },
+      ],
+    },
+  };
+
+  return _enhanceEventWithInitialFrame(event, url, line, column);
+}
+
+/** JSDoc */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _enhanceEventWithInitialFrame(event, url, line, column) {
+  // event.exception
+  const e = (event.exception = event.exception || {});
+  // event.exception.values
+  const ev = (e.values = e.values || []);
+  // event.exception.values[0]
+  const ev0 = (ev[0] = ev[0] || {});
+  // event.exception.values[0].stacktrace
+  const ev0s = (ev0.stacktrace = ev0.stacktrace || {});
+  // event.exception.values[0].stacktrace.frames
+  const ev0sf = (ev0s.frames = ev0s.frames || []);
+
+  const colno = isNaN(parseInt(column, 10)) ? undefined : column;
+  const lineno = isNaN(parseInt(line, 10)) ? undefined : line;
+  const filename = isString(url) && url.length > 0 ? url : getLocationHref();
+
+  // event.exception.values[0].stacktrace.frames
+  if (ev0sf.length === 0) {
+    ev0sf.push({
+      colno,
+      filename,
+      function: '?',
+      in_app: true,
+      lineno,
+    });
+  }
+
+  return event;
+}
+
+function globalHandlerLog(type) {
+  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Global Handler attached: ${type}`);
+}
+
+function addMechanismAndCapture(hub, error, event, type) {
+  addExceptionMechanism(event, {
+    handled: false,
+    type,
+  });
+  hub.captureEvent(event, {
+    originalException: error,
+  });
+}
+
+function getHubAndOptions() {
+  const hub = getCurrentHub();
+  const client = hub.getClient();
+  const options = (client && client.getOptions()) || {
+    stackParser: () => [],
+    attachStacktrace: false,
+  };
+  return [hub, options.stackParser, options.attachStacktrace];
+}
+
+export { GlobalHandlers };
+//# sourceMappingURL=globalhandlers.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/integrations/httpcontext.js b/parent_dir/node_modules/sentry/browser/esm/integrations/httpcontext.js
new file mode 100644
index 0000000..5b63f6b
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/integrations/httpcontext.js
@@ -0,0 +1,50 @@
+import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';
+import { WINDOW } from '../helpers.js';
+
+/** HttpContext integration collects information about HTTP request headers */
+class HttpContext  {
+  /**
+   * @inheritDoc
+   */
+   static __initStatic() {this.id = 'HttpContext';}
+
+  /**
+   * @inheritDoc
+   */
+
+   constructor() {
+    this.name = HttpContext.id;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setupOnce() {
+    addGlobalEventProcessor((event) => {
+      if (getCurrentHub().getIntegration(HttpContext)) {
+        // if none of the information we want exists, don't bother
+        if (!WINDOW.navigator && !WINDOW.location && !WINDOW.document) {
+          return event;
+        }
+
+        // grab as much info as exists and add it to the event
+        const url = (event.request && event.request.url) || (WINDOW.location && WINDOW.location.href);
+        const { referrer } = WINDOW.document || {};
+        const { userAgent } = WINDOW.navigator || {};
+
+        const headers = {
+          ...(event.request && event.request.headers),
+          ...(referrer && { Referer: referrer }),
+          ...(userAgent && { 'User-Agent': userAgent }),
+        };
+        const request = { ...event.request, ...(url && { url }), headers };
+
+        return { ...event, request };
+      }
+      return event;
+    });
+  }
+} HttpContext.__initStatic();
+
+export { HttpContext };
+//# sourceMappingURL=httpcontext.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/integrations/linkederrors.js b/parent_dir/node_modules/sentry/browser/esm/integrations/linkederrors.js
new file mode 100644
index 0000000..cc6d54b
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/integrations/linkederrors.js
@@ -0,0 +1,59 @@
+import { applyAggregateErrorsToEvent } from '@sentry/utils';
+import { exceptionFromError } from '../eventbuilder.js';
+
+const DEFAULT_KEY = 'cause';
+const DEFAULT_LIMIT = 5;
+
+/** Adds SDK info to an event. */
+class LinkedErrors  {
+  /**
+   * @inheritDoc
+   */
+   static __initStatic() {this.id = 'LinkedErrors';}
+
+  /**
+   * @inheritDoc
+   */
+
+  /**
+   * @inheritDoc
+   */
+
+  /**
+   * @inheritDoc
+   */
+
+  /**
+   * @inheritDoc
+   */
+   constructor(options = {}) {
+    this.name = LinkedErrors.id;
+    this._key = options.key || DEFAULT_KEY;
+    this._limit = options.limit || DEFAULT_LIMIT;
+  }
+
+  /** @inheritdoc */
+   setupOnce() {
+    // noop
+  }
+
+  /**
+   * @inheritDoc
+   */
+   preprocessEvent(event, hint, client) {
+    const options = client.getOptions();
+
+    applyAggregateErrorsToEvent(
+      exceptionFromError,
+      options.stackParser,
+      options.maxValueLength,
+      this._key,
+      this._limit,
+      event,
+      hint,
+    );
+  }
+} LinkedErrors.__initStatic();
+
+export { LinkedErrors };
+//# sourceMappingURL=linkederrors.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/integrations/trycatch.js b/parent_dir/node_modules/sentry/browser/esm/integrations/trycatch.js
new file mode 100644
index 0000000..7d5fbf4
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/integrations/trycatch.js
@@ -0,0 +1,283 @@
+import { fill, getFunctionName, getOriginalFunction } from '@sentry/utils';
+import { WINDOW, wrap } from '../helpers.js';
+
+const DEFAULT_EVENT_TARGET = [
+  'EventTarget',
+  'Window',
+  'Node',
+  'ApplicationCache',
+  'AudioTrackList',
+  'BroadcastChannel',
+  'ChannelMergerNode',
+  'CryptoOperation',
+  'EventSource',
+  'FileReader',
+  'HTMLUnknownElement',
+  'IDBDatabase',
+  'IDBRequest',
+  'IDBTransaction',
+  'KeyOperation',
+  'MediaController',
+  'MessagePort',
+  'ModalWindow',
+  'Notification',
+  'SVGElementInstance',
+  'Screen',
+  'SharedWorker',
+  'TextTrack',
+  'TextTrackCue',
+  'TextTrackList',
+  'WebSocket',
+  'WebSocketWorker',
+  'Worker',
+  'XMLHttpRequest',
+  'XMLHttpRequestEventTarget',
+  'XMLHttpRequestUpload',
+];
+
+/** Wrap timer functions and event targets to catch errors and provide better meta data */
+class TryCatch  {
+  /**
+   * @inheritDoc
+   */
+   static __initStatic() {this.id = 'TryCatch';}
+
+  /**
+   * @inheritDoc
+   */
+
+  /** JSDoc */
+
+  /**
+   * @inheritDoc
+   */
+   constructor(options) {
+    this.name = TryCatch.id;
+    this._options = {
+      XMLHttpRequest: true,
+      eventTarget: true,
+      requestAnimationFrame: true,
+      setInterval: true,
+      setTimeout: true,
+      ...options,
+    };
+  }
+
+  /**
+   * Wrap timer functions and event targets to catch errors
+   * and provide better metadata.
+   */
+   setupOnce() {
+    if (this._options.setTimeout) {
+      fill(WINDOW, 'setTimeout', _wrapTimeFunction);
+    }
+
+    if (this._options.setInterval) {
+      fill(WINDOW, 'setInterval', _wrapTimeFunction);
+    }
+
+    if (this._options.requestAnimationFrame) {
+      fill(WINDOW, 'requestAnimationFrame', _wrapRAF);
+    }
+
+    if (this._options.XMLHttpRequest && 'XMLHttpRequest' in WINDOW) {
+      fill(XMLHttpRequest.prototype, 'send', _wrapXHR);
+    }
+
+    const eventTargetOption = this._options.eventTarget;
+    if (eventTargetOption) {
+      const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;
+      eventTarget.forEach(_wrapEventTarget);
+    }
+  }
+} TryCatch.__initStatic();
+
+/** JSDoc */
+function _wrapTimeFunction(original) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return function ( ...args) {
+    const originalCallback = args[0];
+    args[0] = wrap(originalCallback, {
+      mechanism: {
+        data: { function: getFunctionName(original) },
+        handled: false,
+        type: 'instrument',
+      },
+    });
+    return original.apply(this, args);
+  };
+}
+
+/** JSDoc */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _wrapRAF(original) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return function ( callback) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    return original.apply(this, [
+      wrap(callback, {
+        mechanism: {
+          data: {
+            function: 'requestAnimationFrame',
+            handler: getFunctionName(original),
+          },
+          handled: false,
+          type: 'instrument',
+        },
+      }),
+    ]);
+  };
+}
+
+/** JSDoc */
+function _wrapXHR(originalSend) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return function ( ...args) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const xhr = this;
+    const xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];
+
+    xmlHttpRequestProps.forEach(prop => {
+      if (prop in xhr && typeof xhr[prop] === 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        fill(xhr, prop, function (original) {
+          const wrapOptions = {
+            mechanism: {
+              data: {
+                function: prop,
+                handler: getFunctionName(original),
+              },
+              handled: false,
+              type: 'instrument',
+            },
+          };
+
+          // If Instrument integration has been called before TryCatch, get the name of original function
+          const originalFunction = getOriginalFunction(original);
+          if (originalFunction) {
+            wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);
+          }
+
+          // Otherwise wrap directly
+          return wrap(original, wrapOptions);
+        });
+      }
+    });
+
+    return originalSend.apply(this, args);
+  };
+}
+
+/** JSDoc */
+function _wrapEventTarget(target) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const globalObject = WINDOW ;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  const proto = globalObject[target] && globalObject[target].prototype;
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins
+  if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {
+    return;
+  }
+
+  fill(proto, 'addEventListener', function (original)
+
+ {
+    return function (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+      eventName,
+      fn,
+      options,
+    ) {
+      try {
+        if (typeof fn.handleEvent === 'function') {
+          // ESlint disable explanation:
+          //  First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would
+          //  introduce a bug here, because bind returns a new function that doesn't have our
+          //  flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.
+          //  Without those flags, every call to addEventListener wraps the function again, causing a memory leak.
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          fn.handleEvent = wrap(fn.handleEvent, {
+            mechanism: {
+              data: {
+                function: 'handleEvent',
+                handler: getFunctionName(fn),
+                target,
+              },
+              handled: false,
+              type: 'instrument',
+            },
+          });
+        }
+      } catch (err) {
+        // can sometimes get 'Permission denied to access property "handle Event'
+      }
+
+      return original.apply(this, [
+        eventName,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        wrap(fn , {
+          mechanism: {
+            data: {
+              function: 'addEventListener',
+              handler: getFunctionName(fn),
+              target,
+            },
+            handled: false,
+            type: 'instrument',
+          },
+        }),
+        options,
+      ]);
+    };
+  });
+
+  fill(
+    proto,
+    'removeEventListener',
+    function (
+      originalRemoveEventListener,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+      return function (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+        eventName,
+        fn,
+        options,
+      ) {
+        /**
+         * There are 2 possible scenarios here:
+         *
+         * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified
+         * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function
+         * as a pass-through, and call original `removeEventListener` with it.
+         *
+         * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using
+         * our wrapped version of `addEventListener`, which internally calls `wrap` helper.
+         * This helper "wraps" whole callback inside a try/catch statement, and attached appropriate metadata to it,
+         * in order for us to make a distinction between wrapped/non-wrapped functions possible.
+         * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.
+         *
+         * When someone adds a handler prior to initialization, and then do it again, but after,
+         * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible
+         * to get rid of the initial handler and it'd stick there forever.
+         */
+        const wrappedEventHandler = fn ;
+        try {
+          const originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;
+          if (originalEventHandler) {
+            originalRemoveEventListener.call(this, eventName, originalEventHandler, options);
+          }
+        } catch (e) {
+          // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments
+        }
+        return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);
+      };
+    },
+  );
+}
+
+export { TryCatch };
+//# sourceMappingURL=trycatch.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/profiling/hubextensions.js b/parent_dir/node_modules/sentry/browser/esm/profiling/hubextensions.js
new file mode 100644
index 0000000..628a2c8
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/profiling/hubextensions.js
@@ -0,0 +1,244 @@
+import { getCurrentHub } from '@sentry/core';
+import { logger, uuid4 } from '@sentry/utils';
+import { WINDOW } from '../helpers.js';
+import { isValidSampleRate, addProfileToMap } from './utils.js';
+
+/* eslint-disable complexity */
+
+const MAX_PROFILE_DURATION_MS = 30000;
+// Keep a flag value to avoid re-initializing the profiler constructor. If it fails
+// once, it will always fail and this allows us to early return.
+let PROFILING_CONSTRUCTOR_FAILED = false;
+
+/**
+ * Check if profiler constructor is available.
+ * @param maybeProfiler
+ */
+function isJSProfilerSupported(maybeProfiler) {
+  return typeof maybeProfiler === 'function';
+}
+
+/**
+ * Safety wrapper for startTransaction for the unlikely case that transaction starts before tracing is imported -
+ * if that happens we want to avoid throwing an error from profiling code.
+ * see https://github.com/getsentry/sentry-javascript/issues/4731.
+ *
+ * @experimental
+ */
+function onProfilingStartRouteTransaction(transaction) {
+  if (!transaction) {
+    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+      logger.log('[Profiling] Transaction is undefined, skipping profiling');
+    }
+    return transaction;
+  }
+
+  return wrapTransactionWithProfiling(transaction);
+}
+
+/**
+ * Wraps startTransaction and stopTransaction with profiling related logic.
+ * startProfiling is called after the call to startTransaction in order to avoid our own code from
+ * being profiled. Because of that same reason, stopProfiling is called before the call to stopTransaction.
+ */
+function wrapTransactionWithProfiling(transaction) {
+  // Feature support check first
+  const JSProfilerConstructor = WINDOW.Profiler;
+
+  if (!isJSProfilerSupported(JSProfilerConstructor)) {
+    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+      logger.log(
+        '[Profiling] Profiling is not supported by this browser, Profiler interface missing on window object.',
+      );
+    }
+    return transaction;
+  }
+
+  // If constructor failed once, it will always fail, so we can early return.
+  if (PROFILING_CONSTRUCTOR_FAILED) {
+    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+      logger.log('[Profiling] Profiling has been disabled for the duration of the current user session.');
+    }
+    return transaction;
+  }
+
+  const client = getCurrentHub().getClient();
+  const options = client && client.getOptions();
+  if (!options) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Profiling] Profiling disabled, no options found.');
+    return transaction;
+  }
+
+  // @ts-expect-error profilesSampleRate is not part of the browser options yet
+  const profilesSampleRate = options.profilesSampleRate;
+
+  // Since this is coming from the user (or from a function provided by the user), who knows what we might get. (The
+  // only valid values are booleans or numbers between 0 and 1.)
+  if (!isValidSampleRate(profilesSampleRate)) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('[Profiling] Discarding profile because of invalid sample rate.');
+    return transaction;
+  }
+
+  // if the function returned 0 (or false), or if `profileSampleRate` is 0, it's a sign the profile should be dropped
+  if (!profilesSampleRate) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.log(
+        '[Profiling] Discarding profile because a negative sampling decision was inherited or profileSampleRate is set to 0',
+      );
+    return transaction;
+  }
+
+  // Now we roll the dice. Math.random is inclusive of 0, but not of 1, so strict < is safe here. In case sampleRate is
+  // a boolean, the < comparison will cause it to be automatically cast to 1 if it's true and 0 if it's false.
+  const sampled = profilesSampleRate === true ? true : Math.random() < profilesSampleRate;
+  // Check if we should sample this profile
+  if (!sampled) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.log(
+        `[Profiling] Discarding profile because it's not included in the random sample (sampling rate = ${Number(
+          profilesSampleRate,
+        )})`,
+      );
+    return transaction;
+  }
+
+  // From initial testing, it seems that the minimum value for sampleInterval is 10ms.
+  const samplingIntervalMS = 10;
+  // Start the profiler
+  const maxSamples = Math.floor(MAX_PROFILE_DURATION_MS / samplingIntervalMS);
+  let profiler;
+
+  // Attempt to initialize the profiler constructor, if it fails, we disable profiling for the current user session.
+  // This is likely due to a missing 'Document-Policy': 'js-profiling' header. We do not want to throw an error if this happens
+  // as we risk breaking the user's application, so just disable profiling and log an error.
+  try {
+    profiler = new JSProfilerConstructor({ sampleInterval: samplingIntervalMS, maxBufferSize: maxSamples });
+  } catch (e) {
+    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+      logger.log(
+        "[Profiling] Failed to initialize the Profiling constructor, this is likely due to a missing 'Document-Policy': 'js-profiling' header.",
+      );
+      logger.log('[Profiling] Disabling profiling for current user session.');
+    }
+    PROFILING_CONSTRUCTOR_FAILED = true;
+  }
+
+  // We failed to construct the profiler, fallback to original transaction - there is no need to log
+  // anything as we already did that in the try/catch block.
+  if (!profiler) {
+    return transaction;
+  }
+
+  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+    logger.log(`[Profiling] started profiling transaction: ${transaction.name || transaction.description}`);
+  }
+
+  // We create "unique" transaction names to avoid concurrent transactions with same names
+  // from being ignored by the profiler. From here on, only this transaction name should be used when
+  // calling the profiler methods. Note: we log the original name to the user to avoid confusion.
+  const profileId = uuid4();
+
+  /**
+   * Idempotent handler for profile stop
+   */
+  async function onProfileHandler() {
+    // Check if the profile exists and return it the behavior has to be idempotent as users may call transaction.finish multiple times.
+    if (!transaction) {
+      return null;
+    }
+    // Satisfy the type checker, but profiler will always be defined here.
+    if (!profiler) {
+      return null;
+    }
+
+    // This is temporary - we will use the collected span data to evaluate
+    // if deferring txn.finish until profiler resolves is a viable approach.
+    const stopProfilerSpan = transaction.startChild({
+      description: 'profiler.stop',
+      op: 'profiler',
+      origin: 'auto.profiler.browser',
+    });
+
+    return profiler
+      .stop()
+      .then((p) => {
+        stopProfilerSpan.finish();
+
+        if (maxDurationTimeoutID) {
+          WINDOW.clearTimeout(maxDurationTimeoutID);
+          maxDurationTimeoutID = undefined;
+        }
+
+        if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+          logger.log(`[Profiling] stopped profiling of transaction: ${transaction.name || transaction.description}`);
+        }
+
+        // In case of an overlapping transaction, stopProfiling may return null and silently ignore the overlapping profile.
+        if (!p) {
+          if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+            logger.log(
+              `[Profiling] profiler returned null profile for: ${transaction.name || transaction.description}`,
+              'this may indicate an overlapping transaction or a call to stopProfiling with a profile title that was never started',
+            );
+          }
+          return null;
+        }
+
+        addProfileToMap(profileId, p);
+        return null;
+      })
+      .catch(error => {
+        stopProfilerSpan.finish();
+        if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+          logger.log('[Profiling] error while stopping profiler:', error);
+        }
+        return null;
+      });
+  }
+
+  // Enqueue a timeout to prevent profiles from running over max duration.
+  let maxDurationTimeoutID = WINDOW.setTimeout(() => {
+    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+      logger.log(
+        '[Profiling] max profile duration elapsed, stopping profiling for:',
+        transaction.name || transaction.description,
+      );
+    }
+    // If the timeout exceeds, we want to stop profiling, but not finish the transaction
+    void onProfileHandler();
+  }, MAX_PROFILE_DURATION_MS);
+
+  // We need to reference the original finish call to avoid creating an infinite loop
+  const originalFinish = transaction.finish.bind(transaction);
+
+  /**
+   * Wraps startTransaction and stopTransaction with profiling related logic.
+   * startProfiling is called after the call to startTransaction in order to avoid our own code from
+   * being profiled. Because of that same reason, stopProfiling is called before the call to stopTransaction.
+   */
+  function profilingWrappedTransactionFinish() {
+    if (!transaction) {
+      return originalFinish();
+    }
+    // onProfileHandler should always return the same profile even if this is called multiple times.
+    // Always call onProfileHandler to ensure stopProfiling is called and the timeout is cleared.
+    void onProfileHandler().then(
+      () => {
+        transaction.setContext('profile', { profile_id: profileId });
+        originalFinish();
+      },
+      () => {
+        // If onProfileHandler fails, we still want to call the original finish method.
+        originalFinish();
+      },
+    );
+
+    return transaction;
+  }
+
+  transaction.finish = profilingWrappedTransactionFinish;
+  return transaction;
+}
+
+export { MAX_PROFILE_DURATION_MS, onProfilingStartRouteTransaction, wrapTransactionWithProfiling };
+//# sourceMappingURL=hubextensions.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/profiling/integration.js b/parent_dir/node_modules/sentry/browser/esm/profiling/integration.js
new file mode 100644
index 0000000..7ed3a22
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/profiling/integration.js
@@ -0,0 +1,84 @@
+import { logger } from '@sentry/utils';
+import { wrapTransactionWithProfiling } from './hubextensions.js';
+import { PROFILE_MAP, findProfiledTransactionsFromEnvelope, createProfilingEvent, addProfilesToEnvelope } from './utils.js';
+
+/**
+ * Browser profiling integration. Stores any event that has contexts["profile"]["profile_id"]
+ * This exists because we do not want to await async profiler.stop calls as transaction.finish is called
+ * in a synchronous context. Instead, we handle sending the profile async from the promise callback and
+ * rely on being able to pull the event from the cache when we need to construct the envelope. This makes the
+ * integration less reliable as we might be dropping profiles when the cache is full.
+ *
+ * @experimental
+ */
+class BrowserProfilingIntegration  {
+   static __initStatic() {this.id = 'BrowserProfilingIntegration';}
+
+   constructor() {
+    this.name = BrowserProfilingIntegration.id;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setupOnce(addGlobalEventProcessor, getCurrentHub) {
+    this.getCurrentHub = getCurrentHub;
+    const client = this.getCurrentHub().getClient() ;
+
+    if (client && typeof client.on === 'function') {
+      client.on('startTransaction', (transaction) => {
+        wrapTransactionWithProfiling(transaction);
+      });
+
+      client.on('beforeEnvelope', (envelope) => {
+        // if not profiles are in queue, there is nothing to add to the envelope.
+        if (!PROFILE_MAP['size']) {
+          return;
+        }
+
+        const profiledTransactionEvents = findProfiledTransactionsFromEnvelope(envelope);
+        if (!profiledTransactionEvents.length) {
+          return;
+        }
+
+        const profilesToAddToEnvelope = [];
+
+        for (const profiledTransaction of profiledTransactionEvents) {
+          const context = profiledTransaction && profiledTransaction.contexts;
+          const profile_id = context && context['profile'] && (context['profile']['profile_id'] );
+
+          if (!profile_id) {
+            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+              logger.log('[Profiling] cannot find profile for a transaction without a profile context');
+            continue;
+          }
+
+          // Remove the profile from the transaction context before sending, relay will take care of the rest.
+          if (context && context['profile']) {
+            delete context.profile;
+          }
+
+          const profile = PROFILE_MAP.get(profile_id);
+          if (!profile) {
+            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Profiling] Could not retrieve profile for transaction: ${profile_id}`);
+            continue;
+          }
+
+          PROFILE_MAP.delete(profile_id);
+          const profileEvent = createProfilingEvent(profile_id, profile, profiledTransaction );
+
+          if (profileEvent) {
+            profilesToAddToEnvelope.push(profileEvent);
+          }
+        }
+
+        addProfilesToEnvelope(envelope, profilesToAddToEnvelope);
+      });
+    } else {
+      logger.warn('[Profiling] Client does not support hooks, profiling will be disabled');
+    }
+  }
+} BrowserProfilingIntegration.__initStatic();
+
+export { BrowserProfilingIntegration };
+//# sourceMappingURL=integration.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/profiling/utils.js b/parent_dir/node_modules/sentry/browser/esm/profiling/utils.js
new file mode 100644
index 0000000..7779d56
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/profiling/utils.js
@@ -0,0 +1,445 @@
+import { DEFAULT_ENVIRONMENT, getCurrentHub } from '@sentry/core';
+import { forEachEnvelopeItem, logger, uuid4, GLOBAL_OBJ, browserPerformanceTimeOrigin } from '@sentry/utils';
+import { WINDOW } from '../helpers.js';
+
+/* eslint-disable max-lines */
+
+const MS_TO_NS = 1e6;
+// Use 0 as main thread id which is identical to threadId in node:worker_threads
+// where main logs 0 and workers seem to log in increments of 1
+const THREAD_ID_STRING = String(0);
+const THREAD_NAME = 'main';
+
+// Machine properties (eval only once)
+let OS_PLATFORM = '';
+let OS_PLATFORM_VERSION = '';
+let OS_ARCH = '';
+let OS_BROWSER = (WINDOW.navigator && WINDOW.navigator.userAgent) || '';
+let OS_MODEL = '';
+const OS_LOCALE =
+  (WINDOW.navigator && WINDOW.navigator.language) ||
+  (WINDOW.navigator && WINDOW.navigator.languages && WINDOW.navigator.languages[0]) ||
+  '';
+
+function isUserAgentData(data) {
+  return typeof data === 'object' && data !== null && 'getHighEntropyValues' in data;
+}
+
+// @ts-expect-error userAgentData is not part of the navigator interface yet
+const userAgentData = WINDOW.navigator && WINDOW.navigator.userAgentData;
+
+if (isUserAgentData(userAgentData)) {
+  userAgentData
+    .getHighEntropyValues(['architecture', 'model', 'platform', 'platformVersion', 'fullVersionList'])
+    .then((ua) => {
+      OS_PLATFORM = ua.platform || '';
+      OS_ARCH = ua.architecture || '';
+      OS_MODEL = ua.model || '';
+      OS_PLATFORM_VERSION = ua.platformVersion || '';
+
+      if (ua.fullVersionList && ua.fullVersionList.length > 0) {
+        const firstUa = ua.fullVersionList[ua.fullVersionList.length - 1];
+        OS_BROWSER = `${firstUa.brand} ${firstUa.version}`;
+      }
+    })
+    .catch(e => void e);
+}
+
+function isProcessedJSSelfProfile(profile) {
+  return !('thread_metadata' in profile);
+}
+
+// Enriches the profile with threadId of the current thread.
+// This is done in node as we seem to not be able to get the info from C native code.
+/**
+ *
+ */
+function enrichWithThreadInformation(profile) {
+  if (!isProcessedJSSelfProfile(profile)) {
+    return profile;
+  }
+
+  return convertJSSelfProfileToSampledFormat(profile);
+}
+
+// Profile is marked as optional because it is deleted from the metadata
+// by the integration before the event is processed by other integrations.
+
+function getTraceId(event) {
+  const traceId = event && event.contexts && event.contexts['trace'] && event.contexts['trace']['trace_id'];
+  // Log a warning if the profile has an invalid traceId (should be uuidv4).
+  // All profiles and transactions are rejected if this is the case and we want to
+  // warn users that this is happening if they enable debug flag
+  if (typeof traceId === 'string' && traceId.length !== 32) {
+    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+      logger.log(`[Profiling] Invalid traceId: ${traceId} on profiled event`);
+    }
+  }
+  if (typeof traceId !== 'string') {
+    return '';
+  }
+
+  return traceId;
+}
+/**
+ * Creates a profiling event envelope from a Sentry event. If profile does not pass
+ * validation, returns null.
+ * @param event
+ * @param dsn
+ * @param metadata
+ * @param tunnel
+ * @returns {EventEnvelope | null}
+ */
+
+/**
+ * Creates a profiling event envelope from a Sentry event.
+ */
+function createProfilePayload(
+  event,
+  processedProfile,
+  profile_id,
+) {
+  if (event.type !== 'transaction') {
+    // createProfilingEventEnvelope should only be called for transactions,
+    // we type guard this behavior with isProfiledTransactionEvent.
+    throw new TypeError('Profiling events may only be attached to transactions, this should never occur.');
+  }
+
+  if (processedProfile === undefined || processedProfile === null) {
+    throw new TypeError(
+      `Cannot construct profiling event envelope without a valid profile. Got ${processedProfile} instead.`,
+    );
+  }
+
+  const traceId = getTraceId(event);
+  const enrichedThreadProfile = enrichWithThreadInformation(processedProfile);
+  const transactionStartMs = typeof event.start_timestamp === 'number' ? event.start_timestamp * 1000 : Date.now();
+  const transactionEndMs = typeof event.timestamp === 'number' ? event.timestamp * 1000 : Date.now();
+
+  const profile = {
+    event_id: profile_id,
+    timestamp: new Date(transactionStartMs).toISOString(),
+    platform: 'javascript',
+    version: '1',
+    release: event.release || '',
+    environment: event.environment || DEFAULT_ENVIRONMENT,
+    runtime: {
+      name: 'javascript',
+      version: WINDOW.navigator.userAgent,
+    },
+    os: {
+      name: OS_PLATFORM,
+      version: OS_PLATFORM_VERSION,
+      build_number: OS_BROWSER,
+    },
+    device: {
+      locale: OS_LOCALE,
+      model: OS_MODEL,
+      manufacturer: OS_BROWSER,
+      architecture: OS_ARCH,
+      is_emulator: false,
+    },
+    debug_meta: {
+      images: applyDebugMetadata(processedProfile.resources),
+    },
+    profile: enrichedThreadProfile,
+    transactions: [
+      {
+        name: event.transaction || '',
+        id: event.event_id || uuid4(),
+        trace_id: traceId,
+        active_thread_id: THREAD_ID_STRING,
+        relative_start_ns: '0',
+        relative_end_ns: ((transactionEndMs - transactionStartMs) * 1e6).toFixed(0),
+      },
+    ],
+  };
+
+  return profile;
+}
+
+/**
+ * Converts a JSSelfProfile to a our sampled format.
+ * Does not currently perform stack indexing.
+ */
+function convertJSSelfProfileToSampledFormat(input) {
+  let EMPTY_STACK_ID = undefined;
+  let STACK_ID = 0;
+
+  // Initialize the profile that we will fill with data
+  const profile = {
+    samples: [],
+    stacks: [],
+    frames: [],
+    thread_metadata: {
+      [THREAD_ID_STRING]: { name: THREAD_NAME },
+    },
+  };
+
+  if (!input.samples.length) {
+    return profile;
+  }
+
+  // We assert samples.length > 0 above and timestamp should always be present
+  const start = input.samples[0].timestamp;
+  // The JS SDK might change it's time origin based on some heuristic (see See packages/utils/src/time.ts)
+  // when that happens, we need to ensure we are correcting the profile timings so the two timelines stay in sync.
+  // Since JS self profiling time origin is always initialized to performance.timeOrigin, we need to adjust for
+  // the drift between the SDK selected value and our profile time origin.
+  const origin =
+    typeof performance.timeOrigin === 'number' ? performance.timeOrigin : browserPerformanceTimeOrigin || 0;
+  const adjustForOriginChange = origin - (browserPerformanceTimeOrigin || origin);
+
+  for (let i = 0; i < input.samples.length; i++) {
+    const jsSample = input.samples[i];
+
+    // If sample has no stack, add an empty sample
+    if (jsSample.stackId === undefined) {
+      if (EMPTY_STACK_ID === undefined) {
+        EMPTY_STACK_ID = STACK_ID;
+        profile.stacks[EMPTY_STACK_ID] = [];
+        STACK_ID++;
+      }
+
+      profile['samples'][i] = {
+        // convert ms timestamp to ns
+        elapsed_since_start_ns: ((jsSample.timestamp + adjustForOriginChange - start) * MS_TO_NS).toFixed(0),
+        stack_id: EMPTY_STACK_ID,
+        thread_id: THREAD_ID_STRING,
+      };
+      continue;
+    }
+
+    let stackTop = input.stacks[jsSample.stackId];
+
+    // Functions in top->down order (root is last)
+    // We follow the stackTop.parentId trail and collect each visited frameId
+    const stack = [];
+
+    while (stackTop) {
+      stack.push(stackTop.frameId);
+
+      const frame = input.frames[stackTop.frameId];
+
+      // If our frame has not been indexed yet, index it
+      if (profile.frames[stackTop.frameId] === undefined) {
+        profile.frames[stackTop.frameId] = {
+          function: frame.name,
+          abs_path: typeof frame.resourceId === 'number' ? input.resources[frame.resourceId] : undefined,
+          lineno: frame.line,
+          colno: frame.column,
+        };
+      }
+
+      stackTop = stackTop.parentId === undefined ? undefined : input.stacks[stackTop.parentId];
+    }
+
+    const sample = {
+      // convert ms timestamp to ns
+      elapsed_since_start_ns: ((jsSample.timestamp + adjustForOriginChange - start) * MS_TO_NS).toFixed(0),
+      stack_id: STACK_ID,
+      thread_id: THREAD_ID_STRING,
+    };
+
+    profile['stacks'][STACK_ID] = stack;
+    profile['samples'][i] = sample;
+    STACK_ID++;
+  }
+
+  return profile;
+}
+
+/**
+ * Adds items to envelope if they are not already present - mutates the envelope.
+ * @param envelope
+ */
+function addProfilesToEnvelope(envelope, profiles) {
+  if (!profiles.length) {
+    return envelope;
+  }
+
+  for (const profile of profiles) {
+    // @ts-expect-error untyped envelope
+    envelope[1].push([{ type: 'profile' }, profile]);
+  }
+  return envelope;
+}
+
+/**
+ * Finds transactions with profile_id context in the envelope
+ * @param envelope
+ * @returns
+ */
+function findProfiledTransactionsFromEnvelope(envelope) {
+  const events = [];
+
+  forEachEnvelopeItem(envelope, (item, type) => {
+    if (type !== 'transaction') {
+      return;
+    }
+
+    for (let j = 1; j < item.length; j++) {
+      const event = item[j] ;
+
+      if (event && event.contexts && event.contexts['profile'] && event.contexts['profile']['profile_id']) {
+        events.push(item[j] );
+      }
+    }
+  });
+
+  return events;
+}
+
+const debugIdStackParserCache = new WeakMap();
+/**
+ * Applies debug meta data to an event from a list of paths to resources (sourcemaps)
+ */
+function applyDebugMetadata(resource_paths) {
+  const debugIdMap = GLOBAL_OBJ._sentryDebugIds;
+
+  if (!debugIdMap) {
+    return [];
+  }
+
+  const hub = getCurrentHub();
+  if (!hub) {
+    return [];
+  }
+  const client = hub.getClient();
+  if (!client) {
+    return [];
+  }
+  const options = client.getOptions();
+  if (!options) {
+    return [];
+  }
+  const stackParser = options.stackParser;
+  if (!stackParser) {
+    return [];
+  }
+
+  let debugIdStackFramesCache;
+  const cachedDebugIdStackFrameCache = debugIdStackParserCache.get(stackParser);
+  if (cachedDebugIdStackFrameCache) {
+    debugIdStackFramesCache = cachedDebugIdStackFrameCache;
+  } else {
+    debugIdStackFramesCache = new Map();
+    debugIdStackParserCache.set(stackParser, debugIdStackFramesCache);
+  }
+
+  // Build a map of filename -> debug_id
+  const filenameDebugIdMap = Object.keys(debugIdMap).reduce((acc, debugIdStackTrace) => {
+    let parsedStack;
+
+    const cachedParsedStack = debugIdStackFramesCache.get(debugIdStackTrace);
+    if (cachedParsedStack) {
+      parsedStack = cachedParsedStack;
+    } else {
+      parsedStack = stackParser(debugIdStackTrace);
+      debugIdStackFramesCache.set(debugIdStackTrace, parsedStack);
+    }
+
+    for (let i = parsedStack.length - 1; i >= 0; i--) {
+      const stackFrame = parsedStack[i];
+      const file = stackFrame && stackFrame.filename;
+
+      if (stackFrame && file) {
+        acc[file] = debugIdMap[debugIdStackTrace] ;
+        break;
+      }
+    }
+    return acc;
+  }, {});
+
+  const images = [];
+  for (const path of resource_paths) {
+    if (path && filenameDebugIdMap[path]) {
+      images.push({
+        type: 'sourcemap',
+        code_file: path,
+        debug_id: filenameDebugIdMap[path] ,
+      });
+    }
+  }
+
+  return images;
+}
+
+/**
+ * Checks the given sample rate to make sure it is valid type and value (a boolean, or a number between 0 and 1).
+ */
+function isValidSampleRate(rate) {
+  // we need to check NaN explicitly because it's of type 'number' and therefore wouldn't get caught by this typecheck
+  if ((typeof rate !== 'number' && typeof rate !== 'boolean') || (typeof rate === 'number' && isNaN(rate))) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.warn(
+        `[Profiling] Invalid sample rate. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(
+          rate,
+        )} of type ${JSON.stringify(typeof rate)}.`,
+      );
+    return false;
+  }
+
+  // Boolean sample rates are always valid
+  if (rate === true || rate === false) {
+    return true;
+  }
+
+  // in case sampleRate is a boolean, it will get automatically cast to 1 if it's true and 0 if it's false
+  if (rate < 0 || rate > 1) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.warn(`[Profiling] Invalid sample rate. Sample rate must be between 0 and 1. Got ${rate}.`);
+    return false;
+  }
+  return true;
+}
+
+function isValidProfile(profile) {
+  if (profile.samples.length < 2) {
+    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+      // Log a warning if the profile has less than 2 samples so users can know why
+      // they are not seeing any profiling data and we cant avoid the back and forth
+      // of asking them to provide us with a dump of the profile data.
+      logger.log('[Profiling] Discarding profile because it contains less than 2 samples');
+    }
+    return false;
+  }
+
+  if (!profile.frames.length) {
+    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+      logger.log('[Profiling] Discarding profile because it contains no frames');
+    }
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Creates a profiling envelope item, if the profile does not pass validation, returns null.
+ * @param event
+ * @returns {Profile | null}
+ */
+function createProfilingEvent(profile_id, profile, event) {
+  if (!isValidProfile(profile)) {
+    return null;
+  }
+
+  return createProfilePayload(event, profile, profile_id);
+}
+
+const PROFILE_MAP = new Map();
+/**
+ *
+ */
+function addProfileToMap(profile_id, profile) {
+  PROFILE_MAP.set(profile_id, profile);
+
+  if (PROFILE_MAP.size > 30) {
+    const last = PROFILE_MAP.keys().next().value;
+    PROFILE_MAP.delete(last);
+  }
+}
+
+export { PROFILE_MAP, addProfileToMap, addProfilesToEnvelope, applyDebugMetadata, convertJSSelfProfileToSampledFormat, createProfilePayload, createProfilingEvent, enrichWithThreadInformation, findProfiledTransactionsFromEnvelope, isValidSampleRate };
+//# sourceMappingURL=utils.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/sdk.js b/parent_dir/node_modules/sentry/browser/esm/sdk.js
new file mode 100644
index 0000000..48c5677
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/sdk.js
@@ -0,0 +1,256 @@
+import { Integrations, getIntegrationsToSetup, initAndBind, getReportDialogEndpoint, getCurrentHub } from '@sentry/core';
+import { stackParserFromStackParserOptions, supportsFetch, logger, addInstrumentationHandler } from '@sentry/utils';
+import { BrowserClient } from './client.js';
+import { WINDOW, wrap as wrap$1 } from './helpers.js';
+import { GlobalHandlers } from './integrations/globalhandlers.js';
+import { TryCatch } from './integrations/trycatch.js';
+import { Breadcrumbs } from './integrations/breadcrumbs.js';
+import { LinkedErrors } from './integrations/linkederrors.js';
+import { HttpContext } from './integrations/httpcontext.js';
+import { Dedupe } from './integrations/dedupe.js';
+import { defaultStackParser } from './stack-parsers.js';
+import { makeFetchTransport } from './transports/fetch.js';
+import { makeXHRTransport } from './transports/xhr.js';
+
+const defaultIntegrations = [
+  new Integrations.InboundFilters(),
+  new Integrations.FunctionToString(),
+  new TryCatch(),
+  new Breadcrumbs(),
+  new GlobalHandlers(),
+  new LinkedErrors(),
+  new Dedupe(),
+  new HttpContext(),
+];
+
+/**
+ * A magic string that build tooling can leverage in order to inject a release value into the SDK.
+ */
+
+/**
+ * The Sentry Browser SDK Client.
+ *
+ * To use this SDK, call the {@link init} function as early as possible when
+ * loading the web page. To set context information or send manual events, use
+ * the provided methods.
+ *
+ * @example
+ *
+ * ```
+ *
+ * import { init } from '@sentry/browser';
+ *
+ * init({
+ *   dsn: '__DSN__',
+ *   // ...
+ * });
+ * ```
+ *
+ * @example
+ * ```
+ *
+ * import { configureScope } from '@sentry/browser';
+ * configureScope((scope: Scope) => {
+ *   scope.setExtra({ battery: 0.7 });
+ *   scope.setTag({ user_mode: 'admin' });
+ *   scope.setUser({ id: '4711' });
+ * });
+ * ```
+ *
+ * @example
+ * ```
+ *
+ * import { addBreadcrumb } from '@sentry/browser';
+ * addBreadcrumb({
+ *   message: 'My Breadcrumb',
+ *   // ...
+ * });
+ * ```
+ *
+ * @example
+ *
+ * ```
+ *
+ * import * as Sentry from '@sentry/browser';
+ * Sentry.captureMessage('Hello, world!');
+ * Sentry.captureException(new Error('Good bye'));
+ * Sentry.captureEvent({
+ *   message: 'Manual',
+ *   stacktrace: [
+ *     // ...
+ *   ],
+ * });
+ * ```
+ *
+ * @see {@link BrowserOptions} for documentation on configuration options.
+ */
+function init(options = {}) {
+  if (options.defaultIntegrations === undefined) {
+    options.defaultIntegrations = defaultIntegrations;
+  }
+  if (options.release === undefined) {
+    // This allows build tooling to find-and-replace __SENTRY_RELEASE__ to inject a release value
+    if (typeof __SENTRY_RELEASE__ === 'string') {
+      options.release = __SENTRY_RELEASE__;
+    }
+
+    // This supports the variable that sentry-webpack-plugin injects
+    if (WINDOW.SENTRY_RELEASE && WINDOW.SENTRY_RELEASE.id) {
+      options.release = WINDOW.SENTRY_RELEASE.id;
+    }
+  }
+  if (options.autoSessionTracking === undefined) {
+    options.autoSessionTracking = true;
+  }
+  if (options.sendClientReports === undefined) {
+    options.sendClientReports = true;
+  }
+
+  const clientOptions = {
+    ...options,
+    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),
+    integrations: getIntegrationsToSetup(options),
+    transport: options.transport || (supportsFetch() ? makeFetchTransport : makeXHRTransport),
+  };
+
+  initAndBind(BrowserClient, clientOptions);
+
+  if (options.autoSessionTracking) {
+    startSessionTracking();
+  }
+}
+
+/**
+ * Present the user with a report dialog.
+ *
+ * @param options Everything is optional, we try to fetch all info need from the global scope.
+ */
+function showReportDialog(options = {}, hub = getCurrentHub()) {
+  // doesn't work without a document (React Native)
+  if (!WINDOW.document) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Global document not defined in showReportDialog call');
+    return;
+  }
+
+  const { client, scope } = hub.getStackTop();
+  const dsn = options.dsn || (client && client.getDsn());
+  if (!dsn) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('DSN not configured for showReportDialog call');
+    return;
+  }
+
+  if (scope) {
+    options.user = {
+      ...scope.getUser(),
+      ...options.user,
+    };
+  }
+
+  if (!options.eventId) {
+    options.eventId = hub.lastEventId();
+  }
+
+  const script = WINDOW.document.createElement('script');
+  script.async = true;
+  script.crossOrigin = 'anonymous';
+  script.src = getReportDialogEndpoint(dsn, options);
+
+  if (options.onLoad) {
+    script.onload = options.onLoad;
+  }
+
+  const injectionPoint = WINDOW.document.head || WINDOW.document.body;
+  if (injectionPoint) {
+    injectionPoint.appendChild(script);
+  } else {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Not injecting report dialog. No injection point found in HTML');
+  }
+}
+
+/**
+ * This function is here to be API compatible with the loader.
+ * @hidden
+ */
+function forceLoad() {
+  // Noop
+}
+
+/**
+ * This function is here to be API compatible with the loader.
+ * @hidden
+ */
+function onLoad(callback) {
+  callback();
+}
+
+/**
+ * Wrap code within a try/catch block so the SDK is able to capture errors.
+ *
+ * @deprecated This function will be removed in v8.
+ * It is not part of Sentry's official API and it's easily replaceable by using a try/catch block
+ * and calling Sentry.captureException.
+ *
+ * @param fn A function to wrap.
+ *
+ * @returns The result of wrapped function call.
+ */
+// TODO(v8): Remove this function
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function wrap(fn) {
+  return wrap$1(fn)();
+}
+
+function startSessionOnHub(hub) {
+  hub.startSession({ ignoreDuration: true });
+  hub.captureSession();
+}
+
+/**
+ * Enable automatic Session Tracking for the initial page load.
+ */
+function startSessionTracking() {
+  if (typeof WINDOW.document === 'undefined') {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');
+    return;
+  }
+
+  const hub = getCurrentHub();
+
+  // The only way for this to be false is for there to be a version mismatch between @sentry/browser (>= 6.0.0) and
+  // @sentry/hub (< 5.27.0). In the simple case, there won't ever be such a mismatch, because the two packages are
+  // pinned at the same version in package.json, but there are edge cases where it's possible. See
+  // https://github.com/getsentry/sentry-javascript/issues/3207 and
+  // https://github.com/getsentry/sentry-javascript/issues/3234 and
+  // https://github.com/getsentry/sentry-javascript/issues/3278.
+  if (!hub.captureSession) {
+    return;
+  }
+
+  // The session duration for browser sessions does not track a meaningful
+  // concept that can be used as a metric.
+  // Automatically captured sessions are akin to page views, and thus we
+  // discard their duration.
+  startSessionOnHub(hub);
+
+  // We want to create a session for every navigation as well
+  addInstrumentationHandler('history', ({ from, to }) => {
+    // Don't create an additional session for the initial route or if the location did not change
+    if (!(from === undefined || from === to)) {
+      startSessionOnHub(getCurrentHub());
+    }
+  });
+}
+
+/**
+ * Captures user feedback and sends it to Sentry.
+ */
+function captureUserFeedback(feedback) {
+  const client = getCurrentHub().getClient();
+  if (client) {
+    client.captureUserFeedback(feedback);
+  }
+}
+
+export { captureUserFeedback, defaultIntegrations, forceLoad, init, onLoad, showReportDialog, wrap };
+//# sourceMappingURL=sdk.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/stack-parsers.js b/parent_dir/node_modules/sentry/browser/esm/stack-parsers.js
new file mode 100644
index 0000000..4f3da89
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/stack-parsers.js
@@ -0,0 +1,168 @@
+import { createStackParser } from '@sentry/utils';
+
+// global reference to slice
+const UNKNOWN_FUNCTION = '?';
+
+const OPERA10_PRIORITY = 10;
+const OPERA11_PRIORITY = 20;
+const CHROME_PRIORITY = 30;
+const WINJS_PRIORITY = 40;
+const GECKO_PRIORITY = 50;
+
+function createFrame(filename, func, lineno, colno) {
+  const frame = {
+    filename,
+    function: func,
+    in_app: true, // All browser frames are considered in_app
+  };
+
+  if (lineno !== undefined) {
+    frame.lineno = lineno;
+  }
+
+  if (colno !== undefined) {
+    frame.colno = colno;
+  }
+
+  return frame;
+}
+
+// Chromium based browsers: Chrome, Brave, new Opera, new Edge
+const chromeRegex =
+  /^\s*at (?:(.+?\)(?: \[.+\])?|.*?) ?\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\/)?.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+const chromeEvalRegex = /\((\S*)(?::(\d+))(?::(\d+))\)/;
+
+const chrome = line => {
+  const parts = chromeRegex.exec(line);
+
+  if (parts) {
+    const isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line
+
+    if (isEval) {
+      const subMatch = chromeEvalRegex.exec(parts[2]);
+
+      if (subMatch) {
+        // throw out eval line/column and use top-most line/column number
+        parts[2] = subMatch[1]; // url
+        parts[3] = subMatch[2]; // line
+        parts[4] = subMatch[3]; // column
+      }
+    }
+
+    // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now
+    // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)
+    const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);
+
+    return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);
+  }
+
+  return;
+};
+
+const chromeStackLineParser = [CHROME_PRIORITY, chrome];
+
+// gecko regex: `(?:bundle|\d+\.js)`: `bundle` is for react native, `\d+\.js` also but specifically for ram bundles because it
+// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js
+// We need this specific case for now because we want no other regex to match.
+const geckoREgex =
+  /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:[-a-z]+)?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. /=]+)(?::(\d+))?(?::(\d+))?\s*$/i;
+const geckoEvalRegex = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+
+const gecko = line => {
+  const parts = geckoREgex.exec(line);
+
+  if (parts) {
+    const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;
+    if (isEval) {
+      const subMatch = geckoEvalRegex.exec(parts[3]);
+
+      if (subMatch) {
+        // throw out eval line/column and use top-most line number
+        parts[1] = parts[1] || 'eval';
+        parts[3] = subMatch[1];
+        parts[4] = subMatch[2];
+        parts[5] = ''; // no column when eval
+      }
+    }
+
+    let filename = parts[3];
+    let func = parts[1] || UNKNOWN_FUNCTION;
+    [func, filename] = extractSafariExtensionDetails(func, filename);
+
+    return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);
+  }
+
+  return;
+};
+
+const geckoStackLineParser = [GECKO_PRIORITY, gecko];
+
+const winjsRegex = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:[-a-z]+):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+
+const winjs = line => {
+  const parts = winjsRegex.exec(line);
+
+  return parts
+    ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)
+    : undefined;
+};
+
+const winjsStackLineParser = [WINJS_PRIORITY, winjs];
+
+const opera10Regex = / line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i;
+
+const opera10 = line => {
+  const parts = opera10Regex.exec(line);
+  return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;
+};
+
+const opera10StackLineParser = [OPERA10_PRIORITY, opera10];
+
+const opera11Regex =
+  / line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\(.*\))? in (.*):\s*$/i;
+
+const opera11 = line => {
+  const parts = opera11Regex.exec(line);
+  return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;
+};
+
+const opera11StackLineParser = [OPERA11_PRIORITY, opera11];
+
+const defaultStackLineParsers = [chromeStackLineParser, geckoStackLineParser, winjsStackLineParser];
+
+const defaultStackParser = createStackParser(...defaultStackLineParsers);
+
+/**
+ * Safari web extensions, starting version unknown, can produce "frames-only" stacktraces.
+ * What it means, is that instead of format like:
+ *
+ * Error: wat
+ *   at function@url:row:col
+ *   at function@url:row:col
+ *   at function@url:row:col
+ *
+ * it produces something like:
+ *
+ *   function@url:row:col
+ *   function@url:row:col
+ *   function@url:row:col
+ *
+ * Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.
+ * This function is extracted so that we can use it in both places without duplicating the logic.
+ * Unfortunately "just" changing RegExp is too complicated now and making it pass all tests
+ * and fix this case seems like an impossible, or at least way too time-consuming task.
+ */
+const extractSafariExtensionDetails = (func, filename) => {
+  const isSafariExtension = func.indexOf('safari-extension') !== -1;
+  const isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;
+
+  return isSafariExtension || isSafariWebExtension
+    ? [
+        func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION,
+        isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,
+      ]
+    : [func, filename];
+};
+
+export { chromeStackLineParser, defaultStackLineParsers, defaultStackParser, geckoStackLineParser, opera10StackLineParser, opera11StackLineParser, winjsStackLineParser };
+//# sourceMappingURL=stack-parsers.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/transports/fetch.js b/parent_dir/node_modules/sentry/browser/esm/transports/fetch.js
new file mode 100644
index 0000000..bb836e3
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/transports/fetch.js
@@ -0,0 +1,64 @@
+import { createTransport } from '@sentry/core';
+import { rejectedSyncPromise } from '@sentry/utils';
+import { getNativeFetchImplementation, clearCachedFetchImplementation } from './utils.js';
+
+/**
+ * Creates a Transport that uses the Fetch API to send events to Sentry.
+ */
+function makeFetchTransport(
+  options,
+  nativeFetch = getNativeFetchImplementation(),
+) {
+  let pendingBodySize = 0;
+  let pendingCount = 0;
+
+  function makeRequest(request) {
+    const requestSize = request.body.length;
+    pendingBodySize += requestSize;
+    pendingCount++;
+
+    const requestOptions = {
+      body: request.body,
+      method: 'POST',
+      referrerPolicy: 'origin',
+      headers: options.headers,
+      // Outgoing requests are usually cancelled when navigating to a different page, causing a "TypeError: Failed to
+      // fetch" error and sending a "network_error" client-outcome - in Chrome, the request status shows "(cancelled)".
+      // The `keepalive` flag keeps outgoing requests alive, even when switching pages. We want this since we're
+      // frequently sending events right before the user is switching pages (eg. whenfinishing navigation transactions).
+      // Gotchas:
+      // - `keepalive` isn't supported by Firefox
+      // - As per spec (https://fetch.spec.whatwg.org/#http-network-or-cache-fetch):
+      //   If the sum of contentLength and inflightKeepaliveBytes is greater than 64 kibibytes, then return a network error.
+      //   We will therefore only activate the flag when we're below that limit.
+      // There is also a limit of requests that can be open at the same time, so we also limit this to 15
+      // See https://github.com/getsentry/sentry-javascript/pull/7553 for details
+      keepalive: pendingBodySize <= 60000 && pendingCount < 15,
+      ...options.fetchOptions,
+    };
+
+    try {
+      return nativeFetch(options.url, requestOptions).then(response => {
+        pendingBodySize -= requestSize;
+        pendingCount--;
+        return {
+          statusCode: response.status,
+          headers: {
+            'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),
+            'retry-after': response.headers.get('Retry-After'),
+          },
+        };
+      });
+    } catch (e) {
+      clearCachedFetchImplementation();
+      pendingBodySize -= requestSize;
+      pendingCount--;
+      return rejectedSyncPromise(e);
+    }
+  }
+
+  return createTransport(options, makeRequest);
+}
+
+export { makeFetchTransport };
+//# sourceMappingURL=fetch.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/transports/offline.js b/parent_dir/node_modules/sentry/browser/esm/transports/offline.js
new file mode 100644
index 0000000..f914673
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/transports/offline.js
@@ -0,0 +1,133 @@
+import { makeOfflineTransport } from '@sentry/core';
+import { serializeEnvelope, parseEnvelope } from '@sentry/utils';
+
+// 'Store', 'promisifyRequest' and 'createStore' were originally copied from the 'idb-keyval' package before being
+// modified and simplified: https://github.com/jakearchibald/idb-keyval
+//
+// At commit: 0420a704fd6cbb4225429c536b1f61112d012fca
+// Original licence:
+
+// Copyright 2016, Jake Archibald
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+function promisifyRequest(request) {
+  return new Promise((resolve, reject) => {
+    // @ts-expect-error - file size hacks
+    request.oncomplete = request.onsuccess = () => resolve(request.result);
+    // @ts-expect-error - file size hacks
+    request.onabort = request.onerror = () => reject(request.error);
+  });
+}
+
+/** Create or open an IndexedDb store */
+function createStore(dbName, storeName) {
+  const request = indexedDB.open(dbName);
+  request.onupgradeneeded = () => request.result.createObjectStore(storeName);
+  const dbp = promisifyRequest(request);
+
+  return callback => dbp.then(db => callback(db.transaction(storeName, 'readwrite').objectStore(storeName)));
+}
+
+function keys(store) {
+  return promisifyRequest(store.getAllKeys() );
+}
+
+/** Insert into the store */
+function insert(store, value, maxQueueSize) {
+  return store(store => {
+    return keys(store).then(keys => {
+      if (keys.length >= maxQueueSize) {
+        return;
+      }
+
+      // We insert with an incremented key so that the entries are popped in order
+      store.put(value, Math.max(...keys, 0) + 1);
+      return promisifyRequest(store.transaction);
+    });
+  });
+}
+
+/** Pop the oldest value from the store */
+function pop(store) {
+  return store(store => {
+    return keys(store).then(keys => {
+      if (keys.length === 0) {
+        return undefined;
+      }
+
+      return promisifyRequest(store.get(keys[0])).then(value => {
+        store.delete(keys[0]);
+        return promisifyRequest(store.transaction).then(() => value);
+      });
+    });
+  });
+}
+
+function createIndexedDbStore(options) {
+  let store;
+
+  // Lazily create the store only when it's needed
+  function getStore() {
+    if (store == undefined) {
+      store = createStore(options.dbName || 'sentry-offline', options.storeName || 'queue');
+    }
+
+    return store;
+  }
+
+  return {
+    insert: async (env) => {
+      try {
+        const serialized = await serializeEnvelope(env, options.textEncoder);
+        await insert(getStore(), serialized, options.maxQueueSize || 30);
+      } catch (_) {
+        //
+      }
+    },
+    pop: async () => {
+      try {
+        const deserialized = await pop(getStore());
+        if (deserialized) {
+          return parseEnvelope(
+            deserialized,
+            options.textEncoder || new TextEncoder(),
+            options.textDecoder || new TextDecoder(),
+          );
+        }
+      } catch (_) {
+        //
+      }
+
+      return undefined;
+    },
+  };
+}
+
+function makeIndexedDbOfflineTransport(
+  createTransport,
+) {
+  return options => createTransport({ ...options, createStore: createIndexedDbStore });
+}
+
+/**
+ * Creates a transport that uses IndexedDb to store events when offline.
+ */
+function makeBrowserOfflineTransport(
+  createTransport,
+) {
+  return makeIndexedDbOfflineTransport(makeOfflineTransport(createTransport));
+}
+
+export { createStore, insert, makeBrowserOfflineTransport, pop };
+//# sourceMappingURL=offline.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/transports/utils.js b/parent_dir/node_modules/sentry/browser/esm/transports/utils.js
new file mode 100644
index 0000000..bc50f0c
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/transports/utils.js
@@ -0,0 +1,85 @@
+import { isNativeFetch, logger } from '@sentry/utils';
+import { WINDOW } from '../helpers.js';
+
+let cachedFetchImpl = undefined;
+
+/**
+ * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.
+ * Whenever someone wraps the Fetch API and returns the wrong promise chain,
+ * this chain becomes orphaned and there is no possible way to capture it's rejections
+ * other than allowing it bubble up to this very handler. eg.
+ *
+ * const f = window.fetch;
+ * window.fetch = function () {
+ *   const p = f.apply(this, arguments);
+ *
+ *   p.then(function() {
+ *     console.log('hi.');
+ *   });
+ *
+ *   return p;
+ * }
+ *
+ * `p.then(function () { ... })` is producing a completely separate promise chain,
+ * however, what's returned is `p` - the result of original `fetch` call.
+ *
+ * This mean, that whenever we use the Fetch API to send our own requests, _and_
+ * some ad-blocker blocks it, this orphaned chain will _always_ reject,
+ * effectively causing another event to be captured.
+ * This makes a whole process become an infinite loop, which we need to somehow
+ * deal with, and break it in one way or another.
+ *
+ * To deal with this issue, we are making sure that we _always_ use the real
+ * browser Fetch API, instead of relying on what `window.fetch` exposes.
+ * The only downside to this would be missing our own requests as breadcrumbs,
+ * but because we are already not doing this, it should be just fine.
+ *
+ * Possible failed fetch error messages per-browser:
+ *
+ * Chrome:  Failed to fetch
+ * Edge:    Failed to Fetch
+ * Firefox: NetworkError when attempting to fetch resource
+ * Safari:  resource blocked by content blocker
+ */
+function getNativeFetchImplementation() {
+  if (cachedFetchImpl) {
+    return cachedFetchImpl;
+  }
+
+  /* eslint-disable @typescript-eslint/unbound-method */
+
+  // Fast path to avoid DOM I/O
+  if (isNativeFetch(WINDOW.fetch)) {
+    return (cachedFetchImpl = WINDOW.fetch.bind(WINDOW));
+  }
+
+  const document = WINDOW.document;
+  let fetchImpl = WINDOW.fetch;
+  // eslint-disable-next-line deprecation/deprecation
+  if (document && typeof document.createElement === 'function') {
+    try {
+      const sandbox = document.createElement('iframe');
+      sandbox.hidden = true;
+      document.head.appendChild(sandbox);
+      const contentWindow = sandbox.contentWindow;
+      if (contentWindow && contentWindow.fetch) {
+        fetchImpl = contentWindow.fetch;
+      }
+      document.head.removeChild(sandbox);
+    } catch (e) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);
+    }
+  }
+
+  return (cachedFetchImpl = fetchImpl.bind(WINDOW));
+  /* eslint-enable @typescript-eslint/unbound-method */
+}
+
+/** Clears cached fetch impl */
+function clearCachedFetchImplementation() {
+  cachedFetchImpl = undefined;
+}
+
+export { clearCachedFetchImplementation, getNativeFetchImplementation };
+//# sourceMappingURL=utils.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/transports/xhr.js b/parent_dir/node_modules/sentry/browser/esm/transports/xhr.js
new file mode 100644
index 0000000..4cb34a0
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/transports/xhr.js
@@ -0,0 +1,52 @@
+import { createTransport } from '@sentry/core';
+import { SyncPromise } from '@sentry/utils';
+
+/**
+ * The DONE ready state for XmlHttpRequest
+ *
+ * Defining it here as a constant b/c XMLHttpRequest.DONE is not always defined
+ * (e.g. during testing, it is `undefined`)
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState}
+ */
+const XHR_READYSTATE_DONE = 4;
+
+/**
+ * Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.
+ */
+function makeXHRTransport(options) {
+  function makeRequest(request) {
+    return new SyncPromise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+
+      xhr.onerror = reject;
+
+      xhr.onreadystatechange = () => {
+        if (xhr.readyState === XHR_READYSTATE_DONE) {
+          resolve({
+            statusCode: xhr.status,
+            headers: {
+              'x-sentry-rate-limits': xhr.getResponseHeader('X-Sentry-Rate-Limits'),
+              'retry-after': xhr.getResponseHeader('Retry-After'),
+            },
+          });
+        }
+      };
+
+      xhr.open('POST', options.url);
+
+      for (const header in options.headers) {
+        if (Object.prototype.hasOwnProperty.call(options.headers, header)) {
+          xhr.setRequestHeader(header, options.headers[header]);
+        }
+      }
+
+      xhr.send(request.body);
+    });
+  }
+
+  return createTransport(options, makeRequest);
+}
+
+export { makeXHRTransport };
+//# sourceMappingURL=xhr.js.map
diff --git a/parent_dir/node_modules/sentry/browser/esm/userfeedback.js b/parent_dir/node_modules/sentry/browser/esm/userfeedback.js
new file mode 100644
index 0000000..4765c98
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/esm/userfeedback.js
@@ -0,0 +1,41 @@
+import { dsnToString, createEnvelope } from '@sentry/utils';
+
+/**
+ * Creates an envelope from a user feedback.
+ */
+function createUserFeedbackEnvelope(
+  feedback,
+  {
+    metadata,
+    tunnel,
+    dsn,
+  }
+
+,
+) {
+  const headers = {
+    event_id: feedback.event_id,
+    sent_at: new Date().toISOString(),
+    ...(metadata &&
+      metadata.sdk && {
+        sdk: {
+          name: metadata.sdk.name,
+          version: metadata.sdk.version,
+        },
+      }),
+    ...(!!tunnel && !!dsn && { dsn: dsnToString(dsn) }),
+  };
+  const item = createUserFeedbackEnvelopeItem(feedback);
+
+  return createEnvelope(headers, [item]);
+}
+
+function createUserFeedbackEnvelopeItem(feedback) {
+  const feedbackHeaders = {
+    type: 'user_report',
+  };
+  return [feedbackHeaders, feedback];
+}
+
+export { createUserFeedbackEnvelope };
+//# sourceMappingURL=userfeedback.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/backgroundtab.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/backgroundtab.js
new file mode 100644
index 0000000..62c1d20
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/backgroundtab.js
@@ -0,0 +1,36 @@
+import { getActiveTransaction } from '@sentry/core';
+import { logger } from '@sentry/utils';
+import { WINDOW } from './types.js';
+
+/**
+ * Add a listener that cancels and finishes a transaction when the global
+ * document is hidden.
+ */
+function registerBackgroundTabDetection() {
+  if (WINDOW && WINDOW.document) {
+    WINDOW.document.addEventListener('visibilitychange', () => {
+      const activeTransaction = getActiveTransaction() ;
+      if (WINDOW.document.hidden && activeTransaction) {
+        const statusType = 'cancelled';
+
+        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+          logger.log(
+            `[Tracing] Transaction: ${statusType} -> since tab moved to the background, op: ${activeTransaction.op}`,
+          );
+        // We should not set status if it is already set, this prevent important statuses like
+        // error or data loss from being overwritten on transaction.
+        if (!activeTransaction.status) {
+          activeTransaction.setStatus(statusType);
+        }
+        activeTransaction.setTag('visibilitychange', 'document.hidden');
+        activeTransaction.finish();
+      }
+    });
+  } else {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.warn('[Tracing] Could not set up background tab detection due to lack of global document');
+  }
+}
+
+export { registerBackgroundTabDetection };
+//# sourceMappingURL=backgroundtab.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/browsertracing.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/browsertracing.js
new file mode 100644
index 0000000..caf2bc3
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/browsertracing.js
@@ -0,0 +1,319 @@
+import { TRACING_DEFAULTS, addTracingExtensions, startIdleTransaction, getActiveTransaction } from '@sentry/core';
+import { logger, tracingContextFromHeaders, getDomElement } from '@sentry/utils';
+import { registerBackgroundTabDetection } from './backgroundtab.js';
+import { startTrackingWebVitals, startTrackingLongTasks, startTrackingInteractions, addPerformanceEntries } from './metrics/index.js';
+import { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './request.js';
+import { instrumentRoutingWithDefaults } from './router.js';
+import { WINDOW } from './types.js';
+
+const BROWSER_TRACING_INTEGRATION_ID = 'BrowserTracing';
+
+/** Options for Browser Tracing integration */
+
+const DEFAULT_BROWSER_TRACING_OPTIONS = {
+  ...TRACING_DEFAULTS,
+  markBackgroundTransactions: true,
+  routingInstrumentation: instrumentRoutingWithDefaults,
+  startTransactionOnLocationChange: true,
+  startTransactionOnPageLoad: true,
+  enableLongTask: true,
+  _experiments: {},
+  ...defaultRequestInstrumentationOptions,
+};
+
+/**
+ * The Browser Tracing integration automatically instruments browser pageload/navigation
+ * actions as transactions, and captures requests, metrics and errors as spans.
+ *
+ * The integration can be configured with a variety of options, and can be extended to use
+ * any routing library. This integration uses {@see IdleTransaction} to create transactions.
+ */
+class BrowserTracing  {
+  // This class currently doesn't have a static `id` field like the other integration classes, because it prevented
+  // @sentry/tracing from being treeshaken. Tree shakers do not like static fields, because they behave like side effects.
+  // TODO: Come up with a better plan, than using static fields on integration classes, and use that plan on all
+  // integrations.
+
+  /** Browser Tracing integration options */
+
+  /**
+   * @inheritDoc
+   */
+
+   constructor(_options) {
+    this.name = BROWSER_TRACING_INTEGRATION_ID;
+    this._hasSetTracePropagationTargets = false;
+
+    addTracingExtensions();
+
+    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+      this._hasSetTracePropagationTargets = !!(
+        _options &&
+        // eslint-disable-next-line deprecation/deprecation
+        (_options.tracePropagationTargets || _options.tracingOrigins)
+      );
+    }
+
+    this.options = {
+      ...DEFAULT_BROWSER_TRACING_OPTIONS,
+      ..._options,
+    };
+
+    // Special case: enableLongTask can be set in _experiments
+    // TODO (v8): Remove this in v8
+    if (this.options._experiments.enableLongTask !== undefined) {
+      this.options.enableLongTask = this.options._experiments.enableLongTask;
+    }
+
+    // TODO (v8): remove this block after tracingOrigins is removed
+    // Set tracePropagationTargets to tracingOrigins if specified by the user
+    // In case both are specified, tracePropagationTargets takes precedence
+    // eslint-disable-next-line deprecation/deprecation
+    if (_options && !_options.tracePropagationTargets && _options.tracingOrigins) {
+      // eslint-disable-next-line deprecation/deprecation
+      this.options.tracePropagationTargets = _options.tracingOrigins;
+    }
+
+    this._collectWebVitals = startTrackingWebVitals();
+    if (this.options.enableLongTask) {
+      startTrackingLongTasks();
+    }
+    if (this.options._experiments.enableInteractions) {
+      startTrackingInteractions();
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setupOnce(_, getCurrentHub) {
+    this._getCurrentHub = getCurrentHub;
+    const hub = getCurrentHub();
+    const client = hub.getClient();
+    const clientOptions = client && client.getOptions();
+
+    const {
+      routingInstrumentation: instrumentRouting,
+      startTransactionOnLocationChange,
+      startTransactionOnPageLoad,
+      markBackgroundTransactions,
+      traceFetch,
+      traceXHR,
+      shouldCreateSpanForRequest,
+      enableHTTPTimings,
+      _experiments,
+    } = this.options;
+
+    const clientOptionsTracePropagationTargets = clientOptions && clientOptions.tracePropagationTargets;
+    // There are three ways to configure tracePropagationTargets:
+    // 1. via top level client option `tracePropagationTargets`
+    // 2. via BrowserTracing option `tracePropagationTargets`
+    // 3. via BrowserTracing option `tracingOrigins` (deprecated)
+    //
+    // To avoid confusion, favour top level client option `tracePropagationTargets`, and fallback to
+    // BrowserTracing option `tracePropagationTargets` and then `tracingOrigins` (deprecated).
+    // This is done as it minimizes bundle size (we don't have to have undefined checks).
+    //
+    // If both 1 and either one of 2 or 3 are set (from above), we log out a warning.
+    // eslint-disable-next-line deprecation/deprecation
+    const tracePropagationTargets = clientOptionsTracePropagationTargets || this.options.tracePropagationTargets;
+    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && this._hasSetTracePropagationTargets && clientOptionsTracePropagationTargets) {
+      logger.warn(
+        '[Tracing] The `tracePropagationTargets` option was set in the BrowserTracing integration and top level `Sentry.init`. The top level `Sentry.init` value is being used.',
+      );
+    }
+
+    instrumentRouting(
+      (context) => {
+        const transaction = this._createRouteTransaction(context);
+
+        this.options._experiments.onStartRouteTransaction &&
+          this.options._experiments.onStartRouteTransaction(transaction, context, getCurrentHub);
+
+        return transaction;
+      },
+      startTransactionOnPageLoad,
+      startTransactionOnLocationChange,
+    );
+
+    if (markBackgroundTransactions) {
+      registerBackgroundTabDetection();
+    }
+
+    if (_experiments.enableInteractions) {
+      this._registerInteractionListener();
+    }
+
+    instrumentOutgoingRequests({
+      traceFetch,
+      traceXHR,
+      tracePropagationTargets,
+      shouldCreateSpanForRequest,
+      enableHTTPTimings,
+    });
+  }
+
+  /** Create routing idle transaction. */
+   _createRouteTransaction(context) {
+    if (!this._getCurrentHub) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        logger.warn(`[Tracing] Did not create ${context.op} transaction because _getCurrentHub is invalid.`);
+      return undefined;
+    }
+
+    const hub = this._getCurrentHub();
+
+    const { beforeNavigate, idleTimeout, finalTimeout, heartbeatInterval } = this.options;
+
+    const isPageloadTransaction = context.op === 'pageload';
+
+    const sentryTrace = isPageloadTransaction ? getMetaContent('sentry-trace') : '';
+    const baggage = isPageloadTransaction ? getMetaContent('baggage') : '';
+    const { traceparentData, dynamicSamplingContext, propagationContext } = tracingContextFromHeaders(
+      sentryTrace,
+      baggage,
+    );
+
+    const expandedContext = {
+      ...context,
+      ...traceparentData,
+      metadata: {
+        ...context.metadata,
+        dynamicSamplingContext: traceparentData && !dynamicSamplingContext ? {} : dynamicSamplingContext,
+      },
+      trimEnd: true,
+    };
+
+    const modifiedContext = typeof beforeNavigate === 'function' ? beforeNavigate(expandedContext) : expandedContext;
+
+    // For backwards compatibility reasons, beforeNavigate can return undefined to "drop" the transaction (prevent it
+    // from being sent to Sentry).
+    const finalContext = modifiedContext === undefined ? { ...expandedContext, sampled: false } : modifiedContext;
+
+    // If `beforeNavigate` set a custom name, record that fact
+    finalContext.metadata =
+      finalContext.name !== expandedContext.name
+        ? { ...finalContext.metadata, source: 'custom' }
+        : finalContext.metadata;
+
+    this._latestRouteName = finalContext.name;
+    this._latestRouteSource = finalContext.metadata && finalContext.metadata.source;
+
+    if (finalContext.sampled === false) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        logger.log(`[Tracing] Will not send ${finalContext.op} transaction because of beforeNavigate.`);
+    }
+
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Starting ${finalContext.op} transaction on scope`);
+
+    const { location } = WINDOW;
+
+    const idleTransaction = startIdleTransaction(
+      hub,
+      finalContext,
+      idleTimeout,
+      finalTimeout,
+      true,
+      { location }, // for use in the tracesSampler
+      heartbeatInterval,
+    );
+
+    const scope = hub.getScope();
+
+    // If it's a pageload and there is a meta tag set
+    // use the traceparentData as the propagation context
+    if (isPageloadTransaction && traceparentData) {
+      scope.setPropagationContext(propagationContext);
+    } else {
+      // Navigation transactions should set a new propagation context based on the
+      // created idle transaction.
+      scope.setPropagationContext({
+        traceId: idleTransaction.traceId,
+        spanId: idleTransaction.spanId,
+        parentSpanId: idleTransaction.parentSpanId,
+        sampled: idleTransaction.sampled,
+      });
+    }
+
+    idleTransaction.registerBeforeFinishCallback(transaction => {
+      this._collectWebVitals();
+      addPerformanceEntries(transaction);
+    });
+
+    return idleTransaction ;
+  }
+
+  /** Start listener for interaction transactions */
+   _registerInteractionListener() {
+    let inflightInteractionTransaction;
+    const registerInteractionTransaction = () => {
+      const { idleTimeout, finalTimeout, heartbeatInterval } = this.options;
+      const op = 'ui.action.click';
+
+      const currentTransaction = getActiveTransaction();
+      if (currentTransaction && currentTransaction.op && ['navigation', 'pageload'].includes(currentTransaction.op)) {
+        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+          logger.warn(
+            `[Tracing] Did not create ${op} transaction because a pageload or navigation transaction is in progress.`,
+          );
+        return undefined;
+      }
+
+      if (inflightInteractionTransaction) {
+        inflightInteractionTransaction.setFinishReason('interactionInterrupted');
+        inflightInteractionTransaction.finish();
+        inflightInteractionTransaction = undefined;
+      }
+
+      if (!this._getCurrentHub) {
+        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`[Tracing] Did not create ${op} transaction because _getCurrentHub is invalid.`);
+        return undefined;
+      }
+
+      if (!this._latestRouteName) {
+        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+          logger.warn(`[Tracing] Did not create ${op} transaction because _latestRouteName is missing.`);
+        return undefined;
+      }
+
+      const hub = this._getCurrentHub();
+      const { location } = WINDOW;
+
+      const context = {
+        name: this._latestRouteName,
+        op,
+        trimEnd: true,
+        metadata: {
+          source: this._latestRouteSource || 'url',
+        },
+      };
+
+      inflightInteractionTransaction = startIdleTransaction(
+        hub,
+        context,
+        idleTimeout,
+        finalTimeout,
+        true,
+        { location }, // for use in the tracesSampler
+        heartbeatInterval,
+      );
+    };
+
+    ['click'].forEach(type => {
+      addEventListener(type, registerInteractionTransaction, { once: false, capture: true });
+    });
+  }
+}
+
+/** Returns the value of a meta tag */
+function getMetaContent(metaName) {
+  // Can't specify generic to `getDomElement` because tracing can be used
+  // in a variety of environments, have to disable `no-unsafe-member-access`
+  // as a result.
+  const metaTag = getDomElement(`meta[name=${metaName}]`);
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  return metaTag ? metaTag.getAttribute('content') : undefined;
+}
+
+export { BROWSER_TRACING_INTEGRATION_ID, BrowserTracing, getMetaContent };
+//# sourceMappingURL=browsertracing.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/metrics/index.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/metrics/index.js
new file mode 100644
index 0000000..9a09c6a
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/metrics/index.js
@@ -0,0 +1,492 @@
+import { getActiveTransaction } from '@sentry/core';
+import { browserPerformanceTimeOrigin, logger, htmlTreeAsString } from '@sentry/utils';
+import { WINDOW } from '../types.js';
+import { onCLS } from '../web-vitals/getCLS.js';
+import { onFID } from '../web-vitals/getFID.js';
+import { onLCP } from '../web-vitals/getLCP.js';
+import { getVisibilityWatcher } from '../web-vitals/lib/getVisibilityWatcher.js';
+import { observe } from '../web-vitals/lib/observe.js';
+import { _startChild, isMeasurementValue } from './utils.js';
+
+/**
+ * Converts from milliseconds to seconds
+ * @param time time in ms
+ */
+function msToSec(time) {
+  return time / 1000;
+}
+
+function getBrowserPerformanceAPI() {
+  // @ts-expect-error we want to make sure all of these are available, even if TS is sure they are
+  return WINDOW && WINDOW.addEventListener && WINDOW.performance;
+}
+
+let _performanceCursor = 0;
+
+let _measurements = {};
+let _lcpEntry;
+let _clsEntry;
+
+/**
+ * Start tracking web vitals
+ *
+ * @returns A function that forces web vitals collection
+ */
+function startTrackingWebVitals() {
+  const performance = getBrowserPerformanceAPI();
+  if (performance && browserPerformanceTimeOrigin) {
+    // @ts-expect-error we want to make sure all of these are available, even if TS is sure they are
+    if (performance.mark) {
+      WINDOW.performance.mark('sentry-tracing-init');
+    }
+    _trackFID();
+    const clsCallback = _trackCLS();
+    const lcpCallback = _trackLCP();
+
+    return () => {
+      if (clsCallback) {
+        clsCallback();
+      }
+      if (lcpCallback) {
+        lcpCallback();
+      }
+    };
+  }
+
+  return () => undefined;
+}
+
+/**
+ * Start tracking long tasks.
+ */
+function startTrackingLongTasks() {
+  const entryHandler = (entries) => {
+    for (const entry of entries) {
+      const transaction = getActiveTransaction() ;
+      if (!transaction) {
+        return;
+      }
+      const startTime = msToSec((browserPerformanceTimeOrigin ) + entry.startTime);
+      const duration = msToSec(entry.duration);
+
+      transaction.startChild({
+        description: 'Main UI thread blocked',
+        op: 'ui.long-task',
+        origin: 'auto.ui.browser.metrics',
+        startTimestamp: startTime,
+        endTimestamp: startTime + duration,
+      });
+    }
+  };
+
+  observe('longtask', entryHandler);
+}
+
+/**
+ * Start tracking interaction events.
+ */
+function startTrackingInteractions() {
+  const entryHandler = (entries) => {
+    for (const entry of entries) {
+      const transaction = getActiveTransaction() ;
+      if (!transaction) {
+        return;
+      }
+
+      if (entry.name === 'click') {
+        const startTime = msToSec((browserPerformanceTimeOrigin ) + entry.startTime);
+        const duration = msToSec(entry.duration);
+
+        transaction.startChild({
+          description: htmlTreeAsString(entry.target),
+          op: `ui.interaction.${entry.name}`,
+          origin: 'auto.ui.browser.metrics',
+          startTimestamp: startTime,
+          endTimestamp: startTime + duration,
+        });
+      }
+    }
+  };
+
+  observe('event', entryHandler, { durationThreshold: 0 });
+}
+
+/** Starts tracking the Cumulative Layout Shift on the current page. */
+function _trackCLS() {
+  // See:
+  // https://web.dev/evolving-cls/
+  // https://web.dev/cls-web-tooling/
+  return onCLS(metric => {
+    const entry = metric.entries.pop();
+    if (!entry) {
+      return;
+    }
+
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding CLS');
+    _measurements['cls'] = { value: metric.value, unit: '' };
+    _clsEntry = entry ;
+  });
+}
+
+/** Starts tracking the Largest Contentful Paint on the current page. */
+function _trackLCP() {
+  return onLCP(metric => {
+    const entry = metric.entries.pop();
+    if (!entry) {
+      return;
+    }
+
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding LCP');
+    _measurements['lcp'] = { value: metric.value, unit: 'millisecond' };
+    _lcpEntry = entry ;
+  });
+}
+
+/** Starts tracking the First Input Delay on the current page. */
+function _trackFID() {
+  onFID(metric => {
+    const entry = metric.entries.pop();
+    if (!entry) {
+      return;
+    }
+
+    const timeOrigin = msToSec(browserPerformanceTimeOrigin );
+    const startTime = msToSec(entry.startTime);
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding FID');
+    _measurements['fid'] = { value: metric.value, unit: 'millisecond' };
+    _measurements['mark.fid'] = { value: timeOrigin + startTime, unit: 'second' };
+  });
+}
+
+/** Add performance related spans to a transaction */
+function addPerformanceEntries(transaction) {
+  const performance = getBrowserPerformanceAPI();
+  if (!performance || !WINDOW.performance.getEntries || !browserPerformanceTimeOrigin) {
+    // Gatekeeper if performance API not available
+    return;
+  }
+
+  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] Adding & adjusting spans using Performance API');
+  const timeOrigin = msToSec(browserPerformanceTimeOrigin);
+
+  const performanceEntries = performance.getEntries();
+
+  let responseStartTimestamp;
+  let requestStartTimestamp;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  performanceEntries.slice(_performanceCursor).forEach((entry) => {
+    const startTime = msToSec(entry.startTime);
+    const duration = msToSec(entry.duration);
+
+    if (transaction.op === 'navigation' && timeOrigin + startTime < transaction.startTimestamp) {
+      return;
+    }
+
+    switch (entry.entryType) {
+      case 'navigation': {
+        _addNavigationSpans(transaction, entry, timeOrigin);
+        responseStartTimestamp = timeOrigin + msToSec(entry.responseStart);
+        requestStartTimestamp = timeOrigin + msToSec(entry.requestStart);
+        break;
+      }
+      case 'mark':
+      case 'paint':
+      case 'measure': {
+        _addMeasureSpans(transaction, entry, startTime, duration, timeOrigin);
+
+        // capture web vitals
+        const firstHidden = getVisibilityWatcher();
+        // Only report if the page wasn't hidden prior to the web vital.
+        const shouldRecord = entry.startTime < firstHidden.firstHiddenTime;
+
+        if (entry.name === 'first-paint' && shouldRecord) {
+          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding FP');
+          _measurements['fp'] = { value: entry.startTime, unit: 'millisecond' };
+        }
+        if (entry.name === 'first-contentful-paint' && shouldRecord) {
+          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding FCP');
+          _measurements['fcp'] = { value: entry.startTime, unit: 'millisecond' };
+        }
+        break;
+      }
+      case 'resource': {
+        const resourceName = (entry.name ).replace(WINDOW.location.origin, '');
+        _addResourceSpans(transaction, entry, resourceName, startTime, duration, timeOrigin);
+        break;
+      }
+      // Ignore other entry types.
+    }
+  });
+
+  _performanceCursor = Math.max(performanceEntries.length - 1, 0);
+
+  _trackNavigator(transaction);
+
+  // Measurements are only available for pageload transactions
+  if (transaction.op === 'pageload') {
+    // Generate TTFB (Time to First Byte), which measured as the time between the beginning of the transaction and the
+    // start of the response in milliseconds
+    if (typeof responseStartTimestamp === 'number') {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding TTFB');
+      _measurements['ttfb'] = {
+        value: (responseStartTimestamp - transaction.startTimestamp) * 1000,
+        unit: 'millisecond',
+      };
+
+      if (typeof requestStartTimestamp === 'number' && requestStartTimestamp <= responseStartTimestamp) {
+        // Capture the time spent making the request and receiving the first byte of the response.
+        // This is the time between the start of the request and the start of the response in milliseconds.
+        _measurements['ttfb.requestTime'] = {
+          value: (responseStartTimestamp - requestStartTimestamp) * 1000,
+          unit: 'millisecond',
+        };
+      }
+    }
+
+    ['fcp', 'fp', 'lcp'].forEach(name => {
+      if (!_measurements[name] || timeOrigin >= transaction.startTimestamp) {
+        return;
+      }
+      // The web vitals, fcp, fp, lcp, and ttfb, all measure relative to timeOrigin.
+      // Unfortunately, timeOrigin is not captured within the transaction span data, so these web vitals will need
+      // to be adjusted to be relative to transaction.startTimestamp.
+      const oldValue = _measurements[name].value;
+      const measurementTimestamp = timeOrigin + msToSec(oldValue);
+
+      // normalizedValue should be in milliseconds
+      const normalizedValue = Math.abs((measurementTimestamp - transaction.startTimestamp) * 1000);
+      const delta = normalizedValue - oldValue;
+
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        logger.log(`[Measurements] Normalized ${name} from ${oldValue} to ${normalizedValue} (${delta})`);
+      _measurements[name].value = normalizedValue;
+    });
+
+    const fidMark = _measurements['mark.fid'];
+    if (fidMark && _measurements['fid']) {
+      // create span for FID
+      _startChild(transaction, {
+        description: 'first input delay',
+        endTimestamp: fidMark.value + msToSec(_measurements['fid'].value),
+        op: 'ui.action',
+        origin: 'auto.ui.browser.metrics',
+        startTimestamp: fidMark.value,
+      });
+
+      // Delete mark.fid as we don't want it to be part of final payload
+      delete _measurements['mark.fid'];
+    }
+
+    // If FCP is not recorded we should not record the cls value
+    // according to the new definition of CLS.
+    if (!('fcp' in _measurements)) {
+      delete _measurements.cls;
+    }
+
+    Object.keys(_measurements).forEach(measurementName => {
+      transaction.setMeasurement(
+        measurementName,
+        _measurements[measurementName].value,
+        _measurements[measurementName].unit,
+      );
+    });
+
+    _tagMetricInfo(transaction);
+  }
+
+  _lcpEntry = undefined;
+  _clsEntry = undefined;
+  _measurements = {};
+}
+
+/** Create measure related spans */
+function _addMeasureSpans(
+  transaction,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  entry,
+  startTime,
+  duration,
+  timeOrigin,
+) {
+  const measureStartTimestamp = timeOrigin + startTime;
+  const measureEndTimestamp = measureStartTimestamp + duration;
+
+  _startChild(transaction, {
+    description: entry.name ,
+    endTimestamp: measureEndTimestamp,
+    op: entry.entryType ,
+    origin: 'auto.resource.browser.metrics',
+    startTimestamp: measureStartTimestamp,
+  });
+
+  return measureStartTimestamp;
+}
+
+/** Instrument navigation entries */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _addNavigationSpans(transaction, entry, timeOrigin) {
+  ['unloadEvent', 'redirect', 'domContentLoadedEvent', 'loadEvent', 'connect'].forEach(event => {
+    _addPerformanceNavigationTiming(transaction, entry, event, timeOrigin);
+  });
+  _addPerformanceNavigationTiming(transaction, entry, 'secureConnection', timeOrigin, 'TLS/SSL', 'connectEnd');
+  _addPerformanceNavigationTiming(transaction, entry, 'fetch', timeOrigin, 'cache', 'domainLookupStart');
+  _addPerformanceNavigationTiming(transaction, entry, 'domainLookup', timeOrigin, 'DNS');
+  _addRequest(transaction, entry, timeOrigin);
+}
+
+/** Create performance navigation related spans */
+function _addPerformanceNavigationTiming(
+  transaction,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  entry,
+  event,
+  timeOrigin,
+  description,
+  eventEnd,
+) {
+  const end = eventEnd ? (entry[eventEnd] ) : (entry[`${event}End`] );
+  const start = entry[`${event}Start`] ;
+  if (!start || !end) {
+    return;
+  }
+  _startChild(transaction, {
+    op: 'browser',
+    origin: 'auto.browser.browser.metrics',
+    description: description || event,
+    startTimestamp: timeOrigin + msToSec(start),
+    endTimestamp: timeOrigin + msToSec(end),
+  });
+}
+
+/** Create request and response related spans */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _addRequest(transaction, entry, timeOrigin) {
+  _startChild(transaction, {
+    op: 'browser',
+    origin: 'auto.browser.browser.metrics',
+    description: 'request',
+    startTimestamp: timeOrigin + msToSec(entry.requestStart ),
+    endTimestamp: timeOrigin + msToSec(entry.responseEnd ),
+  });
+
+  _startChild(transaction, {
+    op: 'browser',
+    origin: 'auto.browser.browser.metrics',
+    description: 'response',
+    startTimestamp: timeOrigin + msToSec(entry.responseStart ),
+    endTimestamp: timeOrigin + msToSec(entry.responseEnd ),
+  });
+}
+
+/** Create resource-related spans */
+function _addResourceSpans(
+  transaction,
+  entry,
+  resourceName,
+  startTime,
+  duration,
+  timeOrigin,
+) {
+  // we already instrument based on fetch and xhr, so we don't need to
+  // duplicate spans here.
+  if (entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch') {
+    return;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const data = {};
+  if ('transferSize' in entry) {
+    data['http.response_transfer_size'] = entry.transferSize;
+  }
+  if ('encodedBodySize' in entry) {
+    data['http.response_content_length'] = entry.encodedBodySize;
+  }
+  if ('decodedBodySize' in entry) {
+    data['http.decoded_response_content_length'] = entry.decodedBodySize;
+  }
+  if ('renderBlockingStatus' in entry) {
+    data['resource.render_blocking_status'] = entry.renderBlockingStatus;
+  }
+
+  const startTimestamp = timeOrigin + startTime;
+  const endTimestamp = startTimestamp + duration;
+
+  _startChild(transaction, {
+    description: resourceName,
+    endTimestamp,
+    op: entry.initiatorType ? `resource.${entry.initiatorType}` : 'resource.other',
+    origin: 'auto.resource.browser.metrics',
+    startTimestamp,
+    data,
+  });
+}
+
+/**
+ * Capture the information of the user agent.
+ */
+function _trackNavigator(transaction) {
+  const navigator = WINDOW.navigator ;
+  if (!navigator) {
+    return;
+  }
+
+  // track network connectivity
+  const connection = navigator.connection;
+  if (connection) {
+    if (connection.effectiveType) {
+      transaction.setTag('effectiveConnectionType', connection.effectiveType);
+    }
+
+    if (connection.type) {
+      transaction.setTag('connectionType', connection.type);
+    }
+
+    if (isMeasurementValue(connection.rtt)) {
+      _measurements['connection.rtt'] = { value: connection.rtt, unit: 'millisecond' };
+    }
+  }
+
+  if (isMeasurementValue(navigator.deviceMemory)) {
+    transaction.setTag('deviceMemory', `${navigator.deviceMemory} GB`);
+  }
+
+  if (isMeasurementValue(navigator.hardwareConcurrency)) {
+    transaction.setTag('hardwareConcurrency', String(navigator.hardwareConcurrency));
+  }
+}
+
+/** Add LCP / CLS data to transaction to allow debugging */
+function _tagMetricInfo(transaction) {
+  if (_lcpEntry) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding LCP Data');
+
+    // Capture Properties of the LCP element that contributes to the LCP.
+
+    if (_lcpEntry.element) {
+      transaction.setTag('lcp.element', htmlTreeAsString(_lcpEntry.element));
+    }
+
+    if (_lcpEntry.id) {
+      transaction.setTag('lcp.id', _lcpEntry.id);
+    }
+
+    if (_lcpEntry.url) {
+      // Trim URL to the first 200 characters.
+      transaction.setTag('lcp.url', _lcpEntry.url.trim().slice(0, 200));
+    }
+
+    transaction.setTag('lcp.size', _lcpEntry.size);
+  }
+
+  // See: https://developer.mozilla.org/en-US/docs/Web/API/LayoutShift
+  if (_clsEntry && _clsEntry.sources) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding CLS Data');
+    _clsEntry.sources.forEach((source, index) =>
+      transaction.setTag(`cls.source.${index + 1}`, htmlTreeAsString(source.node)),
+    );
+  }
+}
+
+export { _addMeasureSpans, _addResourceSpans, addPerformanceEntries, startTrackingInteractions, startTrackingLongTasks, startTrackingWebVitals };
+//# sourceMappingURL=index.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/metrics/utils.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/metrics/utils.js
new file mode 100644
index 0000000..ecb4873
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/metrics/utils.js
@@ -0,0 +1,25 @@
+/**
+ * Checks if a given value is a valid measurement value.
+ */
+function isMeasurementValue(value) {
+  return typeof value === 'number' && isFinite(value);
+}
+
+/**
+ * Helper function to start child on transactions. This function will make sure that the transaction will
+ * use the start timestamp of the created child span if it is earlier than the transactions actual
+ * start timestamp.
+ */
+function _startChild(transaction, { startTimestamp, ...ctx }) {
+  if (startTimestamp && transaction.startTimestamp > startTimestamp) {
+    transaction.startTimestamp = startTimestamp;
+  }
+
+  return transaction.startChild({
+    startTimestamp,
+    ...ctx,
+  });
+}
+
+export { _startChild, isMeasurementValue };
+//# sourceMappingURL=utils.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/request.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/request.js
new file mode 100644
index 0000000..d7b785c
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/request.js
@@ -0,0 +1,434 @@
+import { hasTracingEnabled, getCurrentHub, getDynamicSamplingContextFromClient } from '@sentry/core';
+import { addInstrumentationHandler, browserPerformanceTimeOrigin, generateSentryTraceHeader, dynamicSamplingContextToSentryBaggageHeader, isInstanceOf, BAGGAGE_HEADER_NAME, SENTRY_XHR_DATA_KEY, stringMatchesSomePattern } from '@sentry/utils';
+
+/* eslint-disable max-lines */
+
+const DEFAULT_TRACE_PROPAGATION_TARGETS = ['localhost', /^\/(?!\/)/];
+
+/** Options for Request Instrumentation */
+
+const defaultRequestInstrumentationOptions = {
+  traceFetch: true,
+  traceXHR: true,
+  enableHTTPTimings: true,
+  // TODO (v8): Remove this property
+  tracingOrigins: DEFAULT_TRACE_PROPAGATION_TARGETS,
+  tracePropagationTargets: DEFAULT_TRACE_PROPAGATION_TARGETS,
+};
+
+/** Registers span creators for xhr and fetch requests  */
+function instrumentOutgoingRequests(_options) {
+  const {
+    traceFetch,
+    traceXHR,
+    // eslint-disable-next-line deprecation/deprecation
+    tracePropagationTargets,
+    // eslint-disable-next-line deprecation/deprecation
+    tracingOrigins,
+    shouldCreateSpanForRequest,
+    enableHTTPTimings,
+  } = {
+    traceFetch: defaultRequestInstrumentationOptions.traceFetch,
+    traceXHR: defaultRequestInstrumentationOptions.traceXHR,
+    ..._options,
+  };
+
+  const shouldCreateSpan =
+    typeof shouldCreateSpanForRequest === 'function' ? shouldCreateSpanForRequest : (_) => true;
+
+  // TODO(v8) Remove tracingOrigins here
+  // The only reason we're passing it in here is because this instrumentOutgoingRequests function is publicly exported
+  // and we don't want to break the API. We can remove it in v8.
+  const shouldAttachHeadersWithTargets = (url) =>
+    shouldAttachHeaders(url, tracePropagationTargets || tracingOrigins);
+
+  const spans = {};
+
+  if (traceFetch) {
+    addInstrumentationHandler('fetch', (handlerData) => {
+      const createdSpan = fetchCallback(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);
+      if (enableHTTPTimings && createdSpan) {
+        addHTTPTimings(createdSpan);
+      }
+    });
+  }
+
+  if (traceXHR) {
+    addInstrumentationHandler('xhr', (handlerData) => {
+      const createdSpan = xhrCallback(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);
+      if (enableHTTPTimings && createdSpan) {
+        addHTTPTimings(createdSpan);
+      }
+    });
+  }
+}
+
+function isPerformanceResourceTiming(entry) {
+  return (
+    entry.entryType === 'resource' &&
+    'initiatorType' in entry &&
+    typeof (entry ).nextHopProtocol === 'string' &&
+    (entry.initiatorType === 'fetch' || entry.initiatorType === 'xmlhttprequest')
+  );
+}
+
+/**
+ * Creates a temporary observer to listen to the next fetch/xhr resourcing timings,
+ * so that when timings hit their per-browser limit they don't need to be removed.
+ *
+ * @param span A span that has yet to be finished, must contain `url` on data.
+ */
+function addHTTPTimings(span) {
+  const url = span.data.url;
+  const observer = new PerformanceObserver(list => {
+    const entries = list.getEntries();
+    entries.forEach(entry => {
+      if (isPerformanceResourceTiming(entry) && entry.name.endsWith(url)) {
+        const spanData = resourceTimingEntryToSpanData(entry);
+        spanData.forEach(data => span.setData(...data));
+        observer.disconnect();
+      }
+    });
+  });
+  observer.observe({
+    entryTypes: ['resource'],
+  });
+}
+
+/**
+ * Converts ALPN protocol ids to name and version.
+ *
+ * (https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids)
+ * @param nextHopProtocol PerformanceResourceTiming.nextHopProtocol
+ */
+function extractNetworkProtocol(nextHopProtocol) {
+  let name = 'unknown';
+  let version = 'unknown';
+  let _name = '';
+  for (const char of nextHopProtocol) {
+    // http/1.1 etc.
+    if (char === '/') {
+      [name, version] = nextHopProtocol.split('/');
+      break;
+    }
+    // h2, h3 etc.
+    if (!isNaN(Number(char))) {
+      name = _name === 'h' ? 'http' : _name;
+      version = nextHopProtocol.split(_name)[1];
+      break;
+    }
+    _name += char;
+  }
+  if (_name === nextHopProtocol) {
+    // webrtc, ftp, etc.
+    name = _name;
+  }
+  return { name, version };
+}
+
+function getAbsoluteTime(time = 0) {
+  return ((browserPerformanceTimeOrigin || performance.timeOrigin) + time) / 1000;
+}
+
+function resourceTimingEntryToSpanData(resourceTiming) {
+  const { name, version } = extractNetworkProtocol(resourceTiming.nextHopProtocol);
+
+  const timingSpanData = [];
+
+  timingSpanData.push(['network.protocol.version', version], ['network.protocol.name', name]);
+
+  if (!browserPerformanceTimeOrigin) {
+    return timingSpanData;
+  }
+  return [
+    ...timingSpanData,
+    ['http.request.redirect_start', getAbsoluteTime(resourceTiming.redirectStart)],
+    ['http.request.fetch_start', getAbsoluteTime(resourceTiming.fetchStart)],
+    ['http.request.domain_lookup_start', getAbsoluteTime(resourceTiming.domainLookupStart)],
+    ['http.request.domain_lookup_end', getAbsoluteTime(resourceTiming.domainLookupEnd)],
+    ['http.request.connect_start', getAbsoluteTime(resourceTiming.connectStart)],
+    ['http.request.secure_connection_start', getAbsoluteTime(resourceTiming.secureConnectionStart)],
+    ['http.request.connection_end', getAbsoluteTime(resourceTiming.connectEnd)],
+    ['http.request.request_start', getAbsoluteTime(resourceTiming.requestStart)],
+    ['http.request.response_start', getAbsoluteTime(resourceTiming.responseStart)],
+    ['http.request.response_end', getAbsoluteTime(resourceTiming.responseEnd)],
+  ];
+}
+
+/**
+ * A function that determines whether to attach tracing headers to a request.
+ * This was extracted from `instrumentOutgoingRequests` to make it easier to test shouldAttachHeaders.
+ * We only export this fuction for testing purposes.
+ */
+function shouldAttachHeaders(url, tracePropagationTargets) {
+  return stringMatchesSomePattern(url, tracePropagationTargets || DEFAULT_TRACE_PROPAGATION_TARGETS);
+}
+
+/**
+ * Create and track fetch request spans
+ *
+ * @returns Span if a span was created, otherwise void.
+ */
+function fetchCallback(
+  handlerData,
+  shouldCreateSpan,
+  shouldAttachHeaders,
+  spans,
+) {
+  if (!hasTracingEnabled() || !handlerData.fetchData) {
+    return undefined;
+  }
+
+  const shouldCreateSpanResult = shouldCreateSpan(handlerData.fetchData.url);
+
+  if (handlerData.endTimestamp && shouldCreateSpanResult) {
+    const spanId = handlerData.fetchData.__span;
+    if (!spanId) return;
+
+    const span = spans[spanId];
+    if (span) {
+      if (handlerData.response) {
+        // TODO (kmclb) remove this once types PR goes through
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        span.setHttpStatus(handlerData.response.status);
+
+        const contentLength =
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          handlerData.response && handlerData.response.headers && handlerData.response.headers.get('content-length');
+
+        const contentLengthNum = parseInt(contentLength);
+        if (contentLengthNum > 0) {
+          span.setData('http.response_content_length', contentLengthNum);
+        }
+      } else if (handlerData.error) {
+        span.setStatus('internal_error');
+      }
+      span.finish();
+
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete spans[spanId];
+    }
+    return undefined;
+  }
+
+  const hub = getCurrentHub();
+  const scope = hub.getScope();
+  const client = hub.getClient();
+  const parentSpan = scope.getSpan();
+
+  const { method, url } = handlerData.fetchData;
+
+  const span =
+    shouldCreateSpanResult && parentSpan
+      ? parentSpan.startChild({
+          data: {
+            url,
+            type: 'fetch',
+            'http.method': method,
+          },
+          description: `${method} ${url}`,
+          op: 'http.client',
+          origin: 'auto.http.browser',
+        })
+      : undefined;
+
+  if (span) {
+    handlerData.fetchData.__span = span.spanId;
+    spans[span.spanId] = span;
+  }
+
+  if (shouldAttachHeaders(handlerData.fetchData.url) && client) {
+    const request = handlerData.args[0];
+
+    // In case the user hasn't set the second argument of a fetch call we default it to `{}`.
+    handlerData.args[1] = handlerData.args[1] || {};
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const options = handlerData.args[1];
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+    options.headers = addTracingHeadersToFetchRequest(request, client, scope, options, span);
+  }
+
+  return span;
+}
+
+/**
+ * Adds sentry-trace and baggage headers to the various forms of fetch headers
+ */
+function addTracingHeadersToFetchRequest(
+  request, // unknown is actually type Request but we can't export DOM types from this package,
+  client,
+  scope,
+  options
+
+,
+  requestSpan,
+) {
+  const span = requestSpan || scope.getSpan();
+
+  const transaction = span && span.transaction;
+
+  const { traceId, sampled, dsc } = scope.getPropagationContext();
+
+  const sentryTraceHeader = span ? span.toTraceparent() : generateSentryTraceHeader(traceId, undefined, sampled);
+  const dynamicSamplingContext = transaction
+    ? transaction.getDynamicSamplingContext()
+    : dsc
+    ? dsc
+    : getDynamicSamplingContextFromClient(traceId, client, scope);
+
+  const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
+
+  const headers =
+    typeof Request !== 'undefined' && isInstanceOf(request, Request) ? (request ).headers : options.headers;
+
+  if (!headers) {
+    return { 'sentry-trace': sentryTraceHeader, baggage: sentryBaggageHeader };
+  } else if (typeof Headers !== 'undefined' && isInstanceOf(headers, Headers)) {
+    const newHeaders = new Headers(headers );
+
+    newHeaders.append('sentry-trace', sentryTraceHeader);
+
+    if (sentryBaggageHeader) {
+      // If the same header is appended multiple times the browser will merge the values into a single request header.
+      // Its therefore safe to simply push a "baggage" entry, even though there might already be another baggage header.
+      newHeaders.append(BAGGAGE_HEADER_NAME, sentryBaggageHeader);
+    }
+
+    return newHeaders ;
+  } else if (Array.isArray(headers)) {
+    const newHeaders = [...headers, ['sentry-trace', sentryTraceHeader]];
+
+    if (sentryBaggageHeader) {
+      // If there are multiple entries with the same key, the browser will merge the values into a single request header.
+      // Its therefore safe to simply push a "baggage" entry, even though there might already be another baggage header.
+      newHeaders.push([BAGGAGE_HEADER_NAME, sentryBaggageHeader]);
+    }
+
+    return newHeaders ;
+  } else {
+    const existingBaggageHeader = 'baggage' in headers ? headers.baggage : undefined;
+    const newBaggageHeaders = [];
+
+    if (Array.isArray(existingBaggageHeader)) {
+      newBaggageHeaders.push(...existingBaggageHeader);
+    } else if (existingBaggageHeader) {
+      newBaggageHeaders.push(existingBaggageHeader);
+    }
+
+    if (sentryBaggageHeader) {
+      newBaggageHeaders.push(sentryBaggageHeader);
+    }
+
+    return {
+      ...(headers ),
+      'sentry-trace': sentryTraceHeader,
+      baggage: newBaggageHeaders.length > 0 ? newBaggageHeaders.join(',') : undefined,
+    };
+  }
+}
+
+/**
+ * Create and track xhr request spans
+ *
+ * @returns Span if a span was created, otherwise void.
+ */
+// eslint-disable-next-line complexity
+function xhrCallback(
+  handlerData,
+  shouldCreateSpan,
+  shouldAttachHeaders,
+  spans,
+) {
+  const xhr = handlerData.xhr;
+  const sentryXhrData = xhr && xhr[SENTRY_XHR_DATA_KEY];
+
+  if (!hasTracingEnabled() || (xhr && xhr.__sentry_own_request__) || !xhr || !sentryXhrData) {
+    return undefined;
+  }
+
+  const shouldCreateSpanResult = shouldCreateSpan(sentryXhrData.url);
+
+  // check first if the request has finished and is tracked by an existing span which should now end
+  if (handlerData.endTimestamp && shouldCreateSpanResult) {
+    const spanId = xhr.__sentry_xhr_span_id__;
+    if (!spanId) return;
+
+    const span = spans[spanId];
+    if (span) {
+      span.setHttpStatus(sentryXhrData.status_code);
+      span.finish();
+
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete spans[spanId];
+    }
+    return undefined;
+  }
+
+  const hub = getCurrentHub();
+  const scope = hub.getScope();
+  const parentSpan = scope.getSpan();
+
+  const span =
+    shouldCreateSpanResult && parentSpan
+      ? parentSpan.startChild({
+          data: {
+            ...sentryXhrData.data,
+            type: 'xhr',
+            'http.method': sentryXhrData.method,
+            url: sentryXhrData.url,
+          },
+          description: `${sentryXhrData.method} ${sentryXhrData.url}`,
+          op: 'http.client',
+          origin: 'auto.http.browser',
+        })
+      : undefined;
+
+  if (span) {
+    xhr.__sentry_xhr_span_id__ = span.spanId;
+    spans[xhr.__sentry_xhr_span_id__] = span;
+  }
+
+  if (xhr.setRequestHeader && shouldAttachHeaders(sentryXhrData.url)) {
+    if (span) {
+      const transaction = span && span.transaction;
+      const dynamicSamplingContext = transaction && transaction.getDynamicSamplingContext();
+      const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
+      setHeaderOnXhr(xhr, span.toTraceparent(), sentryBaggageHeader);
+    } else {
+      const client = hub.getClient();
+      const { traceId, sampled, dsc } = scope.getPropagationContext();
+      const sentryTraceHeader = generateSentryTraceHeader(traceId, undefined, sampled);
+      const dynamicSamplingContext =
+        dsc || (client ? getDynamicSamplingContextFromClient(traceId, client, scope) : undefined);
+      const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
+      setHeaderOnXhr(xhr, sentryTraceHeader, sentryBaggageHeader);
+    }
+  }
+
+  return span;
+}
+
+function setHeaderOnXhr(
+  xhr,
+  sentryTraceHeader,
+  sentryBaggageHeader,
+) {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    xhr.setRequestHeader('sentry-trace', sentryTraceHeader);
+    if (sentryBaggageHeader) {
+      // From MDN: "If this method is called several times with the same header, the values are merged into one single request header."
+      // We can therefore simply set a baggage header without checking what was there before
+      // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      xhr.setRequestHeader(BAGGAGE_HEADER_NAME, sentryBaggageHeader);
+    }
+  } catch (_) {
+    // Error: InvalidStateError: Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.
+  }
+}
+
+export { DEFAULT_TRACE_PROPAGATION_TARGETS, addTracingHeadersToFetchRequest, defaultRequestInstrumentationOptions, extractNetworkProtocol, fetchCallback, instrumentOutgoingRequests, shouldAttachHeaders, xhrCallback };
+//# sourceMappingURL=request.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/router.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/router.js
new file mode 100644
index 0000000..619b2dc
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/router.js
@@ -0,0 +1,66 @@
+import { logger, browserPerformanceTimeOrigin, addInstrumentationHandler } from '@sentry/utils';
+import { WINDOW } from './types.js';
+
+/**
+ * Default function implementing pageload and navigation transactions
+ */
+function instrumentRoutingWithDefaults(
+  customStartTransaction,
+  startTransactionOnPageLoad = true,
+  startTransactionOnLocationChange = true,
+) {
+  if (!WINDOW || !WINDOW.location) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Could not initialize routing instrumentation due to invalid location');
+    return;
+  }
+
+  let startingUrl = WINDOW.location.href;
+
+  let activeTransaction;
+  if (startTransactionOnPageLoad) {
+    activeTransaction = customStartTransaction({
+      name: WINDOW.location.pathname,
+      // pageload should always start at timeOrigin (and needs to be in s, not ms)
+      startTimestamp: browserPerformanceTimeOrigin ? browserPerformanceTimeOrigin / 1000 : undefined,
+      op: 'pageload',
+      origin: 'auto.pageload.browser',
+      metadata: { source: 'url' },
+    });
+  }
+
+  if (startTransactionOnLocationChange) {
+    addInstrumentationHandler('history', ({ to, from }) => {
+      /**
+       * This early return is there to account for some cases where a navigation transaction starts right after
+       * long-running pageload. We make sure that if `from` is undefined and a valid `startingURL` exists, we don't
+       * create an uneccessary navigation transaction.
+       *
+       * This was hard to duplicate, but this behavior stopped as soon as this fix was applied. This issue might also
+       * only be caused in certain development environments where the usage of a hot module reloader is causing
+       * errors.
+       */
+      if (from === undefined && startingUrl && startingUrl.indexOf(to) !== -1) {
+        startingUrl = undefined;
+        return;
+      }
+
+      if (from !== to) {
+        startingUrl = undefined;
+        if (activeTransaction) {
+          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Finishing current transaction with op: ${activeTransaction.op}`);
+          // If there's an open transaction on the scope, we need to finish it before creating an new one.
+          activeTransaction.finish();
+        }
+        activeTransaction = customStartTransaction({
+          name: WINDOW.location.pathname,
+          op: 'navigation',
+          origin: 'auto.navigation.browser',
+          metadata: { source: 'url' },
+        });
+      }
+    });
+  }
+}
+
+export { instrumentRoutingWithDefaults };
+//# sourceMappingURL=router.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/types.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/types.js
new file mode 100644
index 0000000..b01c87e
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/types.js
@@ -0,0 +1,6 @@
+import { GLOBAL_OBJ } from '@sentry/utils';
+
+const WINDOW = GLOBAL_OBJ ;
+
+export { WINDOW };
+//# sourceMappingURL=types.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/getCLS.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/getCLS.js
new file mode 100644
index 0000000..22f1922
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/getCLS.js
@@ -0,0 +1,105 @@
+import { bindReporter } from './lib/bindReporter.js';
+import { initMetric } from './lib/initMetric.js';
+import { observe } from './lib/observe.js';
+import { onHidden } from './lib/onHidden.js';
+
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Calculates the [CLS](https://web.dev/cls/) value for the current page and
+ * calls the `callback` function once the value is ready to be reported, along
+ * with all `layout-shift` performance entries that were used in the metric
+ * value calculation. The reported value is a `double` (corresponding to a
+ * [layout shift score](https://web.dev/cls/#layout-shift-score)).
+ *
+ * If the `reportAllChanges` configuration option is set to `true`, the
+ * `callback` function will be called as soon as the value is initially
+ * determined as well as any time the value changes throughout the page
+ * lifespan.
+ *
+ * _**Important:** CLS should be continually monitored for changes throughout
+ * the entire lifespan of a page—including if the user returns to the page after
+ * it's been hidden/backgrounded. However, since browsers often [will not fire
+ * additional callbacks once the user has backgrounded a
+ * page](https://developer.chrome.com/blog/page-lifecycle-api/#advice-hidden),
+ * `callback` is always called when the page's visibility state changes to
+ * hidden. As a result, the `callback` function might be called multiple times
+ * during the same page load._
+ */
+const onCLS = (onReport) => {
+  const metric = initMetric('CLS', 0);
+  let report;
+
+  let sessionValue = 0;
+  let sessionEntries = [];
+
+  // const handleEntries = (entries: Metric['entries']) => {
+  const handleEntries = (entries) => {
+    entries.forEach(entry => {
+      // Only count layout shifts without recent user input.
+      if (!entry.hadRecentInput) {
+        const firstSessionEntry = sessionEntries[0];
+        const lastSessionEntry = sessionEntries[sessionEntries.length - 1];
+
+        // If the entry occurred less than 1 second after the previous entry and
+        // less than 5 seconds after the first entry in the session, include the
+        // entry in the current session. Otherwise, start a new session.
+        if (
+          sessionValue &&
+          sessionEntries.length !== 0 &&
+          entry.startTime - lastSessionEntry.startTime < 1000 &&
+          entry.startTime - firstSessionEntry.startTime < 5000
+        ) {
+          sessionValue += entry.value;
+          sessionEntries.push(entry);
+        } else {
+          sessionValue = entry.value;
+          sessionEntries = [entry];
+        }
+
+        // If the current session value is larger than the current CLS value,
+        // update CLS and the entries contributing to it.
+        if (sessionValue > metric.value) {
+          metric.value = sessionValue;
+          metric.entries = sessionEntries;
+          if (report) {
+            report();
+          }
+        }
+      }
+    });
+  };
+
+  const po = observe('layout-shift', handleEntries);
+  if (po) {
+    report = bindReporter(onReport, metric);
+
+    const stopListening = () => {
+      handleEntries(po.takeRecords() );
+      report(true);
+    };
+
+    onHidden(stopListening);
+
+    return stopListening;
+  }
+
+  return;
+};
+
+export { onCLS };
+//# sourceMappingURL=getCLS.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/getFID.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/getFID.js
new file mode 100644
index 0000000..fc135c8
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/getFID.js
@@ -0,0 +1,63 @@
+import { bindReporter } from './lib/bindReporter.js';
+import { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';
+import { initMetric } from './lib/initMetric.js';
+import { observe } from './lib/observe.js';
+import { onHidden } from './lib/onHidden.js';
+
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Calculates the [FID](https://web.dev/fid/) value for the current page and
+ * calls the `callback` function once the value is ready, along with the
+ * relevant `first-input` performance entry used to determine the value. The
+ * reported value is a `DOMHighResTimeStamp`.
+ *
+ * _**Important:** since FID is only reported after the user interacts with the
+ * page, it's possible that it will not be reported for some page loads._
+ */
+const onFID = (onReport) => {
+  const visibilityWatcher = getVisibilityWatcher();
+  const metric = initMetric('FID');
+  // eslint-disable-next-line prefer-const
+  let report;
+
+  const handleEntry = (entry) => {
+    // Only report if the page wasn't hidden prior to the first input.
+    if (entry.startTime < visibilityWatcher.firstHiddenTime) {
+      metric.value = entry.processingStart - entry.startTime;
+      metric.entries.push(entry);
+      report(true);
+    }
+  };
+
+  const handleEntries = (entries) => {
+    (entries ).forEach(handleEntry);
+  };
+
+  const po = observe('first-input', handleEntries);
+  report = bindReporter(onReport, metric);
+
+  if (po) {
+    onHidden(() => {
+      handleEntries(po.takeRecords() );
+      po.disconnect();
+    }, true);
+  }
+};
+
+export { onFID };
+//# sourceMappingURL=getFID.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/getLCP.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/getLCP.js
new file mode 100644
index 0000000..0d3c610
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/getLCP.js
@@ -0,0 +1,85 @@
+import { bindReporter } from './lib/bindReporter.js';
+import { getActivationStart } from './lib/getActivationStart.js';
+import { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';
+import { initMetric } from './lib/initMetric.js';
+import { observe } from './lib/observe.js';
+import { onHidden } from './lib/onHidden.js';
+
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const reportedMetricIDs = {};
+
+/**
+ * Calculates the [LCP](https://web.dev/lcp/) value for the current page and
+ * calls the `callback` function once the value is ready (along with the
+ * relevant `largest-contentful-paint` performance entry used to determine the
+ * value). The reported value is a `DOMHighResTimeStamp`.
+ */
+const onLCP = (onReport) => {
+  const visibilityWatcher = getVisibilityWatcher();
+  const metric = initMetric('LCP');
+  let report;
+
+  const handleEntries = (entries) => {
+    const lastEntry = entries[entries.length - 1] ;
+    if (lastEntry) {
+      // The startTime attribute returns the value of the renderTime if it is
+      // not 0, and the value of the loadTime otherwise. The activationStart
+      // reference is used because LCP should be relative to page activation
+      // rather than navigation start if the page was prerendered.
+      const value = Math.max(lastEntry.startTime - getActivationStart(), 0);
+
+      // Only report if the page wasn't hidden prior to LCP.
+      if (value < visibilityWatcher.firstHiddenTime) {
+        metric.value = value;
+        metric.entries = [lastEntry];
+        report();
+      }
+    }
+  };
+
+  const po = observe('largest-contentful-paint', handleEntries);
+
+  if (po) {
+    report = bindReporter(onReport, metric);
+
+    const stopListening = () => {
+      if (!reportedMetricIDs[metric.id]) {
+        handleEntries(po.takeRecords() );
+        po.disconnect();
+        reportedMetricIDs[metric.id] = true;
+        report(true);
+      }
+    };
+
+    // Stop listening after input. Note: while scrolling is an input that
+    // stop LCP observation, it's unreliable since it can be programmatically
+    // generated. See: https://github.com/GoogleChrome/web-vitals/issues/75
+    ['keydown', 'click'].forEach(type => {
+      addEventListener(type, stopListening, { once: true, capture: true });
+    });
+
+    onHidden(stopListening, true);
+
+    return stopListening;
+  }
+
+  return;
+};
+
+export { onLCP };
+//# sourceMappingURL=getLCP.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/bindReporter.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/bindReporter.js
new file mode 100644
index 0000000..dc66278
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/bindReporter.js
@@ -0,0 +1,28 @@
+const bindReporter = (
+  callback,
+  metric,
+  reportAllChanges,
+) => {
+  let prevValue;
+  let delta;
+  return (forceReport) => {
+    if (metric.value >= 0) {
+      if (forceReport || reportAllChanges) {
+        delta = metric.value - (prevValue || 0);
+
+        // Report the metric if there's a non-zero delta or if no previous
+        // value exists (which can happen in the case of the document becoming
+        // hidden when the metric value is 0).
+        // See: https://github.com/GoogleChrome/web-vitals/issues/14
+        if (delta || prevValue === undefined) {
+          prevValue = metric.value;
+          metric.delta = delta;
+          callback(metric);
+        }
+      }
+    }
+  };
+};
+
+export { bindReporter };
+//# sourceMappingURL=bindReporter.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/generateUniqueID.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/generateUniqueID.js
new file mode 100644
index 0000000..dfde3bb
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/generateUniqueID.js
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Performantly generate a unique, 30-char string by combining a version
+ * number, the current timestamp with a 13-digit number integer.
+ * @return {string}
+ */
+const generateUniqueID = () => {
+  return `v3-${Date.now()}-${Math.floor(Math.random() * (9e12 - 1)) + 1e12}`;
+};
+
+export { generateUniqueID };
+//# sourceMappingURL=generateUniqueID.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/getActivationStart.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/getActivationStart.js
new file mode 100644
index 0000000..e7b7f65
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/getActivationStart.js
@@ -0,0 +1,25 @@
+import { getNavigationEntry } from './getNavigationEntry.js';
+
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const getActivationStart = () => {
+  const navEntry = getNavigationEntry();
+  return (navEntry && navEntry.activationStart) || 0;
+};
+
+export { getActivationStart };
+//# sourceMappingURL=getActivationStart.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/getNavigationEntry.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/getNavigationEntry.js
new file mode 100644
index 0000000..89a65a5
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/getNavigationEntry.js
@@ -0,0 +1,53 @@
+import { WINDOW } from '../../types.js';
+
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const getNavigationEntryFromPerformanceTiming = () => {
+  // eslint-disable-next-line deprecation/deprecation
+  const timing = WINDOW.performance.timing;
+  // eslint-disable-next-line deprecation/deprecation
+  const type = WINDOW.performance.navigation.type;
+
+  const navigationEntry = {
+    entryType: 'navigation',
+    startTime: 0,
+    type: type == 2 ? 'back_forward' : type === 1 ? 'reload' : 'navigate',
+  };
+
+  for (const key in timing) {
+    if (key !== 'navigationStart' && key !== 'toJSON') {
+      // eslint-disable-next-line deprecation/deprecation
+      navigationEntry[key] = Math.max((timing[key ] ) - timing.navigationStart, 0);
+    }
+  }
+  return navigationEntry ;
+};
+
+const getNavigationEntry = () => {
+  if (WINDOW.__WEB_VITALS_POLYFILL__) {
+    return (
+      WINDOW.performance &&
+      ((performance.getEntriesByType && performance.getEntriesByType('navigation')[0]) ||
+        getNavigationEntryFromPerformanceTiming())
+    );
+  } else {
+    return WINDOW.performance && performance.getEntriesByType && performance.getEntriesByType('navigation')[0];
+  }
+};
+
+export { getNavigationEntry };
+//# sourceMappingURL=getNavigationEntry.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/getVisibilityWatcher.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/getVisibilityWatcher.js
new file mode 100644
index 0000000..fb86cc2
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/getVisibilityWatcher.js
@@ -0,0 +1,54 @@
+import { WINDOW } from '../../types.js';
+import { onHidden } from './onHidden.js';
+
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+let firstHiddenTime = -1;
+
+const initHiddenTime = () => {
+  // If the document is hidden and not prerendering, assume it was always
+  // hidden and the page was loaded in the background.
+  return WINDOW.document.visibilityState === 'hidden' && !WINDOW.document.prerendering ? 0 : Infinity;
+};
+
+const trackChanges = () => {
+  // Update the time if/when the document becomes hidden.
+  onHidden(({ timeStamp }) => {
+    firstHiddenTime = timeStamp;
+  }, true);
+};
+
+const getVisibilityWatcher = (
+
+) => {
+  if (firstHiddenTime < 0) {
+    // If the document is hidden when this code runs, assume it was hidden
+    // since navigation start. This isn't a perfect heuristic, but it's the
+    // best we can do until an API is available to support querying past
+    // visibilityState.
+    firstHiddenTime = initHiddenTime();
+    trackChanges();
+  }
+  return {
+    get firstHiddenTime() {
+      return firstHiddenTime;
+    },
+  };
+};
+
+export { getVisibilityWatcher };
+//# sourceMappingURL=getVisibilityWatcher.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/initMetric.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/initMetric.js
new file mode 100644
index 0000000..498c63d
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/initMetric.js
@@ -0,0 +1,46 @@
+import { WINDOW } from '../../types.js';
+import { generateUniqueID } from './generateUniqueID.js';
+import { getActivationStart } from './getActivationStart.js';
+import { getNavigationEntry } from './getNavigationEntry.js';
+
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const initMetric = (name, value) => {
+  const navEntry = getNavigationEntry();
+  let navigationType = 'navigate';
+
+  if (navEntry) {
+    if (WINDOW.document.prerendering || getActivationStart() > 0) {
+      navigationType = 'prerender';
+    } else {
+      navigationType = navEntry.type.replace(/_/g, '-') ;
+    }
+  }
+
+  return {
+    name,
+    value: typeof value === 'undefined' ? -1 : value,
+    rating: 'good', // Will be updated if the value changes.
+    delta: 0,
+    entries: [],
+    id: generateUniqueID(),
+    navigationType,
+  };
+};
+
+export { initMetric };
+//# sourceMappingURL=initMetric.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/observe.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/observe.js
new file mode 100644
index 0000000..94b7351
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/observe.js
@@ -0,0 +1,37 @@
+/**
+ * Takes a performance entry type and a callback function, and creates a
+ * `PerformanceObserver` instance that will observe the specified entry type
+ * with buffering enabled and call the callback _for each entry_.
+ *
+ * This function also feature-detects entry support and wraps the logic in a
+ * try/catch to avoid errors in unsupporting browsers.
+ */
+const observe = (
+  type,
+  callback,
+  opts,
+) => {
+  try {
+    if (PerformanceObserver.supportedEntryTypes.includes(type)) {
+      const po = new PerformanceObserver(list => {
+        callback(list.getEntries() );
+      });
+      po.observe(
+        Object.assign(
+          {
+            type,
+            buffered: true,
+          },
+          opts || {},
+        ) ,
+      );
+      return po;
+    }
+  } catch (e) {
+    // Do nothing.
+  }
+  return;
+};
+
+export { observe };
+//# sourceMappingURL=observe.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/onHidden.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/onHidden.js
new file mode 100644
index 0000000..78bb128
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry-internal/tracing/esm/browser/web-vitals/lib/onHidden.js
@@ -0,0 +1,36 @@
+import { WINDOW } from '../../types.js';
+
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const onHidden = (cb, once) => {
+  const onHiddenOrPageHide = (event) => {
+    if (event.type === 'pagehide' || WINDOW.document.visibilityState === 'hidden') {
+      cb(event);
+      if (once) {
+        removeEventListener('visibilitychange', onHiddenOrPageHide, true);
+        removeEventListener('pagehide', onHiddenOrPageHide, true);
+      }
+    }
+  };
+  addEventListener('visibilitychange', onHiddenOrPageHide, true);
+  // Some browsers have buggy implementations of visibilitychange,
+  // so we use pagehide in addition, just to be safe.
+  addEventListener('pagehide', onHiddenOrPageHide, true);
+};
+
+export { onHidden };
+//# sourceMappingURL=onHidden.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/aggregate-errors.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/aggregate-errors.js
new file mode 100644
index 0000000..966f41b
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/aggregate-errors.js
@@ -0,0 +1,145 @@
+import { isInstanceOf } from './is.js';
+import { truncate } from './string.js';
+
+/**
+ * Creates exceptions inside `event.exception.values` for errors that are nested on properties based on the `key` parameter.
+ */
+function applyAggregateErrorsToEvent(
+  exceptionFromErrorImplementation,
+  parser,
+  maxValueLimit = 250,
+  key,
+  limit,
+  event,
+  hint,
+) {
+  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {
+    return;
+  }
+
+  // Generally speaking the last item in `event.exception.values` is the exception originating from the original Error
+  const originalException =
+    event.exception.values.length > 0 ? event.exception.values[event.exception.values.length - 1] : undefined;
+
+  // We only create exception grouping if there is an exception in the event.
+  if (originalException) {
+    event.exception.values = truncateAggregateExceptions(
+      aggregateExceptionsFromError(
+        exceptionFromErrorImplementation,
+        parser,
+        limit,
+        hint.originalException ,
+        key,
+        event.exception.values,
+        originalException,
+        0,
+      ),
+      maxValueLimit,
+    );
+  }
+}
+
+function aggregateExceptionsFromError(
+  exceptionFromErrorImplementation,
+  parser,
+  limit,
+  error,
+  key,
+  prevExceptions,
+  exception,
+  exceptionId,
+) {
+  if (prevExceptions.length >= limit + 1) {
+    return prevExceptions;
+  }
+
+  let newExceptions = [...prevExceptions];
+
+  if (isInstanceOf(error[key], Error)) {
+    applyExceptionGroupFieldsForParentException(exception, exceptionId);
+    const newException = exceptionFromErrorImplementation(parser, error[key]);
+    const newExceptionId = newExceptions.length;
+    applyExceptionGroupFieldsForChildException(newException, key, newExceptionId, exceptionId);
+    newExceptions = aggregateExceptionsFromError(
+      exceptionFromErrorImplementation,
+      parser,
+      limit,
+      error[key],
+      key,
+      [newException, ...newExceptions],
+      newException,
+      newExceptionId,
+    );
+  }
+
+  // This will create exception grouping for AggregateErrors
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError
+  if (Array.isArray(error.errors)) {
+    error.errors.forEach((childError, i) => {
+      if (isInstanceOf(childError, Error)) {
+        applyExceptionGroupFieldsForParentException(exception, exceptionId);
+        const newException = exceptionFromErrorImplementation(parser, childError);
+        const newExceptionId = newExceptions.length;
+        applyExceptionGroupFieldsForChildException(newException, `errors[${i}]`, newExceptionId, exceptionId);
+        newExceptions = aggregateExceptionsFromError(
+          exceptionFromErrorImplementation,
+          parser,
+          limit,
+          childError,
+          key,
+          [newException, ...newExceptions],
+          newException,
+          newExceptionId,
+        );
+      }
+    });
+  }
+
+  return newExceptions;
+}
+
+function applyExceptionGroupFieldsForParentException(exception, exceptionId) {
+  // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.
+  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };
+
+  exception.mechanism = {
+    ...exception.mechanism,
+    is_exception_group: true,
+    exception_id: exceptionId,
+  };
+}
+
+function applyExceptionGroupFieldsForChildException(
+  exception,
+  source,
+  exceptionId,
+  parentId,
+) {
+  // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.
+  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };
+
+  exception.mechanism = {
+    ...exception.mechanism,
+    type: 'chained',
+    source,
+    exception_id: exceptionId,
+    parent_id: parentId,
+  };
+}
+
+/**
+ * Truncate the message (exception.value) of all exceptions in the event.
+ * Because this event processor is ran after `applyClientOptions`,
+ * we need to truncate the message of the added exceptions here.
+ */
+function truncateAggregateExceptions(exceptions, maxValueLength) {
+  return exceptions.map(exception => {
+    if (exception.value) {
+      exception.value = truncate(exception.value, maxValueLength);
+    }
+    return exception;
+  });
+}
+
+export { applyAggregateErrorsToEvent };
+//# sourceMappingURL=aggregate-errors.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/baggage.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/baggage.js
new file mode 100644
index 0000000..d4bd7f4
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/baggage.js
@@ -0,0 +1,149 @@
+import { isString } from './is.js';
+import { logger } from './logger.js';
+
+const BAGGAGE_HEADER_NAME = 'baggage';
+
+const SENTRY_BAGGAGE_KEY_PREFIX = 'sentry-';
+
+const SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;
+
+/**
+ * Max length of a serialized baggage string
+ *
+ * https://www.w3.org/TR/baggage/#limits
+ */
+const MAX_BAGGAGE_STRING_LENGTH = 8192;
+
+/**
+ * Takes a baggage header and turns it into Dynamic Sampling Context, by extracting all the "sentry-" prefixed values
+ * from it.
+ *
+ * @param baggageHeader A very bread definition of a baggage header as it might appear in various frameworks.
+ * @returns The Dynamic Sampling Context that was found on `baggageHeader`, if there was any, `undefined` otherwise.
+ */
+function baggageHeaderToDynamicSamplingContext(
+  // Very liberal definition of what any incoming header might look like
+  baggageHeader,
+) {
+  if (!isString(baggageHeader) && !Array.isArray(baggageHeader)) {
+    return undefined;
+  }
+
+  // Intermediary object to store baggage key value pairs of incoming baggage headers on.
+  // It is later used to read Sentry-DSC-values from.
+  let baggageObject = {};
+
+  if (Array.isArray(baggageHeader)) {
+    // Combine all baggage headers into one object containing the baggage values so we can later read the Sentry-DSC-values from it
+    baggageObject = baggageHeader.reduce((acc, curr) => {
+      const currBaggageObject = baggageHeaderToObject(curr);
+      return {
+        ...acc,
+        ...currBaggageObject,
+      };
+    }, {});
+  } else {
+    // Return undefined if baggage header is an empty string (technically an empty baggage header is not spec conform but
+    // this is how we choose to handle it)
+    if (!baggageHeader) {
+      return undefined;
+    }
+
+    baggageObject = baggageHeaderToObject(baggageHeader);
+  }
+
+  // Read all "sentry-" prefixed values out of the baggage object and put it onto a dynamic sampling context object.
+  const dynamicSamplingContext = Object.entries(baggageObject).reduce((acc, [key, value]) => {
+    if (key.match(SENTRY_BAGGAGE_KEY_PREFIX_REGEX)) {
+      const nonPrefixedKey = key.slice(SENTRY_BAGGAGE_KEY_PREFIX.length);
+      acc[nonPrefixedKey] = value;
+    }
+    return acc;
+  }, {});
+
+  // Only return a dynamic sampling context object if there are keys in it.
+  // A keyless object means there were no sentry values on the header, which means that there is no DSC.
+  if (Object.keys(dynamicSamplingContext).length > 0) {
+    return dynamicSamplingContext ;
+  } else {
+    return undefined;
+  }
+}
+
+/**
+ * Turns a Dynamic Sampling Object into a baggage header by prefixing all the keys on the object with "sentry-".
+ *
+ * @param dynamicSamplingContext The Dynamic Sampling Context to turn into a header. For convenience and compatibility
+ * with the `getDynamicSamplingContext` method on the Transaction class ,this argument can also be `undefined`. If it is
+ * `undefined` the function will return `undefined`.
+ * @returns a baggage header, created from `dynamicSamplingContext`, or `undefined` either if `dynamicSamplingContext`
+ * was `undefined`, or if `dynamicSamplingContext` didn't contain any values.
+ */
+function dynamicSamplingContextToSentryBaggageHeader(
+  // this also takes undefined for convenience and bundle size in other places
+  dynamicSamplingContext,
+) {
+  if (!dynamicSamplingContext) {
+    return undefined;
+  }
+
+  // Prefix all DSC keys with "sentry-" and put them into a new object
+  const sentryPrefixedDSC = Object.entries(dynamicSamplingContext).reduce(
+    (acc, [dscKey, dscValue]) => {
+      if (dscValue) {
+        acc[`${SENTRY_BAGGAGE_KEY_PREFIX}${dscKey}`] = dscValue;
+      }
+      return acc;
+    },
+    {},
+  );
+
+  return objectToBaggageHeader(sentryPrefixedDSC);
+}
+
+/**
+ * Will parse a baggage header, which is a simple key-value map, into a flat object.
+ *
+ * @param baggageHeader The baggage header to parse.
+ * @returns a flat object containing all the key-value pairs from `baggageHeader`.
+ */
+function baggageHeaderToObject(baggageHeader) {
+  return baggageHeader
+    .split(',')
+    .map(baggageEntry => baggageEntry.split('=').map(keyOrValue => decodeURIComponent(keyOrValue.trim())))
+    .reduce((acc, [key, value]) => {
+      acc[key] = value;
+      return acc;
+    }, {});
+}
+
+/**
+ * Turns a flat object (key-value pairs) into a baggage header, which is also just key-value pairs.
+ *
+ * @param object The object to turn into a baggage header.
+ * @returns a baggage header string, or `undefined` if the object didn't have any values, since an empty baggage header
+ * is not spec compliant.
+ */
+function objectToBaggageHeader(object) {
+  if (Object.keys(object).length === 0) {
+    // An empty baggage header is not spec compliant: We return undefined.
+    return undefined;
+  }
+
+  return Object.entries(object).reduce((baggageHeader, [objectKey, objectValue], currentIndex) => {
+    const baggageEntry = `${encodeURIComponent(objectKey)}=${encodeURIComponent(objectValue)}`;
+    const newBaggageHeader = currentIndex === 0 ? baggageEntry : `${baggageHeader},${baggageEntry}`;
+    if (newBaggageHeader.length > MAX_BAGGAGE_STRING_LENGTH) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        logger.warn(
+          `Not adding key: ${objectKey} with val: ${objectValue} to baggage header due to exceeding baggage size limits.`,
+        );
+      return baggageHeader;
+    } else {
+      return newBaggageHeader;
+    }
+  }, '');
+}
+
+export { BAGGAGE_HEADER_NAME, MAX_BAGGAGE_STRING_LENGTH, SENTRY_BAGGAGE_KEY_PREFIX, SENTRY_BAGGAGE_KEY_PREFIX_REGEX, baggageHeaderToDynamicSamplingContext, dynamicSamplingContextToSentryBaggageHeader };
+//# sourceMappingURL=baggage.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/browser.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/browser.js
new file mode 100644
index 0000000..aef06de
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/browser.js
@@ -0,0 +1,152 @@
+import { isString } from './is.js';
+import { getGlobalObject } from './worldwide.js';
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+const DEFAULT_MAX_STRING_LENGTH = 80;
+
+/**
+ * Given a child DOM element, returns a query-selector statement describing that
+ * and its ancestors
+ * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]
+ * @returns generated DOM path
+ */
+function htmlTreeAsString(
+  elem,
+  options = {},
+) {
+
+  // try/catch both:
+  // - accessing event.target (see getsentry/raven-js#838, #768)
+  // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly
+  // - can throw an exception in some circumstances.
+  try {
+    let currentElem = elem ;
+    const MAX_TRAVERSE_HEIGHT = 5;
+    const out = [];
+    let height = 0;
+    let len = 0;
+    const separator = ' > ';
+    const sepLength = separator.length;
+    let nextStr;
+    const keyAttrs = Array.isArray(options) ? options : options.keyAttrs;
+    const maxStringLength = (!Array.isArray(options) && options.maxStringLength) || DEFAULT_MAX_STRING_LENGTH;
+
+    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {
+      nextStr = _htmlElementAsString(currentElem, keyAttrs);
+      // bail out if
+      // - nextStr is the 'html' element
+      // - the length of the string that would be created exceeds maxStringLength
+      //   (ignore this limit if we are on the first iteration)
+      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength)) {
+        break;
+      }
+
+      out.push(nextStr);
+
+      len += nextStr.length;
+      currentElem = currentElem.parentNode;
+    }
+
+    return out.reverse().join(separator);
+  } catch (_oO) {
+    return '<unknown>';
+  }
+}
+
+/**
+ * Returns a simple, query-selector representation of a DOM element
+ * e.g. [HTMLElement] => input#foo.btn[name=baz]
+ * @returns generated DOM path
+ */
+function _htmlElementAsString(el, keyAttrs) {
+  const elem = el
+
+;
+
+  const out = [];
+  let className;
+  let classes;
+  let key;
+  let attr;
+  let i;
+
+  if (!elem || !elem.tagName) {
+    return '';
+  }
+
+  out.push(elem.tagName.toLowerCase());
+
+  // Pairs of attribute keys defined in `serializeAttribute` and their values on element.
+  const keyAttrPairs =
+    keyAttrs && keyAttrs.length
+      ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])
+      : null;
+
+  if (keyAttrPairs && keyAttrPairs.length) {
+    keyAttrPairs.forEach(keyAttrPair => {
+      out.push(`[${keyAttrPair[0]}="${keyAttrPair[1]}"]`);
+    });
+  } else {
+    if (elem.id) {
+      out.push(`#${elem.id}`);
+    }
+
+    // eslint-disable-next-line prefer-const
+    className = elem.className;
+    if (className && isString(className)) {
+      classes = className.split(/\s+/);
+      for (i = 0; i < classes.length; i++) {
+        out.push(`.${classes[i]}`);
+      }
+    }
+  }
+  const allowedAttrs = ['aria-label', 'type', 'name', 'title', 'alt'];
+  for (i = 0; i < allowedAttrs.length; i++) {
+    key = allowedAttrs[i];
+    attr = elem.getAttribute(key);
+    if (attr) {
+      out.push(`[${key}="${attr}"]`);
+    }
+  }
+  return out.join('');
+}
+
+/**
+ * A safe form of location.href
+ */
+function getLocationHref() {
+  try {
+    return WINDOW.document.location.href;
+  } catch (oO) {
+    return '';
+  }
+}
+
+/**
+ * Gets a DOM element by using document.querySelector.
+ *
+ * This wrapper will first check for the existance of the function before
+ * actually calling it so that we don't have to take care of this check,
+ * every time we want to access the DOM.
+ *
+ * Reason: DOM/querySelector is not available in all environments.
+ *
+ * We have to cast to any because utils can be consumed by a variety of environments,
+ * and we don't want to break TS users. If you know what element will be selected by
+ * `document.querySelector`, specify it as part of the generic call. For example,
+ * `const element = getDomElement<Element>('selector');`
+ *
+ * @param selector the selector string passed on to document.querySelector
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getDomElement(selector) {
+  if (WINDOW.document && WINDOW.document.querySelector) {
+    return WINDOW.document.querySelector(selector) ;
+  }
+  return null;
+}
+
+export { getDomElement, getLocationHref, htmlTreeAsString };
+//# sourceMappingURL=browser.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/clientreport.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/clientreport.js
new file mode 100644
index 0000000..22c1c30
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/clientreport.js
@@ -0,0 +1,25 @@
+import { createEnvelope } from './envelope.js';
+import { dateTimestampInSeconds } from './time.js';
+
+/**
+ * Creates client report envelope
+ * @param discarded_events An array of discard events
+ * @param dsn A DSN that can be set on the header. Optional.
+ */
+function createClientReportEnvelope(
+  discarded_events,
+  dsn,
+  timestamp,
+) {
+  const clientReportItem = [
+    { type: 'client_report' },
+    {
+      timestamp: timestamp || dateTimestampInSeconds(),
+      discarded_events,
+    },
+  ];
+  return createEnvelope(dsn ? { dsn } : {}, [clientReportItem]);
+}
+
+export { createClientReportEnvelope };
+//# sourceMappingURL=clientreport.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/dsn.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/dsn.js
new file mode 100644
index 0000000..4fe84be
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/dsn.js
@@ -0,0 +1,126 @@
+import { logger } from './logger.js';
+
+/** Regular expression used to parse a Dsn. */
+const DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)([\w.-]+)(?::(\d+))?\/(.+)/;
+
+function isValidProtocol(protocol) {
+  return protocol === 'http' || protocol === 'https';
+}
+
+/**
+ * Renders the string representation of this Dsn.
+ *
+ * By default, this will render the public representation without the password
+ * component. To get the deprecated private representation, set `withPassword`
+ * to true.
+ *
+ * @param withPassword When set to true, the password will be included.
+ */
+function dsnToString(dsn, withPassword = false) {
+  const { host, path, pass, port, projectId, protocol, publicKey } = dsn;
+  return (
+    `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +
+    `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`
+  );
+}
+
+/**
+ * Parses a Dsn from a given string.
+ *
+ * @param str A Dsn as string
+ * @returns Dsn as DsnComponents or undefined if @param str is not a valid DSN string
+ */
+function dsnFromString(str) {
+  const match = DSN_REGEX.exec(str);
+
+  if (!match) {
+    // This should be logged to the console
+    // eslint-disable-next-line no-console
+    console.error(`Invalid Sentry Dsn: ${str}`);
+    return undefined;
+  }
+
+  const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);
+  let path = '';
+  let projectId = lastPath;
+
+  const split = projectId.split('/');
+  if (split.length > 1) {
+    path = split.slice(0, -1).join('/');
+    projectId = split.pop() ;
+  }
+
+  if (projectId) {
+    const projectMatch = projectId.match(/^\d+/);
+    if (projectMatch) {
+      projectId = projectMatch[0];
+    }
+  }
+
+  return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol , publicKey });
+}
+
+function dsnFromComponents(components) {
+  return {
+    protocol: components.protocol,
+    publicKey: components.publicKey || '',
+    pass: components.pass || '',
+    host: components.host,
+    port: components.port || '',
+    path: components.path || '',
+    projectId: components.projectId,
+  };
+}
+
+function validateDsn(dsn) {
+  if (!(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+    return true;
+  }
+
+  const { port, projectId, protocol } = dsn;
+
+  const requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];
+  const hasMissingRequiredComponent = requiredComponents.find(component => {
+    if (!dsn[component]) {
+      logger.error(`Invalid Sentry Dsn: ${component} missing`);
+      return true;
+    }
+    return false;
+  });
+
+  if (hasMissingRequiredComponent) {
+    return false;
+  }
+
+  if (!projectId.match(/^\d+$/)) {
+    logger.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);
+    return false;
+  }
+
+  if (!isValidProtocol(protocol)) {
+    logger.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);
+    return false;
+  }
+
+  if (port && isNaN(parseInt(port, 10))) {
+    logger.error(`Invalid Sentry Dsn: Invalid port ${port}`);
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Creates a valid Sentry Dsn object, identifying a Sentry instance and project.
+ * @returns a valid DsnComponents object or `undefined` if @param from is an invalid DSN source
+ */
+function makeDsn(from) {
+  const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);
+  if (!components || !validateDsn(components)) {
+    return undefined;
+  }
+  return components;
+}
+
+export { dsnFromString, dsnToString, makeDsn };
+//# sourceMappingURL=dsn.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/env.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/env.js
new file mode 100644
index 0000000..46dc077
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/env.js
@@ -0,0 +1,34 @@
+/*
+ * This module exists for optimizations in the build process through rollup and terser.  We define some global
+ * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these
+ * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will
+ * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to
+ * `logger` and preventing node-related code from appearing in browser bundles.
+ *
+ * Attention:
+ * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by
+ * users. These flags should live in their respective packages, as we identified user tooling (specifically webpack)
+ * having issues tree-shaking these constants across package boundaries.
+ * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want
+ * users to be able to shake away expressions that it guards.
+ */
+
+/**
+ * Figures out if we're building a browser bundle.
+ *
+ * @returns true if this is a browser bundle build.
+ */
+function isBrowserBundle() {
+  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;
+}
+
+/**
+ * Get source of SDK.
+ */
+function getSDKSource() {
+  // @ts-expect-error "npm" is injected by rollup during build process
+  return "npm";
+}
+
+export { getSDKSource, isBrowserBundle };
+//# sourceMappingURL=env.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/envelope.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/envelope.js
new file mode 100644
index 0000000..a2cc042
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/envelope.js
@@ -0,0 +1,232 @@
+import { dsnToString } from './dsn.js';
+import { normalize } from './normalize.js';
+import { dropUndefinedKeys } from './object.js';
+
+/**
+ * Creates an envelope.
+ * Make sure to always explicitly provide the generic to this function
+ * so that the envelope types resolve correctly.
+ */
+function createEnvelope(headers, items = []) {
+  return [headers, items] ;
+}
+
+/**
+ * Add an item to an envelope.
+ * Make sure to always explicitly provide the generic to this function
+ * so that the envelope types resolve correctly.
+ */
+function addItemToEnvelope(envelope, newItem) {
+  const [headers, items] = envelope;
+  return [headers, [...items, newItem]] ;
+}
+
+/**
+ * Convenience function to loop through the items and item types of an envelope.
+ * (This function was mostly created because working with envelope types is painful at the moment)
+ *
+ * If the callback returns true, the rest of the items will be skipped.
+ */
+function forEachEnvelopeItem(
+  envelope,
+  callback,
+) {
+  const envelopeItems = envelope[1];
+
+  for (const envelopeItem of envelopeItems) {
+    const envelopeItemType = envelopeItem[0].type;
+    const result = callback(envelopeItem, envelopeItemType);
+
+    if (result) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Returns true if the envelope contains any of the given envelope item types
+ */
+function envelopeContainsItemType(envelope, types) {
+  return forEachEnvelopeItem(envelope, (_, type) => types.includes(type));
+}
+
+/**
+ * Encode a string to UTF8.
+ */
+function encodeUTF8(input, textEncoder) {
+  const utf8 = textEncoder || new TextEncoder();
+  return utf8.encode(input);
+}
+
+/**
+ * Serializes an envelope.
+ */
+function serializeEnvelope(envelope, textEncoder) {
+  const [envHeaders, items] = envelope;
+
+  // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data
+  let parts = JSON.stringify(envHeaders);
+
+  function append(next) {
+    if (typeof parts === 'string') {
+      parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts, textEncoder), next];
+    } else {
+      parts.push(typeof next === 'string' ? encodeUTF8(next, textEncoder) : next);
+    }
+  }
+
+  for (const item of items) {
+    const [itemHeaders, payload] = item;
+
+    append(`\n${JSON.stringify(itemHeaders)}\n`);
+
+    if (typeof payload === 'string' || payload instanceof Uint8Array) {
+      append(payload);
+    } else {
+      let stringifiedPayload;
+      try {
+        stringifiedPayload = JSON.stringify(payload);
+      } catch (e) {
+        // In case, despite all our efforts to keep `payload` circular-dependency-free, `JSON.strinify()` still
+        // fails, we try again after normalizing it again with infinite normalization depth. This of course has a
+        // performance impact but in this case a performance hit is better than throwing.
+        stringifiedPayload = JSON.stringify(normalize(payload));
+      }
+      append(stringifiedPayload);
+    }
+  }
+
+  return typeof parts === 'string' ? parts : concatBuffers(parts);
+}
+
+function concatBuffers(buffers) {
+  const totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);
+
+  const merged = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const buffer of buffers) {
+    merged.set(buffer, offset);
+    offset += buffer.length;
+  }
+
+  return merged;
+}
+
+/**
+ * Parses an envelope
+ */
+function parseEnvelope(
+  env,
+  textEncoder,
+  textDecoder,
+) {
+  let buffer = typeof env === 'string' ? textEncoder.encode(env) : env;
+
+  function readBinary(length) {
+    const bin = buffer.subarray(0, length);
+    // Replace the buffer with the remaining data excluding trailing newline
+    buffer = buffer.subarray(length + 1);
+    return bin;
+  }
+
+  function readJson() {
+    let i = buffer.indexOf(0xa);
+    // If we couldn't find a newline, we must have found the end of the buffer
+    if (i < 0) {
+      i = buffer.length;
+    }
+
+    return JSON.parse(textDecoder.decode(readBinary(i))) ;
+  }
+
+  const envelopeHeader = readJson();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const items = [];
+
+  while (buffer.length) {
+    const itemHeader = readJson();
+    const binaryLength = typeof itemHeader.length === 'number' ? itemHeader.length : undefined;
+
+    items.push([itemHeader, binaryLength ? readBinary(binaryLength) : readJson()]);
+  }
+
+  return [envelopeHeader, items];
+}
+
+/**
+ * Creates attachment envelope items
+ */
+function createAttachmentEnvelopeItem(
+  attachment,
+  textEncoder,
+) {
+  const buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data, textEncoder) : attachment.data;
+
+  return [
+    dropUndefinedKeys({
+      type: 'attachment',
+      length: buffer.length,
+      filename: attachment.filename,
+      content_type: attachment.contentType,
+      attachment_type: attachment.attachmentType,
+    }),
+    buffer,
+  ];
+}
+
+const ITEM_TYPE_TO_DATA_CATEGORY_MAP = {
+  session: 'session',
+  sessions: 'session',
+  attachment: 'attachment',
+  transaction: 'transaction',
+  event: 'error',
+  client_report: 'internal',
+  user_report: 'default',
+  profile: 'profile',
+  replay_event: 'replay',
+  replay_recording: 'replay',
+  check_in: 'monitor',
+};
+
+/**
+ * Maps the type of an envelope item to a data category.
+ */
+function envelopeItemTypeToDataCategory(type) {
+  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];
+}
+
+/** Extracts the minimal SDK info from from the metadata or an events */
+function getSdkMetadataForEnvelopeHeader(metadataOrEvent) {
+  if (!metadataOrEvent || !metadataOrEvent.sdk) {
+    return;
+  }
+  const { name, version } = metadataOrEvent.sdk;
+  return { name, version };
+}
+
+/**
+ * Creates event envelope headers, based on event, sdk info and tunnel
+ * Note: This function was extracted from the core package to make it available in Replay
+ */
+function createEventEnvelopeHeaders(
+  event,
+  sdkInfo,
+  tunnel,
+  dsn,
+) {
+  const dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;
+  return {
+    event_id: event.event_id ,
+    sent_at: new Date().toISOString(),
+    ...(sdkInfo && { sdk: sdkInfo }),
+    ...(!!tunnel && { dsn: dsnToString(dsn) }),
+    ...(dynamicSamplingContext && {
+      trace: dropUndefinedKeys({ ...dynamicSamplingContext }),
+    }),
+  };
+}
+
+export { addItemToEnvelope, createAttachmentEnvelopeItem, createEnvelope, createEventEnvelopeHeaders, envelopeContainsItemType, envelopeItemTypeToDataCategory, forEachEnvelopeItem, getSdkMetadataForEnvelopeHeader, parseEnvelope, serializeEnvelope };
+//# sourceMappingURL=envelope.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/instrument.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/instrument.js
new file mode 100644
index 0000000..9eb5a9e
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/instrument.js
@@ -0,0 +1,642 @@
+import { isString } from './is.js';
+import { logger, CONSOLE_LEVELS, originalConsoleMethods } from './logger.js';
+import { fill } from './object.js';
+import { getFunctionName } from './stacktrace.js';
+import { supportsNativeFetch } from './supports.js';
+import { getGlobalObject, GLOBAL_OBJ } from './worldwide.js';
+import { supportsHistory } from './vendor/supportsHistory.js';
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+const SENTRY_XHR_DATA_KEY = '__sentry_xhr_v2__';
+
+/**
+ * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.
+ *  - Console API
+ *  - Fetch API
+ *  - XHR API
+ *  - History API
+ *  - DOM API (click/typing)
+ *  - Error API
+ *  - UnhandledRejection API
+ */
+
+const handlers = {};
+const instrumented = {};
+
+/** Instruments given API */
+function instrument(type) {
+  if (instrumented[type]) {
+    return;
+  }
+
+  instrumented[type] = true;
+
+  switch (type) {
+    case 'console':
+      instrumentConsole();
+      break;
+    case 'dom':
+      instrumentDOM();
+      break;
+    case 'xhr':
+      instrumentXHR();
+      break;
+    case 'fetch':
+      instrumentFetch();
+      break;
+    case 'history':
+      instrumentHistory();
+      break;
+    case 'error':
+      instrumentError();
+      break;
+    case 'unhandledrejection':
+      instrumentUnhandledRejection();
+      break;
+    default:
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('unknown instrumentation type:', type);
+      return;
+  }
+}
+
+/**
+ * Add handler that will be called when given type of instrumentation triggers.
+ * Use at your own risk, this might break without changelog notice, only used internally.
+ * @hidden
+ */
+function addInstrumentationHandler(type, callback) {
+  handlers[type] = handlers[type] || [];
+  (handlers[type] ).push(callback);
+  instrument(type);
+}
+
+/**
+ * Reset all instrumentation handlers.
+ * This can be used by tests to ensure we have a clean slate of instrumentation handlers.
+ */
+function resetInstrumentationHandlers() {
+  Object.keys(handlers).forEach(key => {
+    handlers[key ] = undefined;
+  });
+}
+
+/** JSDoc */
+function triggerHandlers(type, data) {
+  if (!type || !handlers[type]) {
+    return;
+  }
+
+  for (const handler of handlers[type] || []) {
+    try {
+      handler(data);
+    } catch (e) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        logger.error(
+          `Error while triggering instrumentation handler.\nType: ${type}\nName: ${getFunctionName(handler)}\nError:`,
+          e,
+        );
+    }
+  }
+}
+
+/** JSDoc */
+function instrumentConsole() {
+  if (!('console' in GLOBAL_OBJ)) {
+    return;
+  }
+
+  CONSOLE_LEVELS.forEach(function (level) {
+    if (!(level in GLOBAL_OBJ.console)) {
+      return;
+    }
+
+    fill(GLOBAL_OBJ.console, level, function (originalConsoleMethod) {
+      originalConsoleMethods[level] = originalConsoleMethod;
+
+      return function (...args) {
+        triggerHandlers('console', { args, level });
+
+        const log = originalConsoleMethods[level];
+        log && log.apply(GLOBAL_OBJ.console, args);
+      };
+    });
+  });
+}
+
+/** JSDoc */
+function instrumentFetch() {
+  if (!supportsNativeFetch()) {
+    return;
+  }
+
+  fill(GLOBAL_OBJ, 'fetch', function (originalFetch) {
+    return function (...args) {
+      const { method, url } = parseFetchArgs(args);
+
+      const handlerData = {
+        args,
+        fetchData: {
+          method,
+          url,
+        },
+        startTimestamp: Date.now(),
+      };
+
+      triggerHandlers('fetch', {
+        ...handlerData,
+      });
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      return originalFetch.apply(GLOBAL_OBJ, args).then(
+        (response) => {
+          triggerHandlers('fetch', {
+            ...handlerData,
+            endTimestamp: Date.now(),
+            response,
+          });
+          return response;
+        },
+        (error) => {
+          triggerHandlers('fetch', {
+            ...handlerData,
+            endTimestamp: Date.now(),
+            error,
+          });
+          // NOTE: If you are a Sentry user, and you are seeing this stack frame,
+          //       it means the sentry.javascript SDK caught an error invoking your application code.
+          //       This is expected behavior and NOT indicative of a bug with sentry.javascript.
+          throw error;
+        },
+      );
+    };
+  });
+}
+
+function hasProp(obj, prop) {
+  return !!obj && typeof obj === 'object' && !!(obj )[prop];
+}
+
+function getUrlFromResource(resource) {
+  if (typeof resource === 'string') {
+    return resource;
+  }
+
+  if (!resource) {
+    return '';
+  }
+
+  if (hasProp(resource, 'url')) {
+    return resource.url;
+  }
+
+  if (resource.toString) {
+    return resource.toString();
+  }
+
+  return '';
+}
+
+/**
+ * Parses the fetch arguments to find the used Http method and the url of the request
+ */
+function parseFetchArgs(fetchArgs) {
+  if (fetchArgs.length === 0) {
+    return { method: 'GET', url: '' };
+  }
+
+  if (fetchArgs.length === 2) {
+    const [url, options] = fetchArgs ;
+
+    return {
+      url: getUrlFromResource(url),
+      method: hasProp(options, 'method') ? String(options.method).toUpperCase() : 'GET',
+    };
+  }
+
+  const arg = fetchArgs[0];
+  return {
+    url: getUrlFromResource(arg ),
+    method: hasProp(arg, 'method') ? String(arg.method).toUpperCase() : 'GET',
+  };
+}
+
+/** JSDoc */
+function instrumentXHR() {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  if (!(WINDOW ).XMLHttpRequest) {
+    return;
+  }
+
+  const xhrproto = XMLHttpRequest.prototype;
+
+  fill(xhrproto, 'open', function (originalOpen) {
+    return function ( ...args) {
+      const url = args[1];
+      const xhrInfo = (this[SENTRY_XHR_DATA_KEY] = {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        method: isString(args[0]) ? args[0].toUpperCase() : args[0],
+        url: args[1],
+        request_headers: {},
+      });
+
+      // if Sentry key appears in URL, don't capture it as a request
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      if (isString(url) && xhrInfo.method === 'POST' && url.match(/sentry_key/)) {
+        this.__sentry_own_request__ = true;
+      }
+
+      const onreadystatechangeHandler = () => {
+        // For whatever reason, this is not the same instance here as from the outer method
+        const xhrInfo = this[SENTRY_XHR_DATA_KEY];
+
+        if (!xhrInfo) {
+          return;
+        }
+
+        if (this.readyState === 4) {
+          try {
+            // touching statusCode in some platforms throws
+            // an exception
+            xhrInfo.status_code = this.status;
+          } catch (e) {
+            /* do nothing */
+          }
+
+          triggerHandlers('xhr', {
+            args: args ,
+            endTimestamp: Date.now(),
+            startTimestamp: Date.now(),
+            xhr: this,
+          } );
+        }
+      };
+
+      if ('onreadystatechange' in this && typeof this.onreadystatechange === 'function') {
+        fill(this, 'onreadystatechange', function (original) {
+          return function ( ...readyStateArgs) {
+            onreadystatechangeHandler();
+            return original.apply(this, readyStateArgs);
+          };
+        });
+      } else {
+        this.addEventListener('readystatechange', onreadystatechangeHandler);
+      }
+
+      // Intercepting `setRequestHeader` to access the request headers of XHR instance.
+      // This will only work for user/library defined headers, not for the default/browser-assigned headers.
+      // Request cookies are also unavailable for XHR, as `Cookie` header can't be defined by `setRequestHeader`.
+      fill(this, 'setRequestHeader', function (original) {
+        return function ( ...setRequestHeaderArgs) {
+          const [header, value] = setRequestHeaderArgs ;
+
+          const xhrInfo = this[SENTRY_XHR_DATA_KEY];
+
+          if (xhrInfo) {
+            xhrInfo.request_headers[header.toLowerCase()] = value;
+          }
+
+          return original.apply(this, setRequestHeaderArgs);
+        };
+      });
+
+      return originalOpen.apply(this, args);
+    };
+  });
+
+  fill(xhrproto, 'send', function (originalSend) {
+    return function ( ...args) {
+      const sentryXhrData = this[SENTRY_XHR_DATA_KEY];
+      if (sentryXhrData && args[0] !== undefined) {
+        sentryXhrData.body = args[0];
+      }
+
+      triggerHandlers('xhr', {
+        args,
+        startTimestamp: Date.now(),
+        xhr: this,
+      });
+
+      return originalSend.apply(this, args);
+    };
+  });
+}
+
+let lastHref;
+
+/** JSDoc */
+function instrumentHistory() {
+  if (!supportsHistory()) {
+    return;
+  }
+
+  const oldOnPopState = WINDOW.onpopstate;
+  WINDOW.onpopstate = function ( ...args) {
+    const to = WINDOW.location.href;
+    // keep track of the current URL state, as we always receive only the updated state
+    const from = lastHref;
+    lastHref = to;
+    triggerHandlers('history', {
+      from,
+      to,
+    });
+    if (oldOnPopState) {
+      // Apparently this can throw in Firefox when incorrectly implemented plugin is installed.
+      // https://github.com/getsentry/sentry-javascript/issues/3344
+      // https://github.com/bugsnag/bugsnag-js/issues/469
+      try {
+        return oldOnPopState.apply(this, args);
+      } catch (_oO) {
+        // no-empty
+      }
+    }
+  };
+
+  /** @hidden */
+  function historyReplacementFunction(originalHistoryFunction) {
+    return function ( ...args) {
+      const url = args.length > 2 ? args[2] : undefined;
+      if (url) {
+        // coerce to string (this is what pushState does)
+        const from = lastHref;
+        const to = String(url);
+        // keep track of the current URL state, as we always receive only the updated state
+        lastHref = to;
+        triggerHandlers('history', {
+          from,
+          to,
+        });
+      }
+      return originalHistoryFunction.apply(this, args);
+    };
+  }
+
+  fill(WINDOW.history, 'pushState', historyReplacementFunction);
+  fill(WINDOW.history, 'replaceState', historyReplacementFunction);
+}
+
+const debounceDuration = 1000;
+let debounceTimerID;
+let lastCapturedEvent;
+
+/**
+ * Decide whether the current event should finish the debounce of previously captured one.
+ * @param previous previously captured event
+ * @param current event to be captured
+ */
+function shouldShortcircuitPreviousDebounce(previous, current) {
+  // If there was no previous event, it should always be swapped for the new one.
+  if (!previous) {
+    return true;
+  }
+
+  // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.
+  if (previous.type !== current.type) {
+    return true;
+  }
+
+  try {
+    // If both events have the same type, it's still possible that actions were performed on different targets.
+    // e.g. 2 clicks on different buttons.
+    if (previous.target !== current.target) {
+      return true;
+    }
+  } catch (e) {
+    // just accessing `target` property can throw an exception in some rare circumstances
+    // see: https://github.com/getsentry/sentry-javascript/issues/838
+  }
+
+  // If both events have the same type _and_ same `target` (an element which triggered an event, _not necessarily_
+  // to which an event listener was attached), we treat them as the same action, as we want to capture
+  // only one breadcrumb. e.g. multiple clicks on the same button, or typing inside a user input box.
+  return false;
+}
+
+/**
+ * Decide whether an event should be captured.
+ * @param event event to be captured
+ */
+function shouldSkipDOMEvent(event) {
+  // We are only interested in filtering `keypress` events for now.
+  if (event.type !== 'keypress') {
+    return false;
+  }
+
+  try {
+    const target = event.target ;
+
+    if (!target || !target.tagName) {
+      return true;
+    }
+
+    // Only consider keypress events on actual input elements. This will disregard keypresses targeting body
+    // e.g.tabbing through elements, hotkeys, etc.
+    if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {
+      return false;
+    }
+  } catch (e) {
+    // just accessing `target` property can throw an exception in some rare circumstances
+    // see: https://github.com/getsentry/sentry-javascript/issues/838
+  }
+
+  return true;
+}
+
+/**
+ * Wraps addEventListener to capture UI breadcrumbs
+ * @param handler function that will be triggered
+ * @param globalListener indicates whether event was captured by the global event listener
+ * @returns wrapped breadcrumb events handler
+ * @hidden
+ */
+function makeDOMEventHandler(handler, globalListener = false) {
+  return (event) => {
+    // It's possible this handler might trigger multiple times for the same
+    // event (e.g. event propagation through node ancestors).
+    // Ignore if we've already captured that event.
+    if (!event || lastCapturedEvent === event) {
+      return;
+    }
+
+    // We always want to skip _some_ events.
+    if (shouldSkipDOMEvent(event)) {
+      return;
+    }
+
+    const name = event.type === 'keypress' ? 'input' : event.type;
+
+    // If there is no debounce timer, it means that we can safely capture the new event and store it for future comparisons.
+    if (debounceTimerID === undefined) {
+      handler({
+        event: event,
+        name,
+        global: globalListener,
+      });
+      lastCapturedEvent = event;
+    }
+    // If there is a debounce awaiting, see if the new event is different enough to treat it as a unique one.
+    // If that's the case, emit the previous event and store locally the newly-captured DOM event.
+    else if (shouldShortcircuitPreviousDebounce(lastCapturedEvent, event)) {
+      handler({
+        event: event,
+        name,
+        global: globalListener,
+      });
+      lastCapturedEvent = event;
+    }
+
+    // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.
+    clearTimeout(debounceTimerID);
+    debounceTimerID = WINDOW.setTimeout(() => {
+      debounceTimerID = undefined;
+    }, debounceDuration);
+  };
+}
+
+/** JSDoc */
+function instrumentDOM() {
+  if (!WINDOW.document) {
+    return;
+  }
+
+  // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom
+  // handlers. (Normally we have only one, which captures a breadcrumb for each click or keypress.) Do this before
+  // we instrument `addEventListener` so that we don't end up attaching this handler twice.
+  const triggerDOMHandler = triggerHandlers.bind(null, 'dom');
+  const globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);
+  WINDOW.document.addEventListener('click', globalDOMEventHandler, false);
+  WINDOW.document.addEventListener('keypress', globalDOMEventHandler, false);
+
+  // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled
+  // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That
+  // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler
+  // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still
+  // guaranteed to fire at least once.)
+  ['EventTarget', 'Node'].forEach((target) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    const proto = (WINDOW )[target] && (WINDOW )[target].prototype;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins
+    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {
+      return;
+    }
+
+    fill(proto, 'addEventListener', function (originalAddEventListener) {
+      return function (
+
+        type,
+        listener,
+        options,
+      ) {
+        if (type === 'click' || type == 'keypress') {
+          try {
+            const el = this ;
+            const handlers = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});
+            const handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });
+
+            if (!handlerForType.handler) {
+              const handler = makeDOMEventHandler(triggerDOMHandler);
+              handlerForType.handler = handler;
+              originalAddEventListener.call(this, type, handler, options);
+            }
+
+            handlerForType.refCount++;
+          } catch (e) {
+            // Accessing dom properties is always fragile.
+            // Also allows us to skip `addEventListenrs` calls with no proper `this` context.
+          }
+        }
+
+        return originalAddEventListener.call(this, type, listener, options);
+      };
+    });
+
+    fill(
+      proto,
+      'removeEventListener',
+      function (originalRemoveEventListener) {
+        return function (
+
+          type,
+          listener,
+          options,
+        ) {
+          if (type === 'click' || type == 'keypress') {
+            try {
+              const el = this ;
+              const handlers = el.__sentry_instrumentation_handlers__ || {};
+              const handlerForType = handlers[type];
+
+              if (handlerForType) {
+                handlerForType.refCount--;
+                // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.
+                if (handlerForType.refCount <= 0) {
+                  originalRemoveEventListener.call(this, type, handlerForType.handler, options);
+                  handlerForType.handler = undefined;
+                  delete handlers[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete
+                }
+
+                // If there are no longer any custom handlers of any type on this element, cleanup everything.
+                if (Object.keys(handlers).length === 0) {
+                  delete el.__sentry_instrumentation_handlers__;
+                }
+              }
+            } catch (e) {
+              // Accessing dom properties is always fragile.
+              // Also allows us to skip `addEventListenrs` calls with no proper `this` context.
+            }
+          }
+
+          return originalRemoveEventListener.call(this, type, listener, options);
+        };
+      },
+    );
+  });
+}
+
+let _oldOnErrorHandler = null;
+/** JSDoc */
+function instrumentError() {
+  _oldOnErrorHandler = WINDOW.onerror;
+
+  WINDOW.onerror = function (msg, url, line, column, error) {
+    triggerHandlers('error', {
+      column,
+      error,
+      line,
+      msg,
+      url,
+    });
+
+    if (_oldOnErrorHandler && !_oldOnErrorHandler.__SENTRY_LOADER__) {
+      // eslint-disable-next-line prefer-rest-params
+      return _oldOnErrorHandler.apply(this, arguments);
+    }
+
+    return false;
+  };
+
+  WINDOW.onerror.__SENTRY_INSTRUMENTED__ = true;
+}
+
+let _oldOnUnhandledRejectionHandler = null;
+/** JSDoc */
+function instrumentUnhandledRejection() {
+  _oldOnUnhandledRejectionHandler = WINDOW.onunhandledrejection;
+
+  WINDOW.onunhandledrejection = function (e) {
+    triggerHandlers('unhandledrejection', e);
+
+    if (_oldOnUnhandledRejectionHandler && !_oldOnUnhandledRejectionHandler.__SENTRY_LOADER__) {
+      // eslint-disable-next-line prefer-rest-params
+      return _oldOnUnhandledRejectionHandler.apply(this, arguments);
+    }
+
+    return true;
+  };
+
+  WINDOW.onunhandledrejection.__SENTRY_INSTRUMENTED__ = true;
+}
+
+export { SENTRY_XHR_DATA_KEY, addInstrumentationHandler, instrumentDOM, instrumentXHR, parseFetchArgs, resetInstrumentationHandlers };
+//# sourceMappingURL=instrument.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/is.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/is.js
new file mode 100644
index 0000000..2ed8c2e
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/is.js
@@ -0,0 +1,190 @@
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const objectToString = Object.prototype.toString;
+
+/**
+ * Checks whether given value's type is one of a few Error or Error-like
+ * {@link isError}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isError(wat) {
+  switch (objectToString.call(wat)) {
+    case '[object Error]':
+    case '[object Exception]':
+    case '[object DOMException]':
+      return true;
+    default:
+      return isInstanceOf(wat, Error);
+  }
+}
+/**
+ * Checks whether given value is an instance of the given built-in class.
+ *
+ * @param wat The value to be checked
+ * @param className
+ * @returns A boolean representing the result.
+ */
+function isBuiltin(wat, className) {
+  return objectToString.call(wat) === `[object ${className}]`;
+}
+
+/**
+ * Checks whether given value's type is ErrorEvent
+ * {@link isErrorEvent}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isErrorEvent(wat) {
+  return isBuiltin(wat, 'ErrorEvent');
+}
+
+/**
+ * Checks whether given value's type is DOMError
+ * {@link isDOMError}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isDOMError(wat) {
+  return isBuiltin(wat, 'DOMError');
+}
+
+/**
+ * Checks whether given value's type is DOMException
+ * {@link isDOMException}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isDOMException(wat) {
+  return isBuiltin(wat, 'DOMException');
+}
+
+/**
+ * Checks whether given value's type is a string
+ * {@link isString}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isString(wat) {
+  return isBuiltin(wat, 'String');
+}
+
+/**
+ * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)
+ * {@link isPrimitive}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isPrimitive(wat) {
+  return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');
+}
+
+/**
+ * Checks whether given value's type is an object literal
+ * {@link isPlainObject}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isPlainObject(wat) {
+  return isBuiltin(wat, 'Object');
+}
+
+/**
+ * Checks whether given value's type is an Event instance
+ * {@link isEvent}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isEvent(wat) {
+  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);
+}
+
+/**
+ * Checks whether given value's type is an Element instance
+ * {@link isElement}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isElement(wat) {
+  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);
+}
+
+/**
+ * Checks whether given value's type is an regexp
+ * {@link isRegExp}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isRegExp(wat) {
+  return isBuiltin(wat, 'RegExp');
+}
+
+/**
+ * Checks whether given value has a then function.
+ * @param wat A value to be checked.
+ */
+function isThenable(wat) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  return Boolean(wat && wat.then && typeof wat.then === 'function');
+}
+
+/**
+ * Checks whether given value's type is a SyntheticEvent
+ * {@link isSyntheticEvent}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isSyntheticEvent(wat) {
+  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;
+}
+
+/**
+ * Checks whether given value is NaN
+ * {@link isNaN}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isNaN(wat) {
+  return typeof wat === 'number' && wat !== wat;
+}
+
+/**
+ * Checks whether given value's type is an instance of provided constructor.
+ * {@link isInstanceOf}.
+ *
+ * @param wat A value to be checked.
+ * @param base A constructor to be used in a check.
+ * @returns A boolean representing the result.
+ */
+function isInstanceOf(wat, base) {
+  try {
+    return wat instanceof base;
+  } catch (_e) {
+    return false;
+  }
+}
+
+/**
+ * Checks whether given value's type is a Vue ViewModel.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isVueViewModel(wat) {
+  // Not using Object.prototype.toString because in Vue 3 it would read the instance's Symbol(Symbol.toStringTag) property.
+  return !!(typeof wat === 'object' && wat !== null && ((wat ).__isVue || (wat )._isVue));
+}
+
+export { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isNaN, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable, isVueViewModel };
+//# sourceMappingURL=is.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/logger.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/logger.js
new file mode 100644
index 0000000..efa35e4
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/logger.js
@@ -0,0 +1,82 @@
+import { GLOBAL_OBJ } from './worldwide.js';
+
+/** Prefix for logging strings */
+const PREFIX = 'Sentry Logger ';
+
+const CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] ;
+
+/** This may be mutated by the console instrumentation. */
+const originalConsoleMethods
+
+ = {};
+
+/** JSDoc */
+
+/**
+ * Temporarily disable sentry console instrumentations.
+ *
+ * @param callback The function to run against the original `console` messages
+ * @returns The results of the callback
+ */
+function consoleSandbox(callback) {
+  if (!('console' in GLOBAL_OBJ)) {
+    return callback();
+  }
+
+  const console = GLOBAL_OBJ.console ;
+  const wrappedFuncs = {};
+
+  const wrappedLevels = Object.keys(originalConsoleMethods) ;
+
+  // Restore all wrapped console methods
+  wrappedLevels.forEach(level => {
+    const originalConsoleMethod = originalConsoleMethods[level] ;
+    wrappedFuncs[level] = console[level] ;
+    console[level] = originalConsoleMethod;
+  });
+
+  try {
+    return callback();
+  } finally {
+    // Revert restoration to wrapped state
+    wrappedLevels.forEach(level => {
+      console[level] = wrappedFuncs[level] ;
+    });
+  }
+}
+
+function makeLogger() {
+  let enabled = false;
+  const logger = {
+    enable: () => {
+      enabled = true;
+    },
+    disable: () => {
+      enabled = false;
+    },
+  };
+
+  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+    CONSOLE_LEVELS.forEach(name => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      logger[name] = (...args) => {
+        if (enabled) {
+          consoleSandbox(() => {
+            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);
+          });
+        }
+      };
+    });
+  } else {
+    CONSOLE_LEVELS.forEach(name => {
+      logger[name] = () => undefined;
+    });
+  }
+
+  return logger ;
+}
+
+const logger = makeLogger();
+
+export { CONSOLE_LEVELS, consoleSandbox, logger, originalConsoleMethods };
+//# sourceMappingURL=logger.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/memo.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/memo.js
new file mode 100644
index 0000000..fe00c9c
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/memo.js
@@ -0,0 +1,45 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/**
+ * Helper to decycle json objects
+ */
+function memoBuilder() {
+  const hasWeakSet = typeof WeakSet === 'function';
+  const inner = hasWeakSet ? new WeakSet() : [];
+  function memoize(obj) {
+    if (hasWeakSet) {
+      if (inner.has(obj)) {
+        return true;
+      }
+      inner.add(obj);
+      return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let i = 0; i < inner.length; i++) {
+      const value = inner[i];
+      if (value === obj) {
+        return true;
+      }
+    }
+    inner.push(obj);
+    return false;
+  }
+
+  function unmemoize(obj) {
+    if (hasWeakSet) {
+      inner.delete(obj);
+    } else {
+      for (let i = 0; i < inner.length; i++) {
+        if (inner[i] === obj) {
+          inner.splice(i, 1);
+          break;
+        }
+      }
+    }
+  }
+  return [memoize, unmemoize];
+}
+
+export { memoBuilder };
+//# sourceMappingURL=memo.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/misc.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/misc.js
new file mode 100644
index 0000000..5685693
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/misc.js
@@ -0,0 +1,203 @@
+import { addNonEnumerableProperty } from './object.js';
+import { snipLine } from './string.js';
+import { GLOBAL_OBJ } from './worldwide.js';
+
+/**
+ * UUID4 generator
+ *
+ * @returns string Generated UUID4.
+ */
+function uuid4() {
+  const gbl = GLOBAL_OBJ ;
+  const crypto = gbl.crypto || gbl.msCrypto;
+
+  let getRandomByte = () => Math.random() * 16;
+  try {
+    if (crypto && crypto.randomUUID) {
+      return crypto.randomUUID().replace(/-/g, '');
+    }
+    if (crypto && crypto.getRandomValues) {
+      getRandomByte = () => crypto.getRandomValues(new Uint8Array(1))[0];
+    }
+  } catch (_) {
+    // some runtimes can crash invoking crypto
+    // https://github.com/getsentry/sentry-javascript/issues/8935
+  }
+
+  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
+  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'
+  return (([1e7] ) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>
+    // eslint-disable-next-line no-bitwise
+    ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),
+  );
+}
+
+function getFirstException(event) {
+  return event.exception && event.exception.values ? event.exception.values[0] : undefined;
+}
+
+/**
+ * Extracts either message or type+value from an event that can be used for user-facing logs
+ * @returns event's description
+ */
+function getEventDescription(event) {
+  const { message, event_id: eventId } = event;
+  if (message) {
+    return message;
+  }
+
+  const firstException = getFirstException(event);
+  if (firstException) {
+    if (firstException.type && firstException.value) {
+      return `${firstException.type}: ${firstException.value}`;
+    }
+    return firstException.type || firstException.value || eventId || '<unknown>';
+  }
+  return eventId || '<unknown>';
+}
+
+/**
+ * Adds exception values, type and value to an synthetic Exception.
+ * @param event The event to modify.
+ * @param value Value of the exception.
+ * @param type Type of the exception.
+ * @hidden
+ */
+function addExceptionTypeValue(event, value, type) {
+  const exception = (event.exception = event.exception || {});
+  const values = (exception.values = exception.values || []);
+  const firstException = (values[0] = values[0] || {});
+  if (!firstException.value) {
+    firstException.value = value || '';
+  }
+  if (!firstException.type) {
+    firstException.type = type || 'Error';
+  }
+}
+
+/**
+ * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.
+ *
+ * @param event The event to modify.
+ * @param newMechanism Mechanism data to add to the event.
+ * @hidden
+ */
+function addExceptionMechanism(event, newMechanism) {
+  const firstException = getFirstException(event);
+  if (!firstException) {
+    return;
+  }
+
+  const defaultMechanism = { type: 'generic', handled: true };
+  const currentMechanism = firstException.mechanism;
+  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };
+
+  if (newMechanism && 'data' in newMechanism) {
+    const mergedData = { ...(currentMechanism && currentMechanism.data), ...newMechanism.data };
+    firstException.mechanism.data = mergedData;
+  }
+}
+
+// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+const SEMVER_REGEXP =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+
+/**
+ * Represents Semantic Versioning object
+ */
+
+/**
+ * Parses input into a SemVer interface
+ * @param input string representation of a semver version
+ */
+function parseSemver(input) {
+  const match = input.match(SEMVER_REGEXP) || [];
+  const major = parseInt(match[1], 10);
+  const minor = parseInt(match[2], 10);
+  const patch = parseInt(match[3], 10);
+  return {
+    buildmetadata: match[5],
+    major: isNaN(major) ? undefined : major,
+    minor: isNaN(minor) ? undefined : minor,
+    patch: isNaN(patch) ? undefined : patch,
+    prerelease: match[4],
+  };
+}
+
+/**
+ * This function adds context (pre/post/line) lines to the provided frame
+ *
+ * @param lines string[] containing all lines
+ * @param frame StackFrame that will be mutated
+ * @param linesOfContext number of context lines we want to add pre/post
+ */
+function addContextToFrame(lines, frame, linesOfContext = 5) {
+  // When there is no line number in the frame, attaching context is nonsensical and will even break grouping
+  if (frame.lineno === undefined) {
+    return;
+  }
+
+  const maxLines = lines.length;
+  const sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0);
+
+  frame.pre_context = lines
+    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)
+    .map((line) => snipLine(line, 0));
+
+  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);
+
+  frame.post_context = lines
+    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)
+    .map((line) => snipLine(line, 0));
+}
+
+/**
+ * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object
+ * in question), and marks it captured if not.
+ *
+ * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and
+ * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so
+ * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because
+ * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not
+ * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This
+ * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we
+ * see it.
+ *
+ * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on
+ * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent
+ * object wrapper forms so that this check will always work. However, because we need to flag the exact object which
+ * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification
+ * must be done before the exception captured.
+ *
+ * @param A thrown exception to check or flag as having been seen
+ * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)
+ */
+function checkOrSetAlreadyCaught(exception) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  if (exception && (exception ).__sentry_captured__) {
+    return true;
+  }
+
+  try {
+    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the
+    // `ExtraErrorData` integration
+    addNonEnumerableProperty(exception , '__sentry_captured__', true);
+  } catch (err) {
+    // `exception` is a primitive, so we can't mark it seen
+  }
+
+  return false;
+}
+
+/**
+ * Checks whether the given input is already an array, and if it isn't, wraps it in one.
+ *
+ * @param maybeArray Input to turn into an array, if necessary
+ * @returns The input, if already an array, or an array with the input as the only element, if not
+ */
+function arrayify(maybeArray) {
+  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];
+}
+
+export { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, arrayify, checkOrSetAlreadyCaught, getEventDescription, parseSemver, uuid4 };
+//# sourceMappingURL=misc.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/node.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/node.js
new file mode 100644
index 0000000..49eb7d7
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/node.js
@@ -0,0 +1,66 @@
+import { isBrowserBundle } from './env.js';
+
+/**
+ * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,
+ * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.
+ */
+
+/**
+ * Checks whether we're in the Node.js or Browser environment
+ *
+ * @returns Answer to given question
+ */
+function isNodeEnv() {
+  // explicitly check for browser bundles as those can be optimized statically
+  // by terser/rollup.
+  return (
+    !isBrowserBundle() &&
+    Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'
+  );
+}
+
+/**
+ * Requires a module which is protected against bundler minification.
+ *
+ * @param request The module path to resolve
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+function dynamicRequire(mod, request) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  return mod.require(request);
+}
+
+/**
+ * Helper for dynamically loading module that should work with linked dependencies.
+ * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`
+ * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during
+ * build time. `require.resolve` is also not available in any other way, so we cannot create,
+ * a fake helper like we do with `dynamicRequire`.
+ *
+ * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.
+ * That is to mimic the behavior of `require.resolve` exactly.
+ *
+ * @param moduleName module name to require
+ * @returns possibly required module
+ */
+function loadModule(moduleName) {
+  let mod;
+
+  try {
+    mod = dynamicRequire(module, moduleName);
+  } catch (e) {
+    // no-empty
+  }
+
+  try {
+    const { cwd } = dynamicRequire(module, 'process');
+    mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) ;
+  } catch (e) {
+    // no-empty
+  }
+
+  return mod;
+}
+
+export { dynamicRequire, isNodeEnv, loadModule };
+//# sourceMappingURL=node.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/normalize.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/normalize.js
new file mode 100644
index 0000000..a8a81ee
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/normalize.js
@@ -0,0 +1,267 @@
+import { isNaN, isVueViewModel, isSyntheticEvent } from './is.js';
+import { memoBuilder } from './memo.js';
+import { convertToPlainObject } from './object.js';
+import { getFunctionName } from './stacktrace.js';
+
+/**
+ * Recursively normalizes the given object.
+ *
+ * - Creates a copy to prevent original input mutation
+ * - Skips non-enumerable properties
+ * - When stringifying, calls `toJSON` if implemented
+ * - Removes circular references
+ * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format
+ * - Translates known global objects/classes to a string representations
+ * - Takes care of `Error` object serialization
+ * - Optionally limits depth of final output
+ * - Optionally limits number of properties/elements included in any single object/array
+ *
+ * @param input The object to be normalized.
+ * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)
+ * @param maxProperties The max number of elements or properties to be included in any single array or
+ * object in the normallized output.
+ * @returns A normalized version of the object, or `"**non-serializable**"` if any errors are thrown during normalization.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function normalize(input, depth = 100, maxProperties = +Infinity) {
+  try {
+    // since we're at the outermost level, we don't provide a key
+    return visit('', input, depth, maxProperties);
+  } catch (err) {
+    return { ERROR: `**non-serializable** (${err})` };
+  }
+}
+
+/** JSDoc */
+function normalizeToSize(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  object,
+  // Default Node.js REPL depth
+  depth = 3,
+  // 100kB, as 200kB is max payload size, so half sounds reasonable
+  maxSize = 100 * 1024,
+) {
+  const normalized = normalize(object, depth);
+
+  if (jsonSize(normalized) > maxSize) {
+    return normalizeToSize(object, depth - 1, maxSize);
+  }
+
+  return normalized ;
+}
+
+/**
+ * Visits a node to perform normalization on it
+ *
+ * @param key The key corresponding to the given node
+ * @param value The node to be visited
+ * @param depth Optional number indicating the maximum recursion depth
+ * @param maxProperties Optional maximum number of properties/elements included in any single object/array
+ * @param memo Optional Memo class handling decycling
+ */
+function visit(
+  key,
+  value,
+  depth = +Infinity,
+  maxProperties = +Infinity,
+  memo = memoBuilder(),
+) {
+  const [memoize, unmemoize] = memo;
+
+  // Get the simple cases out of the way first
+  if (
+    value == null || // this matches null and undefined -> eqeq not eqeqeq
+    (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))
+  ) {
+    return value ;
+  }
+
+  const stringified = stringifyValue(key, value);
+
+  // Anything we could potentially dig into more (objects or arrays) will have come back as `"[object XXXX]"`.
+  // Everything else will have already been serialized, so if we don't see that pattern, we're done.
+  if (!stringified.startsWith('[object ')) {
+    return stringified;
+  }
+
+  // From here on, we can assert that `value` is either an object or an array.
+
+  // Do not normalize objects that we know have already been normalized. As a general rule, the
+  // "__sentry_skip_normalization__" property should only be used sparingly and only should only be set on objects that
+  // have already been normalized.
+  if ((value )['__sentry_skip_normalization__']) {
+    return value ;
+  }
+
+  // We can set `__sentry_override_normalization_depth__` on an object to ensure that from there
+  // We keep a certain amount of depth.
+  // This should be used sparingly, e.g. we use it for the redux integration to ensure we get a certain amount of state.
+  const remainingDepth =
+    typeof (value )['__sentry_override_normalization_depth__'] === 'number'
+      ? ((value )['__sentry_override_normalization_depth__'] )
+      : depth;
+
+  // We're also done if we've reached the max depth
+  if (remainingDepth === 0) {
+    // At this point we know `serialized` is a string of the form `"[object XXXX]"`. Clean it up so it's just `"[XXXX]"`.
+    return stringified.replace('object ', '');
+  }
+
+  // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.
+  if (memoize(value)) {
+    return '[Circular ~]';
+  }
+
+  // If the value has a `toJSON` method, we call it to extract more information
+  const valueWithToJSON = value ;
+  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {
+    try {
+      const jsonValue = valueWithToJSON.toJSON();
+      // We need to normalize the return value of `.toJSON()` in case it has circular references
+      return visit('', jsonValue, remainingDepth - 1, maxProperties, memo);
+    } catch (err) {
+      // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)
+    }
+  }
+
+  // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse
+  // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each
+  // property/entry, and keep track of the number of items we add to it.
+  const normalized = (Array.isArray(value) ? [] : {}) ;
+  let numAdded = 0;
+
+  // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant
+  // properties are non-enumerable and otherwise would get missed.
+  const visitable = convertToPlainObject(value );
+
+  for (const visitKey in visitable) {
+    // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.
+    if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {
+      continue;
+    }
+
+    if (numAdded >= maxProperties) {
+      normalized[visitKey] = '[MaxProperties ~]';
+      break;
+    }
+
+    // Recursively visit all the child nodes
+    const visitValue = visitable[visitKey];
+    normalized[visitKey] = visit(visitKey, visitValue, remainingDepth - 1, maxProperties, memo);
+
+    numAdded++;
+  }
+
+  // Once we've visited all the branches, remove the parent from memo storage
+  unmemoize(value);
+
+  // Return accumulated values
+  return normalized;
+}
+
+/* eslint-disable complexity */
+/**
+ * Stringify the given value. Handles various known special values and types.
+ *
+ * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn
+ * the number 1231 into "[Object Number]", nor on `null`, as it will throw.
+ *
+ * @param value The value to stringify
+ * @returns A stringified representation of the given value
+ */
+function stringifyValue(
+  key,
+  // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for
+  // our internal use, it'll do
+  value,
+) {
+  try {
+    if (key === 'domain' && value && typeof value === 'object' && (value )._events) {
+      return '[Domain]';
+    }
+
+    if (key === 'domainEmitter') {
+      return '[DomainEmitter]';
+    }
+
+    // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first
+    // which won't throw if they are not present.
+
+    if (typeof global !== 'undefined' && value === global) {
+      return '[Global]';
+    }
+
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof window !== 'undefined' && value === window) {
+      return '[Window]';
+    }
+
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof document !== 'undefined' && value === document) {
+      return '[Document]';
+    }
+
+    if (isVueViewModel(value)) {
+      return '[VueViewModel]';
+    }
+
+    // React's SyntheticEvent thingy
+    if (isSyntheticEvent(value)) {
+      return '[SyntheticEvent]';
+    }
+
+    if (typeof value === 'number' && value !== value) {
+      return '[NaN]';
+    }
+
+    if (typeof value === 'function') {
+      return `[Function: ${getFunctionName(value)}]`;
+    }
+
+    if (typeof value === 'symbol') {
+      return `[${String(value)}]`;
+    }
+
+    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion
+    if (typeof value === 'bigint') {
+      return `[BigInt: ${String(value)}]`;
+    }
+
+    // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting
+    // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as
+    // `"[object Object]"`. If we instead look at the constructor's name (which is the same as the name of the class),
+    // we can make sure that only plain objects come out that way.
+    const objName = getConstructorName(value);
+
+    // Handle HTML Elements
+    if (/^HTML(\w*)Element$/.test(objName)) {
+      return `[HTMLElement: ${objName}]`;
+    }
+
+    return `[object ${objName}]`;
+  } catch (err) {
+    return `**non-serializable** (${err})`;
+  }
+}
+/* eslint-enable complexity */
+
+function getConstructorName(value) {
+  const prototype = Object.getPrototypeOf(value);
+
+  return prototype ? prototype.constructor.name : 'null prototype';
+}
+
+/** Calculates bytes size of input string */
+function utf8Length(value) {
+  // eslint-disable-next-line no-bitwise
+  return ~-encodeURI(value).split(/%..|./).length;
+}
+
+/** Calculates bytes size of input object */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function jsonSize(value) {
+  return utf8Length(JSON.stringify(value));
+}
+
+export { normalize, normalizeToSize, visit as walk };
+//# sourceMappingURL=normalize.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/object.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/object.js
new file mode 100644
index 0000000..58706b7
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/object.js
@@ -0,0 +1,281 @@
+import { htmlTreeAsString } from './browser.js';
+import { isError, isEvent, isInstanceOf, isElement, isPlainObject, isPrimitive } from './is.js';
+import { logger } from './logger.js';
+import { truncate } from './string.js';
+
+/**
+ * Replace a method in an object with a wrapped version of itself.
+ *
+ * @param source An object that contains a method to be wrapped.
+ * @param name The name of the method to be wrapped.
+ * @param replacementFactory A higher-order function that takes the original version of the given method and returns a
+ * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to
+ * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other
+ * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.
+ * @returns void
+ */
+function fill(source, name, replacementFactory) {
+  if (!(name in source)) {
+    return;
+  }
+
+  const original = source[name] ;
+  const wrapped = replacementFactory(original) ;
+
+  // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work
+  // otherwise it'll throw "TypeError: Object.defineProperties called on non-object"
+  if (typeof wrapped === 'function') {
+    markFunctionWrapped(wrapped, original);
+  }
+
+  source[name] = wrapped;
+}
+
+/**
+ * Defines a non-enumerable property on the given object.
+ *
+ * @param obj The object on which to set the property
+ * @param name The name of the property to be set
+ * @param value The value to which to set the property
+ */
+function addNonEnumerableProperty(obj, name, value) {
+  try {
+    Object.defineProperty(obj, name, {
+      // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it
+      value: value,
+      writable: true,
+      configurable: true,
+    });
+  } catch (o_O) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Failed to add non-enumerable property "${name}" to object`, obj);
+  }
+}
+
+/**
+ * Remembers the original function on the wrapped function and
+ * patches up the prototype.
+ *
+ * @param wrapped the wrapper function
+ * @param original the original function that gets wrapped
+ */
+function markFunctionWrapped(wrapped, original) {
+  try {
+    const proto = original.prototype || {};
+    wrapped.prototype = original.prototype = proto;
+    addNonEnumerableProperty(wrapped, '__sentry_original__', original);
+  } catch (o_O) {} // eslint-disable-line no-empty
+}
+
+/**
+ * This extracts the original function if available.  See
+ * `markFunctionWrapped` for more information.
+ *
+ * @param func the function to unwrap
+ * @returns the unwrapped version of the function if available.
+ */
+function getOriginalFunction(func) {
+  return func.__sentry_original__;
+}
+
+/**
+ * Encodes given object into url-friendly format
+ *
+ * @param object An object that contains serializable values
+ * @returns string Encoded
+ */
+function urlEncode(object) {
+  return Object.keys(object)
+    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`)
+    .join('&');
+}
+
+/**
+ * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their
+ * non-enumerable properties attached.
+ *
+ * @param value Initial source that we have to transform in order for it to be usable by the serializer
+ * @returns An Event or Error turned into an object - or the value argurment itself, when value is neither an Event nor
+ *  an Error.
+ */
+function convertToPlainObject(value)
+
+ {
+  if (isError(value)) {
+    return {
+      message: value.message,
+      name: value.name,
+      stack: value.stack,
+      ...getOwnProperties(value),
+    };
+  } else if (isEvent(value)) {
+    const newObj
+
+ = {
+      type: value.type,
+      target: serializeEventTarget(value.target),
+      currentTarget: serializeEventTarget(value.currentTarget),
+      ...getOwnProperties(value),
+    };
+
+    if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {
+      newObj.detail = value.detail;
+    }
+
+    return newObj;
+  } else {
+    return value;
+  }
+}
+
+/** Creates a string representation of the target of an `Event` object */
+function serializeEventTarget(target) {
+  try {
+    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);
+  } catch (_oO) {
+    return '<unknown>';
+  }
+}
+
+/** Filters out all but an object's own properties */
+function getOwnProperties(obj) {
+  if (typeof obj === 'object' && obj !== null) {
+    const extractedProps = {};
+    for (const property in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, property)) {
+        extractedProps[property] = (obj )[property];
+      }
+    }
+    return extractedProps;
+  } else {
+    return {};
+  }
+}
+
+/**
+ * Given any captured exception, extract its keys and create a sorted
+ * and truncated list that will be used inside the event message.
+ * eg. `Non-error exception captured with keys: foo, bar, baz`
+ */
+function extractExceptionKeysForMessage(exception, maxLength = 40) {
+  const keys = Object.keys(convertToPlainObject(exception));
+  keys.sort();
+
+  if (!keys.length) {
+    return '[object has no keys]';
+  }
+
+  if (keys[0].length >= maxLength) {
+    return truncate(keys[0], maxLength);
+  }
+
+  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {
+    const serialized = keys.slice(0, includedKeys).join(', ');
+    if (serialized.length > maxLength) {
+      continue;
+    }
+    if (includedKeys === keys.length) {
+      return serialized;
+    }
+    return truncate(serialized, maxLength);
+  }
+
+  return '';
+}
+
+/**
+ * Given any object, return a new object having removed all fields whose value was `undefined`.
+ * Works recursively on objects and arrays.
+ *
+ * Attention: This function keeps circular references in the returned object.
+ */
+function dropUndefinedKeys(inputValue) {
+  // This map keeps track of what already visited nodes map to.
+  // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular
+  // references as the input object.
+  const memoizationMap = new Map();
+
+  // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API
+  return _dropUndefinedKeys(inputValue, memoizationMap);
+}
+
+function _dropUndefinedKeys(inputValue, memoizationMap) {
+  if (isPlainObject(inputValue)) {
+    // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object
+    const memoVal = memoizationMap.get(inputValue);
+    if (memoVal !== undefined) {
+      return memoVal ;
+    }
+
+    const returnValue = {};
+    // Store the mapping of this value in case we visit it again, in case of circular data
+    memoizationMap.set(inputValue, returnValue);
+
+    for (const key of Object.keys(inputValue)) {
+      if (typeof inputValue[key] !== 'undefined') {
+        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);
+      }
+    }
+
+    return returnValue ;
+  }
+
+  if (Array.isArray(inputValue)) {
+    // If this node has already been visited due to a circular reference, return the array it was mapped to in the new object
+    const memoVal = memoizationMap.get(inputValue);
+    if (memoVal !== undefined) {
+      return memoVal ;
+    }
+
+    const returnValue = [];
+    // Store the mapping of this value in case we visit it again, in case of circular data
+    memoizationMap.set(inputValue, returnValue);
+
+    inputValue.forEach((item) => {
+      returnValue.push(_dropUndefinedKeys(item, memoizationMap));
+    });
+
+    return returnValue ;
+  }
+
+  return inputValue;
+}
+
+/**
+ * Ensure that something is an object.
+ *
+ * Turns `undefined` and `null` into `String`s and all other primitives into instances of their respective wrapper
+ * classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.
+ *
+ * @param wat The subject of the objectification
+ * @returns A version of `wat` which can safely be used with `Object` class methods
+ */
+function objectify(wat) {
+  let objectified;
+  switch (true) {
+    case wat === undefined || wat === null:
+      objectified = new String(wat);
+      break;
+
+    // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason
+    // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as
+    // an object in order to wrap it.
+    case typeof wat === 'symbol' || typeof wat === 'bigint':
+      objectified = Object(wat);
+      break;
+
+    // this will catch the remaining primitives: `String`, `Number`, and `Boolean`
+    case isPrimitive(wat):
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      objectified = new (wat ).constructor(wat);
+      break;
+
+    // by process of elimination, at this point we know that `wat` must already be an object
+    default:
+      objectified = wat;
+      break;
+  }
+  return objectified;
+}
+
+export { addNonEnumerableProperty, convertToPlainObject, dropUndefinedKeys, extractExceptionKeysForMessage, fill, getOriginalFunction, markFunctionWrapped, objectify, urlEncode };
+//# sourceMappingURL=object.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/severity.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/severity.js
new file mode 100644
index 0000000..3e5128e
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/severity.js
@@ -0,0 +1,36 @@
+// Note: Ideally the `SeverityLevel` type would be derived from `validSeverityLevels`, but that would mean either
+//
+// a) moving `validSeverityLevels` to `@sentry/types`,
+// b) moving the`SeverityLevel` type here, or
+// c) importing `validSeverityLevels` from here into `@sentry/types`.
+//
+// Option A would make `@sentry/types` a runtime dependency of `@sentry/utils` (not good), and options B and C would
+// create a circular dependency between `@sentry/types` and `@sentry/utils` (also not good). So a TODO accompanying the
+// type, reminding anyone who changes it to change this list also, will have to do.
+
+const validSeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];
+
+/**
+ * Converts a string-based level into a member of the deprecated {@link Severity} enum.
+ *
+ * @deprecated `severityFromString` is deprecated. Please use `severityLevelFromString` instead.
+ *
+ * @param level String representation of Severity
+ * @returns Severity
+ */
+function severityFromString(level) {
+  return severityLevelFromString(level) ;
+}
+
+/**
+ * Converts a string-based level into a `SeverityLevel`, normalizing it along the way.
+ *
+ * @param level String representation of desired `SeverityLevel`.
+ * @returns The `SeverityLevel` corresponding to the given string, or 'log' if the string isn't a valid level.
+ */
+function severityLevelFromString(level) {
+  return (level === 'warn' ? 'warning' : validSeverityLevels.includes(level) ? level : 'log') ;
+}
+
+export { severityFromString, severityLevelFromString, validSeverityLevels };
+//# sourceMappingURL=severity.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/stacktrace.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/stacktrace.js
new file mode 100644
index 0000000..4ea2d17
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/stacktrace.js
@@ -0,0 +1,147 @@
+import { node } from './node-stack-trace.js';
+
+const STACKTRACE_FRAME_LIMIT = 50;
+// Used to sanitize webpack (error: *) wrapped stack errors
+const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
+const STRIP_FRAME_REGEXP = /captureMessage|captureException/;
+
+/**
+ * Creates a stack parser with the supplied line parsers
+ *
+ * StackFrames are returned in the correct order for Sentry Exception
+ * frames and with Sentry SDK internal frames removed from the top and bottom
+ *
+ */
+function createStackParser(...parsers) {
+  const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);
+
+  return (stack, skipFirst = 0) => {
+    const frames = [];
+    const lines = stack.split('\n');
+
+    for (let i = skipFirst; i < lines.length; i++) {
+      const line = lines[i];
+      // Ignore lines over 1kb as they are unlikely to be stack frames.
+      // Many of the regular expressions use backtracking which results in run time that increases exponentially with
+      // input size. Huge strings can result in hangs/Denial of Service:
+      // https://github.com/getsentry/sentry-javascript/issues/2286
+      if (line.length > 1024) {
+        continue;
+      }
+
+      // https://github.com/getsentry/sentry-javascript/issues/5459
+      // Remove webpack (error: *) wrappers
+      const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;
+
+      // https://github.com/getsentry/sentry-javascript/issues/7813
+      // Skip Error: lines
+      if (cleanedLine.match(/\S*Error: /)) {
+        continue;
+      }
+
+      for (const parser of sortedParsers) {
+        const frame = parser(cleanedLine);
+
+        if (frame) {
+          frames.push(frame);
+          break;
+        }
+      }
+
+      if (frames.length >= STACKTRACE_FRAME_LIMIT) {
+        break;
+      }
+    }
+
+    return stripSentryFramesAndReverse(frames);
+  };
+}
+
+/**
+ * Gets a stack parser implementation from Options.stackParser
+ * @see Options
+ *
+ * If options contains an array of line parsers, it is converted into a parser
+ */
+function stackParserFromStackParserOptions(stackParser) {
+  if (Array.isArray(stackParser)) {
+    return createStackParser(...stackParser);
+  }
+  return stackParser;
+}
+
+/**
+ * Removes Sentry frames from the top and bottom of the stack if present and enforces a limit of max number of frames.
+ * Assumes stack input is ordered from top to bottom and returns the reverse representation so call site of the
+ * function that caused the crash is the last frame in the array.
+ * @hidden
+ */
+function stripSentryFramesAndReverse(stack) {
+  if (!stack.length) {
+    return [];
+  }
+
+  const localStack = Array.from(stack);
+
+  // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)
+  if (/sentryWrapped/.test(localStack[localStack.length - 1].function || '')) {
+    localStack.pop();
+  }
+
+  // Reversing in the middle of the procedure allows us to just pop the values off the stack
+  localStack.reverse();
+
+  // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)
+  if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {
+    localStack.pop();
+
+    // When using synthetic events, we will have a 2 levels deep stack, as `new Error('Sentry syntheticException')`
+    // is produced within the hub itself, making it:
+    //
+    //   Sentry.captureException()
+    //   getCurrentHub().captureException()
+    //
+    // instead of just the top `Sentry` call itself.
+    // This forces us to possibly strip an additional frame in the exact same was as above.
+    if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {
+      localStack.pop();
+    }
+  }
+
+  return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map(frame => ({
+    ...frame,
+    filename: frame.filename || localStack[localStack.length - 1].filename,
+    function: frame.function || '?',
+  }));
+}
+
+const defaultFunctionName = '<anonymous>';
+
+/**
+ * Safely extract function name from itself
+ */
+function getFunctionName(fn) {
+  try {
+    if (!fn || typeof fn !== 'function') {
+      return defaultFunctionName;
+    }
+    return fn.name || defaultFunctionName;
+  } catch (e) {
+    // Just accessing custom props in some Selenium environments
+    // can cause a "Permission denied" exception (see raven-js#495).
+    return defaultFunctionName;
+  }
+}
+
+/**
+ * Node.js stack line parser
+ *
+ * This is in @sentry/utils so it can be used from the Electron SDK in the browser for when `nodeIntegration == true`.
+ * This allows it to be used without referencing or importing any node specific code which causes bundlers to complain
+ */
+function nodeStackLineParser(getModule) {
+  return [90, node(getModule)];
+}
+
+export { createStackParser, getFunctionName, nodeStackLineParser, stackParserFromStackParserOptions, stripSentryFramesAndReverse };
+//# sourceMappingURL=stacktrace.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/string.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/string.js
new file mode 100644
index 0000000..b6d3514
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/string.js
@@ -0,0 +1,141 @@
+import { isVueViewModel, isString, isRegExp } from './is.js';
+
+/**
+ * Truncates given string to the maximum characters count
+ *
+ * @param str An object that contains serializable values
+ * @param max Maximum number of characters in truncated string (0 = unlimited)
+ * @returns string Encoded
+ */
+function truncate(str, max = 0) {
+  if (typeof str !== 'string' || max === 0) {
+    return str;
+  }
+  return str.length <= max ? str : `${str.slice(0, max)}...`;
+}
+
+/**
+ * This is basically just `trim_line` from
+ * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67
+ *
+ * @param str An object that contains serializable values
+ * @param max Maximum number of characters in truncated string
+ * @returns string Encoded
+ */
+function snipLine(line, colno) {
+  let newLine = line;
+  const lineLength = newLine.length;
+  if (lineLength <= 150) {
+    return newLine;
+  }
+  if (colno > lineLength) {
+    // eslint-disable-next-line no-param-reassign
+    colno = lineLength;
+  }
+
+  let start = Math.max(colno - 60, 0);
+  if (start < 5) {
+    start = 0;
+  }
+
+  let end = Math.min(start + 140, lineLength);
+  if (end > lineLength - 5) {
+    end = lineLength;
+  }
+  if (end === lineLength) {
+    start = Math.max(end - 140, 0);
+  }
+
+  newLine = newLine.slice(start, end);
+  if (start > 0) {
+    newLine = `'{snip} ${newLine}`;
+  }
+  if (end < lineLength) {
+    newLine += ' {snip}';
+  }
+
+  return newLine;
+}
+
+/**
+ * Join values in array
+ * @param input array of values to be joined together
+ * @param delimiter string to be placed in-between values
+ * @returns Joined values
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function safeJoin(input, delimiter) {
+  if (!Array.isArray(input)) {
+    return '';
+  }
+
+  const output = [];
+  // eslint-disable-next-line @typescript-eslint/prefer-for-of
+  for (let i = 0; i < input.length; i++) {
+    const value = input[i];
+    try {
+      // This is a hack to fix a Vue3-specific bug that causes an infinite loop of
+      // console warnings. This happens when a Vue template is rendered with
+      // an undeclared variable, which we try to stringify, ultimately causing
+      // Vue to issue another warning which repeats indefinitely.
+      // see: https://github.com/getsentry/sentry-javascript/pull/8981
+      if (isVueViewModel(value)) {
+        output.push('[VueViewModel]');
+      } else {
+        output.push(String(value));
+      }
+    } catch (e) {
+      output.push('[value cannot be serialized]');
+    }
+  }
+
+  return output.join(delimiter);
+}
+
+/**
+ * Checks if the given value matches a regex or string
+ *
+ * @param value The string to test
+ * @param pattern Either a regex or a string against which `value` will be matched
+ * @param requireExactStringMatch If true, `value` must match `pattern` exactly. If false, `value` will match
+ * `pattern` if it contains `pattern`. Only applies to string-type patterns.
+ */
+function isMatchingPattern(
+  value,
+  pattern,
+  requireExactStringMatch = false,
+) {
+  if (!isString(value)) {
+    return false;
+  }
+
+  if (isRegExp(pattern)) {
+    return pattern.test(value);
+  }
+  if (isString(pattern)) {
+    return requireExactStringMatch ? value === pattern : value.includes(pattern);
+  }
+
+  return false;
+}
+
+/**
+ * Test the given string against an array of strings and regexes. By default, string matching is done on a
+ * substring-inclusion basis rather than a strict equality basis
+ *
+ * @param testString The string to test
+ * @param patterns The patterns against which to test the string
+ * @param requireExactStringMatch If true, `testString` must match one of the given string patterns exactly in order to
+ * count. If false, `testString` will match a string pattern if it contains that pattern.
+ * @returns
+ */
+function stringMatchesSomePattern(
+  testString,
+  patterns = [],
+  requireExactStringMatch = false,
+) {
+  return patterns.some(pattern => isMatchingPattern(testString, pattern, requireExactStringMatch));
+}
+
+export { isMatchingPattern, safeJoin, snipLine, stringMatchesSomePattern, truncate };
+//# sourceMappingURL=string.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/supports.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/supports.js
new file mode 100644
index 0000000..8e0d9b2
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/supports.js
@@ -0,0 +1,161 @@
+import { logger } from './logger.js';
+import { getGlobalObject } from './worldwide.js';
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+/**
+ * Tells whether current environment supports ErrorEvent objects
+ * {@link supportsErrorEvent}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsErrorEvent() {
+  try {
+    new ErrorEvent('');
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Tells whether current environment supports DOMError objects
+ * {@link supportsDOMError}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsDOMError() {
+  try {
+    // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':
+    // 1 argument required, but only 0 present.
+    // @ts-expect-error It really needs 1 argument, not 0.
+    new DOMError('');
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Tells whether current environment supports DOMException objects
+ * {@link supportsDOMException}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsDOMException() {
+  try {
+    new DOMException('');
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Tells whether current environment supports Fetch API
+ * {@link supportsFetch}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsFetch() {
+  if (!('fetch' in WINDOW)) {
+    return false;
+  }
+
+  try {
+    new Headers();
+    new Request('http://www.example.com');
+    new Response();
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+/**
+ * isNativeFetch checks if the given function is a native implementation of fetch()
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+function isNativeFetch(func) {
+  return func && /^function fetch\(\)\s+\{\s+\[native code\]\s+\}$/.test(func.toString());
+}
+
+/**
+ * Tells whether current environment supports Fetch API natively
+ * {@link supportsNativeFetch}.
+ *
+ * @returns true if `window.fetch` is natively implemented, false otherwise
+ */
+function supportsNativeFetch() {
+  if (!supportsFetch()) {
+    return false;
+  }
+
+  // Fast path to avoid DOM I/O
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  if (isNativeFetch(WINDOW.fetch)) {
+    return true;
+  }
+
+  // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)
+  // so create a "pure" iframe to see if that has native fetch
+  let result = false;
+  const doc = WINDOW.document;
+  // eslint-disable-next-line deprecation/deprecation
+  if (doc && typeof (doc.createElement ) === 'function') {
+    try {
+      const sandbox = doc.createElement('iframe');
+      sandbox.hidden = true;
+      doc.head.appendChild(sandbox);
+      if (sandbox.contentWindow && sandbox.contentWindow.fetch) {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        result = isNativeFetch(sandbox.contentWindow.fetch);
+      }
+      doc.head.removeChild(sandbox);
+    } catch (err) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Tells whether current environment supports ReportingObserver API
+ * {@link supportsReportingObserver}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsReportingObserver() {
+  return 'ReportingObserver' in WINDOW;
+}
+
+/**
+ * Tells whether current environment supports Referrer Policy API
+ * {@link supportsReferrerPolicy}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsReferrerPolicy() {
+  // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'
+  // (see https://caniuse.com/#feat=referrer-policy),
+  // it doesn't. And it throws an exception instead of ignoring this parameter...
+  // REF: https://github.com/getsentry/raven-js/issues/1233
+
+  if (!supportsFetch()) {
+    return false;
+  }
+
+  try {
+    new Request('_', {
+      referrerPolicy: 'origin' ,
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+export { isNativeFetch, supportsDOMError, supportsDOMException, supportsErrorEvent, supportsFetch, supportsNativeFetch, supportsReferrerPolicy, supportsReportingObserver };
+//# sourceMappingURL=supports.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/syncpromise.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/syncpromise.js
new file mode 100644
index 0000000..feac32f
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/syncpromise.js
@@ -0,0 +1,192 @@
+import { isThenable } from './is.js';
+
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+
+/** SyncPromise internal states */
+var States; (function (States) {
+  /** Pending */
+  const PENDING = 0; States[States["PENDING"] = PENDING] = "PENDING";
+  /** Resolved / OK */
+  const RESOLVED = 1; States[States["RESOLVED"] = RESOLVED] = "RESOLVED";
+  /** Rejected / Error */
+  const REJECTED = 2; States[States["REJECTED"] = REJECTED] = "REJECTED";
+})(States || (States = {}));
+
+// Overloads so we can call resolvedSyncPromise without arguments and generic argument
+
+/**
+ * Creates a resolved sync promise.
+ *
+ * @param value the value to resolve the promise with
+ * @returns the resolved sync promise
+ */
+function resolvedSyncPromise(value) {
+  return new SyncPromise(resolve => {
+    resolve(value);
+  });
+}
+
+/**
+ * Creates a rejected sync promise.
+ *
+ * @param value the value to reject the promise with
+ * @returns the rejected sync promise
+ */
+function rejectedSyncPromise(reason) {
+  return new SyncPromise((_, reject) => {
+    reject(reason);
+  });
+}
+
+/**
+ * Thenable class that behaves like a Promise and follows it's interface
+ * but is not async internally
+ */
+class SyncPromise {
+
+   constructor(
+    executor,
+  ) {SyncPromise.prototype.__init.call(this);SyncPromise.prototype.__init2.call(this);SyncPromise.prototype.__init3.call(this);SyncPromise.prototype.__init4.call(this);
+    this._state = States.PENDING;
+    this._handlers = [];
+
+    try {
+      executor(this._resolve, this._reject);
+    } catch (e) {
+      this._reject(e);
+    }
+  }
+
+  /** JSDoc */
+   then(
+    onfulfilled,
+    onrejected,
+  ) {
+    return new SyncPromise((resolve, reject) => {
+      this._handlers.push([
+        false,
+        result => {
+          if (!onfulfilled) {
+            // TODO: ¯\_(ツ)_/¯
+            // TODO: FIXME
+            resolve(result );
+          } else {
+            try {
+              resolve(onfulfilled(result));
+            } catch (e) {
+              reject(e);
+            }
+          }
+        },
+        reason => {
+          if (!onrejected) {
+            reject(reason);
+          } else {
+            try {
+              resolve(onrejected(reason));
+            } catch (e) {
+              reject(e);
+            }
+          }
+        },
+      ]);
+      this._executeHandlers();
+    });
+  }
+
+  /** JSDoc */
+   catch(
+    onrejected,
+  ) {
+    return this.then(val => val, onrejected);
+  }
+
+  /** JSDoc */
+   finally(onfinally) {
+    return new SyncPromise((resolve, reject) => {
+      let val;
+      let isRejected;
+
+      return this.then(
+        value => {
+          isRejected = false;
+          val = value;
+          if (onfinally) {
+            onfinally();
+          }
+        },
+        reason => {
+          isRejected = true;
+          val = reason;
+          if (onfinally) {
+            onfinally();
+          }
+        },
+      ).then(() => {
+        if (isRejected) {
+          reject(val);
+          return;
+        }
+
+        resolve(val );
+      });
+    });
+  }
+
+  /** JSDoc */
+    __init() {this._resolve = (value) => {
+    this._setResult(States.RESOLVED, value);
+  };}
+
+  /** JSDoc */
+    __init2() {this._reject = (reason) => {
+    this._setResult(States.REJECTED, reason);
+  };}
+
+  /** JSDoc */
+    __init3() {this._setResult = (state, value) => {
+    if (this._state !== States.PENDING) {
+      return;
+    }
+
+    if (isThenable(value)) {
+      void (value ).then(this._resolve, this._reject);
+      return;
+    }
+
+    this._state = state;
+    this._value = value;
+
+    this._executeHandlers();
+  };}
+
+  /** JSDoc */
+    __init4() {this._executeHandlers = () => {
+    if (this._state === States.PENDING) {
+      return;
+    }
+
+    const cachedHandlers = this._handlers.slice();
+    this._handlers = [];
+
+    cachedHandlers.forEach(handler => {
+      if (handler[0]) {
+        return;
+      }
+
+      if (this._state === States.RESOLVED) {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        handler[1](this._value );
+      }
+
+      if (this._state === States.REJECTED) {
+        handler[2](this._value);
+      }
+
+      handler[0] = true;
+    });
+  };}
+}
+
+export { SyncPromise, rejectedSyncPromise, resolvedSyncPromise };
+//# sourceMappingURL=syncpromise.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/time.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/time.js
new file mode 100644
index 0000000..2703ed2
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/time.js
@@ -0,0 +1,183 @@
+import { isNodeEnv, dynamicRequire } from './node.js';
+import { getGlobalObject } from './worldwide.js';
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+/**
+ * An object that can return the current timestamp in seconds since the UNIX epoch.
+ */
+
+/**
+ * A TimestampSource implementation for environments that do not support the Performance Web API natively.
+ *
+ * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier
+ * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It
+ * is more obvious to explain "why does my span have negative duration" than "why my spans have zero duration".
+ */
+const dateTimestampSource = {
+  nowSeconds: () => Date.now() / 1000,
+};
+
+/**
+ * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}
+ * for accessing a high-resolution monotonic clock.
+ */
+
+/**
+ * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not
+ * support the API.
+ *
+ * Wrapping the native API works around differences in behavior from different browsers.
+ */
+function getBrowserPerformance() {
+  const { performance } = WINDOW;
+  if (!performance || !performance.now) {
+    return undefined;
+  }
+
+  // Replace performance.timeOrigin with our own timeOrigin based on Date.now().
+  //
+  // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +
+  // performance.now() gives a date arbitrarily in the past.
+  //
+  // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is
+  // undefined.
+  //
+  // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to
+  // interact with data coming out of performance entries.
+  //
+  // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that
+  // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes
+  // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have
+  // observed skews that can be as long as days, weeks or months.
+  //
+  // See https://github.com/getsentry/sentry-javascript/issues/2590.
+  //
+  // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload
+  // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation
+  // transactions of long-lived web pages.
+  const timeOrigin = Date.now() - performance.now();
+
+  return {
+    now: () => performance.now(),
+    timeOrigin,
+  };
+}
+
+/**
+ * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't
+ * implement the API.
+ */
+function getNodePerformance() {
+  try {
+    const perfHooks = dynamicRequire(module, 'perf_hooks') ;
+    return perfHooks.performance;
+  } catch (_) {
+    return undefined;
+  }
+}
+
+/**
+ * The Performance API implementation for the current platform, if available.
+ */
+const platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();
+
+const timestampSource =
+  platformPerformance === undefined
+    ? dateTimestampSource
+    : {
+        nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,
+      };
+
+/**
+ * Returns a timestamp in seconds since the UNIX epoch using the Date API.
+ */
+const dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);
+
+/**
+ * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the
+ * availability of the Performance API.
+ *
+ * See `usingPerformanceAPI` to test whether the Performance API is used.
+ *
+ * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is
+ * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The
+ * skew can grow to arbitrary amounts like days, weeks or months.
+ * See https://github.com/getsentry/sentry-javascript/issues/2590.
+ */
+const timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);
+
+/**
+ * Re-exported with an old name for backwards-compatibility.
+ * TODO (v8): Remove this
+ *
+ * @deprecated Use `timestampInSeconds` instead.
+ */
+const timestampWithMs = timestampInSeconds;
+
+/**
+ * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.
+ */
+const usingPerformanceAPI = platformPerformance !== undefined;
+
+/**
+ * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.
+ */
+let _browserPerformanceTimeOriginMode;
+
+/**
+ * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the
+ * performance API is available.
+ */
+const browserPerformanceTimeOrigin = (() => {
+  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or
+  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin
+  // data as reliable if they are within a reasonable threshold of the current time.
+
+  const { performance } = WINDOW;
+  if (!performance || !performance.now) {
+    _browserPerformanceTimeOriginMode = 'none';
+    return undefined;
+  }
+
+  const threshold = 3600 * 1000;
+  const performanceNow = performance.now();
+  const dateNow = Date.now();
+
+  // if timeOrigin isn't available set delta to threshold so it isn't used
+  const timeOriginDelta = performance.timeOrigin
+    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)
+    : threshold;
+  const timeOriginIsReliable = timeOriginDelta < threshold;
+
+  // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin
+  // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.
+  // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always
+  // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the
+  // Date API.
+  // eslint-disable-next-line deprecation/deprecation
+  const navigationStart = performance.timing && performance.timing.navigationStart;
+  const hasNavigationStart = typeof navigationStart === 'number';
+  // if navigationStart isn't available set delta to threshold so it isn't used
+  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;
+  const navigationStartIsReliable = navigationStartDelta < threshold;
+
+  if (timeOriginIsReliable || navigationStartIsReliable) {
+    // Use the more reliable time origin
+    if (timeOriginDelta <= navigationStartDelta) {
+      _browserPerformanceTimeOriginMode = 'timeOrigin';
+      return performance.timeOrigin;
+    } else {
+      _browserPerformanceTimeOriginMode = 'navigationStart';
+      return navigationStart;
+    }
+  }
+
+  // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.
+  _browserPerformanceTimeOriginMode = 'dateNow';
+  return dateNow;
+})();
+
+export { _browserPerformanceTimeOriginMode, browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds, timestampWithMs, usingPerformanceAPI };
+//# sourceMappingURL=time.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/tracing.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/tracing.js
new file mode 100644
index 0000000..4928f07
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/tracing.js
@@ -0,0 +1,94 @@
+import { baggageHeaderToDynamicSamplingContext } from './baggage.js';
+import { uuid4 } from './misc.js';
+
+const TRACEPARENT_REGEXP = new RegExp(
+  '^[ \\t]*' + // whitespace
+    '([0-9a-f]{32})?' + // trace_id
+    '-?([0-9a-f]{16})?' + // span_id
+    '-?([01])?' + // sampled
+    '[ \\t]*$', // whitespace
+);
+
+/**
+ * Extract transaction context data from a `sentry-trace` header.
+ *
+ * @param traceparent Traceparent string
+ *
+ * @returns Object containing data from the header, or undefined if traceparent string is malformed
+ */
+function extractTraceparentData(traceparent) {
+  if (!traceparent) {
+    return undefined;
+  }
+
+  const matches = traceparent.match(TRACEPARENT_REGEXP);
+  if (!matches) {
+    return undefined;
+  }
+
+  let parentSampled;
+  if (matches[3] === '1') {
+    parentSampled = true;
+  } else if (matches[3] === '0') {
+    parentSampled = false;
+  }
+
+  return {
+    traceId: matches[1],
+    parentSampled,
+    parentSpanId: matches[2],
+  };
+}
+
+/**
+ * Create tracing context from incoming headers.
+ */
+function tracingContextFromHeaders(
+  sentryTrace,
+  baggage,
+)
+
+ {
+  const traceparentData = extractTraceparentData(sentryTrace);
+  const dynamicSamplingContext = baggageHeaderToDynamicSamplingContext(baggage);
+
+  const { traceId, parentSpanId, parentSampled } = traceparentData || {};
+
+  const propagationContext = {
+    traceId: traceId || uuid4(),
+    spanId: uuid4().substring(16),
+    sampled: parentSampled,
+  };
+
+  if (parentSpanId) {
+    propagationContext.parentSpanId = parentSpanId;
+  }
+
+  if (dynamicSamplingContext) {
+    propagationContext.dsc = dynamicSamplingContext ;
+  }
+
+  return {
+    traceparentData,
+    dynamicSamplingContext,
+    propagationContext,
+  };
+}
+
+/**
+ * Create sentry-trace header from span context values.
+ */
+function generateSentryTraceHeader(
+  traceId = uuid4(),
+  spanId = uuid4().substring(16),
+  sampled,
+) {
+  let sampledString = '';
+  if (sampled !== undefined) {
+    sampledString = sampled ? '-1' : '-0';
+  }
+  return `${traceId}-${spanId}${sampledString}`;
+}
+
+export { TRACEPARENT_REGEXP, extractTraceparentData, generateSentryTraceHeader, tracingContextFromHeaders };
+//# sourceMappingURL=tracing.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/url.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/url.js
new file mode 100644
index 0000000..2e0bd40
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/url.js
@@ -0,0 +1,72 @@
+/**
+ * Parses string form of URL into an object
+ * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B
+ * // intentionally using regex and not <a/> href parsing trick because React Native and other
+ * // environments where DOM might not be available
+ * @returns parsed URL object
+ */
+function parseUrl(url) {
+  if (!url) {
+    return {};
+  }
+
+  const match = url.match(/^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/);
+
+  if (!match) {
+    return {};
+  }
+
+  // coerce to undefined values to empty string so we don't get 'undefined'
+  const query = match[6] || '';
+  const fragment = match[8] || '';
+  return {
+    host: match[4],
+    path: match[5],
+    protocol: match[2],
+    search: query,
+    hash: fragment,
+    relative: match[5] + query + fragment, // everything minus origin
+  };
+}
+
+/**
+ * Strip the query string and fragment off of a given URL or path (if present)
+ *
+ * @param urlPath Full URL or path, including possible query string and/or fragment
+ * @returns URL or path without query string or fragment
+ */
+function stripUrlQueryAndFragment(urlPath) {
+  // eslint-disable-next-line no-useless-escape
+  return urlPath.split(/[\?#]/, 1)[0];
+}
+
+/**
+ * Returns number of URL segments of a passed string URL.
+ */
+function getNumberOfUrlSegments(url) {
+  // split at '/' or at '\/' to split regex urls correctly
+  return url.split(/\\?\//).filter(s => s.length > 0 && s !== ',').length;
+}
+
+/**
+ * Takes a URL object and returns a sanitized string which is safe to use as span description
+ * see: https://develop.sentry.dev/sdk/data-handling/#structuring-data
+ */
+function getSanitizedUrlString(url) {
+  const { protocol, host, path } = url;
+
+  const filteredHost =
+    (host &&
+      host
+        // Always filter out authority
+        .replace(/^.*@/, '[filtered]:[filtered]@')
+        // Don't show standard :80 (http) and :443 (https) ports to reduce the noise
+        .replace(':80', '')
+        .replace(':443', '')) ||
+    '';
+
+  return `${protocol ? `${protocol}://` : ''}${filteredHost}${path}`;
+}
+
+export { getNumberOfUrlSegments, getSanitizedUrlString, parseUrl, stripUrlQueryAndFragment };
+//# sourceMappingURL=url.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/vendor/supportsHistory.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/vendor/supportsHistory.js
new file mode 100644
index 0000000..cf33d64
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/vendor/supportsHistory.js
@@ -0,0 +1,29 @@
+import { getGlobalObject } from '../worldwide.js';
+
+// Based on https://github.com/angular/angular.js/pull/13945/files
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+/**
+ * Tells whether current environment supports History API
+ * {@link supportsHistory}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsHistory() {
+  // NOTE: in Chrome App environment, touching history.pushState, *even inside
+  //       a try/catch block*, will cause Chrome to output an error to console.error
+  // borrowed from: https://github.com/angular/angular.js/pull/13945/files
+  /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const chrome = (WINDOW ).chrome;
+  const isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;
+  /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+  const hasHistoryApi = 'history' in WINDOW && !!WINDOW.history.pushState && !!WINDOW.history.replaceState;
+
+  return !isChromePackagedApp && hasHistoryApi;
+}
+
+export { supportsHistory };
+//# sourceMappingURL=supportsHistory.js.map
diff --git a/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/worldwide.js b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/worldwide.js
new file mode 100644
index 0000000..4c54705
--- /dev/null
+++ b/parent_dir/node_modules/sentry/browser/node_modules/sentry/utils/esm/worldwide.js
@@ -0,0 +1,70 @@
+/** Internal global with common properties and Sentry extensions  */
+
+// The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification
+// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js
+// core-js has the following licence:
+//
+// Copyright (c) 2014-2022 Denis Pushkarev
+//
+// 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.
+
+/** Returns 'obj' if it's the global object, otherwise returns undefined */
+function isGlobalObj(obj) {
+  return obj && obj.Math == Math ? obj : undefined;
+}
+
+/** Get's the global object for the current JavaScript runtime */
+const GLOBAL_OBJ =
+  (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||
+  // eslint-disable-next-line no-restricted-globals
+  (typeof window == 'object' && isGlobalObj(window)) ||
+  (typeof self == 'object' && isGlobalObj(self)) ||
+  (typeof global == 'object' && isGlobalObj(global)) ||
+  (function () {
+    return this;
+  })() ||
+  {};
+
+/**
+ * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8
+ */
+function getGlobalObject() {
+  return GLOBAL_OBJ ;
+}
+
+/**
+ * Returns a global singleton contained in the global `__SENTRY__` object.
+ *
+ * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory
+ * function and added to the `__SENTRY__` object.
+ *
+ * @param name name of the global singleton on __SENTRY__
+ * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`
+ * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value
+ * @returns the singleton
+ */
+function getGlobalSingleton(name, creator, obj) {
+  const gbl = (obj || GLOBAL_OBJ) ;
+  const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});
+  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());
+  return singleton;
+}
+
+export { GLOBAL_OBJ, getGlobalObject, getGlobalSingleton };
+//# sourceMappingURL=worldwide.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/api.js b/parent_dir/node_modules/sentry/core/esm/api.js
new file mode 100644
index 0000000..d8dd466
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/api.js
@@ -0,0 +1,90 @@
+import { makeDsn, dsnToString, urlEncode } from '@sentry/utils';
+
+const SENTRY_API_VERSION = '7';
+
+/** Returns the prefix to construct Sentry ingestion API endpoints. */
+function getBaseApiEndpoint(dsn) {
+  const protocol = dsn.protocol ? `${dsn.protocol}:` : '';
+  const port = dsn.port ? `:${dsn.port}` : '';
+  return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;
+}
+
+/** Returns the ingest API endpoint for target. */
+function _getIngestEndpoint(dsn) {
+  return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;
+}
+
+/** Returns a URL-encoded string with auth config suitable for a query string. */
+function _encodedAuth(dsn, sdkInfo) {
+  return urlEncode({
+    // We send only the minimum set of required information. See
+    // https://github.com/getsentry/sentry-javascript/issues/2572.
+    sentry_key: dsn.publicKey,
+    sentry_version: SENTRY_API_VERSION,
+    ...(sdkInfo && { sentry_client: `${sdkInfo.name}/${sdkInfo.version}` }),
+  });
+}
+
+/**
+ * Returns the envelope endpoint URL with auth in the query string.
+ *
+ * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.
+ */
+function getEnvelopeEndpointWithUrlEncodedAuth(
+  dsn,
+  // TODO (v8): Remove `tunnelOrOptions` in favor of `options`, and use the substitute code below
+  // options: ClientOptions = {} as ClientOptions,
+  tunnelOrOptions = {} ,
+) {
+  // TODO (v8): Use this code instead
+  // const { tunnel, _metadata = {} } = options;
+  // return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, _metadata.sdk)}`;
+
+  const tunnel = typeof tunnelOrOptions === 'string' ? tunnelOrOptions : tunnelOrOptions.tunnel;
+  const sdkInfo =
+    typeof tunnelOrOptions === 'string' || !tunnelOrOptions._metadata ? undefined : tunnelOrOptions._metadata.sdk;
+
+  return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, sdkInfo)}`;
+}
+
+/** Returns the url to the report dialog endpoint. */
+function getReportDialogEndpoint(
+  dsnLike,
+  dialogOptions
+
+,
+) {
+  const dsn = makeDsn(dsnLike);
+  if (!dsn) {
+    return '';
+  }
+
+  const endpoint = `${getBaseApiEndpoint(dsn)}embed/error-page/`;
+
+  let encodedOptions = `dsn=${dsnToString(dsn)}`;
+  for (const key in dialogOptions) {
+    if (key === 'dsn') {
+      continue;
+    }
+
+    if (key === 'user') {
+      const user = dialogOptions.user;
+      if (!user) {
+        continue;
+      }
+      if (user.name) {
+        encodedOptions += `&name=${encodeURIComponent(user.name)}`;
+      }
+      if (user.email) {
+        encodedOptions += `&email=${encodeURIComponent(user.email)}`;
+      }
+    } else {
+      encodedOptions += `&${encodeURIComponent(key)}=${encodeURIComponent(dialogOptions[key] )}`;
+    }
+  }
+
+  return `${endpoint}?${encodedOptions}`;
+}
+
+export { getEnvelopeEndpointWithUrlEncodedAuth, getReportDialogEndpoint };
+//# sourceMappingURL=api.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/baseclient.js b/parent_dir/node_modules/sentry/core/esm/baseclient.js
new file mode 100644
index 0000000..1d8ed88
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/baseclient.js
@@ -0,0 +1,722 @@
+import { makeDsn, logger, checkOrSetAlreadyCaught, isPrimitive, resolvedSyncPromise, addItemToEnvelope, createAttachmentEnvelopeItem, SyncPromise, rejectedSyncPromise, SentryError, isThenable, isPlainObject } from '@sentry/utils';
+import { getEnvelopeEndpointWithUrlEncodedAuth } from './api.js';
+import { createEventEnvelope, createSessionEnvelope } from './envelope.js';
+import { setupIntegrations, setupIntegration } from './integration.js';
+import { updateSession } from './session.js';
+import { getDynamicSamplingContextFromClient } from './tracing/dynamicSamplingContext.js';
+import { prepareEvent } from './utils/prepareEvent.js';
+
+const ALREADY_SEEN_ERROR = "Not capturing exception because it's already been captured.";
+
+/**
+ * Base implementation for all JavaScript SDK clients.
+ *
+ * Call the constructor with the corresponding options
+ * specific to the client subclass. To access these options later, use
+ * {@link Client.getOptions}.
+ *
+ * If a Dsn is specified in the options, it will be parsed and stored. Use
+ * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is
+ * invalid, the constructor will throw a {@link SentryException}. Note that
+ * without a valid Dsn, the SDK will not send any events to Sentry.
+ *
+ * Before sending an event, it is passed through
+ * {@link BaseClient._prepareEvent} to add SDK information and scope data
+ * (breadcrumbs and context). To add more custom information, override this
+ * method and extend the resulting prepared event.
+ *
+ * To issue automatically created events (e.g. via instrumentation), use
+ * {@link Client.captureEvent}. It will prepare the event and pass it through
+ * the callback lifecycle. To issue auto-breadcrumbs, use
+ * {@link Client.addBreadcrumb}.
+ *
+ * @example
+ * class NodeClient extends BaseClient<NodeOptions> {
+ *   public constructor(options: NodeOptions) {
+ *     super(options);
+ *   }
+ *
+ *   // ...
+ * }
+ */
+class BaseClient {
+  /** Options passed to the SDK. */
+
+  /** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */
+
+  /** Array of set up integrations. */
+
+  /** Indicates whether this client's integrations have been set up. */
+
+  /** Number of calls being processed */
+
+  /** Holds flushable  */
+
+  // eslint-disable-next-line @typescript-eslint/ban-types
+
+  /**
+   * Initializes this client instance.
+   *
+   * @param options Options for the client.
+   */
+   constructor(options) {
+    this._options = options;
+    this._integrations = {};
+    this._integrationsInitialized = false;
+    this._numProcessing = 0;
+    this._outcomes = {};
+    this._hooks = {};
+    this._eventProcessors = [];
+
+    if (options.dsn) {
+      this._dsn = makeDsn(options.dsn);
+    } else {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('No DSN provided, client will not do anything.');
+    }
+
+    if (this._dsn) {
+      const url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options);
+      this._transport = options.transport({
+        recordDroppedEvent: this.recordDroppedEvent.bind(this),
+        ...options.transportOptions,
+        url,
+      });
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+   captureException(exception, hint, scope) {
+    // ensure we haven't captured this very object before
+    if (checkOrSetAlreadyCaught(exception)) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(ALREADY_SEEN_ERROR);
+      return;
+    }
+
+    let eventId = hint && hint.event_id;
+
+    this._process(
+      this.eventFromException(exception, hint)
+        .then(event => this._captureEvent(event, hint, scope))
+        .then(result => {
+          eventId = result;
+        }),
+    );
+
+    return eventId;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   captureMessage(
+    message,
+    // eslint-disable-next-line deprecation/deprecation
+    level,
+    hint,
+    scope,
+  ) {
+    let eventId = hint && hint.event_id;
+
+    const promisedEvent = isPrimitive(message)
+      ? this.eventFromMessage(String(message), level, hint)
+      : this.eventFromException(message, hint);
+
+    this._process(
+      promisedEvent
+        .then(event => this._captureEvent(event, hint, scope))
+        .then(result => {
+          eventId = result;
+        }),
+    );
+
+    return eventId;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   captureEvent(event, hint, scope) {
+    // ensure we haven't captured this very object before
+    if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(ALREADY_SEEN_ERROR);
+      return;
+    }
+
+    let eventId = hint && hint.event_id;
+
+    this._process(
+      this._captureEvent(event, hint, scope).then(result => {
+        eventId = result;
+      }),
+    );
+
+    return eventId;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   captureSession(session) {
+    if (!this._isEnabled()) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('SDK not enabled, will not capture session.');
+      return;
+    }
+
+    if (!(typeof session.release === 'string')) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Discarded session because of missing or non-string release');
+    } else {
+      this.sendSession(session);
+      // After sending, we set init false to indicate it's not the first occurrence
+      updateSession(session, { init: false });
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getDsn() {
+    return this._dsn;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getOptions() {
+    return this._options;
+  }
+
+  /**
+   * @see SdkMetadata in @sentry/types
+   *
+   * @return The metadata of the SDK
+   */
+   getSdkMetadata() {
+    return this._options._metadata;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getTransport() {
+    return this._transport;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   flush(timeout) {
+    const transport = this._transport;
+    if (transport) {
+      return this._isClientDoneProcessing(timeout).then(clientFinished => {
+        return transport.flush(timeout).then(transportFlushed => clientFinished && transportFlushed);
+      });
+    } else {
+      return resolvedSyncPromise(true);
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+   close(timeout) {
+    return this.flush(timeout).then(result => {
+      this.getOptions().enabled = false;
+      return result;
+    });
+  }
+
+  /** Get all installed event processors. */
+   getEventProcessors() {
+    return this._eventProcessors;
+  }
+
+  /** @inheritDoc */
+   addEventProcessor(eventProcessor) {
+    this._eventProcessors.push(eventProcessor);
+  }
+
+  /**
+   * Sets up the integrations
+   */
+   setupIntegrations() {
+    if (this._isEnabled() && !this._integrationsInitialized) {
+      this._integrations = setupIntegrations(this, this._options.integrations);
+      this._integrationsInitialized = true;
+    }
+  }
+
+  /**
+   * Gets an installed integration by its `id`.
+   *
+   * @returns The installed integration or `undefined` if no integration with that `id` was installed.
+   */
+   getIntegrationById(integrationId) {
+    return this._integrations[integrationId];
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getIntegration(integration) {
+    try {
+      return (this._integrations[integration.id] ) || null;
+    } catch (_oO) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Cannot retrieve integration ${integration.id} from the current Client`);
+      return null;
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+   addIntegration(integration) {
+    setupIntegration(this, integration, this._integrations);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   sendEvent(event, hint = {}) {
+    this.emit('beforeSendEvent', event, hint);
+
+    if (this._dsn) {
+      let env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);
+
+      for (const attachment of hint.attachments || []) {
+        env = addItemToEnvelope(
+          env,
+          createAttachmentEnvelopeItem(
+            attachment,
+            this._options.transportOptions && this._options.transportOptions.textEncoder,
+          ),
+        );
+      }
+
+      const promise = this._sendEnvelope(env);
+      if (promise) {
+        promise.then(sendResponse => this.emit('afterSendEvent', event, sendResponse), null);
+      }
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+   sendSession(session) {
+    if (this._dsn) {
+      const env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);
+      void this._sendEnvelope(env);
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+   recordDroppedEvent(reason, category, _event) {
+    // Note: we use `event` in replay, where we overwrite this hook.
+
+    if (this._options.sendClientReports) {
+      // We want to track each category (error, transaction, session, replay_event) separately
+      // but still keep the distinction between different type of outcomes.
+      // We could use nested maps, but it's much easier to read and type this way.
+      // A correct type for map-based implementation if we want to go that route
+      // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`
+      // With typescript 4.1 we could even use template literal types
+      const key = `${reason}:${category}`;
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Adding outcome: "${key}"`);
+
+      // The following works because undefined + 1 === NaN and NaN is falsy
+      this._outcomes[key] = this._outcomes[key] + 1 || 1;
+    }
+  }
+
+  // Keep on() & emit() signatures in sync with types' client.ts interface
+  /* eslint-disable @typescript-eslint/unified-signatures */
+
+  /** @inheritdoc */
+
+  /** @inheritdoc */
+   on(hook, callback) {
+    if (!this._hooks[hook]) {
+      this._hooks[hook] = [];
+    }
+
+    // @ts-expect-error We assue the types are correct
+    this._hooks[hook].push(callback);
+  }
+
+  /** @inheritdoc */
+
+  /** @inheritdoc */
+   emit(hook, ...rest) {
+    if (this._hooks[hook]) {
+      this._hooks[hook].forEach(callback => callback(...rest));
+    }
+  }
+
+  /* eslint-enable @typescript-eslint/unified-signatures */
+
+  /** Updates existing session based on the provided event */
+   _updateSessionFromEvent(session, event) {
+    let crashed = false;
+    let errored = false;
+    const exceptions = event.exception && event.exception.values;
+
+    if (exceptions) {
+      errored = true;
+
+      for (const ex of exceptions) {
+        const mechanism = ex.mechanism;
+        if (mechanism && mechanism.handled === false) {
+          crashed = true;
+          break;
+        }
+      }
+    }
+
+    // A session is updated and that session update is sent in only one of the two following scenarios:
+    // 1. Session with non terminal status and 0 errors + an error occurred -> Will set error count to 1 and send update
+    // 2. Session with non terminal status and 1 error + a crash occurred -> Will set status crashed and send update
+    const sessionNonTerminal = session.status === 'ok';
+    const shouldUpdateAndSend = (sessionNonTerminal && session.errors === 0) || (sessionNonTerminal && crashed);
+
+    if (shouldUpdateAndSend) {
+      updateSession(session, {
+        ...(crashed && { status: 'crashed' }),
+        errors: session.errors || Number(errored || crashed),
+      });
+      this.captureSession(session);
+    }
+  }
+
+  /**
+   * Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying
+   * "no" (resolving to `false`) in order to give the client a chance to potentially finish first.
+   *
+   * @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not
+   * passing anything) will make the promise wait as long as it takes for processing to finish before resolving to
+   * `true`.
+   * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and
+   * `false` otherwise
+   */
+   _isClientDoneProcessing(timeout) {
+    return new SyncPromise(resolve => {
+      let ticked = 0;
+      const tick = 1;
+
+      const interval = setInterval(() => {
+        if (this._numProcessing == 0) {
+          clearInterval(interval);
+          resolve(true);
+        } else {
+          ticked += tick;
+          if (timeout && ticked >= timeout) {
+            clearInterval(interval);
+            resolve(false);
+          }
+        }
+      }, tick);
+    });
+  }
+
+  /** Determines whether this SDK is enabled and a valid Dsn is present. */
+   _isEnabled() {
+    return this.getOptions().enabled !== false && this._dsn !== undefined;
+  }
+
+  /**
+   * Adds common information to events.
+   *
+   * The information includes release and environment from `options`,
+   * breadcrumbs and context (extra, tags and user) from the scope.
+   *
+   * Information that is already present in the event is never overwritten. For
+   * nested objects, such as the context, keys are merged.
+   *
+   * @param event The original event.
+   * @param hint May contain additional information about the original exception.
+   * @param scope A scope containing event metadata.
+   * @returns A new event with more information.
+   */
+   _prepareEvent(event, hint, scope) {
+    const options = this.getOptions();
+    const integrations = Object.keys(this._integrations);
+    if (!hint.integrations && integrations.length > 0) {
+      hint.integrations = integrations;
+    }
+
+    this.emit('preprocessEvent', event, hint);
+
+    return prepareEvent(options, event, hint, scope, this).then(evt => {
+      if (evt === null) {
+        return evt;
+      }
+
+      // If a trace context is not set on the event, we use the propagationContext set on the event to
+      // generate a trace context. If the propagationContext does not have a dynamic sampling context, we
+      // also generate one for it.
+      const { propagationContext } = evt.sdkProcessingMetadata || {};
+      const trace = evt.contexts && evt.contexts.trace;
+      if (!trace && propagationContext) {
+        const { traceId: trace_id, spanId, parentSpanId, dsc } = propagationContext ;
+        evt.contexts = {
+          trace: {
+            trace_id,
+            span_id: spanId,
+            parent_span_id: parentSpanId,
+          },
+          ...evt.contexts,
+        };
+
+        const dynamicSamplingContext = dsc ? dsc : getDynamicSamplingContextFromClient(trace_id, this, scope);
+
+        evt.sdkProcessingMetadata = {
+          dynamicSamplingContext,
+          ...evt.sdkProcessingMetadata,
+        };
+      }
+      return evt;
+    });
+  }
+
+  /**
+   * Processes the event and logs an error in case of rejection
+   * @param event
+   * @param hint
+   * @param scope
+   */
+   _captureEvent(event, hint = {}, scope) {
+    return this._processEvent(event, hint, scope).then(
+      finalEvent => {
+        return finalEvent.event_id;
+      },
+      reason => {
+        if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+          // If something's gone wrong, log the error as a warning. If it's just us having used a `SentryError` for
+          // control flow, log just the message (no stack) as a log-level log.
+          const sentryError = reason ;
+          if (sentryError.logLevel === 'log') {
+            logger.log(sentryError.message);
+          } else {
+            logger.warn(sentryError);
+          }
+        }
+        return undefined;
+      },
+    );
+  }
+
+  /**
+   * Processes an event (either error or message) and sends it to Sentry.
+   *
+   * This also adds breadcrumbs and context information to the event. However,
+   * platform specific meta data (such as the User's IP address) must be added
+   * by the SDK implementor.
+   *
+   *
+   * @param event The event to send to Sentry.
+   * @param hint May contain additional information about the original exception.
+   * @param scope A scope containing event metadata.
+   * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.
+   */
+   _processEvent(event, hint, scope) {
+    const options = this.getOptions();
+    const { sampleRate } = options;
+
+    if (!this._isEnabled()) {
+      return rejectedSyncPromise(new SentryError('SDK not enabled, will not capture event.', 'log'));
+    }
+
+    const isTransaction = isTransactionEvent(event);
+    const isError = isErrorEvent(event);
+    const eventType = event.type || 'error';
+    const beforeSendLabel = `before send for type \`${eventType}\``;
+
+    // 1.0 === 100% events are sent
+    // 0.0 === 0% events are sent
+    // Sampling for transaction happens somewhere else
+    if (isError && typeof sampleRate === 'number' && Math.random() > sampleRate) {
+      this.recordDroppedEvent('sample_rate', 'error', event);
+      return rejectedSyncPromise(
+        new SentryError(
+          `Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,
+          'log',
+        ),
+      );
+    }
+
+    const dataCategory = eventType === 'replay_event' ? 'replay' : eventType;
+
+    return this._prepareEvent(event, hint, scope)
+      .then(prepared => {
+        if (prepared === null) {
+          this.recordDroppedEvent('event_processor', dataCategory, event);
+          throw new SentryError('An event processor returned `null`, will not send event.', 'log');
+        }
+
+        const isInternalException = hint.data && (hint.data ).__sentry__ === true;
+        if (isInternalException) {
+          return prepared;
+        }
+
+        const result = processBeforeSend(options, prepared, hint);
+        return _validateBeforeSendResult(result, beforeSendLabel);
+      })
+      .then(processedEvent => {
+        if (processedEvent === null) {
+          this.recordDroppedEvent('before_send', dataCategory, event);
+          throw new SentryError(`${beforeSendLabel} returned \`null\`, will not send event.`, 'log');
+        }
+
+        const session = scope && scope.getSession();
+        if (!isTransaction && session) {
+          this._updateSessionFromEvent(session, processedEvent);
+        }
+
+        // None of the Sentry built event processor will update transaction name,
+        // so if the transaction name has been changed by an event processor, we know
+        // it has to come from custom event processor added by a user
+        const transactionInfo = processedEvent.transaction_info;
+        if (isTransaction && transactionInfo && processedEvent.transaction !== event.transaction) {
+          const source = 'custom';
+          processedEvent.transaction_info = {
+            ...transactionInfo,
+            source,
+          };
+        }
+
+        this.sendEvent(processedEvent, hint);
+        return processedEvent;
+      })
+      .then(null, reason => {
+        if (reason instanceof SentryError) {
+          throw reason;
+        }
+
+        this.captureException(reason, {
+          data: {
+            __sentry__: true,
+          },
+          originalException: reason,
+        });
+        throw new SentryError(
+          `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\nReason: ${reason}`,
+        );
+      });
+  }
+
+  /**
+   * Occupies the client with processing and event
+   */
+   _process(promise) {
+    this._numProcessing++;
+    void promise.then(
+      value => {
+        this._numProcessing--;
+        return value;
+      },
+      reason => {
+        this._numProcessing--;
+        return reason;
+      },
+    );
+  }
+
+  /**
+   * @inheritdoc
+   */
+   _sendEnvelope(envelope) {
+    if (this._transport && this._dsn) {
+      this.emit('beforeEnvelope', envelope);
+
+      return this._transport.send(envelope).then(null, reason => {
+        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Error while sending event:', reason);
+      });
+    } else {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Transport disabled');
+    }
+  }
+
+  /**
+   * Clears outcomes on this client and returns them.
+   */
+   _clearOutcomes() {
+    const outcomes = this._outcomes;
+    this._outcomes = {};
+    return Object.keys(outcomes).map(key => {
+      const [reason, category] = key.split(':') ;
+      return {
+        reason,
+        category,
+        quantity: outcomes[key],
+      };
+    });
+  }
+
+  /**
+   * @inheritDoc
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+
+}
+
+/**
+ * Verifies that return value of configured `beforeSend` or `beforeSendTransaction` is of expected type, and returns the value if so.
+ */
+function _validateBeforeSendResult(
+  beforeSendResult,
+  beforeSendLabel,
+) {
+  const invalidValueError = `${beforeSendLabel} must return \`null\` or a valid event.`;
+  if (isThenable(beforeSendResult)) {
+    return beforeSendResult.then(
+      event => {
+        if (!isPlainObject(event) && event !== null) {
+          throw new SentryError(invalidValueError);
+        }
+        return event;
+      },
+      e => {
+        throw new SentryError(`${beforeSendLabel} rejected with ${e}`);
+      },
+    );
+  } else if (!isPlainObject(beforeSendResult) && beforeSendResult !== null) {
+    throw new SentryError(invalidValueError);
+  }
+  return beforeSendResult;
+}
+
+/**
+ * Process the matching `beforeSendXXX` callback.
+ */
+function processBeforeSend(
+  options,
+  event,
+  hint,
+) {
+  const { beforeSend, beforeSendTransaction } = options;
+
+  if (isErrorEvent(event) && beforeSend) {
+    return beforeSend(event, hint);
+  }
+
+  if (isTransactionEvent(event) && beforeSendTransaction) {
+    return beforeSendTransaction(event, hint);
+  }
+
+  return event;
+}
+
+function isErrorEvent(event) {
+  return event.type === undefined;
+}
+
+function isTransactionEvent(event) {
+  return event.type === 'transaction';
+}
+
+export { BaseClient };
+//# sourceMappingURL=baseclient.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/constants.js b/parent_dir/node_modules/sentry/core/esm/constants.js
new file mode 100644
index 0000000..2c81ff6
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/constants.js
@@ -0,0 +1,4 @@
+const DEFAULT_ENVIRONMENT = 'production';
+
+export { DEFAULT_ENVIRONMENT };
+//# sourceMappingURL=constants.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/envelope.js b/parent_dir/node_modules/sentry/core/esm/envelope.js
new file mode 100644
index 0000000..2d1047d
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/envelope.js
@@ -0,0 +1,74 @@
+import { getSdkMetadataForEnvelopeHeader, dsnToString, createEnvelope, createEventEnvelopeHeaders } from '@sentry/utils';
+
+/**
+ * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.
+ * Merge with existing data if any.
+ **/
+function enhanceEventWithSdkInfo(event, sdkInfo) {
+  if (!sdkInfo) {
+    return event;
+  }
+  event.sdk = event.sdk || {};
+  event.sdk.name = event.sdk.name || sdkInfo.name;
+  event.sdk.version = event.sdk.version || sdkInfo.version;
+  event.sdk.integrations = [...(event.sdk.integrations || []), ...(sdkInfo.integrations || [])];
+  event.sdk.packages = [...(event.sdk.packages || []), ...(sdkInfo.packages || [])];
+  return event;
+}
+
+/** Creates an envelope from a Session */
+function createSessionEnvelope(
+  session,
+  dsn,
+  metadata,
+  tunnel,
+) {
+  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);
+  const envelopeHeaders = {
+    sent_at: new Date().toISOString(),
+    ...(sdkInfo && { sdk: sdkInfo }),
+    ...(!!tunnel && { dsn: dsnToString(dsn) }),
+  };
+
+  const envelopeItem =
+    'aggregates' in session ? [{ type: 'sessions' }, session] : [{ type: 'session' }, session.toJSON()];
+
+  return createEnvelope(envelopeHeaders, [envelopeItem]);
+}
+
+/**
+ * Create an Envelope from an event.
+ */
+function createEventEnvelope(
+  event,
+  dsn,
+  metadata,
+  tunnel,
+) {
+  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);
+
+  /*
+    Note: Due to TS, event.type may be `replay_event`, theoretically.
+    In practice, we never call `createEventEnvelope` with `replay_event` type,
+    and we'd have to adjut a looot of types to make this work properly.
+    We want to avoid casting this around, as that could lead to bugs (e.g. when we add another type)
+    So the safe choice is to really guard against the replay_event type here.
+  */
+  const eventType = event.type && event.type !== 'replay_event' ? event.type : 'event';
+
+  enhanceEventWithSdkInfo(event, metadata && metadata.sdk);
+
+  const envelopeHeaders = createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn);
+
+  // Prevent this data (which, if it exists, was used in earlier steps in the processing pipeline) from being sent to
+  // sentry. (Note: Our use of this property comes and goes with whatever we might be debugging, whatever hacks we may
+  // have temporarily added, etc. Even if we don't happen to be using it at some point in the future, let's not get rid
+  // of this `delete`, lest we miss putting it back in the next time the property is in use.)
+  delete event.sdkProcessingMetadata;
+
+  const eventItem = [{ type: eventType }, event];
+  return createEnvelope(envelopeHeaders, [eventItem]);
+}
+
+export { createEventEnvelope, createSessionEnvelope };
+//# sourceMappingURL=envelope.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/eventProcessors.js b/parent_dir/node_modules/sentry/core/esm/eventProcessors.js
new file mode 100644
index 0000000..6e2b316
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/eventProcessors.js
@@ -0,0 +1,53 @@
+import { getGlobalSingleton, SyncPromise, logger, isThenable } from '@sentry/utils';
+
+/**
+ * Returns the global event processors.
+ */
+function getGlobalEventProcessors() {
+  return getGlobalSingleton('globalEventProcessors', () => []);
+}
+
+/**
+ * Add a EventProcessor to be kept globally.
+ * @param callback EventProcessor to add
+ */
+function addGlobalEventProcessor(callback) {
+  getGlobalEventProcessors().push(callback);
+}
+
+/**
+ * Process an array of event processors, returning the processed event (or `null` if the event was dropped).
+ */
+function notifyEventProcessors(
+  processors,
+  event,
+  hint,
+  index = 0,
+) {
+  return new SyncPromise((resolve, reject) => {
+    const processor = processors[index];
+    if (event === null || typeof processor !== 'function') {
+      resolve(event);
+    } else {
+      const result = processor({ ...event }, hint) ;
+
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        processor.id &&
+        result === null &&
+        logger.log(`Event processor "${processor.id}" dropped event`);
+
+      if (isThenable(result)) {
+        void result
+          .then(final => notifyEventProcessors(processors, final, hint, index + 1).then(resolve))
+          .then(null, reject);
+      } else {
+        void notifyEventProcessors(processors, result, hint, index + 1)
+          .then(resolve)
+          .then(null, reject);
+      }
+    }
+  });
+}
+
+export { addGlobalEventProcessor, getGlobalEventProcessors, notifyEventProcessors };
+//# sourceMappingURL=eventProcessors.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/exports.js b/parent_dir/node_modules/sentry/core/esm/exports.js
new file mode 100644
index 0000000..2ec389a
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/exports.js
@@ -0,0 +1,238 @@
+import { logger, uuid4 } from '@sentry/utils';
+import { getCurrentHub } from './hub.js';
+
+// Note: All functions in this file are typed with a return value of `ReturnType<Hub[HUB_FUNCTION]>`,
+// where HUB_FUNCTION is some method on the Hub class.
+//
+// This is done to make sure the top level SDK methods stay in sync with the hub methods.
+// Although every method here has an explicit return type, some of them (that map to void returns) do not
+// contain `return` keywords. This is done to save on bundle size, as `return` is not minifiable.
+
+/**
+ * Captures an exception event and sends it to Sentry.
+ *
+ * @param exception An exception-like object.
+ * @param captureContext Additional scope data to apply to exception event.
+ * @returns The generated eventId.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+function captureException(exception, captureContext) {
+  return getCurrentHub().captureException(exception, { captureContext });
+}
+
+/**
+ * Captures a message event and sends it to Sentry.
+ *
+ * @param message The message to send to Sentry.
+ * @param Severity Define the level of the message.
+ * @returns The generated eventId.
+ */
+function captureMessage(
+  message,
+  // eslint-disable-next-line deprecation/deprecation
+  captureContext,
+) {
+  // This is necessary to provide explicit scopes upgrade, without changing the original
+  // arity of the `captureMessage(message, level)` method.
+  const level = typeof captureContext === 'string' ? captureContext : undefined;
+  const context = typeof captureContext !== 'string' ? { captureContext } : undefined;
+  return getCurrentHub().captureMessage(message, level, context);
+}
+
+/**
+ * Captures a manually created event and sends it to Sentry.
+ *
+ * @param event The event to send to Sentry.
+ * @returns The generated eventId.
+ */
+function captureEvent(event, hint) {
+  return getCurrentHub().captureEvent(event, hint);
+}
+
+/**
+ * Callback to set context information onto the scope.
+ * @param callback Callback function that receives Scope.
+ */
+function configureScope(callback) {
+  getCurrentHub().configureScope(callback);
+}
+
+/**
+ * Records a new breadcrumb which will be attached to future events.
+ *
+ * Breadcrumbs will be added to subsequent events to provide more context on
+ * user's actions prior to an error or crash.
+ *
+ * @param breadcrumb The breadcrumb to record.
+ */
+function addBreadcrumb(breadcrumb) {
+  getCurrentHub().addBreadcrumb(breadcrumb);
+}
+
+/**
+ * Sets context data with the given name.
+ * @param name of the context
+ * @param context Any kind of data. This data will be normalized.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function setContext(name, context) {
+  getCurrentHub().setContext(name, context);
+}
+
+/**
+ * Set an object that will be merged sent as extra data with the event.
+ * @param extras Extras object to merge into current context.
+ */
+function setExtras(extras) {
+  getCurrentHub().setExtras(extras);
+}
+
+/**
+ * Set key:value that will be sent as extra data with the event.
+ * @param key String of extra
+ * @param extra Any kind of data. This data will be normalized.
+ */
+function setExtra(key, extra) {
+  getCurrentHub().setExtra(key, extra);
+}
+
+/**
+ * Set an object that will be merged sent as tags data with the event.
+ * @param tags Tags context object to merge into current context.
+ */
+function setTags(tags) {
+  getCurrentHub().setTags(tags);
+}
+
+/**
+ * Set key:value that will be sent as tags data with the event.
+ *
+ * Can also be used to unset a tag, by passing `undefined`.
+ *
+ * @param key String key of tag
+ * @param value Value of tag
+ */
+function setTag(key, value) {
+  getCurrentHub().setTag(key, value);
+}
+
+/**
+ * Updates user context information for future events.
+ *
+ * @param user User context object to be set in the current context. Pass `null` to unset the user.
+ */
+function setUser(user) {
+  getCurrentHub().setUser(user);
+}
+
+/**
+ * Creates a new scope with and executes the given operation within.
+ * The scope is automatically removed once the operation
+ * finishes or throws.
+ *
+ * This is essentially a convenience function for:
+ *
+ *     pushScope();
+ *     callback();
+ *     popScope();
+ *
+ * @param callback that will be enclosed into push/popScope.
+ */
+function withScope(callback) {
+  getCurrentHub().withScope(callback);
+}
+
+/**
+ * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.
+ *
+ * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a
+ * new child span within the transaction or any span, call the respective `.startChild()` method.
+ *
+ * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.
+ *
+ * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its
+ * finished child spans will be sent to Sentry.
+ *
+ * NOTE: This function should only be used for *manual* instrumentation. Auto-instrumentation should call
+ * `startTransaction` directly on the hub.
+ *
+ * @param context Properties of the new `Transaction`.
+ * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent
+ * default values). See {@link Options.tracesSampler}.
+ *
+ * @returns The transaction which was just started
+ */
+function startTransaction(
+  context,
+  customSamplingContext,
+) {
+  return getCurrentHub().startTransaction({ ...context }, customSamplingContext);
+}
+
+/**
+ * Create a cron monitor check in and send it to Sentry.
+ *
+ * @param checkIn An object that describes a check in.
+ * @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want
+ * to create a monitor automatically when sending a check in.
+ */
+function captureCheckIn(checkIn, upsertMonitorConfig) {
+  const hub = getCurrentHub();
+  const scope = hub.getScope();
+  const client = hub.getClient();
+  if (!client) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot capture check-in. No client defined.');
+  } else if (!client.captureCheckIn) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot capture check-in. Client does not support sending check-ins.');
+  } else {
+    return client.captureCheckIn(checkIn, upsertMonitorConfig, scope);
+  }
+
+  return uuid4();
+}
+
+/**
+ * Call `flush()` on the current client, if there is one. See {@link Client.flush}.
+ *
+ * @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause
+ * the client to wait until all events are sent before resolving the promise.
+ * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it
+ * doesn't (or if there's no client defined).
+ */
+async function flush(timeout) {
+  const client = getCurrentHub().getClient();
+  if (client) {
+    return client.flush(timeout);
+  }
+  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events. No client defined.');
+  return Promise.resolve(false);
+}
+
+/**
+ * Call `close()` on the current client, if there is one. See {@link Client.close}.
+ *
+ * @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this
+ * parameter will cause the client to wait until all events are sent before disabling itself.
+ * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it
+ * doesn't (or if there's no client defined).
+ */
+async function close(timeout) {
+  const client = getCurrentHub().getClient();
+  if (client) {
+    return client.close(timeout);
+  }
+  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events and disable SDK. No client defined.');
+  return Promise.resolve(false);
+}
+
+/**
+ * This is the getter for lastEventId.
+ *
+ * @returns The last event id of a captured event.
+ */
+function lastEventId() {
+  return getCurrentHub().lastEventId();
+}
+
+export { addBreadcrumb, captureCheckIn, captureEvent, captureException, captureMessage, close, configureScope, flush, lastEventId, setContext, setExtra, setExtras, setTag, setTags, setUser, startTransaction, withScope };
+//# sourceMappingURL=exports.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/hub.js b/parent_dir/node_modules/sentry/core/esm/hub.js
new file mode 100644
index 0000000..29e41c1
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/hub.js
@@ -0,0 +1,572 @@
+import { uuid4, dateTimestampInSeconds, consoleSandbox, logger, GLOBAL_OBJ, getGlobalSingleton } from '@sentry/utils';
+import { DEFAULT_ENVIRONMENT } from './constants.js';
+import { Scope } from './scope.js';
+import { closeSession, makeSession, updateSession } from './session.js';
+
+/**
+ * API compatibility version of this hub.
+ *
+ * WARNING: This number should only be increased when the global interface
+ * changes and new methods are introduced.
+ *
+ * @hidden
+ */
+const API_VERSION = 4;
+
+/**
+ * Default maximum number of breadcrumbs added to an event. Can be overwritten
+ * with {@link Options.maxBreadcrumbs}.
+ */
+const DEFAULT_BREADCRUMBS = 100;
+
+/**
+ * @inheritDoc
+ */
+class Hub  {
+  /** Is a {@link Layer}[] containing the client and scope */
+
+  /** Contains the last event id of a captured event.  */
+
+  /**
+   * Creates a new instance of the hub, will push one {@link Layer} into the
+   * internal stack on creation.
+   *
+   * @param client bound to the hub.
+   * @param scope bound to the hub.
+   * @param version number, higher number means higher priority.
+   */
+   constructor(client, scope = new Scope(),   _version = API_VERSION) {this._version = _version;
+    this._stack = [{ scope }];
+    if (client) {
+      this.bindClient(client);
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+   isOlderThan(version) {
+    return this._version < version;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   bindClient(client) {
+    const top = this.getStackTop();
+    top.client = client;
+    if (client && client.setupIntegrations) {
+      client.setupIntegrations();
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+   pushScope() {
+    // We want to clone the content of prev scope
+    const scope = Scope.clone(this.getScope());
+    this.getStack().push({
+      client: this.getClient(),
+      scope,
+    });
+    return scope;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   popScope() {
+    if (this.getStack().length <= 1) return false;
+    return !!this.getStack().pop();
+  }
+
+  /**
+   * @inheritDoc
+   */
+   withScope(callback) {
+    const scope = this.pushScope();
+    try {
+      callback(scope);
+    } finally {
+      this.popScope();
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getClient() {
+    return this.getStackTop().client ;
+  }
+
+  /** Returns the scope of the top stack. */
+   getScope() {
+    return this.getStackTop().scope;
+  }
+
+  /** Returns the scope stack for domains or the process. */
+   getStack() {
+    return this._stack;
+  }
+
+  /** Returns the topmost scope layer in the order domain > local > process. */
+   getStackTop() {
+    return this._stack[this._stack.length - 1];
+  }
+
+  /**
+   * @inheritDoc
+   */
+   captureException(exception, hint) {
+    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());
+    const syntheticException = new Error('Sentry syntheticException');
+    this._withClient((client, scope) => {
+      client.captureException(
+        exception,
+        {
+          originalException: exception,
+          syntheticException,
+          ...hint,
+          event_id: eventId,
+        },
+        scope,
+      );
+    });
+    return eventId;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   captureMessage(
+    message,
+    // eslint-disable-next-line deprecation/deprecation
+    level,
+    hint,
+  ) {
+    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());
+    const syntheticException = new Error(message);
+    this._withClient((client, scope) => {
+      client.captureMessage(
+        message,
+        level,
+        {
+          originalException: message,
+          syntheticException,
+          ...hint,
+          event_id: eventId,
+        },
+        scope,
+      );
+    });
+    return eventId;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   captureEvent(event, hint) {
+    const eventId = hint && hint.event_id ? hint.event_id : uuid4();
+    if (!event.type) {
+      this._lastEventId = eventId;
+    }
+
+    this._withClient((client, scope) => {
+      client.captureEvent(event, { ...hint, event_id: eventId }, scope);
+    });
+    return eventId;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   lastEventId() {
+    return this._lastEventId;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   addBreadcrumb(breadcrumb, hint) {
+    const { scope, client } = this.getStackTop();
+
+    if (!client) return;
+
+    const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } =
+      (client.getOptions && client.getOptions()) || {};
+
+    if (maxBreadcrumbs <= 0) return;
+
+    const timestamp = dateTimestampInSeconds();
+    const mergedBreadcrumb = { timestamp, ...breadcrumb };
+    const finalBreadcrumb = beforeBreadcrumb
+      ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) )
+      : mergedBreadcrumb;
+
+    if (finalBreadcrumb === null) return;
+
+    if (client.emit) {
+      client.emit('beforeAddBreadcrumb', finalBreadcrumb, hint);
+    }
+
+    scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setUser(user) {
+    this.getScope().setUser(user);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setTags(tags) {
+    this.getScope().setTags(tags);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setExtras(extras) {
+    this.getScope().setExtras(extras);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setTag(key, value) {
+    this.getScope().setTag(key, value);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setExtra(key, extra) {
+    this.getScope().setExtra(key, extra);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+   setContext(name, context) {
+    this.getScope().setContext(name, context);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   configureScope(callback) {
+    const { scope, client } = this.getStackTop();
+    if (client) {
+      callback(scope);
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+   run(callback) {
+    const oldHub = makeMain(this);
+    try {
+      callback(this);
+    } finally {
+      makeMain(oldHub);
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getIntegration(integration) {
+    const client = this.getClient();
+    if (!client) return null;
+    try {
+      return client.getIntegration(integration);
+    } catch (_oO) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);
+      return null;
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+   startTransaction(context, customSamplingContext) {
+    const result = this._callExtensionMethod('startTransaction', context, customSamplingContext);
+
+    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && !result) {
+      const client = this.getClient();
+      if (!client) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          "Tracing extension 'startTransaction' is missing. You should 'init' the SDK before calling 'startTransaction'",
+        );
+      } else {
+        // eslint-disable-next-line no-console
+        console.warn(`Tracing extension 'startTransaction' has not been added. Call 'addTracingExtensions' before calling 'init':
+Sentry.addTracingExtensions();
+Sentry.init({...});
+`);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   traceHeaders() {
+    return this._callExtensionMethod('traceHeaders');
+  }
+
+  /**
+   * @inheritDoc
+   */
+   captureSession(endSession = false) {
+    // both send the update and pull the session from the scope
+    if (endSession) {
+      return this.endSession();
+    }
+
+    // only send the update
+    this._sendSessionUpdate();
+  }
+
+  /**
+   * @inheritDoc
+   */
+   endSession() {
+    const layer = this.getStackTop();
+    const scope = layer.scope;
+    const session = scope.getSession();
+    if (session) {
+      closeSession(session);
+    }
+    this._sendSessionUpdate();
+
+    // the session is over; take it off of the scope
+    scope.setSession();
+  }
+
+  /**
+   * @inheritDoc
+   */
+   startSession(context) {
+    const { scope, client } = this.getStackTop();
+    const { release, environment = DEFAULT_ENVIRONMENT } = (client && client.getOptions()) || {};
+
+    // Will fetch userAgent if called from browser sdk
+    const { userAgent } = GLOBAL_OBJ.navigator || {};
+
+    const session = makeSession({
+      release,
+      environment,
+      user: scope.getUser(),
+      ...(userAgent && { userAgent }),
+      ...context,
+    });
+
+    // End existing session if there's one
+    const currentSession = scope.getSession && scope.getSession();
+    if (currentSession && currentSession.status === 'ok') {
+      updateSession(currentSession, { status: 'exited' });
+    }
+    this.endSession();
+
+    // Afterwards we set the new session on the scope
+    scope.setSession(session);
+
+    return session;
+  }
+
+  /**
+   * Returns if default PII should be sent to Sentry and propagated in ourgoing requests
+   * when Tracing is used.
+   */
+   shouldSendDefaultPii() {
+    const client = this.getClient();
+    const options = client && client.getOptions();
+    return Boolean(options && options.sendDefaultPii);
+  }
+
+  /**
+   * Sends the current Session on the scope
+   */
+   _sendSessionUpdate() {
+    const { scope, client } = this.getStackTop();
+
+    const session = scope.getSession();
+    if (session && client && client.captureSession) {
+      client.captureSession(session);
+    }
+  }
+
+  /**
+   * Internal helper function to call a method on the top client if it exists.
+   *
+   * @param method The method to call on the client.
+   * @param args Arguments to pass to the client function.
+   */
+   _withClient(callback) {
+    const { scope, client } = this.getStackTop();
+    if (client) {
+      callback(client, scope);
+    }
+  }
+
+  /**
+   * Calls global extension method and binding current instance to the function call
+   */
+  // @ts-expect-error Function lacks ending return statement and return type does not include 'undefined'. ts(2366)
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+   _callExtensionMethod(method, ...args) {
+    const carrier = getMainCarrier();
+    const sentry = carrier.__SENTRY__;
+    if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {
+      return sentry.extensions[method].apply(this, args);
+    }
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);
+  }
+}
+
+/**
+ * Returns the global shim registry.
+ *
+ * FIXME: This function is problematic, because despite always returning a valid Carrier,
+ * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check
+ * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.
+ **/
+function getMainCarrier() {
+  GLOBAL_OBJ.__SENTRY__ = GLOBAL_OBJ.__SENTRY__ || {
+    extensions: {},
+    hub: undefined,
+  };
+  return GLOBAL_OBJ;
+}
+
+/**
+ * Replaces the current main hub with the passed one on the global object
+ *
+ * @returns The old replaced hub
+ */
+function makeMain(hub) {
+  const registry = getMainCarrier();
+  const oldHub = getHubFromCarrier(registry);
+  setHubOnCarrier(registry, hub);
+  return oldHub;
+}
+
+/**
+ * Returns the default hub instance.
+ *
+ * If a hub is already registered in the global carrier but this module
+ * contains a more recent version, it replaces the registered version.
+ * Otherwise, the currently registered hub will be returned.
+ */
+function getCurrentHub() {
+  // Get main carrier (global for every environment)
+  const registry = getMainCarrier();
+
+  if (registry.__SENTRY__ && registry.__SENTRY__.acs) {
+    const hub = registry.__SENTRY__.acs.getCurrentHub();
+
+    if (hub) {
+      return hub;
+    }
+  }
+
+  // Return hub that lives on a global object
+  return getGlobalHub(registry);
+}
+
+function getGlobalHub(registry = getMainCarrier()) {
+  // If there's no hub, or its an old API, assign a new one
+  if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {
+    setHubOnCarrier(registry, new Hub());
+  }
+
+  // Return hub that lives on a global object
+  return getHubFromCarrier(registry);
+}
+
+/**
+ * @private Private API with no semver guarantees!
+ *
+ * If the carrier does not contain a hub, a new hub is created with the global hub client and scope.
+ */
+function ensureHubOnCarrier(carrier, parent = getGlobalHub()) {
+  // If there's no hub on current domain, or it's an old API, assign a new one
+  if (!hasHubOnCarrier(carrier) || getHubFromCarrier(carrier).isOlderThan(API_VERSION)) {
+    const globalHubTopStack = parent.getStackTop();
+    setHubOnCarrier(carrier, new Hub(globalHubTopStack.client, Scope.clone(globalHubTopStack.scope)));
+  }
+}
+
+/**
+ * @private Private API with no semver guarantees!
+ *
+ * Sets the global async context strategy
+ */
+function setAsyncContextStrategy(strategy) {
+  // Get main carrier (global for every environment)
+  const registry = getMainCarrier();
+  registry.__SENTRY__ = registry.__SENTRY__ || {};
+  registry.__SENTRY__.acs = strategy;
+}
+
+/**
+ * Runs the supplied callback in its own async context. Async Context strategies are defined per SDK.
+ *
+ * @param callback The callback to run in its own async context
+ * @param options Options to pass to the async context strategy
+ * @returns The result of the callback
+ */
+function runWithAsyncContext(callback, options = {}) {
+  const registry = getMainCarrier();
+
+  if (registry.__SENTRY__ && registry.__SENTRY__.acs) {
+    return registry.__SENTRY__.acs.runWithAsyncContext(callback, options);
+  }
+
+  // if there was no strategy, fallback to just calling the callback
+  return callback();
+}
+
+/**
+ * This will tell whether a carrier has a hub on it or not
+ * @param carrier object
+ */
+function hasHubOnCarrier(carrier) {
+  return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);
+}
+
+/**
+ * This will create a new {@link Hub} and add to the passed object on
+ * __SENTRY__.hub.
+ * @param carrier object
+ * @hidden
+ */
+function getHubFromCarrier(carrier) {
+  return getGlobalSingleton('hub', () => new Hub(), carrier);
+}
+
+/**
+ * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute
+ * @param carrier object
+ * @param hub Hub
+ * @returns A boolean indicating success or failure
+ */
+function setHubOnCarrier(carrier, hub) {
+  if (!carrier) return false;
+  const __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});
+  __SENTRY__.hub = hub;
+  return true;
+}
+
+export { API_VERSION, Hub, ensureHubOnCarrier, getCurrentHub, getHubFromCarrier, getMainCarrier, makeMain, runWithAsyncContext, setAsyncContextStrategy, setHubOnCarrier };
+//# sourceMappingURL=hub.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/integration.js b/parent_dir/node_modules/sentry/core/esm/integration.js
new file mode 100644
index 0000000..9673001
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/integration.js
@@ -0,0 +1,128 @@
+import { arrayify, logger } from '@sentry/utils';
+import { addGlobalEventProcessor } from './eventProcessors.js';
+import { getCurrentHub } from './hub.js';
+
+const installedIntegrations = [];
+
+/** Map of integrations assigned to a client */
+
+/**
+ * Remove duplicates from the given array, preferring the last instance of any duplicate. Not guaranteed to
+ * preseve the order of integrations in the array.
+ *
+ * @private
+ */
+function filterDuplicates(integrations) {
+  const integrationsByName = {};
+
+  integrations.forEach(currentInstance => {
+    const { name } = currentInstance;
+
+    const existingInstance = integrationsByName[name];
+
+    // We want integrations later in the array to overwrite earlier ones of the same type, except that we never want a
+    // default instance to overwrite an existing user instance
+    if (existingInstance && !existingInstance.isDefaultInstance && currentInstance.isDefaultInstance) {
+      return;
+    }
+
+    integrationsByName[name] = currentInstance;
+  });
+
+  return Object.keys(integrationsByName).map(k => integrationsByName[k]);
+}
+
+/** Gets integrations to install */
+function getIntegrationsToSetup(options) {
+  const defaultIntegrations = options.defaultIntegrations || [];
+  const userIntegrations = options.integrations;
+
+  // We flag default instances, so that later we can tell them apart from any user-created instances of the same class
+  defaultIntegrations.forEach(integration => {
+    integration.isDefaultInstance = true;
+  });
+
+  let integrations;
+
+  if (Array.isArray(userIntegrations)) {
+    integrations = [...defaultIntegrations, ...userIntegrations];
+  } else if (typeof userIntegrations === 'function') {
+    integrations = arrayify(userIntegrations(defaultIntegrations));
+  } else {
+    integrations = defaultIntegrations;
+  }
+
+  const finalIntegrations = filterDuplicates(integrations);
+
+  // The `Debug` integration prints copies of the `event` and `hint` which will be passed to `beforeSend` or
+  // `beforeSendTransaction`. It therefore has to run after all other integrations, so that the changes of all event
+  // processors will be reflected in the printed values. For lack of a more elegant way to guarantee that, we therefore
+  // locate it and, assuming it exists, pop it out of its current spot and shove it onto the end of the array.
+  const debugIndex = findIndex(finalIntegrations, integration => integration.name === 'Debug');
+  if (debugIndex !== -1) {
+    const [debugInstance] = finalIntegrations.splice(debugIndex, 1);
+    finalIntegrations.push(debugInstance);
+  }
+
+  return finalIntegrations;
+}
+
+/**
+ * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default
+ * integrations are added unless they were already provided before.
+ * @param integrations array of integration instances
+ * @param withDefault should enable default integrations
+ */
+function setupIntegrations(client, integrations) {
+  const integrationIndex = {};
+
+  integrations.forEach(integration => {
+    // guard against empty provided integrations
+    if (integration) {
+      setupIntegration(client, integration, integrationIndex);
+    }
+  });
+
+  return integrationIndex;
+}
+
+/** Setup a single integration.  */
+function setupIntegration(client, integration, integrationIndex) {
+  integrationIndex[integration.name] = integration;
+
+  if (installedIntegrations.indexOf(integration.name) === -1) {
+    integration.setupOnce(addGlobalEventProcessor, getCurrentHub);
+    installedIntegrations.push(integration.name);
+  }
+
+  if (client.on && typeof integration.preprocessEvent === 'function') {
+    const callback = integration.preprocessEvent.bind(integration) ;
+    client.on('preprocessEvent', (event, hint) => callback(event, hint, client));
+  }
+
+  if (client.addEventProcessor && typeof integration.processEvent === 'function') {
+    const callback = integration.processEvent.bind(integration) ;
+
+    const processor = Object.assign((event, hint) => callback(event, hint, client), {
+      id: integration.name,
+    });
+
+    client.addEventProcessor(processor);
+  }
+
+  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Integration installed: ${integration.name}`);
+}
+
+// Polyfill for Array.findIndex(), which is not supported in ES5
+function findIndex(arr, callback) {
+  for (let i = 0; i < arr.length; i++) {
+    if (callback(arr[i]) === true) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+export { getIntegrationsToSetup, installedIntegrations, setupIntegration, setupIntegrations };
+//# sourceMappingURL=integration.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/integrations/functiontostring.js b/parent_dir/node_modules/sentry/core/esm/integrations/functiontostring.js
new file mode 100644
index 0000000..9106aea
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/integrations/functiontostring.js
@@ -0,0 +1,42 @@
+import { getOriginalFunction } from '@sentry/utils';
+
+let originalFunctionToString;
+
+/** Patch toString calls to return proper name for wrapped functions */
+class FunctionToString  {
+  /**
+   * @inheritDoc
+   */
+   static __initStatic() {this.id = 'FunctionToString';}
+
+  /**
+   * @inheritDoc
+   */
+
+   constructor() {
+    this.name = FunctionToString.id;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setupOnce() {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    originalFunctionToString = Function.prototype.toString;
+
+    // intrinsics (like Function.prototype) might be immutable in some environments
+    // e.g. Node with --frozen-intrinsics, XS (an embedded JavaScript engine) or SES (a JavaScript proposal)
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      Function.prototype.toString = function ( ...args) {
+        const context = getOriginalFunction(this) || this;
+        return originalFunctionToString.apply(context, args);
+      };
+    } catch (e) {
+      // ignore errors here, just don't patch this
+    }
+  }
+} FunctionToString.__initStatic();
+
+export { FunctionToString };
+//# sourceMappingURL=functiontostring.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/integrations/inboundfilters.js b/parent_dir/node_modules/sentry/core/esm/integrations/inboundfilters.js
new file mode 100644
index 0000000..062b508
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/integrations/inboundfilters.js
@@ -0,0 +1,230 @@
+import { logger, getEventDescription, stringMatchesSomePattern } from '@sentry/utils';
+
+// "Script error." is hard coded into browsers for errors that it can't read.
+// this is the result of a script being pulled in from an external domain and CORS.
+const DEFAULT_IGNORE_ERRORS = [/^Script error\.?$/, /^Javascript error: Script error\.? on line 0$/];
+
+const DEFAULT_IGNORE_TRANSACTIONS = [
+  /^.*healthcheck.*$/,
+  /^.*healthy.*$/,
+  /^.*live.*$/,
+  /^.*ready.*$/,
+  /^.*heartbeat.*$/,
+  /^.*\/health$/,
+  /^.*\/healthz$/,
+];
+
+/** Options for the InboundFilters integration */
+
+/** Inbound filters configurable by the user */
+class InboundFilters  {
+  /**
+   * @inheritDoc
+   */
+   static __initStatic() {this.id = 'InboundFilters';}
+
+  /**
+   * @inheritDoc
+   */
+
+   constructor(options = {}) {
+    this.name = InboundFilters.id;
+    this._options = options;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setupOnce(addGlobalEventProcessor, getCurrentHub) {
+    const eventProcess = (event) => {
+      const hub = getCurrentHub();
+      if (hub) {
+        const self = hub.getIntegration(InboundFilters);
+        if (self) {
+          const client = hub.getClient();
+          const clientOptions = client ? client.getOptions() : {};
+          const options = _mergeOptions(self._options, clientOptions);
+          return _shouldDropEvent(event, options) ? null : event;
+        }
+      }
+      return event;
+    };
+
+    eventProcess.id = this.name;
+    addGlobalEventProcessor(eventProcess);
+  }
+} InboundFilters.__initStatic();
+
+/** JSDoc */
+function _mergeOptions(
+  internalOptions = {},
+  clientOptions = {},
+) {
+  return {
+    allowUrls: [...(internalOptions.allowUrls || []), ...(clientOptions.allowUrls || [])],
+    denyUrls: [...(internalOptions.denyUrls || []), ...(clientOptions.denyUrls || [])],
+    ignoreErrors: [
+      ...(internalOptions.ignoreErrors || []),
+      ...(clientOptions.ignoreErrors || []),
+      ...(internalOptions.disableErrorDefaults ? [] : DEFAULT_IGNORE_ERRORS),
+    ],
+    ignoreTransactions: [
+      ...(internalOptions.ignoreTransactions || []),
+      ...(clientOptions.ignoreTransactions || []),
+      ...(internalOptions.disableTransactionDefaults ? [] : DEFAULT_IGNORE_TRANSACTIONS),
+    ],
+    ignoreInternal: internalOptions.ignoreInternal !== undefined ? internalOptions.ignoreInternal : true,
+  };
+}
+
+/** JSDoc */
+function _shouldDropEvent(event, options) {
+  if (options.ignoreInternal && _isSentryError(event)) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.warn(`Event dropped due to being internal Sentry Error.\nEvent: ${getEventDescription(event)}`);
+    return true;
+  }
+  if (_isIgnoredError(event, options.ignoreErrors)) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.warn(
+        `Event dropped due to being matched by \`ignoreErrors\` option.\nEvent: ${getEventDescription(event)}`,
+      );
+    return true;
+  }
+  if (_isIgnoredTransaction(event, options.ignoreTransactions)) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.warn(
+        `Event dropped due to being matched by \`ignoreTransactions\` option.\nEvent: ${getEventDescription(event)}`,
+      );
+    return true;
+  }
+  if (_isDeniedUrl(event, options.denyUrls)) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.warn(
+        `Event dropped due to being matched by \`denyUrls\` option.\nEvent: ${getEventDescription(
+          event,
+        )}.\nUrl: ${_getEventFilterUrl(event)}`,
+      );
+    return true;
+  }
+  if (!_isAllowedUrl(event, options.allowUrls)) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.warn(
+        `Event dropped due to not being matched by \`allowUrls\` option.\nEvent: ${getEventDescription(
+          event,
+        )}.\nUrl: ${_getEventFilterUrl(event)}`,
+      );
+    return true;
+  }
+  return false;
+}
+
+function _isIgnoredError(event, ignoreErrors) {
+  // If event.type, this is not an error
+  if (event.type || !ignoreErrors || !ignoreErrors.length) {
+    return false;
+  }
+
+  return _getPossibleEventMessages(event).some(message => stringMatchesSomePattern(message, ignoreErrors));
+}
+
+function _isIgnoredTransaction(event, ignoreTransactions) {
+  if (event.type !== 'transaction' || !ignoreTransactions || !ignoreTransactions.length) {
+    return false;
+  }
+
+  const name = event.transaction;
+  return name ? stringMatchesSomePattern(name, ignoreTransactions) : false;
+}
+
+function _isDeniedUrl(event, denyUrls) {
+  // TODO: Use Glob instead?
+  if (!denyUrls || !denyUrls.length) {
+    return false;
+  }
+  const url = _getEventFilterUrl(event);
+  return !url ? false : stringMatchesSomePattern(url, denyUrls);
+}
+
+function _isAllowedUrl(event, allowUrls) {
+  // TODO: Use Glob instead?
+  if (!allowUrls || !allowUrls.length) {
+    return true;
+  }
+  const url = _getEventFilterUrl(event);
+  return !url ? true : stringMatchesSomePattern(url, allowUrls);
+}
+
+function _getPossibleEventMessages(event) {
+  const possibleMessages = [];
+
+  if (event.message) {
+    possibleMessages.push(event.message);
+  }
+
+  let lastException;
+  try {
+    // @ts-expect-error Try catching to save bundle size
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    lastException = event.exception.values[event.exception.values.length - 1];
+  } catch (e) {
+    // try catching to save bundle size checking existence of variables
+  }
+
+  if (lastException) {
+    if (lastException.value) {
+      possibleMessages.push(lastException.value);
+      if (lastException.type) {
+        possibleMessages.push(`${lastException.type}: ${lastException.value}`);
+      }
+    }
+  }
+
+  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && possibleMessages.length === 0) {
+    logger.error(`Could not extract message for event ${getEventDescription(event)}`);
+  }
+
+  return possibleMessages;
+}
+
+function _isSentryError(event) {
+  try {
+    // @ts-expect-error can't be a sentry error if undefined
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    return event.exception.values[0].type === 'SentryError';
+  } catch (e) {
+    // ignore
+  }
+  return false;
+}
+
+function _getLastValidUrl(frames = []) {
+  for (let i = frames.length - 1; i >= 0; i--) {
+    const frame = frames[i];
+
+    if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {
+      return frame.filename || null;
+    }
+  }
+
+  return null;
+}
+
+function _getEventFilterUrl(event) {
+  try {
+    let frames;
+    try {
+      // @ts-expect-error we only care about frames if the whole thing here is defined
+      frames = event.exception.values[0].stacktrace.frames;
+    } catch (e) {
+      // ignore
+    }
+    return frames ? _getLastValidUrl(frames) : null;
+  } catch (oO) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(`Cannot extract url for event ${getEventDescription(event)}`);
+    return null;
+  }
+}
+
+export { InboundFilters, _mergeOptions, _shouldDropEvent };
+//# sourceMappingURL=inboundfilters.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/integrations/metadata.js b/parent_dir/node_modules/sentry/core/esm/integrations/metadata.js
new file mode 100644
index 0000000..0df48f4
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/integrations/metadata.js
@@ -0,0 +1,61 @@
+import { forEachEnvelopeItem } from '@sentry/utils';
+import { stripMetadataFromStackFrames, addMetadataToStackFrames } from '../metadata.js';
+
+/**
+ * Adds module metadata to stack frames.
+ *
+ * Metadata can be injected by the Sentry bundler plugins using the `_experiments.moduleMetadata` config option.
+ *
+ * When this integration is added, the metadata passed to the bundler plugin is added to the stack frames of all events
+ * under the `module_metadata` property. This can be used to help in tagging or routing of events from different teams
+ * our sources
+ */
+class ModuleMetadata  {
+  /*
+   * @inheritDoc
+   */
+   static __initStatic() {this.id = 'ModuleMetadata';}
+
+  /**
+   * @inheritDoc
+   */
+
+   constructor() {
+    this.name = ModuleMetadata.id;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setupOnce(addGlobalEventProcessor, getCurrentHub) {
+    const client = getCurrentHub().getClient();
+
+    if (!client || typeof client.on !== 'function') {
+      return;
+    }
+
+    // We need to strip metadata from stack frames before sending them to Sentry since these are client side only.
+    client.on('beforeEnvelope', envelope => {
+      forEachEnvelopeItem(envelope, (item, type) => {
+        if (type === 'event') {
+          const event = Array.isArray(item) ? (item )[1] : undefined;
+
+          if (event) {
+            stripMetadataFromStackFrames(event);
+            item[1] = event;
+          }
+        }
+      });
+    });
+
+    const stackParser = client.getOptions().stackParser;
+
+    addGlobalEventProcessor(event => {
+      addMetadataToStackFrames(stackParser, event);
+      return event;
+    });
+  }
+} ModuleMetadata.__initStatic();
+
+export { ModuleMetadata };
+//# sourceMappingURL=metadata.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/metadata.js b/parent_dir/node_modules/sentry/core/esm/metadata.js
new file mode 100644
index 0000000..dbeca8b
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/metadata.js
@@ -0,0 +1,99 @@
+import { GLOBAL_OBJ } from '@sentry/utils';
+
+/** Keys are source filename/url, values are metadata objects. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const filenameMetadataMap = new Map();
+/** Set of stack strings that have already been parsed. */
+const parsedStacks = new Set();
+
+function ensureMetadataStacksAreParsed(parser) {
+  if (!GLOBAL_OBJ._sentryModuleMetadata) {
+    return;
+  }
+
+  for (const stack of Object.keys(GLOBAL_OBJ._sentryModuleMetadata)) {
+    const metadata = GLOBAL_OBJ._sentryModuleMetadata[stack];
+
+    if (parsedStacks.has(stack)) {
+      continue;
+    }
+
+    // Ensure this stack doesn't get parsed again
+    parsedStacks.add(stack);
+
+    const frames = parser(stack);
+
+    // Go through the frames starting from the top of the stack and find the first one with a filename
+    for (const frame of frames.reverse()) {
+      if (frame.filename) {
+        // Save the metadata for this filename
+        filenameMetadataMap.set(frame.filename, metadata);
+        break;
+      }
+    }
+  }
+}
+
+/**
+ * Retrieve metadata for a specific JavaScript file URL.
+ *
+ * Metadata is injected by the Sentry bundler plugins using the `_experiments.moduleMetadata` config option.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getMetadataForUrl(parser, filename) {
+  ensureMetadataStacksAreParsed(parser);
+  return filenameMetadataMap.get(filename);
+}
+
+/**
+ * Adds metadata to stack frames.
+ *
+ * Metadata is injected by the Sentry bundler plugins using the `_experiments.moduleMetadata` config option.
+ */
+function addMetadataToStackFrames(parser, event) {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    event.exception.values.forEach(exception => {
+      if (!exception.stacktrace) {
+        return;
+      }
+
+      for (const frame of exception.stacktrace.frames || []) {
+        if (!frame.filename) {
+          continue;
+        }
+
+        const metadata = getMetadataForUrl(parser, frame.filename);
+
+        if (metadata) {
+          frame.module_metadata = metadata;
+        }
+      }
+    });
+  } catch (_) {
+    // To save bundle size we're just try catching here instead of checking for the existence of all the different objects.
+  }
+}
+
+/**
+ * Strips metadata from stack frames.
+ */
+function stripMetadataFromStackFrames(event) {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    event.exception.values.forEach(exception => {
+      if (!exception.stacktrace) {
+        return;
+      }
+
+      for (const frame of exception.stacktrace.frames || []) {
+        delete frame.module_metadata;
+      }
+    });
+  } catch (_) {
+    // To save bundle size we're just try catching here instead of checking for the existence of all the different objects.
+  }
+}
+
+export { addMetadataToStackFrames, getMetadataForUrl, stripMetadataFromStackFrames };
+//# sourceMappingURL=metadata.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/scope.js b/parent_dir/node_modules/sentry/core/esm/scope.js
new file mode 100644
index 0000000..4f5cad6
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/scope.js
@@ -0,0 +1,556 @@
+import { isPlainObject, dateTimestampInSeconds, arrayify, uuid4 } from '@sentry/utils';
+import { notifyEventProcessors, getGlobalEventProcessors } from './eventProcessors.js';
+import { updateSession } from './session.js';
+
+/**
+ * Default value for maximum number of breadcrumbs added to an event.
+ */
+const DEFAULT_MAX_BREADCRUMBS = 100;
+
+/**
+ * Holds additional event information. {@link Scope.applyToEvent} will be
+ * called by the client before an event will be sent.
+ */
+class Scope  {
+  /** Flag if notifying is happening. */
+
+  /** Callback for client to receive scope changes. */
+
+  /** Callback list that will be called after {@link applyToEvent}. */
+
+  /** Array of breadcrumbs. */
+
+  /** User */
+
+  /** Tags */
+
+  /** Extra */
+
+  /** Contexts */
+
+  /** Attachments */
+
+  /** Propagation Context for distributed tracing */
+
+  /**
+   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get
+   * sent to Sentry
+   */
+
+  /** Fingerprint */
+
+  /** Severity */
+  // eslint-disable-next-line deprecation/deprecation
+
+  /** Transaction Name */
+
+  /** Span */
+
+  /** Session */
+
+  /** Request Mode Session Status */
+
+  // NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method.
+
+   constructor() {
+    this._notifyingListeners = false;
+    this._scopeListeners = [];
+    this._eventProcessors = [];
+    this._breadcrumbs = [];
+    this._attachments = [];
+    this._user = {};
+    this._tags = {};
+    this._extra = {};
+    this._contexts = {};
+    this._sdkProcessingMetadata = {};
+    this._propagationContext = generatePropagationContext();
+  }
+
+  /**
+   * Inherit values from the parent scope.
+   * @param scope to clone.
+   */
+   static clone(scope) {
+    const newScope = new Scope();
+    if (scope) {
+      newScope._breadcrumbs = [...scope._breadcrumbs];
+      newScope._tags = { ...scope._tags };
+      newScope._extra = { ...scope._extra };
+      newScope._contexts = { ...scope._contexts };
+      newScope._user = scope._user;
+      newScope._level = scope._level;
+      newScope._span = scope._span;
+      newScope._session = scope._session;
+      newScope._transactionName = scope._transactionName;
+      newScope._fingerprint = scope._fingerprint;
+      newScope._eventProcessors = [...scope._eventProcessors];
+      newScope._requestSession = scope._requestSession;
+      newScope._attachments = [...scope._attachments];
+      newScope._sdkProcessingMetadata = { ...scope._sdkProcessingMetadata };
+      newScope._propagationContext = { ...scope._propagationContext };
+    }
+    return newScope;
+  }
+
+  /**
+   * Add internal on change listener. Used for sub SDKs that need to store the scope.
+   * @hidden
+   */
+   addScopeListener(callback) {
+    this._scopeListeners.push(callback);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   addEventProcessor(callback) {
+    this._eventProcessors.push(callback);
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setUser(user) {
+    this._user = user || {};
+    if (this._session) {
+      updateSession(this._session, { user });
+    }
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getUser() {
+    return this._user;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getRequestSession() {
+    return this._requestSession;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setRequestSession(requestSession) {
+    this._requestSession = requestSession;
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setTags(tags) {
+    this._tags = {
+      ...this._tags,
+      ...tags,
+    };
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setTag(key, value) {
+    this._tags = { ...this._tags, [key]: value };
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setExtras(extras) {
+    this._extra = {
+      ...this._extra,
+      ...extras,
+    };
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setExtra(key, extra) {
+    this._extra = { ...this._extra, [key]: extra };
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setFingerprint(fingerprint) {
+    this._fingerprint = fingerprint;
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setLevel(
+    // eslint-disable-next-line deprecation/deprecation
+    level,
+  ) {
+    this._level = level;
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setTransactionName(name) {
+    this._transactionName = name;
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setContext(key, context) {
+    if (context === null) {
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete this._contexts[key];
+    } else {
+      this._contexts[key] = context;
+    }
+
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setSpan(span) {
+    this._span = span;
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getSpan() {
+    return this._span;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getTransaction() {
+    // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will
+    // have a pointer to the currently-active transaction.
+    const span = this.getSpan();
+    return span && span.transaction;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setSession(session) {
+    if (!session) {
+      delete this._session;
+    } else {
+      this._session = session;
+    }
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getSession() {
+    return this._session;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   update(captureContext) {
+    if (!captureContext) {
+      return this;
+    }
+
+    if (typeof captureContext === 'function') {
+      const updatedScope = (captureContext )(this);
+      return updatedScope instanceof Scope ? updatedScope : this;
+    }
+
+    if (captureContext instanceof Scope) {
+      this._tags = { ...this._tags, ...captureContext._tags };
+      this._extra = { ...this._extra, ...captureContext._extra };
+      this._contexts = { ...this._contexts, ...captureContext._contexts };
+      if (captureContext._user && Object.keys(captureContext._user).length) {
+        this._user = captureContext._user;
+      }
+      if (captureContext._level) {
+        this._level = captureContext._level;
+      }
+      if (captureContext._fingerprint) {
+        this._fingerprint = captureContext._fingerprint;
+      }
+      if (captureContext._requestSession) {
+        this._requestSession = captureContext._requestSession;
+      }
+      if (captureContext._propagationContext) {
+        this._propagationContext = captureContext._propagationContext;
+      }
+    } else if (isPlainObject(captureContext)) {
+      // eslint-disable-next-line no-param-reassign
+      captureContext = captureContext ;
+      this._tags = { ...this._tags, ...captureContext.tags };
+      this._extra = { ...this._extra, ...captureContext.extra };
+      this._contexts = { ...this._contexts, ...captureContext.contexts };
+      if (captureContext.user) {
+        this._user = captureContext.user;
+      }
+      if (captureContext.level) {
+        this._level = captureContext.level;
+      }
+      if (captureContext.fingerprint) {
+        this._fingerprint = captureContext.fingerprint;
+      }
+      if (captureContext.requestSession) {
+        this._requestSession = captureContext.requestSession;
+      }
+      if (captureContext.propagationContext) {
+        this._propagationContext = captureContext.propagationContext;
+      }
+    }
+
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   clear() {
+    this._breadcrumbs = [];
+    this._tags = {};
+    this._extra = {};
+    this._user = {};
+    this._contexts = {};
+    this._level = undefined;
+    this._transactionName = undefined;
+    this._fingerprint = undefined;
+    this._requestSession = undefined;
+    this._span = undefined;
+    this._session = undefined;
+    this._notifyScopeListeners();
+    this._attachments = [];
+    this._propagationContext = generatePropagationContext();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   addBreadcrumb(breadcrumb, maxBreadcrumbs) {
+    const maxCrumbs = typeof maxBreadcrumbs === 'number' ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;
+
+    // No data has been changed, so don't notify scope listeners
+    if (maxCrumbs <= 0) {
+      return this;
+    }
+
+    const mergedBreadcrumb = {
+      timestamp: dateTimestampInSeconds(),
+      ...breadcrumb,
+    };
+
+    const breadcrumbs = this._breadcrumbs;
+    breadcrumbs.push(mergedBreadcrumb);
+    this._breadcrumbs = breadcrumbs.length > maxCrumbs ? breadcrumbs.slice(-maxCrumbs) : breadcrumbs;
+
+    this._notifyScopeListeners();
+
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getLastBreadcrumb() {
+    return this._breadcrumbs[this._breadcrumbs.length - 1];
+  }
+
+  /**
+   * @inheritDoc
+   */
+   clearBreadcrumbs() {
+    this._breadcrumbs = [];
+    this._notifyScopeListeners();
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   addAttachment(attachment) {
+    this._attachments.push(attachment);
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getAttachments() {
+    return this._attachments;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   clearAttachments() {
+    this._attachments = [];
+    return this;
+  }
+
+  /**
+   * Applies data from the scope to the event and runs all event processors on it.
+   *
+   * @param event Event
+   * @param hint Object containing additional information about the original exception, for use by the event processors.
+   * @hidden
+   */
+   applyToEvent(event, hint = {}) {
+    if (this._extra && Object.keys(this._extra).length) {
+      event.extra = { ...this._extra, ...event.extra };
+    }
+    if (this._tags && Object.keys(this._tags).length) {
+      event.tags = { ...this._tags, ...event.tags };
+    }
+    if (this._user && Object.keys(this._user).length) {
+      event.user = { ...this._user, ...event.user };
+    }
+    if (this._contexts && Object.keys(this._contexts).length) {
+      event.contexts = { ...this._contexts, ...event.contexts };
+    }
+    if (this._level) {
+      event.level = this._level;
+    }
+    if (this._transactionName) {
+      event.transaction = this._transactionName;
+    }
+
+    // We want to set the trace context for normal events only if there isn't already
+    // a trace context on the event. There is a product feature in place where we link
+    // errors with transaction and it relies on that.
+    if (this._span) {
+      event.contexts = { trace: this._span.getTraceContext(), ...event.contexts };
+      const transaction = this._span.transaction;
+      if (transaction) {
+        event.sdkProcessingMetadata = {
+          dynamicSamplingContext: transaction.getDynamicSamplingContext(),
+          ...event.sdkProcessingMetadata,
+        };
+        const transactionName = transaction.name;
+        if (transactionName) {
+          event.tags = { transaction: transactionName, ...event.tags };
+        }
+      }
+    }
+
+    this._applyFingerprint(event);
+
+    const scopeBreadcrumbs = this._getBreadcrumbs();
+    const breadcrumbs = [...(event.breadcrumbs || []), ...scopeBreadcrumbs];
+    event.breadcrumbs = breadcrumbs.length > 0 ? breadcrumbs : undefined;
+
+    event.sdkProcessingMetadata = {
+      ...event.sdkProcessingMetadata,
+      ...this._sdkProcessingMetadata,
+      propagationContext: this._propagationContext,
+    };
+
+    return notifyEventProcessors([...getGlobalEventProcessors(), ...this._eventProcessors], event, hint);
+  }
+
+  /**
+   * Add data which will be accessible during event processing but won't get sent to Sentry
+   */
+   setSDKProcessingMetadata(newData) {
+    this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };
+
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setPropagationContext(context) {
+    this._propagationContext = context;
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getPropagationContext() {
+    return this._propagationContext;
+  }
+
+  /**
+   * Get the breadcrumbs for this scope.
+   */
+   _getBreadcrumbs() {
+    return this._breadcrumbs;
+  }
+
+  /**
+   * This will be called on every set call.
+   */
+   _notifyScopeListeners() {
+    // We need this check for this._notifyingListeners to be able to work on scope during updates
+    // If this check is not here we'll produce endless recursion when something is done with the scope
+    // during the callback.
+    if (!this._notifyingListeners) {
+      this._notifyingListeners = true;
+      this._scopeListeners.forEach(callback => {
+        callback(this);
+      });
+      this._notifyingListeners = false;
+    }
+  }
+
+  /**
+   * Applies fingerprint from the scope to the event if there's one,
+   * uses message if there's one instead or get rid of empty fingerprint
+   */
+   _applyFingerprint(event) {
+    // Make sure it's an array first and we actually have something in place
+    event.fingerprint = event.fingerprint ? arrayify(event.fingerprint) : [];
+
+    // If we have something on the scope, then merge it with event
+    if (this._fingerprint) {
+      event.fingerprint = event.fingerprint.concat(this._fingerprint);
+    }
+
+    // If we have no data at all, remove empty array default
+    if (event.fingerprint && !event.fingerprint.length) {
+      delete event.fingerprint;
+    }
+  }
+}
+
+function generatePropagationContext() {
+  return {
+    traceId: uuid4(),
+    spanId: uuid4().substring(16),
+  };
+}
+
+export { Scope };
+//# sourceMappingURL=scope.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/sdk.js b/parent_dir/node_modules/sentry/core/esm/sdk.js
new file mode 100644
index 0000000..5cb2237
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/sdk.js
@@ -0,0 +1,35 @@
+import { logger } from '@sentry/utils';
+import { getCurrentHub } from './hub.js';
+
+/** A class object that can instantiate Client objects. */
+
+/**
+ * Internal function to create a new SDK client instance. The client is
+ * installed and then bound to the current scope.
+ *
+ * @param clientClass The client class to instantiate.
+ * @param options Options to pass to the client.
+ */
+function initAndBind(
+  clientClass,
+  options,
+) {
+  if (options.debug === true) {
+    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+      logger.enable();
+    } else {
+      // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped
+      // eslint-disable-next-line no-console
+      console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');
+    }
+  }
+  const hub = getCurrentHub();
+  const scope = hub.getScope();
+  scope.update(options.initialScope);
+
+  const client = new clientClass(options);
+  hub.bindClient(client);
+}
+
+export { initAndBind };
+//# sourceMappingURL=sdk.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/session.js b/parent_dir/node_modules/sentry/core/esm/session.js
new file mode 100644
index 0000000..48a948f
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/session.js
@@ -0,0 +1,155 @@
+import { timestampInSeconds, uuid4, dropUndefinedKeys } from '@sentry/utils';
+
+/**
+ * Creates a new `Session` object by setting certain default parameters. If optional @param context
+ * is passed, the passed properties are applied to the session object.
+ *
+ * @param context (optional) additional properties to be applied to the returned session object
+ *
+ * @returns a new `Session` object
+ */
+function makeSession(context) {
+  // Both timestamp and started are in seconds since the UNIX epoch.
+  const startingTime = timestampInSeconds();
+
+  const session = {
+    sid: uuid4(),
+    init: true,
+    timestamp: startingTime,
+    started: startingTime,
+    duration: 0,
+    status: 'ok',
+    errors: 0,
+    ignoreDuration: false,
+    toJSON: () => sessionToJSON(session),
+  };
+
+  if (context) {
+    updateSession(session, context);
+  }
+
+  return session;
+}
+
+/**
+ * Updates a session object with the properties passed in the context.
+ *
+ * Note that this function mutates the passed object and returns void.
+ * (Had to do this instead of returning a new and updated session because closing and sending a session
+ * makes an update to the session after it was passed to the sending logic.
+ * @see BaseClient.captureSession )
+ *
+ * @param session the `Session` to update
+ * @param context the `SessionContext` holding the properties that should be updated in @param session
+ */
+// eslint-disable-next-line complexity
+function updateSession(session, context = {}) {
+  if (context.user) {
+    if (!session.ipAddress && context.user.ip_address) {
+      session.ipAddress = context.user.ip_address;
+    }
+
+    if (!session.did && !context.did) {
+      session.did = context.user.id || context.user.email || context.user.username;
+    }
+  }
+
+  session.timestamp = context.timestamp || timestampInSeconds();
+
+  if (context.ignoreDuration) {
+    session.ignoreDuration = context.ignoreDuration;
+  }
+  if (context.sid) {
+    // Good enough uuid validation. — Kamil
+    session.sid = context.sid.length === 32 ? context.sid : uuid4();
+  }
+  if (context.init !== undefined) {
+    session.init = context.init;
+  }
+  if (!session.did && context.did) {
+    session.did = `${context.did}`;
+  }
+  if (typeof context.started === 'number') {
+    session.started = context.started;
+  }
+  if (session.ignoreDuration) {
+    session.duration = undefined;
+  } else if (typeof context.duration === 'number') {
+    session.duration = context.duration;
+  } else {
+    const duration = session.timestamp - session.started;
+    session.duration = duration >= 0 ? duration : 0;
+  }
+  if (context.release) {
+    session.release = context.release;
+  }
+  if (context.environment) {
+    session.environment = context.environment;
+  }
+  if (!session.ipAddress && context.ipAddress) {
+    session.ipAddress = context.ipAddress;
+  }
+  if (!session.userAgent && context.userAgent) {
+    session.userAgent = context.userAgent;
+  }
+  if (typeof context.errors === 'number') {
+    session.errors = context.errors;
+  }
+  if (context.status) {
+    session.status = context.status;
+  }
+}
+
+/**
+ * Closes a session by setting its status and updating the session object with it.
+ * Internally calls `updateSession` to update the passed session object.
+ *
+ * Note that this function mutates the passed session (@see updateSession for explanation).
+ *
+ * @param session the `Session` object to be closed
+ * @param status the `SessionStatus` with which the session was closed. If you don't pass a status,
+ *               this function will keep the previously set status, unless it was `'ok'` in which case
+ *               it is changed to `'exited'`.
+ */
+function closeSession(session, status) {
+  let context = {};
+  if (status) {
+    context = { status };
+  } else if (session.status === 'ok') {
+    context = { status: 'exited' };
+  }
+
+  updateSession(session, context);
+}
+
+/**
+ * Serializes a passed session object to a JSON object with a slightly different structure.
+ * This is necessary because the Sentry backend requires a slightly different schema of a session
+ * than the one the JS SDKs use internally.
+ *
+ * @param session the session to be converted
+ *
+ * @returns a JSON object of the passed session
+ */
+function sessionToJSON(session) {
+  return dropUndefinedKeys({
+    sid: `${session.sid}`,
+    init: session.init,
+    // Make sure that sec is converted to ms for date constructor
+    started: new Date(session.started * 1000).toISOString(),
+    timestamp: new Date(session.timestamp * 1000).toISOString(),
+    status: session.status,
+    errors: session.errors,
+    did: typeof session.did === 'number' || typeof session.did === 'string' ? `${session.did}` : undefined,
+    duration: session.duration,
+    attrs: {
+      release: session.release,
+      environment: session.environment,
+      ip_address: session.ipAddress,
+      user_agent: session.userAgent,
+    },
+  });
+}
+
+export { closeSession, makeSession, updateSession };
+//# sourceMappingURL=session.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/tracing/dynamicSamplingContext.js b/parent_dir/node_modules/sentry/core/esm/tracing/dynamicSamplingContext.js
new file mode 100644
index 0000000..533c94f
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/tracing/dynamicSamplingContext.js
@@ -0,0 +1,33 @@
+import { dropUndefinedKeys } from '@sentry/utils';
+import { DEFAULT_ENVIRONMENT } from '../constants.js';
+
+/**
+ * Creates a dynamic sampling context from a client.
+ *
+ * Dispatchs the `createDsc` lifecycle hook as a side effect.
+ */
+function getDynamicSamplingContextFromClient(
+  trace_id,
+  client,
+  scope,
+) {
+  const options = client.getOptions();
+
+  const { publicKey: public_key } = client.getDsn() || {};
+  const { segment: user_segment } = (scope && scope.getUser()) || {};
+
+  const dsc = dropUndefinedKeys({
+    environment: options.environment || DEFAULT_ENVIRONMENT,
+    release: options.release,
+    user_segment,
+    public_key,
+    trace_id,
+  }) ;
+
+  client.emit && client.emit('createDsc', dsc);
+
+  return dsc;
+}
+
+export { getDynamicSamplingContextFromClient };
+//# sourceMappingURL=dynamicSamplingContext.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/tracing/errors.js b/parent_dir/node_modules/sentry/core/esm/tracing/errors.js
new file mode 100644
index 0000000..ddfd49b
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/tracing/errors.js
@@ -0,0 +1,36 @@
+import { addInstrumentationHandler, logger } from '@sentry/utils';
+import { getActiveTransaction } from './utils.js';
+
+let errorsInstrumented = false;
+
+/**
+ * Configures global error listeners
+ */
+function registerErrorInstrumentation() {
+  if (errorsInstrumented) {
+    return;
+  }
+
+  errorsInstrumented = true;
+  addInstrumentationHandler('error', errorCallback);
+  addInstrumentationHandler('unhandledrejection', errorCallback);
+}
+
+/**
+ * If an error or unhandled promise occurs, we mark the active transaction as failed
+ */
+function errorCallback() {
+  const activeTransaction = getActiveTransaction();
+  if (activeTransaction) {
+    const status = 'internal_error';
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Transaction: ${status} -> Global error occured`);
+    activeTransaction.setStatus(status);
+  }
+}
+
+// The function name will be lost when bundling but we need to be able to identify this listener later to maintain the
+// node.js default exit behaviour
+errorCallback.tag = 'sentry_tracingErrorCallback';
+
+export { registerErrorInstrumentation };
+//# sourceMappingURL=errors.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/tracing/hubextensions.js b/parent_dir/node_modules/sentry/core/esm/tracing/hubextensions.js
new file mode 100644
index 0000000..f96f922
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/tracing/hubextensions.js
@@ -0,0 +1,241 @@
+import { logger, isNaN } from '@sentry/utils';
+import { getMainCarrier } from '../hub.js';
+import { hasTracingEnabled } from '../utils/hasTracingEnabled.js';
+import { registerErrorInstrumentation } from './errors.js';
+import { IdleTransaction } from './idletransaction.js';
+import { Transaction } from './transaction.js';
+
+/** Returns all trace headers that are currently on the top scope. */
+function traceHeaders() {
+  const scope = this.getScope();
+  const span = scope.getSpan();
+
+  return span
+    ? {
+        'sentry-trace': span.toTraceparent(),
+      }
+    : {};
+}
+
+/**
+ * Makes a sampling decision for the given transaction and stores it on the transaction.
+ *
+ * Called every time a transaction is created. Only transactions which emerge with a `sampled` value of `true` will be
+ * sent to Sentry.
+ *
+ * @param transaction: The transaction needing a sampling decision
+ * @param options: The current client's options, so we can access `tracesSampleRate` and/or `tracesSampler`
+ * @param samplingContext: Default and user-provided data which may be used to help make the decision
+ *
+ * @returns The given transaction with its `sampled` value set
+ */
+function sample(
+  transaction,
+  options,
+  samplingContext,
+) {
+  // nothing to do if tracing is not enabled
+  if (!hasTracingEnabled(options)) {
+    transaction.sampled = false;
+    return transaction;
+  }
+
+  // if the user has forced a sampling decision by passing a `sampled` value in their transaction context, go with that
+  if (transaction.sampled !== undefined) {
+    transaction.setMetadata({
+      sampleRate: Number(transaction.sampled),
+    });
+    return transaction;
+  }
+
+  // we would have bailed already if neither `tracesSampler` nor `tracesSampleRate` nor `enableTracing` were defined, so one of these should
+  // work; prefer the hook if so
+  let sampleRate;
+  if (typeof options.tracesSampler === 'function') {
+    sampleRate = options.tracesSampler(samplingContext);
+    transaction.setMetadata({
+      sampleRate: Number(sampleRate),
+    });
+  } else if (samplingContext.parentSampled !== undefined) {
+    sampleRate = samplingContext.parentSampled;
+  } else if (typeof options.tracesSampleRate !== 'undefined') {
+    sampleRate = options.tracesSampleRate;
+    transaction.setMetadata({
+      sampleRate: Number(sampleRate),
+    });
+  } else {
+    // When `enableTracing === true`, we use a sample rate of 100%
+    sampleRate = 1;
+    transaction.setMetadata({
+      sampleRate,
+    });
+  }
+
+  // Since this is coming from the user (or from a function provided by the user), who knows what we might get. (The
+  // only valid values are booleans or numbers between 0 and 1.)
+  if (!isValidSampleRate(sampleRate)) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('[Tracing] Discarding transaction because of invalid sample rate.');
+    transaction.sampled = false;
+    return transaction;
+  }
+
+  // if the function returned 0 (or false), or if `tracesSampleRate` is 0, it's a sign the transaction should be dropped
+  if (!sampleRate) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.log(
+        `[Tracing] Discarding transaction because ${
+          typeof options.tracesSampler === 'function'
+            ? 'tracesSampler returned 0 or false'
+            : 'a negative sampling decision was inherited or tracesSampleRate is set to 0'
+        }`,
+      );
+    transaction.sampled = false;
+    return transaction;
+  }
+
+  // Now we roll the dice. Math.random is inclusive of 0, but not of 1, so strict < is safe here. In case sampleRate is
+  // a boolean, the < comparison will cause it to be automatically cast to 1 if it's true and 0 if it's false.
+  transaction.sampled = Math.random() < (sampleRate );
+
+  // if we're not going to keep it, we're done
+  if (!transaction.sampled) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.log(
+        `[Tracing] Discarding transaction because it's not included in the random sample (sampling rate = ${Number(
+          sampleRate,
+        )})`,
+      );
+    return transaction;
+  }
+
+  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] starting ${transaction.op} transaction - ${transaction.name}`);
+  return transaction;
+}
+
+/**
+ * Checks the given sample rate to make sure it is valid type and value (a boolean, or a number between 0 and 1).
+ */
+function isValidSampleRate(rate) {
+  // we need to check NaN explicitly because it's of type 'number' and therefore wouldn't get caught by this typecheck
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  if (isNaN(rate) || !(typeof rate === 'number' || typeof rate === 'boolean')) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.warn(
+        `[Tracing] Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(
+          rate,
+        )} of type ${JSON.stringify(typeof rate)}.`,
+      );
+    return false;
+  }
+
+  // in case sampleRate is a boolean, it will get automatically cast to 1 if it's true and 0 if it's false
+  if (rate < 0 || rate > 1) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.warn(`[Tracing] Given sample rate is invalid. Sample rate must be between 0 and 1. Got ${rate}.`);
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Creates a new transaction and adds a sampling decision if it doesn't yet have one.
+ *
+ * The Hub.startTransaction method delegates to this method to do its work, passing the Hub instance in as `this`, as if
+ * it had been called on the hub directly. Exists as a separate function so that it can be injected into the class as an
+ * "extension method."
+ *
+ * @param this: The Hub starting the transaction
+ * @param transactionContext: Data used to configure the transaction
+ * @param CustomSamplingContext: Optional data to be provided to the `tracesSampler` function (if any)
+ *
+ * @returns The new transaction
+ *
+ * @see {@link Hub.startTransaction}
+ */
+function _startTransaction(
+
+  transactionContext,
+  customSamplingContext,
+) {
+  const client = this.getClient();
+  const options = (client && client.getOptions()) || {};
+
+  const configInstrumenter = options.instrumenter || 'sentry';
+  const transactionInstrumenter = transactionContext.instrumenter || 'sentry';
+
+  if (configInstrumenter !== transactionInstrumenter) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.error(
+        `A transaction was started with instrumenter=\`${transactionInstrumenter}\`, but the SDK is configured with the \`${configInstrumenter}\` instrumenter.
+The transaction will not be sampled. Please use the ${configInstrumenter} instrumentation to start transactions.`,
+      );
+
+    transactionContext.sampled = false;
+  }
+
+  let transaction = new Transaction(transactionContext, this);
+  transaction = sample(transaction, options, {
+    parentSampled: transactionContext.parentSampled,
+    transactionContext,
+    ...customSamplingContext,
+  });
+  if (transaction.sampled) {
+    transaction.initSpanRecorder(options._experiments && (options._experiments.maxSpans ));
+  }
+  if (client && client.emit) {
+    client.emit('startTransaction', transaction);
+  }
+  return transaction;
+}
+
+/**
+ * Create new idle transaction.
+ */
+function startIdleTransaction(
+  hub,
+  transactionContext,
+  idleTimeout,
+  finalTimeout,
+  onScope,
+  customSamplingContext,
+  heartbeatInterval,
+) {
+  const client = hub.getClient();
+  const options = (client && client.getOptions()) || {};
+
+  let transaction = new IdleTransaction(transactionContext, hub, idleTimeout, finalTimeout, heartbeatInterval, onScope);
+  transaction = sample(transaction, options, {
+    parentSampled: transactionContext.parentSampled,
+    transactionContext,
+    ...customSamplingContext,
+  });
+  if (transaction.sampled) {
+    transaction.initSpanRecorder(options._experiments && (options._experiments.maxSpans ));
+  }
+  if (client && client.emit) {
+    client.emit('startTransaction', transaction);
+  }
+  return transaction;
+}
+
+/**
+ * Adds tracing extensions to the global hub.
+ */
+function addTracingExtensions() {
+  const carrier = getMainCarrier();
+  if (!carrier.__SENTRY__) {
+    return;
+  }
+  carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};
+  if (!carrier.__SENTRY__.extensions.startTransaction) {
+    carrier.__SENTRY__.extensions.startTransaction = _startTransaction;
+  }
+  if (!carrier.__SENTRY__.extensions.traceHeaders) {
+    carrier.__SENTRY__.extensions.traceHeaders = traceHeaders;
+  }
+
+  registerErrorInstrumentation();
+}
+
+export { addTracingExtensions, startIdleTransaction };
+//# sourceMappingURL=hubextensions.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/tracing/idletransaction.js b/parent_dir/node_modules/sentry/core/esm/tracing/idletransaction.js
new file mode 100644
index 0000000..aad79eb
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/tracing/idletransaction.js
@@ -0,0 +1,353 @@
+import { logger, timestampInSeconds } from '@sentry/utils';
+import { SpanRecorder } from './span.js';
+import { Transaction } from './transaction.js';
+
+const TRACING_DEFAULTS = {
+  idleTimeout: 1000,
+  finalTimeout: 30000,
+  heartbeatInterval: 5000,
+};
+
+const FINISH_REASON_TAG = 'finishReason';
+
+const IDLE_TRANSACTION_FINISH_REASONS = [
+  'heartbeatFailed',
+  'idleTimeout',
+  'documentHidden',
+  'finalTimeout',
+  'externalFinish',
+  'cancelled',
+];
+
+/**
+ * @inheritDoc
+ */
+class IdleTransactionSpanRecorder extends SpanRecorder {
+   constructor(
+      _pushActivity,
+      _popActivity,
+     transactionSpanId,
+    maxlen,
+  ) {
+    super(maxlen);this._pushActivity = _pushActivity;this._popActivity = _popActivity;this.transactionSpanId = transactionSpanId;  }
+
+  /**
+   * @inheritDoc
+   */
+   add(span) {
+    // We should make sure we do not push and pop activities for
+    // the transaction that this span recorder belongs to.
+    if (span.spanId !== this.transactionSpanId) {
+      // We patch span.finish() to pop an activity after setting an endTimestamp.
+      span.finish = (endTimestamp) => {
+        span.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampInSeconds();
+        this._popActivity(span.spanId);
+      };
+
+      // We should only push new activities if the span does not have an end timestamp.
+      if (span.endTimestamp === undefined) {
+        this._pushActivity(span.spanId);
+      }
+    }
+
+    super.add(span);
+  }
+}
+
+/**
+ * An IdleTransaction is a transaction that automatically finishes. It does this by tracking child spans as activities.
+ * You can have multiple IdleTransactions active, but if the `onScope` option is specified, the idle transaction will
+ * put itself on the scope on creation.
+ */
+class IdleTransaction extends Transaction {
+  // Activities store a list of active spans
+
+  // Track state of activities in previous heartbeat
+
+  // Amount of times heartbeat has counted. Will cause transaction to finish after 3 beats.
+
+  // We should not use heartbeat if we finished a transaction
+
+  // Idle timeout was canceled and we should finish the transaction with the last span end.
+
+  /**
+   * Timer that tracks Transaction idleTimeout
+   */
+
+   constructor(
+    transactionContext,
+      _idleHub,
+    /**
+     * The time to wait in ms until the idle transaction will be finished. This timer is started each time
+     * there are no active spans on this transaction.
+     */
+      _idleTimeout = TRACING_DEFAULTS.idleTimeout,
+    /**
+     * The final value in ms that a transaction cannot exceed
+     */
+      _finalTimeout = TRACING_DEFAULTS.finalTimeout,
+      _heartbeatInterval = TRACING_DEFAULTS.heartbeatInterval,
+    // Whether or not the transaction should put itself on the scope when it starts and pop itself off when it ends
+      _onScope = false,
+  ) {
+    super(transactionContext, _idleHub);this._idleHub = _idleHub;this._idleTimeout = _idleTimeout;this._finalTimeout = _finalTimeout;this._heartbeatInterval = _heartbeatInterval;this._onScope = _onScope;
+    this.activities = {};
+    this._heartbeatCounter = 0;
+    this._finished = false;
+    this._idleTimeoutCanceledPermanently = false;
+    this._beforeFinishCallbacks = [];
+    this._finishReason = IDLE_TRANSACTION_FINISH_REASONS[4];
+
+    if (_onScope) {
+      // We set the transaction here on the scope so error events pick up the trace
+      // context and attach it to the error.
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Setting idle transaction on scope. Span ID: ${this.spanId}`);
+      _idleHub.configureScope(scope => scope.setSpan(this));
+    }
+
+    this._restartIdleTimeout();
+    setTimeout(() => {
+      if (!this._finished) {
+        this.setStatus('deadline_exceeded');
+        this._finishReason = IDLE_TRANSACTION_FINISH_REASONS[3];
+        this.finish();
+      }
+    }, this._finalTimeout);
+  }
+
+  /** {@inheritDoc} */
+   finish(endTimestamp = timestampInSeconds()) {
+    this._finished = true;
+    this.activities = {};
+
+    if (this.op === 'ui.action.click') {
+      this.setTag(FINISH_REASON_TAG, this._finishReason);
+    }
+
+    if (this.spanRecorder) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        logger.log('[Tracing] finishing IdleTransaction', new Date(endTimestamp * 1000).toISOString(), this.op);
+
+      for (const callback of this._beforeFinishCallbacks) {
+        callback(this, endTimestamp);
+      }
+
+      this.spanRecorder.spans = this.spanRecorder.spans.filter((span) => {
+        // If we are dealing with the transaction itself, we just return it
+        if (span.spanId === this.spanId) {
+          return true;
+        }
+
+        // We cancel all pending spans with status "cancelled" to indicate the idle transaction was finished early
+        if (!span.endTimestamp) {
+          span.endTimestamp = endTimestamp;
+          span.setStatus('cancelled');
+          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+            logger.log('[Tracing] cancelling span since transaction ended early', JSON.stringify(span, undefined, 2));
+        }
+
+        const spanStartedBeforeTransactionFinish = span.startTimestamp < endTimestamp;
+
+        // Add a delta with idle timeout so that we prevent false positives
+        const timeoutWithMarginOfError = (this._finalTimeout + this._idleTimeout) / 1000;
+        const spanEndedBeforeFinalTimeout = span.endTimestamp - this.startTimestamp < timeoutWithMarginOfError;
+
+        if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+          const stringifiedSpan = JSON.stringify(span, undefined, 2);
+          if (!spanStartedBeforeTransactionFinish) {
+            logger.log('[Tracing] discarding Span since it happened after Transaction was finished', stringifiedSpan);
+          } else if (!spanEndedBeforeFinalTimeout) {
+            logger.log('[Tracing] discarding Span since it finished after Transaction final timeout', stringifiedSpan);
+          }
+        }
+
+        return spanStartedBeforeTransactionFinish && spanEndedBeforeFinalTimeout;
+      });
+
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] flushing IdleTransaction');
+    } else {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] No active IdleTransaction');
+    }
+
+    // if `this._onScope` is `true`, the transaction put itself on the scope when it started
+    if (this._onScope) {
+      const scope = this._idleHub.getScope();
+      if (scope.getTransaction() === this) {
+        scope.setSpan(undefined);
+      }
+    }
+
+    return super.finish(endTimestamp);
+  }
+
+  /**
+   * Register a callback function that gets excecuted before the transaction finishes.
+   * Useful for cleanup or if you want to add any additional spans based on current context.
+   *
+   * This is exposed because users have no other way of running something before an idle transaction
+   * finishes.
+   */
+   registerBeforeFinishCallback(callback) {
+    this._beforeFinishCallbacks.push(callback);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   initSpanRecorder(maxlen) {
+    if (!this.spanRecorder) {
+      const pushActivity = (id) => {
+        if (this._finished) {
+          return;
+        }
+        this._pushActivity(id);
+      };
+      const popActivity = (id) => {
+        if (this._finished) {
+          return;
+        }
+        this._popActivity(id);
+      };
+
+      this.spanRecorder = new IdleTransactionSpanRecorder(pushActivity, popActivity, this.spanId, maxlen);
+
+      // Start heartbeat so that transactions do not run forever.
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('Starting heartbeat');
+      this._pingHeartbeat();
+    }
+    this.spanRecorder.add(this);
+  }
+
+  /**
+   * Cancels the existing idle timeout, if there is one.
+   * @param restartOnChildSpanChange Default is `true`.
+   *                                 If set to false the transaction will end
+   *                                 with the last child span.
+   */
+   cancelIdleTimeout(
+    endTimestamp,
+    {
+      restartOnChildSpanChange,
+    }
+
+ = {
+      restartOnChildSpanChange: true,
+    },
+  ) {
+    this._idleTimeoutCanceledPermanently = restartOnChildSpanChange === false;
+    if (this._idleTimeoutID) {
+      clearTimeout(this._idleTimeoutID);
+      this._idleTimeoutID = undefined;
+
+      if (Object.keys(this.activities).length === 0 && this._idleTimeoutCanceledPermanently) {
+        this._finishReason = IDLE_TRANSACTION_FINISH_REASONS[5];
+        this.finish(endTimestamp);
+      }
+    }
+  }
+
+  /**
+   * Temporary method used to externally set the transaction's `finishReason`
+   *
+   * ** WARNING**
+   * This is for the purpose of experimentation only and will be removed in the near future, do not use!
+   *
+   * @internal
+   *
+   */
+   setFinishReason(reason) {
+    this._finishReason = reason;
+  }
+
+  /**
+   * Restarts idle timeout, if there is no running idle timeout it will start one.
+   */
+   _restartIdleTimeout(endTimestamp) {
+    this.cancelIdleTimeout();
+    this._idleTimeoutID = setTimeout(() => {
+      if (!this._finished && Object.keys(this.activities).length === 0) {
+        this._finishReason = IDLE_TRANSACTION_FINISH_REASONS[1];
+        this.finish(endTimestamp);
+      }
+    }, this._idleTimeout);
+  }
+
+  /**
+   * Start tracking a specific activity.
+   * @param spanId The span id that represents the activity
+   */
+   _pushActivity(spanId) {
+    this.cancelIdleTimeout(undefined, { restartOnChildSpanChange: !this._idleTimeoutCanceledPermanently });
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] pushActivity: ${spanId}`);
+    this.activities[spanId] = true;
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);
+  }
+
+  /**
+   * Remove an activity from usage
+   * @param spanId The span id that represents the activity
+   */
+   _popActivity(spanId) {
+    if (this.activities[spanId]) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] popActivity ${spanId}`);
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete this.activities[spanId];
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);
+    }
+
+    if (Object.keys(this.activities).length === 0) {
+      const endTimestamp = timestampInSeconds();
+      if (this._idleTimeoutCanceledPermanently) {
+        this._finishReason = IDLE_TRANSACTION_FINISH_REASONS[5];
+        this.finish(endTimestamp);
+      } else {
+        // We need to add the timeout here to have the real endtimestamp of the transaction
+        // Remember timestampInSeconds is in seconds, timeout is in ms
+        this._restartIdleTimeout(endTimestamp + this._idleTimeout / 1000);
+      }
+    }
+  }
+
+  /**
+   * Checks when entries of this.activities are not changing for 3 beats.
+   * If this occurs we finish the transaction.
+   */
+   _beat() {
+    // We should not be running heartbeat if the idle transaction is finished.
+    if (this._finished) {
+      return;
+    }
+
+    const heartbeatString = Object.keys(this.activities).join('');
+
+    if (heartbeatString === this._prevHeartbeatString) {
+      this._heartbeatCounter++;
+    } else {
+      this._heartbeatCounter = 1;
+    }
+
+    this._prevHeartbeatString = heartbeatString;
+
+    if (this._heartbeatCounter >= 3) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] Transaction finished because of no change for 3 heart beats');
+      this.setStatus('deadline_exceeded');
+      this._finishReason = IDLE_TRANSACTION_FINISH_REASONS[0];
+      this.finish();
+    } else {
+      this._pingHeartbeat();
+    }
+  }
+
+  /**
+   * Pings the heartbeat
+   */
+   _pingHeartbeat() {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`pinging Heartbeat -> current counter: ${this._heartbeatCounter}`);
+    setTimeout(() => {
+      this._beat();
+    }, this._heartbeatInterval);
+  }
+}
+
+export { IdleTransaction, IdleTransactionSpanRecorder, TRACING_DEFAULTS };
+//# sourceMappingURL=idletransaction.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/tracing/measurement.js b/parent_dir/node_modules/sentry/core/esm/tracing/measurement.js
new file mode 100644
index 0000000..7be8ad5
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/tracing/measurement.js
@@ -0,0 +1,14 @@
+import { getActiveTransaction } from './utils.js';
+
+/**
+ * Adds a measurement to the current active transaction.
+ */
+function setMeasurement(name, value, unit) {
+  const transaction = getActiveTransaction();
+  if (transaction) {
+    transaction.setMeasurement(name, value, unit);
+  }
+}
+
+export { setMeasurement };
+//# sourceMappingURL=measurement.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/tracing/span.js b/parent_dir/node_modules/sentry/core/esm/tracing/span.js
new file mode 100644
index 0000000..c78e5bb
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/tracing/span.js
@@ -0,0 +1,379 @@
+import { uuid4, timestampInSeconds, logger, generateSentryTraceHeader, dropUndefinedKeys } from '@sentry/utils';
+
+/**
+ * Keeps track of finished spans for a given transaction
+ * @internal
+ * @hideconstructor
+ * @hidden
+ */
+class SpanRecorder {
+
+   constructor(maxlen = 1000) {
+    this._maxlen = maxlen;
+    this.spans = [];
+  }
+
+  /**
+   * This is just so that we don't run out of memory while recording a lot
+   * of spans. At some point we just stop and flush out the start of the
+   * trace tree (i.e.the first n spans with the smallest
+   * start_timestamp).
+   */
+   add(span) {
+    if (this.spans.length > this._maxlen) {
+      span.spanRecorder = undefined;
+    } else {
+      this.spans.push(span);
+    }
+  }
+}
+
+/**
+ * Span contains all data about a span
+ */
+class Span  {
+  /**
+   * @inheritDoc
+   */
+
+  /**
+   * @inheritDoc
+   */
+
+  /**
+   * @inheritDoc
+   */
+
+  /**
+   * Internal keeper of the status
+   */
+
+  /**
+   * @inheritDoc
+   */
+
+  /**
+   * Timestamp in seconds when the span was created.
+   */
+
+  /**
+   * Timestamp in seconds when the span ended.
+   */
+
+  /**
+   * @inheritDoc
+   */
+
+  /**
+   * @inheritDoc
+   */
+
+  /**
+   * @inheritDoc
+   */
+
+  /**
+   * @inheritDoc
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+  /**
+   * List of spans that were finalized
+   */
+
+  /**
+   * @inheritDoc
+   */
+
+  /**
+   * The instrumenter that created this span.
+   */
+
+  /**
+   * The origin of the span, giving context about what created the span.
+   */
+
+  /**
+   * You should never call the constructor manually, always use `Sentry.startTransaction()`
+   * or call `startChild()` on an existing span.
+   * @internal
+   * @hideconstructor
+   * @hidden
+   */
+   constructor(spanContext = {}) {
+    this.traceId = spanContext.traceId || uuid4();
+    this.spanId = spanContext.spanId || uuid4().substring(16);
+    this.startTimestamp = spanContext.startTimestamp || timestampInSeconds();
+    this.tags = spanContext.tags || {};
+    this.data = spanContext.data || {};
+    this.instrumenter = spanContext.instrumenter || 'sentry';
+    this.origin = spanContext.origin || 'manual';
+
+    if (spanContext.parentSpanId) {
+      this.parentSpanId = spanContext.parentSpanId;
+    }
+    // We want to include booleans as well here
+    if ('sampled' in spanContext) {
+      this.sampled = spanContext.sampled;
+    }
+    if (spanContext.op) {
+      this.op = spanContext.op;
+    }
+    if (spanContext.description) {
+      this.description = spanContext.description;
+    }
+    if (spanContext.name) {
+      this.description = spanContext.name;
+    }
+    if (spanContext.status) {
+      this.status = spanContext.status;
+    }
+    if (spanContext.endTimestamp) {
+      this.endTimestamp = spanContext.endTimestamp;
+    }
+  }
+
+  /** An alias for `description` of the Span. */
+   get name() {
+    return this.description || '';
+  }
+  /** Update the name of the span. */
+   set name(name) {
+    this.setName(name);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   startChild(
+    spanContext,
+  ) {
+    const childSpan = new Span({
+      ...spanContext,
+      parentSpanId: this.spanId,
+      sampled: this.sampled,
+      traceId: this.traceId,
+    });
+
+    childSpan.spanRecorder = this.spanRecorder;
+    if (childSpan.spanRecorder) {
+      childSpan.spanRecorder.add(childSpan);
+    }
+
+    childSpan.transaction = this.transaction;
+
+    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && childSpan.transaction) {
+      const opStr = (spanContext && spanContext.op) || '< unknown op >';
+      const nameStr = childSpan.transaction.name || '< unknown name >';
+      const idStr = childSpan.transaction.spanId;
+
+      const logMessage = `[Tracing] Starting '${opStr}' span on transaction '${nameStr}' (${idStr}).`;
+      childSpan.transaction.metadata.spanMetadata[childSpan.spanId] = { logMessage };
+      logger.log(logMessage);
+    }
+
+    return childSpan;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setTag(key, value) {
+    this.tags = { ...this.tags, [key]: value };
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+   setData(key, value) {
+    this.data = { ...this.data, [key]: value };
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setStatus(value) {
+    this.status = value;
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setHttpStatus(httpStatus) {
+    this.setTag('http.status_code', String(httpStatus));
+    this.setData('http.response.status_code', httpStatus);
+    const spanStatus = spanStatusfromHttpCode(httpStatus);
+    if (spanStatus !== 'unknown_error') {
+      this.setStatus(spanStatus);
+    }
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setName(name) {
+    this.description = name;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   isSuccess() {
+    return this.status === 'ok';
+  }
+
+  /**
+   * @inheritDoc
+   */
+   finish(endTimestamp) {
+    if (
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      // Don't call this for transactions
+      this.transaction &&
+      this.transaction.spanId !== this.spanId
+    ) {
+      const { logMessage } = this.transaction.metadata.spanMetadata[this.spanId];
+      if (logMessage) {
+        logger.log((logMessage ).replace('Starting', 'Finishing'));
+      }
+    }
+
+    this.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampInSeconds();
+  }
+
+  /**
+   * @inheritDoc
+   */
+   toTraceparent() {
+    return generateSentryTraceHeader(this.traceId, this.spanId, this.sampled);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   toContext() {
+    return dropUndefinedKeys({
+      data: this.data,
+      description: this.description,
+      endTimestamp: this.endTimestamp,
+      op: this.op,
+      parentSpanId: this.parentSpanId,
+      sampled: this.sampled,
+      spanId: this.spanId,
+      startTimestamp: this.startTimestamp,
+      status: this.status,
+      tags: this.tags,
+      traceId: this.traceId,
+    });
+  }
+
+  /**
+   * @inheritDoc
+   */
+   updateWithContext(spanContext) {
+    this.data = spanContext.data || {};
+    this.description = spanContext.description;
+    this.endTimestamp = spanContext.endTimestamp;
+    this.op = spanContext.op;
+    this.parentSpanId = spanContext.parentSpanId;
+    this.sampled = spanContext.sampled;
+    this.spanId = spanContext.spanId || this.spanId;
+    this.startTimestamp = spanContext.startTimestamp || this.startTimestamp;
+    this.status = spanContext.status;
+    this.tags = spanContext.tags || {};
+    this.traceId = spanContext.traceId || this.traceId;
+
+    return this;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   getTraceContext() {
+    return dropUndefinedKeys({
+      data: Object.keys(this.data).length > 0 ? this.data : undefined,
+      description: this.description,
+      op: this.op,
+      parent_span_id: this.parentSpanId,
+      span_id: this.spanId,
+      status: this.status,
+      tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,
+      trace_id: this.traceId,
+    });
+  }
+
+  /**
+   * @inheritDoc
+   */
+   toJSON()
+
+ {
+    return dropUndefinedKeys({
+      data: Object.keys(this.data).length > 0 ? this.data : undefined,
+      description: this.description,
+      op: this.op,
+      parent_span_id: this.parentSpanId,
+      span_id: this.spanId,
+      start_timestamp: this.startTimestamp,
+      status: this.status,
+      tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,
+      timestamp: this.endTimestamp,
+      trace_id: this.traceId,
+      origin: this.origin,
+    });
+  }
+}
+
+/**
+ * Converts a HTTP status code into a {@link SpanStatusType}.
+ *
+ * @param httpStatus The HTTP response status code.
+ * @returns The span status or unknown_error.
+ */
+function spanStatusfromHttpCode(httpStatus) {
+  if (httpStatus < 400 && httpStatus >= 100) {
+    return 'ok';
+  }
+
+  if (httpStatus >= 400 && httpStatus < 500) {
+    switch (httpStatus) {
+      case 401:
+        return 'unauthenticated';
+      case 403:
+        return 'permission_denied';
+      case 404:
+        return 'not_found';
+      case 409:
+        return 'already_exists';
+      case 413:
+        return 'failed_precondition';
+      case 429:
+        return 'resource_exhausted';
+      default:
+        return 'invalid_argument';
+    }
+  }
+
+  if (httpStatus >= 500 && httpStatus < 600) {
+    switch (httpStatus) {
+      case 501:
+        return 'unimplemented';
+      case 503:
+        return 'unavailable';
+      case 504:
+        return 'deadline_exceeded';
+      default:
+        return 'internal_error';
+    }
+  }
+
+  return 'unknown_error';
+}
+
+export { Span, SpanRecorder, spanStatusfromHttpCode };
+//# sourceMappingURL=span.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/tracing/trace.js b/parent_dir/node_modules/sentry/core/esm/tracing/trace.js
new file mode 100644
index 0000000..dfdb6b6
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/tracing/trace.js
@@ -0,0 +1,224 @@
+import { isThenable } from '@sentry/utils';
+import { getCurrentHub } from '../hub.js';
+import { hasTracingEnabled } from '../utils/hasTracingEnabled.js';
+
+/**
+ * Wraps a function with a transaction/span and finishes the span after the function is done.
+ *
+ * Note that if you have not enabled tracing extensions via `addTracingExtensions`
+ * or you didn't set `tracesSampleRate`, this function will not generate spans
+ * and the `span` returned from the callback will be undefined.
+ *
+ * This function is meant to be used internally and may break at any time. Use at your own risk.
+ *
+ * @internal
+ * @private
+ */
+function trace(
+  context,
+  callback,
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  onError = () => {},
+) {
+  const ctx = normalizeContext(context);
+
+  const hub = getCurrentHub();
+  const scope = hub.getScope();
+  const parentSpan = scope.getSpan();
+
+  const activeSpan = createChildSpanOrTransaction(hub, parentSpan, ctx);
+
+  scope.setSpan(activeSpan);
+
+  function finishAndSetSpan() {
+    activeSpan && activeSpan.finish();
+    hub.getScope().setSpan(parentSpan);
+  }
+
+  let maybePromiseResult;
+  try {
+    maybePromiseResult = callback(activeSpan);
+  } catch (e) {
+    activeSpan && activeSpan.setStatus('internal_error');
+    onError(e);
+    finishAndSetSpan();
+    throw e;
+  }
+
+  if (isThenable(maybePromiseResult)) {
+    Promise.resolve(maybePromiseResult).then(
+      () => {
+        finishAndSetSpan();
+      },
+      e => {
+        activeSpan && activeSpan.setStatus('internal_error');
+        onError(e);
+        finishAndSetSpan();
+      },
+    );
+  } else {
+    finishAndSetSpan();
+  }
+
+  return maybePromiseResult;
+}
+
+/**
+ * Wraps a function with a transaction/span and finishes the span after the function is done.
+ * The created span is the active span and will be used as parent by other spans created inside the function
+ * and can be accessed via `Sentry.getSpan()`, as long as the function is executed while the scope is active.
+ *
+ * If you want to create a span that is not set as active, use {@link startInactiveSpan}.
+ *
+ * Note that if you have not enabled tracing extensions via `addTracingExtensions`
+ * or you didn't set `tracesSampleRate`, this function will not generate spans
+ * and the `span` returned from the callback will be undefined.
+ */
+function startSpan(context, callback) {
+  const ctx = normalizeContext(context);
+
+  const hub = getCurrentHub();
+  const scope = hub.getScope();
+  const parentSpan = scope.getSpan();
+
+  const activeSpan = createChildSpanOrTransaction(hub, parentSpan, ctx);
+  scope.setSpan(activeSpan);
+
+  function finishAndSetSpan() {
+    activeSpan && activeSpan.finish();
+    hub.getScope().setSpan(parentSpan);
+  }
+
+  let maybePromiseResult;
+  try {
+    maybePromiseResult = callback(activeSpan);
+  } catch (e) {
+    activeSpan && activeSpan.setStatus('internal_error');
+    finishAndSetSpan();
+    throw e;
+  }
+
+  if (isThenable(maybePromiseResult)) {
+    Promise.resolve(maybePromiseResult).then(
+      () => {
+        finishAndSetSpan();
+      },
+      () => {
+        activeSpan && activeSpan.setStatus('internal_error');
+        finishAndSetSpan();
+      },
+    );
+  } else {
+    finishAndSetSpan();
+  }
+
+  return maybePromiseResult;
+}
+
+/**
+ * @deprecated Use {@link startSpan} instead.
+ */
+const startActiveSpan = startSpan;
+
+/**
+ * Similar to `Sentry.startSpan`. Wraps a function with a transaction/span, but does not finish the span
+ * after the function is done automatically.
+ *
+ * The created span is the active span and will be used as parent by other spans created inside the function
+ * and can be accessed via `Sentry.getActiveSpan()`, as long as the function is executed while the scope is active.
+ *
+ * Note that if you have not enabled tracing extensions via `addTracingExtensions`
+ * or you didn't set `tracesSampleRate`, this function will not generate spans
+ * and the `span` returned from the callback will be undefined.
+ */
+function startSpanManual(
+  context,
+  callback,
+) {
+  const ctx = normalizeContext(context);
+
+  const hub = getCurrentHub();
+  const scope = hub.getScope();
+  const parentSpan = scope.getSpan();
+
+  const activeSpan = createChildSpanOrTransaction(hub, parentSpan, ctx);
+  scope.setSpan(activeSpan);
+
+  function finishAndSetSpan() {
+    activeSpan && activeSpan.finish();
+    hub.getScope().setSpan(parentSpan);
+  }
+
+  let maybePromiseResult;
+  try {
+    maybePromiseResult = callback(activeSpan, finishAndSetSpan);
+  } catch (e) {
+    activeSpan && activeSpan.setStatus('internal_error');
+    throw e;
+  }
+
+  if (isThenable(maybePromiseResult)) {
+    Promise.resolve(maybePromiseResult).then(undefined, () => {
+      activeSpan && activeSpan.setStatus('internal_error');
+    });
+  }
+
+  return maybePromiseResult;
+}
+
+/**
+ * Creates a span. This span is not set as active, so will not get automatic instrumentation spans
+ * as children or be able to be accessed via `Sentry.getSpan()`.
+ *
+ * If you want to create a span that is set as active, use {@link startSpan}.
+ *
+ * Note that if you have not enabled tracing extensions via `addTracingExtensions`
+ * or you didn't set `tracesSampleRate` or `tracesSampler`, this function will not generate spans
+ * and the `span` returned from the callback will be undefined.
+ */
+function startInactiveSpan(context) {
+  if (!hasTracingEnabled()) {
+    return undefined;
+  }
+
+  const ctx = { ...context };
+  // If a name is set and a description is not, set the description to the name.
+  if (ctx.name !== undefined && ctx.description === undefined) {
+    ctx.description = ctx.name;
+  }
+
+  const hub = getCurrentHub();
+  const parentSpan = getActiveSpan();
+  return parentSpan ? parentSpan.startChild(ctx) : hub.startTransaction(ctx);
+}
+
+/**
+ * Returns the currently active span.
+ */
+function getActiveSpan() {
+  return getCurrentHub().getScope().getSpan();
+}
+
+function createChildSpanOrTransaction(
+  hub,
+  parentSpan,
+  ctx,
+) {
+  if (!hasTracingEnabled()) {
+    return undefined;
+  }
+  return parentSpan ? parentSpan.startChild(ctx) : hub.startTransaction(ctx);
+}
+
+function normalizeContext(context) {
+  const ctx = { ...context };
+  // If a name is set and a description is not, set the description to the name.
+  if (ctx.name !== undefined && ctx.description === undefined) {
+    ctx.description = ctx.name;
+  }
+
+  return ctx;
+}
+
+export { getActiveSpan, startActiveSpan, startInactiveSpan, startSpan, startSpanManual, trace };
+//# sourceMappingURL=trace.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/tracing/transaction.js b/parent_dir/node_modules/sentry/core/esm/tracing/transaction.js
new file mode 100644
index 0000000..b9c66ea
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/tracing/transaction.js
@@ -0,0 +1,270 @@
+import { logger, dropUndefinedKeys } from '@sentry/utils';
+import { getCurrentHub } from '../hub.js';
+import { getDynamicSamplingContextFromClient } from './dynamicSamplingContext.js';
+import { Span, SpanRecorder } from './span.js';
+
+/** JSDoc */
+class Transaction extends Span  {
+
+  /**
+   * The reference to the current hub.
+   */
+
+  /**
+   * This constructor should never be called manually. Those instrumenting tracing should use
+   * `Sentry.startTransaction()`, and internal methods should use `hub.startTransaction()`.
+   * @internal
+   * @hideconstructor
+   * @hidden
+   */
+   constructor(transactionContext, hub) {
+    super(transactionContext);
+    // We need to delete description since it's set by the Span class constructor
+    // but not needed for transactions.
+    delete this.description;
+
+    this._measurements = {};
+    this._contexts = {};
+
+    this._hub = hub || getCurrentHub();
+
+    this._name = transactionContext.name || '';
+
+    this.metadata = {
+      source: 'custom',
+      ...transactionContext.metadata,
+      spanMetadata: {},
+    };
+
+    this._trimEnd = transactionContext.trimEnd;
+
+    // this is because transactions are also spans, and spans have a transaction pointer
+    this.transaction = this;
+
+    // If Dynamic Sampling Context is provided during the creation of the transaction, we freeze it as it usually means
+    // there is incoming Dynamic Sampling Context. (Either through an incoming request, a baggage meta-tag, or other means)
+    const incomingDynamicSamplingContext = this.metadata.dynamicSamplingContext;
+    if (incomingDynamicSamplingContext) {
+      // We shallow copy this in case anything writes to the original reference of the passed in `dynamicSamplingContext`
+      this._frozenDynamicSamplingContext = { ...incomingDynamicSamplingContext };
+    }
+  }
+
+  /** Getter for `name` property */
+   get name() {
+    return this._name;
+  }
+
+  /** Setter for `name` property, which also sets `source` as custom */
+   set name(newName) {
+    this.setName(newName);
+  }
+
+  /**
+   * JSDoc
+   */
+   setName(name, source = 'custom') {
+    this._name = name;
+    this.metadata.source = source;
+  }
+
+  /**
+   * Attaches SpanRecorder to the span itself
+   * @param maxlen maximum number of spans that can be recorded
+   */
+   initSpanRecorder(maxlen = 1000) {
+    if (!this.spanRecorder) {
+      this.spanRecorder = new SpanRecorder(maxlen);
+    }
+    this.spanRecorder.add(this);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setContext(key, context) {
+    if (context === null) {
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete this._contexts[key];
+    } else {
+      this._contexts[key] = context;
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setMeasurement(name, value, unit = '') {
+    this._measurements[name] = { value, unit };
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setMetadata(newMetadata) {
+    this.metadata = { ...this.metadata, ...newMetadata };
+  }
+
+  /**
+   * @inheritDoc
+   */
+   finish(endTimestamp) {
+    // This transaction is already finished, so we should not flush it again.
+    if (this.endTimestamp !== undefined) {
+      return undefined;
+    }
+
+    if (!this.name) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Transaction has no name, falling back to `<unlabeled transaction>`.');
+      this.name = '<unlabeled transaction>';
+    }
+
+    // just sets the end timestamp
+    super.finish(endTimestamp);
+
+    const client = this._hub.getClient();
+    if (client && client.emit) {
+      client.emit('finishTransaction', this);
+    }
+
+    if (this.sampled !== true) {
+      // At this point if `sampled !== true` we want to discard the transaction.
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] Discarding transaction because its trace was not chosen to be sampled.');
+
+      if (client) {
+        client.recordDroppedEvent('sample_rate', 'transaction');
+      }
+
+      return undefined;
+    }
+
+    const finishedSpans = this.spanRecorder ? this.spanRecorder.spans.filter(s => s !== this && s.endTimestamp) : [];
+
+    if (this._trimEnd && finishedSpans.length > 0) {
+      this.endTimestamp = finishedSpans.reduce((prev, current) => {
+        if (prev.endTimestamp && current.endTimestamp) {
+          return prev.endTimestamp > current.endTimestamp ? prev : current;
+        }
+        return prev;
+      }).endTimestamp;
+    }
+
+    const metadata = this.metadata;
+
+    const transaction = {
+      contexts: {
+        ...this._contexts,
+        // We don't want to override trace context
+        trace: this.getTraceContext(),
+      },
+      spans: finishedSpans,
+      start_timestamp: this.startTimestamp,
+      tags: this.tags,
+      timestamp: this.endTimestamp,
+      transaction: this.name,
+      type: 'transaction',
+      sdkProcessingMetadata: {
+        ...metadata,
+        dynamicSamplingContext: this.getDynamicSamplingContext(),
+      },
+      ...(metadata.source && {
+        transaction_info: {
+          source: metadata.source,
+        },
+      }),
+    };
+
+    const hasMeasurements = Object.keys(this._measurements).length > 0;
+
+    if (hasMeasurements) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        logger.log(
+          '[Measurements] Adding measurements to transaction',
+          JSON.stringify(this._measurements, undefined, 2),
+        );
+      transaction.measurements = this._measurements;
+    }
+
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Finishing ${this.op} transaction: ${this.name}.`);
+
+    return this._hub.captureEvent(transaction);
+  }
+
+  /**
+   * @inheritDoc
+   */
+   toContext() {
+    const spanContext = super.toContext();
+
+    return dropUndefinedKeys({
+      ...spanContext,
+      name: this.name,
+      trimEnd: this._trimEnd,
+    });
+  }
+
+  /**
+   * @inheritDoc
+   */
+   updateWithContext(transactionContext) {
+    super.updateWithContext(transactionContext);
+
+    this.name = transactionContext.name || '';
+
+    this._trimEnd = transactionContext.trimEnd;
+
+    return this;
+  }
+
+  /**
+   * @inheritdoc
+   *
+   * @experimental
+   */
+   getDynamicSamplingContext() {
+    if (this._frozenDynamicSamplingContext) {
+      return this._frozenDynamicSamplingContext;
+    }
+
+    const hub = this._hub || getCurrentHub();
+    const client = hub.getClient();
+
+    if (!client) return {};
+
+    const scope = hub.getScope();
+    const dsc = getDynamicSamplingContextFromClient(this.traceId, client, scope);
+
+    const maybeSampleRate = this.metadata.sampleRate;
+    if (maybeSampleRate !== undefined) {
+      dsc.sample_rate = `${maybeSampleRate}`;
+    }
+
+    // We don't want to have a transaction name in the DSC if the source is "url" because URLs might contain PII
+    const source = this.metadata.source;
+    if (source && source !== 'url') {
+      dsc.transaction = this.name;
+    }
+
+    if (this.sampled !== undefined) {
+      dsc.sampled = String(this.sampled);
+    }
+
+    // Uncomment if we want to make DSC immutable
+    // this._frozenDynamicSamplingContext = dsc;
+
+    return dsc;
+  }
+
+  /**
+   * Override the current hub with a new one.
+   * Used if you want another hub to finish the transaction.
+   *
+   * @internal
+   */
+   setHub(hub) {
+    this._hub = hub;
+  }
+}
+
+export { Transaction };
+//# sourceMappingURL=transaction.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/tracing/utils.js b/parent_dir/node_modules/sentry/core/esm/tracing/utils.js
new file mode 100644
index 0000000..e3e7818
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/tracing/utils.js
@@ -0,0 +1,12 @@
+import { getCurrentHub } from '../hub.js';
+export { TRACEPARENT_REGEXP, extractTraceparentData, stripUrlQueryAndFragment } from '@sentry/utils';
+
+/** Grabs active transaction off scope, if any */
+function getActiveTransaction(maybeHub) {
+  const hub = maybeHub || getCurrentHub();
+  const scope = hub.getScope();
+  return scope.getTransaction() ;
+}
+
+export { getActiveTransaction };
+//# sourceMappingURL=utils.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/transports/base.js b/parent_dir/node_modules/sentry/core/esm/transports/base.js
new file mode 100644
index 0000000..07adadd
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/transports/base.js
@@ -0,0 +1,101 @@
+import { makePromiseBuffer, forEachEnvelopeItem, envelopeItemTypeToDataCategory, isRateLimited, resolvedSyncPromise, createEnvelope, SentryError, logger, serializeEnvelope, updateRateLimits } from '@sentry/utils';
+
+const DEFAULT_TRANSPORT_BUFFER_SIZE = 30;
+
+/**
+ * Creates an instance of a Sentry `Transport`
+ *
+ * @param options
+ * @param makeRequest
+ */
+function createTransport(
+  options,
+  makeRequest,
+  buffer = makePromiseBuffer(
+    options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE,
+  ),
+) {
+  let rateLimits = {};
+  const flush = (timeout) => buffer.drain(timeout);
+
+  function send(envelope) {
+    const filteredEnvelopeItems = [];
+
+    // Drop rate limited items from envelope
+    forEachEnvelopeItem(envelope, (item, type) => {
+      const envelopeItemDataCategory = envelopeItemTypeToDataCategory(type);
+      if (isRateLimited(rateLimits, envelopeItemDataCategory)) {
+        const event = getEventForEnvelopeItem(item, type);
+        options.recordDroppedEvent('ratelimit_backoff', envelopeItemDataCategory, event);
+      } else {
+        filteredEnvelopeItems.push(item);
+      }
+    });
+
+    // Skip sending if envelope is empty after filtering out rate limited events
+    if (filteredEnvelopeItems.length === 0) {
+      return resolvedSyncPromise();
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const filteredEnvelope = createEnvelope(envelope[0], filteredEnvelopeItems );
+
+    // Creates client report for each item in an envelope
+    const recordEnvelopeLoss = (reason) => {
+      forEachEnvelopeItem(filteredEnvelope, (item, type) => {
+        const event = getEventForEnvelopeItem(item, type);
+        options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type), event);
+      });
+    };
+
+    const requestTask = () =>
+      makeRequest({ body: serializeEnvelope(filteredEnvelope, options.textEncoder) }).then(
+        response => {
+          // We don't want to throw on NOK responses, but we want to at least log them
+          if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode >= 300)) {
+            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);
+          }
+
+          rateLimits = updateRateLimits(rateLimits, response);
+          return response;
+        },
+        error => {
+          recordEnvelopeLoss('network_error');
+          throw error;
+        },
+      );
+
+    return buffer.add(requestTask).then(
+      result => result,
+      error => {
+        if (error instanceof SentryError) {
+          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Skipped sending event because buffer is full.');
+          recordEnvelopeLoss('queue_overflow');
+          return resolvedSyncPromise();
+        } else {
+          throw error;
+        }
+      },
+    );
+  }
+
+  // We use this to identifify if the transport is the base transport
+  // TODO (v8): Remove this again as we'll no longer need it
+  send.__sentry__baseTransport__ = true;
+
+  return {
+    send,
+    flush,
+  };
+}
+
+function getEventForEnvelopeItem(item, type) {
+  if (type !== 'event' && type !== 'transaction') {
+    return undefined;
+  }
+
+  return Array.isArray(item) ? (item )[1] : undefined;
+}
+
+export { DEFAULT_TRANSPORT_BUFFER_SIZE, createTransport };
+//# sourceMappingURL=base.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/transports/multiplexed.js b/parent_dir/node_modules/sentry/core/esm/transports/multiplexed.js
new file mode 100644
index 0000000..60b87f6
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/transports/multiplexed.js
@@ -0,0 +1,118 @@
+import { dsnFromString, forEachEnvelopeItem } from '@sentry/utils';
+import { getEnvelopeEndpointWithUrlEncodedAuth } from '../api.js';
+
+/**
+ * Gets an event from an envelope.
+ *
+ * This is only exported for use in the tests
+ */
+function eventFromEnvelope(env, types) {
+  let event;
+
+  forEachEnvelopeItem(env, (item, type) => {
+    if (types.includes(type)) {
+      event = Array.isArray(item) ? (item )[1] : undefined;
+    }
+    // bail out if we found an event
+    return !!event;
+  });
+
+  return event;
+}
+
+/**
+ * Creates a transport that overrides the release on all events.
+ */
+function makeOverrideReleaseTransport(
+  createTransport,
+  release,
+) {
+  return options => {
+    const transport = createTransport(options);
+
+    return {
+      send: async (envelope) => {
+        const event = eventFromEnvelope(envelope, ['event', 'transaction', 'profile', 'replay_event']);
+
+        if (event) {
+          event.release = release;
+        }
+        return transport.send(envelope);
+      },
+      flush: timeout => transport.flush(timeout),
+    };
+  };
+}
+
+/**
+ * Creates a transport that can send events to different DSNs depending on the envelope contents.
+ */
+function makeMultiplexedTransport(
+  createTransport,
+  matcher,
+) {
+  return options => {
+    const fallbackTransport = createTransport(options);
+    const otherTransports = {};
+
+    function getTransport(dsn, release) {
+      // We create a transport for every unique dsn/release combination as there may be code from multiple releases in
+      // use at the same time
+      const key = release ? `${dsn}:${release}` : dsn;
+
+      if (!otherTransports[key]) {
+        const validatedDsn = dsnFromString(dsn);
+        if (!validatedDsn) {
+          return undefined;
+        }
+        const url = getEnvelopeEndpointWithUrlEncodedAuth(validatedDsn);
+
+        otherTransports[key] = release
+          ? makeOverrideReleaseTransport(createTransport, release)({ ...options, url })
+          : createTransport({ ...options, url });
+      }
+
+      return otherTransports[key];
+    }
+
+    async function send(envelope) {
+      function getEvent(types) {
+        const eventTypes = types && types.length ? types : ['event'];
+        return eventFromEnvelope(envelope, eventTypes);
+      }
+
+      const transports = matcher({ envelope, getEvent })
+        .map(result => {
+          if (typeof result === 'string') {
+            return getTransport(result, undefined);
+          } else {
+            return getTransport(result.dsn, result.release);
+          }
+        })
+        .filter((t) => !!t);
+
+      // If we have no transports to send to, use the fallback transport
+      if (transports.length === 0) {
+        transports.push(fallbackTransport);
+      }
+
+      const results = await Promise.all(transports.map(transport => transport.send(envelope)));
+
+      return results[0];
+    }
+
+    async function flush(timeout) {
+      const allTransports = [...Object.keys(otherTransports).map(dsn => otherTransports[dsn]), fallbackTransport];
+      const results = await Promise.all(allTransports.map(transport => transport.flush(timeout)));
+      return results.every(r => r);
+    }
+
+    return {
+      send,
+      flush,
+    };
+  };
+}
+
+export { eventFromEnvelope, makeMultiplexedTransport };
+//# sourceMappingURL=multiplexed.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/transports/offline.js b/parent_dir/node_modules/sentry/core/esm/transports/offline.js
new file mode 100644
index 0000000..c9de714
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/transports/offline.js
@@ -0,0 +1,122 @@
+import { parseRetryAfterHeader, logger, envelopeContainsItemType } from '@sentry/utils';
+
+const MIN_DELAY = 100; // 100 ms
+const START_DELAY = 5000; // 5 seconds
+const MAX_DELAY = 3.6e6; // 1 hour
+
+function log(msg, error) {
+  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.info(`[Offline]: ${msg}`, error);
+}
+
+/**
+ * Wraps a transport and stores and retries events when they fail to send.
+ *
+ * @param createTransport The transport to wrap.
+ */
+function makeOfflineTransport(
+  createTransport,
+) {
+  return options => {
+    const transport = createTransport(options);
+    const store = options.createStore ? options.createStore(options) : undefined;
+
+    let retryDelay = START_DELAY;
+    let flushTimer;
+
+    function shouldQueue(env, error, retryDelay) {
+      // We don't queue Session Replay envelopes because they are:
+      // - Ordered and Replay relies on the response status to know when they're successfully sent.
+      // - Likely to fill the queue quickly and block other events from being sent.
+      // We also want to drop client reports because they can be generated when we retry sending events while offline.
+      if (envelopeContainsItemType(env, ['replay_event', 'replay_recording', 'client_report'])) {
+        return false;
+      }
+
+      if (options.shouldStore) {
+        return options.shouldStore(env, error, retryDelay);
+      }
+
+      return true;
+    }
+
+    function flushIn(delay) {
+      if (!store) {
+        return;
+      }
+
+      if (flushTimer) {
+        clearTimeout(flushTimer );
+      }
+
+      flushTimer = setTimeout(async () => {
+        flushTimer = undefined;
+
+        const found = await store.pop();
+        if (found) {
+          log('Attempting to send previously queued event');
+          void send(found).catch(e => {
+            log('Failed to retry sending', e);
+          });
+        }
+      }, delay) ;
+
+      // We need to unref the timer in node.js, otherwise the node process never exit.
+      if (typeof flushTimer !== 'number' && flushTimer.unref) {
+        flushTimer.unref();
+      }
+    }
+
+    function flushWithBackOff() {
+      if (flushTimer) {
+        return;
+      }
+
+      flushIn(retryDelay);
+
+      retryDelay = Math.min(retryDelay * 2, MAX_DELAY);
+    }
+
+    async function send(envelope) {
+      try {
+        const result = await transport.send(envelope);
+
+        let delay = MIN_DELAY;
+
+        if (result) {
+          // If there's a retry-after header, use that as the next delay.
+          if (result.headers && result.headers['retry-after']) {
+            delay = parseRetryAfterHeader(result.headers['retry-after']);
+          } // If we have a server error, return now so we don't flush the queue.
+          else if ((result.statusCode || 0) >= 400) {
+            return result;
+          }
+        }
+
+        flushIn(delay);
+        retryDelay = START_DELAY;
+        return result;
+      } catch (e) {
+        if (store && (await shouldQueue(envelope, e , retryDelay))) {
+          await store.insert(envelope);
+          flushWithBackOff();
+          log('Error sending. Event queued', e );
+          return {};
+        } else {
+          throw e;
+        }
+      }
+    }
+
+    if (options.flushAtStartup) {
+      flushWithBackOff();
+    }
+
+    return {
+      send,
+      flush: t => transport.flush(t),
+    };
+  };
+}
+
+export { MIN_DELAY, START_DELAY, makeOfflineTransport };
+//# sourceMappingURL=offline.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/utils/hasTracingEnabled.js b/parent_dir/node_modules/sentry/core/esm/utils/hasTracingEnabled.js
new file mode 100644
index 0000000..d71bd5a
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/utils/hasTracingEnabled.js
@@ -0,0 +1,23 @@
+import { getCurrentHub } from '../hub.js';
+
+// Treeshakable guard to remove all code related to tracing
+
+/**
+ * Determines if tracing is currently enabled.
+ *
+ * Tracing is enabled when at least one of `tracesSampleRate` and `tracesSampler` is defined in the SDK config.
+ */
+function hasTracingEnabled(
+  maybeOptions,
+) {
+  if (typeof __SENTRY_TRACING__ === 'boolean' && !__SENTRY_TRACING__) {
+    return false;
+  }
+
+  const client = getCurrentHub().getClient();
+  const options = maybeOptions || (client && client.getOptions());
+  return !!options && (options.enableTracing || 'tracesSampleRate' in options || 'tracesSampler' in options);
+}
+
+export { hasTracingEnabled };
+//# sourceMappingURL=hasTracingEnabled.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/utils/prepareEvent.js b/parent_dir/node_modules/sentry/core/esm/utils/prepareEvent.js
new file mode 100644
index 0000000..c47ab9d
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/utils/prepareEvent.js
@@ -0,0 +1,311 @@
+import { uuid4, dateTimestampInSeconds, resolvedSyncPromise, truncate, GLOBAL_OBJ, normalize } from '@sentry/utils';
+import { DEFAULT_ENVIRONMENT } from '../constants.js';
+import { notifyEventProcessors } from '../eventProcessors.js';
+import { Scope } from '../scope.js';
+
+/**
+ * Adds common information to events.
+ *
+ * The information includes release and environment from `options`,
+ * breadcrumbs and context (extra, tags and user) from the scope.
+ *
+ * Information that is already present in the event is never overwritten. For
+ * nested objects, such as the context, keys are merged.
+ *
+ * Note: This also triggers callbacks for `addGlobalEventProcessor`, but not `beforeSend`.
+ *
+ * @param event The original event.
+ * @param hint May contain additional information about the original exception.
+ * @param scope A scope containing event metadata.
+ * @returns A new event with more information.
+ * @hidden
+ */
+function prepareEvent(
+  options,
+  event,
+  hint,
+  scope,
+  client,
+) {
+  const { normalizeDepth = 3, normalizeMaxBreadth = 1000 } = options;
+  const prepared = {
+    ...event,
+    event_id: event.event_id || hint.event_id || uuid4(),
+    timestamp: event.timestamp || dateTimestampInSeconds(),
+  };
+  const integrations = hint.integrations || options.integrations.map(i => i.name);
+
+  applyClientOptions(prepared, options);
+  applyIntegrationsMetadata(prepared, integrations);
+
+  // Only put debug IDs onto frames for error events.
+  if (event.type === undefined) {
+    applyDebugIds(prepared, options.stackParser);
+  }
+
+  // If we have scope given to us, use it as the base for further modifications.
+  // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.
+  let finalScope = scope;
+  if (hint.captureContext) {
+    finalScope = Scope.clone(finalScope).update(hint.captureContext);
+  }
+
+  // We prepare the result here with a resolved Event.
+  let result = resolvedSyncPromise(prepared);
+
+  // This should be the last thing called, since we want that
+  // {@link Hub.addEventProcessor} gets the finished prepared event.
+  //
+  // We need to check for the existence of `finalScope.getAttachments`
+  // because `getAttachments` can be undefined if users are using an older version
+  // of `@sentry/core` that does not have the `getAttachments` method.
+  // See: https://github.com/getsentry/sentry-javascript/issues/5229
+  if (finalScope) {
+    // Collect attachments from the hint and scope
+    if (finalScope.getAttachments) {
+      const attachments = [...(hint.attachments || []), ...finalScope.getAttachments()];
+
+      if (attachments.length) {
+        hint.attachments = attachments;
+      }
+    }
+
+    // In case we have a hub we reassign it.
+    result = finalScope.applyToEvent(prepared, hint);
+  }
+
+  return result
+    .then(evt => {
+      // Process client-scoped event processors
+      return client && client.getEventProcessors ? notifyEventProcessors(client.getEventProcessors(), evt, hint) : evt;
+    })
+    .then(evt => {
+      if (evt) {
+        // We apply the debug_meta field only after all event processors have ran, so that if any event processors modified
+        // file names (e.g.the RewriteFrames integration) the filename -> debug ID relationship isn't destroyed.
+        // This should not cause any PII issues, since we're only moving data that is already on the event and not adding
+        // any new data
+        applyDebugMeta(evt);
+      }
+
+      if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {
+        return normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);
+      }
+      return evt;
+    });
+}
+
+/**
+ *  Enhances event using the client configuration.
+ *  It takes care of all "static" values like environment, release and `dist`,
+ *  as well as truncating overly long values.
+ * @param event event instance to be enhanced
+ */
+function applyClientOptions(event, options) {
+  const { environment, release, dist, maxValueLength = 250 } = options;
+
+  if (!('environment' in event)) {
+    event.environment = 'environment' in options ? environment : DEFAULT_ENVIRONMENT;
+  }
+
+  if (event.release === undefined && release !== undefined) {
+    event.release = release;
+  }
+
+  if (event.dist === undefined && dist !== undefined) {
+    event.dist = dist;
+  }
+
+  if (event.message) {
+    event.message = truncate(event.message, maxValueLength);
+  }
+
+  const exception = event.exception && event.exception.values && event.exception.values[0];
+  if (exception && exception.value) {
+    exception.value = truncate(exception.value, maxValueLength);
+  }
+
+  const request = event.request;
+  if (request && request.url) {
+    request.url = truncate(request.url, maxValueLength);
+  }
+}
+
+const debugIdStackParserCache = new WeakMap();
+
+/**
+ * Puts debug IDs into the stack frames of an error event.
+ */
+function applyDebugIds(event, stackParser) {
+  const debugIdMap = GLOBAL_OBJ._sentryDebugIds;
+
+  if (!debugIdMap) {
+    return;
+  }
+
+  let debugIdStackFramesCache;
+  const cachedDebugIdStackFrameCache = debugIdStackParserCache.get(stackParser);
+  if (cachedDebugIdStackFrameCache) {
+    debugIdStackFramesCache = cachedDebugIdStackFrameCache;
+  } else {
+    debugIdStackFramesCache = new Map();
+    debugIdStackParserCache.set(stackParser, debugIdStackFramesCache);
+  }
+
+  // Build a map of filename -> debug_id
+  const filenameDebugIdMap = Object.keys(debugIdMap).reduce((acc, debugIdStackTrace) => {
+    let parsedStack;
+    const cachedParsedStack = debugIdStackFramesCache.get(debugIdStackTrace);
+    if (cachedParsedStack) {
+      parsedStack = cachedParsedStack;
+    } else {
+      parsedStack = stackParser(debugIdStackTrace);
+      debugIdStackFramesCache.set(debugIdStackTrace, parsedStack);
+    }
+
+    for (let i = parsedStack.length - 1; i >= 0; i--) {
+      const stackFrame = parsedStack[i];
+      if (stackFrame.filename) {
+        acc[stackFrame.filename] = debugIdMap[debugIdStackTrace];
+        break;
+      }
+    }
+    return acc;
+  }, {});
+
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    event.exception.values.forEach(exception => {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      exception.stacktrace.frames.forEach(frame => {
+        if (frame.filename) {
+          frame.debug_id = filenameDebugIdMap[frame.filename];
+        }
+      });
+    });
+  } catch (e) {
+    // To save bundle size we're just try catching here instead of checking for the existence of all the different objects.
+  }
+}
+
+/**
+ * Moves debug IDs from the stack frames of an error event into the debug_meta field.
+ */
+function applyDebugMeta(event) {
+  // Extract debug IDs and filenames from the stack frames on the event.
+  const filenameDebugIdMap = {};
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    event.exception.values.forEach(exception => {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      exception.stacktrace.frames.forEach(frame => {
+        if (frame.debug_id) {
+          if (frame.abs_path) {
+            filenameDebugIdMap[frame.abs_path] = frame.debug_id;
+          } else if (frame.filename) {
+            filenameDebugIdMap[frame.filename] = frame.debug_id;
+          }
+          delete frame.debug_id;
+        }
+      });
+    });
+  } catch (e) {
+    // To save bundle size we're just try catching here instead of checking for the existence of all the different objects.
+  }
+
+  if (Object.keys(filenameDebugIdMap).length === 0) {
+    return;
+  }
+
+  // Fill debug_meta information
+  event.debug_meta = event.debug_meta || {};
+  event.debug_meta.images = event.debug_meta.images || [];
+  const images = event.debug_meta.images;
+  Object.keys(filenameDebugIdMap).forEach(filename => {
+    images.push({
+      type: 'sourcemap',
+      code_file: filename,
+      debug_id: filenameDebugIdMap[filename],
+    });
+  });
+}
+
+/**
+ * This function adds all used integrations to the SDK info in the event.
+ * @param event The event that will be filled with all integrations.
+ */
+function applyIntegrationsMetadata(event, integrationNames) {
+  if (integrationNames.length > 0) {
+    event.sdk = event.sdk || {};
+    event.sdk.integrations = [...(event.sdk.integrations || []), ...integrationNames];
+  }
+}
+
+/**
+ * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.
+ * Normalized keys:
+ * - `breadcrumbs.data`
+ * - `user`
+ * - `contexts`
+ * - `extra`
+ * @param event Event
+ * @returns Normalized event
+ */
+function normalizeEvent(event, depth, maxBreadth) {
+  if (!event) {
+    return null;
+  }
+
+  const normalized = {
+    ...event,
+    ...(event.breadcrumbs && {
+      breadcrumbs: event.breadcrumbs.map(b => ({
+        ...b,
+        ...(b.data && {
+          data: normalize(b.data, depth, maxBreadth),
+        }),
+      })),
+    }),
+    ...(event.user && {
+      user: normalize(event.user, depth, maxBreadth),
+    }),
+    ...(event.contexts && {
+      contexts: normalize(event.contexts, depth, maxBreadth),
+    }),
+    ...(event.extra && {
+      extra: normalize(event.extra, depth, maxBreadth),
+    }),
+  };
+
+  // event.contexts.trace stores information about a Transaction. Similarly,
+  // event.spans[] stores information about child Spans. Given that a
+  // Transaction is conceptually a Span, normalization should apply to both
+  // Transactions and Spans consistently.
+  // For now the decision is to skip normalization of Transactions and Spans,
+  // so this block overwrites the normalized event to add back the original
+  // Transaction information prior to normalization.
+  if (event.contexts && event.contexts.trace && normalized.contexts) {
+    normalized.contexts.trace = event.contexts.trace;
+
+    // event.contexts.trace.data may contain circular/dangerous data so we need to normalize it
+    if (event.contexts.trace.data) {
+      normalized.contexts.trace.data = normalize(event.contexts.trace.data, depth, maxBreadth);
+    }
+  }
+
+  // event.spans[].data may contain circular/dangerous data so we need to normalize it
+  if (event.spans) {
+    normalized.spans = event.spans.map(span => {
+      // We cannot use the spread operator here because `toJSON` on `span` is non-enumerable
+      if (span.data) {
+        span.data = normalize(span.data, depth, maxBreadth);
+      }
+      return span;
+    });
+  }
+
+  return normalized;
+}
+
+export { applyDebugIds, applyDebugMeta, prepareEvent };
+//# sourceMappingURL=prepareEvent.js.map
diff --git a/parent_dir/node_modules/sentry/core/esm/version.js b/parent_dir/node_modules/sentry/core/esm/version.js
new file mode 100644
index 0000000..9221064
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/esm/version.js
@@ -0,0 +1,4 @@
+const SDK_VERSION = '7.70.0';
+
+export { SDK_VERSION };
+//# sourceMappingURL=version.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/browser.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/browser.js
new file mode 100644
index 0000000..aef06de
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/browser.js
@@ -0,0 +1,152 @@
+import { isString } from './is.js';
+import { getGlobalObject } from './worldwide.js';
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+const DEFAULT_MAX_STRING_LENGTH = 80;
+
+/**
+ * Given a child DOM element, returns a query-selector statement describing that
+ * and its ancestors
+ * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]
+ * @returns generated DOM path
+ */
+function htmlTreeAsString(
+  elem,
+  options = {},
+) {
+
+  // try/catch both:
+  // - accessing event.target (see getsentry/raven-js#838, #768)
+  // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly
+  // - can throw an exception in some circumstances.
+  try {
+    let currentElem = elem ;
+    const MAX_TRAVERSE_HEIGHT = 5;
+    const out = [];
+    let height = 0;
+    let len = 0;
+    const separator = ' > ';
+    const sepLength = separator.length;
+    let nextStr;
+    const keyAttrs = Array.isArray(options) ? options : options.keyAttrs;
+    const maxStringLength = (!Array.isArray(options) && options.maxStringLength) || DEFAULT_MAX_STRING_LENGTH;
+
+    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {
+      nextStr = _htmlElementAsString(currentElem, keyAttrs);
+      // bail out if
+      // - nextStr is the 'html' element
+      // - the length of the string that would be created exceeds maxStringLength
+      //   (ignore this limit if we are on the first iteration)
+      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength)) {
+        break;
+      }
+
+      out.push(nextStr);
+
+      len += nextStr.length;
+      currentElem = currentElem.parentNode;
+    }
+
+    return out.reverse().join(separator);
+  } catch (_oO) {
+    return '<unknown>';
+  }
+}
+
+/**
+ * Returns a simple, query-selector representation of a DOM element
+ * e.g. [HTMLElement] => input#foo.btn[name=baz]
+ * @returns generated DOM path
+ */
+function _htmlElementAsString(el, keyAttrs) {
+  const elem = el
+
+;
+
+  const out = [];
+  let className;
+  let classes;
+  let key;
+  let attr;
+  let i;
+
+  if (!elem || !elem.tagName) {
+    return '';
+  }
+
+  out.push(elem.tagName.toLowerCase());
+
+  // Pairs of attribute keys defined in `serializeAttribute` and their values on element.
+  const keyAttrPairs =
+    keyAttrs && keyAttrs.length
+      ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])
+      : null;
+
+  if (keyAttrPairs && keyAttrPairs.length) {
+    keyAttrPairs.forEach(keyAttrPair => {
+      out.push(`[${keyAttrPair[0]}="${keyAttrPair[1]}"]`);
+    });
+  } else {
+    if (elem.id) {
+      out.push(`#${elem.id}`);
+    }
+
+    // eslint-disable-next-line prefer-const
+    className = elem.className;
+    if (className && isString(className)) {
+      classes = className.split(/\s+/);
+      for (i = 0; i < classes.length; i++) {
+        out.push(`.${classes[i]}`);
+      }
+    }
+  }
+  const allowedAttrs = ['aria-label', 'type', 'name', 'title', 'alt'];
+  for (i = 0; i < allowedAttrs.length; i++) {
+    key = allowedAttrs[i];
+    attr = elem.getAttribute(key);
+    if (attr) {
+      out.push(`[${key}="${attr}"]`);
+    }
+  }
+  return out.join('');
+}
+
+/**
+ * A safe form of location.href
+ */
+function getLocationHref() {
+  try {
+    return WINDOW.document.location.href;
+  } catch (oO) {
+    return '';
+  }
+}
+
+/**
+ * Gets a DOM element by using document.querySelector.
+ *
+ * This wrapper will first check for the existance of the function before
+ * actually calling it so that we don't have to take care of this check,
+ * every time we want to access the DOM.
+ *
+ * Reason: DOM/querySelector is not available in all environments.
+ *
+ * We have to cast to any because utils can be consumed by a variety of environments,
+ * and we don't want to break TS users. If you know what element will be selected by
+ * `document.querySelector`, specify it as part of the generic call. For example,
+ * `const element = getDomElement<Element>('selector');`
+ *
+ * @param selector the selector string passed on to document.querySelector
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getDomElement(selector) {
+  if (WINDOW.document && WINDOW.document.querySelector) {
+    return WINDOW.document.querySelector(selector) ;
+  }
+  return null;
+}
+
+export { getDomElement, getLocationHref, htmlTreeAsString };
+//# sourceMappingURL=browser.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/dsn.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/dsn.js
new file mode 100644
index 0000000..4fe84be
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/dsn.js
@@ -0,0 +1,126 @@
+import { logger } from './logger.js';
+
+/** Regular expression used to parse a Dsn. */
+const DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)([\w.-]+)(?::(\d+))?\/(.+)/;
+
+function isValidProtocol(protocol) {
+  return protocol === 'http' || protocol === 'https';
+}
+
+/**
+ * Renders the string representation of this Dsn.
+ *
+ * By default, this will render the public representation without the password
+ * component. To get the deprecated private representation, set `withPassword`
+ * to true.
+ *
+ * @param withPassword When set to true, the password will be included.
+ */
+function dsnToString(dsn, withPassword = false) {
+  const { host, path, pass, port, projectId, protocol, publicKey } = dsn;
+  return (
+    `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +
+    `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`
+  );
+}
+
+/**
+ * Parses a Dsn from a given string.
+ *
+ * @param str A Dsn as string
+ * @returns Dsn as DsnComponents or undefined if @param str is not a valid DSN string
+ */
+function dsnFromString(str) {
+  const match = DSN_REGEX.exec(str);
+
+  if (!match) {
+    // This should be logged to the console
+    // eslint-disable-next-line no-console
+    console.error(`Invalid Sentry Dsn: ${str}`);
+    return undefined;
+  }
+
+  const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);
+  let path = '';
+  let projectId = lastPath;
+
+  const split = projectId.split('/');
+  if (split.length > 1) {
+    path = split.slice(0, -1).join('/');
+    projectId = split.pop() ;
+  }
+
+  if (projectId) {
+    const projectMatch = projectId.match(/^\d+/);
+    if (projectMatch) {
+      projectId = projectMatch[0];
+    }
+  }
+
+  return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol , publicKey });
+}
+
+function dsnFromComponents(components) {
+  return {
+    protocol: components.protocol,
+    publicKey: components.publicKey || '',
+    pass: components.pass || '',
+    host: components.host,
+    port: components.port || '',
+    path: components.path || '',
+    projectId: components.projectId,
+  };
+}
+
+function validateDsn(dsn) {
+  if (!(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+    return true;
+  }
+
+  const { port, projectId, protocol } = dsn;
+
+  const requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];
+  const hasMissingRequiredComponent = requiredComponents.find(component => {
+    if (!dsn[component]) {
+      logger.error(`Invalid Sentry Dsn: ${component} missing`);
+      return true;
+    }
+    return false;
+  });
+
+  if (hasMissingRequiredComponent) {
+    return false;
+  }
+
+  if (!projectId.match(/^\d+$/)) {
+    logger.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);
+    return false;
+  }
+
+  if (!isValidProtocol(protocol)) {
+    logger.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);
+    return false;
+  }
+
+  if (port && isNaN(parseInt(port, 10))) {
+    logger.error(`Invalid Sentry Dsn: Invalid port ${port}`);
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Creates a valid Sentry Dsn object, identifying a Sentry instance and project.
+ * @returns a valid DsnComponents object or `undefined` if @param from is an invalid DSN source
+ */
+function makeDsn(from) {
+  const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);
+  if (!components || !validateDsn(components)) {
+    return undefined;
+  }
+  return components;
+}
+
+export { dsnFromString, dsnToString, makeDsn };
+//# sourceMappingURL=dsn.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/env.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/env.js
new file mode 100644
index 0000000..46dc077
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/env.js
@@ -0,0 +1,34 @@
+/*
+ * This module exists for optimizations in the build process through rollup and terser.  We define some global
+ * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these
+ * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will
+ * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to
+ * `logger` and preventing node-related code from appearing in browser bundles.
+ *
+ * Attention:
+ * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by
+ * users. These flags should live in their respective packages, as we identified user tooling (specifically webpack)
+ * having issues tree-shaking these constants across package boundaries.
+ * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want
+ * users to be able to shake away expressions that it guards.
+ */
+
+/**
+ * Figures out if we're building a browser bundle.
+ *
+ * @returns true if this is a browser bundle build.
+ */
+function isBrowserBundle() {
+  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;
+}
+
+/**
+ * Get source of SDK.
+ */
+function getSDKSource() {
+  // @ts-expect-error "npm" is injected by rollup during build process
+  return "npm";
+}
+
+export { getSDKSource, isBrowserBundle };
+//# sourceMappingURL=env.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/envelope.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/envelope.js
new file mode 100644
index 0000000..a2cc042
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/envelope.js
@@ -0,0 +1,232 @@
+import { dsnToString } from './dsn.js';
+import { normalize } from './normalize.js';
+import { dropUndefinedKeys } from './object.js';
+
+/**
+ * Creates an envelope.
+ * Make sure to always explicitly provide the generic to this function
+ * so that the envelope types resolve correctly.
+ */
+function createEnvelope(headers, items = []) {
+  return [headers, items] ;
+}
+
+/**
+ * Add an item to an envelope.
+ * Make sure to always explicitly provide the generic to this function
+ * so that the envelope types resolve correctly.
+ */
+function addItemToEnvelope(envelope, newItem) {
+  const [headers, items] = envelope;
+  return [headers, [...items, newItem]] ;
+}
+
+/**
+ * Convenience function to loop through the items and item types of an envelope.
+ * (This function was mostly created because working with envelope types is painful at the moment)
+ *
+ * If the callback returns true, the rest of the items will be skipped.
+ */
+function forEachEnvelopeItem(
+  envelope,
+  callback,
+) {
+  const envelopeItems = envelope[1];
+
+  for (const envelopeItem of envelopeItems) {
+    const envelopeItemType = envelopeItem[0].type;
+    const result = callback(envelopeItem, envelopeItemType);
+
+    if (result) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Returns true if the envelope contains any of the given envelope item types
+ */
+function envelopeContainsItemType(envelope, types) {
+  return forEachEnvelopeItem(envelope, (_, type) => types.includes(type));
+}
+
+/**
+ * Encode a string to UTF8.
+ */
+function encodeUTF8(input, textEncoder) {
+  const utf8 = textEncoder || new TextEncoder();
+  return utf8.encode(input);
+}
+
+/**
+ * Serializes an envelope.
+ */
+function serializeEnvelope(envelope, textEncoder) {
+  const [envHeaders, items] = envelope;
+
+  // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data
+  let parts = JSON.stringify(envHeaders);
+
+  function append(next) {
+    if (typeof parts === 'string') {
+      parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts, textEncoder), next];
+    } else {
+      parts.push(typeof next === 'string' ? encodeUTF8(next, textEncoder) : next);
+    }
+  }
+
+  for (const item of items) {
+    const [itemHeaders, payload] = item;
+
+    append(`\n${JSON.stringify(itemHeaders)}\n`);
+
+    if (typeof payload === 'string' || payload instanceof Uint8Array) {
+      append(payload);
+    } else {
+      let stringifiedPayload;
+      try {
+        stringifiedPayload = JSON.stringify(payload);
+      } catch (e) {
+        // In case, despite all our efforts to keep `payload` circular-dependency-free, `JSON.strinify()` still
+        // fails, we try again after normalizing it again with infinite normalization depth. This of course has a
+        // performance impact but in this case a performance hit is better than throwing.
+        stringifiedPayload = JSON.stringify(normalize(payload));
+      }
+      append(stringifiedPayload);
+    }
+  }
+
+  return typeof parts === 'string' ? parts : concatBuffers(parts);
+}
+
+function concatBuffers(buffers) {
+  const totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);
+
+  const merged = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const buffer of buffers) {
+    merged.set(buffer, offset);
+    offset += buffer.length;
+  }
+
+  return merged;
+}
+
+/**
+ * Parses an envelope
+ */
+function parseEnvelope(
+  env,
+  textEncoder,
+  textDecoder,
+) {
+  let buffer = typeof env === 'string' ? textEncoder.encode(env) : env;
+
+  function readBinary(length) {
+    const bin = buffer.subarray(0, length);
+    // Replace the buffer with the remaining data excluding trailing newline
+    buffer = buffer.subarray(length + 1);
+    return bin;
+  }
+
+  function readJson() {
+    let i = buffer.indexOf(0xa);
+    // If we couldn't find a newline, we must have found the end of the buffer
+    if (i < 0) {
+      i = buffer.length;
+    }
+
+    return JSON.parse(textDecoder.decode(readBinary(i))) ;
+  }
+
+  const envelopeHeader = readJson();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const items = [];
+
+  while (buffer.length) {
+    const itemHeader = readJson();
+    const binaryLength = typeof itemHeader.length === 'number' ? itemHeader.length : undefined;
+
+    items.push([itemHeader, binaryLength ? readBinary(binaryLength) : readJson()]);
+  }
+
+  return [envelopeHeader, items];
+}
+
+/**
+ * Creates attachment envelope items
+ */
+function createAttachmentEnvelopeItem(
+  attachment,
+  textEncoder,
+) {
+  const buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data, textEncoder) : attachment.data;
+
+  return [
+    dropUndefinedKeys({
+      type: 'attachment',
+      length: buffer.length,
+      filename: attachment.filename,
+      content_type: attachment.contentType,
+      attachment_type: attachment.attachmentType,
+    }),
+    buffer,
+  ];
+}
+
+const ITEM_TYPE_TO_DATA_CATEGORY_MAP = {
+  session: 'session',
+  sessions: 'session',
+  attachment: 'attachment',
+  transaction: 'transaction',
+  event: 'error',
+  client_report: 'internal',
+  user_report: 'default',
+  profile: 'profile',
+  replay_event: 'replay',
+  replay_recording: 'replay',
+  check_in: 'monitor',
+};
+
+/**
+ * Maps the type of an envelope item to a data category.
+ */
+function envelopeItemTypeToDataCategory(type) {
+  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];
+}
+
+/** Extracts the minimal SDK info from from the metadata or an events */
+function getSdkMetadataForEnvelopeHeader(metadataOrEvent) {
+  if (!metadataOrEvent || !metadataOrEvent.sdk) {
+    return;
+  }
+  const { name, version } = metadataOrEvent.sdk;
+  return { name, version };
+}
+
+/**
+ * Creates event envelope headers, based on event, sdk info and tunnel
+ * Note: This function was extracted from the core package to make it available in Replay
+ */
+function createEventEnvelopeHeaders(
+  event,
+  sdkInfo,
+  tunnel,
+  dsn,
+) {
+  const dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;
+  return {
+    event_id: event.event_id ,
+    sent_at: new Date().toISOString(),
+    ...(sdkInfo && { sdk: sdkInfo }),
+    ...(!!tunnel && { dsn: dsnToString(dsn) }),
+    ...(dynamicSamplingContext && {
+      trace: dropUndefinedKeys({ ...dynamicSamplingContext }),
+    }),
+  };
+}
+
+export { addItemToEnvelope, createAttachmentEnvelopeItem, createEnvelope, createEventEnvelopeHeaders, envelopeContainsItemType, envelopeItemTypeToDataCategory, forEachEnvelopeItem, getSdkMetadataForEnvelopeHeader, parseEnvelope, serializeEnvelope };
+//# sourceMappingURL=envelope.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/error.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/error.js
new file mode 100644
index 0000000..5266404
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/error.js
@@ -0,0 +1,17 @@
+/** An error emitted by Sentry SDKs and related utilities. */
+class SentryError extends Error {
+  /** Display name of this error instance. */
+
+   constructor( message, logLevel = 'warn') {
+    super(message);this.message = message;
+    this.name = new.target.prototype.constructor.name;
+    // This sets the prototype to be `Error`, not `SentryError`. It's unclear why we do this, but commenting this line
+    // out causes various (seemingly totally unrelated) playwright tests consistently time out. FYI, this makes
+    // instances of `SentryError` fail `obj instanceof SentryError` checks.
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.logLevel = logLevel;
+  }
+}
+
+export { SentryError };
+//# sourceMappingURL=error.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/instrument.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/instrument.js
new file mode 100644
index 0000000..9eb5a9e
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/instrument.js
@@ -0,0 +1,642 @@
+import { isString } from './is.js';
+import { logger, CONSOLE_LEVELS, originalConsoleMethods } from './logger.js';
+import { fill } from './object.js';
+import { getFunctionName } from './stacktrace.js';
+import { supportsNativeFetch } from './supports.js';
+import { getGlobalObject, GLOBAL_OBJ } from './worldwide.js';
+import { supportsHistory } from './vendor/supportsHistory.js';
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+const SENTRY_XHR_DATA_KEY = '__sentry_xhr_v2__';
+
+/**
+ * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.
+ *  - Console API
+ *  - Fetch API
+ *  - XHR API
+ *  - History API
+ *  - DOM API (click/typing)
+ *  - Error API
+ *  - UnhandledRejection API
+ */
+
+const handlers = {};
+const instrumented = {};
+
+/** Instruments given API */
+function instrument(type) {
+  if (instrumented[type]) {
+    return;
+  }
+
+  instrumented[type] = true;
+
+  switch (type) {
+    case 'console':
+      instrumentConsole();
+      break;
+    case 'dom':
+      instrumentDOM();
+      break;
+    case 'xhr':
+      instrumentXHR();
+      break;
+    case 'fetch':
+      instrumentFetch();
+      break;
+    case 'history':
+      instrumentHistory();
+      break;
+    case 'error':
+      instrumentError();
+      break;
+    case 'unhandledrejection':
+      instrumentUnhandledRejection();
+      break;
+    default:
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('unknown instrumentation type:', type);
+      return;
+  }
+}
+
+/**
+ * Add handler that will be called when given type of instrumentation triggers.
+ * Use at your own risk, this might break without changelog notice, only used internally.
+ * @hidden
+ */
+function addInstrumentationHandler(type, callback) {
+  handlers[type] = handlers[type] || [];
+  (handlers[type] ).push(callback);
+  instrument(type);
+}
+
+/**
+ * Reset all instrumentation handlers.
+ * This can be used by tests to ensure we have a clean slate of instrumentation handlers.
+ */
+function resetInstrumentationHandlers() {
+  Object.keys(handlers).forEach(key => {
+    handlers[key ] = undefined;
+  });
+}
+
+/** JSDoc */
+function triggerHandlers(type, data) {
+  if (!type || !handlers[type]) {
+    return;
+  }
+
+  for (const handler of handlers[type] || []) {
+    try {
+      handler(data);
+    } catch (e) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        logger.error(
+          `Error while triggering instrumentation handler.\nType: ${type}\nName: ${getFunctionName(handler)}\nError:`,
+          e,
+        );
+    }
+  }
+}
+
+/** JSDoc */
+function instrumentConsole() {
+  if (!('console' in GLOBAL_OBJ)) {
+    return;
+  }
+
+  CONSOLE_LEVELS.forEach(function (level) {
+    if (!(level in GLOBAL_OBJ.console)) {
+      return;
+    }
+
+    fill(GLOBAL_OBJ.console, level, function (originalConsoleMethod) {
+      originalConsoleMethods[level] = originalConsoleMethod;
+
+      return function (...args) {
+        triggerHandlers('console', { args, level });
+
+        const log = originalConsoleMethods[level];
+        log && log.apply(GLOBAL_OBJ.console, args);
+      };
+    });
+  });
+}
+
+/** JSDoc */
+function instrumentFetch() {
+  if (!supportsNativeFetch()) {
+    return;
+  }
+
+  fill(GLOBAL_OBJ, 'fetch', function (originalFetch) {
+    return function (...args) {
+      const { method, url } = parseFetchArgs(args);
+
+      const handlerData = {
+        args,
+        fetchData: {
+          method,
+          url,
+        },
+        startTimestamp: Date.now(),
+      };
+
+      triggerHandlers('fetch', {
+        ...handlerData,
+      });
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      return originalFetch.apply(GLOBAL_OBJ, args).then(
+        (response) => {
+          triggerHandlers('fetch', {
+            ...handlerData,
+            endTimestamp: Date.now(),
+            response,
+          });
+          return response;
+        },
+        (error) => {
+          triggerHandlers('fetch', {
+            ...handlerData,
+            endTimestamp: Date.now(),
+            error,
+          });
+          // NOTE: If you are a Sentry user, and you are seeing this stack frame,
+          //       it means the sentry.javascript SDK caught an error invoking your application code.
+          //       This is expected behavior and NOT indicative of a bug with sentry.javascript.
+          throw error;
+        },
+      );
+    };
+  });
+}
+
+function hasProp(obj, prop) {
+  return !!obj && typeof obj === 'object' && !!(obj )[prop];
+}
+
+function getUrlFromResource(resource) {
+  if (typeof resource === 'string') {
+    return resource;
+  }
+
+  if (!resource) {
+    return '';
+  }
+
+  if (hasProp(resource, 'url')) {
+    return resource.url;
+  }
+
+  if (resource.toString) {
+    return resource.toString();
+  }
+
+  return '';
+}
+
+/**
+ * Parses the fetch arguments to find the used Http method and the url of the request
+ */
+function parseFetchArgs(fetchArgs) {
+  if (fetchArgs.length === 0) {
+    return { method: 'GET', url: '' };
+  }
+
+  if (fetchArgs.length === 2) {
+    const [url, options] = fetchArgs ;
+
+    return {
+      url: getUrlFromResource(url),
+      method: hasProp(options, 'method') ? String(options.method).toUpperCase() : 'GET',
+    };
+  }
+
+  const arg = fetchArgs[0];
+  return {
+    url: getUrlFromResource(arg ),
+    method: hasProp(arg, 'method') ? String(arg.method).toUpperCase() : 'GET',
+  };
+}
+
+/** JSDoc */
+function instrumentXHR() {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  if (!(WINDOW ).XMLHttpRequest) {
+    return;
+  }
+
+  const xhrproto = XMLHttpRequest.prototype;
+
+  fill(xhrproto, 'open', function (originalOpen) {
+    return function ( ...args) {
+      const url = args[1];
+      const xhrInfo = (this[SENTRY_XHR_DATA_KEY] = {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        method: isString(args[0]) ? args[0].toUpperCase() : args[0],
+        url: args[1],
+        request_headers: {},
+      });
+
+      // if Sentry key appears in URL, don't capture it as a request
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      if (isString(url) && xhrInfo.method === 'POST' && url.match(/sentry_key/)) {
+        this.__sentry_own_request__ = true;
+      }
+
+      const onreadystatechangeHandler = () => {
+        // For whatever reason, this is not the same instance here as from the outer method
+        const xhrInfo = this[SENTRY_XHR_DATA_KEY];
+
+        if (!xhrInfo) {
+          return;
+        }
+
+        if (this.readyState === 4) {
+          try {
+            // touching statusCode in some platforms throws
+            // an exception
+            xhrInfo.status_code = this.status;
+          } catch (e) {
+            /* do nothing */
+          }
+
+          triggerHandlers('xhr', {
+            args: args ,
+            endTimestamp: Date.now(),
+            startTimestamp: Date.now(),
+            xhr: this,
+          } );
+        }
+      };
+
+      if ('onreadystatechange' in this && typeof this.onreadystatechange === 'function') {
+        fill(this, 'onreadystatechange', function (original) {
+          return function ( ...readyStateArgs) {
+            onreadystatechangeHandler();
+            return original.apply(this, readyStateArgs);
+          };
+        });
+      } else {
+        this.addEventListener('readystatechange', onreadystatechangeHandler);
+      }
+
+      // Intercepting `setRequestHeader` to access the request headers of XHR instance.
+      // This will only work for user/library defined headers, not for the default/browser-assigned headers.
+      // Request cookies are also unavailable for XHR, as `Cookie` header can't be defined by `setRequestHeader`.
+      fill(this, 'setRequestHeader', function (original) {
+        return function ( ...setRequestHeaderArgs) {
+          const [header, value] = setRequestHeaderArgs ;
+
+          const xhrInfo = this[SENTRY_XHR_DATA_KEY];
+
+          if (xhrInfo) {
+            xhrInfo.request_headers[header.toLowerCase()] = value;
+          }
+
+          return original.apply(this, setRequestHeaderArgs);
+        };
+      });
+
+      return originalOpen.apply(this, args);
+    };
+  });
+
+  fill(xhrproto, 'send', function (originalSend) {
+    return function ( ...args) {
+      const sentryXhrData = this[SENTRY_XHR_DATA_KEY];
+      if (sentryXhrData && args[0] !== undefined) {
+        sentryXhrData.body = args[0];
+      }
+
+      triggerHandlers('xhr', {
+        args,
+        startTimestamp: Date.now(),
+        xhr: this,
+      });
+
+      return originalSend.apply(this, args);
+    };
+  });
+}
+
+let lastHref;
+
+/** JSDoc */
+function instrumentHistory() {
+  if (!supportsHistory()) {
+    return;
+  }
+
+  const oldOnPopState = WINDOW.onpopstate;
+  WINDOW.onpopstate = function ( ...args) {
+    const to = WINDOW.location.href;
+    // keep track of the current URL state, as we always receive only the updated state
+    const from = lastHref;
+    lastHref = to;
+    triggerHandlers('history', {
+      from,
+      to,
+    });
+    if (oldOnPopState) {
+      // Apparently this can throw in Firefox when incorrectly implemented plugin is installed.
+      // https://github.com/getsentry/sentry-javascript/issues/3344
+      // https://github.com/bugsnag/bugsnag-js/issues/469
+      try {
+        return oldOnPopState.apply(this, args);
+      } catch (_oO) {
+        // no-empty
+      }
+    }
+  };
+
+  /** @hidden */
+  function historyReplacementFunction(originalHistoryFunction) {
+    return function ( ...args) {
+      const url = args.length > 2 ? args[2] : undefined;
+      if (url) {
+        // coerce to string (this is what pushState does)
+        const from = lastHref;
+        const to = String(url);
+        // keep track of the current URL state, as we always receive only the updated state
+        lastHref = to;
+        triggerHandlers('history', {
+          from,
+          to,
+        });
+      }
+      return originalHistoryFunction.apply(this, args);
+    };
+  }
+
+  fill(WINDOW.history, 'pushState', historyReplacementFunction);
+  fill(WINDOW.history, 'replaceState', historyReplacementFunction);
+}
+
+const debounceDuration = 1000;
+let debounceTimerID;
+let lastCapturedEvent;
+
+/**
+ * Decide whether the current event should finish the debounce of previously captured one.
+ * @param previous previously captured event
+ * @param current event to be captured
+ */
+function shouldShortcircuitPreviousDebounce(previous, current) {
+  // If there was no previous event, it should always be swapped for the new one.
+  if (!previous) {
+    return true;
+  }
+
+  // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.
+  if (previous.type !== current.type) {
+    return true;
+  }
+
+  try {
+    // If both events have the same type, it's still possible that actions were performed on different targets.
+    // e.g. 2 clicks on different buttons.
+    if (previous.target !== current.target) {
+      return true;
+    }
+  } catch (e) {
+    // just accessing `target` property can throw an exception in some rare circumstances
+    // see: https://github.com/getsentry/sentry-javascript/issues/838
+  }
+
+  // If both events have the same type _and_ same `target` (an element which triggered an event, _not necessarily_
+  // to which an event listener was attached), we treat them as the same action, as we want to capture
+  // only one breadcrumb. e.g. multiple clicks on the same button, or typing inside a user input box.
+  return false;
+}
+
+/**
+ * Decide whether an event should be captured.
+ * @param event event to be captured
+ */
+function shouldSkipDOMEvent(event) {
+  // We are only interested in filtering `keypress` events for now.
+  if (event.type !== 'keypress') {
+    return false;
+  }
+
+  try {
+    const target = event.target ;
+
+    if (!target || !target.tagName) {
+      return true;
+    }
+
+    // Only consider keypress events on actual input elements. This will disregard keypresses targeting body
+    // e.g.tabbing through elements, hotkeys, etc.
+    if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {
+      return false;
+    }
+  } catch (e) {
+    // just accessing `target` property can throw an exception in some rare circumstances
+    // see: https://github.com/getsentry/sentry-javascript/issues/838
+  }
+
+  return true;
+}
+
+/**
+ * Wraps addEventListener to capture UI breadcrumbs
+ * @param handler function that will be triggered
+ * @param globalListener indicates whether event was captured by the global event listener
+ * @returns wrapped breadcrumb events handler
+ * @hidden
+ */
+function makeDOMEventHandler(handler, globalListener = false) {
+  return (event) => {
+    // It's possible this handler might trigger multiple times for the same
+    // event (e.g. event propagation through node ancestors).
+    // Ignore if we've already captured that event.
+    if (!event || lastCapturedEvent === event) {
+      return;
+    }
+
+    // We always want to skip _some_ events.
+    if (shouldSkipDOMEvent(event)) {
+      return;
+    }
+
+    const name = event.type === 'keypress' ? 'input' : event.type;
+
+    // If there is no debounce timer, it means that we can safely capture the new event and store it for future comparisons.
+    if (debounceTimerID === undefined) {
+      handler({
+        event: event,
+        name,
+        global: globalListener,
+      });
+      lastCapturedEvent = event;
+    }
+    // If there is a debounce awaiting, see if the new event is different enough to treat it as a unique one.
+    // If that's the case, emit the previous event and store locally the newly-captured DOM event.
+    else if (shouldShortcircuitPreviousDebounce(lastCapturedEvent, event)) {
+      handler({
+        event: event,
+        name,
+        global: globalListener,
+      });
+      lastCapturedEvent = event;
+    }
+
+    // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.
+    clearTimeout(debounceTimerID);
+    debounceTimerID = WINDOW.setTimeout(() => {
+      debounceTimerID = undefined;
+    }, debounceDuration);
+  };
+}
+
+/** JSDoc */
+function instrumentDOM() {
+  if (!WINDOW.document) {
+    return;
+  }
+
+  // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom
+  // handlers. (Normally we have only one, which captures a breadcrumb for each click or keypress.) Do this before
+  // we instrument `addEventListener` so that we don't end up attaching this handler twice.
+  const triggerDOMHandler = triggerHandlers.bind(null, 'dom');
+  const globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);
+  WINDOW.document.addEventListener('click', globalDOMEventHandler, false);
+  WINDOW.document.addEventListener('keypress', globalDOMEventHandler, false);
+
+  // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled
+  // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That
+  // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler
+  // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still
+  // guaranteed to fire at least once.)
+  ['EventTarget', 'Node'].forEach((target) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    const proto = (WINDOW )[target] && (WINDOW )[target].prototype;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins
+    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {
+      return;
+    }
+
+    fill(proto, 'addEventListener', function (originalAddEventListener) {
+      return function (
+
+        type,
+        listener,
+        options,
+      ) {
+        if (type === 'click' || type == 'keypress') {
+          try {
+            const el = this ;
+            const handlers = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});
+            const handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });
+
+            if (!handlerForType.handler) {
+              const handler = makeDOMEventHandler(triggerDOMHandler);
+              handlerForType.handler = handler;
+              originalAddEventListener.call(this, type, handler, options);
+            }
+
+            handlerForType.refCount++;
+          } catch (e) {
+            // Accessing dom properties is always fragile.
+            // Also allows us to skip `addEventListenrs` calls with no proper `this` context.
+          }
+        }
+
+        return originalAddEventListener.call(this, type, listener, options);
+      };
+    });
+
+    fill(
+      proto,
+      'removeEventListener',
+      function (originalRemoveEventListener) {
+        return function (
+
+          type,
+          listener,
+          options,
+        ) {
+          if (type === 'click' || type == 'keypress') {
+            try {
+              const el = this ;
+              const handlers = el.__sentry_instrumentation_handlers__ || {};
+              const handlerForType = handlers[type];
+
+              if (handlerForType) {
+                handlerForType.refCount--;
+                // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.
+                if (handlerForType.refCount <= 0) {
+                  originalRemoveEventListener.call(this, type, handlerForType.handler, options);
+                  handlerForType.handler = undefined;
+                  delete handlers[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete
+                }
+
+                // If there are no longer any custom handlers of any type on this element, cleanup everything.
+                if (Object.keys(handlers).length === 0) {
+                  delete el.__sentry_instrumentation_handlers__;
+                }
+              }
+            } catch (e) {
+              // Accessing dom properties is always fragile.
+              // Also allows us to skip `addEventListenrs` calls with no proper `this` context.
+            }
+          }
+
+          return originalRemoveEventListener.call(this, type, listener, options);
+        };
+      },
+    );
+  });
+}
+
+let _oldOnErrorHandler = null;
+/** JSDoc */
+function instrumentError() {
+  _oldOnErrorHandler = WINDOW.onerror;
+
+  WINDOW.onerror = function (msg, url, line, column, error) {
+    triggerHandlers('error', {
+      column,
+      error,
+      line,
+      msg,
+      url,
+    });
+
+    if (_oldOnErrorHandler && !_oldOnErrorHandler.__SENTRY_LOADER__) {
+      // eslint-disable-next-line prefer-rest-params
+      return _oldOnErrorHandler.apply(this, arguments);
+    }
+
+    return false;
+  };
+
+  WINDOW.onerror.__SENTRY_INSTRUMENTED__ = true;
+}
+
+let _oldOnUnhandledRejectionHandler = null;
+/** JSDoc */
+function instrumentUnhandledRejection() {
+  _oldOnUnhandledRejectionHandler = WINDOW.onunhandledrejection;
+
+  WINDOW.onunhandledrejection = function (e) {
+    triggerHandlers('unhandledrejection', e);
+
+    if (_oldOnUnhandledRejectionHandler && !_oldOnUnhandledRejectionHandler.__SENTRY_LOADER__) {
+      // eslint-disable-next-line prefer-rest-params
+      return _oldOnUnhandledRejectionHandler.apply(this, arguments);
+    }
+
+    return true;
+  };
+
+  WINDOW.onunhandledrejection.__SENTRY_INSTRUMENTED__ = true;
+}
+
+export { SENTRY_XHR_DATA_KEY, addInstrumentationHandler, instrumentDOM, instrumentXHR, parseFetchArgs, resetInstrumentationHandlers };
+//# sourceMappingURL=instrument.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/is.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/is.js
new file mode 100644
index 0000000..2ed8c2e
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/is.js
@@ -0,0 +1,190 @@
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const objectToString = Object.prototype.toString;
+
+/**
+ * Checks whether given value's type is one of a few Error or Error-like
+ * {@link isError}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isError(wat) {
+  switch (objectToString.call(wat)) {
+    case '[object Error]':
+    case '[object Exception]':
+    case '[object DOMException]':
+      return true;
+    default:
+      return isInstanceOf(wat, Error);
+  }
+}
+/**
+ * Checks whether given value is an instance of the given built-in class.
+ *
+ * @param wat The value to be checked
+ * @param className
+ * @returns A boolean representing the result.
+ */
+function isBuiltin(wat, className) {
+  return objectToString.call(wat) === `[object ${className}]`;
+}
+
+/**
+ * Checks whether given value's type is ErrorEvent
+ * {@link isErrorEvent}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isErrorEvent(wat) {
+  return isBuiltin(wat, 'ErrorEvent');
+}
+
+/**
+ * Checks whether given value's type is DOMError
+ * {@link isDOMError}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isDOMError(wat) {
+  return isBuiltin(wat, 'DOMError');
+}
+
+/**
+ * Checks whether given value's type is DOMException
+ * {@link isDOMException}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isDOMException(wat) {
+  return isBuiltin(wat, 'DOMException');
+}
+
+/**
+ * Checks whether given value's type is a string
+ * {@link isString}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isString(wat) {
+  return isBuiltin(wat, 'String');
+}
+
+/**
+ * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)
+ * {@link isPrimitive}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isPrimitive(wat) {
+  return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');
+}
+
+/**
+ * Checks whether given value's type is an object literal
+ * {@link isPlainObject}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isPlainObject(wat) {
+  return isBuiltin(wat, 'Object');
+}
+
+/**
+ * Checks whether given value's type is an Event instance
+ * {@link isEvent}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isEvent(wat) {
+  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);
+}
+
+/**
+ * Checks whether given value's type is an Element instance
+ * {@link isElement}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isElement(wat) {
+  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);
+}
+
+/**
+ * Checks whether given value's type is an regexp
+ * {@link isRegExp}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isRegExp(wat) {
+  return isBuiltin(wat, 'RegExp');
+}
+
+/**
+ * Checks whether given value has a then function.
+ * @param wat A value to be checked.
+ */
+function isThenable(wat) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  return Boolean(wat && wat.then && typeof wat.then === 'function');
+}
+
+/**
+ * Checks whether given value's type is a SyntheticEvent
+ * {@link isSyntheticEvent}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isSyntheticEvent(wat) {
+  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;
+}
+
+/**
+ * Checks whether given value is NaN
+ * {@link isNaN}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isNaN(wat) {
+  return typeof wat === 'number' && wat !== wat;
+}
+
+/**
+ * Checks whether given value's type is an instance of provided constructor.
+ * {@link isInstanceOf}.
+ *
+ * @param wat A value to be checked.
+ * @param base A constructor to be used in a check.
+ * @returns A boolean representing the result.
+ */
+function isInstanceOf(wat, base) {
+  try {
+    return wat instanceof base;
+  } catch (_e) {
+    return false;
+  }
+}
+
+/**
+ * Checks whether given value's type is a Vue ViewModel.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isVueViewModel(wat) {
+  // Not using Object.prototype.toString because in Vue 3 it would read the instance's Symbol(Symbol.toStringTag) property.
+  return !!(typeof wat === 'object' && wat !== null && ((wat ).__isVue || (wat )._isVue));
+}
+
+export { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isNaN, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable, isVueViewModel };
+//# sourceMappingURL=is.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/logger.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/logger.js
new file mode 100644
index 0000000..efa35e4
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/logger.js
@@ -0,0 +1,82 @@
+import { GLOBAL_OBJ } from './worldwide.js';
+
+/** Prefix for logging strings */
+const PREFIX = 'Sentry Logger ';
+
+const CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] ;
+
+/** This may be mutated by the console instrumentation. */
+const originalConsoleMethods
+
+ = {};
+
+/** JSDoc */
+
+/**
+ * Temporarily disable sentry console instrumentations.
+ *
+ * @param callback The function to run against the original `console` messages
+ * @returns The results of the callback
+ */
+function consoleSandbox(callback) {
+  if (!('console' in GLOBAL_OBJ)) {
+    return callback();
+  }
+
+  const console = GLOBAL_OBJ.console ;
+  const wrappedFuncs = {};
+
+  const wrappedLevels = Object.keys(originalConsoleMethods) ;
+
+  // Restore all wrapped console methods
+  wrappedLevels.forEach(level => {
+    const originalConsoleMethod = originalConsoleMethods[level] ;
+    wrappedFuncs[level] = console[level] ;
+    console[level] = originalConsoleMethod;
+  });
+
+  try {
+    return callback();
+  } finally {
+    // Revert restoration to wrapped state
+    wrappedLevels.forEach(level => {
+      console[level] = wrappedFuncs[level] ;
+    });
+  }
+}
+
+function makeLogger() {
+  let enabled = false;
+  const logger = {
+    enable: () => {
+      enabled = true;
+    },
+    disable: () => {
+      enabled = false;
+    },
+  };
+
+  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+    CONSOLE_LEVELS.forEach(name => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      logger[name] = (...args) => {
+        if (enabled) {
+          consoleSandbox(() => {
+            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);
+          });
+        }
+      };
+    });
+  } else {
+    CONSOLE_LEVELS.forEach(name => {
+      logger[name] = () => undefined;
+    });
+  }
+
+  return logger ;
+}
+
+const logger = makeLogger();
+
+export { CONSOLE_LEVELS, consoleSandbox, logger, originalConsoleMethods };
+//# sourceMappingURL=logger.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/memo.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/memo.js
new file mode 100644
index 0000000..fe00c9c
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/memo.js
@@ -0,0 +1,45 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/**
+ * Helper to decycle json objects
+ */
+function memoBuilder() {
+  const hasWeakSet = typeof WeakSet === 'function';
+  const inner = hasWeakSet ? new WeakSet() : [];
+  function memoize(obj) {
+    if (hasWeakSet) {
+      if (inner.has(obj)) {
+        return true;
+      }
+      inner.add(obj);
+      return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let i = 0; i < inner.length; i++) {
+      const value = inner[i];
+      if (value === obj) {
+        return true;
+      }
+    }
+    inner.push(obj);
+    return false;
+  }
+
+  function unmemoize(obj) {
+    if (hasWeakSet) {
+      inner.delete(obj);
+    } else {
+      for (let i = 0; i < inner.length; i++) {
+        if (inner[i] === obj) {
+          inner.splice(i, 1);
+          break;
+        }
+      }
+    }
+  }
+  return [memoize, unmemoize];
+}
+
+export { memoBuilder };
+//# sourceMappingURL=memo.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/misc.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/misc.js
new file mode 100644
index 0000000..5685693
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/misc.js
@@ -0,0 +1,203 @@
+import { addNonEnumerableProperty } from './object.js';
+import { snipLine } from './string.js';
+import { GLOBAL_OBJ } from './worldwide.js';
+
+/**
+ * UUID4 generator
+ *
+ * @returns string Generated UUID4.
+ */
+function uuid4() {
+  const gbl = GLOBAL_OBJ ;
+  const crypto = gbl.crypto || gbl.msCrypto;
+
+  let getRandomByte = () => Math.random() * 16;
+  try {
+    if (crypto && crypto.randomUUID) {
+      return crypto.randomUUID().replace(/-/g, '');
+    }
+    if (crypto && crypto.getRandomValues) {
+      getRandomByte = () => crypto.getRandomValues(new Uint8Array(1))[0];
+    }
+  } catch (_) {
+    // some runtimes can crash invoking crypto
+    // https://github.com/getsentry/sentry-javascript/issues/8935
+  }
+
+  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
+  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'
+  return (([1e7] ) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>
+    // eslint-disable-next-line no-bitwise
+    ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),
+  );
+}
+
+function getFirstException(event) {
+  return event.exception && event.exception.values ? event.exception.values[0] : undefined;
+}
+
+/**
+ * Extracts either message or type+value from an event that can be used for user-facing logs
+ * @returns event's description
+ */
+function getEventDescription(event) {
+  const { message, event_id: eventId } = event;
+  if (message) {
+    return message;
+  }
+
+  const firstException = getFirstException(event);
+  if (firstException) {
+    if (firstException.type && firstException.value) {
+      return `${firstException.type}: ${firstException.value}`;
+    }
+    return firstException.type || firstException.value || eventId || '<unknown>';
+  }
+  return eventId || '<unknown>';
+}
+
+/**
+ * Adds exception values, type and value to an synthetic Exception.
+ * @param event The event to modify.
+ * @param value Value of the exception.
+ * @param type Type of the exception.
+ * @hidden
+ */
+function addExceptionTypeValue(event, value, type) {
+  const exception = (event.exception = event.exception || {});
+  const values = (exception.values = exception.values || []);
+  const firstException = (values[0] = values[0] || {});
+  if (!firstException.value) {
+    firstException.value = value || '';
+  }
+  if (!firstException.type) {
+    firstException.type = type || 'Error';
+  }
+}
+
+/**
+ * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.
+ *
+ * @param event The event to modify.
+ * @param newMechanism Mechanism data to add to the event.
+ * @hidden
+ */
+function addExceptionMechanism(event, newMechanism) {
+  const firstException = getFirstException(event);
+  if (!firstException) {
+    return;
+  }
+
+  const defaultMechanism = { type: 'generic', handled: true };
+  const currentMechanism = firstException.mechanism;
+  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };
+
+  if (newMechanism && 'data' in newMechanism) {
+    const mergedData = { ...(currentMechanism && currentMechanism.data), ...newMechanism.data };
+    firstException.mechanism.data = mergedData;
+  }
+}
+
+// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+const SEMVER_REGEXP =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+
+/**
+ * Represents Semantic Versioning object
+ */
+
+/**
+ * Parses input into a SemVer interface
+ * @param input string representation of a semver version
+ */
+function parseSemver(input) {
+  const match = input.match(SEMVER_REGEXP) || [];
+  const major = parseInt(match[1], 10);
+  const minor = parseInt(match[2], 10);
+  const patch = parseInt(match[3], 10);
+  return {
+    buildmetadata: match[5],
+    major: isNaN(major) ? undefined : major,
+    minor: isNaN(minor) ? undefined : minor,
+    patch: isNaN(patch) ? undefined : patch,
+    prerelease: match[4],
+  };
+}
+
+/**
+ * This function adds context (pre/post/line) lines to the provided frame
+ *
+ * @param lines string[] containing all lines
+ * @param frame StackFrame that will be mutated
+ * @param linesOfContext number of context lines we want to add pre/post
+ */
+function addContextToFrame(lines, frame, linesOfContext = 5) {
+  // When there is no line number in the frame, attaching context is nonsensical and will even break grouping
+  if (frame.lineno === undefined) {
+    return;
+  }
+
+  const maxLines = lines.length;
+  const sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0);
+
+  frame.pre_context = lines
+    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)
+    .map((line) => snipLine(line, 0));
+
+  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);
+
+  frame.post_context = lines
+    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)
+    .map((line) => snipLine(line, 0));
+}
+
+/**
+ * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object
+ * in question), and marks it captured if not.
+ *
+ * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and
+ * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so
+ * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because
+ * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not
+ * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This
+ * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we
+ * see it.
+ *
+ * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on
+ * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent
+ * object wrapper forms so that this check will always work. However, because we need to flag the exact object which
+ * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification
+ * must be done before the exception captured.
+ *
+ * @param A thrown exception to check or flag as having been seen
+ * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)
+ */
+function checkOrSetAlreadyCaught(exception) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  if (exception && (exception ).__sentry_captured__) {
+    return true;
+  }
+
+  try {
+    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the
+    // `ExtraErrorData` integration
+    addNonEnumerableProperty(exception , '__sentry_captured__', true);
+  } catch (err) {
+    // `exception` is a primitive, so we can't mark it seen
+  }
+
+  return false;
+}
+
+/**
+ * Checks whether the given input is already an array, and if it isn't, wraps it in one.
+ *
+ * @param maybeArray Input to turn into an array, if necessary
+ * @returns The input, if already an array, or an array with the input as the only element, if not
+ */
+function arrayify(maybeArray) {
+  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];
+}
+
+export { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, arrayify, checkOrSetAlreadyCaught, getEventDescription, parseSemver, uuid4 };
+//# sourceMappingURL=misc.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/node.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/node.js
new file mode 100644
index 0000000..49eb7d7
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/node.js
@@ -0,0 +1,66 @@
+import { isBrowserBundle } from './env.js';
+
+/**
+ * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,
+ * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.
+ */
+
+/**
+ * Checks whether we're in the Node.js or Browser environment
+ *
+ * @returns Answer to given question
+ */
+function isNodeEnv() {
+  // explicitly check for browser bundles as those can be optimized statically
+  // by terser/rollup.
+  return (
+    !isBrowserBundle() &&
+    Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'
+  );
+}
+
+/**
+ * Requires a module which is protected against bundler minification.
+ *
+ * @param request The module path to resolve
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+function dynamicRequire(mod, request) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  return mod.require(request);
+}
+
+/**
+ * Helper for dynamically loading module that should work with linked dependencies.
+ * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`
+ * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during
+ * build time. `require.resolve` is also not available in any other way, so we cannot create,
+ * a fake helper like we do with `dynamicRequire`.
+ *
+ * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.
+ * That is to mimic the behavior of `require.resolve` exactly.
+ *
+ * @param moduleName module name to require
+ * @returns possibly required module
+ */
+function loadModule(moduleName) {
+  let mod;
+
+  try {
+    mod = dynamicRequire(module, moduleName);
+  } catch (e) {
+    // no-empty
+  }
+
+  try {
+    const { cwd } = dynamicRequire(module, 'process');
+    mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) ;
+  } catch (e) {
+    // no-empty
+  }
+
+  return mod;
+}
+
+export { dynamicRequire, isNodeEnv, loadModule };
+//# sourceMappingURL=node.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/normalize.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/normalize.js
new file mode 100644
index 0000000..a8a81ee
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/normalize.js
@@ -0,0 +1,267 @@
+import { isNaN, isVueViewModel, isSyntheticEvent } from './is.js';
+import { memoBuilder } from './memo.js';
+import { convertToPlainObject } from './object.js';
+import { getFunctionName } from './stacktrace.js';
+
+/**
+ * Recursively normalizes the given object.
+ *
+ * - Creates a copy to prevent original input mutation
+ * - Skips non-enumerable properties
+ * - When stringifying, calls `toJSON` if implemented
+ * - Removes circular references
+ * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format
+ * - Translates known global objects/classes to a string representations
+ * - Takes care of `Error` object serialization
+ * - Optionally limits depth of final output
+ * - Optionally limits number of properties/elements included in any single object/array
+ *
+ * @param input The object to be normalized.
+ * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)
+ * @param maxProperties The max number of elements or properties to be included in any single array or
+ * object in the normallized output.
+ * @returns A normalized version of the object, or `"**non-serializable**"` if any errors are thrown during normalization.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function normalize(input, depth = 100, maxProperties = +Infinity) {
+  try {
+    // since we're at the outermost level, we don't provide a key
+    return visit('', input, depth, maxProperties);
+  } catch (err) {
+    return { ERROR: `**non-serializable** (${err})` };
+  }
+}
+
+/** JSDoc */
+function normalizeToSize(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  object,
+  // Default Node.js REPL depth
+  depth = 3,
+  // 100kB, as 200kB is max payload size, so half sounds reasonable
+  maxSize = 100 * 1024,
+) {
+  const normalized = normalize(object, depth);
+
+  if (jsonSize(normalized) > maxSize) {
+    return normalizeToSize(object, depth - 1, maxSize);
+  }
+
+  return normalized ;
+}
+
+/**
+ * Visits a node to perform normalization on it
+ *
+ * @param key The key corresponding to the given node
+ * @param value The node to be visited
+ * @param depth Optional number indicating the maximum recursion depth
+ * @param maxProperties Optional maximum number of properties/elements included in any single object/array
+ * @param memo Optional Memo class handling decycling
+ */
+function visit(
+  key,
+  value,
+  depth = +Infinity,
+  maxProperties = +Infinity,
+  memo = memoBuilder(),
+) {
+  const [memoize, unmemoize] = memo;
+
+  // Get the simple cases out of the way first
+  if (
+    value == null || // this matches null and undefined -> eqeq not eqeqeq
+    (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))
+  ) {
+    return value ;
+  }
+
+  const stringified = stringifyValue(key, value);
+
+  // Anything we could potentially dig into more (objects or arrays) will have come back as `"[object XXXX]"`.
+  // Everything else will have already been serialized, so if we don't see that pattern, we're done.
+  if (!stringified.startsWith('[object ')) {
+    return stringified;
+  }
+
+  // From here on, we can assert that `value` is either an object or an array.
+
+  // Do not normalize objects that we know have already been normalized. As a general rule, the
+  // "__sentry_skip_normalization__" property should only be used sparingly and only should only be set on objects that
+  // have already been normalized.
+  if ((value )['__sentry_skip_normalization__']) {
+    return value ;
+  }
+
+  // We can set `__sentry_override_normalization_depth__` on an object to ensure that from there
+  // We keep a certain amount of depth.
+  // This should be used sparingly, e.g. we use it for the redux integration to ensure we get a certain amount of state.
+  const remainingDepth =
+    typeof (value )['__sentry_override_normalization_depth__'] === 'number'
+      ? ((value )['__sentry_override_normalization_depth__'] )
+      : depth;
+
+  // We're also done if we've reached the max depth
+  if (remainingDepth === 0) {
+    // At this point we know `serialized` is a string of the form `"[object XXXX]"`. Clean it up so it's just `"[XXXX]"`.
+    return stringified.replace('object ', '');
+  }
+
+  // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.
+  if (memoize(value)) {
+    return '[Circular ~]';
+  }
+
+  // If the value has a `toJSON` method, we call it to extract more information
+  const valueWithToJSON = value ;
+  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {
+    try {
+      const jsonValue = valueWithToJSON.toJSON();
+      // We need to normalize the return value of `.toJSON()` in case it has circular references
+      return visit('', jsonValue, remainingDepth - 1, maxProperties, memo);
+    } catch (err) {
+      // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)
+    }
+  }
+
+  // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse
+  // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each
+  // property/entry, and keep track of the number of items we add to it.
+  const normalized = (Array.isArray(value) ? [] : {}) ;
+  let numAdded = 0;
+
+  // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant
+  // properties are non-enumerable and otherwise would get missed.
+  const visitable = convertToPlainObject(value );
+
+  for (const visitKey in visitable) {
+    // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.
+    if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {
+      continue;
+    }
+
+    if (numAdded >= maxProperties) {
+      normalized[visitKey] = '[MaxProperties ~]';
+      break;
+    }
+
+    // Recursively visit all the child nodes
+    const visitValue = visitable[visitKey];
+    normalized[visitKey] = visit(visitKey, visitValue, remainingDepth - 1, maxProperties, memo);
+
+    numAdded++;
+  }
+
+  // Once we've visited all the branches, remove the parent from memo storage
+  unmemoize(value);
+
+  // Return accumulated values
+  return normalized;
+}
+
+/* eslint-disable complexity */
+/**
+ * Stringify the given value. Handles various known special values and types.
+ *
+ * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn
+ * the number 1231 into "[Object Number]", nor on `null`, as it will throw.
+ *
+ * @param value The value to stringify
+ * @returns A stringified representation of the given value
+ */
+function stringifyValue(
+  key,
+  // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for
+  // our internal use, it'll do
+  value,
+) {
+  try {
+    if (key === 'domain' && value && typeof value === 'object' && (value )._events) {
+      return '[Domain]';
+    }
+
+    if (key === 'domainEmitter') {
+      return '[DomainEmitter]';
+    }
+
+    // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first
+    // which won't throw if they are not present.
+
+    if (typeof global !== 'undefined' && value === global) {
+      return '[Global]';
+    }
+
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof window !== 'undefined' && value === window) {
+      return '[Window]';
+    }
+
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof document !== 'undefined' && value === document) {
+      return '[Document]';
+    }
+
+    if (isVueViewModel(value)) {
+      return '[VueViewModel]';
+    }
+
+    // React's SyntheticEvent thingy
+    if (isSyntheticEvent(value)) {
+      return '[SyntheticEvent]';
+    }
+
+    if (typeof value === 'number' && value !== value) {
+      return '[NaN]';
+    }
+
+    if (typeof value === 'function') {
+      return `[Function: ${getFunctionName(value)}]`;
+    }
+
+    if (typeof value === 'symbol') {
+      return `[${String(value)}]`;
+    }
+
+    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion
+    if (typeof value === 'bigint') {
+      return `[BigInt: ${String(value)}]`;
+    }
+
+    // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting
+    // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as
+    // `"[object Object]"`. If we instead look at the constructor's name (which is the same as the name of the class),
+    // we can make sure that only plain objects come out that way.
+    const objName = getConstructorName(value);
+
+    // Handle HTML Elements
+    if (/^HTML(\w*)Element$/.test(objName)) {
+      return `[HTMLElement: ${objName}]`;
+    }
+
+    return `[object ${objName}]`;
+  } catch (err) {
+    return `**non-serializable** (${err})`;
+  }
+}
+/* eslint-enable complexity */
+
+function getConstructorName(value) {
+  const prototype = Object.getPrototypeOf(value);
+
+  return prototype ? prototype.constructor.name : 'null prototype';
+}
+
+/** Calculates bytes size of input string */
+function utf8Length(value) {
+  // eslint-disable-next-line no-bitwise
+  return ~-encodeURI(value).split(/%..|./).length;
+}
+
+/** Calculates bytes size of input object */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function jsonSize(value) {
+  return utf8Length(JSON.stringify(value));
+}
+
+export { normalize, normalizeToSize, visit as walk };
+//# sourceMappingURL=normalize.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/object.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/object.js
new file mode 100644
index 0000000..58706b7
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/object.js
@@ -0,0 +1,281 @@
+import { htmlTreeAsString } from './browser.js';
+import { isError, isEvent, isInstanceOf, isElement, isPlainObject, isPrimitive } from './is.js';
+import { logger } from './logger.js';
+import { truncate } from './string.js';
+
+/**
+ * Replace a method in an object with a wrapped version of itself.
+ *
+ * @param source An object that contains a method to be wrapped.
+ * @param name The name of the method to be wrapped.
+ * @param replacementFactory A higher-order function that takes the original version of the given method and returns a
+ * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to
+ * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other
+ * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.
+ * @returns void
+ */
+function fill(source, name, replacementFactory) {
+  if (!(name in source)) {
+    return;
+  }
+
+  const original = source[name] ;
+  const wrapped = replacementFactory(original) ;
+
+  // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work
+  // otherwise it'll throw "TypeError: Object.defineProperties called on non-object"
+  if (typeof wrapped === 'function') {
+    markFunctionWrapped(wrapped, original);
+  }
+
+  source[name] = wrapped;
+}
+
+/**
+ * Defines a non-enumerable property on the given object.
+ *
+ * @param obj The object on which to set the property
+ * @param name The name of the property to be set
+ * @param value The value to which to set the property
+ */
+function addNonEnumerableProperty(obj, name, value) {
+  try {
+    Object.defineProperty(obj, name, {
+      // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it
+      value: value,
+      writable: true,
+      configurable: true,
+    });
+  } catch (o_O) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Failed to add non-enumerable property "${name}" to object`, obj);
+  }
+}
+
+/**
+ * Remembers the original function on the wrapped function and
+ * patches up the prototype.
+ *
+ * @param wrapped the wrapper function
+ * @param original the original function that gets wrapped
+ */
+function markFunctionWrapped(wrapped, original) {
+  try {
+    const proto = original.prototype || {};
+    wrapped.prototype = original.prototype = proto;
+    addNonEnumerableProperty(wrapped, '__sentry_original__', original);
+  } catch (o_O) {} // eslint-disable-line no-empty
+}
+
+/**
+ * This extracts the original function if available.  See
+ * `markFunctionWrapped` for more information.
+ *
+ * @param func the function to unwrap
+ * @returns the unwrapped version of the function if available.
+ */
+function getOriginalFunction(func) {
+  return func.__sentry_original__;
+}
+
+/**
+ * Encodes given object into url-friendly format
+ *
+ * @param object An object that contains serializable values
+ * @returns string Encoded
+ */
+function urlEncode(object) {
+  return Object.keys(object)
+    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`)
+    .join('&');
+}
+
+/**
+ * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their
+ * non-enumerable properties attached.
+ *
+ * @param value Initial source that we have to transform in order for it to be usable by the serializer
+ * @returns An Event or Error turned into an object - or the value argurment itself, when value is neither an Event nor
+ *  an Error.
+ */
+function convertToPlainObject(value)
+
+ {
+  if (isError(value)) {
+    return {
+      message: value.message,
+      name: value.name,
+      stack: value.stack,
+      ...getOwnProperties(value),
+    };
+  } else if (isEvent(value)) {
+    const newObj
+
+ = {
+      type: value.type,
+      target: serializeEventTarget(value.target),
+      currentTarget: serializeEventTarget(value.currentTarget),
+      ...getOwnProperties(value),
+    };
+
+    if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {
+      newObj.detail = value.detail;
+    }
+
+    return newObj;
+  } else {
+    return value;
+  }
+}
+
+/** Creates a string representation of the target of an `Event` object */
+function serializeEventTarget(target) {
+  try {
+    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);
+  } catch (_oO) {
+    return '<unknown>';
+  }
+}
+
+/** Filters out all but an object's own properties */
+function getOwnProperties(obj) {
+  if (typeof obj === 'object' && obj !== null) {
+    const extractedProps = {};
+    for (const property in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, property)) {
+        extractedProps[property] = (obj )[property];
+      }
+    }
+    return extractedProps;
+  } else {
+    return {};
+  }
+}
+
+/**
+ * Given any captured exception, extract its keys and create a sorted
+ * and truncated list that will be used inside the event message.
+ * eg. `Non-error exception captured with keys: foo, bar, baz`
+ */
+function extractExceptionKeysForMessage(exception, maxLength = 40) {
+  const keys = Object.keys(convertToPlainObject(exception));
+  keys.sort();
+
+  if (!keys.length) {
+    return '[object has no keys]';
+  }
+
+  if (keys[0].length >= maxLength) {
+    return truncate(keys[0], maxLength);
+  }
+
+  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {
+    const serialized = keys.slice(0, includedKeys).join(', ');
+    if (serialized.length > maxLength) {
+      continue;
+    }
+    if (includedKeys === keys.length) {
+      return serialized;
+    }
+    return truncate(serialized, maxLength);
+  }
+
+  return '';
+}
+
+/**
+ * Given any object, return a new object having removed all fields whose value was `undefined`.
+ * Works recursively on objects and arrays.
+ *
+ * Attention: This function keeps circular references in the returned object.
+ */
+function dropUndefinedKeys(inputValue) {
+  // This map keeps track of what already visited nodes map to.
+  // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular
+  // references as the input object.
+  const memoizationMap = new Map();
+
+  // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API
+  return _dropUndefinedKeys(inputValue, memoizationMap);
+}
+
+function _dropUndefinedKeys(inputValue, memoizationMap) {
+  if (isPlainObject(inputValue)) {
+    // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object
+    const memoVal = memoizationMap.get(inputValue);
+    if (memoVal !== undefined) {
+      return memoVal ;
+    }
+
+    const returnValue = {};
+    // Store the mapping of this value in case we visit it again, in case of circular data
+    memoizationMap.set(inputValue, returnValue);
+
+    for (const key of Object.keys(inputValue)) {
+      if (typeof inputValue[key] !== 'undefined') {
+        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);
+      }
+    }
+
+    return returnValue ;
+  }
+
+  if (Array.isArray(inputValue)) {
+    // If this node has already been visited due to a circular reference, return the array it was mapped to in the new object
+    const memoVal = memoizationMap.get(inputValue);
+    if (memoVal !== undefined) {
+      return memoVal ;
+    }
+
+    const returnValue = [];
+    // Store the mapping of this value in case we visit it again, in case of circular data
+    memoizationMap.set(inputValue, returnValue);
+
+    inputValue.forEach((item) => {
+      returnValue.push(_dropUndefinedKeys(item, memoizationMap));
+    });
+
+    return returnValue ;
+  }
+
+  return inputValue;
+}
+
+/**
+ * Ensure that something is an object.
+ *
+ * Turns `undefined` and `null` into `String`s and all other primitives into instances of their respective wrapper
+ * classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.
+ *
+ * @param wat The subject of the objectification
+ * @returns A version of `wat` which can safely be used with `Object` class methods
+ */
+function objectify(wat) {
+  let objectified;
+  switch (true) {
+    case wat === undefined || wat === null:
+      objectified = new String(wat);
+      break;
+
+    // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason
+    // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as
+    // an object in order to wrap it.
+    case typeof wat === 'symbol' || typeof wat === 'bigint':
+      objectified = Object(wat);
+      break;
+
+    // this will catch the remaining primitives: `String`, `Number`, and `Boolean`
+    case isPrimitive(wat):
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      objectified = new (wat ).constructor(wat);
+      break;
+
+    // by process of elimination, at this point we know that `wat` must already be an object
+    default:
+      objectified = wat;
+      break;
+  }
+  return objectified;
+}
+
+export { addNonEnumerableProperty, convertToPlainObject, dropUndefinedKeys, extractExceptionKeysForMessage, fill, getOriginalFunction, markFunctionWrapped, objectify, urlEncode };
+//# sourceMappingURL=object.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/promisebuffer.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/promisebuffer.js
new file mode 100644
index 0000000..fea1ed0
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/promisebuffer.js
@@ -0,0 +1,102 @@
+import { SentryError } from './error.js';
+import { rejectedSyncPromise, SyncPromise, resolvedSyncPromise } from './syncpromise.js';
+
+/**
+ * Creates an new PromiseBuffer object with the specified limit
+ * @param limit max number of promises that can be stored in the buffer
+ */
+function makePromiseBuffer(limit) {
+  const buffer = [];
+
+  function isReady() {
+    return limit === undefined || buffer.length < limit;
+  }
+
+  /**
+   * Remove a promise from the queue.
+   *
+   * @param task Can be any PromiseLike<T>
+   * @returns Removed promise.
+   */
+  function remove(task) {
+    return buffer.splice(buffer.indexOf(task), 1)[0];
+  }
+
+  /**
+   * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.
+   *
+   * @param taskProducer A function producing any PromiseLike<T>; In previous versions this used to be `task:
+   *        PromiseLike<T>`, but under that model, Promises were instantly created on the call-site and their executor
+   *        functions therefore ran immediately. Thus, even if the buffer was full, the action still happened. By
+   *        requiring the promise to be wrapped in a function, we can defer promise creation until after the buffer
+   *        limit check.
+   * @returns The original promise.
+   */
+  function add(taskProducer) {
+    if (!isReady()) {
+      return rejectedSyncPromise(new SentryError('Not adding Promise because buffer limit was reached.'));
+    }
+
+    // start the task and add its promise to the queue
+    const task = taskProducer();
+    if (buffer.indexOf(task) === -1) {
+      buffer.push(task);
+    }
+    void task
+      .then(() => remove(task))
+      // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`
+      // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't
+      // have promises, so TS has to polyfill when down-compiling.)
+      .then(null, () =>
+        remove(task).then(null, () => {
+          // We have to add another catch here because `remove()` starts a new promise chain.
+        }),
+      );
+    return task;
+  }
+
+  /**
+   * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.
+   *
+   * @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or
+   * not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to
+   * `true`.
+   * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and
+   * `false` otherwise
+   */
+  function drain(timeout) {
+    return new SyncPromise((resolve, reject) => {
+      let counter = buffer.length;
+
+      if (!counter) {
+        return resolve(true);
+      }
+
+      // wait for `timeout` ms and then resolve to `false` (if not cancelled first)
+      const capturedSetTimeout = setTimeout(() => {
+        if (timeout && timeout > 0) {
+          resolve(false);
+        }
+      }, timeout);
+
+      // if all promises resolve in time, cancel the timer and resolve to `true`
+      buffer.forEach(item => {
+        void resolvedSyncPromise(item).then(() => {
+          if (!--counter) {
+            clearTimeout(capturedSetTimeout);
+            resolve(true);
+          }
+        }, reject);
+      });
+    });
+  }
+
+  return {
+    $: buffer,
+    add,
+    drain,
+  };
+}
+
+export { makePromiseBuffer };
+//# sourceMappingURL=promisebuffer.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/ratelimit.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/ratelimit.js
new file mode 100644
index 0000000..becfdf0
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/ratelimit.js
@@ -0,0 +1,97 @@
+// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend
+
+const DEFAULT_RETRY_AFTER = 60 * 1000; // 60 seconds
+
+/**
+ * Extracts Retry-After value from the request header or returns default value
+ * @param header string representation of 'Retry-After' header
+ * @param now current unix timestamp
+ *
+ */
+function parseRetryAfterHeader(header, now = Date.now()) {
+  const headerDelay = parseInt(`${header}`, 10);
+  if (!isNaN(headerDelay)) {
+    return headerDelay * 1000;
+  }
+
+  const headerDate = Date.parse(`${header}`);
+  if (!isNaN(headerDate)) {
+    return headerDate - now;
+  }
+
+  return DEFAULT_RETRY_AFTER;
+}
+
+/**
+ * Gets the time that the given category is disabled until for rate limiting.
+ * In case no category-specific limit is set but a general rate limit across all categories is active,
+ * that time is returned.
+ *
+ * @return the time in ms that the category is disabled until or 0 if there's no active rate limit.
+ */
+function disabledUntil(limits, category) {
+  return limits[category] || limits.all || 0;
+}
+
+/**
+ * Checks if a category is rate limited
+ */
+function isRateLimited(limits, category, now = Date.now()) {
+  return disabledUntil(limits, category) > now;
+}
+
+/**
+ * Update ratelimits from incoming headers.
+ *
+ * @return the updated RateLimits object.
+ */
+function updateRateLimits(
+  limits,
+  { statusCode, headers },
+  now = Date.now(),
+) {
+  const updatedRateLimits = {
+    ...limits,
+  };
+
+  // "The name is case-insensitive."
+  // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get
+  const rateLimitHeader = headers && headers['x-sentry-rate-limits'];
+  const retryAfterHeader = headers && headers['retry-after'];
+
+  if (rateLimitHeader) {
+    /**
+     * rate limit headers are of the form
+     *     <header>,<header>,..
+     * where each <header> is of the form
+     *     <retry_after>: <categories>: <scope>: <reason_code>
+     * where
+     *     <retry_after> is a delay in seconds
+     *     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form
+     *         <category>;<category>;...
+     *     <scope> is what's being limited (org, project, or key) - ignored by SDK
+     *     <reason_code> is an arbitrary string like "org_quota" - ignored by SDK
+     */
+    for (const limit of rateLimitHeader.trim().split(',')) {
+      const [retryAfter, categories] = limit.split(':', 2);
+      const headerDelay = parseInt(retryAfter, 10);
+      const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default
+      if (!categories) {
+        updatedRateLimits.all = now + delay;
+      } else {
+        for (const category of categories.split(';')) {
+          updatedRateLimits[category] = now + delay;
+        }
+      }
+    }
+  } else if (retryAfterHeader) {
+    updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);
+  } else if (statusCode === 429) {
+    updatedRateLimits.all = now + 60 * 1000;
+  }
+
+  return updatedRateLimits;
+}
+
+export { DEFAULT_RETRY_AFTER, disabledUntil, isRateLimited, parseRetryAfterHeader, updateRateLimits };
+//# sourceMappingURL=ratelimit.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/stacktrace.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/stacktrace.js
new file mode 100644
index 0000000..4ea2d17
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/stacktrace.js
@@ -0,0 +1,147 @@
+import { node } from './node-stack-trace.js';
+
+const STACKTRACE_FRAME_LIMIT = 50;
+// Used to sanitize webpack (error: *) wrapped stack errors
+const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
+const STRIP_FRAME_REGEXP = /captureMessage|captureException/;
+
+/**
+ * Creates a stack parser with the supplied line parsers
+ *
+ * StackFrames are returned in the correct order for Sentry Exception
+ * frames and with Sentry SDK internal frames removed from the top and bottom
+ *
+ */
+function createStackParser(...parsers) {
+  const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);
+
+  return (stack, skipFirst = 0) => {
+    const frames = [];
+    const lines = stack.split('\n');
+
+    for (let i = skipFirst; i < lines.length; i++) {
+      const line = lines[i];
+      // Ignore lines over 1kb as they are unlikely to be stack frames.
+      // Many of the regular expressions use backtracking which results in run time that increases exponentially with
+      // input size. Huge strings can result in hangs/Denial of Service:
+      // https://github.com/getsentry/sentry-javascript/issues/2286
+      if (line.length > 1024) {
+        continue;
+      }
+
+      // https://github.com/getsentry/sentry-javascript/issues/5459
+      // Remove webpack (error: *) wrappers
+      const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;
+
+      // https://github.com/getsentry/sentry-javascript/issues/7813
+      // Skip Error: lines
+      if (cleanedLine.match(/\S*Error: /)) {
+        continue;
+      }
+
+      for (const parser of sortedParsers) {
+        const frame = parser(cleanedLine);
+
+        if (frame) {
+          frames.push(frame);
+          break;
+        }
+      }
+
+      if (frames.length >= STACKTRACE_FRAME_LIMIT) {
+        break;
+      }
+    }
+
+    return stripSentryFramesAndReverse(frames);
+  };
+}
+
+/**
+ * Gets a stack parser implementation from Options.stackParser
+ * @see Options
+ *
+ * If options contains an array of line parsers, it is converted into a parser
+ */
+function stackParserFromStackParserOptions(stackParser) {
+  if (Array.isArray(stackParser)) {
+    return createStackParser(...stackParser);
+  }
+  return stackParser;
+}
+
+/**
+ * Removes Sentry frames from the top and bottom of the stack if present and enforces a limit of max number of frames.
+ * Assumes stack input is ordered from top to bottom and returns the reverse representation so call site of the
+ * function that caused the crash is the last frame in the array.
+ * @hidden
+ */
+function stripSentryFramesAndReverse(stack) {
+  if (!stack.length) {
+    return [];
+  }
+
+  const localStack = Array.from(stack);
+
+  // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)
+  if (/sentryWrapped/.test(localStack[localStack.length - 1].function || '')) {
+    localStack.pop();
+  }
+
+  // Reversing in the middle of the procedure allows us to just pop the values off the stack
+  localStack.reverse();
+
+  // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)
+  if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {
+    localStack.pop();
+
+    // When using synthetic events, we will have a 2 levels deep stack, as `new Error('Sentry syntheticException')`
+    // is produced within the hub itself, making it:
+    //
+    //   Sentry.captureException()
+    //   getCurrentHub().captureException()
+    //
+    // instead of just the top `Sentry` call itself.
+    // This forces us to possibly strip an additional frame in the exact same was as above.
+    if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {
+      localStack.pop();
+    }
+  }
+
+  return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map(frame => ({
+    ...frame,
+    filename: frame.filename || localStack[localStack.length - 1].filename,
+    function: frame.function || '?',
+  }));
+}
+
+const defaultFunctionName = '<anonymous>';
+
+/**
+ * Safely extract function name from itself
+ */
+function getFunctionName(fn) {
+  try {
+    if (!fn || typeof fn !== 'function') {
+      return defaultFunctionName;
+    }
+    return fn.name || defaultFunctionName;
+  } catch (e) {
+    // Just accessing custom props in some Selenium environments
+    // can cause a "Permission denied" exception (see raven-js#495).
+    return defaultFunctionName;
+  }
+}
+
+/**
+ * Node.js stack line parser
+ *
+ * This is in @sentry/utils so it can be used from the Electron SDK in the browser for when `nodeIntegration == true`.
+ * This allows it to be used without referencing or importing any node specific code which causes bundlers to complain
+ */
+function nodeStackLineParser(getModule) {
+  return [90, node(getModule)];
+}
+
+export { createStackParser, getFunctionName, nodeStackLineParser, stackParserFromStackParserOptions, stripSentryFramesAndReverse };
+//# sourceMappingURL=stacktrace.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/string.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/string.js
new file mode 100644
index 0000000..b6d3514
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/string.js
@@ -0,0 +1,141 @@
+import { isVueViewModel, isString, isRegExp } from './is.js';
+
+/**
+ * Truncates given string to the maximum characters count
+ *
+ * @param str An object that contains serializable values
+ * @param max Maximum number of characters in truncated string (0 = unlimited)
+ * @returns string Encoded
+ */
+function truncate(str, max = 0) {
+  if (typeof str !== 'string' || max === 0) {
+    return str;
+  }
+  return str.length <= max ? str : `${str.slice(0, max)}...`;
+}
+
+/**
+ * This is basically just `trim_line` from
+ * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67
+ *
+ * @param str An object that contains serializable values
+ * @param max Maximum number of characters in truncated string
+ * @returns string Encoded
+ */
+function snipLine(line, colno) {
+  let newLine = line;
+  const lineLength = newLine.length;
+  if (lineLength <= 150) {
+    return newLine;
+  }
+  if (colno > lineLength) {
+    // eslint-disable-next-line no-param-reassign
+    colno = lineLength;
+  }
+
+  let start = Math.max(colno - 60, 0);
+  if (start < 5) {
+    start = 0;
+  }
+
+  let end = Math.min(start + 140, lineLength);
+  if (end > lineLength - 5) {
+    end = lineLength;
+  }
+  if (end === lineLength) {
+    start = Math.max(end - 140, 0);
+  }
+
+  newLine = newLine.slice(start, end);
+  if (start > 0) {
+    newLine = `'{snip} ${newLine}`;
+  }
+  if (end < lineLength) {
+    newLine += ' {snip}';
+  }
+
+  return newLine;
+}
+
+/**
+ * Join values in array
+ * @param input array of values to be joined together
+ * @param delimiter string to be placed in-between values
+ * @returns Joined values
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function safeJoin(input, delimiter) {
+  if (!Array.isArray(input)) {
+    return '';
+  }
+
+  const output = [];
+  // eslint-disable-next-line @typescript-eslint/prefer-for-of
+  for (let i = 0; i < input.length; i++) {
+    const value = input[i];
+    try {
+      // This is a hack to fix a Vue3-specific bug that causes an infinite loop of
+      // console warnings. This happens when a Vue template is rendered with
+      // an undeclared variable, which we try to stringify, ultimately causing
+      // Vue to issue another warning which repeats indefinitely.
+      // see: https://github.com/getsentry/sentry-javascript/pull/8981
+      if (isVueViewModel(value)) {
+        output.push('[VueViewModel]');
+      } else {
+        output.push(String(value));
+      }
+    } catch (e) {
+      output.push('[value cannot be serialized]');
+    }
+  }
+
+  return output.join(delimiter);
+}
+
+/**
+ * Checks if the given value matches a regex or string
+ *
+ * @param value The string to test
+ * @param pattern Either a regex or a string against which `value` will be matched
+ * @param requireExactStringMatch If true, `value` must match `pattern` exactly. If false, `value` will match
+ * `pattern` if it contains `pattern`. Only applies to string-type patterns.
+ */
+function isMatchingPattern(
+  value,
+  pattern,
+  requireExactStringMatch = false,
+) {
+  if (!isString(value)) {
+    return false;
+  }
+
+  if (isRegExp(pattern)) {
+    return pattern.test(value);
+  }
+  if (isString(pattern)) {
+    return requireExactStringMatch ? value === pattern : value.includes(pattern);
+  }
+
+  return false;
+}
+
+/**
+ * Test the given string against an array of strings and regexes. By default, string matching is done on a
+ * substring-inclusion basis rather than a strict equality basis
+ *
+ * @param testString The string to test
+ * @param patterns The patterns against which to test the string
+ * @param requireExactStringMatch If true, `testString` must match one of the given string patterns exactly in order to
+ * count. If false, `testString` will match a string pattern if it contains that pattern.
+ * @returns
+ */
+function stringMatchesSomePattern(
+  testString,
+  patterns = [],
+  requireExactStringMatch = false,
+) {
+  return patterns.some(pattern => isMatchingPattern(testString, pattern, requireExactStringMatch));
+}
+
+export { isMatchingPattern, safeJoin, snipLine, stringMatchesSomePattern, truncate };
+//# sourceMappingURL=string.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/supports.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/supports.js
new file mode 100644
index 0000000..8e0d9b2
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/supports.js
@@ -0,0 +1,161 @@
+import { logger } from './logger.js';
+import { getGlobalObject } from './worldwide.js';
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+/**
+ * Tells whether current environment supports ErrorEvent objects
+ * {@link supportsErrorEvent}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsErrorEvent() {
+  try {
+    new ErrorEvent('');
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Tells whether current environment supports DOMError objects
+ * {@link supportsDOMError}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsDOMError() {
+  try {
+    // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':
+    // 1 argument required, but only 0 present.
+    // @ts-expect-error It really needs 1 argument, not 0.
+    new DOMError('');
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Tells whether current environment supports DOMException objects
+ * {@link supportsDOMException}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsDOMException() {
+  try {
+    new DOMException('');
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Tells whether current environment supports Fetch API
+ * {@link supportsFetch}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsFetch() {
+  if (!('fetch' in WINDOW)) {
+    return false;
+  }
+
+  try {
+    new Headers();
+    new Request('http://www.example.com');
+    new Response();
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+/**
+ * isNativeFetch checks if the given function is a native implementation of fetch()
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+function isNativeFetch(func) {
+  return func && /^function fetch\(\)\s+\{\s+\[native code\]\s+\}$/.test(func.toString());
+}
+
+/**
+ * Tells whether current environment supports Fetch API natively
+ * {@link supportsNativeFetch}.
+ *
+ * @returns true if `window.fetch` is natively implemented, false otherwise
+ */
+function supportsNativeFetch() {
+  if (!supportsFetch()) {
+    return false;
+  }
+
+  // Fast path to avoid DOM I/O
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  if (isNativeFetch(WINDOW.fetch)) {
+    return true;
+  }
+
+  // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)
+  // so create a "pure" iframe to see if that has native fetch
+  let result = false;
+  const doc = WINDOW.document;
+  // eslint-disable-next-line deprecation/deprecation
+  if (doc && typeof (doc.createElement ) === 'function') {
+    try {
+      const sandbox = doc.createElement('iframe');
+      sandbox.hidden = true;
+      doc.head.appendChild(sandbox);
+      if (sandbox.contentWindow && sandbox.contentWindow.fetch) {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        result = isNativeFetch(sandbox.contentWindow.fetch);
+      }
+      doc.head.removeChild(sandbox);
+    } catch (err) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Tells whether current environment supports ReportingObserver API
+ * {@link supportsReportingObserver}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsReportingObserver() {
+  return 'ReportingObserver' in WINDOW;
+}
+
+/**
+ * Tells whether current environment supports Referrer Policy API
+ * {@link supportsReferrerPolicy}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsReferrerPolicy() {
+  // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'
+  // (see https://caniuse.com/#feat=referrer-policy),
+  // it doesn't. And it throws an exception instead of ignoring this parameter...
+  // REF: https://github.com/getsentry/raven-js/issues/1233
+
+  if (!supportsFetch()) {
+    return false;
+  }
+
+  try {
+    new Request('_', {
+      referrerPolicy: 'origin' ,
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+export { isNativeFetch, supportsDOMError, supportsDOMException, supportsErrorEvent, supportsFetch, supportsNativeFetch, supportsReferrerPolicy, supportsReportingObserver };
+//# sourceMappingURL=supports.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/syncpromise.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/syncpromise.js
new file mode 100644
index 0000000..feac32f
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/syncpromise.js
@@ -0,0 +1,192 @@
+import { isThenable } from './is.js';
+
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+
+/** SyncPromise internal states */
+var States; (function (States) {
+  /** Pending */
+  const PENDING = 0; States[States["PENDING"] = PENDING] = "PENDING";
+  /** Resolved / OK */
+  const RESOLVED = 1; States[States["RESOLVED"] = RESOLVED] = "RESOLVED";
+  /** Rejected / Error */
+  const REJECTED = 2; States[States["REJECTED"] = REJECTED] = "REJECTED";
+})(States || (States = {}));
+
+// Overloads so we can call resolvedSyncPromise without arguments and generic argument
+
+/**
+ * Creates a resolved sync promise.
+ *
+ * @param value the value to resolve the promise with
+ * @returns the resolved sync promise
+ */
+function resolvedSyncPromise(value) {
+  return new SyncPromise(resolve => {
+    resolve(value);
+  });
+}
+
+/**
+ * Creates a rejected sync promise.
+ *
+ * @param value the value to reject the promise with
+ * @returns the rejected sync promise
+ */
+function rejectedSyncPromise(reason) {
+  return new SyncPromise((_, reject) => {
+    reject(reason);
+  });
+}
+
+/**
+ * Thenable class that behaves like a Promise and follows it's interface
+ * but is not async internally
+ */
+class SyncPromise {
+
+   constructor(
+    executor,
+  ) {SyncPromise.prototype.__init.call(this);SyncPromise.prototype.__init2.call(this);SyncPromise.prototype.__init3.call(this);SyncPromise.prototype.__init4.call(this);
+    this._state = States.PENDING;
+    this._handlers = [];
+
+    try {
+      executor(this._resolve, this._reject);
+    } catch (e) {
+      this._reject(e);
+    }
+  }
+
+  /** JSDoc */
+   then(
+    onfulfilled,
+    onrejected,
+  ) {
+    return new SyncPromise((resolve, reject) => {
+      this._handlers.push([
+        false,
+        result => {
+          if (!onfulfilled) {
+            // TODO: ¯\_(ツ)_/¯
+            // TODO: FIXME
+            resolve(result );
+          } else {
+            try {
+              resolve(onfulfilled(result));
+            } catch (e) {
+              reject(e);
+            }
+          }
+        },
+        reason => {
+          if (!onrejected) {
+            reject(reason);
+          } else {
+            try {
+              resolve(onrejected(reason));
+            } catch (e) {
+              reject(e);
+            }
+          }
+        },
+      ]);
+      this._executeHandlers();
+    });
+  }
+
+  /** JSDoc */
+   catch(
+    onrejected,
+  ) {
+    return this.then(val => val, onrejected);
+  }
+
+  /** JSDoc */
+   finally(onfinally) {
+    return new SyncPromise((resolve, reject) => {
+      let val;
+      let isRejected;
+
+      return this.then(
+        value => {
+          isRejected = false;
+          val = value;
+          if (onfinally) {
+            onfinally();
+          }
+        },
+        reason => {
+          isRejected = true;
+          val = reason;
+          if (onfinally) {
+            onfinally();
+          }
+        },
+      ).then(() => {
+        if (isRejected) {
+          reject(val);
+          return;
+        }
+
+        resolve(val );
+      });
+    });
+  }
+
+  /** JSDoc */
+    __init() {this._resolve = (value) => {
+    this._setResult(States.RESOLVED, value);
+  };}
+
+  /** JSDoc */
+    __init2() {this._reject = (reason) => {
+    this._setResult(States.REJECTED, reason);
+  };}
+
+  /** JSDoc */
+    __init3() {this._setResult = (state, value) => {
+    if (this._state !== States.PENDING) {
+      return;
+    }
+
+    if (isThenable(value)) {
+      void (value ).then(this._resolve, this._reject);
+      return;
+    }
+
+    this._state = state;
+    this._value = value;
+
+    this._executeHandlers();
+  };}
+
+  /** JSDoc */
+    __init4() {this._executeHandlers = () => {
+    if (this._state === States.PENDING) {
+      return;
+    }
+
+    const cachedHandlers = this._handlers.slice();
+    this._handlers = [];
+
+    cachedHandlers.forEach(handler => {
+      if (handler[0]) {
+        return;
+      }
+
+      if (this._state === States.RESOLVED) {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        handler[1](this._value );
+      }
+
+      if (this._state === States.REJECTED) {
+        handler[2](this._value);
+      }
+
+      handler[0] = true;
+    });
+  };}
+}
+
+export { SyncPromise, rejectedSyncPromise, resolvedSyncPromise };
+//# sourceMappingURL=syncpromise.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/time.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/time.js
new file mode 100644
index 0000000..2703ed2
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/time.js
@@ -0,0 +1,183 @@
+import { isNodeEnv, dynamicRequire } from './node.js';
+import { getGlobalObject } from './worldwide.js';
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+/**
+ * An object that can return the current timestamp in seconds since the UNIX epoch.
+ */
+
+/**
+ * A TimestampSource implementation for environments that do not support the Performance Web API natively.
+ *
+ * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier
+ * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It
+ * is more obvious to explain "why does my span have negative duration" than "why my spans have zero duration".
+ */
+const dateTimestampSource = {
+  nowSeconds: () => Date.now() / 1000,
+};
+
+/**
+ * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}
+ * for accessing a high-resolution monotonic clock.
+ */
+
+/**
+ * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not
+ * support the API.
+ *
+ * Wrapping the native API works around differences in behavior from different browsers.
+ */
+function getBrowserPerformance() {
+  const { performance } = WINDOW;
+  if (!performance || !performance.now) {
+    return undefined;
+  }
+
+  // Replace performance.timeOrigin with our own timeOrigin based on Date.now().
+  //
+  // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +
+  // performance.now() gives a date arbitrarily in the past.
+  //
+  // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is
+  // undefined.
+  //
+  // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to
+  // interact with data coming out of performance entries.
+  //
+  // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that
+  // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes
+  // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have
+  // observed skews that can be as long as days, weeks or months.
+  //
+  // See https://github.com/getsentry/sentry-javascript/issues/2590.
+  //
+  // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload
+  // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation
+  // transactions of long-lived web pages.
+  const timeOrigin = Date.now() - performance.now();
+
+  return {
+    now: () => performance.now(),
+    timeOrigin,
+  };
+}
+
+/**
+ * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't
+ * implement the API.
+ */
+function getNodePerformance() {
+  try {
+    const perfHooks = dynamicRequire(module, 'perf_hooks') ;
+    return perfHooks.performance;
+  } catch (_) {
+    return undefined;
+  }
+}
+
+/**
+ * The Performance API implementation for the current platform, if available.
+ */
+const platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();
+
+const timestampSource =
+  platformPerformance === undefined
+    ? dateTimestampSource
+    : {
+        nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,
+      };
+
+/**
+ * Returns a timestamp in seconds since the UNIX epoch using the Date API.
+ */
+const dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);
+
+/**
+ * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the
+ * availability of the Performance API.
+ *
+ * See `usingPerformanceAPI` to test whether the Performance API is used.
+ *
+ * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is
+ * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The
+ * skew can grow to arbitrary amounts like days, weeks or months.
+ * See https://github.com/getsentry/sentry-javascript/issues/2590.
+ */
+const timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);
+
+/**
+ * Re-exported with an old name for backwards-compatibility.
+ * TODO (v8): Remove this
+ *
+ * @deprecated Use `timestampInSeconds` instead.
+ */
+const timestampWithMs = timestampInSeconds;
+
+/**
+ * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.
+ */
+const usingPerformanceAPI = platformPerformance !== undefined;
+
+/**
+ * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.
+ */
+let _browserPerformanceTimeOriginMode;
+
+/**
+ * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the
+ * performance API is available.
+ */
+const browserPerformanceTimeOrigin = (() => {
+  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or
+  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin
+  // data as reliable if they are within a reasonable threshold of the current time.
+
+  const { performance } = WINDOW;
+  if (!performance || !performance.now) {
+    _browserPerformanceTimeOriginMode = 'none';
+    return undefined;
+  }
+
+  const threshold = 3600 * 1000;
+  const performanceNow = performance.now();
+  const dateNow = Date.now();
+
+  // if timeOrigin isn't available set delta to threshold so it isn't used
+  const timeOriginDelta = performance.timeOrigin
+    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)
+    : threshold;
+  const timeOriginIsReliable = timeOriginDelta < threshold;
+
+  // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin
+  // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.
+  // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always
+  // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the
+  // Date API.
+  // eslint-disable-next-line deprecation/deprecation
+  const navigationStart = performance.timing && performance.timing.navigationStart;
+  const hasNavigationStart = typeof navigationStart === 'number';
+  // if navigationStart isn't available set delta to threshold so it isn't used
+  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;
+  const navigationStartIsReliable = navigationStartDelta < threshold;
+
+  if (timeOriginIsReliable || navigationStartIsReliable) {
+    // Use the more reliable time origin
+    if (timeOriginDelta <= navigationStartDelta) {
+      _browserPerformanceTimeOriginMode = 'timeOrigin';
+      return performance.timeOrigin;
+    } else {
+      _browserPerformanceTimeOriginMode = 'navigationStart';
+      return navigationStart;
+    }
+  }
+
+  // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.
+  _browserPerformanceTimeOriginMode = 'dateNow';
+  return dateNow;
+})();
+
+export { _browserPerformanceTimeOriginMode, browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds, timestampWithMs, usingPerformanceAPI };
+//# sourceMappingURL=time.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/tracing.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/tracing.js
new file mode 100644
index 0000000..4928f07
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/tracing.js
@@ -0,0 +1,94 @@
+import { baggageHeaderToDynamicSamplingContext } from './baggage.js';
+import { uuid4 } from './misc.js';
+
+const TRACEPARENT_REGEXP = new RegExp(
+  '^[ \\t]*' + // whitespace
+    '([0-9a-f]{32})?' + // trace_id
+    '-?([0-9a-f]{16})?' + // span_id
+    '-?([01])?' + // sampled
+    '[ \\t]*$', // whitespace
+);
+
+/**
+ * Extract transaction context data from a `sentry-trace` header.
+ *
+ * @param traceparent Traceparent string
+ *
+ * @returns Object containing data from the header, or undefined if traceparent string is malformed
+ */
+function extractTraceparentData(traceparent) {
+  if (!traceparent) {
+    return undefined;
+  }
+
+  const matches = traceparent.match(TRACEPARENT_REGEXP);
+  if (!matches) {
+    return undefined;
+  }
+
+  let parentSampled;
+  if (matches[3] === '1') {
+    parentSampled = true;
+  } else if (matches[3] === '0') {
+    parentSampled = false;
+  }
+
+  return {
+    traceId: matches[1],
+    parentSampled,
+    parentSpanId: matches[2],
+  };
+}
+
+/**
+ * Create tracing context from incoming headers.
+ */
+function tracingContextFromHeaders(
+  sentryTrace,
+  baggage,
+)
+
+ {
+  const traceparentData = extractTraceparentData(sentryTrace);
+  const dynamicSamplingContext = baggageHeaderToDynamicSamplingContext(baggage);
+
+  const { traceId, parentSpanId, parentSampled } = traceparentData || {};
+
+  const propagationContext = {
+    traceId: traceId || uuid4(),
+    spanId: uuid4().substring(16),
+    sampled: parentSampled,
+  };
+
+  if (parentSpanId) {
+    propagationContext.parentSpanId = parentSpanId;
+  }
+
+  if (dynamicSamplingContext) {
+    propagationContext.dsc = dynamicSamplingContext ;
+  }
+
+  return {
+    traceparentData,
+    dynamicSamplingContext,
+    propagationContext,
+  };
+}
+
+/**
+ * Create sentry-trace header from span context values.
+ */
+function generateSentryTraceHeader(
+  traceId = uuid4(),
+  spanId = uuid4().substring(16),
+  sampled,
+) {
+  let sampledString = '';
+  if (sampled !== undefined) {
+    sampledString = sampled ? '-1' : '-0';
+  }
+  return `${traceId}-${spanId}${sampledString}`;
+}
+
+export { TRACEPARENT_REGEXP, extractTraceparentData, generateSentryTraceHeader, tracingContextFromHeaders };
+//# sourceMappingURL=tracing.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/vendor/supportsHistory.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/vendor/supportsHistory.js
new file mode 100644
index 0000000..cf33d64
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/vendor/supportsHistory.js
@@ -0,0 +1,29 @@
+import { getGlobalObject } from '../worldwide.js';
+
+// Based on https://github.com/angular/angular.js/pull/13945/files
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+/**
+ * Tells whether current environment supports History API
+ * {@link supportsHistory}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsHistory() {
+  // NOTE: in Chrome App environment, touching history.pushState, *even inside
+  //       a try/catch block*, will cause Chrome to output an error to console.error
+  // borrowed from: https://github.com/angular/angular.js/pull/13945/files
+  /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const chrome = (WINDOW ).chrome;
+  const isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;
+  /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+  const hasHistoryApi = 'history' in WINDOW && !!WINDOW.history.pushState && !!WINDOW.history.replaceState;
+
+  return !isChromePackagedApp && hasHistoryApi;
+}
+
+export { supportsHistory };
+//# sourceMappingURL=supportsHistory.js.map
diff --git a/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/worldwide.js b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/worldwide.js
new file mode 100644
index 0000000..4c54705
--- /dev/null
+++ b/parent_dir/node_modules/sentry/core/node_modules/sentry/utils/esm/worldwide.js
@@ -0,0 +1,70 @@
+/** Internal global with common properties and Sentry extensions  */
+
+// The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification
+// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js
+// core-js has the following licence:
+//
+// Copyright (c) 2014-2022 Denis Pushkarev
+//
+// 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.
+
+/** Returns 'obj' if it's the global object, otherwise returns undefined */
+function isGlobalObj(obj) {
+  return obj && obj.Math == Math ? obj : undefined;
+}
+
+/** Get's the global object for the current JavaScript runtime */
+const GLOBAL_OBJ =
+  (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||
+  // eslint-disable-next-line no-restricted-globals
+  (typeof window == 'object' && isGlobalObj(window)) ||
+  (typeof self == 'object' && isGlobalObj(self)) ||
+  (typeof global == 'object' && isGlobalObj(global)) ||
+  (function () {
+    return this;
+  })() ||
+  {};
+
+/**
+ * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8
+ */
+function getGlobalObject() {
+  return GLOBAL_OBJ ;
+}
+
+/**
+ * Returns a global singleton contained in the global `__SENTRY__` object.
+ *
+ * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory
+ * function and added to the `__SENTRY__` object.
+ *
+ * @param name name of the global singleton on __SENTRY__
+ * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`
+ * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value
+ * @returns the singleton
+ */
+function getGlobalSingleton(name, creator, obj) {
+  const gbl = (obj || GLOBAL_OBJ) ;
+  const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});
+  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());
+  return singleton;
+}
+
+export { GLOBAL_OBJ, getGlobalObject, getGlobalSingleton };
+//# sourceMappingURL=worldwide.js.map
diff --git a/parent_dir/node_modules/sentry/replay/esm/index.js b/parent_dir/node_modules/sentry/replay/esm/index.js
new file mode 100644
index 0000000..4ef7026
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/esm/index.js
@@ -0,0 +1,8822 @@
+import { getCurrentHub, addGlobalEventProcessor, prepareEvent, setContext, captureException } from '@sentry/core';
+import { GLOBAL_OBJ, normalize, fill, htmlTreeAsString, logger, uuid4, SENTRY_XHR_DATA_KEY, dropUndefinedKeys, stringMatchesSomePattern, addInstrumentationHandler, browserPerformanceTimeOrigin, createEnvelope, createEventEnvelopeHeaders, getSdkMetadataForEnvelopeHeader, isNodeEnv } from '@sentry/utils';
+
+// exporting a separate copy of `WINDOW` rather than exporting the one from `@sentry/browser`
+// prevents the browser package from being bundled in the CDN bundle, and avoids a
+// circular dependency between the browser and replay packages should `@sentry/browser` import
+// from `@sentry/replay` in the future
+const WINDOW = GLOBAL_OBJ ;
+
+const REPLAY_SESSION_KEY = 'sentryReplaySession';
+const REPLAY_EVENT_NAME = 'replay_event';
+const UNABLE_TO_SEND_REPLAY = 'Unable to send Replay';
+
+// The idle limit for a session after which recording is paused.
+const SESSION_IDLE_PAUSE_DURATION = 300000; // 5 minutes in ms
+
+// The idle limit for a session after which the session expires.
+const SESSION_IDLE_EXPIRE_DURATION = 900000; // 15 minutes in ms
+
+/** Default flush delays */
+const DEFAULT_FLUSH_MIN_DELAY = 5000;
+// XXX: Temp fix for our debounce logic where `maxWait` would never occur if it
+// was the same as `wait`
+const DEFAULT_FLUSH_MAX_DELAY = 5500;
+
+/* How long to wait for error checkouts */
+const BUFFER_CHECKOUT_TIME = 60000;
+
+const RETRY_BASE_INTERVAL = 5000;
+const RETRY_MAX_COUNT = 3;
+
+/* The max (uncompressed) size in bytes of a network body. Any body larger than this will be truncated. */
+const NETWORK_BODY_MAX_SIZE = 150000;
+
+/* The max size of a single console arg that is captured. Any arg larger than this will be truncated. */
+const CONSOLE_ARG_MAX_SIZE = 5000;
+
+/* Min. time to wait before we consider something a slow click. */
+const SLOW_CLICK_THRESHOLD = 3000;
+/* For scroll actions after a click, we only look for a very short time period to detect programmatic scrolling. */
+const SLOW_CLICK_SCROLL_TIMEOUT = 300;
+
+/** When encountering a total segment size exceeding this size, stop the replay (as we cannot properly ingest it). */
+const REPLAY_MAX_EVENT_BUFFER_SIZE = 20000000; // ~20MB
+
+/** Replays must be min. 5s long before we send them. */
+const MIN_REPLAY_DURATION = 4999;
+/* The max. allowed value that the minReplayDuration can be set to. */
+const MIN_REPLAY_DURATION_LIMIT = 15000;
+
+/** The max. length of a replay. */
+const MAX_REPLAY_DURATION = 3600000; // 60 minutes in ms;
+
+var NodeType$1;
+(function (NodeType) {
+    NodeType[NodeType["Document"] = 0] = "Document";
+    NodeType[NodeType["DocumentType"] = 1] = "DocumentType";
+    NodeType[NodeType["Element"] = 2] = "Element";
+    NodeType[NodeType["Text"] = 3] = "Text";
+    NodeType[NodeType["CDATA"] = 4] = "CDATA";
+    NodeType[NodeType["Comment"] = 5] = "Comment";
+})(NodeType$1 || (NodeType$1 = {}));
+
+function isElement(n) {
+    return n.nodeType === n.ELEMENT_NODE;
+}
+function isShadowRoot(n) {
+    const host = n === null || n === void 0 ? void 0 : n.host;
+    return Boolean(host && host.shadowRoot && host.shadowRoot === n);
+}
+function isInputTypeMasked({ maskInputOptions, tagName, type, }) {
+    if (tagName.toLowerCase() === 'option') {
+        tagName = 'select';
+    }
+    const actualType = typeof type === 'string' ? type.toLowerCase() : undefined;
+    return (maskInputOptions[tagName.toLowerCase()] ||
+        (actualType && maskInputOptions[actualType]) ||
+        actualType === 'password' ||
+        (tagName === 'input' && !type && maskInputOptions['text']));
+}
+function hasInputMaskOptions({ tagName, type, maskInputOptions, maskInputSelector, }) {
+    return (maskInputSelector || isInputTypeMasked({ maskInputOptions, tagName, type }));
+}
+function maskInputValue({ input, maskInputSelector, unmaskInputSelector, maskInputOptions, tagName, type, value, maskInputFn, }) {
+    let text = value || '';
+    if (unmaskInputSelector && input.matches(unmaskInputSelector)) {
+        return text;
+    }
+    if (input.hasAttribute('data-rr-is-password')) {
+        type = 'password';
+    }
+    if (isInputTypeMasked({ maskInputOptions, tagName, type }) ||
+        (maskInputSelector && input.matches(maskInputSelector))) {
+        if (maskInputFn) {
+            text = maskInputFn(text);
+        }
+        else {
+            text = '*'.repeat(text.length);
+        }
+    }
+    return text;
+}
+const ORIGINAL_ATTRIBUTE_NAME = '__rrweb_original__';
+function is2DCanvasBlank(canvas) {
+    const ctx = canvas.getContext('2d');
+    if (!ctx)
+        return true;
+    const chunkSize = 50;
+    for (let x = 0; x < canvas.width; x += chunkSize) {
+        for (let y = 0; y < canvas.height; y += chunkSize) {
+            const getImageData = ctx.getImageData;
+            const originalGetImageData = ORIGINAL_ATTRIBUTE_NAME in getImageData
+                ? getImageData[ORIGINAL_ATTRIBUTE_NAME]
+                : getImageData;
+            const pixelBuffer = new Uint32Array(originalGetImageData.call(ctx, x, y, Math.min(chunkSize, canvas.width - x), Math.min(chunkSize, canvas.height - y)).data.buffer);
+            if (pixelBuffer.some((pixel) => pixel !== 0))
+                return false;
+        }
+    }
+    return true;
+}
+function getInputType(element) {
+    const type = element.type;
+    return element.hasAttribute('data-rr-is-password')
+        ? 'password'
+        : type
+            ? type.toLowerCase()
+            : null;
+}
+function getInputValue(el, tagName, type) {
+    typeof type === 'string' ? type.toLowerCase() : '';
+    if (tagName === 'INPUT' && (type === 'radio' || type === 'checkbox')) {
+        return el.getAttribute('value') || '';
+    }
+    return el.value;
+}
+
+let _id = 1;
+const tagNameRegex = new RegExp('[^a-z0-9-_:]');
+const IGNORED_NODE = -2;
+function defaultMaskFn(str) {
+    return str ? str.replace(/[\S]/g, '*') : '';
+}
+function genId() {
+    return _id++;
+}
+function getValidTagName(element) {
+    if (element instanceof HTMLFormElement) {
+        return 'form';
+    }
+    const processedTagName = element.tagName.toLowerCase().trim();
+    if (tagNameRegex.test(processedTagName)) {
+        return 'div';
+    }
+    return processedTagName;
+}
+function getCssRulesString(s) {
+    try {
+        const rules = s.rules || s.cssRules;
+        return rules ? Array.from(rules).map(getCssRuleString).join('') : null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+function getCssRuleString(rule) {
+    let cssStringified = rule.cssText;
+    if (isCSSImportRule(rule)) {
+        try {
+            cssStringified = getCssRulesString(rule.styleSheet) || cssStringified;
+        }
+        catch (_a) {
+        }
+    }
+    return validateStringifiedCssRule(cssStringified);
+}
+function validateStringifiedCssRule(cssStringified) {
+    if (cssStringified.indexOf(':') > -1) {
+        const regex = /(\[(?:[\w-]+)[^\\])(:(?:[\w-]+)\])/gm;
+        return cssStringified.replace(regex, '$1\\$2');
+    }
+    return cssStringified;
+}
+function isCSSImportRule(rule) {
+    return 'styleSheet' in rule;
+}
+function stringifyStyleSheet(sheet) {
+    return sheet.cssRules
+        ? Array.from(sheet.cssRules)
+            .map((rule) => rule.cssText ? validateStringifiedCssRule(rule.cssText) : '')
+            .join('')
+        : '';
+}
+function extractOrigin(url) {
+    let origin = '';
+    if (url.indexOf('//') > -1) {
+        origin = url.split('/').slice(0, 3).join('/');
+    }
+    else {
+        origin = url.split('/')[0];
+    }
+    origin = origin.split('?')[0];
+    return origin;
+}
+let canvasService;
+let canvasCtx;
+const URL_IN_CSS_REF = /url\((?:(')([^']*)'|(")(.*?)"|([^)]*))\)/gm;
+const RELATIVE_PATH = /^(?!www\.|(?:http|ftp)s?:\/\/|[A-Za-z]:\\|\/\/|#).*/;
+const DATA_URI = /^(data:)([^,]*),(.*)/i;
+function absoluteToStylesheet(cssText, href) {
+    return (cssText || '').replace(URL_IN_CSS_REF, (origin, quote1, path1, quote2, path2, path3) => {
+        const filePath = path1 || path2 || path3;
+        const maybeQuote = quote1 || quote2 || '';
+        if (!filePath) {
+            return origin;
+        }
+        if (!RELATIVE_PATH.test(filePath)) {
+            return `url(${maybeQuote}${filePath}${maybeQuote})`;
+        }
+        if (DATA_URI.test(filePath)) {
+            return `url(${maybeQuote}${filePath}${maybeQuote})`;
+        }
+        if (filePath[0] === '/') {
+            return `url(${maybeQuote}${extractOrigin(href) + filePath}${maybeQuote})`;
+        }
+        const stack = href.split('/');
+        const parts = filePath.split('/');
+        stack.pop();
+        for (const part of parts) {
+            if (part === '.') {
+                continue;
+            }
+            else if (part === '..') {
+                stack.pop();
+            }
+            else {
+                stack.push(part);
+            }
+        }
+        return `url(${maybeQuote}${stack.join('/')}${maybeQuote})`;
+    });
+}
+const SRCSET_NOT_SPACES = /^[^ \t\n\r\u000c]+/;
+const SRCSET_COMMAS_OR_SPACES = /^[, \t\n\r\u000c]+/;
+function getAbsoluteSrcsetString(doc, attributeValue) {
+    if (attributeValue.trim() === '') {
+        return attributeValue;
+    }
+    let pos = 0;
+    function collectCharacters(regEx) {
+        let chars;
+        let match = regEx.exec(attributeValue.substring(pos));
+        if (match) {
+            chars = match[0];
+            pos += chars.length;
+            return chars;
+        }
+        return '';
+    }
+    let output = [];
+    while (true) {
+        collectCharacters(SRCSET_COMMAS_OR_SPACES);
+        if (pos >= attributeValue.length) {
+            break;
+        }
+        let url = collectCharacters(SRCSET_NOT_SPACES);
+        if (url.slice(-1) === ',') {
+            url = absoluteToDoc(doc, url.substring(0, url.length - 1));
+            output.push(url);
+        }
+        else {
+            let descriptorsStr = '';
+            url = absoluteToDoc(doc, url);
+            let inParens = false;
+            while (true) {
+                let c = attributeValue.charAt(pos);
+                if (c === '') {
+                    output.push((url + descriptorsStr).trim());
+                    break;
+                }
+                else if (!inParens) {
+                    if (c === ',') {
+                        pos += 1;
+                        output.push((url + descriptorsStr).trim());
+                        break;
+                    }
+                    else if (c === '(') {
+                        inParens = true;
+                    }
+                }
+                else {
+                    if (c === ')') {
+                        inParens = false;
+                    }
+                }
+                descriptorsStr += c;
+                pos += 1;
+            }
+        }
+    }
+    return output.join(', ');
+}
+function absoluteToDoc(doc, attributeValue) {
+    if (!attributeValue || attributeValue.trim() === '') {
+        return attributeValue;
+    }
+    const a = doc.createElement('a');
+    a.href = attributeValue;
+    return a.href;
+}
+function isSVGElement(el) {
+    return Boolean(el.tagName === 'svg' || el.ownerSVGElement);
+}
+function getHref() {
+    const a = document.createElement('a');
+    a.href = '';
+    return a.href;
+}
+function transformAttribute(doc, element, _tagName, _name, value, maskAllText, unmaskTextSelector, maskTextFn) {
+    if (!value) {
+        return value;
+    }
+    const name = _name.toLowerCase();
+    const tagName = _tagName.toLowerCase();
+    if (name === 'src' || name === 'href') {
+        return absoluteToDoc(doc, value);
+    }
+    else if (name === 'xlink:href' && value[0] !== '#') {
+        return absoluteToDoc(doc, value);
+    }
+    else if (name === 'background' &&
+        (tagName === 'table' || tagName === 'td' || tagName === 'th')) {
+        return absoluteToDoc(doc, value);
+    }
+    else if (name === 'srcset') {
+        return getAbsoluteSrcsetString(doc, value);
+    }
+    else if (name === 'style') {
+        return absoluteToStylesheet(value, getHref());
+    }
+    else if (tagName === 'object' && name === 'data') {
+        return absoluteToDoc(doc, value);
+    }
+    else if (maskAllText &&
+        _shouldMaskAttribute(element, name, tagName, unmaskTextSelector)) {
+        return maskTextFn ? maskTextFn(value) : defaultMaskFn(value);
+    }
+    return value;
+}
+function _shouldMaskAttribute(element, attribute, tagName, unmaskTextSelector) {
+    if (unmaskTextSelector && element.matches(unmaskTextSelector)) {
+        return false;
+    }
+    return (['placeholder', 'title', 'aria-label'].indexOf(attribute) > -1 ||
+        (tagName === 'input' &&
+            attribute === 'value' &&
+            element.hasAttribute('type') &&
+            ['submit', 'button'].indexOf(element.getAttribute('type').toLowerCase()) > -1));
+}
+function _isBlockedElement(element, blockClass, blockSelector, unblockSelector) {
+    if (unblockSelector && element.matches(unblockSelector)) {
+        return false;
+    }
+    if (typeof blockClass === 'string') {
+        if (element.classList.contains(blockClass)) {
+            return true;
+        }
+    }
+    else {
+        for (let eIndex = 0; eIndex < element.classList.length; eIndex++) {
+            const className = element.classList[eIndex];
+            if (blockClass.test(className)) {
+                return true;
+            }
+        }
+    }
+    if (blockSelector) {
+        return element.matches(blockSelector);
+    }
+    return false;
+}
+function needMaskingText(node, maskTextClass, maskTextSelector, unmaskTextSelector, maskAllText) {
+    if (!node) {
+        return false;
+    }
+    if (node.nodeType !== node.ELEMENT_NODE) {
+        return needMaskingText(node.parentNode, maskTextClass, maskTextSelector, unmaskTextSelector, maskAllText);
+    }
+    if (unmaskTextSelector) {
+        if (node.matches(unmaskTextSelector) ||
+            node.closest(unmaskTextSelector)) {
+            return false;
+        }
+    }
+    if (maskAllText) {
+        return true;
+    }
+    if (typeof maskTextClass === 'string') {
+        if (node.classList.contains(maskTextClass)) {
+            return true;
+        }
+    }
+    else {
+        for (let eIndex = 0; eIndex < node.classList.length; eIndex++) {
+            const className = node.classList[eIndex];
+            if (maskTextClass.test(className)) {
+                return true;
+            }
+        }
+    }
+    if (maskTextSelector) {
+        if (node.matches(maskTextSelector)) {
+            return true;
+        }
+    }
+    return needMaskingText(node.parentNode, maskTextClass, maskTextSelector, unmaskTextSelector, maskAllText);
+}
+function onceIframeLoaded(iframeEl, listener, iframeLoadTimeout) {
+    const win = iframeEl.contentWindow;
+    if (!win) {
+        return;
+    }
+    let fired = false;
+    let readyState;
+    try {
+        readyState = win.document.readyState;
+    }
+    catch (error) {
+        return;
+    }
+    if (readyState !== 'complete') {
+        const timer = setTimeout(() => {
+            if (!fired) {
+                listener();
+                fired = true;
+            }
+        }, iframeLoadTimeout);
+        iframeEl.addEventListener('load', () => {
+            clearTimeout(timer);
+            fired = true;
+            listener();
+        });
+        return;
+    }
+    const blankUrl = 'about:blank';
+    if (win.location.href !== blankUrl ||
+        iframeEl.src === blankUrl ||
+        iframeEl.src === '') {
+        setTimeout(listener, 0);
+        return;
+    }
+    iframeEl.addEventListener('load', listener);
+}
+function serializeNode(n, options) {
+    var _a;
+    const { doc, blockClass, blockSelector, unblockSelector, maskTextClass, maskTextSelector, unmaskTextSelector, inlineStylesheet, maskInputSelector, unmaskInputSelector, maskAllText, maskInputOptions = {}, maskTextFn, maskInputFn, dataURLOptions = {}, inlineImages, recordCanvas, keepIframeSrcFn, } = options;
+    let rootId;
+    if (doc.__sn) {
+        const docId = doc.__sn.id;
+        rootId = docId === 1 ? undefined : docId;
+    }
+    switch (n.nodeType) {
+        case n.DOCUMENT_NODE:
+            if (n.compatMode !== 'CSS1Compat') {
+                return {
+                    type: NodeType$1.Document,
+                    childNodes: [],
+                    compatMode: n.compatMode,
+                    rootId,
+                };
+            }
+            else {
+                return {
+                    type: NodeType$1.Document,
+                    childNodes: [],
+                    rootId,
+                };
+            }
+        case n.DOCUMENT_TYPE_NODE:
+            return {
+                type: NodeType$1.DocumentType,
+                name: n.name,
+                publicId: n.publicId,
+                systemId: n.systemId,
+                rootId,
+            };
+        case n.ELEMENT_NODE:
+            const needBlock = _isBlockedElement(n, blockClass, blockSelector, unblockSelector);
+            const tagName = getValidTagName(n);
+            let attributes = {};
+            for (const { name, value } of Array.from(n.attributes)) {
+                if (!skipAttribute(tagName, name)) {
+                    attributes[name] = transformAttribute(doc, n, tagName, name, value, maskAllText, unmaskTextSelector, maskTextFn);
+                }
+            }
+            if (tagName === 'link' && inlineStylesheet) {
+                const stylesheet = Array.from(doc.styleSheets).find((s) => {
+                    return s.href === n.href;
+                });
+                let cssText = null;
+                if (stylesheet) {
+                    cssText = getCssRulesString(stylesheet);
+                }
+                if (cssText) {
+                    delete attributes.rel;
+                    delete attributes.href;
+                    attributes._cssText = absoluteToStylesheet(cssText, stylesheet.href);
+                }
+            }
+            if (tagName === 'style' &&
+                n.sheet &&
+                !(n.innerText ||
+                    n.textContent ||
+                    '').trim().length) {
+                const cssText = getCssRulesString(n.sheet);
+                if (cssText) {
+                    attributes._cssText = absoluteToStylesheet(cssText, getHref());
+                }
+            }
+            if (tagName === 'input' ||
+                tagName === 'textarea' ||
+                tagName === 'select' ||
+                tagName === 'option') {
+                const el = n;
+                const type = getInputType(el);
+                const value = getInputValue(el, tagName.toUpperCase(), type);
+                const checked = n.checked;
+                if (type !== 'submit' &&
+                    type !== 'button' &&
+                    value) {
+                    attributes.value = maskInputValue({
+                        input: el,
+                        type,
+                        tagName,
+                        value,
+                        maskInputSelector,
+                        unmaskInputSelector,
+                        maskInputOptions,
+                        maskInputFn,
+                    });
+                }
+                if (checked) {
+                    attributes.checked = checked;
+                }
+            }
+            if (tagName === 'option') {
+                if (n.selected && !maskInputOptions['select']) {
+                    attributes.selected = true;
+                }
+                else {
+                    delete attributes.selected;
+                }
+            }
+            if (tagName === 'canvas' && recordCanvas) {
+                if (n.__context === '2d') {
+                    if (!is2DCanvasBlank(n)) {
+                        attributes.rr_dataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);
+                    }
+                }
+                else if (!('__context' in n)) {
+                    const canvasDataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);
+                    const blankCanvas = document.createElement('canvas');
+                    blankCanvas.width = n.width;
+                    blankCanvas.height = n.height;
+                    const blankCanvasDataURL = blankCanvas.toDataURL(dataURLOptions.type, dataURLOptions.quality);
+                    if (canvasDataURL !== blankCanvasDataURL) {
+                        attributes.rr_dataURL = canvasDataURL;
+                    }
+                }
+            }
+            if (tagName === 'img' && inlineImages) {
+                if (!canvasService) {
+                    canvasService = doc.createElement('canvas');
+                    canvasCtx = canvasService.getContext('2d');
+                }
+                const image = n;
+                const oldValue = image.crossOrigin;
+                image.crossOrigin = 'anonymous';
+                const recordInlineImage = () => {
+                    try {
+                        canvasService.width = image.naturalWidth;
+                        canvasService.height = image.naturalHeight;
+                        canvasCtx.drawImage(image, 0, 0);
+                        attributes.rr_dataURL = canvasService.toDataURL(dataURLOptions.type, dataURLOptions.quality);
+                    }
+                    catch (err) {
+                        console.warn(`Cannot inline img src=${image.currentSrc}! Error: ${err}`);
+                    }
+                    oldValue
+                        ? (attributes.crossOrigin = oldValue)
+                        : delete attributes.crossOrigin;
+                };
+                if (image.complete && image.naturalWidth !== 0)
+                    recordInlineImage();
+                else
+                    image.onload = recordInlineImage;
+            }
+            if (tagName === 'audio' || tagName === 'video') {
+                attributes.rr_mediaState = n.paused
+                    ? 'paused'
+                    : 'played';
+                attributes.rr_mediaCurrentTime = n.currentTime;
+            }
+            if (n.scrollLeft) {
+                attributes.rr_scrollLeft = n.scrollLeft;
+            }
+            if (n.scrollTop) {
+                attributes.rr_scrollTop = n.scrollTop;
+            }
+            if (needBlock) {
+                const { width, height } = n.getBoundingClientRect();
+                attributes = {
+                    class: attributes.class,
+                    rr_width: `${width}px`,
+                    rr_height: `${height}px`,
+                };
+            }
+            if (tagName === 'iframe' && !keepIframeSrcFn(attributes.src)) {
+                if (!n.contentDocument) {
+                    attributes.rr_src = attributes.src;
+                }
+                delete attributes.src;
+            }
+            return {
+                type: NodeType$1.Element,
+                tagName,
+                attributes,
+                childNodes: [],
+                isSVG: isSVGElement(n) || undefined,
+                needBlock,
+                rootId,
+            };
+        case n.TEXT_NODE:
+            const parentTagName = n.parentNode && n.parentNode.tagName;
+            let textContent = n.textContent;
+            const isStyle = parentTagName === 'STYLE' ? true : undefined;
+            const isScript = parentTagName === 'SCRIPT' ? true : undefined;
+            if (isStyle && textContent) {
+                try {
+                    if (n.nextSibling || n.previousSibling) {
+                    }
+                    else if ((_a = n.parentNode.sheet) === null || _a === void 0 ? void 0 : _a.cssRules) {
+                        textContent = stringifyStyleSheet(n.parentNode.sheet);
+                    }
+                }
+                catch (err) {
+                    console.warn(`Cannot get CSS styles from text's parentNode. Error: ${err}`, n);
+                }
+                textContent = absoluteToStylesheet(textContent, getHref());
+            }
+            if (isScript) {
+                textContent = 'SCRIPT_PLACEHOLDER';
+            }
+            if (parentTagName === 'TEXTAREA' && textContent) {
+                textContent = '';
+            }
+            else if (parentTagName === 'OPTION' && textContent) {
+                const option = n.parentNode;
+                textContent = maskInputValue({
+                    input: option,
+                    type: null,
+                    tagName: parentTagName,
+                    value: textContent,
+                    maskInputSelector,
+                    unmaskInputSelector,
+                    maskInputOptions,
+                    maskInputFn,
+                });
+            }
+            else if (!isStyle &&
+                !isScript &&
+                needMaskingText(n, maskTextClass, maskTextSelector, unmaskTextSelector, maskAllText) &&
+                textContent) {
+                textContent = maskTextFn
+                    ? maskTextFn(textContent)
+                    : defaultMaskFn(textContent);
+            }
+            return {
+                type: NodeType$1.Text,
+                textContent: textContent || '',
+                isStyle,
+                rootId,
+            };
+        case n.CDATA_SECTION_NODE:
+            return {
+                type: NodeType$1.CDATA,
+                textContent: '',
+                rootId,
+            };
+        case n.COMMENT_NODE:
+            return {
+                type: NodeType$1.Comment,
+                textContent: n.textContent || '',
+                rootId,
+            };
+        default:
+            return false;
+    }
+}
+function lowerIfExists(maybeAttr) {
+    if (maybeAttr === undefined || maybeAttr === null) {
+        return '';
+    }
+    else {
+        return maybeAttr.toLowerCase();
+    }
+}
+function slimDOMExcluded(sn, slimDOMOptions) {
+    if (slimDOMOptions.comment && sn.type === NodeType$1.Comment) {
+        return true;
+    }
+    else if (sn.type === NodeType$1.Element) {
+        if (slimDOMOptions.script &&
+            (sn.tagName === 'script' ||
+                (sn.tagName === 'link' &&
+                    (sn.attributes.rel === 'preload' ||
+                        sn.attributes.rel === 'modulepreload') &&
+                    sn.attributes.as === 'script') ||
+                (sn.tagName === 'link' &&
+                    sn.attributes.rel === 'prefetch' &&
+                    typeof sn.attributes.href === 'string' &&
+                    sn.attributes.href.endsWith('.js')))) {
+            return true;
+        }
+        else if (slimDOMOptions.headFavicon &&
+            ((sn.tagName === 'link' && sn.attributes.rel === 'shortcut icon') ||
+                (sn.tagName === 'meta' &&
+                    (lowerIfExists(sn.attributes.name).match(/^msapplication-tile(image|color)$/) ||
+                        lowerIfExists(sn.attributes.name) === 'application-name' ||
+                        lowerIfExists(sn.attributes.rel) === 'icon' ||
+                        lowerIfExists(sn.attributes.rel) === 'apple-touch-icon' ||
+                        lowerIfExists(sn.attributes.rel) === 'shortcut icon')))) {
+            return true;
+        }
+        else if (sn.tagName === 'meta') {
+            if (slimDOMOptions.headMetaDescKeywords &&
+                lowerIfExists(sn.attributes.name).match(/^description|keywords$/)) {
+                return true;
+            }
+            else if (slimDOMOptions.headMetaSocial &&
+                (lowerIfExists(sn.attributes.property).match(/^(og|twitter|fb):/) ||
+                    lowerIfExists(sn.attributes.name).match(/^(og|twitter):/) ||
+                    lowerIfExists(sn.attributes.name) === 'pinterest')) {
+                return true;
+            }
+            else if (slimDOMOptions.headMetaRobots &&
+                (lowerIfExists(sn.attributes.name) === 'robots' ||
+                    lowerIfExists(sn.attributes.name) === 'googlebot' ||
+                    lowerIfExists(sn.attributes.name) === 'bingbot')) {
+                return true;
+            }
+            else if (slimDOMOptions.headMetaHttpEquiv &&
+                sn.attributes['http-equiv'] !== undefined) {
+                return true;
+            }
+            else if (slimDOMOptions.headMetaAuthorship &&
+                (lowerIfExists(sn.attributes.name) === 'author' ||
+                    lowerIfExists(sn.attributes.name) === 'generator' ||
+                    lowerIfExists(sn.attributes.name) === 'framework' ||
+                    lowerIfExists(sn.attributes.name) === 'publisher' ||
+                    lowerIfExists(sn.attributes.name) === 'progid' ||
+                    lowerIfExists(sn.attributes.property).match(/^article:/) ||
+                    lowerIfExists(sn.attributes.property).match(/^product:/))) {
+                return true;
+            }
+            else if (slimDOMOptions.headMetaVerification &&
+                (lowerIfExists(sn.attributes.name) === 'google-site-verification' ||
+                    lowerIfExists(sn.attributes.name) === 'yandex-verification' ||
+                    lowerIfExists(sn.attributes.name) === 'csrf-token' ||
+                    lowerIfExists(sn.attributes.name) === 'p:domain_verify' ||
+                    lowerIfExists(sn.attributes.name) === 'verify-v1' ||
+                    lowerIfExists(sn.attributes.name) === 'verification' ||
+                    lowerIfExists(sn.attributes.name) === 'shopify-checkout-api-token')) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function serializeNodeWithId(n, options) {
+    const { doc, map, blockClass, blockSelector, unblockSelector, maskTextClass, maskTextSelector, unmaskTextSelector, skipChild = false, inlineStylesheet = true, maskInputSelector, unmaskInputSelector, maskAllText, maskInputOptions = {}, maskTextFn, maskInputFn, slimDOMOptions, dataURLOptions = {}, inlineImages = false, recordCanvas = false, onSerialize, onIframeLoad, iframeLoadTimeout = 5000, keepIframeSrcFn = () => false, } = options;
+    let { preserveWhiteSpace = true } = options;
+    const _serializedNode = serializeNode(n, {
+        doc,
+        blockClass,
+        blockSelector,
+        unblockSelector,
+        maskTextClass,
+        maskTextSelector,
+        unmaskTextSelector,
+        inlineStylesheet,
+        maskInputSelector,
+        unmaskInputSelector,
+        maskAllText,
+        maskInputOptions,
+        maskTextFn,
+        maskInputFn,
+        dataURLOptions,
+        inlineImages,
+        recordCanvas,
+        keepIframeSrcFn,
+    });
+    if (!_serializedNode) {
+        console.warn(n, 'not serialized');
+        return null;
+    }
+    let id;
+    if ('__sn' in n) {
+        id = n.__sn.id;
+    }
+    else if (slimDOMExcluded(_serializedNode, slimDOMOptions) ||
+        (!preserveWhiteSpace &&
+            _serializedNode.type === NodeType$1.Text &&
+            !_serializedNode.isStyle &&
+            !_serializedNode.textContent.replace(/^\s+|\s+$/gm, '').length)) {
+        id = IGNORED_NODE;
+    }
+    else {
+        id = genId();
+    }
+    const serializedNode = Object.assign(_serializedNode, { id });
+    n.__sn = serializedNode;
+    if (id === IGNORED_NODE) {
+        return null;
+    }
+    map[id] = n;
+    if (onSerialize) {
+        onSerialize(n);
+    }
+    let recordChild = !skipChild;
+    if (serializedNode.type === NodeType$1.Element) {
+        recordChild = recordChild && !serializedNode.needBlock;
+        delete serializedNode.needBlock;
+        if (n.shadowRoot)
+            serializedNode.isShadowHost = true;
+    }
+    if ((serializedNode.type === NodeType$1.Document ||
+        serializedNode.type === NodeType$1.Element) &&
+        recordChild) {
+        if (slimDOMOptions.headWhitespace &&
+            _serializedNode.type === NodeType$1.Element &&
+            _serializedNode.tagName === 'head') {
+            preserveWhiteSpace = false;
+        }
+        const bypassOptions = {
+            doc,
+            map,
+            blockClass,
+            blockSelector,
+            unblockSelector,
+            maskTextClass,
+            maskTextSelector,
+            unmaskTextSelector,
+            skipChild,
+            inlineStylesheet,
+            maskInputSelector,
+            unmaskInputSelector,
+            maskAllText,
+            maskInputOptions,
+            maskTextFn,
+            maskInputFn,
+            slimDOMOptions,
+            dataURLOptions,
+            inlineImages,
+            recordCanvas,
+            preserveWhiteSpace,
+            onSerialize,
+            onIframeLoad,
+            iframeLoadTimeout,
+            keepIframeSrcFn,
+        };
+        for (const childN of Array.from(n.childNodes)) {
+            const serializedChildNode = serializeNodeWithId(childN, bypassOptions);
+            if (serializedChildNode) {
+                serializedNode.childNodes.push(serializedChildNode);
+            }
+        }
+        if (isElement(n) && n.shadowRoot) {
+            for (const childN of Array.from(n.shadowRoot.childNodes)) {
+                const serializedChildNode = serializeNodeWithId(childN, bypassOptions);
+                if (serializedChildNode) {
+                    serializedChildNode.isShadow = true;
+                    serializedNode.childNodes.push(serializedChildNode);
+                }
+            }
+        }
+    }
+    if (n.parentNode && isShadowRoot(n.parentNode)) {
+        serializedNode.isShadow = true;
+    }
+    if (serializedNode.type === NodeType$1.Element &&
+        serializedNode.tagName === 'iframe') {
+        onceIframeLoaded(n, () => {
+            const iframeDoc = n.contentDocument;
+            if (iframeDoc && onIframeLoad) {
+                const serializedIframeNode = serializeNodeWithId(iframeDoc, {
+                    doc: iframeDoc,
+                    map,
+                    blockClass,
+                    blockSelector,
+                    unblockSelector,
+                    maskTextClass,
+                    maskTextSelector,
+                    unmaskTextSelector,
+                    skipChild: false,
+                    inlineStylesheet,
+                    maskInputSelector,
+                    unmaskInputSelector,
+                    maskAllText,
+                    maskInputOptions,
+                    maskTextFn,
+                    maskInputFn,
+                    slimDOMOptions,
+                    dataURLOptions,
+                    inlineImages,
+                    recordCanvas,
+                    preserveWhiteSpace,
+                    onSerialize,
+                    onIframeLoad,
+                    iframeLoadTimeout,
+                    keepIframeSrcFn,
+                });
+                if (serializedIframeNode) {
+                    onIframeLoad(n, serializedIframeNode);
+                }
+            }
+        }, iframeLoadTimeout);
+    }
+    return serializedNode;
+}
+function snapshot(n, options) {
+    const { blockClass = 'rr-block', blockSelector = null, unblockSelector = null, maskTextClass = 'rr-mask', maskTextSelector = null, unmaskTextSelector = null, inlineStylesheet = true, inlineImages = false, recordCanvas = false, maskInputSelector = null, unmaskInputSelector = null, maskAllText = false, maskAllInputs = false, maskTextFn, maskInputFn, slimDOM = false, dataURLOptions, preserveWhiteSpace, onSerialize, onIframeLoad, iframeLoadTimeout, keepIframeSrcFn = () => false, } = options || {};
+    const idNodeMap = {};
+    const maskInputOptions = maskAllInputs === true
+        ? {
+            color: true,
+            date: true,
+            'datetime-local': true,
+            email: true,
+            month: true,
+            number: true,
+            range: true,
+            search: true,
+            tel: true,
+            text: true,
+            time: true,
+            url: true,
+            week: true,
+            textarea: true,
+            select: true,
+        }
+        : maskAllInputs === false
+            ? {}
+            : maskAllInputs;
+    const slimDOMOptions = slimDOM === true || slimDOM === 'all'
+        ?
+            {
+                script: true,
+                comment: true,
+                headFavicon: true,
+                headWhitespace: true,
+                headMetaDescKeywords: slimDOM === 'all',
+                headMetaSocial: true,
+                headMetaRobots: true,
+                headMetaHttpEquiv: true,
+                headMetaAuthorship: true,
+                headMetaVerification: true,
+            }
+        : slimDOM === false
+            ? {}
+            : slimDOM;
+    return [
+        serializeNodeWithId(n, {
+            doc: n,
+            map: idNodeMap,
+            blockClass,
+            blockSelector,
+            unblockSelector,
+            maskTextClass,
+            maskTextSelector,
+            unmaskTextSelector,
+            skipChild: false,
+            inlineStylesheet,
+            maskInputSelector,
+            unmaskInputSelector,
+            maskAllText,
+            maskInputOptions,
+            maskTextFn,
+            maskInputFn,
+            slimDOMOptions,
+            dataURLOptions,
+            inlineImages,
+            recordCanvas,
+            preserveWhiteSpace,
+            onSerialize,
+            onIframeLoad,
+            iframeLoadTimeout,
+            keepIframeSrcFn,
+        }),
+        idNodeMap,
+    ];
+}
+function skipAttribute(tagName, attributeName, value) {
+    return ((tagName === 'video' || tagName === 'audio') && attributeName === 'autoplay');
+}
+
+var EventType;
+(function (EventType) {
+    EventType[EventType["DomContentLoaded"] = 0] = "DomContentLoaded";
+    EventType[EventType["Load"] = 1] = "Load";
+    EventType[EventType["FullSnapshot"] = 2] = "FullSnapshot";
+    EventType[EventType["IncrementalSnapshot"] = 3] = "IncrementalSnapshot";
+    EventType[EventType["Meta"] = 4] = "Meta";
+    EventType[EventType["Custom"] = 5] = "Custom";
+    EventType[EventType["Plugin"] = 6] = "Plugin";
+})(EventType || (EventType = {}));
+var IncrementalSource;
+(function (IncrementalSource) {
+    IncrementalSource[IncrementalSource["Mutation"] = 0] = "Mutation";
+    IncrementalSource[IncrementalSource["MouseMove"] = 1] = "MouseMove";
+    IncrementalSource[IncrementalSource["MouseInteraction"] = 2] = "MouseInteraction";
+    IncrementalSource[IncrementalSource["Scroll"] = 3] = "Scroll";
+    IncrementalSource[IncrementalSource["ViewportResize"] = 4] = "ViewportResize";
+    IncrementalSource[IncrementalSource["Input"] = 5] = "Input";
+    IncrementalSource[IncrementalSource["TouchMove"] = 6] = "TouchMove";
+    IncrementalSource[IncrementalSource["MediaInteraction"] = 7] = "MediaInteraction";
+    IncrementalSource[IncrementalSource["StyleSheetRule"] = 8] = "StyleSheetRule";
+    IncrementalSource[IncrementalSource["CanvasMutation"] = 9] = "CanvasMutation";
+    IncrementalSource[IncrementalSource["Font"] = 10] = "Font";
+    IncrementalSource[IncrementalSource["Log"] = 11] = "Log";
+    IncrementalSource[IncrementalSource["Drag"] = 12] = "Drag";
+    IncrementalSource[IncrementalSource["StyleDeclaration"] = 13] = "StyleDeclaration";
+})(IncrementalSource || (IncrementalSource = {}));
+var MouseInteractions;
+(function (MouseInteractions) {
+    MouseInteractions[MouseInteractions["MouseUp"] = 0] = "MouseUp";
+    MouseInteractions[MouseInteractions["MouseDown"] = 1] = "MouseDown";
+    MouseInteractions[MouseInteractions["Click"] = 2] = "Click";
+    MouseInteractions[MouseInteractions["ContextMenu"] = 3] = "ContextMenu";
+    MouseInteractions[MouseInteractions["DblClick"] = 4] = "DblClick";
+    MouseInteractions[MouseInteractions["Focus"] = 5] = "Focus";
+    MouseInteractions[MouseInteractions["Blur"] = 6] = "Blur";
+    MouseInteractions[MouseInteractions["TouchStart"] = 7] = "TouchStart";
+    MouseInteractions[MouseInteractions["TouchMove_Departed"] = 8] = "TouchMove_Departed";
+    MouseInteractions[MouseInteractions["TouchEnd"] = 9] = "TouchEnd";
+    MouseInteractions[MouseInteractions["TouchCancel"] = 10] = "TouchCancel";
+})(MouseInteractions || (MouseInteractions = {}));
+var CanvasContext;
+(function (CanvasContext) {
+    CanvasContext[CanvasContext["2D"] = 0] = "2D";
+    CanvasContext[CanvasContext["WebGL"] = 1] = "WebGL";
+    CanvasContext[CanvasContext["WebGL2"] = 2] = "WebGL2";
+})(CanvasContext || (CanvasContext = {}));
+var MediaInteractions;
+(function (MediaInteractions) {
+    MediaInteractions[MediaInteractions["Play"] = 0] = "Play";
+    MediaInteractions[MediaInteractions["Pause"] = 1] = "Pause";
+    MediaInteractions[MediaInteractions["Seeked"] = 2] = "Seeked";
+    MediaInteractions[MediaInteractions["VolumeChange"] = 3] = "VolumeChange";
+})(MediaInteractions || (MediaInteractions = {}));
+var ReplayerEvents;
+(function (ReplayerEvents) {
+    ReplayerEvents["Start"] = "start";
+    ReplayerEvents["Pause"] = "pause";
+    ReplayerEvents["Resume"] = "resume";
+    ReplayerEvents["Resize"] = "resize";
+    ReplayerEvents["Finish"] = "finish";
+    ReplayerEvents["FullsnapshotRebuilded"] = "fullsnapshot-rebuilded";
+    ReplayerEvents["LoadStylesheetStart"] = "load-stylesheet-start";
+    ReplayerEvents["LoadStylesheetEnd"] = "load-stylesheet-end";
+    ReplayerEvents["SkipStart"] = "skip-start";
+    ReplayerEvents["SkipEnd"] = "skip-end";
+    ReplayerEvents["MouseInteraction"] = "mouse-interaction";
+    ReplayerEvents["EventCast"] = "event-cast";
+    ReplayerEvents["CustomEvent"] = "custom-event";
+    ReplayerEvents["Flush"] = "flush";
+    ReplayerEvents["StateChange"] = "state-change";
+    ReplayerEvents["PlayBack"] = "play-back";
+})(ReplayerEvents || (ReplayerEvents = {}));
+
+function on(type, fn, target = document) {
+    const options = { capture: true, passive: true };
+    target.addEventListener(type, fn, options);
+    return () => target.removeEventListener(type, fn, options);
+}
+function createMirror() {
+    return {
+        map: {},
+        getId(n) {
+            if (!n || !n.__sn) {
+                return -1;
+            }
+            return n.__sn.id;
+        },
+        getNode(id) {
+            return this.map[id] || null;
+        },
+        removeNodeFromMap(n) {
+            const id = n.__sn && n.__sn.id;
+            delete this.map[id];
+            if (n.childNodes) {
+                n.childNodes.forEach((child) => this.removeNodeFromMap(child));
+            }
+        },
+        has(id) {
+            return this.map.hasOwnProperty(id);
+        },
+        reset() {
+            this.map = {};
+        },
+    };
+}
+const DEPARTED_MIRROR_ACCESS_WARNING = 'Please stop import mirror directly. Instead of that,' +
+    '\r\n' +
+    'now you can use replayer.getMirror() to access the mirror instance of a replayer,' +
+    '\r\n' +
+    'or you can use record.mirror to access the mirror instance during recording.';
+let _mirror = {
+    map: {},
+    getId() {
+        console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+        return -1;
+    },
+    getNode() {
+        console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+        return null;
+    },
+    removeNodeFromMap() {
+        console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+    },
+    has() {
+        console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+        return false;
+    },
+    reset() {
+        console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+    },
+};
+if (typeof window !== 'undefined' && window.Proxy && window.Reflect) {
+    _mirror = new Proxy(_mirror, {
+        get(target, prop, receiver) {
+            if (prop === 'map') {
+                console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}
+function throttle$1(func, wait, options = {}) {
+    let timeout = null;
+    let previous = 0;
+    return function (arg) {
+        let now = Date.now();
+        if (!previous && options.leading === false) {
+            previous = now;
+        }
+        let remaining = wait - (now - previous);
+        let context = this;
+        let args = arguments;
+        if (remaining <= 0 || remaining > wait) {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = null;
+            }
+            previous = now;
+            func.apply(context, args);
+        }
+        else if (!timeout && options.trailing !== false) {
+            timeout = setTimeout(() => {
+                previous = options.leading === false ? 0 : Date.now();
+                timeout = null;
+                func.apply(context, args);
+            }, remaining);
+        }
+    };
+}
+function hookSetter(target, key, d, isRevoked, win = window) {
+    const original = win.Object.getOwnPropertyDescriptor(target, key);
+    win.Object.defineProperty(target, key, isRevoked
+        ? d
+        : {
+            set(value) {
+                setTimeout(() => {
+                    d.set.call(this, value);
+                }, 0);
+                if (original && original.set) {
+                    original.set.call(this, value);
+                }
+            },
+        });
+    return () => hookSetter(target, key, original || {}, true);
+}
+function patch(source, name, replacement) {
+    try {
+        if (!(name in source)) {
+            return () => { };
+        }
+        const original = source[name];
+        const wrapped = replacement(original);
+        if (typeof wrapped === 'function') {
+            wrapped.prototype = wrapped.prototype || {};
+            Object.defineProperties(wrapped, {
+                __rrweb_original__: {
+                    enumerable: false,
+                    value: original,
+                },
+            });
+        }
+        source[name] = wrapped;
+        return () => {
+            source[name] = original;
+        };
+    }
+    catch (_a) {
+        return () => { };
+    }
+}
+function getWindowHeight() {
+    return (window.innerHeight ||
+        (document.documentElement && document.documentElement.clientHeight) ||
+        (document.body && document.body.clientHeight));
+}
+function getWindowWidth() {
+    return (window.innerWidth ||
+        (document.documentElement && document.documentElement.clientWidth) ||
+        (document.body && document.body.clientWidth));
+}
+function isBlocked(node, blockClass, blockSelector, unblockSelector) {
+    if (!node) {
+        return false;
+    }
+    if (node.nodeType === node.ELEMENT_NODE) {
+        let needBlock = false;
+        const needUnblock = unblockSelector && node.matches(unblockSelector);
+        if (typeof blockClass === 'string') {
+            if (node.closest !== undefined) {
+                needBlock =
+                    !needUnblock &&
+                        node.closest('.' + blockClass) !== null;
+            }
+            else {
+                needBlock =
+                    !needUnblock && node.classList.contains(blockClass);
+            }
+        }
+        else {
+            !needUnblock &&
+                node.classList.forEach((className) => {
+                    if (blockClass.test(className)) {
+                        needBlock = true;
+                    }
+                });
+        }
+        if (!needBlock && blockSelector) {
+            needBlock = node.matches(blockSelector);
+        }
+        return ((!needUnblock && needBlock) ||
+            isBlocked(node.parentNode, blockClass, blockSelector, unblockSelector));
+    }
+    if (node.nodeType === node.TEXT_NODE) {
+        return isBlocked(node.parentNode, blockClass, blockSelector, unblockSelector);
+    }
+    return isBlocked(node.parentNode, blockClass, blockSelector, unblockSelector);
+}
+function isIgnored(n) {
+    if ('__sn' in n) {
+        return n.__sn.id === IGNORED_NODE;
+    }
+    return false;
+}
+function isAncestorRemoved(target, mirror) {
+    if (isShadowRoot(target)) {
+        return false;
+    }
+    const id = mirror.getId(target);
+    if (!mirror.has(id)) {
+        return true;
+    }
+    if (target.parentNode &&
+        target.parentNode.nodeType === target.DOCUMENT_NODE) {
+        return false;
+    }
+    if (!target.parentNode) {
+        return true;
+    }
+    return isAncestorRemoved(target.parentNode, mirror);
+}
+function isTouchEvent(event) {
+    return Boolean(event.changedTouches);
+}
+function polyfill(win = window) {
+    if ('NodeList' in win && !win.NodeList.prototype.forEach) {
+        win.NodeList.prototype.forEach = Array.prototype
+            .forEach;
+    }
+    if ('DOMTokenList' in win && !win.DOMTokenList.prototype.forEach) {
+        win.DOMTokenList.prototype.forEach = Array.prototype
+            .forEach;
+    }
+    if (!Node.prototype.contains) {
+        Node.prototype.contains = function contains(node) {
+            if (!(0 in arguments)) {
+                throw new TypeError('1 argument is required');
+            }
+            do {
+                if (this === node) {
+                    return true;
+                }
+            } while ((node = node && node.parentNode));
+            return false;
+        };
+    }
+}
+function isIframeINode(node) {
+    if ('__sn' in node) {
+        return (node.__sn.type === NodeType$1.Element && node.__sn.tagName === 'iframe');
+    }
+    return false;
+}
+function hasShadowRoot(n) {
+    return Boolean(n === null || n === void 0 ? void 0 : n.shadowRoot);
+}
+
+function isNodeInLinkedList(n) {
+    return '__ln' in n;
+}
+class DoubleLinkedList {
+    constructor() {
+        this.length = 0;
+        this.head = null;
+    }
+    get(position) {
+        if (position >= this.length) {
+            throw new Error('Position outside of list range');
+        }
+        let current = this.head;
+        for (let index = 0; index < position; index++) {
+            current = (current === null || current === void 0 ? void 0 : current.next) || null;
+        }
+        return current;
+    }
+    addNode(n) {
+        const node = {
+            value: n,
+            previous: null,
+            next: null,
+        };
+        n.__ln = node;
+        if (n.previousSibling && isNodeInLinkedList(n.previousSibling)) {
+            const current = n.previousSibling.__ln.next;
+            node.next = current;
+            node.previous = n.previousSibling.__ln;
+            n.previousSibling.__ln.next = node;
+            if (current) {
+                current.previous = node;
+            }
+        }
+        else if (n.nextSibling &&
+            isNodeInLinkedList(n.nextSibling) &&
+            n.nextSibling.__ln.previous) {
+            const current = n.nextSibling.__ln.previous;
+            node.previous = current;
+            node.next = n.nextSibling.__ln;
+            n.nextSibling.__ln.previous = node;
+            if (current) {
+                current.next = node;
+            }
+        }
+        else {
+            if (this.head) {
+                this.head.previous = node;
+            }
+            node.next = this.head;
+            this.head = node;
+        }
+        this.length++;
+    }
+    removeNode(n) {
+        const current = n.__ln;
+        if (!this.head) {
+            return;
+        }
+        if (!current.previous) {
+            this.head = current.next;
+            if (this.head) {
+                this.head.previous = null;
+            }
+        }
+        else {
+            current.previous.next = current.next;
+            if (current.next) {
+                current.next.previous = current.previous;
+            }
+        }
+        if (n.__ln) {
+            delete n.__ln;
+        }
+        this.length--;
+    }
+}
+const moveKey = (id, parentId) => `${id}@${parentId}`;
+function isINode(n) {
+    return '__sn' in n;
+}
+class MutationBuffer {
+    constructor() {
+        this.frozen = false;
+        this.locked = false;
+        this.texts = [];
+        this.attributes = [];
+        this.removes = [];
+        this.mapRemoves = [];
+        this.movedMap = {};
+        this.addedSet = new Set();
+        this.movedSet = new Set();
+        this.droppedSet = new Set();
+        this.processMutations = (mutations) => {
+            mutations.forEach(this.processMutation);
+            this.emit();
+        };
+        this.emit = () => {
+            if (this.frozen || this.locked) {
+                return;
+            }
+            const adds = [];
+            const addList = new DoubleLinkedList();
+            const getNextId = (n) => {
+                let ns = n;
+                let nextId = IGNORED_NODE;
+                while (nextId === IGNORED_NODE) {
+                    ns = ns && ns.nextSibling;
+                    nextId = ns && this.mirror.getId(ns);
+                }
+                return nextId;
+            };
+            const pushAdd = (n) => {
+                var _a, _b, _c, _d, _e;
+                const shadowHost = n.getRootNode
+                    ? (_a = n.getRootNode()) === null || _a === void 0 ? void 0 : _a.host
+                    : null;
+                let rootShadowHost = shadowHost;
+                while ((_c = (_b = rootShadowHost === null || rootShadowHost === void 0 ? void 0 : rootShadowHost.getRootNode) === null || _b === void 0 ? void 0 : _b.call(rootShadowHost)) === null || _c === void 0 ? void 0 : _c.host)
+                    rootShadowHost =
+                        ((_e = (_d = rootShadowHost === null || rootShadowHost === void 0 ? void 0 : rootShadowHost.getRootNode) === null || _d === void 0 ? void 0 : _d.call(rootShadowHost)) === null || _e === void 0 ? void 0 : _e.host) ||
+                            null;
+                const notInDoc = !this.doc.contains(n) &&
+                    (!rootShadowHost || !this.doc.contains(rootShadowHost));
+                if (!n.parentNode || notInDoc) {
+                    return;
+                }
+                const parentId = isShadowRoot(n.parentNode)
+                    ? this.mirror.getId(shadowHost)
+                    : this.mirror.getId(n.parentNode);
+                const nextId = getNextId(n);
+                if (parentId === -1 || nextId === -1) {
+                    return addList.addNode(n);
+                }
+                let sn = serializeNodeWithId(n, {
+                    doc: this.doc,
+                    map: this.mirror.map,
+                    blockClass: this.blockClass,
+                    blockSelector: this.blockSelector,
+                    unblockSelector: this.unblockSelector,
+                    maskTextClass: this.maskTextClass,
+                    maskTextSelector: this.maskTextSelector,
+                    unmaskTextSelector: this.unmaskTextSelector,
+                    maskInputSelector: this.maskInputSelector,
+                    unmaskInputSelector: this.unmaskInputSelector,
+                    skipChild: true,
+                    inlineStylesheet: this.inlineStylesheet,
+                    maskAllText: this.maskAllText,
+                    maskInputOptions: this.maskInputOptions,
+                    maskTextFn: this.maskTextFn,
+                    maskInputFn: this.maskInputFn,
+                    slimDOMOptions: this.slimDOMOptions,
+                    recordCanvas: this.recordCanvas,
+                    inlineImages: this.inlineImages,
+                    onSerialize: (currentN) => {
+                        if (isIframeINode(currentN)) {
+                            this.iframeManager.addIframe(currentN);
+                        }
+                        if (hasShadowRoot(n)) {
+                            this.shadowDomManager.addShadowRoot(n.shadowRoot, document);
+                        }
+                    },
+                    onIframeLoad: (iframe, childSn) => {
+                        this.iframeManager.attachIframe(iframe, childSn);
+                        this.shadowDomManager.observeAttachShadow(iframe);
+                    },
+                });
+                if (sn) {
+                    adds.push({
+                        parentId,
+                        nextId,
+                        node: sn,
+                    });
+                }
+            };
+            while (this.mapRemoves.length) {
+                this.mirror.removeNodeFromMap(this.mapRemoves.shift());
+            }
+            for (const n of this.movedSet) {
+                if (isParentRemoved(this.removes, n, this.mirror) &&
+                    !this.movedSet.has(n.parentNode)) {
+                    continue;
+                }
+                pushAdd(n);
+            }
+            for (const n of this.addedSet) {
+                if (!isAncestorInSet(this.droppedSet, n) &&
+                    !isParentRemoved(this.removes, n, this.mirror)) {
+                    pushAdd(n);
+                }
+                else if (isAncestorInSet(this.movedSet, n)) {
+                    pushAdd(n);
+                }
+                else {
+                    this.droppedSet.add(n);
+                }
+            }
+            let candidate = null;
+            while (addList.length) {
+                let node = null;
+                if (candidate) {
+                    const parentId = this.mirror.getId(candidate.value.parentNode);
+                    const nextId = getNextId(candidate.value);
+                    if (parentId !== -1 && nextId !== -1) {
+                        node = candidate;
+                    }
+                }
+                if (!node) {
+                    for (let index = addList.length - 1; index >= 0; index--) {
+                        const _node = addList.get(index);
+                        if (_node) {
+                            const parentId = this.mirror.getId(_node.value.parentNode);
+                            const nextId = getNextId(_node.value);
+                            if (parentId !== -1 && nextId !== -1) {
+                                node = _node;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (!node) {
+                    while (addList.head) {
+                        addList.removeNode(addList.head.value);
+                    }
+                    break;
+                }
+                candidate = node.previous;
+                addList.removeNode(node.value);
+                pushAdd(node.value);
+            }
+            const payload = {
+                texts: this.texts
+                    .map((text) => ({
+                    id: this.mirror.getId(text.node),
+                    value: text.value,
+                }))
+                    .filter((text) => this.mirror.has(text.id)),
+                attributes: this.attributes
+                    .map((attribute) => ({
+                    id: this.mirror.getId(attribute.node),
+                    attributes: attribute.attributes,
+                }))
+                    .filter((attribute) => this.mirror.has(attribute.id)),
+                removes: this.removes,
+                adds,
+            };
+            if (!payload.texts.length &&
+                !payload.attributes.length &&
+                !payload.removes.length &&
+                !payload.adds.length) {
+                return;
+            }
+            this.texts = [];
+            this.attributes = [];
+            this.removes = [];
+            this.addedSet = new Set();
+            this.movedSet = new Set();
+            this.droppedSet = new Set();
+            this.movedMap = {};
+            this.mutationCb(payload);
+        };
+        this.processMutation = (m) => {
+            if (isIgnored(m.target)) {
+                return;
+            }
+            switch (m.type) {
+                case 'characterData': {
+                    const value = m.target.textContent;
+                    if (!isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector) && value !== m.oldValue) {
+                        this.texts.push({
+                            value: needMaskingText(m.target, this.maskTextClass, this.maskTextSelector, this.unmaskTextSelector, this.maskAllText) && value
+                                ? this.maskTextFn
+                                    ? this.maskTextFn(value)
+                                    : value.replace(/[\S]/g, '*')
+                                : value,
+                            node: m.target,
+                        });
+                    }
+                    break;
+                }
+                case 'attributes': {
+                    const target = m.target;
+                    let value = target.getAttribute(m.attributeName);
+                    if (m.attributeName === 'value') {
+                        value = maskInputValue({
+                            input: target,
+                            maskInputSelector: this.maskInputSelector,
+                            unmaskInputSelector: this.unmaskInputSelector,
+                            maskInputOptions: this.maskInputOptions,
+                            tagName: target.tagName,
+                            type: target.getAttribute('type'),
+                            value,
+                            maskInputFn: this.maskInputFn,
+                        });
+                    }
+                    if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector) || value === m.oldValue) {
+                        return;
+                    }
+                    let item = this.attributes.find((a) => a.node === m.target);
+                    if (!item) {
+                        item = {
+                            node: m.target,
+                            attributes: {},
+                        };
+                        this.attributes.push(item);
+                    }
+                    if (m.attributeName === 'type' &&
+                        target.tagName === 'INPUT' &&
+                        (m.oldValue || '').toLowerCase() === 'password') {
+                        target.setAttribute('data-rr-is-password', 'true');
+                    }
+                    if (m.attributeName === 'style') {
+                        const old = this.doc.createElement('span');
+                        if (m.oldValue) {
+                            old.setAttribute('style', m.oldValue);
+                        }
+                        if (item.attributes.style === undefined ||
+                            item.attributes.style === null) {
+                            item.attributes.style = {};
+                        }
+                        try {
+                            const styleObj = item.attributes.style;
+                            for (const pname of Array.from(target.style)) {
+                                const newValue = target.style.getPropertyValue(pname);
+                                const newPriority = target.style.getPropertyPriority(pname);
+                                if (newValue !== old.style.getPropertyValue(pname) ||
+                                    newPriority !== old.style.getPropertyPriority(pname)) {
+                                    if (newPriority === '') {
+                                        styleObj[pname] = newValue;
+                                    }
+                                    else {
+                                        styleObj[pname] = [newValue, newPriority];
+                                    }
+                                }
+                            }
+                            for (const pname of Array.from(old.style)) {
+                                if (target.style.getPropertyValue(pname) === '') {
+                                    styleObj[pname] = false;
+                                }
+                            }
+                        }
+                        catch (error) {
+                            console.warn('[rrweb] Error when parsing update to style attribute:', error);
+                        }
+                    }
+                    else {
+                        const element = m.target;
+                        item.attributes[m.attributeName] = transformAttribute(this.doc, element, element.tagName, m.attributeName, value, this.maskAllText, this.unmaskTextSelector, this.maskTextFn);
+                    }
+                    break;
+                }
+                case 'childList': {
+                    m.addedNodes.forEach((n) => this.genAdds(n, m.target));
+                    m.removedNodes.forEach((n) => {
+                        const nodeId = this.mirror.getId(n);
+                        const parentId = isShadowRoot(m.target)
+                            ? this.mirror.getId(m.target.host)
+                            : this.mirror.getId(m.target);
+                        if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector) || isIgnored(n)) {
+                            return;
+                        }
+                        if (this.addedSet.has(n)) {
+                            deepDelete(this.addedSet, n);
+                            this.droppedSet.add(n);
+                        }
+                        else if (this.addedSet.has(m.target) && nodeId === -1) ;
+                        else if (isAncestorRemoved(m.target, this.mirror)) ;
+                        else if (this.movedSet.has(n) &&
+                            this.movedMap[moveKey(nodeId, parentId)]) {
+                            deepDelete(this.movedSet, n);
+                        }
+                        else {
+                            this.removes.push({
+                                parentId,
+                                id: nodeId,
+                                isShadow: isShadowRoot(m.target) ? true : undefined,
+                            });
+                        }
+                        this.mapRemoves.push(n);
+                    });
+                    break;
+                }
+            }
+        };
+        this.genAdds = (n, target) => {
+            if (target && isBlocked(target, this.blockClass, this.blockSelector, this.unblockSelector)) {
+                return;
+            }
+            if (isINode(n)) {
+                if (isIgnored(n)) {
+                    return;
+                }
+                this.movedSet.add(n);
+                let targetId = null;
+                if (target && isINode(target)) {
+                    targetId = target.__sn.id;
+                }
+                if (targetId) {
+                    this.movedMap[moveKey(n.__sn.id, targetId)] = true;
+                }
+            }
+            else {
+                this.addedSet.add(n);
+                this.droppedSet.delete(n);
+            }
+            if (!isBlocked(n, this.blockClass, this.blockSelector, this.unblockSelector))
+                n.childNodes.forEach((childN) => this.genAdds(childN));
+        };
+    }
+    init(options) {
+        [
+            'mutationCb',
+            'blockClass',
+            'blockSelector',
+            'unblockSelector',
+            'maskTextClass',
+            'maskTextSelector',
+            'unmaskTextSelector',
+            'maskInputSelector',
+            'unmaskInputSelector',
+            'inlineStylesheet',
+            'maskAllText',
+            'maskInputOptions',
+            'maskTextFn',
+            'maskInputFn',
+            'recordCanvas',
+            'inlineImages',
+            'slimDOMOptions',
+            'doc',
+            'mirror',
+            'iframeManager',
+            'shadowDomManager',
+            'canvasManager',
+        ].forEach((key) => {
+            this[key] = options[key];
+        });
+    }
+    freeze() {
+        this.frozen = true;
+        this.canvasManager.freeze();
+    }
+    unfreeze() {
+        this.frozen = false;
+        this.canvasManager.unfreeze();
+        this.emit();
+    }
+    isFrozen() {
+        return this.frozen;
+    }
+    lock() {
+        this.locked = true;
+        this.canvasManager.lock();
+    }
+    unlock() {
+        this.locked = false;
+        this.canvasManager.unlock();
+        this.emit();
+    }
+    reset() {
+        this.shadowDomManager.reset();
+        this.canvasManager.reset();
+    }
+}
+function deepDelete(addsSet, n) {
+    addsSet.delete(n);
+    n.childNodes.forEach((childN) => deepDelete(addsSet, childN));
+}
+function isParentRemoved(removes, n, mirror) {
+    const { parentNode } = n;
+    if (!parentNode) {
+        return false;
+    }
+    const parentId = mirror.getId(parentNode);
+    if (removes.some((r) => r.id === parentId)) {
+        return true;
+    }
+    return isParentRemoved(removes, parentNode, mirror);
+}
+function isAncestorInSet(set, n) {
+    const { parentNode } = n;
+    if (!parentNode) {
+        return false;
+    }
+    if (set.has(parentNode)) {
+        return true;
+    }
+    return isAncestorInSet(set, parentNode);
+}
+
+const callbackWrapper = (cb) => {
+    const rrwebWrapped = (...rest) => {
+        try {
+            return cb(...rest);
+        }
+        catch (error) {
+            try {
+                error.__rrweb__ = true;
+            }
+            catch (_a) {
+            }
+            throw error;
+        }
+    };
+    return rrwebWrapped;
+};
+
+const mutationBuffers = [];
+function getEventTarget(event) {
+    try {
+        if ('composedPath' in event) {
+            const path = event.composedPath();
+            if (path.length) {
+                return path[0];
+            }
+        }
+        else if ('path' in event && event.path.length) {
+            return event.path[0];
+        }
+    }
+    catch (_a) { }
+    return event && event.target;
+}
+function initMutationObserver(options, rootEl) {
+    var _a, _b;
+    const mutationBuffer = new MutationBuffer();
+    mutationBuffers.push(mutationBuffer);
+    mutationBuffer.init(options);
+    let mutationObserverCtor = window.MutationObserver ||
+        window.__rrMutationObserver;
+    const angularZoneSymbol = (_b = (_a = window === null || window === void 0 ? void 0 : window.Zone) === null || _a === void 0 ? void 0 : _a.__symbol__) === null || _b === void 0 ? void 0 : _b.call(_a, 'MutationObserver');
+    if (angularZoneSymbol &&
+        window[angularZoneSymbol]) {
+        mutationObserverCtor = window[angularZoneSymbol];
+    }
+    const observer = new mutationObserverCtor(callbackWrapper((mutations) => {
+        if (options.onMutation && options.onMutation(mutations) === false) {
+            return;
+        }
+        mutationBuffer.processMutations(mutations);
+    }));
+    observer.observe(rootEl, {
+        attributes: true,
+        attributeOldValue: true,
+        characterData: true,
+        characterDataOldValue: true,
+        childList: true,
+        subtree: true,
+    });
+    return observer;
+}
+function initMoveObserver({ mousemoveCb, sampling, doc, mirror, }) {
+    if (sampling.mousemove === false) {
+        return () => { };
+    }
+    const threshold = typeof sampling.mousemove === 'number' ? sampling.mousemove : 50;
+    const callbackThreshold = typeof sampling.mousemoveCallback === 'number'
+        ? sampling.mousemoveCallback
+        : 500;
+    let positions = [];
+    let timeBaseline;
+    const wrappedCb = throttle$1((source) => {
+        const totalOffset = Date.now() - timeBaseline;
+        callbackWrapper(mousemoveCb)(positions.map((p) => {
+            p.timeOffset -= totalOffset;
+            return p;
+        }), source);
+        positions = [];
+        timeBaseline = null;
+    }, callbackThreshold);
+    const updatePosition = throttle$1((evt) => {
+        const target = getEventTarget(evt);
+        const { clientX, clientY } = isTouchEvent(evt)
+            ? evt.changedTouches[0]
+            : evt;
+        if (!timeBaseline) {
+            timeBaseline = Date.now();
+        }
+        positions.push({
+            x: clientX,
+            y: clientY,
+            id: mirror.getId(target),
+            timeOffset: Date.now() - timeBaseline,
+        });
+        wrappedCb(typeof DragEvent !== 'undefined' && evt instanceof DragEvent
+            ? IncrementalSource.Drag
+            : evt instanceof MouseEvent
+                ? IncrementalSource.MouseMove
+                : IncrementalSource.TouchMove);
+    }, threshold, {
+        trailing: false,
+    });
+    const handlers = [
+        on('mousemove', callbackWrapper(updatePosition), doc),
+        on('touchmove', callbackWrapper(updatePosition), doc),
+        on('drag', callbackWrapper(updatePosition), doc),
+    ];
+    return callbackWrapper(() => {
+        handlers.forEach((h) => h());
+    });
+}
+function initMouseInteractionObserver({ mouseInteractionCb, doc, mirror, blockClass, blockSelector, unblockSelector, sampling, }) {
+    if (sampling.mouseInteraction === false) {
+        return () => { };
+    }
+    const disableMap = sampling.mouseInteraction === true ||
+        sampling.mouseInteraction === undefined
+        ? {}
+        : sampling.mouseInteraction;
+    const handlers = [];
+    const getHandler = (eventKey) => {
+        return (event) => {
+            const target = getEventTarget(event);
+            if (isBlocked(target, blockClass, blockSelector, unblockSelector)) {
+                return;
+            }
+            const e = isTouchEvent(event) ? event.changedTouches[0] : event;
+            if (!e) {
+                return;
+            }
+            const id = mirror.getId(target);
+            const { clientX, clientY } = e;
+            callbackWrapper(mouseInteractionCb)({
+                type: MouseInteractions[eventKey],
+                id,
+                x: clientX,
+                y: clientY,
+            });
+        };
+    };
+    Object.keys(MouseInteractions)
+        .filter((key) => Number.isNaN(Number(key)) &&
+        !key.endsWith('_Departed') &&
+        disableMap[key] !== false)
+        .forEach((eventKey) => {
+        const eventName = eventKey.toLowerCase();
+        const handler = callbackWrapper(getHandler(eventKey));
+        handlers.push(on(eventName, handler, doc));
+    });
+    return callbackWrapper(() => {
+        handlers.forEach((h) => h());
+    });
+}
+function initScrollObserver({ scrollCb, doc, mirror, blockClass, blockSelector, unblockSelector, sampling, }) {
+    const updatePosition = throttle$1((evt) => {
+        const target = getEventTarget(evt);
+        if (!target ||
+            isBlocked(target, blockClass, blockSelector, unblockSelector)) {
+            return;
+        }
+        const id = mirror.getId(target);
+        if (target === doc) {
+            const scrollEl = (doc.scrollingElement || doc.documentElement);
+            callbackWrapper(scrollCb)({
+                id,
+                x: scrollEl.scrollLeft,
+                y: scrollEl.scrollTop,
+            });
+        }
+        else {
+            callbackWrapper(scrollCb)({
+                id,
+                x: target.scrollLeft,
+                y: target.scrollTop,
+            });
+        }
+    }, sampling.scroll || 100);
+    return on('scroll', callbackWrapper(updatePosition), doc);
+}
+function initViewportResizeObserver({ viewportResizeCb, }) {
+    let lastH = -1;
+    let lastW = -1;
+    const updateDimension = throttle$1(() => {
+        const height = getWindowHeight();
+        const width = getWindowWidth();
+        if (lastH !== height || lastW !== width) {
+            callbackWrapper(viewportResizeCb)({
+                width: Number(width),
+                height: Number(height),
+            });
+            lastH = height;
+            lastW = width;
+        }
+    }, 200);
+    return on('resize', callbackWrapper(updateDimension), window);
+}
+function wrapEventWithUserTriggeredFlag(v, enable) {
+    const value = Object.assign({}, v);
+    if (!enable)
+        delete value.userTriggered;
+    return value;
+}
+const INPUT_TAGS = ['INPUT', 'TEXTAREA', 'SELECT'];
+const lastInputValueMap = new WeakMap();
+function initInputObserver({ inputCb, doc, mirror, blockClass, blockSelector, unblockSelector, ignoreClass, ignoreSelector, maskInputSelector, unmaskInputSelector, maskInputOptions, maskInputFn, sampling, userTriggeredOnInput, }) {
+    function eventHandler(event) {
+        let target = getEventTarget(event);
+        const tagName = target && target.tagName;
+        const userTriggered = event.isTrusted;
+        if (tagName === 'OPTION')
+            target = target.parentElement;
+        if (!target ||
+            !tagName ||
+            INPUT_TAGS.indexOf(tagName) < 0 ||
+            isBlocked(target, blockClass, blockSelector, unblockSelector)) {
+            return;
+        }
+        const el = target;
+        const type = getInputType(el);
+        if (el.classList.contains(ignoreClass) ||
+            (ignoreSelector && el.matches(ignoreSelector))) {
+            return;
+        }
+        let text = getInputValue(el, tagName, type);
+        let isChecked = false;
+        if (type === 'radio' || type === 'checkbox') {
+            isChecked = target.checked;
+        }
+        if (hasInputMaskOptions({
+            maskInputOptions,
+            maskInputSelector,
+            tagName,
+            type,
+        })) {
+            text = maskInputValue({
+                input: el,
+                maskInputOptions,
+                maskInputSelector,
+                unmaskInputSelector,
+                tagName,
+                type,
+                value: text,
+                maskInputFn,
+            });
+        }
+        cbWithDedup(target, callbackWrapper(wrapEventWithUserTriggeredFlag)({ text, isChecked, userTriggered }, userTriggeredOnInput));
+        const name = target.name;
+        if (type === 'radio' && name && isChecked) {
+            doc
+                .querySelectorAll(`input[type="radio"][name="${name}"]`)
+                .forEach((el) => {
+                if (el !== target) {
+                    const text = maskInputValue({
+                        input: el,
+                        maskInputOptions,
+                        maskInputSelector,
+                        unmaskInputSelector,
+                        tagName,
+                        type,
+                        value: getInputValue(el, tagName, type),
+                        maskInputFn,
+                    });
+                    cbWithDedup(el, callbackWrapper(wrapEventWithUserTriggeredFlag)({
+                        text,
+                        isChecked: !isChecked,
+                        userTriggered: false,
+                    }, userTriggeredOnInput));
+                }
+            });
+        }
+    }
+    function cbWithDedup(target, v) {
+        const lastInputValue = lastInputValueMap.get(target);
+        if (!lastInputValue ||
+            lastInputValue.text !== v.text ||
+            lastInputValue.isChecked !== v.isChecked) {
+            lastInputValueMap.set(target, v);
+            const id = mirror.getId(target);
+            inputCb(Object.assign(Object.assign({}, v), { id }));
+        }
+    }
+    const events = sampling.input === 'last' ? ['change'] : ['input', 'change'];
+    const handlers = events.map((eventName) => on(eventName, callbackWrapper(eventHandler), doc));
+    const propertyDescriptor = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value');
+    const hookProperties = [
+        [HTMLInputElement.prototype, 'value'],
+        [HTMLInputElement.prototype, 'checked'],
+        [HTMLSelectElement.prototype, 'value'],
+        [HTMLTextAreaElement.prototype, 'value'],
+        [HTMLSelectElement.prototype, 'selectedIndex'],
+        [HTMLOptionElement.prototype, 'selected'],
+    ];
+    if (propertyDescriptor && propertyDescriptor.set) {
+        handlers.push(...hookProperties.map((p) => hookSetter(p[0], p[1], {
+            set() {
+                callbackWrapper(eventHandler)({ target: this });
+            },
+        })));
+    }
+    return callbackWrapper(() => {
+        handlers.forEach((h) => h());
+    });
+}
+function getNestedCSSRulePositions(rule) {
+    const positions = [];
+    function recurse(childRule, pos) {
+        if ((hasNestedCSSRule('CSSGroupingRule') &&
+            childRule.parentRule instanceof CSSGroupingRule) ||
+            (hasNestedCSSRule('CSSMediaRule') &&
+                childRule.parentRule instanceof CSSMediaRule) ||
+            (hasNestedCSSRule('CSSSupportsRule') &&
+                childRule.parentRule instanceof CSSSupportsRule) ||
+            (hasNestedCSSRule('CSSConditionRule') &&
+                childRule.parentRule instanceof CSSConditionRule)) {
+            const rules = Array.from(childRule.parentRule.cssRules);
+            const index = rules.indexOf(childRule);
+            pos.unshift(index);
+        }
+        else {
+            const rules = Array.from(childRule.parentStyleSheet.cssRules);
+            const index = rules.indexOf(childRule);
+            pos.unshift(index);
+        }
+        return pos;
+    }
+    return recurse(rule, positions);
+}
+function initStyleSheetObserver({ styleSheetRuleCb, mirror }, { win }) {
+    if (!win.CSSStyleSheet || !win.CSSStyleSheet.prototype) {
+        return () => { };
+    }
+    const insertRule = win.CSSStyleSheet.prototype.insertRule;
+    win.CSSStyleSheet.prototype.insertRule = new Proxy(insertRule, {
+        apply: callbackWrapper((target, thisArg, argumentsList) => {
+            const [rule, index] = argumentsList;
+            const id = mirror.getId(thisArg.ownerNode);
+            if (id !== -1) {
+                styleSheetRuleCb({
+                    id,
+                    adds: [{ rule, index }],
+                });
+            }
+            return target.apply(thisArg, argumentsList);
+        }),
+    });
+    const deleteRule = win.CSSStyleSheet.prototype.deleteRule;
+    win.CSSStyleSheet.prototype.deleteRule = new Proxy(deleteRule, {
+        apply: callbackWrapper((target, thisArg, argumentsList) => {
+            const [index] = argumentsList;
+            const id = mirror.getId(thisArg.ownerNode);
+            if (id !== -1) {
+                styleSheetRuleCb({
+                    id,
+                    removes: [{ index }],
+                });
+            }
+            return target.apply(thisArg, argumentsList);
+        }),
+    });
+    const supportedNestedCSSRuleTypes = {};
+    if (canMonkeyPatchNestedCSSRule('CSSGroupingRule')) {
+        supportedNestedCSSRuleTypes.CSSGroupingRule = win.CSSGroupingRule;
+    }
+    else {
+        if (canMonkeyPatchNestedCSSRule('CSSMediaRule')) {
+            supportedNestedCSSRuleTypes.CSSMediaRule = win.CSSMediaRule;
+        }
+        if (canMonkeyPatchNestedCSSRule('CSSConditionRule')) {
+            supportedNestedCSSRuleTypes.CSSConditionRule = win.CSSConditionRule;
+        }
+        if (canMonkeyPatchNestedCSSRule('CSSSupportsRule')) {
+            supportedNestedCSSRuleTypes.CSSSupportsRule = win.CSSSupportsRule;
+        }
+    }
+    const unmodifiedFunctions = {};
+    Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {
+        unmodifiedFunctions[typeKey] = {
+            insertRule: type.prototype.insertRule,
+            deleteRule: type.prototype.deleteRule,
+        };
+        type.prototype.insertRule = new Proxy(unmodifiedFunctions[typeKey].insertRule, {
+            apply: callbackWrapper((target, thisArg, argumentsList) => {
+                const [rule, index] = argumentsList;
+                const id = mirror.getId(thisArg.parentStyleSheet.ownerNode);
+                if (id !== -1) {
+                    styleSheetRuleCb({
+                        id,
+                        adds: [
+                            {
+                                rule,
+                                index: [
+                                    ...getNestedCSSRulePositions(thisArg),
+                                    index || 0,
+                                ],
+                            },
+                        ],
+                    });
+                }
+                return target.apply(thisArg, argumentsList);
+            }),
+        });
+        type.prototype.deleteRule = new Proxy(unmodifiedFunctions[typeKey].deleteRule, {
+            apply: callbackWrapper((target, thisArg, argumentsList) => {
+                const [index] = argumentsList;
+                const id = mirror.getId(thisArg.parentStyleSheet.ownerNode);
+                if (id !== -1) {
+                    styleSheetRuleCb({
+                        id,
+                        removes: [
+                            { index: [...getNestedCSSRulePositions(thisArg), index] },
+                        ],
+                    });
+                }
+                return target.apply(thisArg, argumentsList);
+            }),
+        });
+    });
+    return callbackWrapper(() => {
+        win.CSSStyleSheet.prototype.insertRule = insertRule;
+        win.CSSStyleSheet.prototype.deleteRule = deleteRule;
+        Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {
+            type.prototype.insertRule = unmodifiedFunctions[typeKey].insertRule;
+            type.prototype.deleteRule = unmodifiedFunctions[typeKey].deleteRule;
+        });
+    });
+}
+function initStyleDeclarationObserver({ styleDeclarationCb, mirror }, { win }) {
+    const setProperty = win.CSSStyleDeclaration.prototype.setProperty;
+    win.CSSStyleDeclaration.prototype.setProperty = new Proxy(setProperty, {
+        apply: callbackWrapper((target, thisArg, argumentsList) => {
+            var _a, _b;
+            const [property, value, priority] = argumentsList;
+            const id = mirror.getId((_b = (_a = thisArg.parentRule) === null || _a === void 0 ? void 0 : _a.parentStyleSheet) === null || _b === void 0 ? void 0 : _b.ownerNode);
+            if (id !== -1) {
+                styleDeclarationCb({
+                    id,
+                    set: {
+                        property,
+                        value,
+                        priority,
+                    },
+                    index: getNestedCSSRulePositions(thisArg.parentRule),
+                });
+            }
+            return target.apply(thisArg, argumentsList);
+        }),
+    });
+    const removeProperty = win.CSSStyleDeclaration.prototype.removeProperty;
+    win.CSSStyleDeclaration.prototype.removeProperty = new Proxy(removeProperty, {
+        apply: callbackWrapper((target, thisArg, argumentsList) => {
+            var _a, _b;
+            const [property] = argumentsList;
+            const id = mirror.getId((_b = (_a = thisArg.parentRule) === null || _a === void 0 ? void 0 : _a.parentStyleSheet) === null || _b === void 0 ? void 0 : _b.ownerNode);
+            if (id !== -1) {
+                styleDeclarationCb({
+                    id,
+                    remove: {
+                        property,
+                    },
+                    index: getNestedCSSRulePositions(thisArg.parentRule),
+                });
+            }
+            return target.apply(thisArg, argumentsList);
+        }),
+    });
+    return callbackWrapper(() => {
+        win.CSSStyleDeclaration.prototype.setProperty = setProperty;
+        win.CSSStyleDeclaration.prototype.removeProperty = removeProperty;
+    });
+}
+function initMediaInteractionObserver({ mediaInteractionCb, blockClass, blockSelector, unblockSelector, mirror, sampling, }) {
+    const handler = (type) => throttle$1(callbackWrapper((event) => {
+        const target = getEventTarget(event);
+        if (!target ||
+            isBlocked(target, blockClass, blockSelector, unblockSelector)) {
+            return;
+        }
+        const { currentTime, volume, muted } = target;
+        mediaInteractionCb({
+            type,
+            id: mirror.getId(target),
+            currentTime,
+            volume,
+            muted,
+        });
+    }), sampling.media || 500);
+    const handlers = [
+        on('play', handler(0)),
+        on('pause', handler(1)),
+        on('seeked', handler(2)),
+        on('volumechange', handler(3)),
+    ];
+    return callbackWrapper(() => {
+        handlers.forEach((h) => h());
+    });
+}
+function initFontObserver({ fontCb, doc }) {
+    const win = doc.defaultView;
+    if (!win) {
+        return () => { };
+    }
+    const handlers = [];
+    const fontMap = new WeakMap();
+    const originalFontFace = win.FontFace;
+    win.FontFace = function FontFace(family, source, descriptors) {
+        const fontFace = new originalFontFace(family, source, descriptors);
+        fontMap.set(fontFace, {
+            family,
+            buffer: typeof source !== 'string',
+            descriptors,
+            fontSource: typeof source === 'string'
+                ? source
+                :
+                    JSON.stringify(Array.from(new Uint8Array(source))),
+        });
+        return fontFace;
+    };
+    const restoreHandler = patch(doc.fonts, 'add', function (original) {
+        return function (fontFace) {
+            setTimeout(() => {
+                const p = fontMap.get(fontFace);
+                if (p) {
+                    fontCb(p);
+                    fontMap.delete(fontFace);
+                }
+            }, 0);
+            return original.apply(this, [fontFace]);
+        };
+    });
+    handlers.push(() => {
+        win.FontFace = originalFontFace;
+    });
+    handlers.push(restoreHandler);
+    return callbackWrapper(() => {
+        handlers.forEach((h) => h());
+    });
+}
+function mergeHooks(o, hooks) {
+    const { mutationCb, mousemoveCb, mouseInteractionCb, scrollCb, viewportResizeCb, inputCb, mediaInteractionCb, styleSheetRuleCb, styleDeclarationCb, canvasMutationCb, fontCb, } = o;
+    o.mutationCb = (...p) => {
+        if (hooks.mutation) {
+            hooks.mutation(...p);
+        }
+        mutationCb(...p);
+    };
+    o.mousemoveCb = (...p) => {
+        if (hooks.mousemove) {
+            hooks.mousemove(...p);
+        }
+        mousemoveCb(...p);
+    };
+    o.mouseInteractionCb = (...p) => {
+        if (hooks.mouseInteraction) {
+            hooks.mouseInteraction(...p);
+        }
+        mouseInteractionCb(...p);
+    };
+    o.scrollCb = (...p) => {
+        if (hooks.scroll) {
+            hooks.scroll(...p);
+        }
+        scrollCb(...p);
+    };
+    o.viewportResizeCb = (...p) => {
+        if (hooks.viewportResize) {
+            hooks.viewportResize(...p);
+        }
+        viewportResizeCb(...p);
+    };
+    o.inputCb = (...p) => {
+        if (hooks.input) {
+            hooks.input(...p);
+        }
+        inputCb(...p);
+    };
+    o.mediaInteractionCb = (...p) => {
+        if (hooks.mediaInteaction) {
+            hooks.mediaInteaction(...p);
+        }
+        mediaInteractionCb(...p);
+    };
+    o.styleSheetRuleCb = (...p) => {
+        if (hooks.styleSheetRule) {
+            hooks.styleSheetRule(...p);
+        }
+        styleSheetRuleCb(...p);
+    };
+    o.styleDeclarationCb = (...p) => {
+        if (hooks.styleDeclaration) {
+            hooks.styleDeclaration(...p);
+        }
+        styleDeclarationCb(...p);
+    };
+    o.canvasMutationCb = (...p) => {
+        if (hooks.canvasMutation) {
+            hooks.canvasMutation(...p);
+        }
+        canvasMutationCb(...p);
+    };
+    o.fontCb = (...p) => {
+        if (hooks.font) {
+            hooks.font(...p);
+        }
+        fontCb(...p);
+    };
+}
+function initObservers(o, hooks = {}) {
+    const currentWindow = o.doc.defaultView;
+    if (!currentWindow) {
+        return () => { };
+    }
+    mergeHooks(o, hooks);
+    const mutationObserver = initMutationObserver(o, o.doc);
+    const mousemoveHandler = initMoveObserver(o);
+    const mouseInteractionHandler = initMouseInteractionObserver(o);
+    const scrollHandler = initScrollObserver(o);
+    const viewportResizeHandler = initViewportResizeObserver(o);
+    const inputHandler = initInputObserver(o);
+    const mediaInteractionHandler = initMediaInteractionObserver(o);
+    const styleSheetObserver = initStyleSheetObserver(o, { win: currentWindow });
+    const styleDeclarationObserver = initStyleDeclarationObserver(o, {
+        win: currentWindow,
+    });
+    const fontObserver = o.collectFonts ? initFontObserver(o) : () => { };
+    const pluginHandlers = [];
+    for (const plugin of o.plugins) {
+        pluginHandlers.push(plugin.observer(plugin.callback, currentWindow, plugin.options));
+    }
+    return callbackWrapper(() => {
+        mutationBuffers.forEach((b) => b.reset());
+        mutationObserver.disconnect();
+        mousemoveHandler();
+        mouseInteractionHandler();
+        scrollHandler();
+        viewportResizeHandler();
+        inputHandler();
+        mediaInteractionHandler();
+        try {
+            styleSheetObserver();
+            styleDeclarationObserver();
+        }
+        catch (e) {
+        }
+        fontObserver();
+        pluginHandlers.forEach((h) => h());
+    });
+}
+function hasNestedCSSRule(prop) {
+    return typeof window[prop] !== 'undefined';
+}
+function canMonkeyPatchNestedCSSRule(prop) {
+    return Boolean(typeof window[prop] !== 'undefined' &&
+        window[prop].prototype &&
+        'insertRule' in window[prop].prototype &&
+        'deleteRule' in window[prop].prototype);
+}
+
+class IframeManager {
+    constructor(options) {
+        this.iframes = new WeakMap();
+        this.mutationCb = options.mutationCb;
+    }
+    addIframe(iframeEl) {
+        this.iframes.set(iframeEl, true);
+    }
+    addLoadListener(cb) {
+        this.loadListener = cb;
+    }
+    attachIframe(iframeEl, childSn) {
+        var _a;
+        this.mutationCb({
+            adds: [
+                {
+                    parentId: iframeEl.__sn.id,
+                    nextId: null,
+                    node: childSn,
+                },
+            ],
+            removes: [],
+            texts: [],
+            attributes: [],
+            isAttachIframe: true,
+        });
+        (_a = this.loadListener) === null || _a === void 0 ? void 0 : _a.call(this, iframeEl);
+    }
+}
+
+class ShadowDomManager {
+    constructor(options) {
+        this.restorePatches = [];
+        this.mutationCb = options.mutationCb;
+        this.scrollCb = options.scrollCb;
+        this.bypassOptions = options.bypassOptions;
+        this.mirror = options.mirror;
+        const manager = this;
+        this.restorePatches.push(patch(HTMLElement.prototype, 'attachShadow', function (original) {
+            return function () {
+                const shadowRoot = original.apply(this, arguments);
+                if (this.shadowRoot)
+                    manager.addShadowRoot(this.shadowRoot, this.ownerDocument);
+                return shadowRoot;
+            };
+        }));
+    }
+    addShadowRoot(shadowRoot, doc) {
+        initMutationObserver(Object.assign(Object.assign({}, this.bypassOptions), { doc, mutationCb: this.mutationCb, mirror: this.mirror, shadowDomManager: this }), shadowRoot);
+        initScrollObserver(Object.assign(Object.assign({}, this.bypassOptions), { scrollCb: this.scrollCb, doc: shadowRoot, mirror: this.mirror }));
+    }
+    observeAttachShadow(iframeElement) {
+        if (iframeElement.contentWindow) {
+            const manager = this;
+            this.restorePatches.push(patch(iframeElement.contentWindow.HTMLElement.prototype, 'attachShadow', function (original) {
+                return function () {
+                    const shadowRoot = original.apply(this, arguments);
+                    if (this.shadowRoot)
+                        manager.addShadowRoot(this.shadowRoot, iframeElement.contentDocument);
+                    return shadowRoot;
+                };
+            }));
+        }
+    }
+    reset() {
+        this.restorePatches.forEach((restorePatch) => restorePatch());
+    }
+}
+
+/******************************************************************************
+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.
+***************************************************************************** */
+
+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 initCanvas2DMutationObserver(cb, win, blockClass, unblockSelector, blockSelector, mirror) {
+    const handlers = [];
+    const props2D = Object.getOwnPropertyNames(win.CanvasRenderingContext2D.prototype);
+    for (const prop of props2D) {
+        try {
+            if (typeof win.CanvasRenderingContext2D.prototype[prop] !== 'function') {
+                continue;
+            }
+            const restoreHandler = patch(win.CanvasRenderingContext2D.prototype, prop, function (original) {
+                return function (...args) {
+                    if (!isBlocked(this.canvas, blockClass, blockSelector, unblockSelector)) {
+                        setTimeout(() => {
+                            const recordArgs = [...args];
+                            if (prop === 'drawImage') {
+                                if (recordArgs[0] &&
+                                    recordArgs[0] instanceof HTMLCanvasElement) {
+                                    const canvas = recordArgs[0];
+                                    const ctx = canvas.getContext('2d');
+                                    let imgd = ctx === null || ctx === void 0 ? void 0 : ctx.getImageData(0, 0, canvas.width, canvas.height);
+                                    let pix = imgd === null || imgd === void 0 ? void 0 : imgd.data;
+                                    recordArgs[0] = JSON.stringify(pix);
+                                }
+                            }
+                            cb(this.canvas, {
+                                type: CanvasContext['2D'],
+                                property: prop,
+                                args: recordArgs,
+                            });
+                        }, 0);
+                    }
+                    return original.apply(this, args);
+                };
+            });
+            handlers.push(restoreHandler);
+        }
+        catch (_a) {
+            const hookHandler = hookSetter(win.CanvasRenderingContext2D.prototype, prop, {
+                set(v) {
+                    cb(this.canvas, {
+                        type: CanvasContext['2D'],
+                        property: prop,
+                        args: [v],
+                        setter: true,
+                    });
+                },
+            });
+            handlers.push(hookHandler);
+        }
+    }
+    return () => {
+        handlers.forEach((h) => h());
+    };
+}
+
+function initCanvasContextObserver(win, blockClass, blockSelector, unblockSelector) {
+    const handlers = [];
+    try {
+        const restoreHandler = patch(win.HTMLCanvasElement.prototype, 'getContext', function (original) {
+            return function (contextType, ...args) {
+                if (!isBlocked(this, blockClass, blockSelector, unblockSelector)) {
+                    if (!('__context' in this))
+                        this.__context = contextType;
+                }
+                return original.apply(this, [contextType, ...args]);
+            };
+        });
+        handlers.push(restoreHandler);
+    }
+    catch (_a) {
+        console.error('failed to patch HTMLCanvasElement.prototype.getContext');
+    }
+    return () => {
+        handlers.forEach((h) => h());
+    };
+}
+
+/*
+ * base64-arraybuffer 1.0.2 <https://github.com/niklasvh/base64-arraybuffer>
+ * Copyright (c) 2022 Niklas von Hertzen <https://hertzen.com>
+ * Released under MIT License
+ */
+var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+// Use a lookup table to find the index.
+var lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
+for (var i = 0; i < chars.length; i++) {
+    lookup[chars.charCodeAt(i)] = i;
+}
+var encode = function (arraybuffer) {
+    var bytes = new Uint8Array(arraybuffer), i, len = bytes.length, base64 = '';
+    for (i = 0; i < len; i += 3) {
+        base64 += chars[bytes[i] >> 2];
+        base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
+        base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
+        base64 += chars[bytes[i + 2] & 63];
+    }
+    if (len % 3 === 2) {
+        base64 = base64.substring(0, base64.length - 1) + '=';
+    }
+    else if (len % 3 === 1) {
+        base64 = base64.substring(0, base64.length - 2) + '==';
+    }
+    return base64;
+};
+
+const webGLVarMap = new Map();
+function variableListFor(ctx, ctor) {
+    let contextMap = webGLVarMap.get(ctx);
+    if (!contextMap) {
+        contextMap = new Map();
+        webGLVarMap.set(ctx, contextMap);
+    }
+    if (!contextMap.has(ctor)) {
+        contextMap.set(ctor, []);
+    }
+    return contextMap.get(ctor);
+}
+const saveWebGLVar = (value, win, ctx) => {
+    if (!value ||
+        !(isInstanceOfWebGLObject(value, win) || typeof value === 'object'))
+        return;
+    const name = value.constructor.name;
+    const list = variableListFor(ctx, name);
+    let index = list.indexOf(value);
+    if (index === -1) {
+        index = list.length;
+        list.push(value);
+    }
+    return index;
+};
+function serializeArg(value, win, ctx) {
+    if (value instanceof Array) {
+        return value.map((arg) => serializeArg(arg, win, ctx));
+    }
+    else if (value === null) {
+        return value;
+    }
+    else if (value instanceof Float32Array ||
+        value instanceof Float64Array ||
+        value instanceof Int32Array ||
+        value instanceof Uint32Array ||
+        value instanceof Uint8Array ||
+        value instanceof Uint16Array ||
+        value instanceof Int16Array ||
+        value instanceof Int8Array ||
+        value instanceof Uint8ClampedArray) {
+        const name = value.constructor.name;
+        return {
+            rr_type: name,
+            args: [Object.values(value)],
+        };
+    }
+    else if (value instanceof ArrayBuffer) {
+        const name = value.constructor.name;
+        const base64 = encode(value);
+        return {
+            rr_type: name,
+            base64,
+        };
+    }
+    else if (value instanceof DataView) {
+        const name = value.constructor.name;
+        return {
+            rr_type: name,
+            args: [
+                serializeArg(value.buffer, win, ctx),
+                value.byteOffset,
+                value.byteLength,
+            ],
+        };
+    }
+    else if (value instanceof HTMLImageElement) {
+        const name = value.constructor.name;
+        const { src } = value;
+        return {
+            rr_type: name,
+            src,
+        };
+    }
+    else if (value instanceof ImageData) {
+        const name = value.constructor.name;
+        return {
+            rr_type: name,
+            args: [serializeArg(value.data, win, ctx), value.width, value.height],
+        };
+    }
+    else if (isInstanceOfWebGLObject(value, win) || typeof value === 'object') {
+        const name = value.constructor.name;
+        const index = saveWebGLVar(value, win, ctx);
+        return {
+            rr_type: name,
+            index: index,
+        };
+    }
+    return value;
+}
+const serializeArgs = (args, win, ctx) => {
+    return [...args].map((arg) => serializeArg(arg, win, ctx));
+};
+const isInstanceOfWebGLObject = (value, win) => {
+    const webGLConstructorNames = [
+        'WebGLActiveInfo',
+        'WebGLBuffer',
+        'WebGLFramebuffer',
+        'WebGLProgram',
+        'WebGLRenderbuffer',
+        'WebGLShader',
+        'WebGLShaderPrecisionFormat',
+        'WebGLTexture',
+        'WebGLUniformLocation',
+        'WebGLVertexArrayObject',
+        'WebGLVertexArrayObjectOES',
+    ];
+    const supportedWebGLConstructorNames = webGLConstructorNames.filter((name) => typeof win[name] === 'function');
+    return Boolean(supportedWebGLConstructorNames.find((name) => value instanceof win[name]));
+};
+
+function patchGLPrototype(prototype, type, cb, blockClass, unblockSelector, blockSelector, mirror, win) {
+    const handlers = [];
+    const props = Object.getOwnPropertyNames(prototype);
+    for (const prop of props) {
+        try {
+            if (typeof prototype[prop] !== 'function') {
+                continue;
+            }
+            const restoreHandler = patch(prototype, prop, function (original) {
+                return function (...args) {
+                    const result = original.apply(this, args);
+                    saveWebGLVar(result, win, prototype);
+                    if (!isBlocked(this.canvas, blockClass, blockSelector, unblockSelector)) {
+                        const id = mirror.getId(this.canvas);
+                        const recordArgs = serializeArgs([...args], win, prototype);
+                        const mutation = {
+                            type,
+                            property: prop,
+                            args: recordArgs,
+                        };
+                        cb(this.canvas, mutation);
+                    }
+                    return result;
+                };
+            });
+            handlers.push(restoreHandler);
+        }
+        catch (_a) {
+            const hookHandler = hookSetter(prototype, prop, {
+                set(v) {
+                    cb(this.canvas, {
+                        type,
+                        property: prop,
+                        args: [v],
+                        setter: true,
+                    });
+                },
+            });
+            handlers.push(hookHandler);
+        }
+    }
+    return handlers;
+}
+function initCanvasWebGLMutationObserver(cb, win, blockClass, blockSelector, unblockSelector, mirror) {
+    const handlers = [];
+    handlers.push(...patchGLPrototype(win.WebGLRenderingContext.prototype, CanvasContext.WebGL, cb, blockClass, blockSelector, unblockSelector, mirror, win));
+    if (typeof win.WebGL2RenderingContext !== 'undefined') {
+        handlers.push(...patchGLPrototype(win.WebGL2RenderingContext.prototype, CanvasContext.WebGL2, cb, blockClass, blockSelector, unblockSelector, mirror, win));
+    }
+    return () => {
+        handlers.forEach((h) => h());
+    };
+}
+
+class CanvasManager {
+    reset() {
+        this.pendingCanvasMutations.clear();
+        this.resetObservers && this.resetObservers();
+    }
+    freeze() {
+        this.frozen = true;
+    }
+    unfreeze() {
+        this.frozen = false;
+    }
+    lock() {
+        this.locked = true;
+    }
+    unlock() {
+        this.locked = false;
+    }
+    constructor(options) {
+        this.pendingCanvasMutations = new Map();
+        this.rafStamps = { latestId: 0, invokeId: null };
+        this.frozen = false;
+        this.locked = false;
+        this.processMutation = function (target, mutation) {
+            const newFrame = this.rafStamps.invokeId &&
+                this.rafStamps.latestId !== this.rafStamps.invokeId;
+            if (newFrame || !this.rafStamps.invokeId)
+                this.rafStamps.invokeId = this.rafStamps.latestId;
+            if (!this.pendingCanvasMutations.has(target)) {
+                this.pendingCanvasMutations.set(target, []);
+            }
+            this.pendingCanvasMutations.get(target).push(mutation);
+        };
+        this.mutationCb = options.mutationCb;
+        this.mirror = options.mirror;
+        if (options.recordCanvas === true)
+            this.initCanvasMutationObserver(options.win, options.blockClass, options.blockSelector, options.unblockSelector);
+    }
+    initCanvasMutationObserver(win, blockClass, unblockSelector, blockSelector) {
+        this.startRAFTimestamping();
+        this.startPendingCanvasMutationFlusher();
+        const canvasContextReset = initCanvasContextObserver(win, blockClass, blockSelector, unblockSelector);
+        const canvas2DReset = initCanvas2DMutationObserver(this.processMutation.bind(this), win, blockClass, blockSelector, unblockSelector, this.mirror);
+        const canvasWebGL1and2Reset = initCanvasWebGLMutationObserver(this.processMutation.bind(this), win, blockClass, blockSelector, unblockSelector, this.mirror);
+        this.resetObservers = () => {
+            canvasContextReset();
+            canvas2DReset();
+            canvasWebGL1and2Reset();
+        };
+    }
+    startPendingCanvasMutationFlusher() {
+        requestAnimationFrame(() => this.flushPendingCanvasMutations());
+    }
+    startRAFTimestamping() {
+        const setLatestRAFTimestamp = (timestamp) => {
+            this.rafStamps.latestId = timestamp;
+            requestAnimationFrame(setLatestRAFTimestamp);
+        };
+        requestAnimationFrame(setLatestRAFTimestamp);
+    }
+    flushPendingCanvasMutations() {
+        this.pendingCanvasMutations.forEach((values, canvas) => {
+            const id = this.mirror.getId(canvas);
+            this.flushPendingCanvasMutationFor(canvas, id);
+        });
+        requestAnimationFrame(() => this.flushPendingCanvasMutations());
+    }
+    flushPendingCanvasMutationFor(canvas, id) {
+        if (this.frozen || this.locked) {
+            return;
+        }
+        const valuesWithType = this.pendingCanvasMutations.get(canvas);
+        if (!valuesWithType || id === -1)
+            return;
+        const values = valuesWithType.map((value) => {
+            const rest = __rest(value, ["type"]);
+            return rest;
+        });
+        const { type } = valuesWithType[0];
+        this.mutationCb({ id, type, commands: values });
+        this.pendingCanvasMutations.delete(canvas);
+    }
+}
+
+function wrapEvent(e) {
+    return Object.assign(Object.assign({}, e), { timestamp: Date.now() });
+}
+let wrappedEmit;
+let takeFullSnapshot;
+const mirror = createMirror();
+function record(options = {}) {
+    const { emit, checkoutEveryNms, checkoutEveryNth, blockClass = 'rr-block', blockSelector = null, unblockSelector = null, ignoreClass = 'rr-ignore', ignoreSelector = null, maskTextClass = 'rr-mask', maskTextSelector = null, maskInputSelector = null, unmaskTextSelector = null, unmaskInputSelector = null, inlineStylesheet = true, maskAllText = false, maskAllInputs, maskInputOptions: _maskInputOptions, slimDOMOptions: _slimDOMOptions, maskInputFn, maskTextFn, hooks, packFn, sampling = {}, mousemoveWait, recordCanvas = false, userTriggeredOnInput = false, collectFonts = false, inlineImages = false, plugins, keepIframeSrcFn = () => false, onMutation, } = options;
+    if (!emit) {
+        throw new Error('emit function is required');
+    }
+    if (mousemoveWait !== undefined && sampling.mousemove === undefined) {
+        sampling.mousemove = mousemoveWait;
+    }
+    const maskInputOptions = maskAllInputs === true
+        ? {
+            color: true,
+            date: true,
+            'datetime-local': true,
+            email: true,
+            month: true,
+            number: true,
+            range: true,
+            search: true,
+            tel: true,
+            text: true,
+            time: true,
+            url: true,
+            week: true,
+            textarea: true,
+            select: true,
+            radio: true,
+            checkbox: true,
+        }
+        : _maskInputOptions !== undefined
+            ? _maskInputOptions
+            : {};
+    const slimDOMOptions = _slimDOMOptions === true || _slimDOMOptions === 'all'
+        ? {
+            script: true,
+            comment: true,
+            headFavicon: true,
+            headWhitespace: true,
+            headMetaSocial: true,
+            headMetaRobots: true,
+            headMetaHttpEquiv: true,
+            headMetaVerification: true,
+            headMetaAuthorship: _slimDOMOptions === 'all',
+            headMetaDescKeywords: _slimDOMOptions === 'all',
+        }
+        : _slimDOMOptions
+            ? _slimDOMOptions
+            : {};
+    polyfill();
+    let lastFullSnapshotEvent;
+    let incrementalSnapshotCount = 0;
+    const eventProcessor = (e) => {
+        for (const plugin of plugins || []) {
+            if (plugin.eventProcessor) {
+                e = plugin.eventProcessor(e);
+            }
+        }
+        if (packFn) {
+            e = packFn(e);
+        }
+        return e;
+    };
+    wrappedEmit = (e, isCheckout) => {
+        var _a;
+        if (((_a = mutationBuffers[0]) === null || _a === void 0 ? void 0 : _a.isFrozen()) &&
+            e.type !== EventType.FullSnapshot &&
+            !(e.type === EventType.IncrementalSnapshot &&
+                e.data.source === IncrementalSource.Mutation)) {
+            mutationBuffers.forEach((buf) => buf.unfreeze());
+        }
+        emit(eventProcessor(e), isCheckout);
+        if (e.type === EventType.FullSnapshot) {
+            lastFullSnapshotEvent = e;
+            incrementalSnapshotCount = 0;
+        }
+        else if (e.type === EventType.IncrementalSnapshot) {
+            if (e.data.source === IncrementalSource.Mutation &&
+                e.data.isAttachIframe) {
+                return;
+            }
+            incrementalSnapshotCount++;
+            const exceedCount = checkoutEveryNth && incrementalSnapshotCount >= checkoutEveryNth;
+            const exceedTime = checkoutEveryNms &&
+                e.timestamp - lastFullSnapshotEvent.timestamp > checkoutEveryNms;
+            if (exceedCount || exceedTime) {
+                takeFullSnapshot(true);
+            }
+        }
+    };
+    const wrappedMutationEmit = (m) => {
+        wrappedEmit(wrapEvent({
+            type: EventType.IncrementalSnapshot,
+            data: Object.assign({ source: IncrementalSource.Mutation }, m),
+        }));
+    };
+    const wrappedScrollEmit = (p) => wrappedEmit(wrapEvent({
+        type: EventType.IncrementalSnapshot,
+        data: Object.assign({ source: IncrementalSource.Scroll }, p),
+    }));
+    const wrappedCanvasMutationEmit = (p) => wrappedEmit(wrapEvent({
+        type: EventType.IncrementalSnapshot,
+        data: Object.assign({ source: IncrementalSource.CanvasMutation }, p),
+    }));
+    const iframeManager = new IframeManager({
+        mutationCb: wrappedMutationEmit,
+    });
+    const canvasManager = new CanvasManager({
+        recordCanvas,
+        mutationCb: wrappedCanvasMutationEmit,
+        win: window,
+        blockClass,
+        blockSelector,
+        unblockSelector,
+        mirror,
+    });
+    const shadowDomManager = new ShadowDomManager({
+        mutationCb: wrappedMutationEmit,
+        scrollCb: wrappedScrollEmit,
+        bypassOptions: {
+            onMutation,
+            blockClass,
+            blockSelector,
+            unblockSelector,
+            maskTextClass,
+            maskTextSelector,
+            unmaskTextSelector,
+            maskInputSelector,
+            unmaskInputSelector,
+            inlineStylesheet,
+            maskAllText,
+            maskInputOptions,
+            maskTextFn,
+            maskInputFn,
+            recordCanvas,
+            inlineImages,
+            sampling,
+            slimDOMOptions,
+            iframeManager,
+            canvasManager,
+        },
+        mirror,
+    });
+    takeFullSnapshot = (isCheckout = false) => {
+        var _a, _b, _c, _d;
+        wrappedEmit(wrapEvent({
+            type: EventType.Meta,
+            data: {
+                href: window.location.href,
+                width: getWindowWidth(),
+                height: getWindowHeight(),
+            },
+        }), isCheckout);
+        mutationBuffers.forEach((buf) => buf.lock());
+        const [node, idNodeMap] = snapshot(document, {
+            blockClass,
+            blockSelector,
+            unblockSelector,
+            maskTextClass,
+            maskTextSelector,
+            unmaskTextSelector,
+            maskInputSelector,
+            unmaskInputSelector,
+            inlineStylesheet,
+            maskAllText,
+            maskAllInputs: maskInputOptions,
+            maskTextFn,
+            slimDOM: slimDOMOptions,
+            recordCanvas,
+            inlineImages,
+            onSerialize: (n) => {
+                if (isIframeINode(n)) {
+                    iframeManager.addIframe(n);
+                }
+                if (hasShadowRoot(n)) {
+                    shadowDomManager.addShadowRoot(n.shadowRoot, document);
+                }
+            },
+            onIframeLoad: (iframe, childSn) => {
+                iframeManager.attachIframe(iframe, childSn);
+                shadowDomManager.observeAttachShadow(iframe);
+            },
+            keepIframeSrcFn,
+        });
+        if (!node) {
+            return console.warn('Failed to snapshot the document');
+        }
+        mirror.map = idNodeMap;
+        wrappedEmit(wrapEvent({
+            type: EventType.FullSnapshot,
+            data: {
+                node,
+                initialOffset: {
+                    left: window.pageXOffset !== undefined
+                        ? window.pageXOffset
+                        : (document === null || document === void 0 ? void 0 : document.documentElement.scrollLeft) ||
+                            ((_b = (_a = document === null || document === void 0 ? void 0 : document.body) === null || _a === void 0 ? void 0 : _a.parentElement) === null || _b === void 0 ? void 0 : _b.scrollLeft) ||
+                            (document === null || document === void 0 ? void 0 : document.body.scrollLeft) ||
+                            0,
+                    top: window.pageYOffset !== undefined
+                        ? window.pageYOffset
+                        : (document === null || document === void 0 ? void 0 : document.documentElement.scrollTop) ||
+                            ((_d = (_c = document === null || document === void 0 ? void 0 : document.body) === null || _c === void 0 ? void 0 : _c.parentElement) === null || _d === void 0 ? void 0 : _d.scrollTop) ||
+                            (document === null || document === void 0 ? void 0 : document.body.scrollTop) ||
+                            0,
+                },
+            },
+        }));
+        mutationBuffers.forEach((buf) => buf.unlock());
+    };
+    try {
+        const handlers = [];
+        handlers.push(on('DOMContentLoaded', () => {
+            wrappedEmit(wrapEvent({
+                type: EventType.DomContentLoaded,
+                data: {},
+            }));
+        }));
+        const observe = (doc) => {
+            var _a;
+            return callbackWrapper(initObservers)({
+                onMutation,
+                mutationCb: wrappedMutationEmit,
+                mousemoveCb: (positions, source) => wrappedEmit(wrapEvent({
+                    type: EventType.IncrementalSnapshot,
+                    data: {
+                        source,
+                        positions,
+                    },
+                })),
+                mouseInteractionCb: (d) => wrappedEmit(wrapEvent({
+                    type: EventType.IncrementalSnapshot,
+                    data: Object.assign({ source: IncrementalSource.MouseInteraction }, d),
+                })),
+                scrollCb: wrappedScrollEmit,
+                viewportResizeCb: (d) => wrappedEmit(wrapEvent({
+                    type: EventType.IncrementalSnapshot,
+                    data: Object.assign({ source: IncrementalSource.ViewportResize }, d),
+                })),
+                inputCb: (v) => wrappedEmit(wrapEvent({
+                    type: EventType.IncrementalSnapshot,
+                    data: Object.assign({ source: IncrementalSource.Input }, v),
+                })),
+                mediaInteractionCb: (p) => wrappedEmit(wrapEvent({
+                    type: EventType.IncrementalSnapshot,
+                    data: Object.assign({ source: IncrementalSource.MediaInteraction }, p),
+                })),
+                styleSheetRuleCb: (r) => wrappedEmit(wrapEvent({
+                    type: EventType.IncrementalSnapshot,
+                    data: Object.assign({ source: IncrementalSource.StyleSheetRule }, r),
+                })),
+                styleDeclarationCb: (r) => wrappedEmit(wrapEvent({
+                    type: EventType.IncrementalSnapshot,
+                    data: Object.assign({ source: IncrementalSource.StyleDeclaration }, r),
+                })),
+                canvasMutationCb: wrappedCanvasMutationEmit,
+                fontCb: (p) => wrappedEmit(wrapEvent({
+                    type: EventType.IncrementalSnapshot,
+                    data: Object.assign({ source: IncrementalSource.Font }, p),
+                })),
+                blockClass,
+                ignoreClass,
+                ignoreSelector,
+                maskTextClass,
+                maskTextSelector,
+                unmaskTextSelector,
+                maskInputSelector,
+                unmaskInputSelector,
+                maskInputOptions,
+                inlineStylesheet,
+                sampling,
+                recordCanvas,
+                inlineImages,
+                userTriggeredOnInput,
+                collectFonts,
+                doc,
+                maskAllText,
+                maskInputFn,
+                maskTextFn,
+                blockSelector,
+                unblockSelector,
+                slimDOMOptions,
+                mirror,
+                iframeManager,
+                shadowDomManager,
+                canvasManager,
+                plugins: ((_a = plugins === null || plugins === void 0 ? void 0 : plugins.filter((p) => p.observer)) === null || _a === void 0 ? void 0 : _a.map((p) => ({
+                    observer: p.observer,
+                    options: p.options,
+                    callback: (payload) => wrappedEmit(wrapEvent({
+                        type: EventType.Plugin,
+                        data: {
+                            plugin: p.name,
+                            payload,
+                        },
+                    })),
+                }))) || [],
+            }, hooks);
+        };
+        iframeManager.addLoadListener((iframeEl) => {
+            try {
+                handlers.push(observe(iframeEl.contentDocument));
+            }
+            catch (error) {
+                console.warn(error);
+            }
+        });
+        const init = () => {
+            takeFullSnapshot();
+            handlers.push(observe(document));
+        };
+        if (document.readyState === 'interactive' ||
+            document.readyState === 'complete') {
+            init();
+        }
+        else {
+            handlers.push(on('load', () => {
+                wrappedEmit(wrapEvent({
+                    type: EventType.Load,
+                    data: {},
+                }));
+                init();
+            }, window));
+        }
+        return () => {
+            handlers.forEach((h) => h());
+        };
+    }
+    catch (error) {
+        console.warn(error);
+    }
+}
+record.addCustomEvent = (tag, payload) => {
+    if (!wrappedEmit) {
+        throw new Error('please add custom event after start recording');
+    }
+    wrappedEmit(wrapEvent({
+        type: EventType.Custom,
+        data: {
+            tag,
+            payload,
+        },
+    }));
+};
+record.freezePage = () => {
+    mutationBuffers.forEach((buf) => buf.freeze());
+};
+record.takeFullSnapshot = (isCheckout) => {
+    if (!takeFullSnapshot) {
+        throw new Error('please take full snapshot after start recording');
+    }
+    takeFullSnapshot(isCheckout);
+};
+record.mirror = mirror;
+
+/**
+ * Converts a timestamp to ms, if it was in s, or keeps it as ms.
+ */
+function timestampToMs(timestamp) {
+  const isMs = timestamp > 9999999999;
+  return isMs ? timestamp : timestamp * 1000;
+}
+
+/**
+ * Converts a timestamp to s, if it was in ms, or keeps it as s.
+ */
+function timestampToS(timestamp) {
+  const isMs = timestamp > 9999999999;
+  return isMs ? timestamp / 1000 : timestamp;
+}
+
+/**
+ * Add a breadcrumb event to replay.
+ */
+function addBreadcrumbEvent(replay, breadcrumb) {
+  if (breadcrumb.category === 'sentry.transaction') {
+    return;
+  }
+
+  if (['ui.click', 'ui.input'].includes(breadcrumb.category )) {
+    replay.triggerUserActivity();
+  } else {
+    replay.checkAndHandleExpiredSession();
+  }
+
+  replay.addUpdate(() => {
+    void replay.throttledAddEvent({
+      type: EventType.Custom,
+      // TODO: We were converting from ms to seconds for breadcrumbs, spans,
+      // but maybe we should just keep them as milliseconds
+      timestamp: (breadcrumb.timestamp || 0) * 1000,
+      data: {
+        tag: 'breadcrumb',
+        // normalize to max. 10 depth and 1_000 properties per object
+        payload: normalize(breadcrumb, 10, 1000),
+      },
+    });
+
+    // Do not flush after console log messages
+    return breadcrumb.category === 'console';
+  });
+}
+
+const INTERACTIVE_SELECTOR = 'button,a';
+
+/**
+ * For clicks, we check if the target is inside of a button or link
+ * If so, we use this as the target instead
+ * This is useful because if you click on the image in <button><img></button>,
+ * The target will be the image, not the button, which we don't want here
+ */
+function getClickTargetNode(event) {
+  const target = getTargetNode(event);
+
+  if (!target || !(target instanceof Element)) {
+    return target;
+  }
+
+  const closestInteractive = target.closest(INTERACTIVE_SELECTOR);
+  return closestInteractive || target;
+}
+
+/** Get the event target node. */
+function getTargetNode(event) {
+  if (isEventWithTarget(event)) {
+    return event.target ;
+  }
+
+  return event;
+}
+
+function isEventWithTarget(event) {
+  return typeof event === 'object' && !!event && 'target' in event;
+}
+
+let handlers;
+
+/**
+ * Register a handler to be called when `window.open()` is called.
+ * Returns a cleanup function.
+ */
+function onWindowOpen(cb) {
+  // Ensure to only register this once
+  if (!handlers) {
+    handlers = [];
+    monkeyPatchWindowOpen();
+  }
+
+  handlers.push(cb);
+
+  return () => {
+    const pos = handlers ? handlers.indexOf(cb) : -1;
+    if (pos > -1) {
+      (handlers ).splice(pos, 1);
+    }
+  };
+}
+
+function monkeyPatchWindowOpen() {
+  fill(WINDOW, 'open', function (originalWindowOpen) {
+    return function (...args) {
+      if (handlers) {
+        try {
+          handlers.forEach(handler => handler());
+        } catch (e) {
+          // ignore errors in here
+        }
+      }
+
+      return originalWindowOpen.apply(WINDOW, args);
+    };
+  });
+}
+
+/** Handle a click. */
+function handleClick(clickDetector, clickBreadcrumb, node) {
+  clickDetector.handleClick(clickBreadcrumb, node);
+}
+
+/** A click detector class that can be used to detect slow or rage clicks on elements. */
+class ClickDetector  {
+  // protected for testing
+
+   constructor(
+    replay,
+    slowClickConfig,
+    // Just for easier testing
+    _addBreadcrumbEvent = addBreadcrumbEvent,
+  ) {
+    this._lastMutation = 0;
+    this._lastScroll = 0;
+    this._clicks = [];
+
+    // We want everything in s, but options are in ms
+    this._timeout = slowClickConfig.timeout / 1000;
+    this._threshold = slowClickConfig.threshold / 1000;
+    this._scollTimeout = slowClickConfig.scrollTimeout / 1000;
+    this._replay = replay;
+    this._ignoreSelector = slowClickConfig.ignoreSelector;
+    this._addBreadcrumbEvent = _addBreadcrumbEvent;
+  }
+
+  /** Register click detection handlers on mutation or scroll. */
+   addListeners() {
+    const mutationHandler = () => {
+      this._lastMutation = nowInSeconds();
+    };
+
+    const scrollHandler = () => {
+      this._lastScroll = nowInSeconds();
+    };
+
+    const cleanupWindowOpen = onWindowOpen(() => {
+      // Treat window.open as mutation
+      this._lastMutation = nowInSeconds();
+    });
+
+    const clickHandler = (event) => {
+      if (!event.target) {
+        return;
+      }
+
+      const node = getClickTargetNode(event);
+      if (node) {
+        this._handleMultiClick(node );
+      }
+    };
+
+    const obs = new MutationObserver(mutationHandler);
+
+    obs.observe(WINDOW.document.documentElement, {
+      attributes: true,
+      characterData: true,
+      childList: true,
+      subtree: true,
+    });
+
+    WINDOW.addEventListener('scroll', scrollHandler, { passive: true });
+    WINDOW.addEventListener('click', clickHandler, { passive: true });
+
+    this._teardown = () => {
+      WINDOW.removeEventListener('scroll', scrollHandler);
+      WINDOW.removeEventListener('click', clickHandler);
+      cleanupWindowOpen();
+
+      obs.disconnect();
+      this._clicks = [];
+      this._lastMutation = 0;
+      this._lastScroll = 0;
+    };
+  }
+
+  /** Clean up listeners. */
+   removeListeners() {
+    if (this._teardown) {
+      this._teardown();
+    }
+
+    if (this._checkClickTimeout) {
+      clearTimeout(this._checkClickTimeout);
+    }
+  }
+
+  /** Handle a click */
+   handleClick(breadcrumb, node) {
+    if (ignoreElement(node, this._ignoreSelector) || !isClickBreadcrumb(breadcrumb)) {
+      return;
+    }
+
+    const newClick = {
+      timestamp: timestampToS(breadcrumb.timestamp),
+      clickBreadcrumb: breadcrumb,
+      // Set this to 0 so we know it originates from the click breadcrumb
+      clickCount: 0,
+      node,
+    };
+
+    // If there was a click in the last 1s on the same element, ignore it - only keep a single reference per second
+    if (
+      this._clicks.some(click => click.node === newClick.node && Math.abs(click.timestamp - newClick.timestamp) < 1)
+    ) {
+      return;
+    }
+
+    this._clicks.push(newClick);
+
+    // If this is the first new click, set a timeout to check for multi clicks
+    if (this._clicks.length === 1) {
+      this._scheduleCheckClicks();
+    }
+  }
+
+  /** Count multiple clicks on elements. */
+   _handleMultiClick(node) {
+    this._getClicks(node).forEach(click => {
+      click.clickCount++;
+    });
+  }
+
+  /** Get all pending clicks for a given node. */
+   _getClicks(node) {
+    return this._clicks.filter(click => click.node === node);
+  }
+
+  /** Check the clicks that happened. */
+   _checkClicks() {
+    const timedOutClicks = [];
+
+    const now = nowInSeconds();
+
+    this._clicks.forEach(click => {
+      if (!click.mutationAfter && this._lastMutation) {
+        click.mutationAfter = click.timestamp <= this._lastMutation ? this._lastMutation - click.timestamp : undefined;
+      }
+      if (!click.scrollAfter && this._lastScroll) {
+        click.scrollAfter = click.timestamp <= this._lastScroll ? this._lastScroll - click.timestamp : undefined;
+      }
+
+      // All of these are in seconds!
+      if (click.timestamp + this._timeout <= now) {
+        timedOutClicks.push(click);
+      }
+    });
+
+    // Remove "old" clicks
+    for (const click of timedOutClicks) {
+      const pos = this._clicks.indexOf(click);
+
+      if (pos > -1) {
+        this._generateBreadcrumbs(click);
+        this._clicks.splice(pos, 1);
+      }
+    }
+
+    // Trigger new check, unless no clicks left
+    if (this._clicks.length) {
+      this._scheduleCheckClicks();
+    }
+  }
+
+  /** Generate matching breadcrumb(s) for the click. */
+   _generateBreadcrumbs(click) {
+    const replay = this._replay;
+    const hadScroll = click.scrollAfter && click.scrollAfter <= this._scollTimeout;
+    const hadMutation = click.mutationAfter && click.mutationAfter <= this._threshold;
+
+    const isSlowClick = !hadScroll && !hadMutation;
+    const { clickCount, clickBreadcrumb } = click;
+
+    // Slow click
+    if (isSlowClick) {
+      // If `mutationAfter` is set, it means a mutation happened after the threshold, but before the timeout
+      // If not, it means we just timed out without scroll & mutation
+      const timeAfterClickMs = Math.min(click.mutationAfter || this._timeout, this._timeout) * 1000;
+      const endReason = timeAfterClickMs < this._timeout * 1000 ? 'mutation' : 'timeout';
+
+      const breadcrumb = {
+        type: 'default',
+        message: clickBreadcrumb.message,
+        timestamp: clickBreadcrumb.timestamp,
+        category: 'ui.slowClickDetected',
+        data: {
+          ...clickBreadcrumb.data,
+          url: WINDOW.location.href,
+          route: replay.getCurrentRoute(),
+          timeAfterClickMs,
+          endReason,
+          // If clickCount === 0, it means multiClick was not correctly captured here
+          // - we still want to send 1 in this case
+          clickCount: clickCount || 1,
+        },
+      };
+
+      this._addBreadcrumbEvent(replay, breadcrumb);
+      return;
+    }
+
+    // Multi click
+    if (clickCount > 1) {
+      const breadcrumb = {
+        type: 'default',
+        message: clickBreadcrumb.message,
+        timestamp: clickBreadcrumb.timestamp,
+        category: 'ui.multiClick',
+        data: {
+          ...clickBreadcrumb.data,
+          url: WINDOW.location.href,
+          route: replay.getCurrentRoute(),
+          clickCount,
+          metric: true,
+        },
+      };
+
+      this._addBreadcrumbEvent(replay, breadcrumb);
+    }
+  }
+
+  /** Schedule to check current clicks. */
+   _scheduleCheckClicks() {
+    if (this._checkClickTimeout) {
+      clearTimeout(this._checkClickTimeout);
+    }
+
+    this._checkClickTimeout = setTimeout(() => this._checkClicks(), 1000);
+  }
+}
+
+const SLOW_CLICK_TAGS = ['A', 'BUTTON', 'INPUT'];
+
+/** exported for tests only */
+function ignoreElement(node, ignoreSelector) {
+  if (!SLOW_CLICK_TAGS.includes(node.tagName)) {
+    return true;
+  }
+
+  // If <input> tag, we only want to consider input[type='submit'] & input[type='button']
+  if (node.tagName === 'INPUT' && !['submit', 'button'].includes(node.getAttribute('type') || '')) {
+    return true;
+  }
+
+  // If <a> tag, detect special variants that may not lead to an action
+  // If target !== _self, we may open the link somewhere else, which would lead to no action
+  // Also, when downloading a file, we may not leave the page, but still not trigger an action
+  if (
+    node.tagName === 'A' &&
+    (node.hasAttribute('download') || (node.hasAttribute('target') && node.getAttribute('target') !== '_self'))
+  ) {
+    return true;
+  }
+
+  if (ignoreSelector && node.matches(ignoreSelector)) {
+    return true;
+  }
+
+  return false;
+}
+
+function isClickBreadcrumb(breadcrumb) {
+  return !!(breadcrumb.data && typeof breadcrumb.data.nodeId === 'number' && breadcrumb.timestamp);
+}
+
+// This is good enough for us, and is easier to test/mock than `timestampInSeconds`
+function nowInSeconds() {
+  return Date.now() / 1000;
+}
+
+/**
+ * Create a breadcrumb for a replay.
+ */
+function createBreadcrumb(
+  breadcrumb,
+) {
+  return {
+    timestamp: Date.now() / 1000,
+    type: 'default',
+    ...breadcrumb,
+  };
+}
+
+var NodeType;
+(function (NodeType) {
+    NodeType[NodeType["Document"] = 0] = "Document";
+    NodeType[NodeType["DocumentType"] = 1] = "DocumentType";
+    NodeType[NodeType["Element"] = 2] = "Element";
+    NodeType[NodeType["Text"] = 3] = "Text";
+    NodeType[NodeType["CDATA"] = 4] = "CDATA";
+    NodeType[NodeType["Comment"] = 5] = "Comment";
+})(NodeType || (NodeType = {}));
+
+// Note that these are the serialized attributes and not attributes directly on
+// the DOM Node. Attributes we are interested in:
+const ATTRIBUTES_TO_RECORD = new Set([
+  'id',
+  'class',
+  'aria-label',
+  'role',
+  'name',
+  'alt',
+  'title',
+  'data-test-id',
+  'data-testid',
+  'disabled',
+  'aria-disabled',
+]);
+
+/**
+ * Inclusion list of attributes that we want to record from the DOM element
+ */
+function getAttributesToRecord(attributes) {
+  const obj = {};
+  for (const key in attributes) {
+    if (ATTRIBUTES_TO_RECORD.has(key)) {
+      let normalizedKey = key;
+
+      if (key === 'data-testid' || key === 'data-test-id') {
+        normalizedKey = 'testId';
+      }
+
+      obj[normalizedKey] = attributes[key];
+    }
+  }
+
+  return obj;
+}
+
+const handleDomListener = (
+  replay,
+) => {
+  return (handlerData) => {
+    if (!replay.isEnabled()) {
+      return;
+    }
+
+    const result = handleDom(handlerData);
+
+    if (!result) {
+      return;
+    }
+
+    const isClick = handlerData.name === 'click';
+    const event = isClick && (handlerData.event );
+    // Ignore clicks if ctrl/alt/meta/shift keys are held down as they alter behavior of clicks (e.g. open in new tab)
+    if (
+      isClick &&
+      replay.clickDetector &&
+      event &&
+      !event.altKey &&
+      !event.metaKey &&
+      !event.ctrlKey &&
+      !event.shiftKey
+    ) {
+      handleClick(
+        replay.clickDetector,
+        result ,
+        getClickTargetNode(handlerData.event) ,
+      );
+    }
+
+    addBreadcrumbEvent(replay, result);
+  };
+};
+
+/** Get the base DOM breadcrumb. */
+function getBaseDomBreadcrumb(target, message) {
+  // `__sn` property is the serialized node created by rrweb
+  const serializedNode = target && isRrwebNode(target) && target.__sn.type === NodeType.Element ? target.__sn : null;
+
+  return {
+    message,
+    data: serializedNode
+      ? {
+          nodeId: serializedNode.id,
+          node: {
+            id: serializedNode.id,
+            tagName: serializedNode.tagName,
+            textContent: target
+              ? Array.from(target.childNodes)
+                  .map(
+                    (node) => '__sn' in node && node.__sn.type === NodeType.Text && node.__sn.textContent,
+                  )
+                  .filter(Boolean) // filter out empty values
+                  .map(text => (text ).trim())
+                  .join('')
+              : '',
+            attributes: getAttributesToRecord(serializedNode.attributes),
+          },
+        }
+      : {},
+  };
+}
+
+/**
+ * An event handler to react to DOM events.
+ * Exported for tests.
+ */
+function handleDom(handlerData) {
+  const { target, message } = getDomTarget(handlerData);
+
+  return createBreadcrumb({
+    category: `ui.${handlerData.name}`,
+    ...getBaseDomBreadcrumb(target, message),
+  });
+}
+
+function getDomTarget(handlerData) {
+  const isClick = handlerData.name === 'click';
+
+  let message;
+  let target = null;
+
+  // Accessing event.target can throw (see getsentry/raven-js#838, #768)
+  try {
+    target = isClick ? getClickTargetNode(handlerData.event) : getTargetNode(handlerData.event);
+    message = htmlTreeAsString(target, { maxStringLength: 200 }) || '<unknown>';
+  } catch (e) {
+    message = '<unknown>';
+  }
+
+  return { target, message };
+}
+
+function isRrwebNode(node) {
+  return '__sn' in node;
+}
+
+/** Handle keyboard events & create breadcrumbs. */
+function handleKeyboardEvent(replay, event) {
+  if (!replay.isEnabled()) {
+    return;
+  }
+
+  // Update user activity, but do not restart recording as it can create
+  // noisy/low-value replays (e.g. user comes back from idle, hits alt-tab, new
+  // session with a single "keydown" breadcrumb is created)
+  replay.updateUserActivity();
+
+  const breadcrumb = getKeyboardBreadcrumb(event);
+
+  if (!breadcrumb) {
+    return;
+  }
+
+  addBreadcrumbEvent(replay, breadcrumb);
+}
+
+/** exported only for tests */
+function getKeyboardBreadcrumb(event) {
+  const { metaKey, shiftKey, ctrlKey, altKey, key, target } = event;
+
+  // never capture for input fields
+  if (!target || isInputElement(target ) || !key) {
+    return null;
+  }
+
+  // Note: We do not consider shift here, as that means "uppercase"
+  const hasModifierKey = metaKey || ctrlKey || altKey;
+  const isCharacterKey = key.length === 1; // other keys like Escape, Tab, etc have a longer length
+
+  // Do not capture breadcrumb if only a word key is pressed
+  // This could leak e.g. user input
+  if (!hasModifierKey && isCharacterKey) {
+    return null;
+  }
+
+  const message = htmlTreeAsString(target, { maxStringLength: 200 }) || '<unknown>';
+  const baseBreadcrumb = getBaseDomBreadcrumb(target , message);
+
+  return createBreadcrumb({
+    category: 'ui.keyDown',
+    message,
+    data: {
+      ...baseBreadcrumb.data,
+      metaKey,
+      shiftKey,
+      ctrlKey,
+      altKey,
+      key,
+    },
+  });
+}
+
+function isInputElement(target) {
+  return target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable;
+}
+
+const NAVIGATION_ENTRY_KEYS = [
+  'name',
+  'type',
+  'startTime',
+  'transferSize',
+  'duration',
+];
+
+function isNavigationEntryEqual(a) {
+  return function (b) {
+    return NAVIGATION_ENTRY_KEYS.every(key => a[key] === b[key]);
+  };
+}
+
+/**
+ * There are some difficulties diagnosing why there are duplicate navigation
+ * entries. We've witnessed several intermittent results:
+ * - duplicate entries have duration = 0
+ * - duplicate entries are the same object reference
+ * - none of the above
+ *
+ * Compare the values of several keys to determine if the entries are duplicates or not.
+ */
+// TODO (high-prio): Figure out wth is returned here
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+function dedupePerformanceEntries(
+  currentList,
+  newList,
+) {
+  // Partition `currentList` into 3 different lists based on entryType
+  const [existingNavigationEntries, existingLcpEntries, existingEntries] = currentList.reduce(
+    (acc, entry) => {
+      if (entry.entryType === 'navigation') {
+        acc[0].push(entry );
+      } else if (entry.entryType === 'largest-contentful-paint') {
+        acc[1].push(entry );
+      } else {
+        acc[2].push(entry);
+      }
+      return acc;
+    },
+    [[], [], []],
+  );
+
+  const newEntries = [];
+  const newNavigationEntries = [];
+  let newLcpEntry = existingLcpEntries.length
+    ? existingLcpEntries[existingLcpEntries.length - 1] // Take the last element as list is sorted
+    : undefined;
+
+  newList.forEach(entry => {
+    if (entry.entryType === 'largest-contentful-paint') {
+      // We want the latest LCP event only
+      if (!newLcpEntry || newLcpEntry.startTime < entry.startTime) {
+        newLcpEntry = entry;
+      }
+      return;
+    }
+
+    if (entry.entryType === 'navigation') {
+      const navigationEntry = entry ;
+
+      // Check if the navigation entry is contained in currentList or newList
+      if (
+        // Ignore any navigation entries with duration 0, as they are likely duplicates
+        entry.duration > 0 &&
+        // Ensure new entry does not already exist in existing entries
+        !existingNavigationEntries.find(isNavigationEntryEqual(navigationEntry)) &&
+        // Ensure new entry does not already exist in new list of navigation entries
+        !newNavigationEntries.find(isNavigationEntryEqual(navigationEntry))
+      ) {
+        newNavigationEntries.push(navigationEntry);
+      }
+
+      // Otherwise this navigation entry is considered a duplicate and is thrown away
+      return;
+    }
+
+    newEntries.push(entry);
+  });
+
+  // Re-combine and sort by startTime
+  return [
+    ...(newLcpEntry ? [newLcpEntry] : []),
+    ...existingNavigationEntries,
+    ...existingEntries,
+    ...newEntries,
+    ...newNavigationEntries,
+  ].sort((a, b) => a.startTime - b.startTime);
+}
+
+/**
+ * Sets up a PerformanceObserver to listen to all performance entry types.
+ */
+function setupPerformanceObserver(replay) {
+  const performanceObserverHandler = (list) => {
+    // For whatever reason the observer was returning duplicate navigation
+    // entries (the other entry types were not duplicated).
+    const newPerformanceEntries = dedupePerformanceEntries(
+      replay.performanceEvents,
+      list.getEntries() ,
+    );
+    replay.performanceEvents = newPerformanceEntries;
+  };
+
+  const performanceObserver = new PerformanceObserver(performanceObserverHandler);
+
+  [
+    'element',
+    'event',
+    'first-input',
+    'largest-contentful-paint',
+    'layout-shift',
+    'longtask',
+    'navigation',
+    'paint',
+    'resource',
+  ].forEach(type => {
+    try {
+      performanceObserver.observe({
+        type,
+        buffered: true,
+      });
+    } catch (e) {
+      // This can throw if an entry type is not supported in the browser.
+      // Ignore these errors.
+    }
+  });
+
+  return performanceObserver;
+}
+
+const r = `/*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
+function t(t){let e=t.length;for(;--e>=0;)t[e]=0}const e=new Uint8Array([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0]),a=new Uint8Array([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13]),i=new Uint8Array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7]),n=new Uint8Array([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),s=new Array(576);t(s);const r=new Array(60);t(r);const o=new Array(512);t(o);const l=new Array(256);t(l);const h=new Array(29);t(h);const d=new Array(30);function _(t,e,a,i,n){this.static_tree=t,this.extra_bits=e,this.extra_base=a,this.elems=i,this.max_length=n,this.has_stree=t&&t.length}let f,c,u;function w(t,e){this.dyn_tree=t,this.max_code=0,this.stat_desc=e}t(d);const m=t=>t<256?o[t]:o[256+(t>>>7)],b=(t,e)=>{t.pending_buf[t.pending++]=255&e,t.pending_buf[t.pending++]=e>>>8&255},g=(t,e,a)=>{t.bi_valid>16-a?(t.bi_buf|=e<<t.bi_valid&65535,b(t,t.bi_buf),t.bi_buf=e>>16-t.bi_valid,t.bi_valid+=a-16):(t.bi_buf|=e<<t.bi_valid&65535,t.bi_valid+=a)},p=(t,e,a)=>{g(t,a[2*e],a[2*e+1])},k=(t,e)=>{let a=0;do{a|=1&t,t>>>=1,a<<=1}while(--e>0);return a>>>1},v=(t,e,a)=>{const i=new Array(16);let n,s,r=0;for(n=1;n<=15;n++)r=r+a[n-1]<<1,i[n]=r;for(s=0;s<=e;s++){let e=t[2*s+1];0!==e&&(t[2*s]=k(i[e]++,e))}},y=t=>{let e;for(e=0;e<286;e++)t.dyn_ltree[2*e]=0;for(e=0;e<30;e++)t.dyn_dtree[2*e]=0;for(e=0;e<19;e++)t.bl_tree[2*e]=0;t.dyn_ltree[512]=1,t.opt_len=t.static_len=0,t.sym_next=t.matches=0},x=t=>{t.bi_valid>8?b(t,t.bi_buf):t.bi_valid>0&&(t.pending_buf[t.pending++]=t.bi_buf),t.bi_buf=0,t.bi_valid=0},z=(t,e,a,i)=>{const n=2*e,s=2*a;return t[n]<t[s]||t[n]===t[s]&&i[e]<=i[a]},A=(t,e,a)=>{const i=t.heap[a];let n=a<<1;for(;n<=t.heap_len&&(n<t.heap_len&&z(e,t.heap[n+1],t.heap[n],t.depth)&&n++,!z(e,i,t.heap[n],t.depth));)t.heap[a]=t.heap[n],a=n,n<<=1;t.heap[a]=i},E=(t,i,n)=>{let s,r,o,_,f=0;if(0!==t.sym_next)do{s=255&t.pending_buf[t.sym_buf+f++],s+=(255&t.pending_buf[t.sym_buf+f++])<<8,r=t.pending_buf[t.sym_buf+f++],0===s?p(t,r,i):(o=l[r],p(t,o+256+1,i),_=e[o],0!==_&&(r-=h[o],g(t,r,_)),s--,o=m(s),p(t,o,n),_=a[o],0!==_&&(s-=d[o],g(t,s,_)))}while(f<t.sym_next);p(t,256,i)},R=(t,e)=>{const a=e.dyn_tree,i=e.stat_desc.static_tree,n=e.stat_desc.has_stree,s=e.stat_desc.elems;let r,o,l,h=-1;for(t.heap_len=0,t.heap_max=573,r=0;r<s;r++)0!==a[2*r]?(t.heap[++t.heap_len]=h=r,t.depth[r]=0):a[2*r+1]=0;for(;t.heap_len<2;)l=t.heap[++t.heap_len]=h<2?++h:0,a[2*l]=1,t.depth[l]=0,t.opt_len--,n&&(t.static_len-=i[2*l+1]);for(e.max_code=h,r=t.heap_len>>1;r>=1;r--)A(t,a,r);l=s;do{r=t.heap[1],t.heap[1]=t.heap[t.heap_len--],A(t,a,1),o=t.heap[1],t.heap[--t.heap_max]=r,t.heap[--t.heap_max]=o,a[2*l]=a[2*r]+a[2*o],t.depth[l]=(t.depth[r]>=t.depth[o]?t.depth[r]:t.depth[o])+1,a[2*r+1]=a[2*o+1]=l,t.heap[1]=l++,A(t,a,1)}while(t.heap_len>=2);t.heap[--t.heap_max]=t.heap[1],((t,e)=>{const a=e.dyn_tree,i=e.max_code,n=e.stat_desc.static_tree,s=e.stat_desc.has_stree,r=e.stat_desc.extra_bits,o=e.stat_desc.extra_base,l=e.stat_desc.max_length;let h,d,_,f,c,u,w=0;for(f=0;f<=15;f++)t.bl_count[f]=0;for(a[2*t.heap[t.heap_max]+1]=0,h=t.heap_max+1;h<573;h++)d=t.heap[h],f=a[2*a[2*d+1]+1]+1,f>l&&(f=l,w++),a[2*d+1]=f,d>i||(t.bl_count[f]++,c=0,d>=o&&(c=r[d-o]),u=a[2*d],t.opt_len+=u*(f+c),s&&(t.static_len+=u*(n[2*d+1]+c)));if(0!==w){do{for(f=l-1;0===t.bl_count[f];)f--;t.bl_count[f]--,t.bl_count[f+1]+=2,t.bl_count[l]--,w-=2}while(w>0);for(f=l;0!==f;f--)for(d=t.bl_count[f];0!==d;)_=t.heap[--h],_>i||(a[2*_+1]!==f&&(t.opt_len+=(f-a[2*_+1])*a[2*_],a[2*_+1]=f),d--)}})(t,e),v(a,h,t.bl_count)},Z=(t,e,a)=>{let i,n,s=-1,r=e[1],o=0,l=7,h=4;for(0===r&&(l=138,h=3),e[2*(a+1)+1]=65535,i=0;i<=a;i++)n=r,r=e[2*(i+1)+1],++o<l&&n===r||(o<h?t.bl_tree[2*n]+=o:0!==n?(n!==s&&t.bl_tree[2*n]++,t.bl_tree[32]++):o<=10?t.bl_tree[34]++:t.bl_tree[36]++,o=0,s=n,0===r?(l=138,h=3):n===r?(l=6,h=3):(l=7,h=4))},U=(t,e,a)=>{let i,n,s=-1,r=e[1],o=0,l=7,h=4;for(0===r&&(l=138,h=3),i=0;i<=a;i++)if(n=r,r=e[2*(i+1)+1],!(++o<l&&n===r)){if(o<h)do{p(t,n,t.bl_tree)}while(0!=--o);else 0!==n?(n!==s&&(p(t,n,t.bl_tree),o--),p(t,16,t.bl_tree),g(t,o-3,2)):o<=10?(p(t,17,t.bl_tree),g(t,o-3,3)):(p(t,18,t.bl_tree),g(t,o-11,7));o=0,s=n,0===r?(l=138,h=3):n===r?(l=6,h=3):(l=7,h=4)}};let S=!1;const D=(t,e,a,i)=>{g(t,0+(i?1:0),3),x(t),b(t,a),b(t,~a),a&&t.pending_buf.set(t.window.subarray(e,e+a),t.pending),t.pending+=a};var T=(t,e,a,i)=>{let o,l,h=0;t.level>0?(2===t.strm.data_type&&(t.strm.data_type=(t=>{let e,a=4093624447;for(e=0;e<=31;e++,a>>>=1)if(1&a&&0!==t.dyn_ltree[2*e])return 0;if(0!==t.dyn_ltree[18]||0!==t.dyn_ltree[20]||0!==t.dyn_ltree[26])return 1;for(e=32;e<256;e++)if(0!==t.dyn_ltree[2*e])return 1;return 0})(t)),R(t,t.l_desc),R(t,t.d_desc),h=(t=>{let e;for(Z(t,t.dyn_ltree,t.l_desc.max_code),Z(t,t.dyn_dtree,t.d_desc.max_code),R(t,t.bl_desc),e=18;e>=3&&0===t.bl_tree[2*n[e]+1];e--);return t.opt_len+=3*(e+1)+5+5+4,e})(t),o=t.opt_len+3+7>>>3,l=t.static_len+3+7>>>3,l<=o&&(o=l)):o=l=a+5,a+4<=o&&-1!==e?D(t,e,a,i):4===t.strategy||l===o?(g(t,2+(i?1:0),3),E(t,s,r)):(g(t,4+(i?1:0),3),((t,e,a,i)=>{let s;for(g(t,e-257,5),g(t,a-1,5),g(t,i-4,4),s=0;s<i;s++)g(t,t.bl_tree[2*n[s]+1],3);U(t,t.dyn_ltree,e-1),U(t,t.dyn_dtree,a-1)})(t,t.l_desc.max_code+1,t.d_desc.max_code+1,h+1),E(t,t.dyn_ltree,t.dyn_dtree)),y(t),i&&x(t)},O={_tr_init:t=>{S||((()=>{let t,n,w,m,b;const g=new Array(16);for(w=0,m=0;m<28;m++)for(h[m]=w,t=0;t<1<<e[m];t++)l[w++]=m;for(l[w-1]=m,b=0,m=0;m<16;m++)for(d[m]=b,t=0;t<1<<a[m];t++)o[b++]=m;for(b>>=7;m<30;m++)for(d[m]=b<<7,t=0;t<1<<a[m]-7;t++)o[256+b++]=m;for(n=0;n<=15;n++)g[n]=0;for(t=0;t<=143;)s[2*t+1]=8,t++,g[8]++;for(;t<=255;)s[2*t+1]=9,t++,g[9]++;for(;t<=279;)s[2*t+1]=7,t++,g[7]++;for(;t<=287;)s[2*t+1]=8,t++,g[8]++;for(v(s,287,g),t=0;t<30;t++)r[2*t+1]=5,r[2*t]=k(t,5);f=new _(s,e,257,286,15),c=new _(r,a,0,30,15),u=new _(new Array(0),i,0,19,7)})(),S=!0),t.l_desc=new w(t.dyn_ltree,f),t.d_desc=new w(t.dyn_dtree,c),t.bl_desc=new w(t.bl_tree,u),t.bi_buf=0,t.bi_valid=0,y(t)},_tr_stored_block:D,_tr_flush_block:T,_tr_tally:(t,e,a)=>(t.pending_buf[t.sym_buf+t.sym_next++]=e,t.pending_buf[t.sym_buf+t.sym_next++]=e>>8,t.pending_buf[t.sym_buf+t.sym_next++]=a,0===e?t.dyn_ltree[2*a]++:(t.matches++,e--,t.dyn_ltree[2*(l[a]+256+1)]++,t.dyn_dtree[2*m(e)]++),t.sym_next===t.sym_end),_tr_align:t=>{g(t,2,3),p(t,256,s),(t=>{16===t.bi_valid?(b(t,t.bi_buf),t.bi_buf=0,t.bi_valid=0):t.bi_valid>=8&&(t.pending_buf[t.pending++]=255&t.bi_buf,t.bi_buf>>=8,t.bi_valid-=8)})(t)}};var F=(t,e,a,i)=>{let n=65535&t|0,s=t>>>16&65535|0,r=0;for(;0!==a;){r=a>2e3?2e3:a,a-=r;do{n=n+e[i++]|0,s=s+n|0}while(--r);n%=65521,s%=65521}return n|s<<16|0};const L=new Uint32Array((()=>{let t,e=[];for(var a=0;a<256;a++){t=a;for(var i=0;i<8;i++)t=1&t?3988292384^t>>>1:t>>>1;e[a]=t}return e})());var N=(t,e,a,i)=>{const n=L,s=i+a;t^=-1;for(let a=i;a<s;a++)t=t>>>8^n[255&(t^e[a])];return-1^t},I={2:"need dictionary",1:"stream end",0:"","-1":"file error","-2":"stream error","-3":"data error","-4":"insufficient memory","-5":"buffer error","-6":"incompatible version"},B={Z_NO_FLUSH:0,Z_PARTIAL_FLUSH:1,Z_SYNC_FLUSH:2,Z_FULL_FLUSH:3,Z_FINISH:4,Z_BLOCK:5,Z_TREES:6,Z_OK:0,Z_STREAM_END:1,Z_NEED_DICT:2,Z_ERRNO:-1,Z_STREAM_ERROR:-2,Z_DATA_ERROR:-3,Z_MEM_ERROR:-4,Z_BUF_ERROR:-5,Z_NO_COMPRESSION:0,Z_BEST_SPEED:1,Z_BEST_COMPRESSION:9,Z_DEFAULT_COMPRESSION:-1,Z_FILTERED:1,Z_HUFFMAN_ONLY:2,Z_RLE:3,Z_FIXED:4,Z_DEFAULT_STRATEGY:0,Z_BINARY:0,Z_TEXT:1,Z_UNKNOWN:2,Z_DEFLATED:8};const{_tr_init:C,_tr_stored_block:H,_tr_flush_block:M,_tr_tally:j,_tr_align:K}=O,{Z_NO_FLUSH:P,Z_PARTIAL_FLUSH:Y,Z_FULL_FLUSH:G,Z_FINISH:X,Z_BLOCK:W,Z_OK:q,Z_STREAM_END:J,Z_STREAM_ERROR:Q,Z_DATA_ERROR:V,Z_BUF_ERROR:$,Z_DEFAULT_COMPRESSION:tt,Z_FILTERED:et,Z_HUFFMAN_ONLY:at,Z_RLE:it,Z_FIXED:nt,Z_DEFAULT_STRATEGY:st,Z_UNKNOWN:rt,Z_DEFLATED:ot}=B,lt=(t,e)=>(t.msg=I[e],e),ht=t=>2*t-(t>4?9:0),dt=t=>{let e=t.length;for(;--e>=0;)t[e]=0},_t=t=>{let e,a,i,n=t.w_size;e=t.hash_size,i=e;do{a=t.head[--i],t.head[i]=a>=n?a-n:0}while(--e);e=n,i=e;do{a=t.prev[--i],t.prev[i]=a>=n?a-n:0}while(--e)};let ft=(t,e,a)=>(e<<t.hash_shift^a)&t.hash_mask;const ct=t=>{const e=t.state;let a=e.pending;a>t.avail_out&&(a=t.avail_out),0!==a&&(t.output.set(e.pending_buf.subarray(e.pending_out,e.pending_out+a),t.next_out),t.next_out+=a,e.pending_out+=a,t.total_out+=a,t.avail_out-=a,e.pending-=a,0===e.pending&&(e.pending_out=0))},ut=(t,e)=>{M(t,t.block_start>=0?t.block_start:-1,t.strstart-t.block_start,e),t.block_start=t.strstart,ct(t.strm)},wt=(t,e)=>{t.pending_buf[t.pending++]=e},mt=(t,e)=>{t.pending_buf[t.pending++]=e>>>8&255,t.pending_buf[t.pending++]=255&e},bt=(t,e,a,i)=>{let n=t.avail_in;return n>i&&(n=i),0===n?0:(t.avail_in-=n,e.set(t.input.subarray(t.next_in,t.next_in+n),a),1===t.state.wrap?t.adler=F(t.adler,e,n,a):2===t.state.wrap&&(t.adler=N(t.adler,e,n,a)),t.next_in+=n,t.total_in+=n,n)},gt=(t,e)=>{let a,i,n=t.max_chain_length,s=t.strstart,r=t.prev_length,o=t.nice_match;const l=t.strstart>t.w_size-262?t.strstart-(t.w_size-262):0,h=t.window,d=t.w_mask,_=t.prev,f=t.strstart+258;let c=h[s+r-1],u=h[s+r];t.prev_length>=t.good_match&&(n>>=2),o>t.lookahead&&(o=t.lookahead);do{if(a=e,h[a+r]===u&&h[a+r-1]===c&&h[a]===h[s]&&h[++a]===h[s+1]){s+=2,a++;do{}while(h[++s]===h[++a]&&h[++s]===h[++a]&&h[++s]===h[++a]&&h[++s]===h[++a]&&h[++s]===h[++a]&&h[++s]===h[++a]&&h[++s]===h[++a]&&h[++s]===h[++a]&&s<f);if(i=258-(f-s),s=f-258,i>r){if(t.match_start=e,r=i,i>=o)break;c=h[s+r-1],u=h[s+r]}}}while((e=_[e&d])>l&&0!=--n);return r<=t.lookahead?r:t.lookahead},pt=t=>{const e=t.w_size;let a,i,n;do{if(i=t.window_size-t.lookahead-t.strstart,t.strstart>=e+(e-262)&&(t.window.set(t.window.subarray(e,e+e-i),0),t.match_start-=e,t.strstart-=e,t.block_start-=e,t.insert>t.strstart&&(t.insert=t.strstart),_t(t),i+=e),0===t.strm.avail_in)break;if(a=bt(t.strm,t.window,t.strstart+t.lookahead,i),t.lookahead+=a,t.lookahead+t.insert>=3)for(n=t.strstart-t.insert,t.ins_h=t.window[n],t.ins_h=ft(t,t.ins_h,t.window[n+1]);t.insert&&(t.ins_h=ft(t,t.ins_h,t.window[n+3-1]),t.prev[n&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=n,n++,t.insert--,!(t.lookahead+t.insert<3)););}while(t.lookahead<262&&0!==t.strm.avail_in)},kt=(t,e)=>{let a,i,n,s=t.pending_buf_size-5>t.w_size?t.w_size:t.pending_buf_size-5,r=0,o=t.strm.avail_in;do{if(a=65535,n=t.bi_valid+42>>3,t.strm.avail_out<n)break;if(n=t.strm.avail_out-n,i=t.strstart-t.block_start,a>i+t.strm.avail_in&&(a=i+t.strm.avail_in),a>n&&(a=n),a<s&&(0===a&&e!==X||e===P||a!==i+t.strm.avail_in))break;r=e===X&&a===i+t.strm.avail_in?1:0,H(t,0,0,r),t.pending_buf[t.pending-4]=a,t.pending_buf[t.pending-3]=a>>8,t.pending_buf[t.pending-2]=~a,t.pending_buf[t.pending-1]=~a>>8,ct(t.strm),i&&(i>a&&(i=a),t.strm.output.set(t.window.subarray(t.block_start,t.block_start+i),t.strm.next_out),t.strm.next_out+=i,t.strm.avail_out-=i,t.strm.total_out+=i,t.block_start+=i,a-=i),a&&(bt(t.strm,t.strm.output,t.strm.next_out,a),t.strm.next_out+=a,t.strm.avail_out-=a,t.strm.total_out+=a)}while(0===r);return o-=t.strm.avail_in,o&&(o>=t.w_size?(t.matches=2,t.window.set(t.strm.input.subarray(t.strm.next_in-t.w_size,t.strm.next_in),0),t.strstart=t.w_size,t.insert=t.strstart):(t.window_size-t.strstart<=o&&(t.strstart-=t.w_size,t.window.set(t.window.subarray(t.w_size,t.w_size+t.strstart),0),t.matches<2&&t.matches++,t.insert>t.strstart&&(t.insert=t.strstart)),t.window.set(t.strm.input.subarray(t.strm.next_in-o,t.strm.next_in),t.strstart),t.strstart+=o,t.insert+=o>t.w_size-t.insert?t.w_size-t.insert:o),t.block_start=t.strstart),t.high_water<t.strstart&&(t.high_water=t.strstart),r?4:e!==P&&e!==X&&0===t.strm.avail_in&&t.strstart===t.block_start?2:(n=t.window_size-t.strstart,t.strm.avail_in>n&&t.block_start>=t.w_size&&(t.block_start-=t.w_size,t.strstart-=t.w_size,t.window.set(t.window.subarray(t.w_size,t.w_size+t.strstart),0),t.matches<2&&t.matches++,n+=t.w_size,t.insert>t.strstart&&(t.insert=t.strstart)),n>t.strm.avail_in&&(n=t.strm.avail_in),n&&(bt(t.strm,t.window,t.strstart,n),t.strstart+=n,t.insert+=n>t.w_size-t.insert?t.w_size-t.insert:n),t.high_water<t.strstart&&(t.high_water=t.strstart),n=t.bi_valid+42>>3,n=t.pending_buf_size-n>65535?65535:t.pending_buf_size-n,s=n>t.w_size?t.w_size:n,i=t.strstart-t.block_start,(i>=s||(i||e===X)&&e!==P&&0===t.strm.avail_in&&i<=n)&&(a=i>n?n:i,r=e===X&&0===t.strm.avail_in&&a===i?1:0,H(t,t.block_start,a,r),t.block_start+=a,ct(t.strm)),r?3:1)},vt=(t,e)=>{let a,i;for(;;){if(t.lookahead<262){if(pt(t),t.lookahead<262&&e===P)return 1;if(0===t.lookahead)break}if(a=0,t.lookahead>=3&&(t.ins_h=ft(t,t.ins_h,t.window[t.strstart+3-1]),a=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart),0!==a&&t.strstart-a<=t.w_size-262&&(t.match_length=gt(t,a)),t.match_length>=3)if(i=j(t,t.strstart-t.match_start,t.match_length-3),t.lookahead-=t.match_length,t.match_length<=t.max_lazy_match&&t.lookahead>=3){t.match_length--;do{t.strstart++,t.ins_h=ft(t,t.ins_h,t.window[t.strstart+3-1]),a=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart}while(0!=--t.match_length);t.strstart++}else t.strstart+=t.match_length,t.match_length=0,t.ins_h=t.window[t.strstart],t.ins_h=ft(t,t.ins_h,t.window[t.strstart+1]);else i=j(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++;if(i&&(ut(t,!1),0===t.strm.avail_out))return 1}return t.insert=t.strstart<2?t.strstart:2,e===X?(ut(t,!0),0===t.strm.avail_out?3:4):t.sym_next&&(ut(t,!1),0===t.strm.avail_out)?1:2},yt=(t,e)=>{let a,i,n;for(;;){if(t.lookahead<262){if(pt(t),t.lookahead<262&&e===P)return 1;if(0===t.lookahead)break}if(a=0,t.lookahead>=3&&(t.ins_h=ft(t,t.ins_h,t.window[t.strstart+3-1]),a=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart),t.prev_length=t.match_length,t.prev_match=t.match_start,t.match_length=2,0!==a&&t.prev_length<t.max_lazy_match&&t.strstart-a<=t.w_size-262&&(t.match_length=gt(t,a),t.match_length<=5&&(t.strategy===et||3===t.match_length&&t.strstart-t.match_start>4096)&&(t.match_length=2)),t.prev_length>=3&&t.match_length<=t.prev_length){n=t.strstart+t.lookahead-3,i=j(t,t.strstart-1-t.prev_match,t.prev_length-3),t.lookahead-=t.prev_length-1,t.prev_length-=2;do{++t.strstart<=n&&(t.ins_h=ft(t,t.ins_h,t.window[t.strstart+3-1]),a=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart)}while(0!=--t.prev_length);if(t.match_available=0,t.match_length=2,t.strstart++,i&&(ut(t,!1),0===t.strm.avail_out))return 1}else if(t.match_available){if(i=j(t,0,t.window[t.strstart-1]),i&&ut(t,!1),t.strstart++,t.lookahead--,0===t.strm.avail_out)return 1}else t.match_available=1,t.strstart++,t.lookahead--}return t.match_available&&(i=j(t,0,t.window[t.strstart-1]),t.match_available=0),t.insert=t.strstart<2?t.strstart:2,e===X?(ut(t,!0),0===t.strm.avail_out?3:4):t.sym_next&&(ut(t,!1),0===t.strm.avail_out)?1:2};function xt(t,e,a,i,n){this.good_length=t,this.max_lazy=e,this.nice_length=a,this.max_chain=i,this.func=n}const zt=[new xt(0,0,0,0,kt),new xt(4,4,8,4,vt),new xt(4,5,16,8,vt),new xt(4,6,32,32,vt),new xt(4,4,16,16,yt),new xt(8,16,32,32,yt),new xt(8,16,128,128,yt),new xt(8,32,128,256,yt),new xt(32,128,258,1024,yt),new xt(32,258,258,4096,yt)];function At(){this.strm=null,this.status=0,this.pending_buf=null,this.pending_buf_size=0,this.pending_out=0,this.pending=0,this.wrap=0,this.gzhead=null,this.gzindex=0,this.method=ot,this.last_flush=-1,this.w_size=0,this.w_bits=0,this.w_mask=0,this.window=null,this.window_size=0,this.prev=null,this.head=null,this.ins_h=0,this.hash_size=0,this.hash_bits=0,this.hash_mask=0,this.hash_shift=0,this.block_start=0,this.match_length=0,this.prev_match=0,this.match_available=0,this.strstart=0,this.match_start=0,this.lookahead=0,this.prev_length=0,this.max_chain_length=0,this.max_lazy_match=0,this.level=0,this.strategy=0,this.good_match=0,this.nice_match=0,this.dyn_ltree=new Uint16Array(1146),this.dyn_dtree=new Uint16Array(122),this.bl_tree=new Uint16Array(78),dt(this.dyn_ltree),dt(this.dyn_dtree),dt(this.bl_tree),this.l_desc=null,this.d_desc=null,this.bl_desc=null,this.bl_count=new Uint16Array(16),this.heap=new Uint16Array(573),dt(this.heap),this.heap_len=0,this.heap_max=0,this.depth=new Uint16Array(573),dt(this.depth),this.sym_buf=0,this.lit_bufsize=0,this.sym_next=0,this.sym_end=0,this.opt_len=0,this.static_len=0,this.matches=0,this.insert=0,this.bi_buf=0,this.bi_valid=0}const Et=t=>{if(!t)return 1;const e=t.state;return!e||e.strm!==t||42!==e.status&&57!==e.status&&69!==e.status&&73!==e.status&&91!==e.status&&103!==e.status&&113!==e.status&&666!==e.status?1:0},Rt=t=>{if(Et(t))return lt(t,Q);t.total_in=t.total_out=0,t.data_type=rt;const e=t.state;return e.pending=0,e.pending_out=0,e.wrap<0&&(e.wrap=-e.wrap),e.status=2===e.wrap?57:e.wrap?42:113,t.adler=2===e.wrap?0:1,e.last_flush=-2,C(e),q},Zt=t=>{const e=Rt(t);var a;return e===q&&((a=t.state).window_size=2*a.w_size,dt(a.head),a.max_lazy_match=zt[a.level].max_lazy,a.good_match=zt[a.level].good_length,a.nice_match=zt[a.level].nice_length,a.max_chain_length=zt[a.level].max_chain,a.strstart=0,a.block_start=0,a.lookahead=0,a.insert=0,a.match_length=a.prev_length=2,a.match_available=0,a.ins_h=0),e},Ut=(t,e,a,i,n,s)=>{if(!t)return Q;let r=1;if(e===tt&&(e=6),i<0?(r=0,i=-i):i>15&&(r=2,i-=16),n<1||n>9||a!==ot||i<8||i>15||e<0||e>9||s<0||s>nt||8===i&&1!==r)return lt(t,Q);8===i&&(i=9);const o=new At;return t.state=o,o.strm=t,o.status=42,o.wrap=r,o.gzhead=null,o.w_bits=i,o.w_size=1<<o.w_bits,o.w_mask=o.w_size-1,o.hash_bits=n+7,o.hash_size=1<<o.hash_bits,o.hash_mask=o.hash_size-1,o.hash_shift=~~((o.hash_bits+3-1)/3),o.window=new Uint8Array(2*o.w_size),o.head=new Uint16Array(o.hash_size),o.prev=new Uint16Array(o.w_size),o.lit_bufsize=1<<n+6,o.pending_buf_size=4*o.lit_bufsize,o.pending_buf=new Uint8Array(o.pending_buf_size),o.sym_buf=o.lit_bufsize,o.sym_end=3*(o.lit_bufsize-1),o.level=e,o.strategy=s,o.method=a,Zt(t)};var St={deflateInit:(t,e)=>Ut(t,e,ot,15,8,st),deflateInit2:Ut,deflateReset:Zt,deflateResetKeep:Rt,deflateSetHeader:(t,e)=>Et(t)||2!==t.state.wrap?Q:(t.state.gzhead=e,q),deflate:(t,e)=>{if(Et(t)||e>W||e<0)return t?lt(t,Q):Q;const a=t.state;if(!t.output||0!==t.avail_in&&!t.input||666===a.status&&e!==X)return lt(t,0===t.avail_out?$:Q);const i=a.last_flush;if(a.last_flush=e,0!==a.pending){if(ct(t),0===t.avail_out)return a.last_flush=-1,q}else if(0===t.avail_in&&ht(e)<=ht(i)&&e!==X)return lt(t,$);if(666===a.status&&0!==t.avail_in)return lt(t,$);if(42===a.status&&0===a.wrap&&(a.status=113),42===a.status){let e=ot+(a.w_bits-8<<4)<<8,i=-1;if(i=a.strategy>=at||a.level<2?0:a.level<6?1:6===a.level?2:3,e|=i<<6,0!==a.strstart&&(e|=32),e+=31-e%31,mt(a,e),0!==a.strstart&&(mt(a,t.adler>>>16),mt(a,65535&t.adler)),t.adler=1,a.status=113,ct(t),0!==a.pending)return a.last_flush=-1,q}if(57===a.status)if(t.adler=0,wt(a,31),wt(a,139),wt(a,8),a.gzhead)wt(a,(a.gzhead.text?1:0)+(a.gzhead.hcrc?2:0)+(a.gzhead.extra?4:0)+(a.gzhead.name?8:0)+(a.gzhead.comment?16:0)),wt(a,255&a.gzhead.time),wt(a,a.gzhead.time>>8&255),wt(a,a.gzhead.time>>16&255),wt(a,a.gzhead.time>>24&255),wt(a,9===a.level?2:a.strategy>=at||a.level<2?4:0),wt(a,255&a.gzhead.os),a.gzhead.extra&&a.gzhead.extra.length&&(wt(a,255&a.gzhead.extra.length),wt(a,a.gzhead.extra.length>>8&255)),a.gzhead.hcrc&&(t.adler=N(t.adler,a.pending_buf,a.pending,0)),a.gzindex=0,a.status=69;else if(wt(a,0),wt(a,0),wt(a,0),wt(a,0),wt(a,0),wt(a,9===a.level?2:a.strategy>=at||a.level<2?4:0),wt(a,3),a.status=113,ct(t),0!==a.pending)return a.last_flush=-1,q;if(69===a.status){if(a.gzhead.extra){let e=a.pending,i=(65535&a.gzhead.extra.length)-a.gzindex;for(;a.pending+i>a.pending_buf_size;){let n=a.pending_buf_size-a.pending;if(a.pending_buf.set(a.gzhead.extra.subarray(a.gzindex,a.gzindex+n),a.pending),a.pending=a.pending_buf_size,a.gzhead.hcrc&&a.pending>e&&(t.adler=N(t.adler,a.pending_buf,a.pending-e,e)),a.gzindex+=n,ct(t),0!==a.pending)return a.last_flush=-1,q;e=0,i-=n}let n=new Uint8Array(a.gzhead.extra);a.pending_buf.set(n.subarray(a.gzindex,a.gzindex+i),a.pending),a.pending+=i,a.gzhead.hcrc&&a.pending>e&&(t.adler=N(t.adler,a.pending_buf,a.pending-e,e)),a.gzindex=0}a.status=73}if(73===a.status){if(a.gzhead.name){let e,i=a.pending;do{if(a.pending===a.pending_buf_size){if(a.gzhead.hcrc&&a.pending>i&&(t.adler=N(t.adler,a.pending_buf,a.pending-i,i)),ct(t),0!==a.pending)return a.last_flush=-1,q;i=0}e=a.gzindex<a.gzhead.name.length?255&a.gzhead.name.charCodeAt(a.gzindex++):0,wt(a,e)}while(0!==e);a.gzhead.hcrc&&a.pending>i&&(t.adler=N(t.adler,a.pending_buf,a.pending-i,i)),a.gzindex=0}a.status=91}if(91===a.status){if(a.gzhead.comment){let e,i=a.pending;do{if(a.pending===a.pending_buf_size){if(a.gzhead.hcrc&&a.pending>i&&(t.adler=N(t.adler,a.pending_buf,a.pending-i,i)),ct(t),0!==a.pending)return a.last_flush=-1,q;i=0}e=a.gzindex<a.gzhead.comment.length?255&a.gzhead.comment.charCodeAt(a.gzindex++):0,wt(a,e)}while(0!==e);a.gzhead.hcrc&&a.pending>i&&(t.adler=N(t.adler,a.pending_buf,a.pending-i,i))}a.status=103}if(103===a.status){if(a.gzhead.hcrc){if(a.pending+2>a.pending_buf_size&&(ct(t),0!==a.pending))return a.last_flush=-1,q;wt(a,255&t.adler),wt(a,t.adler>>8&255),t.adler=0}if(a.status=113,ct(t),0!==a.pending)return a.last_flush=-1,q}if(0!==t.avail_in||0!==a.lookahead||e!==P&&666!==a.status){let i=0===a.level?kt(a,e):a.strategy===at?((t,e)=>{let a;for(;;){if(0===t.lookahead&&(pt(t),0===t.lookahead)){if(e===P)return 1;break}if(t.match_length=0,a=j(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++,a&&(ut(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===X?(ut(t,!0),0===t.strm.avail_out?3:4):t.sym_next&&(ut(t,!1),0===t.strm.avail_out)?1:2})(a,e):a.strategy===it?((t,e)=>{let a,i,n,s;const r=t.window;for(;;){if(t.lookahead<=258){if(pt(t),t.lookahead<=258&&e===P)return 1;if(0===t.lookahead)break}if(t.match_length=0,t.lookahead>=3&&t.strstart>0&&(n=t.strstart-1,i=r[n],i===r[++n]&&i===r[++n]&&i===r[++n])){s=t.strstart+258;do{}while(i===r[++n]&&i===r[++n]&&i===r[++n]&&i===r[++n]&&i===r[++n]&&i===r[++n]&&i===r[++n]&&i===r[++n]&&n<s);t.match_length=258-(s-n),t.match_length>t.lookahead&&(t.match_length=t.lookahead)}if(t.match_length>=3?(a=j(t,1,t.match_length-3),t.lookahead-=t.match_length,t.strstart+=t.match_length,t.match_length=0):(a=j(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++),a&&(ut(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===X?(ut(t,!0),0===t.strm.avail_out?3:4):t.sym_next&&(ut(t,!1),0===t.strm.avail_out)?1:2})(a,e):zt[a.level].func(a,e);if(3!==i&&4!==i||(a.status=666),1===i||3===i)return 0===t.avail_out&&(a.last_flush=-1),q;if(2===i&&(e===Y?K(a):e!==W&&(H(a,0,0,!1),e===G&&(dt(a.head),0===a.lookahead&&(a.strstart=0,a.block_start=0,a.insert=0))),ct(t),0===t.avail_out))return a.last_flush=-1,q}return e!==X?q:a.wrap<=0?J:(2===a.wrap?(wt(a,255&t.adler),wt(a,t.adler>>8&255),wt(a,t.adler>>16&255),wt(a,t.adler>>24&255),wt(a,255&t.total_in),wt(a,t.total_in>>8&255),wt(a,t.total_in>>16&255),wt(a,t.total_in>>24&255)):(mt(a,t.adler>>>16),mt(a,65535&t.adler)),ct(t),a.wrap>0&&(a.wrap=-a.wrap),0!==a.pending?q:J)},deflateEnd:t=>{if(Et(t))return Q;const e=t.state.status;return t.state=null,113===e?lt(t,V):q},deflateSetDictionary:(t,e)=>{let a=e.length;if(Et(t))return Q;const i=t.state,n=i.wrap;if(2===n||1===n&&42!==i.status||i.lookahead)return Q;if(1===n&&(t.adler=F(t.adler,e,a,0)),i.wrap=0,a>=i.w_size){0===n&&(dt(i.head),i.strstart=0,i.block_start=0,i.insert=0);let t=new Uint8Array(i.w_size);t.set(e.subarray(a-i.w_size,a),0),e=t,a=i.w_size}const s=t.avail_in,r=t.next_in,o=t.input;for(t.avail_in=a,t.next_in=0,t.input=e,pt(i);i.lookahead>=3;){let t=i.strstart,e=i.lookahead-2;do{i.ins_h=ft(i,i.ins_h,i.window[t+3-1]),i.prev[t&i.w_mask]=i.head[i.ins_h],i.head[i.ins_h]=t,t++}while(--e);i.strstart=t,i.lookahead=2,pt(i)}return i.strstart+=i.lookahead,i.block_start=i.strstart,i.insert=i.lookahead,i.lookahead=0,i.match_length=i.prev_length=2,i.match_available=0,t.next_in=r,t.input=o,t.avail_in=s,i.wrap=n,q},deflateInfo:"pako deflate (from Nodeca project)"};const Dt=(t,e)=>Object.prototype.hasOwnProperty.call(t,e);var Tt=function(t){const e=Array.prototype.slice.call(arguments,1);for(;e.length;){const a=e.shift();if(a){if("object"!=typeof a)throw new TypeError(a+"must be non-object");for(const e in a)Dt(a,e)&&(t[e]=a[e])}}return t},Ot=t=>{let e=0;for(let a=0,i=t.length;a<i;a++)e+=t[a].length;const a=new Uint8Array(e);for(let e=0,i=0,n=t.length;e<n;e++){let n=t[e];a.set(n,i),i+=n.length}return a};let Ft=!0;try{String.fromCharCode.apply(null,new Uint8Array(1))}catch(t){Ft=!1}const Lt=new Uint8Array(256);for(let t=0;t<256;t++)Lt[t]=t>=252?6:t>=248?5:t>=240?4:t>=224?3:t>=192?2:1;Lt[254]=Lt[254]=1;var Nt=t=>{if("function"==typeof TextEncoder&&TextEncoder.prototype.encode)return(new TextEncoder).encode(t);let e,a,i,n,s,r=t.length,o=0;for(n=0;n<r;n++)a=t.charCodeAt(n),55296==(64512&a)&&n+1<r&&(i=t.charCodeAt(n+1),56320==(64512&i)&&(a=65536+(a-55296<<10)+(i-56320),n++)),o+=a<128?1:a<2048?2:a<65536?3:4;for(e=new Uint8Array(o),s=0,n=0;s<o;n++)a=t.charCodeAt(n),55296==(64512&a)&&n+1<r&&(i=t.charCodeAt(n+1),56320==(64512&i)&&(a=65536+(a-55296<<10)+(i-56320),n++)),a<128?e[s++]=a:a<2048?(e[s++]=192|a>>>6,e[s++]=128|63&a):a<65536?(e[s++]=224|a>>>12,e[s++]=128|a>>>6&63,e[s++]=128|63&a):(e[s++]=240|a>>>18,e[s++]=128|a>>>12&63,e[s++]=128|a>>>6&63,e[s++]=128|63&a);return e},It=(t,e)=>{const a=e||t.length;if("function"==typeof TextDecoder&&TextDecoder.prototype.decode)return(new TextDecoder).decode(t.subarray(0,e));let i,n;const s=new Array(2*a);for(n=0,i=0;i<a;){let e=t[i++];if(e<128){s[n++]=e;continue}let r=Lt[e];if(r>4)s[n++]=65533,i+=r-1;else{for(e&=2===r?31:3===r?15:7;r>1&&i<a;)e=e<<6|63&t[i++],r--;r>1?s[n++]=65533:e<65536?s[n++]=e:(e-=65536,s[n++]=55296|e>>10&1023,s[n++]=56320|1023&e)}}return((t,e)=>{if(e<65534&&t.subarray&&Ft)return String.fromCharCode.apply(null,t.length===e?t:t.subarray(0,e));let a="";for(let i=0;i<e;i++)a+=String.fromCharCode(t[i]);return a})(s,n)},Bt=(t,e)=>{(e=e||t.length)>t.length&&(e=t.length);let a=e-1;for(;a>=0&&128==(192&t[a]);)a--;return a<0||0===a?e:a+Lt[t[a]]>e?a:e};var Ct=function(){this.input=null,this.next_in=0,this.avail_in=0,this.total_in=0,this.output=null,this.next_out=0,this.avail_out=0,this.total_out=0,this.msg="",this.state=null,this.data_type=2,this.adler=0};const Ht=Object.prototype.toString,{Z_NO_FLUSH:Mt,Z_SYNC_FLUSH:jt,Z_FULL_FLUSH:Kt,Z_FINISH:Pt,Z_OK:Yt,Z_STREAM_END:Gt,Z_DEFAULT_COMPRESSION:Xt,Z_DEFAULT_STRATEGY:Wt,Z_DEFLATED:qt}=B;function Jt(t){this.options=Tt({level:Xt,method:qt,chunkSize:16384,windowBits:15,memLevel:8,strategy:Wt},t||{});let e=this.options;e.raw&&e.windowBits>0?e.windowBits=-e.windowBits:e.gzip&&e.windowBits>0&&e.windowBits<16&&(e.windowBits+=16),this.err=0,this.msg="",this.ended=!1,this.chunks=[],this.strm=new Ct,this.strm.avail_out=0;let a=St.deflateInit2(this.strm,e.level,e.method,e.windowBits,e.memLevel,e.strategy);if(a!==Yt)throw new Error(I[a]);if(e.header&&St.deflateSetHeader(this.strm,e.header),e.dictionary){let t;if(t="string"==typeof e.dictionary?Nt(e.dictionary):"[object ArrayBuffer]"===Ht.call(e.dictionary)?new Uint8Array(e.dictionary):e.dictionary,a=St.deflateSetDictionary(this.strm,t),a!==Yt)throw new Error(I[a]);this._dict_set=!0}}function Qt(t,e){const a=new Jt(e);if(a.push(t,!0),a.err)throw a.msg||I[a.err];return a.result}Jt.prototype.push=function(t,e){const a=this.strm,i=this.options.chunkSize;let n,s;if(this.ended)return!1;for(s=e===~~e?e:!0===e?Pt:Mt,"string"==typeof t?a.input=Nt(t):"[object ArrayBuffer]"===Ht.call(t)?a.input=new Uint8Array(t):a.input=t,a.next_in=0,a.avail_in=a.input.length;;)if(0===a.avail_out&&(a.output=new Uint8Array(i),a.next_out=0,a.avail_out=i),(s===jt||s===Kt)&&a.avail_out<=6)this.onData(a.output.subarray(0,a.next_out)),a.avail_out=0;else{if(n=St.deflate(a,s),n===Gt)return a.next_out>0&&this.onData(a.output.subarray(0,a.next_out)),n=St.deflateEnd(this.strm),this.onEnd(n),this.ended=!0,n===Yt;if(0!==a.avail_out){if(s>0&&a.next_out>0)this.onData(a.output.subarray(0,a.next_out)),a.avail_out=0;else if(0===a.avail_in)break}else this.onData(a.output)}return!0},Jt.prototype.onData=function(t){this.chunks.push(t)},Jt.prototype.onEnd=function(t){t===Yt&&(this.result=Ot(this.chunks)),this.chunks=[],this.err=t,this.msg=this.strm.msg};var Vt={Deflate:Jt,deflate:Qt,deflateRaw:function(t,e){return(e=e||{}).raw=!0,Qt(t,e)},gzip:function(t,e){return(e=e||{}).gzip=!0,Qt(t,e)},constants:B};var $t=function(t,e){let a,i,n,s,r,o,l,h,d,_,f,c,u,w,m,b,g,p,k,v,y,x,z,A;const E=t.state;a=t.next_in,z=t.input,i=a+(t.avail_in-5),n=t.next_out,A=t.output,s=n-(e-t.avail_out),r=n+(t.avail_out-257),o=E.dmax,l=E.wsize,h=E.whave,d=E.wnext,_=E.window,f=E.hold,c=E.bits,u=E.lencode,w=E.distcode,m=(1<<E.lenbits)-1,b=(1<<E.distbits)-1;t:do{c<15&&(f+=z[a++]<<c,c+=8,f+=z[a++]<<c,c+=8),g=u[f&m];e:for(;;){if(p=g>>>24,f>>>=p,c-=p,p=g>>>16&255,0===p)A[n++]=65535&g;else{if(!(16&p)){if(0==(64&p)){g=u[(65535&g)+(f&(1<<p)-1)];continue e}if(32&p){E.mode=16191;break t}t.msg="invalid literal/length code",E.mode=16209;break t}k=65535&g,p&=15,p&&(c<p&&(f+=z[a++]<<c,c+=8),k+=f&(1<<p)-1,f>>>=p,c-=p),c<15&&(f+=z[a++]<<c,c+=8,f+=z[a++]<<c,c+=8),g=w[f&b];a:for(;;){if(p=g>>>24,f>>>=p,c-=p,p=g>>>16&255,!(16&p)){if(0==(64&p)){g=w[(65535&g)+(f&(1<<p)-1)];continue a}t.msg="invalid distance code",E.mode=16209;break t}if(v=65535&g,p&=15,c<p&&(f+=z[a++]<<c,c+=8,c<p&&(f+=z[a++]<<c,c+=8)),v+=f&(1<<p)-1,v>o){t.msg="invalid distance too far back",E.mode=16209;break t}if(f>>>=p,c-=p,p=n-s,v>p){if(p=v-p,p>h&&E.sane){t.msg="invalid distance too far back",E.mode=16209;break t}if(y=0,x=_,0===d){if(y+=l-p,p<k){k-=p;do{A[n++]=_[y++]}while(--p);y=n-v,x=A}}else if(d<p){if(y+=l+d-p,p-=d,p<k){k-=p;do{A[n++]=_[y++]}while(--p);if(y=0,d<k){p=d,k-=p;do{A[n++]=_[y++]}while(--p);y=n-v,x=A}}}else if(y+=d-p,p<k){k-=p;do{A[n++]=_[y++]}while(--p);y=n-v,x=A}for(;k>2;)A[n++]=x[y++],A[n++]=x[y++],A[n++]=x[y++],k-=3;k&&(A[n++]=x[y++],k>1&&(A[n++]=x[y++]))}else{y=n-v;do{A[n++]=A[y++],A[n++]=A[y++],A[n++]=A[y++],k-=3}while(k>2);k&&(A[n++]=A[y++],k>1&&(A[n++]=A[y++]))}break}}break}}while(a<i&&n<r);k=c>>3,a-=k,c-=k<<3,f&=(1<<c)-1,t.next_in=a,t.next_out=n,t.avail_in=a<i?i-a+5:5-(a-i),t.avail_out=n<r?r-n+257:257-(n-r),E.hold=f,E.bits=c};const te=new Uint16Array([3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258,0,0]),ee=new Uint8Array([16,16,16,16,16,16,16,16,17,17,17,17,18,18,18,18,19,19,19,19,20,20,20,20,21,21,21,21,16,72,78]),ae=new Uint16Array([1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0]),ie=new Uint8Array([16,16,16,16,17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,64,64]);var ne=(t,e,a,i,n,s,r,o)=>{const l=o.bits;let h,d,_,f,c,u,w=0,m=0,b=0,g=0,p=0,k=0,v=0,y=0,x=0,z=0,A=null;const E=new Uint16Array(16),R=new Uint16Array(16);let Z,U,S,D=null;for(w=0;w<=15;w++)E[w]=0;for(m=0;m<i;m++)E[e[a+m]]++;for(p=l,g=15;g>=1&&0===E[g];g--);if(p>g&&(p=g),0===g)return n[s++]=20971520,n[s++]=20971520,o.bits=1,0;for(b=1;b<g&&0===E[b];b++);for(p<b&&(p=b),y=1,w=1;w<=15;w++)if(y<<=1,y-=E[w],y<0)return-1;if(y>0&&(0===t||1!==g))return-1;for(R[1]=0,w=1;w<15;w++)R[w+1]=R[w]+E[w];for(m=0;m<i;m++)0!==e[a+m]&&(r[R[e[a+m]]++]=m);if(0===t?(A=D=r,u=20):1===t?(A=te,D=ee,u=257):(A=ae,D=ie,u=0),z=0,m=0,w=b,c=s,k=p,v=0,_=-1,x=1<<p,f=x-1,1===t&&x>852||2===t&&x>592)return 1;for(;;){Z=w-v,r[m]+1<u?(U=0,S=r[m]):r[m]>=u?(U=D[r[m]-u],S=A[r[m]-u]):(U=96,S=0),h=1<<w-v,d=1<<k,b=d;do{d-=h,n[c+(z>>v)+d]=Z<<24|U<<16|S|0}while(0!==d);for(h=1<<w-1;z&h;)h>>=1;if(0!==h?(z&=h-1,z+=h):z=0,m++,0==--E[w]){if(w===g)break;w=e[a+r[m]]}if(w>p&&(z&f)!==_){for(0===v&&(v=p),c+=b,k=w-v,y=1<<k;k+v<g&&(y-=E[k+v],!(y<=0));)k++,y<<=1;if(x+=1<<k,1===t&&x>852||2===t&&x>592)return 1;_=z&f,n[_]=p<<24|k<<16|c-s|0}}return 0!==z&&(n[c+z]=w-v<<24|64<<16|0),o.bits=p,0};const{Z_FINISH:se,Z_BLOCK:re,Z_TREES:oe,Z_OK:le,Z_STREAM_END:he,Z_NEED_DICT:de,Z_STREAM_ERROR:_e,Z_DATA_ERROR:fe,Z_MEM_ERROR:ce,Z_BUF_ERROR:ue,Z_DEFLATED:we}=B,me=16209,be=t=>(t>>>24&255)+(t>>>8&65280)+((65280&t)<<8)+((255&t)<<24);function ge(){this.strm=null,this.mode=0,this.last=!1,this.wrap=0,this.havedict=!1,this.flags=0,this.dmax=0,this.check=0,this.total=0,this.head=null,this.wbits=0,this.wsize=0,this.whave=0,this.wnext=0,this.window=null,this.hold=0,this.bits=0,this.length=0,this.offset=0,this.extra=0,this.lencode=null,this.distcode=null,this.lenbits=0,this.distbits=0,this.ncode=0,this.nlen=0,this.ndist=0,this.have=0,this.next=null,this.lens=new Uint16Array(320),this.work=new Uint16Array(288),this.lendyn=null,this.distdyn=null,this.sane=0,this.back=0,this.was=0}const pe=t=>{if(!t)return 1;const e=t.state;return!e||e.strm!==t||e.mode<16180||e.mode>16211?1:0},ke=t=>{if(pe(t))return _e;const e=t.state;return t.total_in=t.total_out=e.total=0,t.msg="",e.wrap&&(t.adler=1&e.wrap),e.mode=16180,e.last=0,e.havedict=0,e.flags=-1,e.dmax=32768,e.head=null,e.hold=0,e.bits=0,e.lencode=e.lendyn=new Int32Array(852),e.distcode=e.distdyn=new Int32Array(592),e.sane=1,e.back=-1,le},ve=t=>{if(pe(t))return _e;const e=t.state;return e.wsize=0,e.whave=0,e.wnext=0,ke(t)},ye=(t,e)=>{let a;if(pe(t))return _e;const i=t.state;return e<0?(a=0,e=-e):(a=5+(e>>4),e<48&&(e&=15)),e&&(e<8||e>15)?_e:(null!==i.window&&i.wbits!==e&&(i.window=null),i.wrap=a,i.wbits=e,ve(t))},xe=(t,e)=>{if(!t)return _e;const a=new ge;t.state=a,a.strm=t,a.window=null,a.mode=16180;const i=ye(t,e);return i!==le&&(t.state=null),i};let ze,Ae,Ee=!0;const Re=t=>{if(Ee){ze=new Int32Array(512),Ae=new Int32Array(32);let e=0;for(;e<144;)t.lens[e++]=8;for(;e<256;)t.lens[e++]=9;for(;e<280;)t.lens[e++]=7;for(;e<288;)t.lens[e++]=8;for(ne(1,t.lens,0,288,ze,0,t.work,{bits:9}),e=0;e<32;)t.lens[e++]=5;ne(2,t.lens,0,32,Ae,0,t.work,{bits:5}),Ee=!1}t.lencode=ze,t.lenbits=9,t.distcode=Ae,t.distbits=5},Ze=(t,e,a,i)=>{let n;const s=t.state;return null===s.window&&(s.wsize=1<<s.wbits,s.wnext=0,s.whave=0,s.window=new Uint8Array(s.wsize)),i>=s.wsize?(s.window.set(e.subarray(a-s.wsize,a),0),s.wnext=0,s.whave=s.wsize):(n=s.wsize-s.wnext,n>i&&(n=i),s.window.set(e.subarray(a-i,a-i+n),s.wnext),(i-=n)?(s.window.set(e.subarray(a-i,a),0),s.wnext=i,s.whave=s.wsize):(s.wnext+=n,s.wnext===s.wsize&&(s.wnext=0),s.whave<s.wsize&&(s.whave+=n))),0};var Ue={inflateReset:ve,inflateReset2:ye,inflateResetKeep:ke,inflateInit:t=>xe(t,15),inflateInit2:xe,inflate:(t,e)=>{let a,i,n,s,r,o,l,h,d,_,f,c,u,w,m,b,g,p,k,v,y,x,z=0;const A=new Uint8Array(4);let E,R;const Z=new Uint8Array([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]);if(pe(t)||!t.output||!t.input&&0!==t.avail_in)return _e;a=t.state,16191===a.mode&&(a.mode=16192),r=t.next_out,n=t.output,l=t.avail_out,s=t.next_in,i=t.input,o=t.avail_in,h=a.hold,d=a.bits,_=o,f=l,x=le;t:for(;;)switch(a.mode){case 16180:if(0===a.wrap){a.mode=16192;break}for(;d<16;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}if(2&a.wrap&&35615===h){0===a.wbits&&(a.wbits=15),a.check=0,A[0]=255&h,A[1]=h>>>8&255,a.check=N(a.check,A,2,0),h=0,d=0,a.mode=16181;break}if(a.head&&(a.head.done=!1),!(1&a.wrap)||(((255&h)<<8)+(h>>8))%31){t.msg="incorrect header check",a.mode=me;break}if((15&h)!==we){t.msg="unknown compression method",a.mode=me;break}if(h>>>=4,d-=4,y=8+(15&h),0===a.wbits&&(a.wbits=y),y>15||y>a.wbits){t.msg="invalid window size",a.mode=me;break}a.dmax=1<<a.wbits,a.flags=0,t.adler=a.check=1,a.mode=512&h?16189:16191,h=0,d=0;break;case 16181:for(;d<16;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}if(a.flags=h,(255&a.flags)!==we){t.msg="unknown compression method",a.mode=me;break}if(57344&a.flags){t.msg="unknown header flags set",a.mode=me;break}a.head&&(a.head.text=h>>8&1),512&a.flags&&4&a.wrap&&(A[0]=255&h,A[1]=h>>>8&255,a.check=N(a.check,A,2,0)),h=0,d=0,a.mode=16182;case 16182:for(;d<32;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}a.head&&(a.head.time=h),512&a.flags&&4&a.wrap&&(A[0]=255&h,A[1]=h>>>8&255,A[2]=h>>>16&255,A[3]=h>>>24&255,a.check=N(a.check,A,4,0)),h=0,d=0,a.mode=16183;case 16183:for(;d<16;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}a.head&&(a.head.xflags=255&h,a.head.os=h>>8),512&a.flags&&4&a.wrap&&(A[0]=255&h,A[1]=h>>>8&255,a.check=N(a.check,A,2,0)),h=0,d=0,a.mode=16184;case 16184:if(1024&a.flags){for(;d<16;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}a.length=h,a.head&&(a.head.extra_len=h),512&a.flags&&4&a.wrap&&(A[0]=255&h,A[1]=h>>>8&255,a.check=N(a.check,A,2,0)),h=0,d=0}else a.head&&(a.head.extra=null);a.mode=16185;case 16185:if(1024&a.flags&&(c=a.length,c>o&&(c=o),c&&(a.head&&(y=a.head.extra_len-a.length,a.head.extra||(a.head.extra=new Uint8Array(a.head.extra_len)),a.head.extra.set(i.subarray(s,s+c),y)),512&a.flags&&4&a.wrap&&(a.check=N(a.check,i,c,s)),o-=c,s+=c,a.length-=c),a.length))break t;a.length=0,a.mode=16186;case 16186:if(2048&a.flags){if(0===o)break t;c=0;do{y=i[s+c++],a.head&&y&&a.length<65536&&(a.head.name+=String.fromCharCode(y))}while(y&&c<o);if(512&a.flags&&4&a.wrap&&(a.check=N(a.check,i,c,s)),o-=c,s+=c,y)break t}else a.head&&(a.head.name=null);a.length=0,a.mode=16187;case 16187:if(4096&a.flags){if(0===o)break t;c=0;do{y=i[s+c++],a.head&&y&&a.length<65536&&(a.head.comment+=String.fromCharCode(y))}while(y&&c<o);if(512&a.flags&&4&a.wrap&&(a.check=N(a.check,i,c,s)),o-=c,s+=c,y)break t}else a.head&&(a.head.comment=null);a.mode=16188;case 16188:if(512&a.flags){for(;d<16;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}if(4&a.wrap&&h!==(65535&a.check)){t.msg="header crc mismatch",a.mode=me;break}h=0,d=0}a.head&&(a.head.hcrc=a.flags>>9&1,a.head.done=!0),t.adler=a.check=0,a.mode=16191;break;case 16189:for(;d<32;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}t.adler=a.check=be(h),h=0,d=0,a.mode=16190;case 16190:if(0===a.havedict)return t.next_out=r,t.avail_out=l,t.next_in=s,t.avail_in=o,a.hold=h,a.bits=d,de;t.adler=a.check=1,a.mode=16191;case 16191:if(e===re||e===oe)break t;case 16192:if(a.last){h>>>=7&d,d-=7&d,a.mode=16206;break}for(;d<3;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}switch(a.last=1&h,h>>>=1,d-=1,3&h){case 0:a.mode=16193;break;case 1:if(Re(a),a.mode=16199,e===oe){h>>>=2,d-=2;break t}break;case 2:a.mode=16196;break;case 3:t.msg="invalid block type",a.mode=me}h>>>=2,d-=2;break;case 16193:for(h>>>=7&d,d-=7&d;d<32;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}if((65535&h)!=(h>>>16^65535)){t.msg="invalid stored block lengths",a.mode=me;break}if(a.length=65535&h,h=0,d=0,a.mode=16194,e===oe)break t;case 16194:a.mode=16195;case 16195:if(c=a.length,c){if(c>o&&(c=o),c>l&&(c=l),0===c)break t;n.set(i.subarray(s,s+c),r),o-=c,s+=c,l-=c,r+=c,a.length-=c;break}a.mode=16191;break;case 16196:for(;d<14;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}if(a.nlen=257+(31&h),h>>>=5,d-=5,a.ndist=1+(31&h),h>>>=5,d-=5,a.ncode=4+(15&h),h>>>=4,d-=4,a.nlen>286||a.ndist>30){t.msg="too many length or distance symbols",a.mode=me;break}a.have=0,a.mode=16197;case 16197:for(;a.have<a.ncode;){for(;d<3;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}a.lens[Z[a.have++]]=7&h,h>>>=3,d-=3}for(;a.have<19;)a.lens[Z[a.have++]]=0;if(a.lencode=a.lendyn,a.lenbits=7,E={bits:a.lenbits},x=ne(0,a.lens,0,19,a.lencode,0,a.work,E),a.lenbits=E.bits,x){t.msg="invalid code lengths set",a.mode=me;break}a.have=0,a.mode=16198;case 16198:for(;a.have<a.nlen+a.ndist;){for(;z=a.lencode[h&(1<<a.lenbits)-1],m=z>>>24,b=z>>>16&255,g=65535&z,!(m<=d);){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}if(g<16)h>>>=m,d-=m,a.lens[a.have++]=g;else{if(16===g){for(R=m+2;d<R;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}if(h>>>=m,d-=m,0===a.have){t.msg="invalid bit length repeat",a.mode=me;break}y=a.lens[a.have-1],c=3+(3&h),h>>>=2,d-=2}else if(17===g){for(R=m+3;d<R;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}h>>>=m,d-=m,y=0,c=3+(7&h),h>>>=3,d-=3}else{for(R=m+7;d<R;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}h>>>=m,d-=m,y=0,c=11+(127&h),h>>>=7,d-=7}if(a.have+c>a.nlen+a.ndist){t.msg="invalid bit length repeat",a.mode=me;break}for(;c--;)a.lens[a.have++]=y}}if(a.mode===me)break;if(0===a.lens[256]){t.msg="invalid code -- missing end-of-block",a.mode=me;break}if(a.lenbits=9,E={bits:a.lenbits},x=ne(1,a.lens,0,a.nlen,a.lencode,0,a.work,E),a.lenbits=E.bits,x){t.msg="invalid literal/lengths set",a.mode=me;break}if(a.distbits=6,a.distcode=a.distdyn,E={bits:a.distbits},x=ne(2,a.lens,a.nlen,a.ndist,a.distcode,0,a.work,E),a.distbits=E.bits,x){t.msg="invalid distances set",a.mode=me;break}if(a.mode=16199,e===oe)break t;case 16199:a.mode=16200;case 16200:if(o>=6&&l>=258){t.next_out=r,t.avail_out=l,t.next_in=s,t.avail_in=o,a.hold=h,a.bits=d,$t(t,f),r=t.next_out,n=t.output,l=t.avail_out,s=t.next_in,i=t.input,o=t.avail_in,h=a.hold,d=a.bits,16191===a.mode&&(a.back=-1);break}for(a.back=0;z=a.lencode[h&(1<<a.lenbits)-1],m=z>>>24,b=z>>>16&255,g=65535&z,!(m<=d);){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}if(b&&0==(240&b)){for(p=m,k=b,v=g;z=a.lencode[v+((h&(1<<p+k)-1)>>p)],m=z>>>24,b=z>>>16&255,g=65535&z,!(p+m<=d);){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}h>>>=p,d-=p,a.back+=p}if(h>>>=m,d-=m,a.back+=m,a.length=g,0===b){a.mode=16205;break}if(32&b){a.back=-1,a.mode=16191;break}if(64&b){t.msg="invalid literal/length code",a.mode=me;break}a.extra=15&b,a.mode=16201;case 16201:if(a.extra){for(R=a.extra;d<R;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}a.length+=h&(1<<a.extra)-1,h>>>=a.extra,d-=a.extra,a.back+=a.extra}a.was=a.length,a.mode=16202;case 16202:for(;z=a.distcode[h&(1<<a.distbits)-1],m=z>>>24,b=z>>>16&255,g=65535&z,!(m<=d);){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}if(0==(240&b)){for(p=m,k=b,v=g;z=a.distcode[v+((h&(1<<p+k)-1)>>p)],m=z>>>24,b=z>>>16&255,g=65535&z,!(p+m<=d);){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}h>>>=p,d-=p,a.back+=p}if(h>>>=m,d-=m,a.back+=m,64&b){t.msg="invalid distance code",a.mode=me;break}a.offset=g,a.extra=15&b,a.mode=16203;case 16203:if(a.extra){for(R=a.extra;d<R;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}a.offset+=h&(1<<a.extra)-1,h>>>=a.extra,d-=a.extra,a.back+=a.extra}if(a.offset>a.dmax){t.msg="invalid distance too far back",a.mode=me;break}a.mode=16204;case 16204:if(0===l)break t;if(c=f-l,a.offset>c){if(c=a.offset-c,c>a.whave&&a.sane){t.msg="invalid distance too far back",a.mode=me;break}c>a.wnext?(c-=a.wnext,u=a.wsize-c):u=a.wnext-c,c>a.length&&(c=a.length),w=a.window}else w=n,u=r-a.offset,c=a.length;c>l&&(c=l),l-=c,a.length-=c;do{n[r++]=w[u++]}while(--c);0===a.length&&(a.mode=16200);break;case 16205:if(0===l)break t;n[r++]=a.length,l--,a.mode=16200;break;case 16206:if(a.wrap){for(;d<32;){if(0===o)break t;o--,h|=i[s++]<<d,d+=8}if(f-=l,t.total_out+=f,a.total+=f,4&a.wrap&&f&&(t.adler=a.check=a.flags?N(a.check,n,f,r-f):F(a.check,n,f,r-f)),f=l,4&a.wrap&&(a.flags?h:be(h))!==a.check){t.msg="incorrect data check",a.mode=me;break}h=0,d=0}a.mode=16207;case 16207:if(a.wrap&&a.flags){for(;d<32;){if(0===o)break t;o--,h+=i[s++]<<d,d+=8}if(4&a.wrap&&h!==(4294967295&a.total)){t.msg="incorrect length check",a.mode=me;break}h=0,d=0}a.mode=16208;case 16208:x=he;break t;case me:x=fe;break t;case 16210:return ce;default:return _e}return t.next_out=r,t.avail_out=l,t.next_in=s,t.avail_in=o,a.hold=h,a.bits=d,(a.wsize||f!==t.avail_out&&a.mode<me&&(a.mode<16206||e!==se))&&Ze(t,t.output,t.next_out,f-t.avail_out),_-=t.avail_in,f-=t.avail_out,t.total_in+=_,t.total_out+=f,a.total+=f,4&a.wrap&&f&&(t.adler=a.check=a.flags?N(a.check,n,f,t.next_out-f):F(a.check,n,f,t.next_out-f)),t.data_type=a.bits+(a.last?64:0)+(16191===a.mode?128:0)+(16199===a.mode||16194===a.mode?256:0),(0===_&&0===f||e===se)&&x===le&&(x=ue),x},inflateEnd:t=>{if(pe(t))return _e;let e=t.state;return e.window&&(e.window=null),t.state=null,le},inflateGetHeader:(t,e)=>{if(pe(t))return _e;const a=t.state;return 0==(2&a.wrap)?_e:(a.head=e,e.done=!1,le)},inflateSetDictionary:(t,e)=>{const a=e.length;let i,n,s;return pe(t)?_e:(i=t.state,0!==i.wrap&&16190!==i.mode?_e:16190===i.mode&&(n=1,n=F(n,e,a,0),n!==i.check)?fe:(s=Ze(t,e,a,a),s?(i.mode=16210,ce):(i.havedict=1,le)))},inflateInfo:"pako inflate (from Nodeca project)"};var Se=function(){this.text=0,this.time=0,this.xflags=0,this.os=0,this.extra=null,this.extra_len=0,this.name="",this.comment="",this.hcrc=0,this.done=!1};const De=Object.prototype.toString,{Z_NO_FLUSH:Te,Z_FINISH:Oe,Z_OK:Fe,Z_STREAM_END:Le,Z_NEED_DICT:Ne,Z_STREAM_ERROR:Ie,Z_DATA_ERROR:Be,Z_MEM_ERROR:Ce}=B;function He(t){this.options=Tt({chunkSize:65536,windowBits:15,to:""},t||{});const e=this.options;e.raw&&e.windowBits>=0&&e.windowBits<16&&(e.windowBits=-e.windowBits,0===e.windowBits&&(e.windowBits=-15)),!(e.windowBits>=0&&e.windowBits<16)||t&&t.windowBits||(e.windowBits+=32),e.windowBits>15&&e.windowBits<48&&0==(15&e.windowBits)&&(e.windowBits|=15),this.err=0,this.msg="",this.ended=!1,this.chunks=[],this.strm=new Ct,this.strm.avail_out=0;let a=Ue.inflateInit2(this.strm,e.windowBits);if(a!==Fe)throw new Error(I[a]);if(this.header=new Se,Ue.inflateGetHeader(this.strm,this.header),e.dictionary&&("string"==typeof e.dictionary?e.dictionary=Nt(e.dictionary):"[object ArrayBuffer]"===De.call(e.dictionary)&&(e.dictionary=new Uint8Array(e.dictionary)),e.raw&&(a=Ue.inflateSetDictionary(this.strm,e.dictionary),a!==Fe)))throw new Error(I[a])}He.prototype.push=function(t,e){const a=this.strm,i=this.options.chunkSize,n=this.options.dictionary;let s,r,o;if(this.ended)return!1;for(r=e===~~e?e:!0===e?Oe:Te,"[object ArrayBuffer]"===De.call(t)?a.input=new Uint8Array(t):a.input=t,a.next_in=0,a.avail_in=a.input.length;;){for(0===a.avail_out&&(a.output=new Uint8Array(i),a.next_out=0,a.avail_out=i),s=Ue.inflate(a,r),s===Ne&&n&&(s=Ue.inflateSetDictionary(a,n),s===Fe?s=Ue.inflate(a,r):s===Be&&(s=Ne));a.avail_in>0&&s===Le&&a.state.wrap>0&&0!==t[a.next_in];)Ue.inflateReset(a),s=Ue.inflate(a,r);switch(s){case Ie:case Be:case Ne:case Ce:return this.onEnd(s),this.ended=!0,!1}if(o=a.avail_out,a.next_out&&(0===a.avail_out||s===Le))if("string"===this.options.to){let t=Bt(a.output,a.next_out),e=a.next_out-t,n=It(a.output,t);a.next_out=e,a.avail_out=i-e,e&&a.output.set(a.output.subarray(t,t+e),0),this.onData(n)}else this.onData(a.output.length===a.next_out?a.output:a.output.subarray(0,a.next_out));if(s!==Fe||0!==o){if(s===Le)return s=Ue.inflateEnd(this.strm),this.onEnd(s),this.ended=!0,!0;if(0===a.avail_in)break}}return!0},He.prototype.onData=function(t){this.chunks.push(t)},He.prototype.onEnd=function(t){t===Fe&&("string"===this.options.to?this.result=this.chunks.join(""):this.result=Ot(this.chunks)),this.chunks=[],this.err=t,this.msg=this.strm.msg};const{Deflate:Me,deflate:je,deflateRaw:Ke,gzip:Pe}=Vt;var Ye=Me,Ge=je,Xe=B;const We=new class{constructor(){this._init()}clear(){this._init()}addEvent(t){if(!t)throw new Error("Adding invalid event");const e=this._hasEvents?",":"";this.deflate.push(e+t,Xe.Z_SYNC_FLUSH),this._hasEvents=!0}finish(){if(this.deflate.push("]",Xe.Z_FINISH),this.deflate.err)throw this.deflate.err;const t=this.deflate.result;return this._init(),t}_init(){this._hasEvents=!1,this.deflate=new Ye,this.deflate.push("[",Xe.Z_NO_FLUSH)}},qe={clear:()=>{We.clear()},addEvent:t=>We.addEvent(t),finish:()=>We.finish(),compress:t=>function(t){return Ge(t)}(t)};addEventListener("message",(function(t){const e=t.data.method,a=t.data.id,i=t.data.arg;if(e in qe&&"function"==typeof qe[e])try{const t=qe[e](i);postMessage({id:a,method:e,success:!0,response:t})}catch(t){postMessage({id:a,method:e,success:!1,response:t.message}),console.error(t)}})),postMessage({id:void 0,method:"init",success:!0,response:void 0});`;
+
+function e(){const e=new Blob([r]);return URL.createObjectURL(e)}
+
+/**
+ * Log a message in debug mode, and add a breadcrumb when _experiment.traceInternals is enabled.
+ */
+function logInfo(message, shouldAddBreadcrumb) {
+  if (!(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+    return;
+  }
+
+  logger.info(message);
+
+  if (shouldAddBreadcrumb) {
+    addBreadcrumb(message);
+  }
+}
+
+/**
+ * Log a message, and add a breadcrumb in the next tick.
+ * This is necessary when the breadcrumb may be added before the replay is initialized.
+ */
+function logInfoNextTick(message, shouldAddBreadcrumb) {
+  if (!(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+    return;
+  }
+
+  logger.info(message);
+
+  if (shouldAddBreadcrumb) {
+    // Wait a tick here to avoid race conditions for some initial logs
+    // which may be added before replay is initialized
+    setTimeout(() => {
+      addBreadcrumb(message);
+    }, 0);
+  }
+}
+
+function addBreadcrumb(message) {
+  const hub = getCurrentHub();
+  hub.addBreadcrumb(
+    {
+      category: 'console',
+      data: {
+        logger: 'replay',
+      },
+      level: 'info',
+      message,
+    },
+    { level: 'info' },
+  );
+}
+
+/** This error indicates that the event buffer size exceeded the limit.. */
+class EventBufferSizeExceededError extends Error {
+   constructor() {
+    super(`Event buffer exceeded maximum size of ${REPLAY_MAX_EVENT_BUFFER_SIZE}.`);
+  }
+}
+
+/**
+ * A basic event buffer that does not do any compression.
+ * Used as fallback if the compression worker cannot be loaded or is disabled.
+ */
+class EventBufferArray  {
+  /** All the events that are buffered to be sent. */
+
+  /** @inheritdoc */
+
+   constructor() {
+    this.events = [];
+    this._totalSize = 0;
+    this.hasCheckout = false;
+  }
+
+  /** @inheritdoc */
+   get hasEvents() {
+    return this.events.length > 0;
+  }
+
+  /** @inheritdoc */
+   get type() {
+    return 'sync';
+  }
+
+  /** @inheritdoc */
+   destroy() {
+    this.events = [];
+  }
+
+  /** @inheritdoc */
+   async addEvent(event) {
+    const eventSize = JSON.stringify(event).length;
+    this._totalSize += eventSize;
+    if (this._totalSize > REPLAY_MAX_EVENT_BUFFER_SIZE) {
+      throw new EventBufferSizeExceededError();
+    }
+
+    this.events.push(event);
+  }
+
+  /** @inheritdoc */
+   finish() {
+    return new Promise(resolve => {
+      // Make a copy of the events array reference and immediately clear the
+      // events member so that we do not lose new events while uploading
+      // attachment.
+      const eventsRet = this.events;
+      this.clear();
+      resolve(JSON.stringify(eventsRet));
+    });
+  }
+
+  /** @inheritdoc */
+   clear() {
+    this.events = [];
+    this._totalSize = 0;
+    this.hasCheckout = false;
+  }
+
+  /** @inheritdoc */
+   getEarliestTimestamp() {
+    const timestamp = this.events.map(event => event.timestamp).sort()[0];
+
+    if (!timestamp) {
+      return null;
+    }
+
+    return timestampToMs(timestamp);
+  }
+}
+
+/**
+ * Event buffer that uses a web worker to compress events.
+ * Exported only for testing.
+ */
+class WorkerHandler {
+
+   constructor(worker) {
+    this._worker = worker;
+    this._id = 0;
+  }
+
+  /**
+   * Ensure the worker is ready (or not).
+   * This will either resolve when the worker is ready, or reject if an error occured.
+   */
+   ensureReady() {
+    // Ensure we only check once
+    if (this._ensureReadyPromise) {
+      return this._ensureReadyPromise;
+    }
+
+    this._ensureReadyPromise = new Promise((resolve, reject) => {
+      this._worker.addEventListener(
+        'message',
+        ({ data }) => {
+          if ((data ).success) {
+            resolve();
+          } else {
+            reject();
+          }
+        },
+        { once: true },
+      );
+
+      this._worker.addEventListener(
+        'error',
+        error => {
+          reject(error);
+        },
+        { once: true },
+      );
+    });
+
+    return this._ensureReadyPromise;
+  }
+
+  /**
+   * Destroy the worker.
+   */
+   destroy() {
+    logInfo('[Replay] Destroying compression worker');
+    this._worker.terminate();
+  }
+
+  /**
+   * Post message to worker and wait for response before resolving promise.
+   */
+   postMessage(method, arg) {
+    const id = this._getAndIncrementId();
+
+    return new Promise((resolve, reject) => {
+      const listener = ({ data }) => {
+        const response = data ;
+        if (response.method !== method) {
+          return;
+        }
+
+        // There can be multiple listeners for a single method, the id ensures
+        // that the response matches the caller.
+        if (response.id !== id) {
+          return;
+        }
+
+        // At this point, we'll always want to remove listener regardless of result status
+        this._worker.removeEventListener('message', listener);
+
+        if (!response.success) {
+          // TODO: Do some error handling, not sure what
+          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('[Replay]', response.response);
+
+          reject(new Error('Error in compression worker'));
+          return;
+        }
+
+        resolve(response.response );
+      };
+
+      // Note: we can't use `once` option because it's possible it needs to
+      // listen to multiple messages
+      this._worker.addEventListener('message', listener);
+      this._worker.postMessage({ id, method, arg });
+    });
+  }
+
+  /** Get the current ID and increment it for the next call. */
+   _getAndIncrementId() {
+    return this._id++;
+  }
+}
+
+/**
+ * Event buffer that uses a web worker to compress events.
+ * Exported only for testing.
+ */
+class EventBufferCompressionWorker  {
+  /** @inheritdoc */
+
+   constructor(worker) {
+    this._worker = new WorkerHandler(worker);
+    this._earliestTimestamp = null;
+    this._totalSize = 0;
+    this.hasCheckout = false;
+  }
+
+  /** @inheritdoc */
+   get hasEvents() {
+    return !!this._earliestTimestamp;
+  }
+
+  /** @inheritdoc */
+   get type() {
+    return 'worker';
+  }
+
+  /**
+   * Ensure the worker is ready (or not).
+   * This will either resolve when the worker is ready, or reject if an error occured.
+   */
+   ensureReady() {
+    return this._worker.ensureReady();
+  }
+
+  /**
+   * Destroy the event buffer.
+   */
+   destroy() {
+    this._worker.destroy();
+  }
+
+  /**
+   * Add an event to the event buffer.
+   *
+   * Returns true if event was successfuly received and processed by worker.
+   */
+   addEvent(event) {
+    const timestamp = timestampToMs(event.timestamp);
+    if (!this._earliestTimestamp || timestamp < this._earliestTimestamp) {
+      this._earliestTimestamp = timestamp;
+    }
+
+    const data = JSON.stringify(event);
+    this._totalSize += data.length;
+
+    if (this._totalSize > REPLAY_MAX_EVENT_BUFFER_SIZE) {
+      return Promise.reject(new EventBufferSizeExceededError());
+    }
+
+    return this._sendEventToWorker(data);
+  }
+
+  /**
+   * Finish the event buffer and return the compressed data.
+   */
+   finish() {
+    return this._finishRequest();
+  }
+
+  /** @inheritdoc */
+   clear() {
+    this._earliestTimestamp = null;
+    this._totalSize = 0;
+    this.hasCheckout = false;
+
+    // We do not wait on this, as we assume the order of messages is consistent for the worker
+    void this._worker.postMessage('clear');
+  }
+
+  /** @inheritdoc */
+   getEarliestTimestamp() {
+    return this._earliestTimestamp;
+  }
+
+  /**
+   * Send the event to the worker.
+   */
+   _sendEventToWorker(data) {
+    return this._worker.postMessage('addEvent', data);
+  }
+
+  /**
+   * Finish the request and return the compressed data from the worker.
+   */
+   async _finishRequest() {
+    const response = await this._worker.postMessage('finish');
+
+    this._earliestTimestamp = null;
+    this._totalSize = 0;
+
+    return response;
+  }
+}
+
+/**
+ * This proxy will try to use the compression worker, and fall back to use the simple buffer if an error occurs there.
+ * This can happen e.g. if the worker cannot be loaded.
+ * Exported only for testing.
+ */
+class EventBufferProxy  {
+
+   constructor(worker) {
+    this._fallback = new EventBufferArray();
+    this._compression = new EventBufferCompressionWorker(worker);
+    this._used = this._fallback;
+
+    this._ensureWorkerIsLoadedPromise = this._ensureWorkerIsLoaded();
+  }
+
+  /** @inheritdoc */
+   get type() {
+    return this._used.type;
+  }
+
+  /** @inheritDoc */
+   get hasEvents() {
+    return this._used.hasEvents;
+  }
+
+  /** @inheritdoc */
+   get hasCheckout() {
+    return this._used.hasCheckout;
+  }
+  /** @inheritdoc */
+   set hasCheckout(value) {
+    this._used.hasCheckout = value;
+  }
+
+  /** @inheritDoc */
+   destroy() {
+    this._fallback.destroy();
+    this._compression.destroy();
+  }
+
+  /** @inheritdoc */
+   clear() {
+    return this._used.clear();
+  }
+
+  /** @inheritdoc */
+   getEarliestTimestamp() {
+    return this._used.getEarliestTimestamp();
+  }
+
+  /**
+   * Add an event to the event buffer.
+   *
+   * Returns true if event was successfully added.
+   */
+   addEvent(event) {
+    return this._used.addEvent(event);
+  }
+
+  /** @inheritDoc */
+   async finish() {
+    // Ensure the worker is loaded, so the sent event is compressed
+    await this.ensureWorkerIsLoaded();
+
+    return this._used.finish();
+  }
+
+  /** Ensure the worker has loaded. */
+   ensureWorkerIsLoaded() {
+    return this._ensureWorkerIsLoadedPromise;
+  }
+
+  /** Actually check if the worker has been loaded. */
+   async _ensureWorkerIsLoaded() {
+    try {
+      await this._compression.ensureReady();
+    } catch (error) {
+      // If the worker fails to load, we fall back to the simple buffer.
+      // Nothing more to do from our side here
+      logInfo('[Replay] Failed to load the compression worker, falling back to simple buffer');
+      return;
+    }
+
+    // Now we need to switch over the array buffer to the compression worker
+    await this._switchToCompressionWorker();
+  }
+
+  /** Switch the used buffer to the compression worker. */
+   async _switchToCompressionWorker() {
+    const { events, hasCheckout } = this._fallback;
+
+    const addEventPromises = [];
+    for (const event of events) {
+      addEventPromises.push(this._compression.addEvent(event));
+    }
+
+    this._compression.hasCheckout = hasCheckout;
+
+    // We switch over to the new buffer immediately - any further events will be added
+    // after the previously buffered ones
+    this._used = this._compression;
+
+    // Wait for original events to be re-added before resolving
+    try {
+      await Promise.all(addEventPromises);
+    } catch (error) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('[Replay] Failed to add events when switching buffers.', error);
+    }
+  }
+}
+
+/**
+ * Create an event buffer for replays.
+ */
+function createEventBuffer({ useCompression }) {
+  // eslint-disable-next-line no-restricted-globals
+  if (useCompression && window.Worker) {
+    try {
+      const workerUrl = e();
+
+      logInfo('[Replay] Using compression worker');
+      const worker = new Worker(workerUrl);
+      return new EventBufferProxy(worker);
+    } catch (error) {
+      logInfo('[Replay] Failed to create compression worker');
+      // Fall back to use simple event buffer array
+    }
+  }
+
+  logInfo('[Replay] Using simple buffer');
+  return new EventBufferArray();
+}
+
+/** If sessionStorage is available. */
+function hasSessionStorage() {
+  try {
+    // This can throw, e.g. when being accessed in a sandboxed iframe
+    return 'sessionStorage' in WINDOW && !!WINDOW.sessionStorage;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Removes the session from Session Storage and unsets session in replay instance
+ */
+function clearSession(replay) {
+  deleteSession();
+  replay.session = undefined;
+}
+
+/**
+ * Deletes a session from storage
+ */
+function deleteSession() {
+  if (!hasSessionStorage()) {
+    return;
+  }
+
+  try {
+    WINDOW.sessionStorage.removeItem(REPLAY_SESSION_KEY);
+  } catch (e) {
+    // Ignore potential SecurityError exceptions
+  }
+}
+
+/**
+ * Given a sample rate, returns true if replay should be sampled.
+ *
+ * 1.0 = 100% sampling
+ * 0.0 = 0% sampling
+ */
+function isSampled(sampleRate) {
+  if (sampleRate === undefined) {
+    return false;
+  }
+
+  // Math.random() returns a number in range of 0 to 1 (inclusive of 0, but not 1)
+  return Math.random() < sampleRate;
+}
+
+/**
+ * Save a session to session storage.
+ */
+function saveSession(session) {
+  if (!hasSessionStorage()) {
+    return;
+  }
+
+  try {
+    WINDOW.sessionStorage.setItem(REPLAY_SESSION_KEY, JSON.stringify(session));
+  } catch (e) {
+    // Ignore potential SecurityError exceptions
+  }
+}
+
+/**
+ * Get a session with defaults & applied sampling.
+ */
+function makeSession(session) {
+  const now = Date.now();
+  const id = session.id || uuid4();
+  // Note that this means we cannot set a started/lastActivity of `0`, but this should not be relevant outside of tests.
+  const started = session.started || now;
+  const lastActivity = session.lastActivity || now;
+  const segmentId = session.segmentId || 0;
+  const sampled = session.sampled;
+  const previousSessionId = session.previousSessionId;
+
+  return {
+    id,
+    started,
+    lastActivity,
+    segmentId,
+    sampled,
+    previousSessionId,
+  };
+}
+
+/**
+ * Get the sampled status for a session based on sample rates & current sampled status.
+ */
+function getSessionSampleType(sessionSampleRate, allowBuffering) {
+  return isSampled(sessionSampleRate) ? 'session' : allowBuffering ? 'buffer' : false;
+}
+
+/**
+ * Create a new session, which in its current implementation is a Sentry event
+ * that all replays will be saved to as attachments. Currently, we only expect
+ * one of these Sentry events per "replay session".
+ */
+function createSession(
+  { sessionSampleRate, allowBuffering, stickySession = false },
+  { previousSessionId } = {},
+) {
+  const sampled = getSessionSampleType(sessionSampleRate, allowBuffering);
+  const session = makeSession({
+    sampled,
+    previousSessionId,
+  });
+
+  if (stickySession) {
+    saveSession(session);
+  }
+
+  return session;
+}
+
+/**
+ * Fetches a session from storage
+ */
+function fetchSession(traceInternals) {
+  if (!hasSessionStorage()) {
+    return null;
+  }
+
+  try {
+    // This can throw if cookies are disabled
+    const sessionStringFromStorage = WINDOW.sessionStorage.getItem(REPLAY_SESSION_KEY);
+
+    if (!sessionStringFromStorage) {
+      return null;
+    }
+
+    const sessionObj = JSON.parse(sessionStringFromStorage) ;
+
+    logInfoNextTick('[Replay] Loading existing session', traceInternals);
+
+    return makeSession(sessionObj);
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Given an initial timestamp and an expiry duration, checks to see if current
+ * time should be considered as expired.
+ */
+function isExpired(
+  initialTime,
+  expiry,
+  targetTime = +new Date(),
+) {
+  // Always expired if < 0
+  if (initialTime === null || expiry === undefined || expiry < 0) {
+    return true;
+  }
+
+  // Never expires if == 0
+  if (expiry === 0) {
+    return false;
+  }
+
+  return initialTime + expiry <= targetTime;
+}
+
+/**
+ * Checks to see if session is expired
+ */
+function isSessionExpired(
+  session,
+  {
+    maxReplayDuration,
+    sessionIdleExpire,
+    targetTime = Date.now(),
+  },
+) {
+  return (
+    // First, check that maximum session length has not been exceeded
+    isExpired(session.started, maxReplayDuration, targetTime) ||
+    // check that the idle timeout has not been exceeded (i.e. user has
+    // performed an action within the last `sessionIdleExpire` ms)
+    isExpired(session.lastActivity, sessionIdleExpire, targetTime)
+  );
+}
+
+/** If the session should be refreshed or not. */
+function shouldRefreshSession(
+  session,
+  { sessionIdleExpire, maxReplayDuration },
+) {
+  // If not expired, all good, just keep the session
+  if (!isSessionExpired(session, { sessionIdleExpire, maxReplayDuration })) {
+    return false;
+  }
+
+  // If we are buffering & haven't ever flushed yet, always continue
+  if (session.sampled === 'buffer' && session.segmentId === 0) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Get or create a session, when initializing the replay.
+ * Returns a session that may be unsampled.
+ */
+function loadOrCreateSession(
+  {
+    traceInternals,
+    sessionIdleExpire,
+    maxReplayDuration,
+    previousSessionId,
+  }
+
+,
+  sessionOptions,
+) {
+  const existingSession = sessionOptions.stickySession && fetchSession(traceInternals);
+
+  // No session exists yet, just create a new one
+  if (!existingSession) {
+    logInfoNextTick('[Replay] Creating new session', traceInternals);
+    return createSession(sessionOptions, { previousSessionId });
+  }
+
+  if (!shouldRefreshSession(existingSession, { sessionIdleExpire, maxReplayDuration })) {
+    return existingSession;
+  }
+
+  logInfoNextTick('[Replay] Session in sessionStorage is expired, creating new one...');
+  return createSession(sessionOptions, { previousSessionId: existingSession.id });
+}
+
+const ReplayEventTypeCustom = 5;
+
+function isCustomEvent(event) {
+  return event.type === EventType.Custom;
+}
+
+/**
+ * Add an event to the event buffer.
+ * In contrast to `addEvent`, this does not return a promise & does not wait for the adding of the event to succeed/fail.
+ * Instead this returns `true` if we tried to add the event, else false.
+ * It returns `false` e.g. if we are paused, disabled, or out of the max replay duration.
+ *
+ * `isCheckout` is true if this is either the very first event, or an event triggered by `checkoutEveryNms`.
+ */
+function addEventSync(replay, event, isCheckout) {
+  if (!shouldAddEvent(replay, event)) {
+    return false;
+  }
+
+  void _addEvent(replay, event, isCheckout);
+
+  return true;
+}
+
+/**
+ * Add an event to the event buffer.
+ * Resolves to `null` if no event was added, else to `void`.
+ *
+ * `isCheckout` is true if this is either the very first event, or an event triggered by `checkoutEveryNms`.
+ */
+function addEvent(
+  replay,
+  event,
+  isCheckout,
+) {
+  if (!shouldAddEvent(replay, event)) {
+    return Promise.resolve(null);
+  }
+
+  return _addEvent(replay, event, isCheckout);
+}
+
+async function _addEvent(
+  replay,
+  event,
+  isCheckout,
+) {
+  if (!replay.eventBuffer) {
+    return null;
+  }
+
+  try {
+    if (isCheckout && replay.recordingMode === 'buffer') {
+      replay.eventBuffer.clear();
+    }
+
+    if (isCheckout) {
+      replay.eventBuffer.hasCheckout = true;
+    }
+
+    const replayOptions = replay.getOptions();
+
+    const eventAfterPossibleCallback = maybeApplyCallback(event, replayOptions.beforeAddRecordingEvent);
+
+    if (!eventAfterPossibleCallback) {
+      return;
+    }
+
+    return await replay.eventBuffer.addEvent(eventAfterPossibleCallback);
+  } catch (error) {
+    const reason = error && error instanceof EventBufferSizeExceededError ? 'addEventSizeExceeded' : 'addEvent';
+
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(error);
+    await replay.stop({ reason });
+
+    const client = getCurrentHub().getClient();
+
+    if (client) {
+      client.recordDroppedEvent('internal_sdk_error', 'replay');
+    }
+  }
+}
+
+/** Exported only for tests. */
+function shouldAddEvent(replay, event) {
+  if (!replay.eventBuffer || replay.isPaused() || !replay.isEnabled()) {
+    return false;
+  }
+
+  const timestampInMs = timestampToMs(event.timestamp);
+
+  // Throw out events that happen more than 5 minutes ago. This can happen if
+  // page has been left open and idle for a long period of time and user
+  // comes back to trigger a new session. The performance entries rely on
+  // `performance.timeOrigin`, which is when the page first opened.
+  if (timestampInMs + replay.timeouts.sessionIdlePause < Date.now()) {
+    return false;
+  }
+
+  // Throw out events that are +60min from the initial timestamp
+  if (timestampInMs > replay.getContext().initialTimestamp + replay.getOptions().maxReplayDuration) {
+    logInfo(
+      `[Replay] Skipping event with timestamp ${timestampInMs} because it is after maxReplayDuration`,
+      replay.getOptions()._experiments.traceInternals,
+    );
+    return false;
+  }
+
+  return true;
+}
+
+function maybeApplyCallback(
+  event,
+  callback,
+) {
+  try {
+    if (typeof callback === 'function' && isCustomEvent(event)) {
+      return callback(event);
+    }
+  } catch (error) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+      logger.error('[Replay] An error occured in the `beforeAddRecordingEvent` callback, skipping the event...', error);
+    return null;
+  }
+
+  return event;
+}
+
+/** If the event is an error event */
+function isErrorEvent(event) {
+  return !event.type;
+}
+
+/** If the event is a transaction event */
+function isTransactionEvent(event) {
+  return event.type === 'transaction';
+}
+
+/** If the event is an replay event */
+function isReplayEvent(event) {
+  return event.type === 'replay_event';
+}
+
+/**
+ * Returns a listener to be added to `client.on('afterSendErrorEvent, listener)`.
+ */
+function handleAfterSendEvent(replay) {
+  // Custom transports may still be returning `Promise<void>`, which means we cannot expect the status code to be available there
+  // TODO (v8): remove this check as it will no longer be necessary
+  const enforceStatusCode = isBaseTransportSend();
+
+  return (event, sendResponse) => {
+    if (!replay.isEnabled() || (!isErrorEvent(event) && !isTransactionEvent(event))) {
+      return;
+    }
+
+    const statusCode = sendResponse && sendResponse.statusCode;
+
+    // We only want to do stuff on successful error sending, otherwise you get error replays without errors attached
+    // If not using the base transport, we allow `undefined` response (as a custom transport may not implement this correctly yet)
+    // If we do use the base transport, we skip if we encountered an non-OK status code
+    if (enforceStatusCode && (!statusCode || statusCode < 200 || statusCode >= 300)) {
+      return;
+    }
+
+    if (isTransactionEvent(event)) {
+      handleTransactionEvent(replay, event);
+      return;
+    }
+
+    handleErrorEvent(replay, event);
+  };
+}
+
+function handleTransactionEvent(replay, event) {
+  const replayContext = replay.getContext();
+
+  // Collect traceIds in _context regardless of `recordingMode`
+  // In error mode, _context gets cleared on every checkout
+  // We limit to max. 100 transactions linked
+  if (event.contexts && event.contexts.trace && event.contexts.trace.trace_id && replayContext.traceIds.size < 100) {
+    replayContext.traceIds.add(event.contexts.trace.trace_id );
+  }
+}
+
+function handleErrorEvent(replay, event) {
+  const replayContext = replay.getContext();
+
+  // Add error to list of errorIds of replay. This is ok to do even if not
+  // sampled because context will get reset at next checkout.
+  // XXX: There is also a race condition where it's possible to capture an
+  // error to Sentry before Replay SDK has loaded, but response returns after
+  // it was loaded, and this gets called.
+  // We limit to max. 100 errors linked
+  if (event.event_id && replayContext.errorIds.size < 100) {
+    replayContext.errorIds.add(event.event_id);
+  }
+
+  // If error event is tagged with replay id it means it was sampled (when in buffer mode)
+  // Need to be very careful that this does not cause an infinite loop
+  if (replay.recordingMode === 'buffer' && event.tags && event.tags.replayId) {
+    setTimeout(() => {
+      // Capture current event buffer as new replay
+      void replay.sendBufferedReplayOrFlush();
+    });
+  }
+}
+
+function isBaseTransportSend() {
+  const client = getCurrentHub().getClient();
+  if (!client) {
+    return false;
+  }
+
+  const transport = client.getTransport();
+  if (!transport) {
+    return false;
+  }
+
+  return (
+    (transport.send ).__sentry__baseTransport__ || false
+  );
+}
+
+/**
+ * Returns true if we think the given event is an error originating inside of rrweb.
+ */
+function isRrwebError(event, hint) {
+  if (event.type || !event.exception || !event.exception.values || !event.exception.values.length) {
+    return false;
+  }
+
+  // @ts-expect-error this may be set by rrweb when it finds errors
+  if (hint.originalException && hint.originalException.__rrweb__) {
+    return true;
+  }
+
+  // Check if any exception originates from rrweb
+  return event.exception.values.some(exception => {
+    if (!exception.stacktrace || !exception.stacktrace.frames || !exception.stacktrace.frames.length) {
+      return false;
+    }
+
+    return exception.stacktrace.frames.some(frame => frame.filename && frame.filename.includes('/rrweb/src/'));
+  });
+}
+
+/**
+ * Determine if event should be sampled (only applies in buffer mode).
+ * When an event is captured by `hanldleGlobalEvent`, when in buffer mode
+ * we determine if we want to sample the error or not.
+ */
+function shouldSampleForBufferEvent(replay, event) {
+  if (replay.recordingMode !== 'buffer') {
+    return false;
+  }
+
+  // ignore this error because otherwise we could loop indefinitely with
+  // trying to capture replay and failing
+  if (event.message === UNABLE_TO_SEND_REPLAY) {
+    return false;
+  }
+
+  // Require the event to be an error event & to have an exception
+  if (!event.exception || event.type) {
+    return false;
+  }
+
+  return isSampled(replay.getOptions().errorSampleRate);
+}
+
+/**
+ * Returns a listener to be added to `addGlobalEventProcessor(listener)`.
+ */
+function handleGlobalEventListener(
+  replay,
+  includeAfterSendEventHandling = false,
+) {
+  const afterSendHandler = includeAfterSendEventHandling ? handleAfterSendEvent(replay) : undefined;
+
+  return (event, hint) => {
+    // Do nothing if replay has been disabled
+    if (!replay.isEnabled()) {
+      return event;
+    }
+
+    if (isReplayEvent(event)) {
+      // Replays have separate set of breadcrumbs, do not include breadcrumbs
+      // from core SDK
+      delete event.breadcrumbs;
+      return event;
+    }
+
+    // We only want to handle errors & transactions, nothing else
+    if (!isErrorEvent(event) && !isTransactionEvent(event)) {
+      return event;
+    }
+
+    // Unless `captureExceptions` is enabled, we want to ignore errors coming from rrweb
+    // As there can be a bunch of stuff going wrong in internals there, that we don't want to bubble up to users
+    if (isRrwebError(event, hint) && !replay.getOptions()._experiments.captureExceptions) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Replay] Ignoring error from rrweb internals', event);
+      return null;
+    }
+
+    // When in buffer mode, we decide to sample here.
+    // Later, in `handleAfterSendEvent`, if the replayId is set, we know that we sampled
+    // And convert the buffer session to a full session
+    const isErrorEventSampled = shouldSampleForBufferEvent(replay, event);
+
+    // Tag errors if it has been sampled in buffer mode, or if it is session mode
+    // Only tag transactions if in session mode
+    const shouldTagReplayId = isErrorEventSampled || replay.recordingMode === 'session';
+
+    if (shouldTagReplayId) {
+      event.tags = { ...event.tags, replayId: replay.getSessionId() };
+    }
+
+    // In cases where a custom client is used that does not support the new hooks (yet),
+    // we manually call this hook method here
+    if (afterSendHandler) {
+      // Pretend the error had a 200 response so we always capture it
+      afterSendHandler(event, { statusCode: 200 });
+    }
+
+    return event;
+  };
+}
+
+/**
+ * Create a "span" for each performance entry.
+ */
+function createPerformanceSpans(
+  replay,
+  entries,
+) {
+  return entries.map(({ type, start, end, name, data }) => {
+    const response = replay.throttledAddEvent({
+      type: EventType.Custom,
+      timestamp: start,
+      data: {
+        tag: 'performanceSpan',
+        payload: {
+          op: type,
+          description: name,
+          startTimestamp: start,
+          endTimestamp: end,
+          data,
+        },
+      },
+    });
+
+    // If response is a string, it means its either THROTTLED or SKIPPED
+    return typeof response === 'string' ? Promise.resolve(null) : response;
+  });
+}
+
+function handleHistory(handlerData) {
+  const { from, to } = handlerData;
+
+  const now = Date.now() / 1000;
+
+  return {
+    type: 'navigation.push',
+    start: now,
+    end: now,
+    name: to,
+    data: {
+      previous: from,
+    },
+  };
+}
+
+/**
+ * Returns a listener to be added to `addInstrumentationHandler('history', listener)`.
+ */
+function handleHistorySpanListener(replay) {
+  return (handlerData) => {
+    if (!replay.isEnabled()) {
+      return;
+    }
+
+    const result = handleHistory(handlerData);
+
+    if (result === null) {
+      return;
+    }
+
+    // Need to collect visited URLs
+    replay.getContext().urls.push(result.name);
+    replay.triggerUserActivity();
+
+    replay.addUpdate(() => {
+      createPerformanceSpans(replay, [result]);
+      // Returning false to flush
+      return false;
+    });
+  };
+}
+
+/**
+ * Check whether a given request URL should be filtered out. This is so we
+ * don't log Sentry ingest requests.
+ */
+function shouldFilterRequest(replay, url) {
+  // If we enabled the `traceInternals` experiment, we want to trace everything
+  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && replay.getOptions()._experiments.traceInternals) {
+    return false;
+  }
+
+  return _isSentryRequest(url);
+}
+
+/**
+ * Checks wether a given URL belongs to the configured Sentry DSN.
+ */
+function _isSentryRequest(url) {
+  const client = getCurrentHub().getClient();
+  const dsn = client && client.getDsn();
+  return dsn ? url.includes(dsn.host) : false;
+}
+
+/** Add a performance entry breadcrumb */
+function addNetworkBreadcrumb(
+  replay,
+  result,
+) {
+  if (!replay.isEnabled()) {
+    return;
+  }
+
+  if (result === null) {
+    return;
+  }
+
+  if (shouldFilterRequest(replay, result.name)) {
+    return;
+  }
+
+  replay.addUpdate(() => {
+    createPerformanceSpans(replay, [result]);
+    // Returning true will cause `addUpdate` to not flush
+    // We do not want network requests to cause a flush. This will prevent
+    // recurring/polling requests from keeping the replay session alive.
+    return true;
+  });
+}
+
+/** only exported for tests */
+function handleFetch(handlerData) {
+  const { startTimestamp, endTimestamp, fetchData, response } = handlerData;
+
+  if (!endTimestamp) {
+    return null;
+  }
+
+  // This is only used as a fallback, so we know the body sizes are never set here
+  const { method, url } = fetchData;
+
+  return {
+    type: 'resource.fetch',
+    start: startTimestamp / 1000,
+    end: endTimestamp / 1000,
+    name: url,
+    data: {
+      method,
+      statusCode: response ? (response ).status : undefined,
+    },
+  };
+}
+
+/**
+ * Returns a listener to be added to `addInstrumentationHandler('fetch', listener)`.
+ */
+function handleFetchSpanListener(replay) {
+  return (handlerData) => {
+    if (!replay.isEnabled()) {
+      return;
+    }
+
+    const result = handleFetch(handlerData);
+
+    addNetworkBreadcrumb(replay, result);
+  };
+}
+
+/** only exported for tests */
+function handleXhr(handlerData) {
+  const { startTimestamp, endTimestamp, xhr } = handlerData;
+
+  const sentryXhrData = xhr[SENTRY_XHR_DATA_KEY];
+
+  if (!startTimestamp || !endTimestamp || !sentryXhrData) {
+    return null;
+  }
+
+  // This is only used as a fallback, so we know the body sizes are never set here
+  const { method, url, status_code: statusCode } = sentryXhrData;
+
+  if (url === undefined) {
+    return null;
+  }
+
+  return {
+    type: 'resource.xhr',
+    name: url,
+    start: startTimestamp / 1000,
+    end: endTimestamp / 1000,
+    data: {
+      method,
+      statusCode,
+    },
+  };
+}
+
+/**
+ * Returns a listener to be added to `addInstrumentationHandler('xhr', listener)`.
+ */
+function handleXhrSpanListener(replay) {
+  return (handlerData) => {
+    if (!replay.isEnabled()) {
+      return;
+    }
+
+    const result = handleXhr(handlerData);
+
+    addNetworkBreadcrumb(replay, result);
+  };
+}
+
+const OBJ = 10;
+const OBJ_KEY = 11;
+const OBJ_KEY_STR = 12;
+const OBJ_VAL = 13;
+const OBJ_VAL_STR = 14;
+const OBJ_VAL_COMPLETED = 15;
+
+const ARR = 20;
+const ARR_VAL = 21;
+const ARR_VAL_STR = 22;
+const ARR_VAL_COMPLETED = 23;
+
+const ALLOWED_PRIMITIVES = ['true', 'false', 'null'];
+
+/**
+ * Complete an incomplete JSON string.
+ * This will ensure that the last element always has a `"~~"` to indicate it was truncated.
+ * For example, `[1,2,` will be completed to `[1,2,"~~"]`
+ * and `{"aa":"b` will be completed to `{"aa":"b~~"}`
+ */
+function completeJson(incompleteJson, stack) {
+  if (!stack.length) {
+    return incompleteJson;
+  }
+
+  let json = incompleteJson;
+
+  // Most checks are only needed for the last step in the stack
+  const lastPos = stack.length - 1;
+  const lastStep = stack[lastPos];
+
+  json = _fixLastStep(json, lastStep);
+
+  // Complete remaining steps - just add closing brackets
+  for (let i = lastPos; i >= 0; i--) {
+    const step = stack[i];
+
+    switch (step) {
+      case OBJ:
+        json = `${json}}`;
+        break;
+      case ARR:
+        json = `${json}]`;
+        break;
+    }
+  }
+
+  return json;
+}
+
+function _fixLastStep(json, lastStep) {
+  switch (lastStep) {
+    // Object cases
+    case OBJ:
+      return `${json}"~~":"~~"`;
+    case OBJ_KEY:
+      return `${json}:"~~"`;
+    case OBJ_KEY_STR:
+      return `${json}~~":"~~"`;
+    case OBJ_VAL:
+      return _maybeFixIncompleteObjValue(json);
+    case OBJ_VAL_STR:
+      return `${json}~~"`;
+    case OBJ_VAL_COMPLETED:
+      return `${json},"~~":"~~"`;
+
+    // Array cases
+    case ARR:
+      return `${json}"~~"`;
+    case ARR_VAL:
+      return _maybeFixIncompleteArrValue(json);
+    case ARR_VAL_STR:
+      return `${json}~~"`;
+    case ARR_VAL_COMPLETED:
+      return `${json},"~~"`;
+  }
+
+  return json;
+}
+
+function _maybeFixIncompleteArrValue(json) {
+  const pos = _findLastArrayDelimiter(json);
+
+  if (pos > -1) {
+    const part = json.slice(pos + 1);
+
+    if (ALLOWED_PRIMITIVES.includes(part.trim())) {
+      return `${json},"~~"`;
+    }
+
+    // Everything else is replaced with `"~~"`
+    return `${json.slice(0, pos + 1)}"~~"`;
+  }
+
+  // fallback, this shouldn't happen, to be save
+  return json;
+}
+
+function _findLastArrayDelimiter(json) {
+  for (let i = json.length - 1; i >= 0; i--) {
+    const char = json[i];
+
+    if (char === ',' || char === '[') {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+function _maybeFixIncompleteObjValue(json) {
+  const startPos = json.lastIndexOf(':');
+
+  const part = json.slice(startPos + 1);
+
+  if (ALLOWED_PRIMITIVES.includes(part.trim())) {
+    return `${json},"~~":"~~"`;
+  }
+
+  // Everything else is replaced with `"~~"`
+  // This also means we do not have incomplete numbers, e.g `[1` is replaced with `["~~"]`
+  return `${json.slice(0, startPos + 1)}"~~"`;
+}
+
+/**
+ * Evaluate an (incomplete) JSON string.
+ */
+function evaluateJson(json) {
+  const stack = [];
+
+  for (let pos = 0; pos < json.length; pos++) {
+    _evaluateJsonPos(stack, json, pos);
+  }
+
+  return stack;
+}
+
+function _evaluateJsonPos(stack, json, pos) {
+  const curStep = stack[stack.length - 1];
+
+  const char = json[pos];
+
+  const whitespaceRegex = /\s/;
+
+  if (whitespaceRegex.test(char)) {
+    return;
+  }
+
+  if (char === '"' && !_isEscaped(json, pos)) {
+    _handleQuote(stack, curStep);
+    return;
+  }
+
+  switch (char) {
+    case '{':
+      _handleObj(stack, curStep);
+      break;
+    case '[':
+      _handleArr(stack, curStep);
+      break;
+    case ':':
+      _handleColon(stack, curStep);
+      break;
+    case ',':
+      _handleComma(stack, curStep);
+      break;
+    case '}':
+      _handleObjClose(stack, curStep);
+      break;
+    case ']':
+      _handleArrClose(stack, curStep);
+      break;
+  }
+}
+
+function _handleQuote(stack, curStep) {
+  // End of obj value
+  if (curStep === OBJ_VAL_STR) {
+    stack.pop();
+    stack.push(OBJ_VAL_COMPLETED);
+    return;
+  }
+
+  // End of arr value
+  if (curStep === ARR_VAL_STR) {
+    stack.pop();
+    stack.push(ARR_VAL_COMPLETED);
+    return;
+  }
+
+  // Start of obj value
+  if (curStep === OBJ_VAL) {
+    stack.push(OBJ_VAL_STR);
+    return;
+  }
+
+  // Start of arr value
+  if (curStep === ARR_VAL) {
+    stack.push(ARR_VAL_STR);
+    return;
+  }
+
+  // Start of obj key
+  if (curStep === OBJ) {
+    stack.push(OBJ_KEY_STR);
+    return;
+  }
+
+  // End of obj key
+  if (curStep === OBJ_KEY_STR) {
+    stack.pop();
+    stack.push(OBJ_KEY);
+    return;
+  }
+}
+
+function _handleObj(stack, curStep) {
+  // Initial object
+  if (!curStep) {
+    stack.push(OBJ);
+    return;
+  }
+
+  // New object as obj value
+  if (curStep === OBJ_VAL) {
+    stack.push(OBJ);
+    return;
+  }
+
+  // New object as array element
+  if (curStep === ARR_VAL) {
+    stack.push(OBJ);
+  }
+
+  // New object as first array element
+  if (curStep === ARR) {
+    stack.push(OBJ);
+    return;
+  }
+}
+
+function _handleArr(stack, curStep) {
+  // Initial array
+  if (!curStep) {
+    stack.push(ARR);
+    stack.push(ARR_VAL);
+    return;
+  }
+
+  // New array as obj value
+  if (curStep === OBJ_VAL) {
+    stack.push(ARR);
+    stack.push(ARR_VAL);
+    return;
+  }
+
+  // New array as array element
+  if (curStep === ARR_VAL) {
+    stack.push(ARR);
+    stack.push(ARR_VAL);
+  }
+
+  // New array as first array element
+  if (curStep === ARR) {
+    stack.push(ARR);
+    stack.push(ARR_VAL);
+    return;
+  }
+}
+
+function _handleColon(stack, curStep) {
+  if (curStep === OBJ_KEY) {
+    stack.pop();
+    stack.push(OBJ_VAL);
+  }
+}
+
+function _handleComma(stack, curStep) {
+  // Comma after obj value
+  if (curStep === OBJ_VAL) {
+    stack.pop();
+    return;
+  }
+  if (curStep === OBJ_VAL_COMPLETED) {
+    // Pop OBJ_VAL_COMPLETED & OBJ_VAL
+    stack.pop();
+    stack.pop();
+    return;
+  }
+
+  // Comma after arr value
+  if (curStep === ARR_VAL) {
+    // do nothing - basically we'd pop ARR_VAL but add it right back
+    return;
+  }
+
+  if (curStep === ARR_VAL_COMPLETED) {
+    // Pop ARR_VAL_COMPLETED
+    stack.pop();
+
+    // basically we'd pop ARR_VAL but add it right back
+    return;
+  }
+}
+
+function _handleObjClose(stack, curStep) {
+  // Empty object {}
+  if (curStep === OBJ) {
+    stack.pop();
+  }
+
+  // Object with element
+  if (curStep === OBJ_VAL) {
+    // Pop OBJ_VAL, OBJ
+    stack.pop();
+    stack.pop();
+  }
+
+  // Obj with element
+  if (curStep === OBJ_VAL_COMPLETED) {
+    // Pop OBJ_VAL_COMPLETED, OBJ_VAL, OBJ
+    stack.pop();
+    stack.pop();
+    stack.pop();
+  }
+
+  // if was obj value, complete it
+  if (stack[stack.length - 1] === OBJ_VAL) {
+    stack.push(OBJ_VAL_COMPLETED);
+  }
+
+  // if was arr value, complete it
+  if (stack[stack.length - 1] === ARR_VAL) {
+    stack.push(ARR_VAL_COMPLETED);
+  }
+}
+
+function _handleArrClose(stack, curStep) {
+  // Empty array []
+  if (curStep === ARR) {
+    stack.pop();
+  }
+
+  // Array with element
+  if (curStep === ARR_VAL) {
+    // Pop ARR_VAL, ARR
+    stack.pop();
+    stack.pop();
+  }
+
+  // Array with element
+  if (curStep === ARR_VAL_COMPLETED) {
+    // Pop ARR_VAL_COMPLETED, ARR_VAL, ARR
+    stack.pop();
+    stack.pop();
+    stack.pop();
+  }
+
+  // if was obj value, complete it
+  if (stack[stack.length - 1] === OBJ_VAL) {
+    stack.push(OBJ_VAL_COMPLETED);
+  }
+
+  // if was arr value, complete it
+  if (stack[stack.length - 1] === ARR_VAL) {
+    stack.push(ARR_VAL_COMPLETED);
+  }
+}
+
+function _isEscaped(str, pos) {
+  const previousChar = str[pos - 1];
+
+  return previousChar === '\\' && !_isEscaped(str, pos - 1);
+}
+
+/* eslint-disable max-lines */
+
+/**
+ * Takes an incomplete JSON string, and returns a hopefully valid JSON string.
+ * Note that this _can_ fail, so you should check the return value is valid JSON.
+ */
+function fixJson(incompleteJson) {
+  const stack = evaluateJson(incompleteJson);
+
+  return completeJson(incompleteJson, stack);
+}
+
+/** Get the size of a body. */
+function getBodySize(
+  body,
+  textEncoder,
+) {
+  if (!body) {
+    return undefined;
+  }
+
+  try {
+    if (typeof body === 'string') {
+      return textEncoder.encode(body).length;
+    }
+
+    if (body instanceof URLSearchParams) {
+      return textEncoder.encode(body.toString()).length;
+    }
+
+    if (body instanceof FormData) {
+      const formDataStr = _serializeFormData(body);
+      return textEncoder.encode(formDataStr).length;
+    }
+
+    if (body instanceof Blob) {
+      return body.size;
+    }
+
+    if (body instanceof ArrayBuffer) {
+      return body.byteLength;
+    }
+
+    // Currently unhandled types: ArrayBufferView, ReadableStream
+  } catch (e) {
+    // just return undefined
+  }
+
+  return undefined;
+}
+
+/** Convert a Content-Length header to number/undefined.  */
+function parseContentLengthHeader(header) {
+  if (!header) {
+    return undefined;
+  }
+
+  const size = parseInt(header, 10);
+  return isNaN(size) ? undefined : size;
+}
+
+/** Get the string representation of a body. */
+function getBodyString(body) {
+  if (typeof body === 'string') {
+    return body;
+  }
+
+  if (body instanceof URLSearchParams) {
+    return body.toString();
+  }
+
+  if (body instanceof FormData) {
+    return _serializeFormData(body);
+  }
+
+  return undefined;
+}
+
+/** Convert ReplayNetworkRequestData to a PerformanceEntry. */
+function makeNetworkReplayBreadcrumb(
+  type,
+  data,
+) {
+  if (!data) {
+    return null;
+  }
+
+  const { startTimestamp, endTimestamp, url, method, statusCode, request, response } = data;
+
+  const result = {
+    type,
+    start: startTimestamp / 1000,
+    end: endTimestamp / 1000,
+    name: url,
+    data: dropUndefinedKeys({
+      method,
+      statusCode,
+      request,
+      response,
+    }),
+  };
+
+  return result;
+}
+
+/** Build the request or response part of a replay network breadcrumb that was skipped. */
+function buildSkippedNetworkRequestOrResponse(bodySize) {
+  return {
+    headers: {},
+    size: bodySize,
+    _meta: {
+      warnings: ['URL_SKIPPED'],
+    },
+  };
+}
+
+/** Build the request or response part of a replay network breadcrumb. */
+function buildNetworkRequestOrResponse(
+  headers,
+  bodySize,
+  body,
+) {
+  if (!bodySize && Object.keys(headers).length === 0) {
+    return undefined;
+  }
+
+  if (!bodySize) {
+    return {
+      headers,
+    };
+  }
+
+  if (!body) {
+    return {
+      headers,
+      size: bodySize,
+    };
+  }
+
+  const info = {
+    headers,
+    size: bodySize,
+  };
+
+  const { body: normalizedBody, warnings } = normalizeNetworkBody(body);
+  info.body = normalizedBody;
+  if (warnings.length > 0) {
+    info._meta = {
+      warnings,
+    };
+  }
+
+  return info;
+}
+
+/** Filter a set of headers */
+function getAllowedHeaders(headers, allowedHeaders) {
+  return Object.keys(headers).reduce((filteredHeaders, key) => {
+    const normalizedKey = key.toLowerCase();
+    // Avoid putting empty strings into the headers
+    if (allowedHeaders.includes(normalizedKey) && headers[key]) {
+      filteredHeaders[normalizedKey] = headers[key];
+    }
+    return filteredHeaders;
+  }, {});
+}
+
+function _serializeFormData(formData) {
+  // This is a bit simplified, but gives us a decent estimate
+  // This converts e.g. { name: 'Anne Smith', age: 13 } to 'name=Anne+Smith&age=13'
+  // @ts-expect-error passing FormData to URLSearchParams actually works
+  return new URLSearchParams(formData).toString();
+}
+
+function normalizeNetworkBody(body)
+
+ {
+  if (!body || typeof body !== 'string') {
+    return {
+      body,
+      warnings: [],
+    };
+  }
+
+  const exceedsSizeLimit = body.length > NETWORK_BODY_MAX_SIZE;
+
+  if (_strIsProbablyJson(body)) {
+    try {
+      const json = exceedsSizeLimit ? fixJson(body.slice(0, NETWORK_BODY_MAX_SIZE)) : body;
+      const normalizedBody = JSON.parse(json);
+      return {
+        body: normalizedBody,
+        warnings: exceedsSizeLimit ? ['JSON_TRUNCATED'] : [],
+      };
+    } catch (e3) {
+      return {
+        body: exceedsSizeLimit ? `${body.slice(0, NETWORK_BODY_MAX_SIZE)}…` : body,
+        warnings: exceedsSizeLimit ? ['INVALID_JSON', 'TEXT_TRUNCATED'] : ['INVALID_JSON'],
+      };
+    }
+  }
+
+  return {
+    body: exceedsSizeLimit ? `${body.slice(0, NETWORK_BODY_MAX_SIZE)}…` : body,
+    warnings: exceedsSizeLimit ? ['TEXT_TRUNCATED'] : [],
+  };
+}
+
+function _strIsProbablyJson(str) {
+  const first = str[0];
+  const last = str[str.length - 1];
+
+  // Simple check: If this does not start & end with {} or [], it's not JSON
+  return (first === '[' && last === ']') || (first === '{' && last === '}');
+}
+
+/** Match an URL against a list of strings/Regex. */
+function urlMatches(url, urls) {
+  const fullUrl = getFullUrl(url);
+
+  return stringMatchesSomePattern(fullUrl, urls);
+}
+
+/** exported for tests */
+function getFullUrl(url, baseURI = WINDOW.document.baseURI) {
+  // Short circuit for common cases:
+  if (url.startsWith('http://') || url.startsWith('https://') || url.startsWith(WINDOW.location.origin)) {
+    return url;
+  }
+  const fixedUrl = new URL(url, baseURI);
+
+  // If these do not match, we are not dealing with a relative URL, so just return it
+  if (fixedUrl.origin !== new URL(baseURI).origin) {
+    return url;
+  }
+
+  const fullUrl = fixedUrl.href;
+
+  // Remove trailing slashes, if they don't match the original URL
+  if (!url.endsWith('/') && fullUrl.endsWith('/')) {
+    return fullUrl.slice(0, -1);
+  }
+
+  return fullUrl;
+}
+
+/**
+ * Capture a fetch breadcrumb to a replay.
+ * This adds additional data (where approriate).
+ */
+async function captureFetchBreadcrumbToReplay(
+  breadcrumb,
+  hint,
+  options
+
+,
+) {
+  try {
+    const data = await _prepareFetchData(breadcrumb, hint, options);
+
+    // Create a replay performance entry from this breadcrumb
+    const result = makeNetworkReplayBreadcrumb('resource.fetch', data);
+    addNetworkBreadcrumb(options.replay, result);
+  } catch (error) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('[Replay] Failed to capture fetch breadcrumb', error);
+  }
+}
+
+/**
+ * Enrich a breadcrumb with additional data.
+ * This has to be sync & mutate the given breadcrumb,
+ * as the breadcrumb is afterwards consumed by other handlers.
+ */
+function enrichFetchBreadcrumb(
+  breadcrumb,
+  hint,
+  options,
+) {
+  const { input, response } = hint;
+
+  const body = _getFetchRequestArgBody(input);
+  const reqSize = getBodySize(body, options.textEncoder);
+
+  const resSize = response ? parseContentLengthHeader(response.headers.get('content-length')) : undefined;
+
+  if (reqSize !== undefined) {
+    breadcrumb.data.request_body_size = reqSize;
+  }
+  if (resSize !== undefined) {
+    breadcrumb.data.response_body_size = resSize;
+  }
+}
+
+async function _prepareFetchData(
+  breadcrumb,
+  hint,
+  options
+
+,
+) {
+  const { startTimestamp, endTimestamp } = hint;
+
+  const {
+    url,
+    method,
+    status_code: statusCode = 0,
+    request_body_size: requestBodySize,
+    response_body_size: responseBodySize,
+  } = breadcrumb.data;
+
+  const captureDetails =
+    urlMatches(url, options.networkDetailAllowUrls) && !urlMatches(url, options.networkDetailDenyUrls);
+
+  const request = captureDetails
+    ? _getRequestInfo(options, hint.input, requestBodySize)
+    : buildSkippedNetworkRequestOrResponse(requestBodySize);
+  const response = await _getResponseInfo(captureDetails, options, hint.response, responseBodySize);
+
+  return {
+    startTimestamp,
+    endTimestamp,
+    url,
+    method,
+    statusCode,
+    request,
+    response,
+  };
+}
+
+function _getRequestInfo(
+  { networkCaptureBodies, networkRequestHeaders },
+  input,
+  requestBodySize,
+) {
+  const headers = getRequestHeaders(input, networkRequestHeaders);
+
+  if (!networkCaptureBodies) {
+    return buildNetworkRequestOrResponse(headers, requestBodySize, undefined);
+  }
+
+  // We only want to transmit string or string-like bodies
+  const requestBody = _getFetchRequestArgBody(input);
+  const bodyStr = getBodyString(requestBody);
+  return buildNetworkRequestOrResponse(headers, requestBodySize, bodyStr);
+}
+
+async function _getResponseInfo(
+  captureDetails,
+  {
+    networkCaptureBodies,
+    textEncoder,
+    networkResponseHeaders,
+  }
+
+,
+  response,
+  responseBodySize,
+) {
+  if (!captureDetails && responseBodySize !== undefined) {
+    return buildSkippedNetworkRequestOrResponse(responseBodySize);
+  }
+
+  const headers = getAllHeaders(response.headers, networkResponseHeaders);
+
+  if (!networkCaptureBodies && responseBodySize !== undefined) {
+    return buildNetworkRequestOrResponse(headers, responseBodySize, undefined);
+  }
+
+  // Only clone the response if we need to
+  try {
+    // We have to clone this, as the body can only be read once
+    const res = response.clone();
+    const bodyText = await _parseFetchBody(res);
+
+    const size =
+      bodyText && bodyText.length && responseBodySize === undefined
+        ? getBodySize(bodyText, textEncoder)
+        : responseBodySize;
+
+    if (!captureDetails) {
+      return buildSkippedNetworkRequestOrResponse(size);
+    }
+
+    if (networkCaptureBodies) {
+      return buildNetworkRequestOrResponse(headers, size, bodyText);
+    }
+
+    return buildNetworkRequestOrResponse(headers, size, undefined);
+  } catch (e) {
+    // fallback
+    return buildNetworkRequestOrResponse(headers, responseBodySize, undefined);
+  }
+}
+
+async function _parseFetchBody(response) {
+  try {
+    return await response.text();
+  } catch (e2) {
+    return undefined;
+  }
+}
+
+function _getFetchRequestArgBody(fetchArgs = []) {
+  // We only support getting the body from the fetch options
+  if (fetchArgs.length !== 2 || typeof fetchArgs[1] !== 'object') {
+    return undefined;
+  }
+
+  return (fetchArgs[1] ).body;
+}
+
+function getAllHeaders(headers, allowedHeaders) {
+  const allHeaders = {};
+
+  allowedHeaders.forEach(header => {
+    if (headers.get(header)) {
+      allHeaders[header] = headers.get(header) ;
+    }
+  });
+
+  return allHeaders;
+}
+
+function getRequestHeaders(fetchArgs, allowedHeaders) {
+  if (fetchArgs.length === 1 && typeof fetchArgs[0] !== 'string') {
+    return getHeadersFromOptions(fetchArgs[0] , allowedHeaders);
+  }
+
+  if (fetchArgs.length === 2) {
+    return getHeadersFromOptions(fetchArgs[1] , allowedHeaders);
+  }
+
+  return {};
+}
+
+function getHeadersFromOptions(
+  input,
+  allowedHeaders,
+) {
+  if (!input) {
+    return {};
+  }
+
+  const headers = input.headers;
+
+  if (!headers) {
+    return {};
+  }
+
+  if (headers instanceof Headers) {
+    return getAllHeaders(headers, allowedHeaders);
+  }
+
+  // We do not support this, as it is not really documented (anymore?)
+  if (Array.isArray(headers)) {
+    return {};
+  }
+
+  return getAllowedHeaders(headers, allowedHeaders);
+}
+
+/**
+ * Capture an XHR breadcrumb to a replay.
+ * This adds additional data (where approriate).
+ */
+async function captureXhrBreadcrumbToReplay(
+  breadcrumb,
+  hint,
+  options,
+) {
+  try {
+    const data = _prepareXhrData(breadcrumb, hint, options);
+
+    // Create a replay performance entry from this breadcrumb
+    const result = makeNetworkReplayBreadcrumb('resource.xhr', data);
+    addNetworkBreadcrumb(options.replay, result);
+  } catch (error) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('[Replay] Failed to capture fetch breadcrumb', error);
+  }
+}
+
+/**
+ * Enrich a breadcrumb with additional data.
+ * This has to be sync & mutate the given breadcrumb,
+ * as the breadcrumb is afterwards consumed by other handlers.
+ */
+function enrichXhrBreadcrumb(
+  breadcrumb,
+  hint,
+  options,
+) {
+  const { xhr, input } = hint;
+
+  const reqSize = getBodySize(input, options.textEncoder);
+  const resSize = xhr.getResponseHeader('content-length')
+    ? parseContentLengthHeader(xhr.getResponseHeader('content-length'))
+    : getBodySize(xhr.response, options.textEncoder);
+
+  if (reqSize !== undefined) {
+    breadcrumb.data.request_body_size = reqSize;
+  }
+  if (resSize !== undefined) {
+    breadcrumb.data.response_body_size = resSize;
+  }
+}
+
+function _prepareXhrData(
+  breadcrumb,
+  hint,
+  options,
+) {
+  const { startTimestamp, endTimestamp, input, xhr } = hint;
+
+  const {
+    url,
+    method,
+    status_code: statusCode = 0,
+    request_body_size: requestBodySize,
+    response_body_size: responseBodySize,
+  } = breadcrumb.data;
+
+  if (!url) {
+    return null;
+  }
+
+  if (!urlMatches(url, options.networkDetailAllowUrls) || urlMatches(url, options.networkDetailDenyUrls)) {
+    const request = buildSkippedNetworkRequestOrResponse(requestBodySize);
+    const response = buildSkippedNetworkRequestOrResponse(responseBodySize);
+    return {
+      startTimestamp,
+      endTimestamp,
+      url,
+      method,
+      statusCode,
+      request,
+      response,
+    };
+  }
+
+  const xhrInfo = xhr[SENTRY_XHR_DATA_KEY];
+  const networkRequestHeaders = xhrInfo
+    ? getAllowedHeaders(xhrInfo.request_headers, options.networkRequestHeaders)
+    : {};
+  const networkResponseHeaders = getAllowedHeaders(getResponseHeaders(xhr), options.networkResponseHeaders);
+
+  const request = buildNetworkRequestOrResponse(
+    networkRequestHeaders,
+    requestBodySize,
+    options.networkCaptureBodies ? getBodyString(input) : undefined,
+  );
+  const response = buildNetworkRequestOrResponse(
+    networkResponseHeaders,
+    responseBodySize,
+    options.networkCaptureBodies ? hint.xhr.responseText : undefined,
+  );
+
+  return {
+    startTimestamp,
+    endTimestamp,
+    url,
+    method,
+    statusCode,
+    request,
+    response,
+  };
+}
+
+function getResponseHeaders(xhr) {
+  const headers = xhr.getAllResponseHeaders();
+
+  if (!headers) {
+    return {};
+  }
+
+  return headers.split('\r\n').reduce((acc, line) => {
+    const [key, value] = line.split(': ');
+    acc[key.toLowerCase()] = value;
+    return acc;
+  }, {});
+}
+
+/**
+ * This method does two things:
+ * - It enriches the regular XHR/fetch breadcrumbs with request/response size data
+ * - It captures the XHR/fetch breadcrumbs to the replay
+ *   (enriching it with further data that is _not_ added to the regular breadcrumbs)
+ */
+function handleNetworkBreadcrumbs(replay) {
+  const client = getCurrentHub().getClient();
+
+  try {
+    const textEncoder = new TextEncoder();
+
+    const {
+      networkDetailAllowUrls,
+      networkDetailDenyUrls,
+      networkCaptureBodies,
+      networkRequestHeaders,
+      networkResponseHeaders,
+    } = replay.getOptions();
+
+    const options = {
+      replay,
+      textEncoder,
+      networkDetailAllowUrls,
+      networkDetailDenyUrls,
+      networkCaptureBodies,
+      networkRequestHeaders,
+      networkResponseHeaders,
+    };
+
+    if (client && client.on) {
+      client.on('beforeAddBreadcrumb', (breadcrumb, hint) => beforeAddNetworkBreadcrumb(options, breadcrumb, hint));
+    } else {
+      // Fallback behavior
+      addInstrumentationHandler('fetch', handleFetchSpanListener(replay));
+      addInstrumentationHandler('xhr', handleXhrSpanListener(replay));
+    }
+  } catch (e2) {
+    // Do nothing
+  }
+}
+
+/** just exported for tests */
+function beforeAddNetworkBreadcrumb(
+  options,
+  breadcrumb,
+  hint,
+) {
+  if (!breadcrumb.data) {
+    return;
+  }
+
+  try {
+    if (_isXhrBreadcrumb(breadcrumb) && _isXhrHint(hint)) {
+      // This has to be sync, as we need to ensure the breadcrumb is enriched in the same tick
+      // Because the hook runs synchronously, and the breadcrumb is afterwards passed on
+      // So any async mutations to it will not be reflected in the final breadcrumb
+      enrichXhrBreadcrumb(breadcrumb, hint, options);
+
+      void captureXhrBreadcrumbToReplay(breadcrumb, hint, options);
+    }
+
+    if (_isFetchBreadcrumb(breadcrumb) && _isFetchHint(hint)) {
+      // This has to be sync, as we need to ensure the breadcrumb is enriched in the same tick
+      // Because the hook runs synchronously, and the breadcrumb is afterwards passed on
+      // So any async mutations to it will not be reflected in the final breadcrumb
+      enrichFetchBreadcrumb(breadcrumb, hint, options);
+
+      void captureFetchBreadcrumbToReplay(breadcrumb, hint, options);
+    }
+  } catch (e) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Error when enriching network breadcrumb');
+  }
+}
+
+function _isXhrBreadcrumb(breadcrumb) {
+  return breadcrumb.category === 'xhr';
+}
+
+function _isFetchBreadcrumb(breadcrumb) {
+  return breadcrumb.category === 'fetch';
+}
+
+function _isXhrHint(hint) {
+  return hint && hint.xhr;
+}
+
+function _isFetchHint(hint) {
+  return hint && hint.response;
+}
+
+let _LAST_BREADCRUMB = null;
+
+function isBreadcrumbWithCategory(breadcrumb) {
+  return !!breadcrumb.category;
+}
+
+const handleScopeListener =
+  (replay) =>
+  (scope) => {
+    if (!replay.isEnabled()) {
+      return;
+    }
+
+    const result = handleScope(scope);
+
+    if (!result) {
+      return;
+    }
+
+    addBreadcrumbEvent(replay, result);
+  };
+
+/**
+ * An event handler to handle scope changes.
+ */
+function handleScope(scope) {
+  // TODO (v8): Remove this guard. This was put in place because we introduced
+  // Scope.getLastBreadcrumb mid-v7 which caused incompatibilities with older SDKs.
+  // For now, we'll just return null if the method doesn't exist but we should eventually
+  // get rid of this guard.
+  const newBreadcrumb = scope.getLastBreadcrumb && scope.getLastBreadcrumb();
+
+  // Listener can be called when breadcrumbs have not changed, so we store the
+  // reference to the last crumb and only return a crumb if it has changed
+  if (_LAST_BREADCRUMB === newBreadcrumb || !newBreadcrumb) {
+    return null;
+  }
+
+  _LAST_BREADCRUMB = newBreadcrumb;
+
+  if (
+    !isBreadcrumbWithCategory(newBreadcrumb) ||
+    ['fetch', 'xhr', 'sentry.event', 'sentry.transaction'].includes(newBreadcrumb.category) ||
+    newBreadcrumb.category.startsWith('ui.')
+  ) {
+    return null;
+  }
+
+  if (newBreadcrumb.category === 'console') {
+    return normalizeConsoleBreadcrumb(newBreadcrumb);
+  }
+
+  return createBreadcrumb(newBreadcrumb);
+}
+
+/** exported for tests only */
+function normalizeConsoleBreadcrumb(
+  breadcrumb,
+) {
+  const args = breadcrumb.data && breadcrumb.data.arguments;
+
+  if (!Array.isArray(args) || args.length === 0) {
+    return createBreadcrumb(breadcrumb);
+  }
+
+  let isTruncated = false;
+
+  // Avoid giant args captures
+  const normalizedArgs = args.map(arg => {
+    if (!arg) {
+      return arg;
+    }
+    if (typeof arg === 'string') {
+      if (arg.length > CONSOLE_ARG_MAX_SIZE) {
+        isTruncated = true;
+        return `${arg.slice(0, CONSOLE_ARG_MAX_SIZE)}…`;
+      }
+
+      return arg;
+    }
+    if (typeof arg === 'object') {
+      try {
+        const normalizedArg = normalize(arg, 7);
+        const stringified = JSON.stringify(normalizedArg);
+        if (stringified.length > CONSOLE_ARG_MAX_SIZE) {
+          const fixedJson = fixJson(stringified.slice(0, CONSOLE_ARG_MAX_SIZE));
+          const json = JSON.parse(fixedJson);
+          // We only set this after JSON.parse() was successfull, so we know we didn't run into `catch`
+          isTruncated = true;
+          return json;
+        }
+        return normalizedArg;
+      } catch (e) {
+        // fall back to default
+      }
+    }
+
+    return arg;
+  });
+
+  return createBreadcrumb({
+    ...breadcrumb,
+    data: {
+      ...breadcrumb.data,
+      arguments: normalizedArgs,
+      ...(isTruncated ? { _meta: { warnings: ['CONSOLE_ARG_TRUNCATED'] } } : {}),
+    },
+  });
+}
+
+/**
+ * Add global listeners that cannot be removed.
+ */
+function addGlobalListeners(replay) {
+  // Listeners from core SDK //
+  const scope = getCurrentHub().getScope();
+  const client = getCurrentHub().getClient();
+
+  scope.addScopeListener(handleScopeListener(replay));
+  addInstrumentationHandler('dom', handleDomListener(replay));
+  addInstrumentationHandler('history', handleHistorySpanListener(replay));
+  handleNetworkBreadcrumbs(replay);
+
+  // Tag all (non replay) events that get sent to Sentry with the current
+  // replay ID so that we can reference them later in the UI
+  addGlobalEventProcessor(handleGlobalEventListener(replay, !hasHooks(client)));
+
+  // If a custom client has no hooks yet, we continue to use the "old" implementation
+  if (hasHooks(client)) {
+    client.on('afterSendEvent', handleAfterSendEvent(replay));
+    client.on('createDsc', (dsc) => {
+      const replayId = replay.getSessionId();
+      // We do not want to set the DSC when in buffer mode, as that means the replay has not been sent (yet)
+      if (replayId && replay.isEnabled() && replay.recordingMode === 'session') {
+        dsc.replay_id = replayId;
+      }
+    });
+
+    client.on('startTransaction', transaction => {
+      replay.lastTransaction = transaction;
+    });
+
+    // We may be missing the initial startTransaction due to timing issues,
+    // so we capture it on finish again.
+    client.on('finishTransaction', transaction => {
+      replay.lastTransaction = transaction;
+    });
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function hasHooks(client) {
+  return !!(client && client.on);
+}
+
+/**
+ * Create a "span" for the total amount of memory being used by JS objects
+ * (including v8 internal objects).
+ */
+async function addMemoryEntry(replay) {
+  // window.performance.memory is a non-standard API and doesn't work on all browsers, so we try-catch this
+  try {
+    return Promise.all(
+      createPerformanceSpans(replay, [
+        // @ts-expect-error memory doesn't exist on type Performance as the API is non-standard (we check that it exists above)
+        createMemoryEntry(WINDOW.performance.memory),
+      ]),
+    );
+  } catch (error) {
+    // Do nothing
+    return [];
+  }
+}
+
+function createMemoryEntry(memoryEntry) {
+  const { jsHeapSizeLimit, totalJSHeapSize, usedJSHeapSize } = memoryEntry;
+  // we don't want to use `getAbsoluteTime` because it adds the event time to the
+  // time origin, so we get the current timestamp instead
+  const time = Date.now() / 1000;
+  return {
+    type: 'memory',
+    name: 'memory',
+    start: time,
+    end: time,
+    data: {
+      memory: {
+        jsHeapSizeLimit,
+        totalJSHeapSize,
+        usedJSHeapSize,
+      },
+    },
+  };
+}
+
+// Map entryType -> function to normalize data for event
+const ENTRY_TYPES
+
+ = {
+  // @ts-expect-error TODO: entry type does not fit the create* functions entry type
+  resource: createResourceEntry,
+  paint: createPaintEntry,
+  // @ts-expect-error TODO: entry type does not fit the create* functions entry type
+  navigation: createNavigationEntry,
+  // @ts-expect-error TODO: entry type does not fit the create* functions entry type
+  ['largest-contentful-paint']: createLargestContentfulPaint,
+};
+
+/**
+ * Create replay performance entries from the browser performance entries.
+ */
+function createPerformanceEntries(
+  entries,
+) {
+  return entries.map(createPerformanceEntry).filter(Boolean) ;
+}
+
+function createPerformanceEntry(entry) {
+  if (ENTRY_TYPES[entry.entryType] === undefined) {
+    return null;
+  }
+
+  return ENTRY_TYPES[entry.entryType](entry);
+}
+
+function getAbsoluteTime(time) {
+  // browserPerformanceTimeOrigin can be undefined if `performance` or
+  // `performance.now` doesn't exist, but this is already checked by this integration
+  return ((browserPerformanceTimeOrigin || WINDOW.performance.timeOrigin) + time) / 1000;
+}
+
+function createPaintEntry(entry) {
+  const { duration, entryType, name, startTime } = entry;
+
+  const start = getAbsoluteTime(startTime);
+  return {
+    type: entryType,
+    name,
+    start,
+    end: start + duration,
+    data: undefined,
+  };
+}
+
+function createNavigationEntry(entry) {
+  const {
+    entryType,
+    name,
+    decodedBodySize,
+    duration,
+    domComplete,
+    encodedBodySize,
+    domContentLoadedEventStart,
+    domContentLoadedEventEnd,
+    domInteractive,
+    loadEventStart,
+    loadEventEnd,
+    redirectCount,
+    startTime,
+    transferSize,
+    type,
+  } = entry;
+
+  // Ignore entries with no duration, they do not seem to be useful and cause dupes
+  if (duration === 0) {
+    return null;
+  }
+
+  return {
+    type: `${entryType}.${type}`,
+    start: getAbsoluteTime(startTime),
+    end: getAbsoluteTime(domComplete),
+    name,
+    data: {
+      size: transferSize,
+      decodedBodySize,
+      encodedBodySize,
+      duration,
+      domInteractive,
+      domContentLoadedEventStart,
+      domContentLoadedEventEnd,
+      loadEventStart,
+      loadEventEnd,
+      domComplete,
+      redirectCount,
+    },
+  };
+}
+
+function createResourceEntry(
+  entry,
+) {
+  const {
+    entryType,
+    initiatorType,
+    name,
+    responseEnd,
+    startTime,
+    decodedBodySize,
+    encodedBodySize,
+    responseStatus,
+    transferSize,
+  } = entry;
+
+  // Core SDK handles these
+  if (['fetch', 'xmlhttprequest'].includes(initiatorType)) {
+    return null;
+  }
+
+  return {
+    type: `${entryType}.${initiatorType}`,
+    start: getAbsoluteTime(startTime),
+    end: getAbsoluteTime(responseEnd),
+    name,
+    data: {
+      size: transferSize,
+      statusCode: responseStatus,
+      decodedBodySize,
+      encodedBodySize,
+    },
+  };
+}
+
+function createLargestContentfulPaint(
+  entry,
+) {
+  const { entryType, startTime, size } = entry;
+
+  let startTimeOrNavigationActivation = 0;
+
+  if (WINDOW.performance) {
+    const navEntry = WINDOW.performance.getEntriesByType('navigation')[0]
+
+;
+
+    // See https://github.com/GoogleChrome/web-vitals/blob/9f11c4c6578fb4c5ee6fa4e32b9d1d756475f135/src/lib/getActivationStart.ts#L21
+    startTimeOrNavigationActivation = (navEntry && navEntry.activationStart) || 0;
+  }
+
+  // value is in ms
+  const value = Math.max(startTime - startTimeOrNavigationActivation, 0);
+  // LCP doesn't have a "duration", it just happens at a single point in time.
+  // But the UI expects both, so use end (in seconds) for both timestamps.
+  const end = getAbsoluteTime(startTimeOrNavigationActivation) + value / 1000;
+
+  return {
+    type: entryType,
+    name: entryType,
+    start: end,
+    end,
+    data: {
+      value, // LCP "duration" in ms
+      size,
+      // Not sure why this errors, Node should be correct (Argument of type 'Node' is not assignable to parameter of type 'INode')
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      nodeId: record.mirror.getId(entry.element ),
+    },
+  };
+}
+
+/**
+ * Heavily simplified debounce function based on lodash.debounce.
+ *
+ * This function takes a callback function (@param fun) and delays its invocation
+ * by @param wait milliseconds. Optionally, a maxWait can be specified in @param options,
+ * which ensures that the callback is invoked at least once after the specified max. wait time.
+ *
+ * @param func the function whose invocation is to be debounced
+ * @param wait the minimum time until the function is invoked after it was called once
+ * @param options the options object, which can contain the `maxWait` property
+ *
+ * @returns the debounced version of the function, which needs to be called at least once to start the
+ *          debouncing process. Subsequent calls will reset the debouncing timer and, in case @paramfunc
+ *          was already invoked in the meantime, return @param func's return value.
+ *          The debounced function has two additional properties:
+ *          - `flush`: Invokes the debounced function immediately and returns its return value
+ *          - `cancel`: Cancels the debouncing process and resets the debouncing timer
+ */
+function debounce(func, wait, options) {
+  let callbackReturnValue;
+
+  let timerId;
+  let maxTimerId;
+
+  const maxWait = options && options.maxWait ? Math.max(options.maxWait, wait) : 0;
+
+  function invokeFunc() {
+    cancelTimers();
+    callbackReturnValue = func();
+    return callbackReturnValue;
+  }
+
+  function cancelTimers() {
+    timerId !== undefined && clearTimeout(timerId);
+    maxTimerId !== undefined && clearTimeout(maxTimerId);
+    timerId = maxTimerId = undefined;
+  }
+
+  function flush() {
+    if (timerId !== undefined || maxTimerId !== undefined) {
+      return invokeFunc();
+    }
+    return callbackReturnValue;
+  }
+
+  function debounced() {
+    if (timerId) {
+      clearTimeout(timerId);
+    }
+    timerId = setTimeout(invokeFunc, wait);
+
+    if (maxWait && maxTimerId === undefined) {
+      maxTimerId = setTimeout(invokeFunc, maxWait);
+    }
+
+    return callbackReturnValue;
+  }
+
+  debounced.cancel = cancelTimers;
+  debounced.flush = flush;
+  return debounced;
+}
+
+/**
+ * Handler for recording events.
+ *
+ * Adds to event buffer, and has varying flushing behaviors if the event was a checkout.
+ */
+function getHandleRecordingEmit(replay) {
+  let hadFirstEvent = false;
+
+  return (event, _isCheckout) => {
+    // If this is false, it means session is expired, create and a new session and wait for checkout
+    if (!replay.checkAndHandleExpiredSession()) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('[Replay] Received replay event after session expired.');
+
+      return;
+    }
+
+    // `_isCheckout` is only set when the checkout is due to `checkoutEveryNms`
+    // We also want to treat the first event as a checkout, so we handle this specifically here
+    const isCheckout = _isCheckout || !hadFirstEvent;
+    hadFirstEvent = true;
+
+    // The handler returns `true` if we do not want to trigger debounced flush, `false` if we want to debounce flush.
+    replay.addUpdate(() => {
+      // The session is always started immediately on pageload/init, but for
+      // error-only replays, it should reflect the most recent checkout
+      // when an error occurs. Clear any state that happens before this current
+      // checkout. This needs to happen before `addEvent()` which updates state
+      // dependent on this reset.
+      if (replay.recordingMode === 'buffer' && isCheckout) {
+        replay.setInitialState();
+      }
+
+      // If the event is not added (e.g. due to being paused, disabled, or out of the max replay duration),
+      // Skip all further steps
+      if (!addEventSync(replay, event, isCheckout)) {
+        // Return true to skip scheduling a debounced flush
+        return true;
+      }
+
+      // Different behavior for full snapshots (type=2), ignore other event types
+      // See https://github.com/rrweb-io/rrweb/blob/d8f9290ca496712aa1e7d472549480c4e7876594/packages/rrweb/src/types.ts#L16
+      if (!isCheckout) {
+        return false;
+      }
+
+      // Additionally, create a meta event that will capture certain SDK settings.
+      // In order to handle buffer mode, this needs to either be done when we
+      // receive checkout events or at flush time.
+      //
+      // `isCheckout` is always true, but want to be explicit that it should
+      // only be added for checkouts
+      addSettingsEvent(replay, isCheckout);
+
+      // If there is a previousSessionId after a full snapshot occurs, then
+      // the replay session was started due to session expiration. The new session
+      // is started before triggering a new checkout and contains the id
+      // of the previous session. Do not immediately flush in this case
+      // to avoid capturing only the checkout and instead the replay will
+      // be captured if they perform any follow-up actions.
+      if (replay.session && replay.session.previousSessionId) {
+        return true;
+      }
+
+      // When in buffer mode, make sure we adjust the session started date to the current earliest event of the buffer
+      // this should usually be the timestamp of the checkout event, but to be safe...
+      if (replay.recordingMode === 'buffer' && replay.session && replay.eventBuffer) {
+        const earliestEvent = replay.eventBuffer.getEarliestTimestamp();
+        if (earliestEvent) {
+          logInfo(
+            `[Replay] Updating session start time to earliest event in buffer to ${new Date(earliestEvent)}`,
+            replay.getOptions()._experiments.traceInternals,
+          );
+
+          replay.session.started = earliestEvent;
+
+          if (replay.getOptions().stickySession) {
+            saveSession(replay.session);
+          }
+        }
+      }
+
+      if (replay.recordingMode === 'session') {
+        // If the full snapshot is due to an initial load, we will not have
+        // a previous session ID. In this case, we want to buffer events
+        // for a set amount of time before flushing. This can help avoid
+        // capturing replays of users that immediately close the window.
+        void replay.flush();
+      }
+
+      return true;
+    });
+  };
+}
+
+/**
+ * Exported for tests
+ */
+function createOptionsEvent(replay) {
+  const options = replay.getOptions();
+  return {
+    type: EventType.Custom,
+    timestamp: Date.now(),
+    data: {
+      tag: 'options',
+      payload: {
+        sessionSampleRate: options.sessionSampleRate,
+        errorSampleRate: options.errorSampleRate,
+        useCompressionOption: options.useCompression,
+        blockAllMedia: options.blockAllMedia,
+        maskAllText: options.maskAllText,
+        maskAllInputs: options.maskAllInputs,
+        useCompression: replay.eventBuffer ? replay.eventBuffer.type === 'worker' : false,
+        networkDetailHasUrls: options.networkDetailAllowUrls.length > 0,
+        networkCaptureBodies: options.networkCaptureBodies,
+        networkRequestHasHeaders: options.networkRequestHeaders.length > 0,
+        networkResponseHasHeaders: options.networkResponseHeaders.length > 0,
+      },
+    },
+  };
+}
+
+/**
+ * Add a "meta" event that contains a simplified view on current configuration
+ * options. This should only be included on the first segment of a recording.
+ */
+function addSettingsEvent(replay, isCheckout) {
+  // Only need to add this event when sending the first segment
+  if (!isCheckout || !replay.session || replay.session.segmentId !== 0) {
+    return;
+  }
+
+  addEventSync(replay, createOptionsEvent(replay), false);
+}
+
+/**
+ * Create a replay envelope ready to be sent.
+ * This includes both the replay event, as well as the recording data.
+ */
+function createReplayEnvelope(
+  replayEvent,
+  recordingData,
+  dsn,
+  tunnel,
+) {
+  return createEnvelope(
+    createEventEnvelopeHeaders(replayEvent, getSdkMetadataForEnvelopeHeader(replayEvent), tunnel, dsn),
+    [
+      [{ type: 'replay_event' }, replayEvent],
+      [
+        {
+          type: 'replay_recording',
+          // If string then we need to encode to UTF8, otherwise will have
+          // wrong size. TextEncoder has similar browser support to
+          // MutationObserver, although it does not accept IE11.
+          length:
+            typeof recordingData === 'string' ? new TextEncoder().encode(recordingData).length : recordingData.length,
+        },
+        recordingData,
+      ],
+    ],
+  );
+}
+
+/**
+ * Prepare the recording data ready to be sent.
+ */
+function prepareRecordingData({
+  recordingData,
+  headers,
+}
+
+) {
+  let payloadWithSequence;
+
+  // XXX: newline is needed to separate sequence id from events
+  const replayHeaders = `${JSON.stringify(headers)}
+`;
+
+  if (typeof recordingData === 'string') {
+    payloadWithSequence = `${replayHeaders}${recordingData}`;
+  } else {
+    const enc = new TextEncoder();
+    // XXX: newline is needed to separate sequence id from events
+    const sequence = enc.encode(replayHeaders);
+    // Merge the two Uint8Arrays
+    payloadWithSequence = new Uint8Array(sequence.length + recordingData.length);
+    payloadWithSequence.set(sequence);
+    payloadWithSequence.set(recordingData, sequence.length);
+  }
+
+  return payloadWithSequence;
+}
+
+/**
+ * Prepare a replay event & enrich it with the SDK metadata.
+ */
+async function prepareReplayEvent({
+  client,
+  scope,
+  replayId: event_id,
+  event,
+}
+
+) {
+  const integrations =
+    typeof client._integrations === 'object' && client._integrations !== null && !Array.isArray(client._integrations)
+      ? Object.keys(client._integrations)
+      : undefined;
+
+  const eventHint = { event_id, integrations };
+
+  if (client.emit) {
+    client.emit('preprocessEvent', event, eventHint);
+  }
+
+  const preparedEvent = (await prepareEvent(
+    client.getOptions(),
+    event,
+    eventHint,
+    scope,
+    client,
+  )) ;
+
+  // If e.g. a global event processor returned null
+  if (!preparedEvent) {
+    return null;
+  }
+
+  // This normally happens in browser client "_prepareEvent"
+  // but since we do not use this private method from the client, but rather the plain import
+  // we need to do this manually.
+  preparedEvent.platform = preparedEvent.platform || 'javascript';
+
+  // extract the SDK name because `client._prepareEvent` doesn't add it to the event
+  const metadata = client.getSdkMetadata && client.getSdkMetadata();
+  const { name, version } = (metadata && metadata.sdk) || {};
+
+  preparedEvent.sdk = {
+    ...preparedEvent.sdk,
+    name: name || 'sentry.javascript.unknown',
+    version: version || '0.0.0',
+  };
+
+  return preparedEvent;
+}
+
+/**
+ * Send replay attachment using `fetch()`
+ */
+async function sendReplayRequest({
+  recordingData,
+  replayId,
+  segmentId: segment_id,
+  eventContext,
+  timestamp,
+  session,
+}) {
+  const preparedRecordingData = prepareRecordingData({
+    recordingData,
+    headers: {
+      segment_id,
+    },
+  });
+
+  const { urls, errorIds, traceIds, initialTimestamp } = eventContext;
+
+  const hub = getCurrentHub();
+  const client = hub.getClient();
+  const scope = hub.getScope();
+  const transport = client && client.getTransport();
+  const dsn = client && client.getDsn();
+
+  if (!client || !transport || !dsn || !session.sampled) {
+    return;
+  }
+
+  const baseEvent = {
+    type: REPLAY_EVENT_NAME,
+    replay_start_timestamp: initialTimestamp / 1000,
+    timestamp: timestamp / 1000,
+    error_ids: errorIds,
+    trace_ids: traceIds,
+    urls,
+    replay_id: replayId,
+    segment_id,
+    replay_type: session.sampled,
+  };
+
+  const replayEvent = await prepareReplayEvent({ scope, client, replayId, event: baseEvent });
+
+  if (!replayEvent) {
+    // Taken from baseclient's `_processEvent` method, where this is handled for errors/transactions
+    client.recordDroppedEvent('event_processor', 'replay', baseEvent);
+    logInfo('An event processor returned `null`, will not send event.');
+    return;
+  }
+
+  /*
+  For reference, the fully built event looks something like this:
+  {
+      "type": "replay_event",
+      "timestamp": 1670837008.634,
+      "error_ids": [
+          "errorId"
+      ],
+      "trace_ids": [
+          "traceId"
+      ],
+      "urls": [
+          "https://example.com"
+      ],
+      "replay_id": "eventId",
+      "segment_id": 3,
+      "replay_type": "error",
+      "platform": "javascript",
+      "event_id": "eventId",
+      "environment": "production",
+      "sdk": {
+          "integrations": [
+              "BrowserTracing",
+              "Replay"
+          ],
+          "name": "sentry.javascript.browser",
+          "version": "7.25.0"
+      },
+      "sdkProcessingMetadata": {},
+      "contexts": {
+      },
+  }
+  */
+
+  // Prevent this data (which, if it exists, was used in earlier steps in the processing pipeline) from being sent to
+  // sentry. (Note: Our use of this property comes and goes with whatever we might be debugging, whatever hacks we may
+  // have temporarily added, etc. Even if we don't happen to be using it at some point in the future, let's not get rid
+  // of this `delete`, lest we miss putting it back in the next time the property is in use.)
+  delete replayEvent.sdkProcessingMetadata;
+
+  const envelope = createReplayEnvelope(replayEvent, preparedRecordingData, dsn, client.getOptions().tunnel);
+
+  let response;
+
+  try {
+    response = await transport.send(envelope);
+  } catch (err) {
+    const error = new Error(UNABLE_TO_SEND_REPLAY);
+
+    try {
+      // In case browsers don't allow this property to be writable
+      // @ts-expect-error This needs lib es2022 and newer
+      error.cause = err;
+    } catch (e) {
+      // nothing to do
+    }
+    throw error;
+  }
+
+  // TODO (v8): we can remove this guard once transport.send's type signature doesn't include void anymore
+  if (!response) {
+    return response;
+  }
+
+  // If the status code is invalid, we want to immediately stop & not retry
+  if (typeof response.statusCode === 'number' && (response.statusCode < 200 || response.statusCode >= 300)) {
+    throw new TransportStatusCodeError(response.statusCode);
+  }
+
+  return response;
+}
+
+/**
+ * This error indicates that the transport returned an invalid status code.
+ */
+class TransportStatusCodeError extends Error {
+   constructor(statusCode) {
+    super(`Transport returned status code ${statusCode}`);
+  }
+}
+
+/**
+ * Finalize and send the current replay event to Sentry
+ */
+async function sendReplay(
+  replayData,
+  retryConfig = {
+    count: 0,
+    interval: RETRY_BASE_INTERVAL,
+  },
+) {
+  const { recordingData, options } = replayData;
+
+  // short circuit if there's no events to upload (this shouldn't happen as _runFlush makes this check)
+  if (!recordingData.length) {
+    return;
+  }
+
+  try {
+    await sendReplayRequest(replayData);
+    return true;
+  } catch (err) {
+    if (err instanceof TransportStatusCodeError) {
+      throw err;
+    }
+
+    // Capture error for every failed replay
+    setContext('Replays', {
+      _retryCount: retryConfig.count,
+    });
+
+    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && options._experiments && options._experiments.captureExceptions) {
+      captureException(err);
+    }
+
+    // If an error happened here, it's likely that uploading the attachment
+    // failed, we'll can retry with the same events payload
+    if (retryConfig.count >= RETRY_MAX_COUNT) {
+      const error = new Error(`${UNABLE_TO_SEND_REPLAY} - max retries exceeded`);
+
+      try {
+        // In case browsers don't allow this property to be writable
+        // @ts-expect-error This needs lib es2022 and newer
+        error.cause = err;
+      } catch (e) {
+        // nothing to do
+      }
+
+      throw error;
+    }
+
+    // will retry in intervals of 5, 10, 30
+    retryConfig.interval *= ++retryConfig.count;
+
+    return new Promise((resolve, reject) => {
+      setTimeout(async () => {
+        try {
+          await sendReplay(replayData, retryConfig);
+          resolve(true);
+        } catch (err) {
+          reject(err);
+        }
+      }, retryConfig.interval);
+    });
+  }
+}
+
+const THROTTLED = '__THROTTLED';
+const SKIPPED = '__SKIPPED';
+
+/**
+ * Create a throttled function off a given function.
+ * When calling the throttled function, it will call the original function only
+ * if it hasn't been called more than `maxCount` times in the last `durationSeconds`.
+ *
+ * Returns `THROTTLED` if throttled for the first time, after that `SKIPPED`,
+ * or else the return value of the original function.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function throttle(
+  fn,
+  maxCount,
+  durationSeconds,
+) {
+  const counter = new Map();
+
+  const _cleanup = (now) => {
+    const threshold = now - durationSeconds;
+    counter.forEach((_value, key) => {
+      if (key < threshold) {
+        counter.delete(key);
+      }
+    });
+  };
+
+  const _getTotalCount = () => {
+    return [...counter.values()].reduce((a, b) => a + b, 0);
+  };
+
+  let isThrottled = false;
+
+  return (...rest) => {
+    // Date in second-precision, which we use as basis for the throttling
+    const now = Math.floor(Date.now() / 1000);
+
+    // First, make sure to delete any old entries
+    _cleanup(now);
+
+    // If already over limit, do nothing
+    if (_getTotalCount() >= maxCount) {
+      const wasThrottled = isThrottled;
+      isThrottled = true;
+      return wasThrottled ? SKIPPED : THROTTLED;
+    }
+
+    isThrottled = false;
+    const count = counter.get(now) || 0;
+    counter.set(now, count + 1);
+
+    return fn(...rest);
+  };
+}
+
+/* eslint-disable max-lines */ // TODO: We might want to split this file up
+
+/**
+ * The main replay container class, which holds all the state and methods for recording and sending replays.
+ */
+class ReplayContainer  {
+
+  /**
+   * List of PerformanceEntry from PerformanceObserver
+   */
+
+  /**
+   * Recording can happen in one of three modes:
+   *   - session: Record the whole session, sending it continuously
+   *   - buffer: Always keep the last 60s of recording, requires:
+   *     - having replaysOnErrorSampleRate > 0 to capture replay when an error occurs
+   *     - or calling `flush()` to send the replay
+   */
+
+  /**
+   * The current or last active transcation.
+   * This is only available when performance is enabled.
+   */
+
+  /**
+   * These are here so we can overwrite them in tests etc.
+   * @hidden
+   */
+
+  /**
+   * Options to pass to `rrweb.record()`
+   */
+
+  /**
+   * Timestamp of the last user activity. This lives across sessions.
+   */
+
+  /**
+   * Is the integration currently active?
+   */
+
+  /**
+   * Paused is a state where:
+   * - DOM Recording is not listening at all
+   * - Nothing will be added to event buffer (e.g. core SDK events)
+   */
+
+  /**
+   * Have we attached listeners to the core SDK?
+   * Note we have to track this as there is no way to remove instrumentation handlers.
+   */
+
+  /**
+   * Function to stop recording
+   */
+
+   constructor({
+    options,
+    recordingOptions,
+  }
+
+) {ReplayContainer.prototype.__init.call(this);ReplayContainer.prototype.__init2.call(this);ReplayContainer.prototype.__init3.call(this);ReplayContainer.prototype.__init4.call(this);ReplayContainer.prototype.__init5.call(this);ReplayContainer.prototype.__init6.call(this);
+    this.eventBuffer = null;
+    this.performanceEvents = [];
+    this.recordingMode = 'session';
+    this.timeouts = {
+      sessionIdlePause: SESSION_IDLE_PAUSE_DURATION,
+      sessionIdleExpire: SESSION_IDLE_EXPIRE_DURATION,
+    } ;
+    this._lastActivity = Date.now();
+    this._isEnabled = false;
+    this._isPaused = false;
+    this._hasInitializedCoreListeners = false;
+    this._context = {
+      errorIds: new Set(),
+      traceIds: new Set(),
+      urls: [],
+      initialTimestamp: Date.now(),
+      initialUrl: '',
+    };
+
+    this._recordingOptions = recordingOptions;
+    this._options = options;
+
+    this._debouncedFlush = debounce(() => this._flush(), this._options.flushMinDelay, {
+      maxWait: this._options.flushMaxDelay,
+    });
+
+    this._throttledAddEvent = throttle(
+      (event, isCheckout) => addEvent(this, event, isCheckout),
+      // Max 300 events...
+      300,
+      // ... per 5s
+      5,
+    );
+
+    const { slowClickTimeout, slowClickIgnoreSelectors } = this.getOptions();
+
+    const slowClickConfig = slowClickTimeout
+      ? {
+          threshold: Math.min(SLOW_CLICK_THRESHOLD, slowClickTimeout),
+          timeout: slowClickTimeout,
+          scrollTimeout: SLOW_CLICK_SCROLL_TIMEOUT,
+          ignoreSelector: slowClickIgnoreSelectors ? slowClickIgnoreSelectors.join(',') : '',
+        }
+      : undefined;
+
+    if (slowClickConfig) {
+      this.clickDetector = new ClickDetector(this, slowClickConfig);
+    }
+  }
+
+  /** Get the event context. */
+   getContext() {
+    return this._context;
+  }
+
+  /** If recording is currently enabled. */
+   isEnabled() {
+    return this._isEnabled;
+  }
+
+  /** If recording is currently paused. */
+   isPaused() {
+    return this._isPaused;
+  }
+
+  /** Get the replay integration options. */
+   getOptions() {
+    return this._options;
+  }
+
+  /**
+   * Initializes the plugin based on sampling configuration. Should not be
+   * called outside of constructor.
+   */
+   initializeSampling(previousSessionId) {
+    const { errorSampleRate, sessionSampleRate } = this._options;
+
+    // If neither sample rate is > 0, then do nothing - user will need to call one of
+    // `start()` or `startBuffering` themselves.
+    if (errorSampleRate <= 0 && sessionSampleRate <= 0) {
+      return;
+    }
+
+    // Otherwise if there is _any_ sample rate set, try to load an existing
+    // session, or create a new one.
+    this._initializeSessionForSampling(previousSessionId);
+
+    if (!this.session) {
+      // This should not happen, something wrong has occurred
+      this._handleException(new Error('Unable to initialize and create session'));
+      return;
+    }
+
+    if (this.session.sampled === false) {
+      // This should only occur if `errorSampleRate` is 0 and was unsampled for
+      // session-based replay. In this case there is nothing to do.
+      return;
+    }
+
+    // If segmentId > 0, it means we've previously already captured this session
+    // In this case, we still want to continue in `session` recording mode
+    this.recordingMode = this.session.sampled === 'buffer' && this.session.segmentId === 0 ? 'buffer' : 'session';
+
+    logInfoNextTick(
+      `[Replay] Starting replay in ${this.recordingMode} mode`,
+      this._options._experiments.traceInternals,
+    );
+
+    this._initializeRecording();
+  }
+
+  /**
+   * Start a replay regardless of sampling rate. Calling this will always
+   * create a new session. Will throw an error if replay is already in progress.
+   *
+   * Creates or loads a session, attaches listeners to varying events (DOM,
+   * _performanceObserver, Recording, Sentry SDK, etc)
+   */
+   start() {
+    if (this._isEnabled && this.recordingMode === 'session') {
+      throw new Error('Replay recording is already in progress');
+    }
+
+    if (this._isEnabled && this.recordingMode === 'buffer') {
+      throw new Error('Replay buffering is in progress, call `flush()` to save the replay');
+    }
+
+    logInfoNextTick('[Replay] Starting replay in session mode', this._options._experiments.traceInternals);
+
+    const session = loadOrCreateSession(
+      {
+        maxReplayDuration: this._options.maxReplayDuration,
+        sessionIdleExpire: this.timeouts.sessionIdleExpire,
+        traceInternals: this._options._experiments.traceInternals,
+      },
+      {
+        stickySession: this._options.stickySession,
+        // This is intentional: create a new session-based replay when calling `start()`
+        sessionSampleRate: 1,
+        allowBuffering: false,
+      },
+    );
+
+    this.session = session;
+
+    this._initializeRecording();
+  }
+
+  /**
+   * Start replay buffering. Buffers until `flush()` is called or, if
+   * `replaysOnErrorSampleRate` > 0, an error occurs.
+   */
+   startBuffering() {
+    if (this._isEnabled) {
+      throw new Error('Replay recording is already in progress');
+    }
+
+    logInfoNextTick('[Replay] Starting replay in buffer mode', this._options._experiments.traceInternals);
+
+    const session = loadOrCreateSession(
+      {
+        sessionIdleExpire: this.timeouts.sessionIdleExpire,
+        maxReplayDuration: this._options.maxReplayDuration,
+        traceInternals: this._options._experiments.traceInternals,
+      },
+      {
+        stickySession: this._options.stickySession,
+        sessionSampleRate: 0,
+        allowBuffering: true,
+      },
+    );
+
+    this.session = session;
+
+    this.recordingMode = 'buffer';
+    this._initializeRecording();
+  }
+
+  /**
+   * Start recording.
+   *
+   * Note that this will cause a new DOM checkout
+   */
+   startRecording() {
+    try {
+      this._stopRecording = record({
+        ...this._recordingOptions,
+        // When running in error sampling mode, we need to overwrite `checkoutEveryNms`
+        // Without this, it would record forever, until an error happens, which we don't want
+        // instead, we'll always keep the last 60 seconds of replay before an error happened
+        ...(this.recordingMode === 'buffer' && { checkoutEveryNms: BUFFER_CHECKOUT_TIME }),
+        emit: getHandleRecordingEmit(this),
+        onMutation: this._onMutationHandler,
+      });
+    } catch (err) {
+      this._handleException(err);
+    }
+  }
+
+  /**
+   * Stops the recording, if it was running.
+   *
+   * Returns true if it was previously stopped, or is now stopped,
+   * otherwise false.
+   */
+   stopRecording() {
+    try {
+      if (this._stopRecording) {
+        this._stopRecording();
+        this._stopRecording = undefined;
+      }
+
+      return true;
+    } catch (err) {
+      this._handleException(err);
+      return false;
+    }
+  }
+
+  /**
+   * Currently, this needs to be manually called (e.g. for tests). Sentry SDK
+   * does not support a teardown
+   */
+   async stop({ forceFlush = false, reason } = {}) {
+    if (!this._isEnabled) {
+      return;
+    }
+
+    // We can't move `_isEnabled` after awaiting a flush, otherwise we can
+    // enter into an infinite loop when `stop()` is called while flushing.
+    this._isEnabled = false;
+
+    try {
+      logInfo(
+        `[Replay] Stopping Replay${reason ? ` triggered by ${reason}` : ''}`,
+        this._options._experiments.traceInternals,
+      );
+
+      this._removeListeners();
+      this.stopRecording();
+
+      this._debouncedFlush.cancel();
+      // See comment above re: `_isEnabled`, we "force" a flush, ignoring the
+      // `_isEnabled` state of the plugin since it was disabled above.
+      if (forceFlush) {
+        await this._flush({ force: true });
+      }
+
+      // After flush, destroy event buffer
+      this.eventBuffer && this.eventBuffer.destroy();
+      this.eventBuffer = null;
+
+      // Clear session from session storage, note this means if a new session
+      // is started after, it will not have `previousSessionId`
+      clearSession(this);
+    } catch (err) {
+      this._handleException(err);
+    }
+  }
+
+  /**
+   * Pause some replay functionality. See comments for `_isPaused`.
+   * This differs from stop as this only stops DOM recording, it is
+   * not as thorough of a shutdown as `stop()`.
+   */
+   pause() {
+    if (this._isPaused) {
+      return;
+    }
+
+    this._isPaused = true;
+    this.stopRecording();
+
+    logInfo('[Replay] Pausing replay', this._options._experiments.traceInternals);
+  }
+
+  /**
+   * Resumes recording, see notes for `pause().
+   *
+   * Note that calling `startRecording()` here will cause a
+   * new DOM checkout.`
+   */
+   resume() {
+    if (!this._isPaused || !this._checkSession()) {
+      return;
+    }
+
+    this._isPaused = false;
+    this.startRecording();
+
+    logInfo('[Replay] Resuming replay', this._options._experiments.traceInternals);
+  }
+
+  /**
+   * If not in "session" recording mode, flush event buffer which will create a new replay.
+   * Unless `continueRecording` is false, the replay will continue to record and
+   * behave as a "session"-based replay.
+   *
+   * Otherwise, queue up a flush.
+   */
+   async sendBufferedReplayOrFlush({ continueRecording = true } = {}) {
+    if (this.recordingMode === 'session') {
+      return this.flushImmediate();
+    }
+
+    const activityTime = Date.now();
+
+    logInfo('[Replay] Converting buffer to session', this._options._experiments.traceInternals);
+
+    // Allow flush to complete before resuming as a session recording, otherwise
+    // the checkout from `startRecording` may be included in the payload.
+    // Prefer to keep the error replay as a separate (and smaller) segment
+    // than the session replay.
+    await this.flushImmediate();
+
+    const hasStoppedRecording = this.stopRecording();
+
+    if (!continueRecording || !hasStoppedRecording) {
+      return;
+    }
+
+    // To avoid race conditions where this is called multiple times, we check here again that we are still buffering
+    if ((this.recordingMode ) === 'session') {
+      return;
+    }
+
+    // Re-start recording in session-mode
+    this.recordingMode = 'session';
+
+    // Once this session ends, we do not want to refresh it
+    if (this.session) {
+      this._updateUserActivity(activityTime);
+      this._updateSessionActivity(activityTime);
+      this._maybeSaveSession();
+    }
+
+    this.startRecording();
+  }
+
+  /**
+   * We want to batch uploads of replay events. Save events only if
+   * `<flushMinDelay>` milliseconds have elapsed since the last event
+   * *OR* if `<flushMaxDelay>` milliseconds have elapsed.
+   *
+   * Accepts a callback to perform side-effects and returns true to stop batch
+   * processing and hand back control to caller.
+   */
+   addUpdate(cb) {
+    // We need to always run `cb` (e.g. in the case of `this.recordingMode == 'buffer'`)
+    const cbResult = cb();
+
+    // If this option is turned on then we will only want to call `flush`
+    // explicitly
+    if (this.recordingMode === 'buffer') {
+      return;
+    }
+
+    // If callback is true, we do not want to continue with flushing -- the
+    // caller will need to handle it.
+    if (cbResult === true) {
+      return;
+    }
+
+    // addUpdate is called quite frequently - use _debouncedFlush so that it
+    // respects the flush delays and does not flush immediately
+    this._debouncedFlush();
+  }
+
+  /**
+   * Updates the user activity timestamp and resumes recording. This should be
+   * called in an event handler for a user action that we consider as the user
+   * being "active" (e.g. a mouse click).
+   */
+   triggerUserActivity() {
+    this._updateUserActivity();
+
+    // This case means that recording was once stopped due to inactivity.
+    // Ensure that recording is resumed.
+    if (!this._stopRecording) {
+      // Create a new session, otherwise when the user action is flushed, it
+      // will get rejected due to an expired session.
+      if (!this._checkSession()) {
+        return;
+      }
+
+      // Note: This will cause a new DOM checkout
+      this.resume();
+      return;
+    }
+
+    // Otherwise... recording was never suspended, continue as normalish
+    this.checkAndHandleExpiredSession();
+
+    this._updateSessionActivity();
+  }
+
+  /**
+   * Updates the user activity timestamp *without* resuming
+   * recording. Some user events (e.g. keydown) can be create
+   * low-value replays that only contain the keypress as a
+   * breadcrumb. Instead this would require other events to
+   * create a new replay after a session has expired.
+   */
+   updateUserActivity() {
+    this._updateUserActivity();
+    this._updateSessionActivity();
+  }
+
+  /**
+   * Only flush if `this.recordingMode === 'session'`
+   */
+   conditionalFlush() {
+    if (this.recordingMode === 'buffer') {
+      return Promise.resolve();
+    }
+
+    return this.flushImmediate();
+  }
+
+  /**
+   * Flush using debounce flush
+   */
+   flush() {
+    return this._debouncedFlush() ;
+  }
+
+  /**
+   * Always flush via `_debouncedFlush` so that we do not have flushes triggered
+   * from calling both `flush` and `_debouncedFlush`. Otherwise, there could be
+   * cases of mulitple flushes happening closely together.
+   */
+   flushImmediate() {
+    this._debouncedFlush();
+    // `.flush` is provided by the debounced function, analogously to lodash.debounce
+    return this._debouncedFlush.flush() ;
+  }
+
+  /**
+   * Cancels queued up flushes.
+   */
+   cancelFlush() {
+    this._debouncedFlush.cancel();
+  }
+
+  /** Get the current sesion (=replay) ID */
+   getSessionId() {
+    return this.session && this.session.id;
+  }
+
+  /**
+   * Checks if recording should be stopped due to user inactivity. Otherwise
+   * check if session is expired and create a new session if so. Triggers a new
+   * full snapshot on new session.
+   *
+   * Returns true if session is not expired, false otherwise.
+   * @hidden
+   */
+   checkAndHandleExpiredSession() {
+    // Prevent starting a new session if the last user activity is older than
+    // SESSION_IDLE_PAUSE_DURATION. Otherwise non-user activity can trigger a new
+    // session+recording. This creates noisy replays that do not have much
+    // content in them.
+    if (
+      this._lastActivity &&
+      isExpired(this._lastActivity, this.timeouts.sessionIdlePause) &&
+      this.session &&
+      this.session.sampled === 'session'
+    ) {
+      // Pause recording only for session-based replays. Otherwise, resuming
+      // will create a new replay and will conflict with users who only choose
+      // to record error-based replays only. (e.g. the resumed replay will not
+      // contain a reference to an error)
+      this.pause();
+      return;
+    }
+
+    // --- There is recent user activity --- //
+    // This will create a new session if expired, based on expiry length
+    if (!this._checkSession()) {
+      // Check session handles the refreshing itself
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Capture some initial state that can change throughout the lifespan of the
+   * replay. This is required because otherwise they would be captured at the
+   * first flush.
+   */
+   setInitialState() {
+    const urlPath = `${WINDOW.location.pathname}${WINDOW.location.hash}${WINDOW.location.search}`;
+    const url = `${WINDOW.location.origin}${urlPath}`;
+
+    this.performanceEvents = [];
+
+    // Reset _context as well
+    this._clearContext();
+
+    this._context.initialUrl = url;
+    this._context.initialTimestamp = Date.now();
+    this._context.urls.push(url);
+  }
+
+  /**
+   * Add a breadcrumb event, that may be throttled.
+   * If it was throttled, we add a custom breadcrumb to indicate that.
+   */
+   throttledAddEvent(
+    event,
+    isCheckout,
+  ) {
+    const res = this._throttledAddEvent(event, isCheckout);
+
+    // If this is THROTTLED, it means we have throttled the event for the first time
+    // In this case, we want to add a breadcrumb indicating that something was skipped
+    if (res === THROTTLED) {
+      const breadcrumb = createBreadcrumb({
+        category: 'replay.throttled',
+      });
+
+      this.addUpdate(() => {
+        // Return `false` if the event _was_ added, as that means we schedule a flush
+        return !addEventSync(this, {
+          type: ReplayEventTypeCustom,
+          timestamp: breadcrumb.timestamp || 0,
+          data: {
+            tag: 'breadcrumb',
+            payload: breadcrumb,
+            metric: true,
+          },
+        });
+      });
+    }
+
+    return res;
+  }
+
+  /**
+   * This will get the parametrized route name of the current page.
+   * This is only available if performance is enabled, and if an instrumented router is used.
+   */
+   getCurrentRoute() {
+    const lastTransaction = this.lastTransaction || getCurrentHub().getScope().getTransaction();
+    if (!lastTransaction || !['route', 'custom'].includes(lastTransaction.metadata.source)) {
+      return undefined;
+    }
+
+    return lastTransaction.name;
+  }
+
+  /**
+   * Initialize and start all listeners to varying events (DOM,
+   * Performance Observer, Recording, Sentry SDK, etc)
+   */
+   _initializeRecording() {
+    this.setInitialState();
+
+    // this method is generally called on page load or manually - in both cases
+    // we should treat it as an activity
+    this._updateSessionActivity();
+
+    this.eventBuffer = createEventBuffer({
+      useCompression: this._options.useCompression,
+    });
+
+    this._removeListeners();
+    this._addListeners();
+
+    // Need to set as enabled before we start recording, as `record()` can trigger a flush with a new checkout
+    this._isEnabled = true;
+    this._isPaused = false;
+
+    this.startRecording();
+  }
+
+  /** A wrapper to conditionally capture exceptions. */
+   _handleException(error) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('[Replay]', error);
+
+    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && this._options._experiments && this._options._experiments.captureExceptions) {
+      captureException(error);
+    }
+  }
+
+  /**
+   * Loads (or refreshes) the current session.
+   */
+   _initializeSessionForSampling(previousSessionId) {
+    // Whenever there is _any_ error sample rate, we always allow buffering
+    // Because we decide on sampling when an error occurs, we need to buffer at all times if sampling for errors
+    const allowBuffering = this._options.errorSampleRate > 0;
+
+    const session = loadOrCreateSession(
+      {
+        sessionIdleExpire: this.timeouts.sessionIdleExpire,
+        maxReplayDuration: this._options.maxReplayDuration,
+        traceInternals: this._options._experiments.traceInternals,
+        previousSessionId,
+      },
+      {
+        stickySession: this._options.stickySession,
+        sessionSampleRate: this._options.sessionSampleRate,
+        allowBuffering,
+      },
+    );
+
+    this.session = session;
+  }
+
+  /**
+   * Checks and potentially refreshes the current session.
+   * Returns false if session is not recorded.
+   */
+   _checkSession() {
+    // If there is no session yet, we do not want to refresh anything
+    // This should generally not happen, but to be safe....
+    if (!this.session) {
+      return false;
+    }
+
+    const currentSession = this.session;
+
+    if (
+      shouldRefreshSession(currentSession, {
+        sessionIdleExpire: this.timeouts.sessionIdleExpire,
+        maxReplayDuration: this._options.maxReplayDuration,
+      })
+    ) {
+      void this._refreshSession(currentSession);
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Refresh a session with a new one.
+   * This stops the current session (without forcing a flush, as that would never work since we are expired),
+   * and then does a new sampling based on the refreshed session.
+   */
+   async _refreshSession(session) {
+    if (!this._isEnabled) {
+      return;
+    }
+    await this.stop({ reason: 'refresh session' });
+    this.initializeSampling(session.id);
+  }
+
+  /**
+   * Adds listeners to record events for the replay
+   */
+   _addListeners() {
+    try {
+      WINDOW.document.addEventListener('visibilitychange', this._handleVisibilityChange);
+      WINDOW.addEventListener('blur', this._handleWindowBlur);
+      WINDOW.addEventListener('focus', this._handleWindowFocus);
+      WINDOW.addEventListener('keydown', this._handleKeyboardEvent);
+
+      if (this.clickDetector) {
+        this.clickDetector.addListeners();
+      }
+
+      // There is no way to remove these listeners, so ensure they are only added once
+      if (!this._hasInitializedCoreListeners) {
+        addGlobalListeners(this);
+
+        this._hasInitializedCoreListeners = true;
+      }
+    } catch (err) {
+      this._handleException(err);
+    }
+
+    // PerformanceObserver //
+    if (!('PerformanceObserver' in WINDOW)) {
+      return;
+    }
+
+    this._performanceObserver = setupPerformanceObserver(this);
+  }
+
+  /**
+   * Cleans up listeners that were created in `_addListeners`
+   */
+   _removeListeners() {
+    try {
+      WINDOW.document.removeEventListener('visibilitychange', this._handleVisibilityChange);
+
+      WINDOW.removeEventListener('blur', this._handleWindowBlur);
+      WINDOW.removeEventListener('focus', this._handleWindowFocus);
+      WINDOW.removeEventListener('keydown', this._handleKeyboardEvent);
+
+      if (this.clickDetector) {
+        this.clickDetector.removeListeners();
+      }
+
+      if (this._performanceObserver) {
+        this._performanceObserver.disconnect();
+        this._performanceObserver = undefined;
+      }
+    } catch (err) {
+      this._handleException(err);
+    }
+  }
+
+  /**
+   * Handle when visibility of the page content changes. Opening a new tab will
+   * cause the state to change to hidden because of content of current page will
+   * be hidden. Likewise, moving a different window to cover the contents of the
+   * page will also trigger a change to a hidden state.
+   */
+   __init() {this._handleVisibilityChange = () => {
+    if (WINDOW.document.visibilityState === 'visible') {
+      this._doChangeToForegroundTasks();
+    } else {
+      this._doChangeToBackgroundTasks();
+    }
+  };}
+
+  /**
+   * Handle when page is blurred
+   */
+   __init2() {this._handleWindowBlur = () => {
+    const breadcrumb = createBreadcrumb({
+      category: 'ui.blur',
+    });
+
+    // Do not count blur as a user action -- it's part of the process of them
+    // leaving the page
+    this._doChangeToBackgroundTasks(breadcrumb);
+  };}
+
+  /**
+   * Handle when page is focused
+   */
+   __init3() {this._handleWindowFocus = () => {
+    const breadcrumb = createBreadcrumb({
+      category: 'ui.focus',
+    });
+
+    // Do not count focus as a user action -- instead wait until they focus and
+    // interactive with page
+    this._doChangeToForegroundTasks(breadcrumb);
+  };}
+
+  /** Ensure page remains active when a key is pressed. */
+   __init4() {this._handleKeyboardEvent = (event) => {
+    handleKeyboardEvent(this, event);
+  };}
+
+  /**
+   * Tasks to run when we consider a page to be hidden (via blurring and/or visibility)
+   */
+   _doChangeToBackgroundTasks(breadcrumb) {
+    if (!this.session) {
+      return;
+    }
+
+    const expired = isSessionExpired(this.session, {
+      maxReplayDuration: this._options.maxReplayDuration,
+      sessionIdleExpire: this.timeouts.sessionIdleExpire,
+    });
+
+    if (expired) {
+      return;
+    }
+
+    if (breadcrumb) {
+      this._createCustomBreadcrumb(breadcrumb);
+    }
+
+    // Send replay when the page/tab becomes hidden. There is no reason to send
+    // replay if it becomes visible, since no actions we care about were done
+    // while it was hidden
+    void this.conditionalFlush();
+  }
+
+  /**
+   * Tasks to run when we consider a page to be visible (via focus and/or visibility)
+   */
+   _doChangeToForegroundTasks(breadcrumb) {
+    if (!this.session) {
+      return;
+    }
+
+    const isSessionActive = this.checkAndHandleExpiredSession();
+
+    if (!isSessionActive) {
+      // If the user has come back to the page within SESSION_IDLE_PAUSE_DURATION
+      // ms, we will re-use the existing session, otherwise create a new
+      // session
+      logInfo('[Replay] Document has become active, but session has expired');
+      return;
+    }
+
+    if (breadcrumb) {
+      this._createCustomBreadcrumb(breadcrumb);
+    }
+  }
+
+  /**
+   * Trigger rrweb to take a full snapshot which will cause this plugin to
+   * create a new Replay event.
+   */
+   _triggerFullSnapshot(checkout = true) {
+    try {
+      logInfo('[Replay] Taking full rrweb snapshot');
+      record.takeFullSnapshot(checkout);
+    } catch (err) {
+      this._handleException(err);
+    }
+  }
+
+  /**
+   * Update user activity (across session lifespans)
+   */
+   _updateUserActivity(_lastActivity = Date.now()) {
+    this._lastActivity = _lastActivity;
+  }
+
+  /**
+   * Updates the session's last activity timestamp
+   */
+   _updateSessionActivity(_lastActivity = Date.now()) {
+    if (this.session) {
+      this.session.lastActivity = _lastActivity;
+      this._maybeSaveSession();
+    }
+  }
+
+  /**
+   * Helper to create (and buffer) a replay breadcrumb from a core SDK breadcrumb
+   */
+   _createCustomBreadcrumb(breadcrumb) {
+    this.addUpdate(() => {
+      void this.throttledAddEvent({
+        type: EventType.Custom,
+        timestamp: breadcrumb.timestamp || 0,
+        data: {
+          tag: 'breadcrumb',
+          payload: breadcrumb,
+        },
+      });
+    });
+  }
+
+  /**
+   * Observed performance events are added to `this.performanceEvents`. These
+   * are included in the replay event before it is finished and sent to Sentry.
+   */
+   _addPerformanceEntries() {
+    // Copy and reset entries before processing
+    const entries = [...this.performanceEvents];
+    this.performanceEvents = [];
+
+    return Promise.all(createPerformanceSpans(this, createPerformanceEntries(entries)));
+  }
+
+  /**
+   * Clear _context
+   */
+   _clearContext() {
+    // XXX: `initialTimestamp` and `initialUrl` do not get cleared
+    this._context.errorIds.clear();
+    this._context.traceIds.clear();
+    this._context.urls = [];
+  }
+
+  /** Update the initial timestamp based on the buffer content. */
+   _updateInitialTimestampFromEventBuffer() {
+    const { session, eventBuffer } = this;
+    if (!session || !eventBuffer) {
+      return;
+    }
+
+    // we only ever update this on the initial segment
+    if (session.segmentId) {
+      return;
+    }
+
+    const earliestEvent = eventBuffer.getEarliestTimestamp();
+    if (earliestEvent && earliestEvent < this._context.initialTimestamp) {
+      this._context.initialTimestamp = earliestEvent;
+    }
+  }
+
+  /**
+   * Return and clear _context
+   */
+   _popEventContext() {
+    const _context = {
+      initialTimestamp: this._context.initialTimestamp,
+      initialUrl: this._context.initialUrl,
+      errorIds: Array.from(this._context.errorIds),
+      traceIds: Array.from(this._context.traceIds),
+      urls: this._context.urls,
+    };
+
+    this._clearContext();
+
+    return _context;
+  }
+
+  /**
+   * Flushes replay event buffer to Sentry.
+   *
+   * Performance events are only added right before flushing - this is
+   * due to the buffered performance observer events.
+   *
+   * Should never be called directly, only by `flush`
+   */
+   async _runFlush() {
+    const replayId = this.getSessionId();
+
+    if (!this.session || !this.eventBuffer || !replayId) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('[Replay] No session or eventBuffer found to flush.');
+      return;
+    }
+
+    await this._addPerformanceEntries();
+
+    // Check eventBuffer again, as it could have been stopped in the meanwhile
+    if (!this.eventBuffer || !this.eventBuffer.hasEvents) {
+      return;
+    }
+
+    // Only attach memory event if eventBuffer is not empty
+    await addMemoryEntry(this);
+
+    // Check eventBuffer again, as it could have been stopped in the meanwhile
+    if (!this.eventBuffer) {
+      return;
+    }
+
+    // if this changed in the meanwhile, e.g. because the session was refreshed or similar, we abort here
+    if (replayId !== this.getSessionId()) {
+      return;
+    }
+
+    try {
+      // This uses the data from the eventBuffer, so we need to call this before `finish()
+      this._updateInitialTimestampFromEventBuffer();
+
+      const timestamp = Date.now();
+
+      // Check total duration again, to avoid sending outdated stuff
+      // We leave 30s wiggle room to accomodate late flushing etc.
+      // This _could_ happen when the browser is suspended during flushing, in which case we just want to stop
+      if (timestamp - this._context.initialTimestamp > this._options.maxReplayDuration + 30000) {
+        throw new Error('Session is too long, not sending replay');
+      }
+
+      const eventContext = this._popEventContext();
+      // Always increment segmentId regardless of outcome of sending replay
+      const segmentId = this.session.segmentId++;
+      this._maybeSaveSession();
+
+      // Note this empties the event buffer regardless of outcome of sending replay
+      const recordingData = await this.eventBuffer.finish();
+
+      await sendReplay({
+        replayId,
+        recordingData,
+        segmentId,
+        eventContext,
+        session: this.session,
+        options: this.getOptions(),
+        timestamp,
+      });
+    } catch (err) {
+      this._handleException(err);
+
+      // This means we retried 3 times and all of them failed,
+      // or we ran into a problem we don't want to retry, like rate limiting.
+      // In this case, we want to completely stop the replay - otherwise, we may get inconsistent segments
+      void this.stop({ reason: 'sendReplay' });
+
+      const client = getCurrentHub().getClient();
+
+      if (client) {
+        client.recordDroppedEvent('send_error', 'replay');
+      }
+    }
+  }
+
+  /**
+   * Flush recording data to Sentry. Creates a lock so that only a single flush
+   * can be active at a time. Do not call this directly.
+   */
+   __init5() {this._flush = async ({
+    force = false,
+  }
+
+ = {}) => {
+    if (!this._isEnabled && !force) {
+      // This can happen if e.g. the replay was stopped because of exceeding the retry limit
+      return;
+    }
+
+    if (!this.checkAndHandleExpiredSession()) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('[Replay] Attempting to finish replay event after session expired.');
+      return;
+    }
+
+    if (!this.session) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('[Replay] No session found to flush.');
+      return;
+    }
+
+    const start = this.session.started;
+    const now = Date.now();
+    const duration = now - start;
+
+    // A flush is about to happen, cancel any queued flushes
+    this._debouncedFlush.cancel();
+
+    // If session is too short, or too long (allow some wiggle room over maxReplayDuration), do not send it
+    // This _should_ not happen, but it may happen if flush is triggered due to a page activity change or similar
+    const tooShort = duration < this._options.minReplayDuration;
+    const tooLong = duration > this._options.maxReplayDuration + 5000;
+    if (tooShort || tooLong) {
+      logInfo(
+        `[Replay] Session duration (${Math.floor(duration / 1000)}s) is too ${
+          tooShort ? 'short' : 'long'
+        }, not sending replay.`,
+        this._options._experiments.traceInternals,
+      );
+
+      if (tooShort) {
+        this._debouncedFlush();
+      }
+      return;
+    }
+
+    const eventBuffer = this.eventBuffer;
+    if (eventBuffer && this.session.segmentId === 0 && !eventBuffer.hasCheckout) {
+      logInfo('[Replay] Flushing initial segment without checkout.', this._options._experiments.traceInternals);
+      // TODO FN: Evaluate if we want to stop here, or remove this again?
+    }
+
+    // this._flushLock acts as a lock so that future calls to `_flush()`
+    // will be blocked until this promise resolves
+    if (!this._flushLock) {
+      this._flushLock = this._runFlush();
+      await this._flushLock;
+      this._flushLock = undefined;
+      return;
+    }
+
+    // Wait for previous flush to finish, then call the debounced `_flush()`.
+    // It's possible there are other flush requests queued and waiting for it
+    // to resolve. We want to reduce all outstanding requests (as well as any
+    // new flush requests that occur within a second of the locked flush
+    // completing) into a single flush.
+
+    try {
+      await this._flushLock;
+    } catch (err) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(err);
+    } finally {
+      this._debouncedFlush();
+    }
+  };}
+
+  /** Save the session, if it is sticky */
+   _maybeSaveSession() {
+    if (this.session && this._options.stickySession) {
+      saveSession(this.session);
+    }
+  }
+
+  /** Handler for rrweb.record.onMutation */
+   __init6() {this._onMutationHandler = (mutations) => {
+    const count = mutations.length;
+
+    const mutationLimit = this._options.mutationLimit;
+    const mutationBreadcrumbLimit = this._options.mutationBreadcrumbLimit;
+    const overMutationLimit = mutationLimit && count > mutationLimit;
+
+    // Create a breadcrumb if a lot of mutations happen at the same time
+    // We can show this in the UI as an information with potential performance improvements
+    if (count > mutationBreadcrumbLimit || overMutationLimit) {
+      const breadcrumb = createBreadcrumb({
+        category: 'replay.mutations',
+        data: {
+          count,
+          limit: overMutationLimit,
+        },
+      });
+      this._createCustomBreadcrumb(breadcrumb);
+    }
+
+    // Stop replay if over the mutation limit
+    if (overMutationLimit) {
+      void this.stop({ reason: 'mutationLimit', forceFlush: this.recordingMode === 'session' });
+      return false;
+    }
+
+    // `true` means we use the regular mutation handling by rrweb
+    return true;
+  };}
+}
+
+function getOption(
+  selectors,
+  defaultSelectors,
+  deprecatedClassOption,
+  deprecatedSelectorOption,
+) {
+  const deprecatedSelectors = typeof deprecatedSelectorOption === 'string' ? deprecatedSelectorOption.split(',') : [];
+
+  const allSelectors = [
+    ...selectors,
+    // @deprecated
+    ...deprecatedSelectors,
+
+    // sentry defaults
+    ...defaultSelectors,
+  ];
+
+  // @deprecated
+  if (typeof deprecatedClassOption !== 'undefined') {
+    // NOTE: No support for RegExp
+    if (typeof deprecatedClassOption === 'string') {
+      allSelectors.push(`.${deprecatedClassOption}`);
+    }
+
+    // eslint-disable-next-line no-console
+    console.warn(
+      '[Replay] You are using a deprecated configuration item for privacy. Read the documentation on how to use the new privacy configuration.',
+    );
+  }
+
+  return allSelectors.join(',');
+}
+
+/**
+ * Returns privacy related configuration for use in rrweb
+ */
+function getPrivacyOptions({
+  mask,
+  unmask,
+  block,
+  unblock,
+  ignore,
+
+  // eslint-disable-next-line deprecation/deprecation
+  blockClass,
+  // eslint-disable-next-line deprecation/deprecation
+  blockSelector,
+  // eslint-disable-next-line deprecation/deprecation
+  maskTextClass,
+  // eslint-disable-next-line deprecation/deprecation
+  maskTextSelector,
+  // eslint-disable-next-line deprecation/deprecation
+  ignoreClass,
+}) {
+  const defaultBlockedElements = ['base[href="/"]'];
+
+  const maskSelector = getOption(mask, ['.sentry-mask', '[data-sentry-mask]'], maskTextClass, maskTextSelector);
+  const unmaskSelector = getOption(unmask, ['.sentry-unmask', '[data-sentry-unmask]']);
+
+  const options = {
+    // We are making the decision to make text and input selectors the same
+    maskTextSelector: maskSelector,
+    unmaskTextSelector: unmaskSelector,
+    maskInputSelector: maskSelector,
+    unmaskInputSelector: unmaskSelector,
+
+    blockSelector: getOption(
+      block,
+      ['.sentry-block', '[data-sentry-block]', ...defaultBlockedElements],
+      blockClass,
+      blockSelector,
+    ),
+    unblockSelector: getOption(unblock, ['.sentry-unblock', '[data-sentry-unblock]']),
+    ignoreSelector: getOption(ignore, ['.sentry-ignore', '[data-sentry-ignore]', 'input[type="file"]'], ignoreClass),
+  };
+
+  if (blockClass instanceof RegExp) {
+    options.blockClass = blockClass;
+  }
+
+  if (maskTextClass instanceof RegExp) {
+    options.maskTextClass = maskTextClass;
+  }
+
+  return options;
+}
+
+/**
+ * Returns true if we are in the browser.
+ */
+function isBrowser() {
+  // eslint-disable-next-line no-restricted-globals
+  return typeof window !== 'undefined' && (!isNodeEnv() || isElectronNodeRenderer());
+}
+
+// Electron renderers with nodeIntegration enabled are detected as Node.js so we specifically test for them
+function isElectronNodeRenderer() {
+  return typeof process !== 'undefined' && (process ).type === 'renderer';
+}
+
+const MEDIA_SELECTORS =
+  'img,image,svg,video,object,picture,embed,map,audio,link[rel="icon"],link[rel="apple-touch-icon"]';
+
+const DEFAULT_NETWORK_HEADERS = ['content-length', 'content-type', 'accept'];
+
+let _initialized = false;
+
+/**
+ * The main replay integration class, to be passed to `init({  integrations: [] })`.
+ */
+class Replay  {
+  /**
+   * @inheritDoc
+   */
+   static __initStatic() {this.id = 'Replay';}
+
+  /**
+   * @inheritDoc
+   */
+
+  /**
+   * Options to pass to `rrweb.record()`
+   */
+
+  /**
+   * Initial options passed to the replay integration, merged with default values.
+   * Note: `sessionSampleRate` and `errorSampleRate` are not required here, as they
+   * can only be finally set when setupOnce() is called.
+   *
+   * @private
+   */
+
+   constructor({
+    flushMinDelay = DEFAULT_FLUSH_MIN_DELAY,
+    flushMaxDelay = DEFAULT_FLUSH_MAX_DELAY,
+    minReplayDuration = MIN_REPLAY_DURATION,
+    maxReplayDuration = MAX_REPLAY_DURATION,
+    stickySession = true,
+    useCompression = true,
+    _experiments = {},
+    sessionSampleRate,
+    errorSampleRate,
+    maskAllText = true,
+    maskAllInputs = true,
+    blockAllMedia = true,
+
+    mutationBreadcrumbLimit = 750,
+    mutationLimit = 10000,
+
+    slowClickTimeout = 7000,
+    slowClickIgnoreSelectors = [],
+
+    networkDetailAllowUrls = [],
+    networkDetailDenyUrls = [],
+    networkCaptureBodies = true,
+    networkRequestHeaders = [],
+    networkResponseHeaders = [],
+
+    mask = [],
+    unmask = [],
+    block = [],
+    unblock = [],
+    ignore = [],
+    maskFn,
+
+    beforeAddRecordingEvent,
+
+    // eslint-disable-next-line deprecation/deprecation
+    blockClass,
+    // eslint-disable-next-line deprecation/deprecation
+    blockSelector,
+    // eslint-disable-next-line deprecation/deprecation
+    maskInputOptions,
+    // eslint-disable-next-line deprecation/deprecation
+    maskTextClass,
+    // eslint-disable-next-line deprecation/deprecation
+    maskTextSelector,
+    // eslint-disable-next-line deprecation/deprecation
+    ignoreClass,
+  } = {}) {
+    this.name = Replay.id;
+
+    this._recordingOptions = {
+      maskAllInputs,
+      maskAllText,
+      maskInputOptions: { ...(maskInputOptions || {}), password: true },
+      maskTextFn: maskFn,
+      maskInputFn: maskFn,
+
+      ...getPrivacyOptions({
+        mask,
+        unmask,
+        block,
+        unblock,
+        ignore,
+        blockClass,
+        blockSelector,
+        maskTextClass,
+        maskTextSelector,
+        ignoreClass,
+      }),
+
+      // Our defaults
+      slimDOMOptions: 'all',
+      inlineStylesheet: true,
+      // Disable inline images as it will increase segment/replay size
+      inlineImages: false,
+      // collect fonts, but be aware that `sentry.io` needs to be an allowed
+      // origin for playback
+      collectFonts: true,
+    };
+
+    this._initialOptions = {
+      flushMinDelay,
+      flushMaxDelay,
+      minReplayDuration: Math.min(minReplayDuration, MIN_REPLAY_DURATION_LIMIT),
+      maxReplayDuration: Math.min(maxReplayDuration, MAX_REPLAY_DURATION),
+      stickySession,
+      sessionSampleRate,
+      errorSampleRate,
+      useCompression,
+      blockAllMedia,
+      maskAllInputs,
+      maskAllText,
+      mutationBreadcrumbLimit,
+      mutationLimit,
+      slowClickTimeout,
+      slowClickIgnoreSelectors,
+      networkDetailAllowUrls,
+      networkDetailDenyUrls,
+      networkCaptureBodies,
+      networkRequestHeaders: _getMergedNetworkHeaders(networkRequestHeaders),
+      networkResponseHeaders: _getMergedNetworkHeaders(networkResponseHeaders),
+      beforeAddRecordingEvent,
+
+      _experiments,
+    };
+
+    if (typeof sessionSampleRate === 'number') {
+      // eslint-disable-next-line
+      console.warn(
+        `[Replay] You are passing \`sessionSampleRate\` to the Replay integration.
+This option is deprecated and will be removed soon.
+Instead, configure \`replaysSessionSampleRate\` directly in the SDK init options, e.g.:
+Sentry.init({ replaysSessionSampleRate: ${sessionSampleRate} })`,
+      );
+
+      this._initialOptions.sessionSampleRate = sessionSampleRate;
+    }
+
+    if (typeof errorSampleRate === 'number') {
+      // eslint-disable-next-line
+      console.warn(
+        `[Replay] You are passing \`errorSampleRate\` to the Replay integration.
+This option is deprecated and will be removed soon.
+Instead, configure \`replaysOnErrorSampleRate\` directly in the SDK init options, e.g.:
+Sentry.init({ replaysOnErrorSampleRate: ${errorSampleRate} })`,
+      );
+
+      this._initialOptions.errorSampleRate = errorSampleRate;
+    }
+
+    if (this._initialOptions.blockAllMedia) {
+      // `blockAllMedia` is a more user friendly option to configure blocking
+      // embedded media elements
+      this._recordingOptions.blockSelector = !this._recordingOptions.blockSelector
+        ? MEDIA_SELECTORS
+        : `${this._recordingOptions.blockSelector},${MEDIA_SELECTORS}`;
+    }
+
+    if (this._isInitialized && isBrowser()) {
+      throw new Error('Multiple Sentry Session Replay instances are not supported');
+    }
+
+    this._isInitialized = true;
+  }
+
+  /** If replay has already been initialized */
+   get _isInitialized() {
+    return _initialized;
+  }
+
+  /** Update _isInitialized */
+   set _isInitialized(value) {
+    _initialized = value;
+  }
+
+  /**
+   * Setup and initialize replay container
+   */
+   setupOnce() {
+    if (!isBrowser()) {
+      return;
+    }
+
+    this._setup();
+
+    // Once upon a time, we tried to create a transaction in `setupOnce` and it would
+    // potentially create a transaction before some native SDK integrations have run
+    // and applied their own global event processor. An example is:
+    // https://github.com/getsentry/sentry-javascript/blob/b47ceafbdac7f8b99093ce6023726ad4687edc48/packages/browser/src/integrations/useragent.ts
+    //
+    // So we call `this._initialize()` in next event loop as a workaround to wait for other
+    // global event processors to finish. This is no longer needed, but keeping it
+    // here to avoid any future issues.
+    setTimeout(() => this._initialize());
+  }
+
+  /**
+   * Start a replay regardless of sampling rate. Calling this will always
+   * create a new session. Will throw an error if replay is already in progress.
+   *
+   * Creates or loads a session, attaches listeners to varying events (DOM,
+   * PerformanceObserver, Recording, Sentry SDK, etc)
+   */
+   start() {
+    if (!this._replay) {
+      return;
+    }
+
+    this._replay.start();
+  }
+
+  /**
+   * Start replay buffering. Buffers until `flush()` is called or, if
+   * `replaysOnErrorSampleRate` > 0, until an error occurs.
+   */
+   startBuffering() {
+    if (!this._replay) {
+      return;
+    }
+
+    this._replay.startBuffering();
+  }
+
+  /**
+   * Currently, this needs to be manually called (e.g. for tests). Sentry SDK
+   * does not support a teardown
+   */
+   stop() {
+    if (!this._replay) {
+      return Promise.resolve();
+    }
+
+    return this._replay.stop({ forceFlush: this._replay.recordingMode === 'session' });
+  }
+
+  /**
+   * If not in "session" recording mode, flush event buffer which will create a new replay.
+   * Unless `continueRecording` is false, the replay will continue to record and
+   * behave as a "session"-based replay.
+   *
+   * Otherwise, queue up a flush.
+   */
+   flush(options) {
+    if (!this._replay || !this._replay.isEnabled()) {
+      return Promise.resolve();
+    }
+
+    return this._replay.sendBufferedReplayOrFlush(options);
+  }
+
+  /**
+   * Get the current session ID.
+   */
+   getReplayId() {
+    if (!this._replay || !this._replay.isEnabled()) {
+      return;
+    }
+
+    return this._replay.getSessionId();
+  }
+  /**
+   * Initializes replay.
+   */
+   _initialize() {
+    if (!this._replay) {
+      return;
+    }
+
+    this._replay.initializeSampling();
+  }
+
+  /** Setup the integration. */
+   _setup() {
+    // Client is not available in constructor, so we need to wait until setupOnce
+    const finalOptions = loadReplayOptionsFromClient(this._initialOptions);
+
+    this._replay = new ReplayContainer({
+      options: finalOptions,
+      recordingOptions: this._recordingOptions,
+    });
+  }
+} Replay.__initStatic();
+
+/** Parse Replay-related options from SDK options */
+function loadReplayOptionsFromClient(initialOptions) {
+  const client = getCurrentHub().getClient();
+  const opt = client && (client.getOptions() );
+
+  const finalOptions = { sessionSampleRate: 0, errorSampleRate: 0, ...dropUndefinedKeys(initialOptions) };
+
+  if (!opt) {
+    // eslint-disable-next-line no-console
+    console.warn('SDK client is not available.');
+    return finalOptions;
+  }
+
+  if (
+    initialOptions.sessionSampleRate == null && // TODO remove once deprecated rates are removed
+    initialOptions.errorSampleRate == null && // TODO remove once deprecated rates are removed
+    opt.replaysSessionSampleRate == null &&
+    opt.replaysOnErrorSampleRate == null
+  ) {
+    // eslint-disable-next-line no-console
+    console.warn(
+      'Replay is disabled because neither `replaysSessionSampleRate` nor `replaysOnErrorSampleRate` are set.',
+    );
+  }
+
+  if (typeof opt.replaysSessionSampleRate === 'number') {
+    finalOptions.sessionSampleRate = opt.replaysSessionSampleRate;
+  }
+
+  if (typeof opt.replaysOnErrorSampleRate === 'number') {
+    finalOptions.errorSampleRate = opt.replaysOnErrorSampleRate;
+  }
+
+  return finalOptions;
+}
+
+function _getMergedNetworkHeaders(headers) {
+  return [...DEFAULT_NETWORK_HEADERS, ...headers.map(header => header.toLowerCase())];
+}
+
+export { Replay };
+//# sourceMappingURL=index.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/browser.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/browser.js
new file mode 100644
index 0000000..aef06de
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/browser.js
@@ -0,0 +1,152 @@
+import { isString } from './is.js';
+import { getGlobalObject } from './worldwide.js';
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+const DEFAULT_MAX_STRING_LENGTH = 80;
+
+/**
+ * Given a child DOM element, returns a query-selector statement describing that
+ * and its ancestors
+ * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]
+ * @returns generated DOM path
+ */
+function htmlTreeAsString(
+  elem,
+  options = {},
+) {
+
+  // try/catch both:
+  // - accessing event.target (see getsentry/raven-js#838, #768)
+  // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly
+  // - can throw an exception in some circumstances.
+  try {
+    let currentElem = elem ;
+    const MAX_TRAVERSE_HEIGHT = 5;
+    const out = [];
+    let height = 0;
+    let len = 0;
+    const separator = ' > ';
+    const sepLength = separator.length;
+    let nextStr;
+    const keyAttrs = Array.isArray(options) ? options : options.keyAttrs;
+    const maxStringLength = (!Array.isArray(options) && options.maxStringLength) || DEFAULT_MAX_STRING_LENGTH;
+
+    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {
+      nextStr = _htmlElementAsString(currentElem, keyAttrs);
+      // bail out if
+      // - nextStr is the 'html' element
+      // - the length of the string that would be created exceeds maxStringLength
+      //   (ignore this limit if we are on the first iteration)
+      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength)) {
+        break;
+      }
+
+      out.push(nextStr);
+
+      len += nextStr.length;
+      currentElem = currentElem.parentNode;
+    }
+
+    return out.reverse().join(separator);
+  } catch (_oO) {
+    return '<unknown>';
+  }
+}
+
+/**
+ * Returns a simple, query-selector representation of a DOM element
+ * e.g. [HTMLElement] => input#foo.btn[name=baz]
+ * @returns generated DOM path
+ */
+function _htmlElementAsString(el, keyAttrs) {
+  const elem = el
+
+;
+
+  const out = [];
+  let className;
+  let classes;
+  let key;
+  let attr;
+  let i;
+
+  if (!elem || !elem.tagName) {
+    return '';
+  }
+
+  out.push(elem.tagName.toLowerCase());
+
+  // Pairs of attribute keys defined in `serializeAttribute` and their values on element.
+  const keyAttrPairs =
+    keyAttrs && keyAttrs.length
+      ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])
+      : null;
+
+  if (keyAttrPairs && keyAttrPairs.length) {
+    keyAttrPairs.forEach(keyAttrPair => {
+      out.push(`[${keyAttrPair[0]}="${keyAttrPair[1]}"]`);
+    });
+  } else {
+    if (elem.id) {
+      out.push(`#${elem.id}`);
+    }
+
+    // eslint-disable-next-line prefer-const
+    className = elem.className;
+    if (className && isString(className)) {
+      classes = className.split(/\s+/);
+      for (i = 0; i < classes.length; i++) {
+        out.push(`.${classes[i]}`);
+      }
+    }
+  }
+  const allowedAttrs = ['aria-label', 'type', 'name', 'title', 'alt'];
+  for (i = 0; i < allowedAttrs.length; i++) {
+    key = allowedAttrs[i];
+    attr = elem.getAttribute(key);
+    if (attr) {
+      out.push(`[${key}="${attr}"]`);
+    }
+  }
+  return out.join('');
+}
+
+/**
+ * A safe form of location.href
+ */
+function getLocationHref() {
+  try {
+    return WINDOW.document.location.href;
+  } catch (oO) {
+    return '';
+  }
+}
+
+/**
+ * Gets a DOM element by using document.querySelector.
+ *
+ * This wrapper will first check for the existance of the function before
+ * actually calling it so that we don't have to take care of this check,
+ * every time we want to access the DOM.
+ *
+ * Reason: DOM/querySelector is not available in all environments.
+ *
+ * We have to cast to any because utils can be consumed by a variety of environments,
+ * and we don't want to break TS users. If you know what element will be selected by
+ * `document.querySelector`, specify it as part of the generic call. For example,
+ * `const element = getDomElement<Element>('selector');`
+ *
+ * @param selector the selector string passed on to document.querySelector
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getDomElement(selector) {
+  if (WINDOW.document && WINDOW.document.querySelector) {
+    return WINDOW.document.querySelector(selector) ;
+  }
+  return null;
+}
+
+export { getDomElement, getLocationHref, htmlTreeAsString };
+//# sourceMappingURL=browser.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/dsn.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/dsn.js
new file mode 100644
index 0000000..4fe84be
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/dsn.js
@@ -0,0 +1,126 @@
+import { logger } from './logger.js';
+
+/** Regular expression used to parse a Dsn. */
+const DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)([\w.-]+)(?::(\d+))?\/(.+)/;
+
+function isValidProtocol(protocol) {
+  return protocol === 'http' || protocol === 'https';
+}
+
+/**
+ * Renders the string representation of this Dsn.
+ *
+ * By default, this will render the public representation without the password
+ * component. To get the deprecated private representation, set `withPassword`
+ * to true.
+ *
+ * @param withPassword When set to true, the password will be included.
+ */
+function dsnToString(dsn, withPassword = false) {
+  const { host, path, pass, port, projectId, protocol, publicKey } = dsn;
+  return (
+    `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +
+    `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`
+  );
+}
+
+/**
+ * Parses a Dsn from a given string.
+ *
+ * @param str A Dsn as string
+ * @returns Dsn as DsnComponents or undefined if @param str is not a valid DSN string
+ */
+function dsnFromString(str) {
+  const match = DSN_REGEX.exec(str);
+
+  if (!match) {
+    // This should be logged to the console
+    // eslint-disable-next-line no-console
+    console.error(`Invalid Sentry Dsn: ${str}`);
+    return undefined;
+  }
+
+  const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);
+  let path = '';
+  let projectId = lastPath;
+
+  const split = projectId.split('/');
+  if (split.length > 1) {
+    path = split.slice(0, -1).join('/');
+    projectId = split.pop() ;
+  }
+
+  if (projectId) {
+    const projectMatch = projectId.match(/^\d+/);
+    if (projectMatch) {
+      projectId = projectMatch[0];
+    }
+  }
+
+  return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol , publicKey });
+}
+
+function dsnFromComponents(components) {
+  return {
+    protocol: components.protocol,
+    publicKey: components.publicKey || '',
+    pass: components.pass || '',
+    host: components.host,
+    port: components.port || '',
+    path: components.path || '',
+    projectId: components.projectId,
+  };
+}
+
+function validateDsn(dsn) {
+  if (!(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+    return true;
+  }
+
+  const { port, projectId, protocol } = dsn;
+
+  const requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];
+  const hasMissingRequiredComponent = requiredComponents.find(component => {
+    if (!dsn[component]) {
+      logger.error(`Invalid Sentry Dsn: ${component} missing`);
+      return true;
+    }
+    return false;
+  });
+
+  if (hasMissingRequiredComponent) {
+    return false;
+  }
+
+  if (!projectId.match(/^\d+$/)) {
+    logger.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);
+    return false;
+  }
+
+  if (!isValidProtocol(protocol)) {
+    logger.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);
+    return false;
+  }
+
+  if (port && isNaN(parseInt(port, 10))) {
+    logger.error(`Invalid Sentry Dsn: Invalid port ${port}`);
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Creates a valid Sentry Dsn object, identifying a Sentry instance and project.
+ * @returns a valid DsnComponents object or `undefined` if @param from is an invalid DSN source
+ */
+function makeDsn(from) {
+  const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);
+  if (!components || !validateDsn(components)) {
+    return undefined;
+  }
+  return components;
+}
+
+export { dsnFromString, dsnToString, makeDsn };
+//# sourceMappingURL=dsn.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/env.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/env.js
new file mode 100644
index 0000000..46dc077
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/env.js
@@ -0,0 +1,34 @@
+/*
+ * This module exists for optimizations in the build process through rollup and terser.  We define some global
+ * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these
+ * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will
+ * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to
+ * `logger` and preventing node-related code from appearing in browser bundles.
+ *
+ * Attention:
+ * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by
+ * users. These flags should live in their respective packages, as we identified user tooling (specifically webpack)
+ * having issues tree-shaking these constants across package boundaries.
+ * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want
+ * users to be able to shake away expressions that it guards.
+ */
+
+/**
+ * Figures out if we're building a browser bundle.
+ *
+ * @returns true if this is a browser bundle build.
+ */
+function isBrowserBundle() {
+  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;
+}
+
+/**
+ * Get source of SDK.
+ */
+function getSDKSource() {
+  // @ts-expect-error "npm" is injected by rollup during build process
+  return "npm";
+}
+
+export { getSDKSource, isBrowserBundle };
+//# sourceMappingURL=env.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/envelope.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/envelope.js
new file mode 100644
index 0000000..a2cc042
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/envelope.js
@@ -0,0 +1,232 @@
+import { dsnToString } from './dsn.js';
+import { normalize } from './normalize.js';
+import { dropUndefinedKeys } from './object.js';
+
+/**
+ * Creates an envelope.
+ * Make sure to always explicitly provide the generic to this function
+ * so that the envelope types resolve correctly.
+ */
+function createEnvelope(headers, items = []) {
+  return [headers, items] ;
+}
+
+/**
+ * Add an item to an envelope.
+ * Make sure to always explicitly provide the generic to this function
+ * so that the envelope types resolve correctly.
+ */
+function addItemToEnvelope(envelope, newItem) {
+  const [headers, items] = envelope;
+  return [headers, [...items, newItem]] ;
+}
+
+/**
+ * Convenience function to loop through the items and item types of an envelope.
+ * (This function was mostly created because working with envelope types is painful at the moment)
+ *
+ * If the callback returns true, the rest of the items will be skipped.
+ */
+function forEachEnvelopeItem(
+  envelope,
+  callback,
+) {
+  const envelopeItems = envelope[1];
+
+  for (const envelopeItem of envelopeItems) {
+    const envelopeItemType = envelopeItem[0].type;
+    const result = callback(envelopeItem, envelopeItemType);
+
+    if (result) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Returns true if the envelope contains any of the given envelope item types
+ */
+function envelopeContainsItemType(envelope, types) {
+  return forEachEnvelopeItem(envelope, (_, type) => types.includes(type));
+}
+
+/**
+ * Encode a string to UTF8.
+ */
+function encodeUTF8(input, textEncoder) {
+  const utf8 = textEncoder || new TextEncoder();
+  return utf8.encode(input);
+}
+
+/**
+ * Serializes an envelope.
+ */
+function serializeEnvelope(envelope, textEncoder) {
+  const [envHeaders, items] = envelope;
+
+  // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data
+  let parts = JSON.stringify(envHeaders);
+
+  function append(next) {
+    if (typeof parts === 'string') {
+      parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts, textEncoder), next];
+    } else {
+      parts.push(typeof next === 'string' ? encodeUTF8(next, textEncoder) : next);
+    }
+  }
+
+  for (const item of items) {
+    const [itemHeaders, payload] = item;
+
+    append(`\n${JSON.stringify(itemHeaders)}\n`);
+
+    if (typeof payload === 'string' || payload instanceof Uint8Array) {
+      append(payload);
+    } else {
+      let stringifiedPayload;
+      try {
+        stringifiedPayload = JSON.stringify(payload);
+      } catch (e) {
+        // In case, despite all our efforts to keep `payload` circular-dependency-free, `JSON.strinify()` still
+        // fails, we try again after normalizing it again with infinite normalization depth. This of course has a
+        // performance impact but in this case a performance hit is better than throwing.
+        stringifiedPayload = JSON.stringify(normalize(payload));
+      }
+      append(stringifiedPayload);
+    }
+  }
+
+  return typeof parts === 'string' ? parts : concatBuffers(parts);
+}
+
+function concatBuffers(buffers) {
+  const totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);
+
+  const merged = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const buffer of buffers) {
+    merged.set(buffer, offset);
+    offset += buffer.length;
+  }
+
+  return merged;
+}
+
+/**
+ * Parses an envelope
+ */
+function parseEnvelope(
+  env,
+  textEncoder,
+  textDecoder,
+) {
+  let buffer = typeof env === 'string' ? textEncoder.encode(env) : env;
+
+  function readBinary(length) {
+    const bin = buffer.subarray(0, length);
+    // Replace the buffer with the remaining data excluding trailing newline
+    buffer = buffer.subarray(length + 1);
+    return bin;
+  }
+
+  function readJson() {
+    let i = buffer.indexOf(0xa);
+    // If we couldn't find a newline, we must have found the end of the buffer
+    if (i < 0) {
+      i = buffer.length;
+    }
+
+    return JSON.parse(textDecoder.decode(readBinary(i))) ;
+  }
+
+  const envelopeHeader = readJson();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const items = [];
+
+  while (buffer.length) {
+    const itemHeader = readJson();
+    const binaryLength = typeof itemHeader.length === 'number' ? itemHeader.length : undefined;
+
+    items.push([itemHeader, binaryLength ? readBinary(binaryLength) : readJson()]);
+  }
+
+  return [envelopeHeader, items];
+}
+
+/**
+ * Creates attachment envelope items
+ */
+function createAttachmentEnvelopeItem(
+  attachment,
+  textEncoder,
+) {
+  const buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data, textEncoder) : attachment.data;
+
+  return [
+    dropUndefinedKeys({
+      type: 'attachment',
+      length: buffer.length,
+      filename: attachment.filename,
+      content_type: attachment.contentType,
+      attachment_type: attachment.attachmentType,
+    }),
+    buffer,
+  ];
+}
+
+const ITEM_TYPE_TO_DATA_CATEGORY_MAP = {
+  session: 'session',
+  sessions: 'session',
+  attachment: 'attachment',
+  transaction: 'transaction',
+  event: 'error',
+  client_report: 'internal',
+  user_report: 'default',
+  profile: 'profile',
+  replay_event: 'replay',
+  replay_recording: 'replay',
+  check_in: 'monitor',
+};
+
+/**
+ * Maps the type of an envelope item to a data category.
+ */
+function envelopeItemTypeToDataCategory(type) {
+  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];
+}
+
+/** Extracts the minimal SDK info from from the metadata or an events */
+function getSdkMetadataForEnvelopeHeader(metadataOrEvent) {
+  if (!metadataOrEvent || !metadataOrEvent.sdk) {
+    return;
+  }
+  const { name, version } = metadataOrEvent.sdk;
+  return { name, version };
+}
+
+/**
+ * Creates event envelope headers, based on event, sdk info and tunnel
+ * Note: This function was extracted from the core package to make it available in Replay
+ */
+function createEventEnvelopeHeaders(
+  event,
+  sdkInfo,
+  tunnel,
+  dsn,
+) {
+  const dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;
+  return {
+    event_id: event.event_id ,
+    sent_at: new Date().toISOString(),
+    ...(sdkInfo && { sdk: sdkInfo }),
+    ...(!!tunnel && { dsn: dsnToString(dsn) }),
+    ...(dynamicSamplingContext && {
+      trace: dropUndefinedKeys({ ...dynamicSamplingContext }),
+    }),
+  };
+}
+
+export { addItemToEnvelope, createAttachmentEnvelopeItem, createEnvelope, createEventEnvelopeHeaders, envelopeContainsItemType, envelopeItemTypeToDataCategory, forEachEnvelopeItem, getSdkMetadataForEnvelopeHeader, parseEnvelope, serializeEnvelope };
+//# sourceMappingURL=envelope.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/instrument.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/instrument.js
new file mode 100644
index 0000000..9eb5a9e
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/instrument.js
@@ -0,0 +1,642 @@
+import { isString } from './is.js';
+import { logger, CONSOLE_LEVELS, originalConsoleMethods } from './logger.js';
+import { fill } from './object.js';
+import { getFunctionName } from './stacktrace.js';
+import { supportsNativeFetch } from './supports.js';
+import { getGlobalObject, GLOBAL_OBJ } from './worldwide.js';
+import { supportsHistory } from './vendor/supportsHistory.js';
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+const SENTRY_XHR_DATA_KEY = '__sentry_xhr_v2__';
+
+/**
+ * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.
+ *  - Console API
+ *  - Fetch API
+ *  - XHR API
+ *  - History API
+ *  - DOM API (click/typing)
+ *  - Error API
+ *  - UnhandledRejection API
+ */
+
+const handlers = {};
+const instrumented = {};
+
+/** Instruments given API */
+function instrument(type) {
+  if (instrumented[type]) {
+    return;
+  }
+
+  instrumented[type] = true;
+
+  switch (type) {
+    case 'console':
+      instrumentConsole();
+      break;
+    case 'dom':
+      instrumentDOM();
+      break;
+    case 'xhr':
+      instrumentXHR();
+      break;
+    case 'fetch':
+      instrumentFetch();
+      break;
+    case 'history':
+      instrumentHistory();
+      break;
+    case 'error':
+      instrumentError();
+      break;
+    case 'unhandledrejection':
+      instrumentUnhandledRejection();
+      break;
+    default:
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('unknown instrumentation type:', type);
+      return;
+  }
+}
+
+/**
+ * Add handler that will be called when given type of instrumentation triggers.
+ * Use at your own risk, this might break without changelog notice, only used internally.
+ * @hidden
+ */
+function addInstrumentationHandler(type, callback) {
+  handlers[type] = handlers[type] || [];
+  (handlers[type] ).push(callback);
+  instrument(type);
+}
+
+/**
+ * Reset all instrumentation handlers.
+ * This can be used by tests to ensure we have a clean slate of instrumentation handlers.
+ */
+function resetInstrumentationHandlers() {
+  Object.keys(handlers).forEach(key => {
+    handlers[key ] = undefined;
+  });
+}
+
+/** JSDoc */
+function triggerHandlers(type, data) {
+  if (!type || !handlers[type]) {
+    return;
+  }
+
+  for (const handler of handlers[type] || []) {
+    try {
+      handler(data);
+    } catch (e) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        logger.error(
+          `Error while triggering instrumentation handler.\nType: ${type}\nName: ${getFunctionName(handler)}\nError:`,
+          e,
+        );
+    }
+  }
+}
+
+/** JSDoc */
+function instrumentConsole() {
+  if (!('console' in GLOBAL_OBJ)) {
+    return;
+  }
+
+  CONSOLE_LEVELS.forEach(function (level) {
+    if (!(level in GLOBAL_OBJ.console)) {
+      return;
+    }
+
+    fill(GLOBAL_OBJ.console, level, function (originalConsoleMethod) {
+      originalConsoleMethods[level] = originalConsoleMethod;
+
+      return function (...args) {
+        triggerHandlers('console', { args, level });
+
+        const log = originalConsoleMethods[level];
+        log && log.apply(GLOBAL_OBJ.console, args);
+      };
+    });
+  });
+}
+
+/** JSDoc */
+function instrumentFetch() {
+  if (!supportsNativeFetch()) {
+    return;
+  }
+
+  fill(GLOBAL_OBJ, 'fetch', function (originalFetch) {
+    return function (...args) {
+      const { method, url } = parseFetchArgs(args);
+
+      const handlerData = {
+        args,
+        fetchData: {
+          method,
+          url,
+        },
+        startTimestamp: Date.now(),
+      };
+
+      triggerHandlers('fetch', {
+        ...handlerData,
+      });
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      return originalFetch.apply(GLOBAL_OBJ, args).then(
+        (response) => {
+          triggerHandlers('fetch', {
+            ...handlerData,
+            endTimestamp: Date.now(),
+            response,
+          });
+          return response;
+        },
+        (error) => {
+          triggerHandlers('fetch', {
+            ...handlerData,
+            endTimestamp: Date.now(),
+            error,
+          });
+          // NOTE: If you are a Sentry user, and you are seeing this stack frame,
+          //       it means the sentry.javascript SDK caught an error invoking your application code.
+          //       This is expected behavior and NOT indicative of a bug with sentry.javascript.
+          throw error;
+        },
+      );
+    };
+  });
+}
+
+function hasProp(obj, prop) {
+  return !!obj && typeof obj === 'object' && !!(obj )[prop];
+}
+
+function getUrlFromResource(resource) {
+  if (typeof resource === 'string') {
+    return resource;
+  }
+
+  if (!resource) {
+    return '';
+  }
+
+  if (hasProp(resource, 'url')) {
+    return resource.url;
+  }
+
+  if (resource.toString) {
+    return resource.toString();
+  }
+
+  return '';
+}
+
+/**
+ * Parses the fetch arguments to find the used Http method and the url of the request
+ */
+function parseFetchArgs(fetchArgs) {
+  if (fetchArgs.length === 0) {
+    return { method: 'GET', url: '' };
+  }
+
+  if (fetchArgs.length === 2) {
+    const [url, options] = fetchArgs ;
+
+    return {
+      url: getUrlFromResource(url),
+      method: hasProp(options, 'method') ? String(options.method).toUpperCase() : 'GET',
+    };
+  }
+
+  const arg = fetchArgs[0];
+  return {
+    url: getUrlFromResource(arg ),
+    method: hasProp(arg, 'method') ? String(arg.method).toUpperCase() : 'GET',
+  };
+}
+
+/** JSDoc */
+function instrumentXHR() {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  if (!(WINDOW ).XMLHttpRequest) {
+    return;
+  }
+
+  const xhrproto = XMLHttpRequest.prototype;
+
+  fill(xhrproto, 'open', function (originalOpen) {
+    return function ( ...args) {
+      const url = args[1];
+      const xhrInfo = (this[SENTRY_XHR_DATA_KEY] = {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        method: isString(args[0]) ? args[0].toUpperCase() : args[0],
+        url: args[1],
+        request_headers: {},
+      });
+
+      // if Sentry key appears in URL, don't capture it as a request
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      if (isString(url) && xhrInfo.method === 'POST' && url.match(/sentry_key/)) {
+        this.__sentry_own_request__ = true;
+      }
+
+      const onreadystatechangeHandler = () => {
+        // For whatever reason, this is not the same instance here as from the outer method
+        const xhrInfo = this[SENTRY_XHR_DATA_KEY];
+
+        if (!xhrInfo) {
+          return;
+        }
+
+        if (this.readyState === 4) {
+          try {
+            // touching statusCode in some platforms throws
+            // an exception
+            xhrInfo.status_code = this.status;
+          } catch (e) {
+            /* do nothing */
+          }
+
+          triggerHandlers('xhr', {
+            args: args ,
+            endTimestamp: Date.now(),
+            startTimestamp: Date.now(),
+            xhr: this,
+          } );
+        }
+      };
+
+      if ('onreadystatechange' in this && typeof this.onreadystatechange === 'function') {
+        fill(this, 'onreadystatechange', function (original) {
+          return function ( ...readyStateArgs) {
+            onreadystatechangeHandler();
+            return original.apply(this, readyStateArgs);
+          };
+        });
+      } else {
+        this.addEventListener('readystatechange', onreadystatechangeHandler);
+      }
+
+      // Intercepting `setRequestHeader` to access the request headers of XHR instance.
+      // This will only work for user/library defined headers, not for the default/browser-assigned headers.
+      // Request cookies are also unavailable for XHR, as `Cookie` header can't be defined by `setRequestHeader`.
+      fill(this, 'setRequestHeader', function (original) {
+        return function ( ...setRequestHeaderArgs) {
+          const [header, value] = setRequestHeaderArgs ;
+
+          const xhrInfo = this[SENTRY_XHR_DATA_KEY];
+
+          if (xhrInfo) {
+            xhrInfo.request_headers[header.toLowerCase()] = value;
+          }
+
+          return original.apply(this, setRequestHeaderArgs);
+        };
+      });
+
+      return originalOpen.apply(this, args);
+    };
+  });
+
+  fill(xhrproto, 'send', function (originalSend) {
+    return function ( ...args) {
+      const sentryXhrData = this[SENTRY_XHR_DATA_KEY];
+      if (sentryXhrData && args[0] !== undefined) {
+        sentryXhrData.body = args[0];
+      }
+
+      triggerHandlers('xhr', {
+        args,
+        startTimestamp: Date.now(),
+        xhr: this,
+      });
+
+      return originalSend.apply(this, args);
+    };
+  });
+}
+
+let lastHref;
+
+/** JSDoc */
+function instrumentHistory() {
+  if (!supportsHistory()) {
+    return;
+  }
+
+  const oldOnPopState = WINDOW.onpopstate;
+  WINDOW.onpopstate = function ( ...args) {
+    const to = WINDOW.location.href;
+    // keep track of the current URL state, as we always receive only the updated state
+    const from = lastHref;
+    lastHref = to;
+    triggerHandlers('history', {
+      from,
+      to,
+    });
+    if (oldOnPopState) {
+      // Apparently this can throw in Firefox when incorrectly implemented plugin is installed.
+      // https://github.com/getsentry/sentry-javascript/issues/3344
+      // https://github.com/bugsnag/bugsnag-js/issues/469
+      try {
+        return oldOnPopState.apply(this, args);
+      } catch (_oO) {
+        // no-empty
+      }
+    }
+  };
+
+  /** @hidden */
+  function historyReplacementFunction(originalHistoryFunction) {
+    return function ( ...args) {
+      const url = args.length > 2 ? args[2] : undefined;
+      if (url) {
+        // coerce to string (this is what pushState does)
+        const from = lastHref;
+        const to = String(url);
+        // keep track of the current URL state, as we always receive only the updated state
+        lastHref = to;
+        triggerHandlers('history', {
+          from,
+          to,
+        });
+      }
+      return originalHistoryFunction.apply(this, args);
+    };
+  }
+
+  fill(WINDOW.history, 'pushState', historyReplacementFunction);
+  fill(WINDOW.history, 'replaceState', historyReplacementFunction);
+}
+
+const debounceDuration = 1000;
+let debounceTimerID;
+let lastCapturedEvent;
+
+/**
+ * Decide whether the current event should finish the debounce of previously captured one.
+ * @param previous previously captured event
+ * @param current event to be captured
+ */
+function shouldShortcircuitPreviousDebounce(previous, current) {
+  // If there was no previous event, it should always be swapped for the new one.
+  if (!previous) {
+    return true;
+  }
+
+  // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.
+  if (previous.type !== current.type) {
+    return true;
+  }
+
+  try {
+    // If both events have the same type, it's still possible that actions were performed on different targets.
+    // e.g. 2 clicks on different buttons.
+    if (previous.target !== current.target) {
+      return true;
+    }
+  } catch (e) {
+    // just accessing `target` property can throw an exception in some rare circumstances
+    // see: https://github.com/getsentry/sentry-javascript/issues/838
+  }
+
+  // If both events have the same type _and_ same `target` (an element which triggered an event, _not necessarily_
+  // to which an event listener was attached), we treat them as the same action, as we want to capture
+  // only one breadcrumb. e.g. multiple clicks on the same button, or typing inside a user input box.
+  return false;
+}
+
+/**
+ * Decide whether an event should be captured.
+ * @param event event to be captured
+ */
+function shouldSkipDOMEvent(event) {
+  // We are only interested in filtering `keypress` events for now.
+  if (event.type !== 'keypress') {
+    return false;
+  }
+
+  try {
+    const target = event.target ;
+
+    if (!target || !target.tagName) {
+      return true;
+    }
+
+    // Only consider keypress events on actual input elements. This will disregard keypresses targeting body
+    // e.g.tabbing through elements, hotkeys, etc.
+    if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {
+      return false;
+    }
+  } catch (e) {
+    // just accessing `target` property can throw an exception in some rare circumstances
+    // see: https://github.com/getsentry/sentry-javascript/issues/838
+  }
+
+  return true;
+}
+
+/**
+ * Wraps addEventListener to capture UI breadcrumbs
+ * @param handler function that will be triggered
+ * @param globalListener indicates whether event was captured by the global event listener
+ * @returns wrapped breadcrumb events handler
+ * @hidden
+ */
+function makeDOMEventHandler(handler, globalListener = false) {
+  return (event) => {
+    // It's possible this handler might trigger multiple times for the same
+    // event (e.g. event propagation through node ancestors).
+    // Ignore if we've already captured that event.
+    if (!event || lastCapturedEvent === event) {
+      return;
+    }
+
+    // We always want to skip _some_ events.
+    if (shouldSkipDOMEvent(event)) {
+      return;
+    }
+
+    const name = event.type === 'keypress' ? 'input' : event.type;
+
+    // If there is no debounce timer, it means that we can safely capture the new event and store it for future comparisons.
+    if (debounceTimerID === undefined) {
+      handler({
+        event: event,
+        name,
+        global: globalListener,
+      });
+      lastCapturedEvent = event;
+    }
+    // If there is a debounce awaiting, see if the new event is different enough to treat it as a unique one.
+    // If that's the case, emit the previous event and store locally the newly-captured DOM event.
+    else if (shouldShortcircuitPreviousDebounce(lastCapturedEvent, event)) {
+      handler({
+        event: event,
+        name,
+        global: globalListener,
+      });
+      lastCapturedEvent = event;
+    }
+
+    // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.
+    clearTimeout(debounceTimerID);
+    debounceTimerID = WINDOW.setTimeout(() => {
+      debounceTimerID = undefined;
+    }, debounceDuration);
+  };
+}
+
+/** JSDoc */
+function instrumentDOM() {
+  if (!WINDOW.document) {
+    return;
+  }
+
+  // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom
+  // handlers. (Normally we have only one, which captures a breadcrumb for each click or keypress.) Do this before
+  // we instrument `addEventListener` so that we don't end up attaching this handler twice.
+  const triggerDOMHandler = triggerHandlers.bind(null, 'dom');
+  const globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);
+  WINDOW.document.addEventListener('click', globalDOMEventHandler, false);
+  WINDOW.document.addEventListener('keypress', globalDOMEventHandler, false);
+
+  // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled
+  // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That
+  // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler
+  // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still
+  // guaranteed to fire at least once.)
+  ['EventTarget', 'Node'].forEach((target) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    const proto = (WINDOW )[target] && (WINDOW )[target].prototype;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins
+    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {
+      return;
+    }
+
+    fill(proto, 'addEventListener', function (originalAddEventListener) {
+      return function (
+
+        type,
+        listener,
+        options,
+      ) {
+        if (type === 'click' || type == 'keypress') {
+          try {
+            const el = this ;
+            const handlers = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});
+            const handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });
+
+            if (!handlerForType.handler) {
+              const handler = makeDOMEventHandler(triggerDOMHandler);
+              handlerForType.handler = handler;
+              originalAddEventListener.call(this, type, handler, options);
+            }
+
+            handlerForType.refCount++;
+          } catch (e) {
+            // Accessing dom properties is always fragile.
+            // Also allows us to skip `addEventListenrs` calls with no proper `this` context.
+          }
+        }
+
+        return originalAddEventListener.call(this, type, listener, options);
+      };
+    });
+
+    fill(
+      proto,
+      'removeEventListener',
+      function (originalRemoveEventListener) {
+        return function (
+
+          type,
+          listener,
+          options,
+        ) {
+          if (type === 'click' || type == 'keypress') {
+            try {
+              const el = this ;
+              const handlers = el.__sentry_instrumentation_handlers__ || {};
+              const handlerForType = handlers[type];
+
+              if (handlerForType) {
+                handlerForType.refCount--;
+                // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.
+                if (handlerForType.refCount <= 0) {
+                  originalRemoveEventListener.call(this, type, handlerForType.handler, options);
+                  handlerForType.handler = undefined;
+                  delete handlers[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete
+                }
+
+                // If there are no longer any custom handlers of any type on this element, cleanup everything.
+                if (Object.keys(handlers).length === 0) {
+                  delete el.__sentry_instrumentation_handlers__;
+                }
+              }
+            } catch (e) {
+              // Accessing dom properties is always fragile.
+              // Also allows us to skip `addEventListenrs` calls with no proper `this` context.
+            }
+          }
+
+          return originalRemoveEventListener.call(this, type, listener, options);
+        };
+      },
+    );
+  });
+}
+
+let _oldOnErrorHandler = null;
+/** JSDoc */
+function instrumentError() {
+  _oldOnErrorHandler = WINDOW.onerror;
+
+  WINDOW.onerror = function (msg, url, line, column, error) {
+    triggerHandlers('error', {
+      column,
+      error,
+      line,
+      msg,
+      url,
+    });
+
+    if (_oldOnErrorHandler && !_oldOnErrorHandler.__SENTRY_LOADER__) {
+      // eslint-disable-next-line prefer-rest-params
+      return _oldOnErrorHandler.apply(this, arguments);
+    }
+
+    return false;
+  };
+
+  WINDOW.onerror.__SENTRY_INSTRUMENTED__ = true;
+}
+
+let _oldOnUnhandledRejectionHandler = null;
+/** JSDoc */
+function instrumentUnhandledRejection() {
+  _oldOnUnhandledRejectionHandler = WINDOW.onunhandledrejection;
+
+  WINDOW.onunhandledrejection = function (e) {
+    triggerHandlers('unhandledrejection', e);
+
+    if (_oldOnUnhandledRejectionHandler && !_oldOnUnhandledRejectionHandler.__SENTRY_LOADER__) {
+      // eslint-disable-next-line prefer-rest-params
+      return _oldOnUnhandledRejectionHandler.apply(this, arguments);
+    }
+
+    return true;
+  };
+
+  WINDOW.onunhandledrejection.__SENTRY_INSTRUMENTED__ = true;
+}
+
+export { SENTRY_XHR_DATA_KEY, addInstrumentationHandler, instrumentDOM, instrumentXHR, parseFetchArgs, resetInstrumentationHandlers };
+//# sourceMappingURL=instrument.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/is.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/is.js
new file mode 100644
index 0000000..2ed8c2e
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/is.js
@@ -0,0 +1,190 @@
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const objectToString = Object.prototype.toString;
+
+/**
+ * Checks whether given value's type is one of a few Error or Error-like
+ * {@link isError}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isError(wat) {
+  switch (objectToString.call(wat)) {
+    case '[object Error]':
+    case '[object Exception]':
+    case '[object DOMException]':
+      return true;
+    default:
+      return isInstanceOf(wat, Error);
+  }
+}
+/**
+ * Checks whether given value is an instance of the given built-in class.
+ *
+ * @param wat The value to be checked
+ * @param className
+ * @returns A boolean representing the result.
+ */
+function isBuiltin(wat, className) {
+  return objectToString.call(wat) === `[object ${className}]`;
+}
+
+/**
+ * Checks whether given value's type is ErrorEvent
+ * {@link isErrorEvent}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isErrorEvent(wat) {
+  return isBuiltin(wat, 'ErrorEvent');
+}
+
+/**
+ * Checks whether given value's type is DOMError
+ * {@link isDOMError}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isDOMError(wat) {
+  return isBuiltin(wat, 'DOMError');
+}
+
+/**
+ * Checks whether given value's type is DOMException
+ * {@link isDOMException}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isDOMException(wat) {
+  return isBuiltin(wat, 'DOMException');
+}
+
+/**
+ * Checks whether given value's type is a string
+ * {@link isString}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isString(wat) {
+  return isBuiltin(wat, 'String');
+}
+
+/**
+ * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)
+ * {@link isPrimitive}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isPrimitive(wat) {
+  return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');
+}
+
+/**
+ * Checks whether given value's type is an object literal
+ * {@link isPlainObject}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isPlainObject(wat) {
+  return isBuiltin(wat, 'Object');
+}
+
+/**
+ * Checks whether given value's type is an Event instance
+ * {@link isEvent}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isEvent(wat) {
+  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);
+}
+
+/**
+ * Checks whether given value's type is an Element instance
+ * {@link isElement}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isElement(wat) {
+  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);
+}
+
+/**
+ * Checks whether given value's type is an regexp
+ * {@link isRegExp}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isRegExp(wat) {
+  return isBuiltin(wat, 'RegExp');
+}
+
+/**
+ * Checks whether given value has a then function.
+ * @param wat A value to be checked.
+ */
+function isThenable(wat) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  return Boolean(wat && wat.then && typeof wat.then === 'function');
+}
+
+/**
+ * Checks whether given value's type is a SyntheticEvent
+ * {@link isSyntheticEvent}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isSyntheticEvent(wat) {
+  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;
+}
+
+/**
+ * Checks whether given value is NaN
+ * {@link isNaN}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isNaN(wat) {
+  return typeof wat === 'number' && wat !== wat;
+}
+
+/**
+ * Checks whether given value's type is an instance of provided constructor.
+ * {@link isInstanceOf}.
+ *
+ * @param wat A value to be checked.
+ * @param base A constructor to be used in a check.
+ * @returns A boolean representing the result.
+ */
+function isInstanceOf(wat, base) {
+  try {
+    return wat instanceof base;
+  } catch (_e) {
+    return false;
+  }
+}
+
+/**
+ * Checks whether given value's type is a Vue ViewModel.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isVueViewModel(wat) {
+  // Not using Object.prototype.toString because in Vue 3 it would read the instance's Symbol(Symbol.toStringTag) property.
+  return !!(typeof wat === 'object' && wat !== null && ((wat ).__isVue || (wat )._isVue));
+}
+
+export { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isNaN, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable, isVueViewModel };
+//# sourceMappingURL=is.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/logger.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/logger.js
new file mode 100644
index 0000000..efa35e4
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/logger.js
@@ -0,0 +1,82 @@
+import { GLOBAL_OBJ } from './worldwide.js';
+
+/** Prefix for logging strings */
+const PREFIX = 'Sentry Logger ';
+
+const CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] ;
+
+/** This may be mutated by the console instrumentation. */
+const originalConsoleMethods
+
+ = {};
+
+/** JSDoc */
+
+/**
+ * Temporarily disable sentry console instrumentations.
+ *
+ * @param callback The function to run against the original `console` messages
+ * @returns The results of the callback
+ */
+function consoleSandbox(callback) {
+  if (!('console' in GLOBAL_OBJ)) {
+    return callback();
+  }
+
+  const console = GLOBAL_OBJ.console ;
+  const wrappedFuncs = {};
+
+  const wrappedLevels = Object.keys(originalConsoleMethods) ;
+
+  // Restore all wrapped console methods
+  wrappedLevels.forEach(level => {
+    const originalConsoleMethod = originalConsoleMethods[level] ;
+    wrappedFuncs[level] = console[level] ;
+    console[level] = originalConsoleMethod;
+  });
+
+  try {
+    return callback();
+  } finally {
+    // Revert restoration to wrapped state
+    wrappedLevels.forEach(level => {
+      console[level] = wrappedFuncs[level] ;
+    });
+  }
+}
+
+function makeLogger() {
+  let enabled = false;
+  const logger = {
+    enable: () => {
+      enabled = true;
+    },
+    disable: () => {
+      enabled = false;
+    },
+  };
+
+  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+    CONSOLE_LEVELS.forEach(name => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      logger[name] = (...args) => {
+        if (enabled) {
+          consoleSandbox(() => {
+            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);
+          });
+        }
+      };
+    });
+  } else {
+    CONSOLE_LEVELS.forEach(name => {
+      logger[name] = () => undefined;
+    });
+  }
+
+  return logger ;
+}
+
+const logger = makeLogger();
+
+export { CONSOLE_LEVELS, consoleSandbox, logger, originalConsoleMethods };
+//# sourceMappingURL=logger.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/memo.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/memo.js
new file mode 100644
index 0000000..fe00c9c
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/memo.js
@@ -0,0 +1,45 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/**
+ * Helper to decycle json objects
+ */
+function memoBuilder() {
+  const hasWeakSet = typeof WeakSet === 'function';
+  const inner = hasWeakSet ? new WeakSet() : [];
+  function memoize(obj) {
+    if (hasWeakSet) {
+      if (inner.has(obj)) {
+        return true;
+      }
+      inner.add(obj);
+      return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let i = 0; i < inner.length; i++) {
+      const value = inner[i];
+      if (value === obj) {
+        return true;
+      }
+    }
+    inner.push(obj);
+    return false;
+  }
+
+  function unmemoize(obj) {
+    if (hasWeakSet) {
+      inner.delete(obj);
+    } else {
+      for (let i = 0; i < inner.length; i++) {
+        if (inner[i] === obj) {
+          inner.splice(i, 1);
+          break;
+        }
+      }
+    }
+  }
+  return [memoize, unmemoize];
+}
+
+export { memoBuilder };
+//# sourceMappingURL=memo.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/misc.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/misc.js
new file mode 100644
index 0000000..5685693
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/misc.js
@@ -0,0 +1,203 @@
+import { addNonEnumerableProperty } from './object.js';
+import { snipLine } from './string.js';
+import { GLOBAL_OBJ } from './worldwide.js';
+
+/**
+ * UUID4 generator
+ *
+ * @returns string Generated UUID4.
+ */
+function uuid4() {
+  const gbl = GLOBAL_OBJ ;
+  const crypto = gbl.crypto || gbl.msCrypto;
+
+  let getRandomByte = () => Math.random() * 16;
+  try {
+    if (crypto && crypto.randomUUID) {
+      return crypto.randomUUID().replace(/-/g, '');
+    }
+    if (crypto && crypto.getRandomValues) {
+      getRandomByte = () => crypto.getRandomValues(new Uint8Array(1))[0];
+    }
+  } catch (_) {
+    // some runtimes can crash invoking crypto
+    // https://github.com/getsentry/sentry-javascript/issues/8935
+  }
+
+  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
+  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'
+  return (([1e7] ) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>
+    // eslint-disable-next-line no-bitwise
+    ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),
+  );
+}
+
+function getFirstException(event) {
+  return event.exception && event.exception.values ? event.exception.values[0] : undefined;
+}
+
+/**
+ * Extracts either message or type+value from an event that can be used for user-facing logs
+ * @returns event's description
+ */
+function getEventDescription(event) {
+  const { message, event_id: eventId } = event;
+  if (message) {
+    return message;
+  }
+
+  const firstException = getFirstException(event);
+  if (firstException) {
+    if (firstException.type && firstException.value) {
+      return `${firstException.type}: ${firstException.value}`;
+    }
+    return firstException.type || firstException.value || eventId || '<unknown>';
+  }
+  return eventId || '<unknown>';
+}
+
+/**
+ * Adds exception values, type and value to an synthetic Exception.
+ * @param event The event to modify.
+ * @param value Value of the exception.
+ * @param type Type of the exception.
+ * @hidden
+ */
+function addExceptionTypeValue(event, value, type) {
+  const exception = (event.exception = event.exception || {});
+  const values = (exception.values = exception.values || []);
+  const firstException = (values[0] = values[0] || {});
+  if (!firstException.value) {
+    firstException.value = value || '';
+  }
+  if (!firstException.type) {
+    firstException.type = type || 'Error';
+  }
+}
+
+/**
+ * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.
+ *
+ * @param event The event to modify.
+ * @param newMechanism Mechanism data to add to the event.
+ * @hidden
+ */
+function addExceptionMechanism(event, newMechanism) {
+  const firstException = getFirstException(event);
+  if (!firstException) {
+    return;
+  }
+
+  const defaultMechanism = { type: 'generic', handled: true };
+  const currentMechanism = firstException.mechanism;
+  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };
+
+  if (newMechanism && 'data' in newMechanism) {
+    const mergedData = { ...(currentMechanism && currentMechanism.data), ...newMechanism.data };
+    firstException.mechanism.data = mergedData;
+  }
+}
+
+// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+const SEMVER_REGEXP =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+
+/**
+ * Represents Semantic Versioning object
+ */
+
+/**
+ * Parses input into a SemVer interface
+ * @param input string representation of a semver version
+ */
+function parseSemver(input) {
+  const match = input.match(SEMVER_REGEXP) || [];
+  const major = parseInt(match[1], 10);
+  const minor = parseInt(match[2], 10);
+  const patch = parseInt(match[3], 10);
+  return {
+    buildmetadata: match[5],
+    major: isNaN(major) ? undefined : major,
+    minor: isNaN(minor) ? undefined : minor,
+    patch: isNaN(patch) ? undefined : patch,
+    prerelease: match[4],
+  };
+}
+
+/**
+ * This function adds context (pre/post/line) lines to the provided frame
+ *
+ * @param lines string[] containing all lines
+ * @param frame StackFrame that will be mutated
+ * @param linesOfContext number of context lines we want to add pre/post
+ */
+function addContextToFrame(lines, frame, linesOfContext = 5) {
+  // When there is no line number in the frame, attaching context is nonsensical and will even break grouping
+  if (frame.lineno === undefined) {
+    return;
+  }
+
+  const maxLines = lines.length;
+  const sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0);
+
+  frame.pre_context = lines
+    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)
+    .map((line) => snipLine(line, 0));
+
+  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);
+
+  frame.post_context = lines
+    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)
+    .map((line) => snipLine(line, 0));
+}
+
+/**
+ * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object
+ * in question), and marks it captured if not.
+ *
+ * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and
+ * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so
+ * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because
+ * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not
+ * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This
+ * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we
+ * see it.
+ *
+ * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on
+ * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent
+ * object wrapper forms so that this check will always work. However, because we need to flag the exact object which
+ * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification
+ * must be done before the exception captured.
+ *
+ * @param A thrown exception to check or flag as having been seen
+ * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)
+ */
+function checkOrSetAlreadyCaught(exception) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  if (exception && (exception ).__sentry_captured__) {
+    return true;
+  }
+
+  try {
+    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the
+    // `ExtraErrorData` integration
+    addNonEnumerableProperty(exception , '__sentry_captured__', true);
+  } catch (err) {
+    // `exception` is a primitive, so we can't mark it seen
+  }
+
+  return false;
+}
+
+/**
+ * Checks whether the given input is already an array, and if it isn't, wraps it in one.
+ *
+ * @param maybeArray Input to turn into an array, if necessary
+ * @returns The input, if already an array, or an array with the input as the only element, if not
+ */
+function arrayify(maybeArray) {
+  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];
+}
+
+export { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, arrayify, checkOrSetAlreadyCaught, getEventDescription, parseSemver, uuid4 };
+//# sourceMappingURL=misc.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/node.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/node.js
new file mode 100644
index 0000000..49eb7d7
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/node.js
@@ -0,0 +1,66 @@
+import { isBrowserBundle } from './env.js';
+
+/**
+ * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,
+ * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.
+ */
+
+/**
+ * Checks whether we're in the Node.js or Browser environment
+ *
+ * @returns Answer to given question
+ */
+function isNodeEnv() {
+  // explicitly check for browser bundles as those can be optimized statically
+  // by terser/rollup.
+  return (
+    !isBrowserBundle() &&
+    Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'
+  );
+}
+
+/**
+ * Requires a module which is protected against bundler minification.
+ *
+ * @param request The module path to resolve
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+function dynamicRequire(mod, request) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  return mod.require(request);
+}
+
+/**
+ * Helper for dynamically loading module that should work with linked dependencies.
+ * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`
+ * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during
+ * build time. `require.resolve` is also not available in any other way, so we cannot create,
+ * a fake helper like we do with `dynamicRequire`.
+ *
+ * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.
+ * That is to mimic the behavior of `require.resolve` exactly.
+ *
+ * @param moduleName module name to require
+ * @returns possibly required module
+ */
+function loadModule(moduleName) {
+  let mod;
+
+  try {
+    mod = dynamicRequire(module, moduleName);
+  } catch (e) {
+    // no-empty
+  }
+
+  try {
+    const { cwd } = dynamicRequire(module, 'process');
+    mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) ;
+  } catch (e) {
+    // no-empty
+  }
+
+  return mod;
+}
+
+export { dynamicRequire, isNodeEnv, loadModule };
+//# sourceMappingURL=node.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/normalize.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/normalize.js
new file mode 100644
index 0000000..a8a81ee
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/normalize.js
@@ -0,0 +1,267 @@
+import { isNaN, isVueViewModel, isSyntheticEvent } from './is.js';
+import { memoBuilder } from './memo.js';
+import { convertToPlainObject } from './object.js';
+import { getFunctionName } from './stacktrace.js';
+
+/**
+ * Recursively normalizes the given object.
+ *
+ * - Creates a copy to prevent original input mutation
+ * - Skips non-enumerable properties
+ * - When stringifying, calls `toJSON` if implemented
+ * - Removes circular references
+ * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format
+ * - Translates known global objects/classes to a string representations
+ * - Takes care of `Error` object serialization
+ * - Optionally limits depth of final output
+ * - Optionally limits number of properties/elements included in any single object/array
+ *
+ * @param input The object to be normalized.
+ * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)
+ * @param maxProperties The max number of elements or properties to be included in any single array or
+ * object in the normallized output.
+ * @returns A normalized version of the object, or `"**non-serializable**"` if any errors are thrown during normalization.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function normalize(input, depth = 100, maxProperties = +Infinity) {
+  try {
+    // since we're at the outermost level, we don't provide a key
+    return visit('', input, depth, maxProperties);
+  } catch (err) {
+    return { ERROR: `**non-serializable** (${err})` };
+  }
+}
+
+/** JSDoc */
+function normalizeToSize(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  object,
+  // Default Node.js REPL depth
+  depth = 3,
+  // 100kB, as 200kB is max payload size, so half sounds reasonable
+  maxSize = 100 * 1024,
+) {
+  const normalized = normalize(object, depth);
+
+  if (jsonSize(normalized) > maxSize) {
+    return normalizeToSize(object, depth - 1, maxSize);
+  }
+
+  return normalized ;
+}
+
+/**
+ * Visits a node to perform normalization on it
+ *
+ * @param key The key corresponding to the given node
+ * @param value The node to be visited
+ * @param depth Optional number indicating the maximum recursion depth
+ * @param maxProperties Optional maximum number of properties/elements included in any single object/array
+ * @param memo Optional Memo class handling decycling
+ */
+function visit(
+  key,
+  value,
+  depth = +Infinity,
+  maxProperties = +Infinity,
+  memo = memoBuilder(),
+) {
+  const [memoize, unmemoize] = memo;
+
+  // Get the simple cases out of the way first
+  if (
+    value == null || // this matches null and undefined -> eqeq not eqeqeq
+    (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))
+  ) {
+    return value ;
+  }
+
+  const stringified = stringifyValue(key, value);
+
+  // Anything we could potentially dig into more (objects or arrays) will have come back as `"[object XXXX]"`.
+  // Everything else will have already been serialized, so if we don't see that pattern, we're done.
+  if (!stringified.startsWith('[object ')) {
+    return stringified;
+  }
+
+  // From here on, we can assert that `value` is either an object or an array.
+
+  // Do not normalize objects that we know have already been normalized. As a general rule, the
+  // "__sentry_skip_normalization__" property should only be used sparingly and only should only be set on objects that
+  // have already been normalized.
+  if ((value )['__sentry_skip_normalization__']) {
+    return value ;
+  }
+
+  // We can set `__sentry_override_normalization_depth__` on an object to ensure that from there
+  // We keep a certain amount of depth.
+  // This should be used sparingly, e.g. we use it for the redux integration to ensure we get a certain amount of state.
+  const remainingDepth =
+    typeof (value )['__sentry_override_normalization_depth__'] === 'number'
+      ? ((value )['__sentry_override_normalization_depth__'] )
+      : depth;
+
+  // We're also done if we've reached the max depth
+  if (remainingDepth === 0) {
+    // At this point we know `serialized` is a string of the form `"[object XXXX]"`. Clean it up so it's just `"[XXXX]"`.
+    return stringified.replace('object ', '');
+  }
+
+  // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.
+  if (memoize(value)) {
+    return '[Circular ~]';
+  }
+
+  // If the value has a `toJSON` method, we call it to extract more information
+  const valueWithToJSON = value ;
+  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {
+    try {
+      const jsonValue = valueWithToJSON.toJSON();
+      // We need to normalize the return value of `.toJSON()` in case it has circular references
+      return visit('', jsonValue, remainingDepth - 1, maxProperties, memo);
+    } catch (err) {
+      // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)
+    }
+  }
+
+  // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse
+  // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each
+  // property/entry, and keep track of the number of items we add to it.
+  const normalized = (Array.isArray(value) ? [] : {}) ;
+  let numAdded = 0;
+
+  // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant
+  // properties are non-enumerable and otherwise would get missed.
+  const visitable = convertToPlainObject(value );
+
+  for (const visitKey in visitable) {
+    // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.
+    if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {
+      continue;
+    }
+
+    if (numAdded >= maxProperties) {
+      normalized[visitKey] = '[MaxProperties ~]';
+      break;
+    }
+
+    // Recursively visit all the child nodes
+    const visitValue = visitable[visitKey];
+    normalized[visitKey] = visit(visitKey, visitValue, remainingDepth - 1, maxProperties, memo);
+
+    numAdded++;
+  }
+
+  // Once we've visited all the branches, remove the parent from memo storage
+  unmemoize(value);
+
+  // Return accumulated values
+  return normalized;
+}
+
+/* eslint-disable complexity */
+/**
+ * Stringify the given value. Handles various known special values and types.
+ *
+ * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn
+ * the number 1231 into "[Object Number]", nor on `null`, as it will throw.
+ *
+ * @param value The value to stringify
+ * @returns A stringified representation of the given value
+ */
+function stringifyValue(
+  key,
+  // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for
+  // our internal use, it'll do
+  value,
+) {
+  try {
+    if (key === 'domain' && value && typeof value === 'object' && (value )._events) {
+      return '[Domain]';
+    }
+
+    if (key === 'domainEmitter') {
+      return '[DomainEmitter]';
+    }
+
+    // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first
+    // which won't throw if they are not present.
+
+    if (typeof global !== 'undefined' && value === global) {
+      return '[Global]';
+    }
+
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof window !== 'undefined' && value === window) {
+      return '[Window]';
+    }
+
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof document !== 'undefined' && value === document) {
+      return '[Document]';
+    }
+
+    if (isVueViewModel(value)) {
+      return '[VueViewModel]';
+    }
+
+    // React's SyntheticEvent thingy
+    if (isSyntheticEvent(value)) {
+      return '[SyntheticEvent]';
+    }
+
+    if (typeof value === 'number' && value !== value) {
+      return '[NaN]';
+    }
+
+    if (typeof value === 'function') {
+      return `[Function: ${getFunctionName(value)}]`;
+    }
+
+    if (typeof value === 'symbol') {
+      return `[${String(value)}]`;
+    }
+
+    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion
+    if (typeof value === 'bigint') {
+      return `[BigInt: ${String(value)}]`;
+    }
+
+    // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting
+    // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as
+    // `"[object Object]"`. If we instead look at the constructor's name (which is the same as the name of the class),
+    // we can make sure that only plain objects come out that way.
+    const objName = getConstructorName(value);
+
+    // Handle HTML Elements
+    if (/^HTML(\w*)Element$/.test(objName)) {
+      return `[HTMLElement: ${objName}]`;
+    }
+
+    return `[object ${objName}]`;
+  } catch (err) {
+    return `**non-serializable** (${err})`;
+  }
+}
+/* eslint-enable complexity */
+
+function getConstructorName(value) {
+  const prototype = Object.getPrototypeOf(value);
+
+  return prototype ? prototype.constructor.name : 'null prototype';
+}
+
+/** Calculates bytes size of input string */
+function utf8Length(value) {
+  // eslint-disable-next-line no-bitwise
+  return ~-encodeURI(value).split(/%..|./).length;
+}
+
+/** Calculates bytes size of input object */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function jsonSize(value) {
+  return utf8Length(JSON.stringify(value));
+}
+
+export { normalize, normalizeToSize, visit as walk };
+//# sourceMappingURL=normalize.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/object.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/object.js
new file mode 100644
index 0000000..58706b7
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/object.js
@@ -0,0 +1,281 @@
+import { htmlTreeAsString } from './browser.js';
+import { isError, isEvent, isInstanceOf, isElement, isPlainObject, isPrimitive } from './is.js';
+import { logger } from './logger.js';
+import { truncate } from './string.js';
+
+/**
+ * Replace a method in an object with a wrapped version of itself.
+ *
+ * @param source An object that contains a method to be wrapped.
+ * @param name The name of the method to be wrapped.
+ * @param replacementFactory A higher-order function that takes the original version of the given method and returns a
+ * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to
+ * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other
+ * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.
+ * @returns void
+ */
+function fill(source, name, replacementFactory) {
+  if (!(name in source)) {
+    return;
+  }
+
+  const original = source[name] ;
+  const wrapped = replacementFactory(original) ;
+
+  // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work
+  // otherwise it'll throw "TypeError: Object.defineProperties called on non-object"
+  if (typeof wrapped === 'function') {
+    markFunctionWrapped(wrapped, original);
+  }
+
+  source[name] = wrapped;
+}
+
+/**
+ * Defines a non-enumerable property on the given object.
+ *
+ * @param obj The object on which to set the property
+ * @param name The name of the property to be set
+ * @param value The value to which to set the property
+ */
+function addNonEnumerableProperty(obj, name, value) {
+  try {
+    Object.defineProperty(obj, name, {
+      // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it
+      value: value,
+      writable: true,
+      configurable: true,
+    });
+  } catch (o_O) {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Failed to add non-enumerable property "${name}" to object`, obj);
+  }
+}
+
+/**
+ * Remembers the original function on the wrapped function and
+ * patches up the prototype.
+ *
+ * @param wrapped the wrapper function
+ * @param original the original function that gets wrapped
+ */
+function markFunctionWrapped(wrapped, original) {
+  try {
+    const proto = original.prototype || {};
+    wrapped.prototype = original.prototype = proto;
+    addNonEnumerableProperty(wrapped, '__sentry_original__', original);
+  } catch (o_O) {} // eslint-disable-line no-empty
+}
+
+/**
+ * This extracts the original function if available.  See
+ * `markFunctionWrapped` for more information.
+ *
+ * @param func the function to unwrap
+ * @returns the unwrapped version of the function if available.
+ */
+function getOriginalFunction(func) {
+  return func.__sentry_original__;
+}
+
+/**
+ * Encodes given object into url-friendly format
+ *
+ * @param object An object that contains serializable values
+ * @returns string Encoded
+ */
+function urlEncode(object) {
+  return Object.keys(object)
+    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`)
+    .join('&');
+}
+
+/**
+ * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their
+ * non-enumerable properties attached.
+ *
+ * @param value Initial source that we have to transform in order for it to be usable by the serializer
+ * @returns An Event or Error turned into an object - or the value argurment itself, when value is neither an Event nor
+ *  an Error.
+ */
+function convertToPlainObject(value)
+
+ {
+  if (isError(value)) {
+    return {
+      message: value.message,
+      name: value.name,
+      stack: value.stack,
+      ...getOwnProperties(value),
+    };
+  } else if (isEvent(value)) {
+    const newObj
+
+ = {
+      type: value.type,
+      target: serializeEventTarget(value.target),
+      currentTarget: serializeEventTarget(value.currentTarget),
+      ...getOwnProperties(value),
+    };
+
+    if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {
+      newObj.detail = value.detail;
+    }
+
+    return newObj;
+  } else {
+    return value;
+  }
+}
+
+/** Creates a string representation of the target of an `Event` object */
+function serializeEventTarget(target) {
+  try {
+    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);
+  } catch (_oO) {
+    return '<unknown>';
+  }
+}
+
+/** Filters out all but an object's own properties */
+function getOwnProperties(obj) {
+  if (typeof obj === 'object' && obj !== null) {
+    const extractedProps = {};
+    for (const property in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, property)) {
+        extractedProps[property] = (obj )[property];
+      }
+    }
+    return extractedProps;
+  } else {
+    return {};
+  }
+}
+
+/**
+ * Given any captured exception, extract its keys and create a sorted
+ * and truncated list that will be used inside the event message.
+ * eg. `Non-error exception captured with keys: foo, bar, baz`
+ */
+function extractExceptionKeysForMessage(exception, maxLength = 40) {
+  const keys = Object.keys(convertToPlainObject(exception));
+  keys.sort();
+
+  if (!keys.length) {
+    return '[object has no keys]';
+  }
+
+  if (keys[0].length >= maxLength) {
+    return truncate(keys[0], maxLength);
+  }
+
+  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {
+    const serialized = keys.slice(0, includedKeys).join(', ');
+    if (serialized.length > maxLength) {
+      continue;
+    }
+    if (includedKeys === keys.length) {
+      return serialized;
+    }
+    return truncate(serialized, maxLength);
+  }
+
+  return '';
+}
+
+/**
+ * Given any object, return a new object having removed all fields whose value was `undefined`.
+ * Works recursively on objects and arrays.
+ *
+ * Attention: This function keeps circular references in the returned object.
+ */
+function dropUndefinedKeys(inputValue) {
+  // This map keeps track of what already visited nodes map to.
+  // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular
+  // references as the input object.
+  const memoizationMap = new Map();
+
+  // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API
+  return _dropUndefinedKeys(inputValue, memoizationMap);
+}
+
+function _dropUndefinedKeys(inputValue, memoizationMap) {
+  if (isPlainObject(inputValue)) {
+    // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object
+    const memoVal = memoizationMap.get(inputValue);
+    if (memoVal !== undefined) {
+      return memoVal ;
+    }
+
+    const returnValue = {};
+    // Store the mapping of this value in case we visit it again, in case of circular data
+    memoizationMap.set(inputValue, returnValue);
+
+    for (const key of Object.keys(inputValue)) {
+      if (typeof inputValue[key] !== 'undefined') {
+        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);
+      }
+    }
+
+    return returnValue ;
+  }
+
+  if (Array.isArray(inputValue)) {
+    // If this node has already been visited due to a circular reference, return the array it was mapped to in the new object
+    const memoVal = memoizationMap.get(inputValue);
+    if (memoVal !== undefined) {
+      return memoVal ;
+    }
+
+    const returnValue = [];
+    // Store the mapping of this value in case we visit it again, in case of circular data
+    memoizationMap.set(inputValue, returnValue);
+
+    inputValue.forEach((item) => {
+      returnValue.push(_dropUndefinedKeys(item, memoizationMap));
+    });
+
+    return returnValue ;
+  }
+
+  return inputValue;
+}
+
+/**
+ * Ensure that something is an object.
+ *
+ * Turns `undefined` and `null` into `String`s and all other primitives into instances of their respective wrapper
+ * classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.
+ *
+ * @param wat The subject of the objectification
+ * @returns A version of `wat` which can safely be used with `Object` class methods
+ */
+function objectify(wat) {
+  let objectified;
+  switch (true) {
+    case wat === undefined || wat === null:
+      objectified = new String(wat);
+      break;
+
+    // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason
+    // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as
+    // an object in order to wrap it.
+    case typeof wat === 'symbol' || typeof wat === 'bigint':
+      objectified = Object(wat);
+      break;
+
+    // this will catch the remaining primitives: `String`, `Number`, and `Boolean`
+    case isPrimitive(wat):
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      objectified = new (wat ).constructor(wat);
+      break;
+
+    // by process of elimination, at this point we know that `wat` must already be an object
+    default:
+      objectified = wat;
+      break;
+  }
+  return objectified;
+}
+
+export { addNonEnumerableProperty, convertToPlainObject, dropUndefinedKeys, extractExceptionKeysForMessage, fill, getOriginalFunction, markFunctionWrapped, objectify, urlEncode };
+//# sourceMappingURL=object.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/stacktrace.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/stacktrace.js
new file mode 100644
index 0000000..4ea2d17
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/stacktrace.js
@@ -0,0 +1,147 @@
+import { node } from './node-stack-trace.js';
+
+const STACKTRACE_FRAME_LIMIT = 50;
+// Used to sanitize webpack (error: *) wrapped stack errors
+const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
+const STRIP_FRAME_REGEXP = /captureMessage|captureException/;
+
+/**
+ * Creates a stack parser with the supplied line parsers
+ *
+ * StackFrames are returned in the correct order for Sentry Exception
+ * frames and with Sentry SDK internal frames removed from the top and bottom
+ *
+ */
+function createStackParser(...parsers) {
+  const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);
+
+  return (stack, skipFirst = 0) => {
+    const frames = [];
+    const lines = stack.split('\n');
+
+    for (let i = skipFirst; i < lines.length; i++) {
+      const line = lines[i];
+      // Ignore lines over 1kb as they are unlikely to be stack frames.
+      // Many of the regular expressions use backtracking which results in run time that increases exponentially with
+      // input size. Huge strings can result in hangs/Denial of Service:
+      // https://github.com/getsentry/sentry-javascript/issues/2286
+      if (line.length > 1024) {
+        continue;
+      }
+
+      // https://github.com/getsentry/sentry-javascript/issues/5459
+      // Remove webpack (error: *) wrappers
+      const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;
+
+      // https://github.com/getsentry/sentry-javascript/issues/7813
+      // Skip Error: lines
+      if (cleanedLine.match(/\S*Error: /)) {
+        continue;
+      }
+
+      for (const parser of sortedParsers) {
+        const frame = parser(cleanedLine);
+
+        if (frame) {
+          frames.push(frame);
+          break;
+        }
+      }
+
+      if (frames.length >= STACKTRACE_FRAME_LIMIT) {
+        break;
+      }
+    }
+
+    return stripSentryFramesAndReverse(frames);
+  };
+}
+
+/**
+ * Gets a stack parser implementation from Options.stackParser
+ * @see Options
+ *
+ * If options contains an array of line parsers, it is converted into a parser
+ */
+function stackParserFromStackParserOptions(stackParser) {
+  if (Array.isArray(stackParser)) {
+    return createStackParser(...stackParser);
+  }
+  return stackParser;
+}
+
+/**
+ * Removes Sentry frames from the top and bottom of the stack if present and enforces a limit of max number of frames.
+ * Assumes stack input is ordered from top to bottom and returns the reverse representation so call site of the
+ * function that caused the crash is the last frame in the array.
+ * @hidden
+ */
+function stripSentryFramesAndReverse(stack) {
+  if (!stack.length) {
+    return [];
+  }
+
+  const localStack = Array.from(stack);
+
+  // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)
+  if (/sentryWrapped/.test(localStack[localStack.length - 1].function || '')) {
+    localStack.pop();
+  }
+
+  // Reversing in the middle of the procedure allows us to just pop the values off the stack
+  localStack.reverse();
+
+  // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)
+  if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {
+    localStack.pop();
+
+    // When using synthetic events, we will have a 2 levels deep stack, as `new Error('Sentry syntheticException')`
+    // is produced within the hub itself, making it:
+    //
+    //   Sentry.captureException()
+    //   getCurrentHub().captureException()
+    //
+    // instead of just the top `Sentry` call itself.
+    // This forces us to possibly strip an additional frame in the exact same was as above.
+    if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {
+      localStack.pop();
+    }
+  }
+
+  return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map(frame => ({
+    ...frame,
+    filename: frame.filename || localStack[localStack.length - 1].filename,
+    function: frame.function || '?',
+  }));
+}
+
+const defaultFunctionName = '<anonymous>';
+
+/**
+ * Safely extract function name from itself
+ */
+function getFunctionName(fn) {
+  try {
+    if (!fn || typeof fn !== 'function') {
+      return defaultFunctionName;
+    }
+    return fn.name || defaultFunctionName;
+  } catch (e) {
+    // Just accessing custom props in some Selenium environments
+    // can cause a "Permission denied" exception (see raven-js#495).
+    return defaultFunctionName;
+  }
+}
+
+/**
+ * Node.js stack line parser
+ *
+ * This is in @sentry/utils so it can be used from the Electron SDK in the browser for when `nodeIntegration == true`.
+ * This allows it to be used without referencing or importing any node specific code which causes bundlers to complain
+ */
+function nodeStackLineParser(getModule) {
+  return [90, node(getModule)];
+}
+
+export { createStackParser, getFunctionName, nodeStackLineParser, stackParserFromStackParserOptions, stripSentryFramesAndReverse };
+//# sourceMappingURL=stacktrace.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/string.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/string.js
new file mode 100644
index 0000000..b6d3514
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/string.js
@@ -0,0 +1,141 @@
+import { isVueViewModel, isString, isRegExp } from './is.js';
+
+/**
+ * Truncates given string to the maximum characters count
+ *
+ * @param str An object that contains serializable values
+ * @param max Maximum number of characters in truncated string (0 = unlimited)
+ * @returns string Encoded
+ */
+function truncate(str, max = 0) {
+  if (typeof str !== 'string' || max === 0) {
+    return str;
+  }
+  return str.length <= max ? str : `${str.slice(0, max)}...`;
+}
+
+/**
+ * This is basically just `trim_line` from
+ * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67
+ *
+ * @param str An object that contains serializable values
+ * @param max Maximum number of characters in truncated string
+ * @returns string Encoded
+ */
+function snipLine(line, colno) {
+  let newLine = line;
+  const lineLength = newLine.length;
+  if (lineLength <= 150) {
+    return newLine;
+  }
+  if (colno > lineLength) {
+    // eslint-disable-next-line no-param-reassign
+    colno = lineLength;
+  }
+
+  let start = Math.max(colno - 60, 0);
+  if (start < 5) {
+    start = 0;
+  }
+
+  let end = Math.min(start + 140, lineLength);
+  if (end > lineLength - 5) {
+    end = lineLength;
+  }
+  if (end === lineLength) {
+    start = Math.max(end - 140, 0);
+  }
+
+  newLine = newLine.slice(start, end);
+  if (start > 0) {
+    newLine = `'{snip} ${newLine}`;
+  }
+  if (end < lineLength) {
+    newLine += ' {snip}';
+  }
+
+  return newLine;
+}
+
+/**
+ * Join values in array
+ * @param input array of values to be joined together
+ * @param delimiter string to be placed in-between values
+ * @returns Joined values
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function safeJoin(input, delimiter) {
+  if (!Array.isArray(input)) {
+    return '';
+  }
+
+  const output = [];
+  // eslint-disable-next-line @typescript-eslint/prefer-for-of
+  for (let i = 0; i < input.length; i++) {
+    const value = input[i];
+    try {
+      // This is a hack to fix a Vue3-specific bug that causes an infinite loop of
+      // console warnings. This happens when a Vue template is rendered with
+      // an undeclared variable, which we try to stringify, ultimately causing
+      // Vue to issue another warning which repeats indefinitely.
+      // see: https://github.com/getsentry/sentry-javascript/pull/8981
+      if (isVueViewModel(value)) {
+        output.push('[VueViewModel]');
+      } else {
+        output.push(String(value));
+      }
+    } catch (e) {
+      output.push('[value cannot be serialized]');
+    }
+  }
+
+  return output.join(delimiter);
+}
+
+/**
+ * Checks if the given value matches a regex or string
+ *
+ * @param value The string to test
+ * @param pattern Either a regex or a string against which `value` will be matched
+ * @param requireExactStringMatch If true, `value` must match `pattern` exactly. If false, `value` will match
+ * `pattern` if it contains `pattern`. Only applies to string-type patterns.
+ */
+function isMatchingPattern(
+  value,
+  pattern,
+  requireExactStringMatch = false,
+) {
+  if (!isString(value)) {
+    return false;
+  }
+
+  if (isRegExp(pattern)) {
+    return pattern.test(value);
+  }
+  if (isString(pattern)) {
+    return requireExactStringMatch ? value === pattern : value.includes(pattern);
+  }
+
+  return false;
+}
+
+/**
+ * Test the given string against an array of strings and regexes. By default, string matching is done on a
+ * substring-inclusion basis rather than a strict equality basis
+ *
+ * @param testString The string to test
+ * @param patterns The patterns against which to test the string
+ * @param requireExactStringMatch If true, `testString` must match one of the given string patterns exactly in order to
+ * count. If false, `testString` will match a string pattern if it contains that pattern.
+ * @returns
+ */
+function stringMatchesSomePattern(
+  testString,
+  patterns = [],
+  requireExactStringMatch = false,
+) {
+  return patterns.some(pattern => isMatchingPattern(testString, pattern, requireExactStringMatch));
+}
+
+export { isMatchingPattern, safeJoin, snipLine, stringMatchesSomePattern, truncate };
+//# sourceMappingURL=string.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/supports.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/supports.js
new file mode 100644
index 0000000..8e0d9b2
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/supports.js
@@ -0,0 +1,161 @@
+import { logger } from './logger.js';
+import { getGlobalObject } from './worldwide.js';
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+/**
+ * Tells whether current environment supports ErrorEvent objects
+ * {@link supportsErrorEvent}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsErrorEvent() {
+  try {
+    new ErrorEvent('');
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Tells whether current environment supports DOMError objects
+ * {@link supportsDOMError}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsDOMError() {
+  try {
+    // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':
+    // 1 argument required, but only 0 present.
+    // @ts-expect-error It really needs 1 argument, not 0.
+    new DOMError('');
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Tells whether current environment supports DOMException objects
+ * {@link supportsDOMException}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsDOMException() {
+  try {
+    new DOMException('');
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Tells whether current environment supports Fetch API
+ * {@link supportsFetch}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsFetch() {
+  if (!('fetch' in WINDOW)) {
+    return false;
+  }
+
+  try {
+    new Headers();
+    new Request('http://www.example.com');
+    new Response();
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+/**
+ * isNativeFetch checks if the given function is a native implementation of fetch()
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+function isNativeFetch(func) {
+  return func && /^function fetch\(\)\s+\{\s+\[native code\]\s+\}$/.test(func.toString());
+}
+
+/**
+ * Tells whether current environment supports Fetch API natively
+ * {@link supportsNativeFetch}.
+ *
+ * @returns true if `window.fetch` is natively implemented, false otherwise
+ */
+function supportsNativeFetch() {
+  if (!supportsFetch()) {
+    return false;
+  }
+
+  // Fast path to avoid DOM I/O
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  if (isNativeFetch(WINDOW.fetch)) {
+    return true;
+  }
+
+  // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)
+  // so create a "pure" iframe to see if that has native fetch
+  let result = false;
+  const doc = WINDOW.document;
+  // eslint-disable-next-line deprecation/deprecation
+  if (doc && typeof (doc.createElement ) === 'function') {
+    try {
+      const sandbox = doc.createElement('iframe');
+      sandbox.hidden = true;
+      doc.head.appendChild(sandbox);
+      if (sandbox.contentWindow && sandbox.contentWindow.fetch) {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        result = isNativeFetch(sandbox.contentWindow.fetch);
+      }
+      doc.head.removeChild(sandbox);
+    } catch (err) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&
+        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Tells whether current environment supports ReportingObserver API
+ * {@link supportsReportingObserver}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsReportingObserver() {
+  return 'ReportingObserver' in WINDOW;
+}
+
+/**
+ * Tells whether current environment supports Referrer Policy API
+ * {@link supportsReferrerPolicy}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsReferrerPolicy() {
+  // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'
+  // (see https://caniuse.com/#feat=referrer-policy),
+  // it doesn't. And it throws an exception instead of ignoring this parameter...
+  // REF: https://github.com/getsentry/raven-js/issues/1233
+
+  if (!supportsFetch()) {
+    return false;
+  }
+
+  try {
+    new Request('_', {
+      referrerPolicy: 'origin' ,
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+export { isNativeFetch, supportsDOMError, supportsDOMException, supportsErrorEvent, supportsFetch, supportsNativeFetch, supportsReferrerPolicy, supportsReportingObserver };
+//# sourceMappingURL=supports.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/time.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/time.js
new file mode 100644
index 0000000..2703ed2
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/time.js
@@ -0,0 +1,183 @@
+import { isNodeEnv, dynamicRequire } from './node.js';
+import { getGlobalObject } from './worldwide.js';
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+/**
+ * An object that can return the current timestamp in seconds since the UNIX epoch.
+ */
+
+/**
+ * A TimestampSource implementation for environments that do not support the Performance Web API natively.
+ *
+ * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier
+ * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It
+ * is more obvious to explain "why does my span have negative duration" than "why my spans have zero duration".
+ */
+const dateTimestampSource = {
+  nowSeconds: () => Date.now() / 1000,
+};
+
+/**
+ * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}
+ * for accessing a high-resolution monotonic clock.
+ */
+
+/**
+ * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not
+ * support the API.
+ *
+ * Wrapping the native API works around differences in behavior from different browsers.
+ */
+function getBrowserPerformance() {
+  const { performance } = WINDOW;
+  if (!performance || !performance.now) {
+    return undefined;
+  }
+
+  // Replace performance.timeOrigin with our own timeOrigin based on Date.now().
+  //
+  // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +
+  // performance.now() gives a date arbitrarily in the past.
+  //
+  // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is
+  // undefined.
+  //
+  // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to
+  // interact with data coming out of performance entries.
+  //
+  // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that
+  // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes
+  // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have
+  // observed skews that can be as long as days, weeks or months.
+  //
+  // See https://github.com/getsentry/sentry-javascript/issues/2590.
+  //
+  // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload
+  // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation
+  // transactions of long-lived web pages.
+  const timeOrigin = Date.now() - performance.now();
+
+  return {
+    now: () => performance.now(),
+    timeOrigin,
+  };
+}
+
+/**
+ * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't
+ * implement the API.
+ */
+function getNodePerformance() {
+  try {
+    const perfHooks = dynamicRequire(module, 'perf_hooks') ;
+    return perfHooks.performance;
+  } catch (_) {
+    return undefined;
+  }
+}
+
+/**
+ * The Performance API implementation for the current platform, if available.
+ */
+const platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();
+
+const timestampSource =
+  platformPerformance === undefined
+    ? dateTimestampSource
+    : {
+        nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,
+      };
+
+/**
+ * Returns a timestamp in seconds since the UNIX epoch using the Date API.
+ */
+const dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);
+
+/**
+ * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the
+ * availability of the Performance API.
+ *
+ * See `usingPerformanceAPI` to test whether the Performance API is used.
+ *
+ * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is
+ * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The
+ * skew can grow to arbitrary amounts like days, weeks or months.
+ * See https://github.com/getsentry/sentry-javascript/issues/2590.
+ */
+const timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);
+
+/**
+ * Re-exported with an old name for backwards-compatibility.
+ * TODO (v8): Remove this
+ *
+ * @deprecated Use `timestampInSeconds` instead.
+ */
+const timestampWithMs = timestampInSeconds;
+
+/**
+ * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.
+ */
+const usingPerformanceAPI = platformPerformance !== undefined;
+
+/**
+ * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.
+ */
+let _browserPerformanceTimeOriginMode;
+
+/**
+ * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the
+ * performance API is available.
+ */
+const browserPerformanceTimeOrigin = (() => {
+  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or
+  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin
+  // data as reliable if they are within a reasonable threshold of the current time.
+
+  const { performance } = WINDOW;
+  if (!performance || !performance.now) {
+    _browserPerformanceTimeOriginMode = 'none';
+    return undefined;
+  }
+
+  const threshold = 3600 * 1000;
+  const performanceNow = performance.now();
+  const dateNow = Date.now();
+
+  // if timeOrigin isn't available set delta to threshold so it isn't used
+  const timeOriginDelta = performance.timeOrigin
+    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)
+    : threshold;
+  const timeOriginIsReliable = timeOriginDelta < threshold;
+
+  // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin
+  // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.
+  // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always
+  // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the
+  // Date API.
+  // eslint-disable-next-line deprecation/deprecation
+  const navigationStart = performance.timing && performance.timing.navigationStart;
+  const hasNavigationStart = typeof navigationStart === 'number';
+  // if navigationStart isn't available set delta to threshold so it isn't used
+  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;
+  const navigationStartIsReliable = navigationStartDelta < threshold;
+
+  if (timeOriginIsReliable || navigationStartIsReliable) {
+    // Use the more reliable time origin
+    if (timeOriginDelta <= navigationStartDelta) {
+      _browserPerformanceTimeOriginMode = 'timeOrigin';
+      return performance.timeOrigin;
+    } else {
+      _browserPerformanceTimeOriginMode = 'navigationStart';
+      return navigationStart;
+    }
+  }
+
+  // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.
+  _browserPerformanceTimeOriginMode = 'dateNow';
+  return dateNow;
+})();
+
+export { _browserPerformanceTimeOriginMode, browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds, timestampWithMs, usingPerformanceAPI };
+//# sourceMappingURL=time.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/vendor/supportsHistory.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/vendor/supportsHistory.js
new file mode 100644
index 0000000..cf33d64
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/vendor/supportsHistory.js
@@ -0,0 +1,29 @@
+import { getGlobalObject } from '../worldwide.js';
+
+// Based on https://github.com/angular/angular.js/pull/13945/files
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+/**
+ * Tells whether current environment supports History API
+ * {@link supportsHistory}.
+ *
+ * @returns Answer to the given question.
+ */
+function supportsHistory() {
+  // NOTE: in Chrome App environment, touching history.pushState, *even inside
+  //       a try/catch block*, will cause Chrome to output an error to console.error
+  // borrowed from: https://github.com/angular/angular.js/pull/13945/files
+  /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const chrome = (WINDOW ).chrome;
+  const isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;
+  /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+  const hasHistoryApi = 'history' in WINDOW && !!WINDOW.history.pushState && !!WINDOW.history.replaceState;
+
+  return !isChromePackagedApp && hasHistoryApi;
+}
+
+export { supportsHistory };
+//# sourceMappingURL=supportsHistory.js.map
diff --git a/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/worldwide.js b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/worldwide.js
new file mode 100644
index 0000000..4c54705
--- /dev/null
+++ b/parent_dir/node_modules/sentry/replay/node_modules/sentry/utils/esm/worldwide.js
@@ -0,0 +1,70 @@
+/** Internal global with common properties and Sentry extensions  */
+
+// The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification
+// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js
+// core-js has the following licence:
+//
+// Copyright (c) 2014-2022 Denis Pushkarev
+//
+// 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.
+
+/** Returns 'obj' if it's the global object, otherwise returns undefined */
+function isGlobalObj(obj) {
+  return obj && obj.Math == Math ? obj : undefined;
+}
+
+/** Get's the global object for the current JavaScript runtime */
+const GLOBAL_OBJ =
+  (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||
+  // eslint-disable-next-line no-restricted-globals
+  (typeof window == 'object' && isGlobalObj(window)) ||
+  (typeof self == 'object' && isGlobalObj(self)) ||
+  (typeof global == 'object' && isGlobalObj(global)) ||
+  (function () {
+    return this;
+  })() ||
+  {};
+
+/**
+ * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8
+ */
+function getGlobalObject() {
+  return GLOBAL_OBJ ;
+}
+
+/**
+ * Returns a global singleton contained in the global `__SENTRY__` object.
+ *
+ * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory
+ * function and added to the `__SENTRY__` object.
+ *
+ * @param name name of the global singleton on __SENTRY__
+ * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`
+ * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value
+ * @returns the singleton
+ */
+function getGlobalSingleton(name, creator, obj) {
+  const gbl = (obj || GLOBAL_OBJ) ;
+  const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});
+  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());
+  return singleton;
+}
+
+export { GLOBAL_OBJ, getGlobalObject, getGlobalSingleton };
+//# sourceMappingURL=worldwide.js.map
diff --git a/parent_dir/node_modules/sentry/utils/esm/misc.js b/parent_dir/node_modules/sentry/utils/esm/misc.js
new file mode 100644
index 0000000..5685693
--- /dev/null
+++ b/parent_dir/node_modules/sentry/utils/esm/misc.js
@@ -0,0 +1,203 @@
+import { addNonEnumerableProperty } from './object.js';
+import { snipLine } from './string.js';
+import { GLOBAL_OBJ } from './worldwide.js';
+
+/**
+ * UUID4 generator
+ *
+ * @returns string Generated UUID4.
+ */
+function uuid4() {
+  const gbl = GLOBAL_OBJ ;
+  const crypto = gbl.crypto || gbl.msCrypto;
+
+  let getRandomByte = () => Math.random() * 16;
+  try {
+    if (crypto && crypto.randomUUID) {
+      return crypto.randomUUID().replace(/-/g, '');
+    }
+    if (crypto && crypto.getRandomValues) {
+      getRandomByte = () => crypto.getRandomValues(new Uint8Array(1))[0];
+    }
+  } catch (_) {
+    // some runtimes can crash invoking crypto
+    // https://github.com/getsentry/sentry-javascript/issues/8935
+  }
+
+  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
+  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'
+  return (([1e7] ) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>
+    // eslint-disable-next-line no-bitwise
+    ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),
+  );
+}
+
+function getFirstException(event) {
+  return event.exception && event.exception.values ? event.exception.values[0] : undefined;
+}
+
+/**
+ * Extracts either message or type+value from an event that can be used for user-facing logs
+ * @returns event's description
+ */
+function getEventDescription(event) {
+  const { message, event_id: eventId } = event;
+  if (message) {
+    return message;
+  }
+
+  const firstException = getFirstException(event);
+  if (firstException) {
+    if (firstException.type && firstException.value) {
+      return `${firstException.type}: ${firstException.value}`;
+    }
+    return firstException.type || firstException.value || eventId || '<unknown>';
+  }
+  return eventId || '<unknown>';
+}
+
+/**
+ * Adds exception values, type and value to an synthetic Exception.
+ * @param event The event to modify.
+ * @param value Value of the exception.
+ * @param type Type of the exception.
+ * @hidden
+ */
+function addExceptionTypeValue(event, value, type) {
+  const exception = (event.exception = event.exception || {});
+  const values = (exception.values = exception.values || []);
+  const firstException = (values[0] = values[0] || {});
+  if (!firstException.value) {
+    firstException.value = value || '';
+  }
+  if (!firstException.type) {
+    firstException.type = type || 'Error';
+  }
+}
+
+/**
+ * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.
+ *
+ * @param event The event to modify.
+ * @param newMechanism Mechanism data to add to the event.
+ * @hidden
+ */
+function addExceptionMechanism(event, newMechanism) {
+  const firstException = getFirstException(event);
+  if (!firstException) {
+    return;
+  }
+
+  const defaultMechanism = { type: 'generic', handled: true };
+  const currentMechanism = firstException.mechanism;
+  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };
+
+  if (newMechanism && 'data' in newMechanism) {
+    const mergedData = { ...(currentMechanism && currentMechanism.data), ...newMechanism.data };
+    firstException.mechanism.data = mergedData;
+  }
+}
+
+// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+const SEMVER_REGEXP =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+
+/**
+ * Represents Semantic Versioning object
+ */
+
+/**
+ * Parses input into a SemVer interface
+ * @param input string representation of a semver version
+ */
+function parseSemver(input) {
+  const match = input.match(SEMVER_REGEXP) || [];
+  const major = parseInt(match[1], 10);
+  const minor = parseInt(match[2], 10);
+  const patch = parseInt(match[3], 10);
+  return {
+    buildmetadata: match[5],
+    major: isNaN(major) ? undefined : major,
+    minor: isNaN(minor) ? undefined : minor,
+    patch: isNaN(patch) ? undefined : patch,
+    prerelease: match[4],
+  };
+}
+
+/**
+ * This function adds context (pre/post/line) lines to the provided frame
+ *
+ * @param lines string[] containing all lines
+ * @param frame StackFrame that will be mutated
+ * @param linesOfContext number of context lines we want to add pre/post
+ */
+function addContextToFrame(lines, frame, linesOfContext = 5) {
+  // When there is no line number in the frame, attaching context is nonsensical and will even break grouping
+  if (frame.lineno === undefined) {
+    return;
+  }
+
+  const maxLines = lines.length;
+  const sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0);
+
+  frame.pre_context = lines
+    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)
+    .map((line) => snipLine(line, 0));
+
+  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);
+
+  frame.post_context = lines
+    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)
+    .map((line) => snipLine(line, 0));
+}
+
+/**
+ * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object
+ * in question), and marks it captured if not.
+ *
+ * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and
+ * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so
+ * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because
+ * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not
+ * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This
+ * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we
+ * see it.
+ *
+ * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on
+ * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent
+ * object wrapper forms so that this check will always work. However, because we need to flag the exact object which
+ * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification
+ * must be done before the exception captured.
+ *
+ * @param A thrown exception to check or flag as having been seen
+ * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)
+ */
+function checkOrSetAlreadyCaught(exception) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  if (exception && (exception ).__sentry_captured__) {
+    return true;
+  }
+
+  try {
+    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the
+    // `ExtraErrorData` integration
+    addNonEnumerableProperty(exception , '__sentry_captured__', true);
+  } catch (err) {
+    // `exception` is a primitive, so we can't mark it seen
+  }
+
+  return false;
+}
+
+/**
+ * Checks whether the given input is already an array, and if it isn't, wraps it in one.
+ *
+ * @param maybeArray Input to turn into an array, if necessary
+ * @returns The input, if already an array, or an array with the input as the only element, if not
+ */
+function arrayify(maybeArray) {
+  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];
+}
+
+export { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, arrayify, checkOrSetAlreadyCaught, getEventDescription, parseSemver, uuid4 };
+//# sourceMappingURL=misc.js.map
diff --git a/parent_dir/node_modules/sentry/vue/esm/constants.js b/parent_dir/node_modules/sentry/vue/esm/constants.js
new file mode 100644
index 0000000..da1a5b6
--- /dev/null
+++ b/parent_dir/node_modules/sentry/vue/esm/constants.js
@@ -0,0 +1,4 @@
+const DEFAULT_HOOKS = ['activate', 'mount', 'update'];
+
+export { DEFAULT_HOOKS };
+//# sourceMappingURL=constants.js.map
diff --git a/parent_dir/node_modules/sentry/vue/esm/errorhandler.js b/parent_dir/node_modules/sentry/vue/esm/errorhandler.js
new file mode 100644
index 0000000..afdb771
--- /dev/null
+++ b/parent_dir/node_modules/sentry/vue/esm/errorhandler.js
@@ -0,0 +1,62 @@
+import { getCurrentHub } from '@sentry/browser';
+import { addExceptionMechanism } from '@sentry/utils';
+import { formatComponentName, generateComponentTrace } from './vendor/components.js';
+
+const attachErrorHandler = (app, options) => {
+  const { errorHandler, warnHandler, silent } = app.config;
+
+  app.config.errorHandler = (error, vm, lifecycleHook) => {
+    const componentName = formatComponentName(vm, false);
+    const trace = vm ? generateComponentTrace(vm) : '';
+    const metadata = {
+      componentName,
+      lifecycleHook,
+      trace,
+    };
+
+    if (options.attachProps && vm) {
+      // Vue2 - $options.propsData
+      // Vue3 - $props
+      if (vm.$options && vm.$options.propsData) {
+        metadata.propsData = vm.$options.propsData;
+      } else if (vm.$props) {
+        metadata.propsData = vm.$props;
+      }
+    }
+
+    // Capture exception in the next event loop, to make sure that all breadcrumbs are recorded in time.
+    setTimeout(() => {
+      getCurrentHub().withScope(scope => {
+        scope.setContext('vue', metadata);
+
+        scope.addEventProcessor(event => {
+          addExceptionMechanism(event, {
+            handled: false,
+          });
+          return event;
+        });
+
+        getCurrentHub().captureException(error);
+      });
+    });
+
+    if (typeof errorHandler === 'function') {
+      (errorHandler ).call(app, error, vm, lifecycleHook);
+    }
+
+    if (options.logErrors) {
+      const hasConsole = typeof console !== 'undefined';
+      const message = `Error in ${lifecycleHook}: "${error && error.toString()}"`;
+
+      if (warnHandler) {
+        (warnHandler ).call(null, message, vm, trace);
+      } else if (hasConsole && !silent) {
+        // eslint-disable-next-line no-console
+        console.error(`[Vue warn]: ${message}${trace}`);
+      }
+    }
+  };
+};
+
+export { attachErrorHandler };
+//# sourceMappingURL=errorhandler.js.map
diff --git a/parent_dir/node_modules/sentry/vue/esm/router.js b/parent_dir/node_modules/sentry/vue/esm/router.js
new file mode 100644
index 0000000..ceb732f
--- /dev/null
+++ b/parent_dir/node_modules/sentry/vue/esm/router.js
@@ -0,0 +1,114 @@
+import { WINDOW, captureException } from '@sentry/browser';
+import { addExceptionMechanism } from '@sentry/utils';
+import { getActiveTransaction } from './tracing.js';
+
+/**
+ * Creates routing instrumentation for Vue Router v2, v3 and v4
+ *
+ * You can optionally pass in an options object with the available option:
+ * * `routeLabel`: Set this to `route` to opt-out of using `route.name` for transaction names.
+ *
+ * @param router The Vue Router instance that is used
+ */
+function vueRouterInstrumentation(
+  router,
+  options = {},
+) {
+  return (
+    startTransaction,
+    startTransactionOnPageLoad = true,
+    startTransactionOnLocationChange = true,
+  ) => {
+    const tags = {
+      'routing.instrumentation': 'vue-router',
+    };
+
+    // We have to start the pageload transaction as early as possible (before the router's `beforeEach` hook
+    // is called) to not miss child spans of the pageload.
+    // We check that window & window.location exists in order to not run this code in SSR environments.
+    if (startTransactionOnPageLoad && WINDOW && WINDOW.location) {
+      startTransaction({
+        name: WINDOW.location.pathname,
+        op: 'pageload',
+        origin: 'auto.pageload.vue',
+        tags,
+        metadata: {
+          source: 'url',
+        },
+      });
+    }
+
+    router.onError(error =>
+      captureException(error, scope => {
+        scope.addEventProcessor(event => {
+          addExceptionMechanism(event, { handled: false });
+          return event;
+        });
+
+        return scope;
+      }),
+    );
+
+    router.beforeEach((to, from, next) => {
+      // According to docs we could use `from === VueRouter.START_LOCATION` but I couldnt get it working for Vue 2
+      // https://router.vuejs.org/api/#router-start-location
+      // https://next.router.vuejs.org/api/#start-location
+
+      // from.name:
+      // - Vue 2: null
+      // - Vue 3: undefined
+      // hence only '==' instead of '===', because `undefined == null` evaluates to `true`
+      const isPageLoadNavigation = from.name == null && from.matched.length === 0;
+
+      const data = {
+        params: to.params,
+        query: to.query,
+      };
+
+      // Determine a name for the routing transaction and where that name came from
+      let transactionName = to.path;
+      let transactionSource = 'url';
+      if (to.name && options.routeLabel !== 'path') {
+        transactionName = to.name.toString();
+        transactionSource = 'custom';
+      } else if (to.matched[0] && to.matched[0].path) {
+        transactionName = to.matched[0].path;
+        transactionSource = 'route';
+      }
+
+      if (startTransactionOnPageLoad && isPageLoadNavigation) {
+        const pageloadTransaction = getActiveTransaction();
+        if (pageloadTransaction) {
+          if (pageloadTransaction.metadata.source !== 'custom') {
+            pageloadTransaction.setName(transactionName, transactionSource);
+          }
+          pageloadTransaction.setData('params', data.params);
+          pageloadTransaction.setData('query', data.query);
+        }
+      }
+
+      if (startTransactionOnLocationChange && !isPageLoadNavigation) {
+        startTransaction({
+          name: transactionName,
+          op: 'navigation',
+          origin: 'auto.navigation.vue',
+          tags,
+          data,
+          metadata: {
+            source: transactionSource,
+          },
+        });
+      }
+
+      // Vue Router 4 no longer exposes the `next` function, so we need to
+      // check if it's available before calling it.
+      // `next` needs to be called in Vue Router 3 so that the hook is resolved.
+      if (next) {
+        next();
+      }
+    });
+  };
+}
+
+export { vueRouterInstrumentation };
+//# sourceMappingURL=router.js.map
diff --git a/parent_dir/node_modules/sentry/vue/esm/sdk.js b/parent_dir/node_modules/sentry/vue/esm/sdk.js
new file mode 100644
index 0000000..e92533c
--- /dev/null
+++ b/parent_dir/node_modules/sentry/vue/esm/sdk.js
@@ -0,0 +1,91 @@
+import { SDK_VERSION, init as init$1 } from '@sentry/browser';
+import { hasTracingEnabled } from '@sentry/core';
+import { GLOBAL_OBJ, arrayify } from '@sentry/utils';
+import { DEFAULT_HOOKS } from './constants.js';
+import { attachErrorHandler } from './errorhandler.js';
+import { createTracingMixins } from './tracing.js';
+
+const globalWithVue = GLOBAL_OBJ ;
+
+const DEFAULT_CONFIG = {
+  Vue: globalWithVue.Vue,
+  attachProps: true,
+  logErrors: true,
+  hooks: DEFAULT_HOOKS,
+  timeout: 2000,
+  trackComponents: false,
+  _metadata: {
+    sdk: {
+      name: 'sentry.javascript.vue',
+      packages: [
+        {
+          name: 'npm:@sentry/vue',
+          version: SDK_VERSION,
+        },
+      ],
+      version: SDK_VERSION,
+    },
+  },
+};
+
+/**
+ * Inits the Vue SDK
+ */
+function init(
+  config = {},
+) {
+  const options = {
+    ...DEFAULT_CONFIG,
+    ...config,
+  };
+
+  init$1(options);
+
+  if (!options.Vue && !options.app) {
+    // eslint-disable-next-line no-console
+    console.warn(
+      `[@sentry/vue]: Misconfigured SDK. Vue specific errors will not be captured.
+Update your \`Sentry.init\` call with an appropriate config option:
+\`app\` (Application Instance - Vue 3) or \`Vue\` (Vue Constructor - Vue 2).`,
+    );
+    return;
+  }
+
+  if (options.app) {
+    const apps = arrayify(options.app);
+    apps.forEach(app => vueInit(app, options));
+  } else if (options.Vue) {
+    vueInit(options.Vue, options);
+  }
+}
+
+const vueInit = (app, options) => {
+  // Check app is not mounted yet - should be mounted _after_ init()!
+  // This is _somewhat_ private, but in the case that this doesn't exist we simply ignore it
+  // See: https://github.com/vuejs/core/blob/eb2a83283caa9de0a45881d860a3cbd9d0bdd279/packages/runtime-core/src/component.ts#L394
+  const appWithInstance = app
+
+;
+
+  const isMounted = appWithInstance._instance && appWithInstance._instance.isMounted;
+  if (isMounted === true) {
+    // eslint-disable-next-line no-console
+    console.warn(
+      '[@sentry/vue]: Misconfigured SDK. Vue app is already mounted. Make sure to call `app.mount()` after `Sentry.init()`.',
+    );
+  }
+
+  attachErrorHandler(app, options);
+
+  if (hasTracingEnabled(options)) {
+    app.mixin(
+      createTracingMixins({
+        ...options,
+        ...options.tracingOptions,
+      }),
+    );
+  }
+};
+
+export { init };
+//# sourceMappingURL=sdk.js.map
diff --git a/parent_dir/node_modules/sentry/vue/esm/tracing.js b/parent_dir/node_modules/sentry/vue/esm/tracing.js
new file mode 100644
index 0000000..45acf30
--- /dev/null
+++ b/parent_dir/node_modules/sentry/vue/esm/tracing.js
@@ -0,0 +1,120 @@
+import { getCurrentHub } from '@sentry/browser';
+import { logger, timestampInSeconds } from '@sentry/utils';
+import { DEFAULT_HOOKS } from './constants.js';
+import { formatComponentName } from './vendor/components.js';
+
+const VUE_OP = 'ui.vue';
+
+// Mappings from operation to corresponding lifecycle hook.
+const HOOKS = {
+  activate: ['activated', 'deactivated'],
+  create: ['beforeCreate', 'created'],
+  destroy: ['beforeDestroy', 'destroyed'],
+  mount: ['beforeMount', 'mounted'],
+  update: ['beforeUpdate', 'updated'],
+};
+
+/** Grabs active transaction off scope, if any */
+function getActiveTransaction() {
+  return getCurrentHub().getScope().getTransaction();
+}
+
+/** Finish top-level span and activity with a debounce configured using `timeout` option */
+function finishRootSpan(vm, timestamp, timeout) {
+  if (vm.$_sentryRootSpanTimer) {
+    clearTimeout(vm.$_sentryRootSpanTimer);
+  }
+
+  vm.$_sentryRootSpanTimer = setTimeout(() => {
+    if (vm.$root && vm.$root.$_sentryRootSpan) {
+      vm.$root.$_sentryRootSpan.finish(timestamp);
+      vm.$root.$_sentryRootSpan = undefined;
+    }
+  }, timeout);
+}
+
+const createTracingMixins = (options) => {
+  const hooks = (options.hooks || [])
+    .concat(DEFAULT_HOOKS)
+    // Removing potential duplicates
+    .filter((value, index, self) => self.indexOf(value) === index);
+
+  const mixins = {};
+
+  for (const operation of hooks) {
+    // Retrieve corresponding hooks from Vue lifecycle.
+    // eg. mount => ['beforeMount', 'mounted']
+    const internalHooks = HOOKS[operation];
+    if (!internalHooks) {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Unknown hook: ${operation}`);
+      continue;
+    }
+
+    for (const internalHook of internalHooks) {
+      mixins[internalHook] = function () {
+        const isRoot = this.$root === this;
+
+        if (isRoot) {
+          const activeTransaction = getActiveTransaction();
+          if (activeTransaction) {
+            this.$_sentryRootSpan =
+              this.$_sentryRootSpan ||
+              activeTransaction.startChild({
+                description: 'Application Render',
+                op: `${VUE_OP}.render`,
+                origin: 'auto.ui.vue',
+              });
+          }
+        }
+
+        // Skip components that we don't want to track to minimize the noise and give a more granular control to the user
+        const name = formatComponentName(this, false);
+        const shouldTrack = Array.isArray(options.trackComponents)
+          ? options.trackComponents.indexOf(name) > -1
+          : options.trackComponents;
+
+        // We always want to track root component
+        if (!isRoot && !shouldTrack) {
+          return;
+        }
+
+        this.$_sentrySpans = this.$_sentrySpans || {};
+
+        // Start a new span if current hook is a 'before' hook.
+        // Otherwise, retrieve the current span and finish it.
+        if (internalHook == internalHooks[0]) {
+          const activeTransaction = (this.$root && this.$root.$_sentryRootSpan) || getActiveTransaction();
+          if (activeTransaction) {
+            // Cancel old span for this hook operation in case it didn't get cleaned up. We're not actually sure if it
+            // will ever be the case that cleanup hooks re not called, but we had users report that spans didn't get
+            // finished so we finish the span before starting a new one, just to be sure.
+            const oldSpan = this.$_sentrySpans[operation];
+            if (oldSpan && !oldSpan.endTimestamp) {
+              oldSpan.finish();
+            }
+
+            this.$_sentrySpans[operation] = activeTransaction.startChild({
+              description: `Vue <${name}>`,
+              op: `${VUE_OP}.${operation}`,
+              origin: 'auto.ui.vue',
+            });
+          }
+        } else {
+          // The span should already be added via the first handler call (in the 'before' hook)
+          const span = this.$_sentrySpans[operation];
+          // The before hook did not start the tracking span, so the span was not added.
+          // This is probably because it happened before there is an active transaction
+          if (!span) return;
+          span.finish();
+
+          finishRootSpan(this, timestampInSeconds(), options.timeout);
+        }
+      };
+    }
+  }
+
+  return mixins;
+};
+
+export { createTracingMixins, getActiveTransaction };
+//# sourceMappingURL=tracing.js.map
diff --git a/parent_dir/node_modules/sentry/vue/esm/vendor/components.js b/parent_dir/node_modules/sentry/vue/esm/vendor/components.js
new file mode 100644
index 0000000..8cc04b6
--- /dev/null
+++ b/parent_dir/node_modules/sentry/vue/esm/vendor/components.js
@@ -0,0 +1,109 @@
+// Vendored from https://github.com/vuejs/vue/blob/612fb89547711cacb030a3893a0065b785802860/src/core/util/debug.js
+// with types only changes.
+
+// The MIT License (MIT)
+
+// Copyright (c) 2013-present, Yuxi (Evan) You
+
+// 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.
+
+const classifyRE = /(?:^|[-_])(\w)/g;
+const classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');
+
+const ROOT_COMPONENT_NAME = '<Root>';
+const ANONYMOUS_COMPONENT_NAME = '<Anonymous>';
+
+const repeat = (str, n) => {
+  // string.repeat() is not supported by IE11, we fall back to just using the string in that case
+  // eslint-disable-next-line @sentry-internal/sdk/no-unsupported-es6-methods
+  return str.repeat ? str.repeat(n) : str;
+};
+
+const formatComponentName = (vm, includeFile) => {
+  if (!vm) {
+    return ANONYMOUS_COMPONENT_NAME;
+  }
+
+  if (vm.$root === vm) {
+    return ROOT_COMPONENT_NAME;
+  }
+
+  // https://github.com/getsentry/sentry-javascript/issues/5204 $options can be undefined
+  if (!vm.$options) {
+    return ANONYMOUS_COMPONENT_NAME;
+  }
+
+  const options = vm.$options;
+
+  let name = options.name || options._componentTag;
+  const file = options.__file;
+  if (!name && file) {
+    const match = file.match(/([^/\\]+)\.vue$/);
+    if (match) {
+      name = match[1];
+    }
+  }
+
+  return (
+    (name ? `<${classify(name)}>` : ANONYMOUS_COMPONENT_NAME) + (file && includeFile !== false ? ` at ${file}` : '')
+  );
+};
+
+const generateComponentTrace = (vm) => {
+  if (vm && (vm._isVue || vm.__isVue) && vm.$parent) {
+    const tree = [];
+    let currentRecursiveSequence = 0;
+    while (vm) {
+      if (tree.length > 0) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const last = tree[tree.length - 1] ;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        if (last.constructor === vm.constructor) {
+          currentRecursiveSequence++;
+          vm = vm.$parent; // eslint-disable-line no-param-reassign
+          continue;
+        } else if (currentRecursiveSequence > 0) {
+          tree[tree.length - 1] = [last, currentRecursiveSequence];
+          currentRecursiveSequence = 0;
+        }
+      }
+      tree.push(vm);
+      vm = vm.$parent; // eslint-disable-line no-param-reassign
+    }
+
+    const formattedTree = tree
+      .map(
+        (vm, i) =>
+          `${
+            (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) +
+            (Array.isArray(vm)
+              ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+              : formatComponentName(vm))
+          }`,
+      )
+      .join('\n');
+
+    return `\n\nfound in\n\n${formattedTree}`;
+  }
+
+  return `\n\n(found in ${formatComponentName(vm)})`;
+};
+
+export { formatComponentName, generateComponentTrace };
+//# sourceMappingURL=components.js.map
diff --git a/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/env.js b/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/env.js
new file mode 100644
index 0000000..46dc077
--- /dev/null
+++ b/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/env.js
@@ -0,0 +1,34 @@
+/*
+ * This module exists for optimizations in the build process through rollup and terser.  We define some global
+ * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these
+ * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will
+ * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to
+ * `logger` and preventing node-related code from appearing in browser bundles.
+ *
+ * Attention:
+ * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by
+ * users. These flags should live in their respective packages, as we identified user tooling (specifically webpack)
+ * having issues tree-shaking these constants across package boundaries.
+ * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want
+ * users to be able to shake away expressions that it guards.
+ */
+
+/**
+ * Figures out if we're building a browser bundle.
+ *
+ * @returns true if this is a browser bundle build.
+ */
+function isBrowserBundle() {
+  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;
+}
+
+/**
+ * Get source of SDK.
+ */
+function getSDKSource() {
+  // @ts-expect-error "npm" is injected by rollup during build process
+  return "npm";
+}
+
+export { getSDKSource, isBrowserBundle };
+//# sourceMappingURL=env.js.map
diff --git a/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/logger.js b/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/logger.js
new file mode 100644
index 0000000..efa35e4
--- /dev/null
+++ b/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/logger.js
@@ -0,0 +1,82 @@
+import { GLOBAL_OBJ } from './worldwide.js';
+
+/** Prefix for logging strings */
+const PREFIX = 'Sentry Logger ';
+
+const CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] ;
+
+/** This may be mutated by the console instrumentation. */
+const originalConsoleMethods
+
+ = {};
+
+/** JSDoc */
+
+/**
+ * Temporarily disable sentry console instrumentations.
+ *
+ * @param callback The function to run against the original `console` messages
+ * @returns The results of the callback
+ */
+function consoleSandbox(callback) {
+  if (!('console' in GLOBAL_OBJ)) {
+    return callback();
+  }
+
+  const console = GLOBAL_OBJ.console ;
+  const wrappedFuncs = {};
+
+  const wrappedLevels = Object.keys(originalConsoleMethods) ;
+
+  // Restore all wrapped console methods
+  wrappedLevels.forEach(level => {
+    const originalConsoleMethod = originalConsoleMethods[level] ;
+    wrappedFuncs[level] = console[level] ;
+    console[level] = originalConsoleMethod;
+  });
+
+  try {
+    return callback();
+  } finally {
+    // Revert restoration to wrapped state
+    wrappedLevels.forEach(level => {
+      console[level] = wrappedFuncs[level] ;
+    });
+  }
+}
+
+function makeLogger() {
+  let enabled = false;
+  const logger = {
+    enable: () => {
+      enabled = true;
+    },
+    disable: () => {
+      enabled = false;
+    },
+  };
+
+  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+    CONSOLE_LEVELS.forEach(name => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      logger[name] = (...args) => {
+        if (enabled) {
+          consoleSandbox(() => {
+            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);
+          });
+        }
+      };
+    });
+  } else {
+    CONSOLE_LEVELS.forEach(name => {
+      logger[name] = () => undefined;
+    });
+  }
+
+  return logger ;
+}
+
+const logger = makeLogger();
+
+export { CONSOLE_LEVELS, consoleSandbox, logger, originalConsoleMethods };
+//# sourceMappingURL=logger.js.map
diff --git a/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/misc.js b/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/misc.js
new file mode 100644
index 0000000..5685693
--- /dev/null
+++ b/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/misc.js
@@ -0,0 +1,203 @@
+import { addNonEnumerableProperty } from './object.js';
+import { snipLine } from './string.js';
+import { GLOBAL_OBJ } from './worldwide.js';
+
+/**
+ * UUID4 generator
+ *
+ * @returns string Generated UUID4.
+ */
+function uuid4() {
+  const gbl = GLOBAL_OBJ ;
+  const crypto = gbl.crypto || gbl.msCrypto;
+
+  let getRandomByte = () => Math.random() * 16;
+  try {
+    if (crypto && crypto.randomUUID) {
+      return crypto.randomUUID().replace(/-/g, '');
+    }
+    if (crypto && crypto.getRandomValues) {
+      getRandomByte = () => crypto.getRandomValues(new Uint8Array(1))[0];
+    }
+  } catch (_) {
+    // some runtimes can crash invoking crypto
+    // https://github.com/getsentry/sentry-javascript/issues/8935
+  }
+
+  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
+  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'
+  return (([1e7] ) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>
+    // eslint-disable-next-line no-bitwise
+    ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),
+  );
+}
+
+function getFirstException(event) {
+  return event.exception && event.exception.values ? event.exception.values[0] : undefined;
+}
+
+/**
+ * Extracts either message or type+value from an event that can be used for user-facing logs
+ * @returns event's description
+ */
+function getEventDescription(event) {
+  const { message, event_id: eventId } = event;
+  if (message) {
+    return message;
+  }
+
+  const firstException = getFirstException(event);
+  if (firstException) {
+    if (firstException.type && firstException.value) {
+      return `${firstException.type}: ${firstException.value}`;
+    }
+    return firstException.type || firstException.value || eventId || '<unknown>';
+  }
+  return eventId || '<unknown>';
+}
+
+/**
+ * Adds exception values, type and value to an synthetic Exception.
+ * @param event The event to modify.
+ * @param value Value of the exception.
+ * @param type Type of the exception.
+ * @hidden
+ */
+function addExceptionTypeValue(event, value, type) {
+  const exception = (event.exception = event.exception || {});
+  const values = (exception.values = exception.values || []);
+  const firstException = (values[0] = values[0] || {});
+  if (!firstException.value) {
+    firstException.value = value || '';
+  }
+  if (!firstException.type) {
+    firstException.type = type || 'Error';
+  }
+}
+
+/**
+ * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.
+ *
+ * @param event The event to modify.
+ * @param newMechanism Mechanism data to add to the event.
+ * @hidden
+ */
+function addExceptionMechanism(event, newMechanism) {
+  const firstException = getFirstException(event);
+  if (!firstException) {
+    return;
+  }
+
+  const defaultMechanism = { type: 'generic', handled: true };
+  const currentMechanism = firstException.mechanism;
+  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };
+
+  if (newMechanism && 'data' in newMechanism) {
+    const mergedData = { ...(currentMechanism && currentMechanism.data), ...newMechanism.data };
+    firstException.mechanism.data = mergedData;
+  }
+}
+
+// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+const SEMVER_REGEXP =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+
+/**
+ * Represents Semantic Versioning object
+ */
+
+/**
+ * Parses input into a SemVer interface
+ * @param input string representation of a semver version
+ */
+function parseSemver(input) {
+  const match = input.match(SEMVER_REGEXP) || [];
+  const major = parseInt(match[1], 10);
+  const minor = parseInt(match[2], 10);
+  const patch = parseInt(match[3], 10);
+  return {
+    buildmetadata: match[5],
+    major: isNaN(major) ? undefined : major,
+    minor: isNaN(minor) ? undefined : minor,
+    patch: isNaN(patch) ? undefined : patch,
+    prerelease: match[4],
+  };
+}
+
+/**
+ * This function adds context (pre/post/line) lines to the provided frame
+ *
+ * @param lines string[] containing all lines
+ * @param frame StackFrame that will be mutated
+ * @param linesOfContext number of context lines we want to add pre/post
+ */
+function addContextToFrame(lines, frame, linesOfContext = 5) {
+  // When there is no line number in the frame, attaching context is nonsensical and will even break grouping
+  if (frame.lineno === undefined) {
+    return;
+  }
+
+  const maxLines = lines.length;
+  const sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0);
+
+  frame.pre_context = lines
+    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)
+    .map((line) => snipLine(line, 0));
+
+  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);
+
+  frame.post_context = lines
+    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)
+    .map((line) => snipLine(line, 0));
+}
+
+/**
+ * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object
+ * in question), and marks it captured if not.
+ *
+ * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and
+ * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so
+ * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because
+ * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not
+ * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This
+ * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we
+ * see it.
+ *
+ * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on
+ * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent
+ * object wrapper forms so that this check will always work. However, because we need to flag the exact object which
+ * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification
+ * must be done before the exception captured.
+ *
+ * @param A thrown exception to check or flag as having been seen
+ * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)
+ */
+function checkOrSetAlreadyCaught(exception) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  if (exception && (exception ).__sentry_captured__) {
+    return true;
+  }
+
+  try {
+    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the
+    // `ExtraErrorData` integration
+    addNonEnumerableProperty(exception , '__sentry_captured__', true);
+  } catch (err) {
+    // `exception` is a primitive, so we can't mark it seen
+  }
+
+  return false;
+}
+
+/**
+ * Checks whether the given input is already an array, and if it isn't, wraps it in one.
+ *
+ * @param maybeArray Input to turn into an array, if necessary
+ * @returns The input, if already an array, or an array with the input as the only element, if not
+ */
+function arrayify(maybeArray) {
+  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];
+}
+
+export { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, arrayify, checkOrSetAlreadyCaught, getEventDescription, parseSemver, uuid4 };
+//# sourceMappingURL=misc.js.map
diff --git a/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/node.js b/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/node.js
new file mode 100644
index 0000000..49eb7d7
--- /dev/null
+++ b/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/node.js
@@ -0,0 +1,66 @@
+import { isBrowserBundle } from './env.js';
+
+/**
+ * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,
+ * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.
+ */
+
+/**
+ * Checks whether we're in the Node.js or Browser environment
+ *
+ * @returns Answer to given question
+ */
+function isNodeEnv() {
+  // explicitly check for browser bundles as those can be optimized statically
+  // by terser/rollup.
+  return (
+    !isBrowserBundle() &&
+    Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'
+  );
+}
+
+/**
+ * Requires a module which is protected against bundler minification.
+ *
+ * @param request The module path to resolve
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+function dynamicRequire(mod, request) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  return mod.require(request);
+}
+
+/**
+ * Helper for dynamically loading module that should work with linked dependencies.
+ * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`
+ * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during
+ * build time. `require.resolve` is also not available in any other way, so we cannot create,
+ * a fake helper like we do with `dynamicRequire`.
+ *
+ * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.
+ * That is to mimic the behavior of `require.resolve` exactly.
+ *
+ * @param moduleName module name to require
+ * @returns possibly required module
+ */
+function loadModule(moduleName) {
+  let mod;
+
+  try {
+    mod = dynamicRequire(module, moduleName);
+  } catch (e) {
+    // no-empty
+  }
+
+  try {
+    const { cwd } = dynamicRequire(module, 'process');
+    mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) ;
+  } catch (e) {
+    // no-empty
+  }
+
+  return mod;
+}
+
+export { dynamicRequire, isNodeEnv, loadModule };
+//# sourceMappingURL=node.js.map
diff --git a/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/time.js b/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/time.js
new file mode 100644
index 0000000..2703ed2
--- /dev/null
+++ b/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/time.js
@@ -0,0 +1,183 @@
+import { isNodeEnv, dynamicRequire } from './node.js';
+import { getGlobalObject } from './worldwide.js';
+
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW = getGlobalObject();
+
+/**
+ * An object that can return the current timestamp in seconds since the UNIX epoch.
+ */
+
+/**
+ * A TimestampSource implementation for environments that do not support the Performance Web API natively.
+ *
+ * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier
+ * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It
+ * is more obvious to explain "why does my span have negative duration" than "why my spans have zero duration".
+ */
+const dateTimestampSource = {
+  nowSeconds: () => Date.now() / 1000,
+};
+
+/**
+ * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}
+ * for accessing a high-resolution monotonic clock.
+ */
+
+/**
+ * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not
+ * support the API.
+ *
+ * Wrapping the native API works around differences in behavior from different browsers.
+ */
+function getBrowserPerformance() {
+  const { performance } = WINDOW;
+  if (!performance || !performance.now) {
+    return undefined;
+  }
+
+  // Replace performance.timeOrigin with our own timeOrigin based on Date.now().
+  //
+  // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +
+  // performance.now() gives a date arbitrarily in the past.
+  //
+  // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is
+  // undefined.
+  //
+  // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to
+  // interact with data coming out of performance entries.
+  //
+  // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that
+  // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes
+  // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have
+  // observed skews that can be as long as days, weeks or months.
+  //
+  // See https://github.com/getsentry/sentry-javascript/issues/2590.
+  //
+  // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload
+  // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation
+  // transactions of long-lived web pages.
+  const timeOrigin = Date.now() - performance.now();
+
+  return {
+    now: () => performance.now(),
+    timeOrigin,
+  };
+}
+
+/**
+ * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't
+ * implement the API.
+ */
+function getNodePerformance() {
+  try {
+    const perfHooks = dynamicRequire(module, 'perf_hooks') ;
+    return perfHooks.performance;
+  } catch (_) {
+    return undefined;
+  }
+}
+
+/**
+ * The Performance API implementation for the current platform, if available.
+ */
+const platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();
+
+const timestampSource =
+  platformPerformance === undefined
+    ? dateTimestampSource
+    : {
+        nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,
+      };
+
+/**
+ * Returns a timestamp in seconds since the UNIX epoch using the Date API.
+ */
+const dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);
+
+/**
+ * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the
+ * availability of the Performance API.
+ *
+ * See `usingPerformanceAPI` to test whether the Performance API is used.
+ *
+ * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is
+ * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The
+ * skew can grow to arbitrary amounts like days, weeks or months.
+ * See https://github.com/getsentry/sentry-javascript/issues/2590.
+ */
+const timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);
+
+/**
+ * Re-exported with an old name for backwards-compatibility.
+ * TODO (v8): Remove this
+ *
+ * @deprecated Use `timestampInSeconds` instead.
+ */
+const timestampWithMs = timestampInSeconds;
+
+/**
+ * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.
+ */
+const usingPerformanceAPI = platformPerformance !== undefined;
+
+/**
+ * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.
+ */
+let _browserPerformanceTimeOriginMode;
+
+/**
+ * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the
+ * performance API is available.
+ */
+const browserPerformanceTimeOrigin = (() => {
+  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or
+  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin
+  // data as reliable if they are within a reasonable threshold of the current time.
+
+  const { performance } = WINDOW;
+  if (!performance || !performance.now) {
+    _browserPerformanceTimeOriginMode = 'none';
+    return undefined;
+  }
+
+  const threshold = 3600 * 1000;
+  const performanceNow = performance.now();
+  const dateNow = Date.now();
+
+  // if timeOrigin isn't available set delta to threshold so it isn't used
+  const timeOriginDelta = performance.timeOrigin
+    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)
+    : threshold;
+  const timeOriginIsReliable = timeOriginDelta < threshold;
+
+  // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin
+  // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.
+  // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always
+  // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the
+  // Date API.
+  // eslint-disable-next-line deprecation/deprecation
+  const navigationStart = performance.timing && performance.timing.navigationStart;
+  const hasNavigationStart = typeof navigationStart === 'number';
+  // if navigationStart isn't available set delta to threshold so it isn't used
+  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;
+  const navigationStartIsReliable = navigationStartDelta < threshold;
+
+  if (timeOriginIsReliable || navigationStartIsReliable) {
+    // Use the more reliable time origin
+    if (timeOriginDelta <= navigationStartDelta) {
+      _browserPerformanceTimeOriginMode = 'timeOrigin';
+      return performance.timeOrigin;
+    } else {
+      _browserPerformanceTimeOriginMode = 'navigationStart';
+      return navigationStart;
+    }
+  }
+
+  // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.
+  _browserPerformanceTimeOriginMode = 'dateNow';
+  return dateNow;
+})();
+
+export { _browserPerformanceTimeOriginMode, browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds, timestampWithMs, usingPerformanceAPI };
+//# sourceMappingURL=time.js.map
diff --git a/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/worldwide.js b/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/worldwide.js
new file mode 100644
index 0000000..4c54705
--- /dev/null
+++ b/parent_dir/node_modules/sentry/vue/node_modules/sentry/utils/esm/worldwide.js
@@ -0,0 +1,70 @@
+/** Internal global with common properties and Sentry extensions  */
+
+// The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification
+// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js
+// core-js has the following licence:
+//
+// Copyright (c) 2014-2022 Denis Pushkarev
+//
+// 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.
+
+/** Returns 'obj' if it's the global object, otherwise returns undefined */
+function isGlobalObj(obj) {
+  return obj && obj.Math == Math ? obj : undefined;
+}
+
+/** Get's the global object for the current JavaScript runtime */
+const GLOBAL_OBJ =
+  (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||
+  // eslint-disable-next-line no-restricted-globals
+  (typeof window == 'object' && isGlobalObj(window)) ||
+  (typeof self == 'object' && isGlobalObj(self)) ||
+  (typeof global == 'object' && isGlobalObj(global)) ||
+  (function () {
+    return this;
+  })() ||
+  {};
+
+/**
+ * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8
+ */
+function getGlobalObject() {
+  return GLOBAL_OBJ ;
+}
+
+/**
+ * Returns a global singleton contained in the global `__SENTRY__` object.
+ *
+ * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory
+ * function and added to the `__SENTRY__` object.
+ *
+ * @param name name of the global singleton on __SENTRY__
+ * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`
+ * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value
+ * @returns the singleton
+ */
+function getGlobalSingleton(name, creator, obj) {
+  const gbl = (obj || GLOBAL_OBJ) ;
+  const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});
+  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());
+  return singleton;
+}
+
+export { GLOBAL_OBJ, getGlobalObject, getGlobalSingleton };
+//# sourceMappingURL=worldwide.js.map
diff --git a/parent_dir/node_modules/sourcebuster/dist/sourcebuster.js b/parent_dir/node_modules/sourcebuster/dist/sourcebuster.js
new file mode 100644
index 0000000..897c7c8
--- /dev/null
+++ b/parent_dir/node_modules/sourcebuster/dist/sourcebuster.js
@@ -0,0 +1,845 @@
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.sbjs=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
+"use strict";
+
+var init = _dereq_('./init');
+
+var sbjs = {
+  init: function(prefs) {
+    this.get = init(prefs);
+    if (prefs && prefs.callback && typeof prefs.callback === 'function') {
+      prefs.callback(this.get);
+    }
+  }
+};
+
+module.exports = sbjs;
+},{"./init":6}],2:[function(_dereq_,module,exports){
+"use strict";
+
+var terms = _dereq_('./terms'),
+    utils = _dereq_('./helpers/utils');
+
+var data = {
+
+  containers: {
+    current:          'sbjs_current',
+    current_extra:    'sbjs_current_add',
+    first:            'sbjs_first',
+    first_extra:      'sbjs_first_add',
+    session:          'sbjs_session',
+    udata:            'sbjs_udata',
+    promocode:        'sbjs_promo'
+  },
+
+  service: {
+    migrations:       'sbjs_migrations'
+  },
+
+  delimiter:          '|||',
+
+  aliases: {
+
+    main: {
+      type:           'typ',
+      source:         'src',
+      medium:         'mdm',
+      campaign:       'cmp',
+      content:        'cnt',
+      term:           'trm'
+    },
+
+    extra: {
+      fire_date:      'fd',
+      entrance_point: 'ep',
+      referer:        'rf'
+    },
+
+    session: {
+      pages_seen:     'pgs',
+      current_page:   'cpg'
+    },
+
+    udata: {
+      visits:         'vst',
+      ip:             'uip',
+      agent:          'uag'
+    },
+
+    promo:            'code'
+
+  },
+
+  pack: {
+
+    main: function(sbjs) {
+      return (
+        data.aliases.main.type      + '=' + sbjs.type     + data.delimiter +
+        data.aliases.main.source    + '=' + sbjs.source   + data.delimiter +
+        data.aliases.main.medium    + '=' + sbjs.medium   + data.delimiter +
+        data.aliases.main.campaign  + '=' + sbjs.campaign + data.delimiter +
+        data.aliases.main.content   + '=' + sbjs.content  + data.delimiter +
+        data.aliases.main.term      + '=' + sbjs.term
+      );
+    },
+
+    extra: function(timezone_offset) {
+      return (
+        data.aliases.extra.fire_date      + '=' + utils.setDate(new Date, timezone_offset) + data.delimiter +
+        data.aliases.extra.entrance_point + '=' + document.location.href                   + data.delimiter +
+        data.aliases.extra.referer        + '=' + (document.referrer || terms.none)
+      );
+    },
+
+    user: function(visits, user_ip) {
+      return (
+        data.aliases.udata.visits + '=' + visits  + data.delimiter +
+        data.aliases.udata.ip     + '=' + user_ip + data.delimiter +
+        data.aliases.udata.agent  + '=' + navigator.userAgent
+      );
+    },
+
+    session: function(pages) {
+      return (
+      data.aliases.session.pages_seen   + '=' + pages + data.delimiter +
+      data.aliases.session.current_page + '=' + document.location.href
+      );
+    },
+
+    promo: function(promo) {
+      return (
+        data.aliases.promo + '=' + utils.setLeadingZeroToInt(utils.randomInt(promo.min, promo.max), promo.max.toString().length)
+      );
+    }
+
+  }
+};
+
+module.exports = data;
+},{"./helpers/utils":5,"./terms":9}],3:[function(_dereq_,module,exports){
+"use strict";
+
+var delimiter = _dereq_('../data').delimiter;
+
+module.exports = {
+
+  encodeData: function(s) {
+    return encodeURIComponent(s).replace(/\!/g, '%21')
+                                .replace(/\~/g, '%7E')
+                                .replace(/\*/g, '%2A')
+                                .replace(/\'/g, '%27')
+                                .replace(/\(/g, '%28')
+                                .replace(/\)/g, '%29');
+  },
+
+  decodeData: function(s) {
+    try {
+      return decodeURIComponent(s).replace(/\%21/g, '!')
+                                  .replace(/\%7E/g, '~')
+                                  .replace(/\%2A/g, '*')
+                                  .replace(/\%27/g, "'")
+                                  .replace(/\%28/g, '(')
+                                  .replace(/\%29/g, ')');
+    } catch(err1) {
+      // try unescape for backward compatibility
+      try { return unescape(s); } catch(err2) { return ''; }
+    }
+  },
+
+  set: function(name, value, minutes, domain, excl_subdomains) {
+    var expires, basehost;
+
+    if (minutes) {
+      var date = new Date();
+      date.setTime(date.getTime() + (minutes * 60 * 1000));
+      expires = '; expires=' + date.toGMTString();
+    } else {
+      expires = '';
+    }
+    if (domain && !excl_subdomains) {
+      basehost = ';domain=.' + domain;
+    } else {
+      basehost = '';
+    }
+    document.cookie = this.encodeData(name) + '=' + this.encodeData(value) + expires + basehost + '; path=/';
+  },
+
+  get: function(name) {
+    var nameEQ = this.encodeData(name) + '=',
+        ca = document.cookie.split(';');
+
+    for (var i = 0; i < ca.length; i++) {
+      var c = ca[i];
+      while (c.charAt(0) === ' ') { c = c.substring(1, c.length); }
+      if (c.indexOf(nameEQ) === 0) {
+        return this.decodeData(c.substring(nameEQ.length, c.length));
+      }
+    }
+    return null;
+  },
+
+  destroy: function(name, domain, excl_subdomains) {
+    this.set(name, '', -1, domain, excl_subdomains);
+  },
+
+  parse: function(yummy) {
+
+    var cookies = [],
+        data    = {};
+
+    if (typeof yummy === 'string') {
+      cookies.push(yummy);
+    } else {
+      for (var prop in yummy) {
+        if (yummy.hasOwnProperty(prop)) {
+          cookies.push(yummy[prop]);
+        }
+      }
+    }
+
+    for (var i1 = 0; i1 < cookies.length; i1++) {
+      var cookie_array;
+      data[this.unsbjs(cookies[i1])] = {};
+      if (this.get(cookies[i1])) {
+        cookie_array = this.get(cookies[i1]).split(delimiter);
+      } else {
+        cookie_array = [];
+      }
+      for (var i2 = 0; i2 < cookie_array.length; i2++) {
+        var tmp_array = cookie_array[i2].split('='),
+            result_array = tmp_array.splice(0, 1);
+        result_array.push(tmp_array.join('='));
+        data[this.unsbjs(cookies[i1])][result_array[0]] = this.decodeData(result_array[1]);
+      }
+    }
+
+    return data;
+
+  },
+
+  unsbjs: function (string) {
+    return string.replace('sbjs_', '');
+  }
+
+};
+
+},{"../data":2}],4:[function(_dereq_,module,exports){
+"use strict";
+
+module.exports = {
+
+  parse: function(str) {
+    var o = this.parseOptions,
+        m = o.parser[o.strictMode ? 'strict' : 'loose'].exec(str),
+        uri = {},
+        i = 14;
+
+    while (i--) { uri[o.key[i]] = m[i] || ''; }
+
+    uri[o.q.name] = {};
+    uri[o.key[12]].replace(o.q.parser, function ($0, $1, $2) {
+      if ($1) { uri[o.q.name][$1] = $2; }
+    });
+
+    return uri;
+  },
+
+  parseOptions: {
+    strictMode: false,
+    key: ['source','protocol','authority','userInfo','user','password','host','port','relative','path','directory','file','query','anchor'],
+    q: {
+      name:   'queryKey',
+      parser: /(?:^|&)([^&=]*)=?([^&]*)/g
+    },
+    parser: {
+      strict: /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,
+      loose:  /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/
+    }
+  },
+
+  getParam: function(custom_params) {
+    var query_string = {},
+        query = custom_params ? custom_params : window.location.search.substring(1),
+        vars = query.split('&');
+
+    for (var i = 0; i < vars.length; i++) {
+      var pair = vars[i].split('=');
+      if (typeof query_string[pair[0]] === 'undefined') {
+        query_string[pair[0]] = pair[1];
+      } else if (typeof query_string[pair[0]] === 'string') {
+        var arr = [ query_string[pair[0]], pair[1] ];
+        query_string[pair[0]] = arr;
+      } else {
+        query_string[pair[0]].push(pair[1]);
+      }
+    }
+    return query_string;
+  },
+
+  getHost: function(request) {
+    return this.parse(request).host.replace('www.', '');
+  }
+
+};
+},{}],5:[function(_dereq_,module,exports){
+"use strict";
+
+module.exports = {
+
+  escapeRegexp: function(string) {
+    return string.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+  },
+
+  setDate: function(date, offset) {
+    var utc_offset    = date.getTimezoneOffset() / 60,
+        now_hours     = date.getHours(),
+        custom_offset = offset || offset === 0 ? offset : -utc_offset;
+
+    date.setHours(now_hours + utc_offset + custom_offset);
+
+    var year    = date.getFullYear(),
+        month   = this.setLeadingZeroToInt(date.getMonth() + 1,   2),
+        day     = this.setLeadingZeroToInt(date.getDate(),        2),
+        hour    = this.setLeadingZeroToInt(date.getHours(),       2),
+        minute  = this.setLeadingZeroToInt(date.getMinutes(),     2),
+        second  = this.setLeadingZeroToInt(date.getSeconds(),     2);
+
+    return (year + '-' + month + '-' + day + ' ' + hour + ':' + minute + ':' + second);
+  },
+
+  setLeadingZeroToInt: function(num, size) {
+    var s = num + '';
+    while (s.length < size) { s = '0' + s; }
+    return s;
+  },
+
+  randomInt: function(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+  }
+
+};
+
+},{}],6:[function(_dereq_,module,exports){
+"use strict";
+
+var data        = _dereq_('./data'),
+    terms       = _dereq_('./terms'),
+    cookies     = _dereq_('./helpers/cookies'),
+    uri         = _dereq_('./helpers/uri'),
+    utils       = _dereq_('./helpers/utils'),
+    params      = _dereq_('./params'),
+    migrations  = _dereq_('./migrations');
+
+module.exports = function(prefs) {
+
+  var p         = params.fetch(prefs);
+  var get_param = uri.getParam();
+  var domain    = p.domain.host,
+      isolate   = p.domain.isolate,
+      lifetime  = p.lifetime;
+
+  migrations.go(lifetime, domain, isolate);
+
+  var __sbjs_type,
+      __sbjs_source,
+      __sbjs_medium,
+      __sbjs_campaign,
+      __sbjs_content,
+      __sbjs_term;
+
+  function mainData() {
+    var sbjs_data;
+    if (
+        typeof get_param.utm_source        !== 'undefined' ||
+        typeof get_param.utm_medium        !== 'undefined' ||
+        typeof get_param.utm_campaign      !== 'undefined' ||
+        typeof get_param.utm_content       !== 'undefined' ||
+        typeof get_param.utm_term          !== 'undefined' ||
+        typeof get_param.gclid             !== 'undefined' ||
+        typeof get_param.yclid             !== 'undefined' ||
+        typeof get_param[p.campaign_param] !== 'undefined'
+      ) {
+      setFirstAndCurrentExtraData();
+      sbjs_data = getData(terms.traffic.utm);
+    } else if (checkReferer(terms.traffic.organic)) {
+      setFirstAndCurrentExtraData();
+      sbjs_data = getData(terms.traffic.organic);
+    } else if (!cookies.get(data.containers.session) && checkReferer(terms.traffic.referral)) {
+      setFirstAndCurrentExtraData();
+      sbjs_data = getData(terms.traffic.referral);
+    } else if (!cookies.get(data.containers.first) && !cookies.get(data.containers.current)) {
+      setFirstAndCurrentExtraData();
+      sbjs_data = getData(terms.traffic.typein);
+    } else {
+      return cookies.get(data.containers.current);
+    }
+
+    return sbjs_data;
+  }
+
+  function getData(type) {
+
+    switch (type) {
+
+      case terms.traffic.utm:
+
+        __sbjs_type = terms.traffic.utm;
+
+        if (typeof get_param.utm_source !== 'undefined') {
+          __sbjs_source = get_param.utm_source;
+        } else if (typeof get_param.gclid !== 'undefined') {
+          __sbjs_source = 'google';
+        } else if (typeof get_param.yclid !== 'undefined') {
+          __sbjs_source = 'yandex';  
+        } else {
+          __sbjs_source = terms.none;
+        }
+
+        if (typeof get_param.utm_medium !== 'undefined') {
+          __sbjs_medium = get_param.utm_medium;
+        } else if (typeof get_param.gclid !== 'undefined') {
+          __sbjs_medium = 'cpc';
+        } else if (typeof get_param.yclid !== 'undefined') {
+          __sbjs_medium = 'cpc';  
+        } else {
+          __sbjs_medium = terms.none;
+        }
+
+        if (typeof get_param.utm_campaign !== 'undefined') {
+          __sbjs_campaign = get_param.utm_campaign;
+        } else if (typeof get_param[p.campaign_param] !== 'undefined') {
+          __sbjs_campaign = get_param[p.campaign_param];
+        } else if (typeof get_param.gclid !== 'undefined') {
+          __sbjs_campaign = 'google_cpc';
+        } else if (typeof get_param.yclid !== 'undefined') {
+          __sbjs_campaign = 'yandex_cpc';  
+        } else {
+          __sbjs_campaign = terms.none;
+        }
+
+        __sbjs_content  = get_param.utm_content || terms.none;
+        __sbjs_term     = getUtmTerm()          || terms.none;
+        break;
+
+      case terms.traffic.organic:
+        __sbjs_type     = terms.traffic.organic;
+        __sbjs_source   = __sbjs_source || uri.getHost(document.referrer);
+        __sbjs_medium   = terms.referer.organic;
+        __sbjs_campaign = terms.none;
+        __sbjs_content  = terms.none;
+        __sbjs_term     = terms.none;
+        break;
+
+      case terms.traffic.referral:
+        __sbjs_type     = terms.traffic.referral;
+        __sbjs_source   = __sbjs_source || uri.getHost(document.referrer);
+        __sbjs_medium   = __sbjs_medium || terms.referer.referral;
+        __sbjs_campaign = terms.none;
+        __sbjs_content  = uri.parse(document.referrer).path;
+        __sbjs_term     = terms.none;
+        break;
+
+      case terms.traffic.typein:
+        __sbjs_type     = terms.traffic.typein;
+        __sbjs_source   = p.typein_attributes.source;
+        __sbjs_medium   = p.typein_attributes.medium;
+        __sbjs_campaign = terms.none;
+        __sbjs_content  = terms.none;
+        __sbjs_term     = terms.none;
+        break;
+
+      default:
+        __sbjs_type     = terms.oops;
+        __sbjs_source   = terms.oops;
+        __sbjs_medium   = terms.oops;
+        __sbjs_campaign = terms.oops;
+        __sbjs_content  = terms.oops;
+        __sbjs_term     = terms.oops;
+    }
+    var sbjs_data = {
+      type:             __sbjs_type,
+      source:           __sbjs_source,
+      medium:           __sbjs_medium,
+      campaign:         __sbjs_campaign,
+      content:          __sbjs_content,
+      term:             __sbjs_term
+    };
+
+    return data.pack.main(sbjs_data);
+
+  }
+
+  function getUtmTerm() {
+    var referer = document.referrer;
+    if (get_param.utm_term) {
+      return get_param.utm_term;
+    } else if (referer && uri.parse(referer).host && uri.parse(referer).host.match(/^(?:.*\.)?yandex\..{2,9}$/i)) {
+      try {
+        return uri.getParam(uri.parse(document.referrer).query).text;
+      } catch (err) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+
+  function checkReferer(type) {
+    var referer = document.referrer;
+    switch(type) {
+      case terms.traffic.organic:
+        return (!!referer && checkRefererHost(referer) && isOrganic(referer));
+      case terms.traffic.referral:
+        return (!!referer && checkRefererHost(referer) && isReferral(referer));
+      default:
+        return false;
+    }
+  }
+
+  function checkRefererHost(referer) {
+    if (p.domain) {
+      if (!isolate) {
+        var host_regex = new RegExp('^(?:.*\\.)?' + utils.escapeRegexp(domain) + '$', 'i');
+        return !(uri.getHost(referer).match(host_regex));
+      } else {
+        return (uri.getHost(referer) !== uri.getHost(domain));
+      }
+    } else {
+      return (uri.getHost(referer) !== uri.getHost(document.location.href));
+    }
+  }
+
+  function isOrganic(referer) {
+
+    var y_host  = 'yandex',
+        y_param = 'text',
+        g_host  = 'google';
+
+    var y_host_regex  = new RegExp('^(?:.*\\.)?'  + utils.escapeRegexp(y_host)  + '\\..{2,9}$'),
+        y_param_regex = new RegExp('.*'           + utils.escapeRegexp(y_param) + '=.*'),
+        g_host_regex  = new RegExp('^(?:www\\.)?' + utils.escapeRegexp(g_host)  + '\\..{2,9}$');
+
+    if (
+        !!uri.parse(referer).query &&
+        !!uri.parse(referer).host.match(y_host_regex) &&
+        !!uri.parse(referer).query.match(y_param_regex)
+      ) {
+      __sbjs_source = y_host;
+      return true;
+    } else if (!!uri.parse(referer).host.match(g_host_regex)) {
+      __sbjs_source = g_host;
+      return true;
+    } else if (!!uri.parse(referer).query) {
+      for (var i = 0; i < p.organics.length; i++) {
+        if (
+            uri.parse(referer).host.match(new RegExp('^(?:.*\\.)?' + utils.escapeRegexp(p.organics[i].host)  + '$', 'i')) &&
+            uri.parse(referer).query.match(new RegExp('.*'         + utils.escapeRegexp(p.organics[i].param) + '=.*', 'i'))
+          ) {
+          __sbjs_source = p.organics[i].display || p.organics[i].host;
+          return true;
+        }
+        if (i + 1 === p.organics.length) {
+          return false;
+        }
+      }
+    } else {
+      return false;
+    }
+  }
+
+  function isReferral(referer) {
+    if (p.referrals.length > 0) {
+      for (var i = 0; i < p.referrals.length; i++) {
+        if (uri.parse(referer).host.match(new RegExp('^(?:.*\\.)?' + utils.escapeRegexp(p.referrals[i].host) + '$', 'i'))) {
+          __sbjs_source = p.referrals[i].display  || p.referrals[i].host;
+          __sbjs_medium = p.referrals[i].medium   || terms.referer.referral;
+          return true;
+        }
+        if (i + 1 === p.referrals.length) {
+          __sbjs_source = uri.getHost(referer);
+          return true;
+        }
+      }
+    } else {
+      __sbjs_source = uri.getHost(referer);
+      return true;
+    }
+  }
+
+  function setFirstAndCurrentExtraData() {
+    cookies.set(data.containers.current_extra, data.pack.extra(p.timezone_offset), lifetime, domain, isolate);
+    if (!cookies.get(data.containers.first_extra)) {
+      cookies.set(data.containers.first_extra, data.pack.extra(p.timezone_offset), lifetime, domain, isolate);
+    }
+  }
+
+  (function setData() {
+
+    // Main data
+    cookies.set(data.containers.current, mainData(), lifetime, domain, isolate);
+    if (!cookies.get(data.containers.first)) {
+      cookies.set(data.containers.first, cookies.get(data.containers.current), lifetime, domain, isolate);
+    }
+
+    // User data
+    var visits, udata;
+    if (!cookies.get(data.containers.udata)) {
+      visits  = 1;
+      udata   = data.pack.user(visits, p.user_ip);
+    } else {
+      visits  = parseInt(cookies.parse(data.containers.udata)[cookies.unsbjs(data.containers.udata)][data.aliases.udata.visits]) || 1;
+      visits  = cookies.get(data.containers.session) ? visits : visits + 1;
+      udata   = data.pack.user(visits, p.user_ip);
+    }
+    cookies.set(data.containers.udata, udata, lifetime, domain, isolate);
+
+    // Session
+    var pages_count;
+    if (!cookies.get(data.containers.session)) {
+      pages_count = 1;
+    } else {
+      pages_count = parseInt(cookies.parse(data.containers.session)[cookies.unsbjs(data.containers.session)][data.aliases.session.pages_seen]) || 1;
+      pages_count += 1;
+    }
+    cookies.set(data.containers.session, data.pack.session(pages_count), p.session_length, domain, isolate);
+
+    // Promocode
+    if (p.promocode && !cookies.get(data.containers.promocode)) {
+      cookies.set(data.containers.promocode, data.pack.promo(p.promocode), lifetime, domain, isolate);
+    }
+
+  })();
+
+  return cookies.parse(data.containers);
+
+};
+},{"./data":2,"./helpers/cookies":3,"./helpers/uri":4,"./helpers/utils":5,"./migrations":7,"./params":8,"./terms":9}],7:[function(_dereq_,module,exports){
+"use strict";
+
+var data    = _dereq_('./data'),
+    cookies = _dereq_('./helpers/cookies');
+
+module.exports = {
+
+  go: function(lifetime, domain, isolate) {
+
+    var migrate = this.migrations,
+        _with   = { l: lifetime, d: domain, i: isolate };
+
+    var i;
+
+    if (!cookies.get(data.containers.first) && !cookies.get(data.service.migrations)) {
+
+      var mids = [];
+      for (i = 0; i < migrate.length; i++) { mids.push(migrate[i].id); }
+
+      var advance = '';
+      for (i = 0; i < mids.length; i++) {
+        advance += mids[i] + '=1';
+        if (i < mids.length - 1) { advance += data.delimiter; }
+      }
+      cookies.set(data.service.migrations, advance, _with.l, _with.d, _with.i);
+
+    } else if (!cookies.get(data.service.migrations)) {
+
+      // We have only one migration for now, so just
+      for (i = 0; i < migrate.length; i++) {
+        migrate[i].go(migrate[i].id, _with);
+      }
+
+    }
+
+  },
+
+  migrations: [
+
+    {
+      id: '1418474375998',
+      version: '1.0.0-beta',
+      go: function(mid, _with) {
+
+        var success = mid + '=1',
+            fail    = mid + '=0';
+
+        var safeReplace = function($0, $1, $2) {
+          return ($1 || $2 ? $0 : data.delimiter);
+        };
+
+        try {
+
+          // Switch delimiter and renew cookies
+          var _in = [];
+          for (var prop in data.containers) {
+            if (data.containers.hasOwnProperty(prop)) {
+              _in.push(data.containers[prop]);
+            }
+          }
+
+          for (var i = 0; i < _in.length; i++) {
+            if (cookies.get(_in[i])) {
+              var buffer = cookies.get(_in[i]).replace(/(\|)?\|(\|)?/g, safeReplace);
+              cookies.destroy(_in[i], _with.d, _with.i);
+              cookies.destroy(_in[i], _with.d, !_with.i);
+              cookies.set(_in[i], buffer, _with.l, _with.d, _with.i);
+            }
+          }
+
+          // Update `session`
+          if (cookies.get(data.containers.session)) {
+            cookies.set(data.containers.session, data.pack.session(0), _with.l, _with.d, _with.i);
+          }
+
+          // Yay!
+          cookies.set(data.service.migrations, success, _with.l, _with.d, _with.i);
+
+        } catch (err) {
+          // Oops
+          cookies.set(data.service.migrations, fail, _with.l, _with.d, _with.i);
+        }
+      }
+    }
+
+  ]
+
+};
+},{"./data":2,"./helpers/cookies":3}],8:[function(_dereq_,module,exports){
+"use strict";
+
+var terms = _dereq_('./terms'),
+    uri   = _dereq_('./helpers/uri');
+
+module.exports = {
+
+  fetch: function(prefs) {
+
+    var user   = prefs || {},
+        params = {};
+
+    // Set `lifetime of the cookie` in months
+    params.lifetime = this.validate.checkFloat(user.lifetime) || 6;
+    params.lifetime = parseInt(params.lifetime * 30 * 24 * 60);
+
+    // Set `session length` in minutes
+    params.session_length = this.validate.checkInt(user.session_length) || 30;
+
+    // Set `timezone offset` in hours
+    params.timezone_offset = this.validate.checkInt(user.timezone_offset);
+
+    // Set `campaign param` for AdWords links
+    params.campaign_param = user.campaign_param || false;
+
+    // Set `user ip`
+    params.user_ip = user.user_ip || terms.none;
+
+    // Set `promocode`
+    if (user.promocode) {
+      params.promocode = {};
+      params.promocode.min = parseInt(user.promocode.min) || 100000;
+      params.promocode.max = parseInt(user.promocode.max) || 999999;
+    } else {
+      params.promocode = false;
+    }
+
+    // Set `typein attributes`
+    if (user.typein_attributes && user.typein_attributes.source && user.typein_attributes.medium) {
+      params.typein_attributes = {};
+      params.typein_attributes.source = user.typein_attributes.source;
+      params.typein_attributes.medium = user.typein_attributes.medium;
+    } else {
+      params.typein_attributes = { source: '(direct)', medium: '(none)' };
+    }
+
+    // Set `domain`
+    if (user.domain && this.validate.isString(user.domain)) {
+      params.domain = { host: user.domain, isolate: false };
+    } else if (user.domain && user.domain.host) {
+      params.domain = user.domain;
+    } else {
+      params.domain = { host: uri.getHost(document.location.hostname), isolate: false };
+    }
+
+    // Set `referral sources`
+    params.referrals = [];
+
+    if (user.referrals && user.referrals.length > 0) {
+      for (var ir = 0; ir < user.referrals.length; ir++) {
+        if (user.referrals[ir].host) {
+          params.referrals.push(user.referrals[ir]);
+        }
+      }
+    }
+
+    // Set `organic sources`
+    params.organics = [];
+
+    if (user.organics && user.organics.length > 0) {
+      for (var io = 0; io < user.organics.length; io++) {
+        if (user.organics[io].host && user.organics[io].param) {
+          params.organics.push(user.organics[io]);
+        }
+      }
+    }
+
+    params.organics.push({ host: 'bing.com',      param: 'q',     display: 'bing'            });
+    params.organics.push({ host: 'yahoo.com',     param: 'p',     display: 'yahoo'           });
+    params.organics.push({ host: 'about.com',     param: 'q',     display: 'about'           });
+    params.organics.push({ host: 'aol.com',       param: 'q',     display: 'aol'             });
+    params.organics.push({ host: 'ask.com',       param: 'q',     display: 'ask'             });
+    params.organics.push({ host: 'globososo.com', param: 'q',     display: 'globo'           });
+    params.organics.push({ host: 'go.mail.ru',    param: 'q',     display: 'go.mail.ru'      });
+    params.organics.push({ host: 'rambler.ru',    param: 'query', display: 'rambler'         });
+    params.organics.push({ host: 'tut.by',        param: 'query', display: 'tut.by'          });
+
+    params.referrals.push({ host: 't.co',                         display: 'twitter.com'     });
+    params.referrals.push({ host: 'plus.url.google.com',          display: 'plus.google.com' });
+
+
+    return params;
+
+  },
+
+  validate: {
+
+    checkFloat: function(v) {
+      return v && this.isNumeric(parseFloat(v)) ? parseFloat(v) : false;
+    },
+
+    checkInt: function(v) {
+      return v && this.isNumeric(parseInt(v)) ? parseInt(v) : false;
+    },
+
+    isNumeric: function(v){
+      return !isNaN(v);
+    },
+
+    isString: function(v) {
+      return Object.prototype.toString.call(v) === '[object String]';
+    }
+
+  }
+
+};
+},{"./helpers/uri":4,"./terms":9}],9:[function(_dereq_,module,exports){
+"use strict";
+
+module.exports = {
+
+  traffic: {
+    utm:        'utm',
+    organic:    'organic',
+    referral:   'referral',
+    typein:     'typein'
+  },
+
+  referer: {
+    referral:   'referral',
+    organic:    'organic',
+    social:     'social'
+  },
+
+  none:         '(none)',
+  oops:         '(Houston, we have a problem)'
+
+};
+
+},{}]},{},[1])(1)
+});
\ No newline at end of file
diff --git a/parent_dir/node_modules/unhead/dist/index.mjs b/parent_dir/node_modules/unhead/dist/index.mjs
new file mode 100644
index 0000000..e0da2af
--- /dev/null
+++ b/parent_dir/node_modules/unhead/dist/index.mjs
@@ -0,0 +1,997 @@
+import { createHooks } from 'hookable';
+import { PatchDomOnEntryUpdatesPlugin, maybeGetSSRHash } from '@unhead/dom';
+import { defineHeadPlugin, resolveTitleTemplate, hashTag, hashCode, tagDedupeKey, asArray as asArray$1, TagConfigKeys, TagsWithInnerContent, ValidHeadTags } from '@unhead/shared';
+
+const TAG_WEIGHTS = {
+  // aliases
+  critical: 2,
+  high: 9,
+  low: 12,
+  // tags
+  base: -1,
+  title: 1,
+  meta: 10
+};
+function tagWeight(tag) {
+  if (typeof tag.tagPriority === "number")
+    return tag.tagPriority;
+  if (tag.tag === "meta") {
+    if (tag.props.charset)
+      return -2;
+    if (tag.props["http-equiv"] === "content-security-policy")
+      return 0;
+  }
+  const key = tag.tagPriority || tag.tag;
+  if (key in TAG_WEIGHTS) {
+    return TAG_WEIGHTS[key];
+  }
+  return 10;
+}
+const SortModifiers = [{ prefix: "before:", offset: -1 }, { prefix: "after:", offset: 1 }];
+function SortTagsPlugin() {
+  return defineHeadPlugin({
+    hooks: {
+      "tags:resolve": (ctx) => {
+        const tagPositionForKey = (key) => ctx.tags.find((tag) => tag._d === key)?._p;
+        for (const { prefix, offset } of SortModifiers) {
+          for (const tag of ctx.tags.filter((tag2) => typeof tag2.tagPriority === "string" && tag2.tagPriority.startsWith(prefix))) {
+            const position = tagPositionForKey(
+              tag.tagPriority.replace(prefix, "")
+            );
+            if (typeof position !== "undefined")
+              tag._p = position + offset;
+          }
+        }
+        ctx.tags.sort((a, b) => a._p - b._p).sort((a, b) => tagWeight(a) - tagWeight(b));
+      }
+    }
+  });
+}
+
+const TitleTemplatePlugin = () => {
+  return defineHeadPlugin({
+    hooks: {
+      "tags:resolve": (ctx) => {
+        const { tags } = ctx;
+        let titleTemplateIdx = tags.findIndex((i) => i.tag === "titleTemplate");
+        const titleIdx = tags.findIndex((i) => i.tag === "title");
+        if (titleIdx !== -1 && titleTemplateIdx !== -1) {
+          const newTitle = resolveTitleTemplate(
+            tags[titleTemplateIdx].textContent,
+            tags[titleIdx].textContent
+          );
+          if (newTitle !== null) {
+            tags[titleIdx].textContent = newTitle || tags[titleIdx].textContent;
+          } else {
+            delete tags[titleIdx];
+          }
+        } else if (titleTemplateIdx !== -1) {
+          const newTitle = resolveTitleTemplate(
+            tags[titleTemplateIdx].textContent
+          );
+          if (newTitle !== null) {
+            tags[titleTemplateIdx].textContent = newTitle;
+            tags[titleTemplateIdx].tag = "title";
+            titleTemplateIdx = -1;
+          }
+        }
+        if (titleTemplateIdx !== -1) {
+          delete tags[titleTemplateIdx];
+        }
+        ctx.tags = tags.filter(Boolean);
+      }
+    }
+  });
+};
+
+const DeprecatedTagAttrPlugin = () => {
+  return defineHeadPlugin({
+    hooks: {
+      "tag:normalise": function({ tag }) {
+        if (typeof tag.props.body !== "undefined") {
+          tag.tagPosition = "bodyClose";
+          delete tag.props.body;
+        }
+      }
+    }
+  });
+};
+
+const DupeableTags = ["link", "style", "script", "noscript"];
+const ProvideTagHashPlugin = () => {
+  return defineHeadPlugin({
+    hooks: {
+      "tag:normalise": ({ tag, resolvedOptions }) => {
+        if (resolvedOptions.experimentalHashHydration === true) {
+          tag._h = hashTag(tag);
+        }
+        if (tag.key && DupeableTags.includes(tag.tag)) {
+          tag._h = hashCode(tag.key);
+          tag.props[`data-h-${tag._h}`] = "";
+        }
+      }
+    }
+  });
+};
+
+const ValidEventTags = ["script", "link", "bodyAttrs"];
+const EventHandlersPlugin = () => {
+  const stripEventHandlers = (mode, tag) => {
+    const props = {};
+    const eventHandlers = {};
+    Object.entries(tag.props).forEach(([key, value]) => {
+      if (key.startsWith("on") && typeof value === "function")
+        eventHandlers[key] = value;
+      else
+        props[key] = value;
+    });
+    let delayedSrc;
+    if (mode === "dom" && tag.tag === "script" && typeof props.src === "string" && typeof eventHandlers.onload !== "undefined") {
+      delayedSrc = props.src;
+      delete props.src;
+    }
+    return { props, eventHandlers, delayedSrc };
+  };
+  return defineHeadPlugin({
+    hooks: {
+      "ssr:render": function(ctx) {
+        ctx.tags = ctx.tags.map((tag) => {
+          if (!ValidEventTags.includes(tag.tag))
+            return tag;
+          if (!Object.entries(tag.props).find(([key, value]) => key.startsWith("on") && typeof value === "function"))
+            return tag;
+          tag.props = stripEventHandlers("ssr", tag).props;
+          return tag;
+        });
+      },
+      "dom:beforeRenderTag": function(ctx) {
+        if (!ValidEventTags.includes(ctx.tag.tag))
+          return;
+        if (!Object.entries(ctx.tag.props).find(([key, value]) => key.startsWith("on") && typeof value === "function"))
+          return;
+        const { props, eventHandlers, delayedSrc } = stripEventHandlers("dom", ctx.tag);
+        if (!Object.keys(eventHandlers).length)
+          return;
+        ctx.tag.props = props;
+        ctx.tag._eventHandlers = eventHandlers;
+        ctx.tag._delayedSrc = delayedSrc;
+      },
+      "dom:renderTag": function(ctx) {
+        const $el = ctx.$el;
+        if (!ctx.tag._eventHandlers || !$el)
+          return;
+        const $eventListenerTarget = ctx.tag.tag === "bodyAttrs" && typeof window !== "undefined" ? window : $el;
+        Object.entries(ctx.tag._eventHandlers).forEach(([k, value]) => {
+          const sdeKey = `${ctx.tag._d || ctx.tag._p}:${k}`;
+          const eventName = k.slice(2).toLowerCase();
+          const eventDedupeKey = `data-h-${eventName}`;
+          ctx.markSideEffect(sdeKey, () => {
+          });
+          if ($el.hasAttribute(eventDedupeKey))
+            return;
+          const handler = value;
+          $el.setAttribute(eventDedupeKey, "");
+          $eventListenerTarget.addEventListener(eventName, handler);
+          if (ctx.entry) {
+            ctx.entry._sde[sdeKey] = () => {
+              $eventListenerTarget.removeEventListener(eventName, handler);
+              $el.removeAttribute(eventDedupeKey);
+            };
+          }
+        });
+        if (ctx.tag._delayedSrc) {
+          $el.setAttribute("src", ctx.tag._delayedSrc);
+        }
+      }
+    }
+  });
+};
+
+const UsesMergeStrategy = ["templateParams", "htmlAttrs", "bodyAttrs"];
+const DedupesTagsPlugin = () => {
+  return defineHeadPlugin({
+    hooks: {
+      "tag:normalise": function({ tag }) {
+        ["hid", "vmid", "key"].forEach((key) => {
+          if (tag.props[key]) {
+            tag.key = tag.props[key];
+            delete tag.props[key];
+          }
+        });
+        const dedupe = tag.key ? `${tag.tag}:${tag.key}` : tagDedupeKey(tag);
+        if (dedupe)
+          tag._d = dedupe;
+      },
+      "tags:resolve": function(ctx) {
+        const deduping = {};
+        ctx.tags.forEach((tag) => {
+          const dedupeKey = tag._d || tag._p;
+          const dupedTag = deduping[dedupeKey];
+          if (dupedTag) {
+            let strategy = tag?.tagDuplicateStrategy;
+            if (!strategy && UsesMergeStrategy.includes(tag.tag))
+              strategy = "merge";
+            if (strategy === "merge") {
+              const oldProps = dupedTag.props;
+              ["class", "style"].forEach((key) => {
+                if (tag.props[key] && oldProps[key]) {
+                  if (key === "style" && !oldProps[key].endsWith(";"))
+                    oldProps[key] += ";";
+                  tag.props[key] = `${oldProps[key]} ${tag.props[key]}`;
+                }
+              });
+              deduping[dedupeKey].props = {
+                ...oldProps,
+                ...tag.props
+              };
+              return;
+            } else if (tag._e === dupedTag._e) {
+              dupedTag._duped = dupedTag._duped || [];
+              tag._d = `${dupedTag._d}:${dupedTag._duped.length + 1}`;
+              dupedTag._duped.push(tag);
+              return;
+            }
+            const propCount = Object.keys(tag.props).length;
+            if ((propCount === 0 || propCount === 1 && typeof tag.props["data-h-key"] !== "undefined") && !tag.innerHTML && !tag.textContent) {
+              delete deduping[dedupeKey];
+              return;
+            }
+          }
+          deduping[dedupeKey] = tag;
+        });
+        const newTags = [];
+        Object.values(deduping).forEach((tag) => {
+          const dupes = tag._duped;
+          delete tag._duped;
+          newTags.push(tag);
+          if (dupes)
+            newTags.push(...dupes);
+        });
+        ctx.tags = newTags;
+      }
+    }
+  });
+};
+
+function processTemplateParams(s, config) {
+  function sub(token) {
+    if (["s", "pageTitle"].includes(token))
+      return config.pageTitle;
+    let val;
+    if (token.includes(".")) {
+      val = token.split(".").reduce((acc, key) => acc ? acc[key] || void 0 : void 0, config);
+    } else {
+      val = config[token];
+    }
+    return typeof val !== "undefined" ? val || "" : false;
+  }
+  let decoded = s;
+  try {
+    decoded = decodeURI(s);
+  } catch {
+  }
+  const tokens = (decoded.match(/%(\w+\.+\w+)|%(\w+)/g) || []).sort().reverse();
+  tokens.forEach((token) => {
+    const re = sub(token.slice(1));
+    if (typeof re === "string") {
+      s = s.replaceAll(new RegExp(`\\${token}(\\W|$)`, "g"), `${re}$1`).trim();
+    }
+  });
+  if (config.separator) {
+    if (s.endsWith(config.separator))
+      s = s.slice(0, -config.separator.length).trim();
+    if (s.startsWith(config.separator))
+      s = s.slice(config.separator.length).trim();
+    s = s.replace(new RegExp(`\\${config.separator}\\s*\\${config.separator}`, "g"), config.separator);
+  }
+  return s;
+}
+function TemplateParamsPlugin() {
+  return defineHeadPlugin({
+    hooks: {
+      "tags:resolve": (ctx) => {
+        const { tags } = ctx;
+        const title = tags.find((tag) => tag.tag === "title")?.textContent;
+        const idx = tags.findIndex((tag) => tag.tag === "templateParams");
+        const params = idx !== -1 ? tags[idx].props : {};
+        params.pageTitle = params.pageTitle || title || "";
+        for (const tag of tags) {
+          if (["titleTemplate", "title"].includes(tag.tag) && typeof tag.textContent === "string") {
+            tag.textContent = processTemplateParams(tag.textContent, params);
+          } else if (tag.tag === "meta" && typeof tag.props.content === "string") {
+            tag.props.content = processTemplateParams(tag.props.content, params);
+          } else if (tag.tag === "link" && typeof tag.props.href === "string") {
+            tag.props.href = processTemplateParams(tag.props.href, params);
+          } else if (tag.tag === "script" && ["application/json", "application/ld+json"].includes(tag.props.type) && typeof tag.innerHTML === "string") {
+            try {
+              tag.innerHTML = JSON.stringify(JSON.parse(tag.innerHTML), (key, val) => {
+                if (typeof val === "string")
+                  return processTemplateParams(val, params);
+                return val;
+              });
+            } catch {
+            }
+          }
+        }
+        ctx.tags = tags.filter((tag) => tag.tag !== "templateParams");
+      }
+    }
+  });
+}
+
+const IsBrowser = typeof window !== "undefined";
+
+let activeHead;
+const setActiveHead = (head) => activeHead = head;
+const getActiveHead = () => activeHead;
+
+function useHead(input, options = {}) {
+  const head = getActiveHead();
+  if (head) {
+    const isBrowser = IsBrowser || head.resolvedOptions?.document;
+    if (options.mode === "server" && isBrowser || options.mode === "client" && !isBrowser)
+      return;
+    return head.push(input, options);
+  }
+}
+
+function useHeadSafe(input, options = {}) {
+  return useHead(input, {
+    ...options || {},
+    transform: whitelistSafeInput
+  });
+}
+
+function useServerHead(input, options = {}) {
+  return useHead(input, { ...options, mode: "server" });
+}
+
+function useServerHeadSafe(input, options = {}) {
+  return useHeadSafe(input, { ...options, mode: "server" });
+}
+
+function useSeoMeta(input, options) {
+  const { title, titleTemplate, ...meta } = input;
+  return useHead({
+    title,
+    titleTemplate,
+    meta: unpackMeta(meta)
+  }, options);
+}
+
+function useServerSeoMeta(input, options) {
+  return useSeoMeta(input, {
+    ...options || {},
+    mode: "server"
+  });
+}
+
+const useTagTitle = (title) => useHead({ title });
+const useTagBase = (base) => useHead({ base });
+const useTagMeta = (meta) => useHead({ meta: asArray$1(meta) });
+const useTagMetaFlat = (meta) => useTagMeta(unpackMeta(meta));
+const useTagLink = (link) => useHead({ link: asArray$1(link) });
+const useTagScript = (script) => useHead({ script: asArray$1(script) });
+const useTagStyle = (style) => useHead({ style: asArray$1(style) });
+const useTagNoscript = (noscript) => useHead({ noscript: asArray$1(noscript) });
+const useHtmlAttrs = (attrs) => useHead({ htmlAttrs: attrs });
+const useBodyAttrs = (attrs) => useHead({ bodyAttrs: attrs });
+const useTitleTemplate = (titleTemplate) => useHead({ titleTemplate });
+const useServerTagTitle = (title) => useServerHead({ title });
+const useServerTagBase = (base) => useServerHead({ base });
+const useServerTagMeta = (meta) => useServerHead({ meta: asArray$1(meta) });
+const useServerTagMetaFlat = (meta) => useServerTagMeta(unpackMeta(meta));
+const useServerTagLink = (link) => useServerHead({ link: asArray$1(link) });
+const useServerTagScript = (script) => useServerHead({ script: asArray$1(script) });
+const useServerTagStyle = (style) => useServerHead({ style: asArray$1(style) });
+const useServerTagNoscript = (noscript) => useServerHead({ noscript: asArray$1(noscript) });
+const useServerHtmlAttrs = (attrs) => useServerHead({ htmlAttrs: attrs });
+const useServerBodyAttrs = (attrs) => useServerHead({ bodyAttrs: attrs });
+const useServerTitleTemplate = (titleTemplate) => useServerHead({ titleTemplate });
+
+function asArray(input) {
+  return Array.isArray(input) ? input : [input];
+}
+const InternalKeySymbol = "_$key";
+function packObject(input, options) {
+  const keys = Object.keys(input);
+  let [k, v] = keys;
+  options = options || {};
+  options.key = options.key || k;
+  options.value = options.value || v;
+  options.resolveKey = options.resolveKey || ((k2) => k2);
+  const resolveKey = (index) => {
+    const arr = asArray(options?.[index]);
+    return arr.find((k2) => {
+      if (typeof k2 === "string" && k2.includes(".")) {
+        return k2;
+      }
+      return k2 && keys.includes(k2);
+    });
+  };
+  const resolveValue = (k2, input2) => {
+    if (k2.includes(".")) {
+      const paths = k2.split(".");
+      let val = input2;
+      for (const path of paths)
+        val = val[path];
+      return val;
+    }
+    return input2[k2];
+  };
+  k = resolveKey("key") || k;
+  v = resolveKey("value") || v;
+  const dedupeKeyPrefix = input.key ? `${InternalKeySymbol}${input.key}-` : "";
+  let keyValue = resolveValue(k, input);
+  keyValue = options.resolveKey(keyValue);
+  return {
+    [`${dedupeKeyPrefix}${keyValue}`]: resolveValue(v, input)
+  };
+}
+
+function packArray(input, options) {
+  const packed = {};
+  for (const i of input) {
+    const packedObj = packObject(i, options);
+    const pKey = Object.keys(packedObj)[0];
+    const isDedupeKey = pKey.startsWith(InternalKeySymbol);
+    if (!isDedupeKey && packed[pKey]) {
+      packed[pKey] = Array.isArray(packed[pKey]) ? packed[pKey] : [packed[pKey]];
+      packed[pKey].push(Object.values(packedObj)[0]);
+    } else {
+      packed[isDedupeKey ? pKey.split("-").slice(1).join("-") || pKey : pKey] = packedObj[pKey];
+    }
+  }
+  return packed;
+}
+
+function unpackToArray(input, options) {
+  const unpacked = [];
+  const kFn = options.resolveKeyData || ((ctx) => ctx.key);
+  const vFn = options.resolveValueData || ((ctx) => ctx.value);
+  for (const [k, v] of Object.entries(input)) {
+    unpacked.push(...(Array.isArray(v) ? v : [v]).map((i) => {
+      const ctx = { key: k, value: i };
+      const val = vFn(ctx);
+      if (typeof val === "object")
+        return unpackToArray(val, options);
+      if (Array.isArray(val))
+        return val;
+      return {
+        [typeof options.key === "function" ? options.key(ctx) : options.key]: kFn(ctx),
+        [typeof options.value === "function" ? options.value(ctx) : options.value]: val
+      };
+    }).flat());
+  }
+  return unpacked;
+}
+
+function unpackToString(value, options) {
+  return Object.entries(value).map(([key, value2]) => {
+    if (typeof value2 === "object")
+      value2 = unpackToString(value2, options);
+    if (options.resolve) {
+      const resolved = options.resolve({ key, value: value2 });
+      if (resolved)
+        return resolved;
+    }
+    if (typeof value2 === "number")
+      value2 = value2.toString();
+    if (typeof value2 === "string" && options.wrapValue) {
+      value2 = value2.replace(new RegExp(options.wrapValue, "g"), `\\${options.wrapValue}`);
+      value2 = `${options.wrapValue}${value2}${options.wrapValue}`;
+    }
+    return `${key}${options.keyValueSeparator || ""}${value2}`;
+  }).join(options.entrySeparator || "");
+}
+
+const MetaPackingSchema = {
+  robots: {
+    unpack: {
+      keyValueSeparator: ":"
+    }
+  },
+  // Pragma directives
+  contentSecurityPolicy: {
+    unpack: {
+      keyValueSeparator: " ",
+      entrySeparator: "; "
+    },
+    metaKey: "http-equiv"
+  },
+  fbAppId: {
+    keyValue: "fb:app_id",
+    metaKey: "property"
+  },
+  ogSiteName: {
+    keyValue: "og:site_name"
+  },
+  msapplicationTileImage: {
+    keyValue: "msapplication-TileImage"
+  },
+  /**
+   * Tile colour for windows
+   */
+  msapplicationTileColor: {
+    keyValue: "msapplication-TileColor"
+  },
+  /**
+   * URL of a config for windows tile.
+   */
+  msapplicationConfig: {
+    keyValue: "msapplication-Config"
+  },
+  charset: {
+    metaKey: "charset"
+  },
+  contentType: {
+    metaKey: "http-equiv"
+  },
+  defaultStyle: {
+    metaKey: "http-equiv"
+  },
+  xUaCompatible: {
+    metaKey: "http-equiv"
+  },
+  refresh: {
+    metaKey: "http-equiv"
+  }
+};
+
+function packMeta(inputs) {
+  const mappedPackingSchema = Object.entries(MetaPackingSchema).map(([key, value]) => [key, value.keyValue]);
+  return packArray(inputs, {
+    key: ["name", "property", "httpEquiv", "http-equiv", "charset"],
+    value: ["content", "charset"],
+    resolveKey(k) {
+      let key = mappedPackingSchema.filter((sk) => sk[1] === k)?.[0]?.[0] || k;
+      const replacer = (_, letter) => letter?.toUpperCase();
+      key = key.replace(/:([a-z])/g, replacer).replace(/-([a-z])/g, replacer);
+      return key;
+    }
+  });
+}
+
+const ArrayableInputs = ["Image", "Video", "Audio"];
+const ColonPrefixKeys = /^(og|twitter|fb)/;
+const PropertyPrefixKeys = /^(og|fb)/;
+function resolveMetaKeyType(key) {
+  return PropertyPrefixKeys.test(key) ? "property" : MetaPackingSchema[key]?.metaKey || "name";
+}
+function resolveMetaKeyValue(key) {
+  return MetaPackingSchema[key]?.keyValue || fixKeyCase(key);
+}
+function fixKeyCase(key) {
+  key = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+  if (ColonPrefixKeys.test(key)) {
+    key = key.replace("secure-url", "secure_url").replace(/-/g, ":");
+  }
+  return key;
+}
+function changeKeyCasingDeep(input) {
+  if (Array.isArray(input)) {
+    return input.map((entry) => changeKeyCasingDeep(entry));
+  }
+  if (typeof input !== "object" || Array.isArray(input))
+    return input;
+  const output = {};
+  for (const [key, value] of Object.entries(input))
+    output[fixKeyCase(key)] = changeKeyCasingDeep(value);
+  return output;
+}
+function unpackMeta(input) {
+  const extras = [];
+  ArrayableInputs.forEach((key) => {
+    const ogKey = `og:${key.toLowerCase()}`;
+    const inputKey = `og${key}`;
+    const val = input[inputKey];
+    if (typeof val === "object") {
+      (Array.isArray(val) ? val : [val]).forEach((entry) => {
+        if (!entry)
+          return;
+        const unpackedEntry = unpackToArray(entry, {
+          key: "property",
+          value: "content",
+          resolveKeyData({ key: key2 }) {
+            return fixKeyCase(`${ogKey}${key2 !== "url" ? `:${key2}` : ""}`);
+          },
+          resolveValueData({ value }) {
+            return typeof value === "number" ? value.toString() : value;
+          }
+        });
+        extras.push(
+          ...unpackedEntry.sort((a, b) => a.property === ogKey ? -1 : b.property === ogKey ? 1 : 0)
+        );
+      });
+      delete input[inputKey];
+    }
+  });
+  const meta = unpackToArray(input, {
+    key({ key }) {
+      return resolveMetaKeyType(key);
+    },
+    value({ key }) {
+      return key === "charset" ? "charset" : "content";
+    },
+    resolveKeyData({ key }) {
+      return resolveMetaKeyValue(key);
+    },
+    resolveValueData({ value, key }) {
+      if (value === null)
+        return "_null";
+      if (typeof value === "object")
+        return resolvePackedMetaObjectValue(value, key);
+      return typeof value === "number" ? value.toString() : value;
+    }
+  });
+  return [...extras, ...meta].filter((v) => typeof v.content === "undefined" || v.content !== "_null");
+}
+function resolvePackedMetaObjectValue(value, key) {
+  const definition = MetaPackingSchema[key];
+  if (key === "refresh")
+    return `${value.seconds};url=${value.url}`;
+  return unpackToString(
+    changeKeyCasingDeep(value),
+    {
+      entrySeparator: ", ",
+      keyValueSeparator: "=",
+      resolve({ value: value2, key: key2 }) {
+        if (value2 === null)
+          return "";
+        if (typeof value2 === "boolean")
+          return `${key2}`;
+      },
+      ...definition?.unpack
+    }
+  );
+}
+
+async function normaliseTag(tagName, input) {
+  const tag = { tag: tagName, props: {} };
+  if (tagName === "templateParams") {
+    tag.props = input;
+    return tag;
+  }
+  if (["title", "titleTemplate"].includes(tagName)) {
+    tag.textContent = input instanceof Promise ? await input : input;
+    return tag;
+  }
+  if (typeof input === "string") {
+    if (!["script", "noscript", "style"].includes(tagName))
+      return false;
+    if (tagName === "script" && (/^(https?:)?\/\//.test(input) || input.startsWith("/")))
+      tag.props.src = input;
+    else
+      tag.innerHTML = input;
+    return tag;
+  }
+  tag.props = await normaliseProps(tagName, { ...input });
+  if (tag.props.children) {
+    tag.props.innerHTML = tag.props.children;
+  }
+  delete tag.props.children;
+  Object.keys(tag.props).filter((k) => TagConfigKeys.includes(k)).forEach((k) => {
+    if (!["innerHTML", "textContent"].includes(k) || TagsWithInnerContent.includes(tag.tag)) {
+      tag[k] = tag.props[k];
+    }
+    delete tag.props[k];
+  });
+  ["innerHTML", "textContent"].forEach((k) => {
+    if (tag.tag === "script" && typeof tag[k] === "string" && ["application/ld+json", "application/json"].includes(tag.props.type)) {
+      try {
+        tag[k] = JSON.parse(tag[k]);
+      } catch (e) {
+        tag[k] = "";
+      }
+    }
+    if (typeof tag[k] === "object")
+      tag[k] = JSON.stringify(tag[k]);
+  });
+  if (tag.props.class)
+    tag.props.class = normaliseClassProp(tag.props.class);
+  if (tag.props.content && Array.isArray(tag.props.content))
+    return tag.props.content.map((v) => ({ ...tag, props: { ...tag.props, content: v } }));
+  return tag;
+}
+function normaliseClassProp(v) {
+  if (typeof v === "object" && !Array.isArray(v)) {
+    v = Object.keys(v).filter((k) => v[k]);
+  }
+  return (Array.isArray(v) ? v.join(" ") : v).split(" ").filter((c) => c.trim()).filter(Boolean).join(" ");
+}
+async function normaliseProps(tagName, props) {
+  for (const k of Object.keys(props)) {
+    const isDataKey = k.startsWith("data-");
+    if (props[k] instanceof Promise) {
+      props[k] = await props[k];
+    }
+    if (String(props[k]) === "true") {
+      props[k] = isDataKey ? "true" : "";
+    } else if (String(props[k]) === "false") {
+      if (isDataKey) {
+        props[k] = "false";
+      } else {
+        delete props[k];
+      }
+    }
+  }
+  return props;
+}
+const TagEntityBits = 10;
+async function normaliseEntryTags(e) {
+  const tagPromises = [];
+  Object.entries(e.resolvedInput).filter(([k, v]) => typeof v !== "undefined" && ValidHeadTags.includes(k)).forEach(([k, value]) => {
+    const v = asArray$1(value);
+    tagPromises.push(...v.map((props) => normaliseTag(k, props)).flat());
+  });
+  return (await Promise.all(tagPromises)).flat().filter(Boolean).map((t, i) => {
+    t._e = e._i;
+    t._p = (e._i << TagEntityBits) + i;
+    return t;
+  });
+}
+
+const WhitelistAttributes = {
+  htmlAttrs: ["id", "class", "lang", "dir"],
+  bodyAttrs: ["id", "class"],
+  meta: ["id", "name", "property", "charset", "content"],
+  noscript: ["id", "textContent"],
+  script: ["id", "type", "textContent"],
+  link: ["id", "color", "crossorigin", "fetchpriority", "href", "hreflang", "imagesrcset", "imagesizes", "integrity", "media", "referrerpolicy", "rel", "sizes", "type"]
+};
+function whitelistSafeInput(input) {
+  const filtered = {};
+  Object.keys(input).forEach((key) => {
+    const tagValue = input[key];
+    if (!tagValue)
+      return;
+    switch (key) {
+      case "title":
+      case "titleTemplate":
+      case "templateParams":
+        filtered[key] = tagValue;
+        break;
+      case "htmlAttrs":
+      case "bodyAttrs":
+        filtered[key] = {};
+        WhitelistAttributes[key].forEach((a) => {
+          if (tagValue[a])
+            filtered[key][a] = tagValue[a];
+        });
+        Object.keys(tagValue || {}).filter((a) => a.startsWith("data-")).forEach((a) => {
+          filtered[key][a] = tagValue[a];
+        });
+        break;
+      case "meta":
+        if (Array.isArray(tagValue)) {
+          filtered[key] = tagValue.map((meta) => {
+            const safeMeta = {};
+            WhitelistAttributes.meta.forEach((key2) => {
+              if (meta[key2] || key2.startsWith("data-"))
+                safeMeta[key2] = meta[key2];
+            });
+            return safeMeta;
+          }).filter((meta) => Object.keys(meta).length > 0);
+        }
+        break;
+      case "link":
+        if (Array.isArray(tagValue)) {
+          filtered[key] = tagValue.map((meta) => {
+            const link = {};
+            WhitelistAttributes.link.forEach((key2) => {
+              if (key2 === "rel" && ["stylesheet", "canonical", "modulepreload", "prerender", "preload", "prefetch"].includes(meta[key2]))
+                return;
+              if (key2 === "href") {
+                try {
+                  const url = new URL(meta[key2]);
+                  if (["javascript:", "data:"].includes(url.protocol))
+                    return;
+                  link[key2] = meta[key2];
+                } catch (e) {
+                }
+              } else if (meta[key2] || key2.startsWith("data-")) {
+                link[key2] = meta[key2];
+              }
+            });
+            return link;
+          }).filter((link) => Object.keys(link).length > 1 && !!link.rel);
+        }
+        break;
+      case "noscript":
+        if (Array.isArray(tagValue)) {
+          filtered[key] = tagValue.map((meta) => {
+            const noscript = {};
+            WhitelistAttributes.noscript.forEach((key2) => {
+              if (meta[key2] || key2.startsWith("data-"))
+                noscript[key2] = meta[key2];
+            });
+            return noscript;
+          }).filter((meta) => Object.keys(meta).length > 0);
+        }
+        break;
+      case "script":
+        if (Array.isArray(tagValue)) {
+          filtered[key] = tagValue.map((script) => {
+            const safeScript = {};
+            WhitelistAttributes.script.forEach((s) => {
+              if (script[s] || s.startsWith("data-")) {
+                if (s === "textContent") {
+                  try {
+                    const jsonVal = typeof script[s] === "string" ? JSON.parse(script[s]) : script[s];
+                    safeScript[s] = JSON.stringify(jsonVal, null, 0);
+                  } catch (e) {
+                  }
+                } else {
+                  safeScript[s] = script[s];
+                }
+              }
+            });
+            return safeScript;
+          }).filter((meta) => Object.keys(meta).length > 0);
+        }
+        break;
+    }
+  });
+  return filtered;
+}
+
+const CorePlugins = () => [
+  // dedupe needs to come first
+  DedupesTagsPlugin(),
+  SortTagsPlugin(),
+  TemplateParamsPlugin(),
+  TitleTemplatePlugin(),
+  ProvideTagHashPlugin(),
+  EventHandlersPlugin(),
+  DeprecatedTagAttrPlugin()
+];
+const DOMPlugins = (options = {}) => [
+  PatchDomOnEntryUpdatesPlugin({ document: options?.document, delayFn: options?.domDelayFn })
+];
+function createHead(options = {}) {
+  const head = createHeadCore({
+    ...options,
+    plugins: [...DOMPlugins(options), ...options?.plugins || []]
+  });
+  if (options.experimentalHashHydration && head.resolvedOptions.document)
+    head._hash = maybeGetSSRHash(head.resolvedOptions.document);
+  setActiveHead(head);
+  return head;
+}
+function createServerHead(options = {}) {
+  const head = createHeadCore(options);
+  setActiveHead(head);
+  return head;
+}
+function createHeadCore(options = {}) {
+  let entries = [];
+  let _sde = {};
+  let _eid = 0;
+  const hooks = createHooks();
+  if (options?.hooks)
+    hooks.addHooks(options.hooks);
+  options.plugins = [
+    ...CorePlugins(),
+    ...options?.plugins || []
+  ];
+  options.plugins.forEach((p) => p.hooks && hooks.addHooks(p.hooks));
+  options.document = options.document || (IsBrowser ? document : void 0);
+  const updated = () => hooks.callHook("entries:updated", head);
+  const head = {
+    resolvedOptions: options,
+    headEntries() {
+      return entries;
+    },
+    get hooks() {
+      return hooks;
+    },
+    use(plugin) {
+      if (plugin.hooks)
+        hooks.addHooks(plugin.hooks);
+    },
+    push(input, options2) {
+      const activeEntry = {
+        _i: _eid++,
+        input,
+        _sde: {}
+      };
+      if (options2?.mode)
+        activeEntry._m = options2?.mode;
+      if (options2?.transform) {
+        activeEntry._t = options2?.transform;
+      }
+      entries.push(activeEntry);
+      updated();
+      return {
+        dispose() {
+          entries = entries.filter((e) => {
+            if (e._i !== activeEntry._i)
+              return true;
+            _sde = { ..._sde, ...e._sde || {} };
+            e._sde = {};
+            updated();
+            return false;
+          });
+        },
+        // a patch is the same as creating a new entry, just a nice DX
+        patch(input2) {
+          entries = entries.map((e) => {
+            if (e._i === activeEntry._i) {
+              activeEntry.input = e.input = input2;
+              updated();
+            }
+            return e;
+          });
+        }
+      };
+    },
+    async resolveTags() {
+      const resolveCtx = { tags: [], entries: [...entries] };
+      await hooks.callHook("entries:resolve", resolveCtx);
+      for (const entry of resolveCtx.entries) {
+        const transformer = entry._t || ((i) => i);
+        entry.resolvedInput = transformer(entry.resolvedInput || entry.input);
+        if (entry.resolvedInput) {
+          for (const tag of await normaliseEntryTags(entry)) {
+            const tagCtx = { tag, entry, resolvedOptions: head.resolvedOptions };
+            await hooks.callHook("tag:normalise", tagCtx);
+            resolveCtx.tags.push(tagCtx.tag);
+          }
+        }
+      }
+      await hooks.callHook("tags:resolve", resolveCtx);
+      return resolveCtx.tags;
+    },
+    _popSideEffectQueue() {
+      const sde = { ..._sde };
+      _sde = {};
+      return sde;
+    },
+    _elMap: {}
+  };
+  head.hooks.callHook("init", head);
+  return head;
+}
+
+const coreComposableNames = [
+  "getActiveHead"
+];
+const composableNames = [
+  "useHead",
+  "useSeoMeta",
+  "useHeadSafe",
+  "useServerHead",
+  "useServerSeoMeta",
+  "useServerHeadSafe",
+  // deprecated
+  "useTagTitle",
+  "useTagBase",
+  "useTagMeta",
+  "useTagMetaFlat",
+  "useTagLink",
+  "useTagScript",
+  "useTagStyle",
+  "useTagNoscript",
+  "useHtmlAttrs",
+  "useBodyAttrs",
+  "useTitleTemplate",
+  "useServerTagTitle",
+  "useServerTagBase",
+  "useServerTagMeta",
+  "useServerTagMetaFlat",
+  "useServerTagLink",
+  "useServerTagScript",
+  "useServerTagStyle",
+  "useServerTagNoscript",
+  "useServerHtmlAttrs",
+  "useServerBodyAttrs",
+  "useServerTitleTemplate"
+];
+const unheadComposablesImports = [
+  {
+    from: "unhead",
+    imports: [...coreComposableNames, ...composableNames]
+  }
+];
+
+export { CorePlugins, DOMPlugins, DedupesTagsPlugin, DeprecatedTagAttrPlugin, EventHandlersPlugin, ProvideTagHashPlugin, SortModifiers, SortTagsPlugin, TAG_WEIGHTS, TagEntityBits, TemplateParamsPlugin, TitleTemplatePlugin, activeHead, composableNames, createHead, createHeadCore, createServerHead, getActiveHead, normaliseClassProp, normaliseEntryTags, normaliseProps, normaliseTag, packMeta, processTemplateParams, resolveMetaKeyType, resolveMetaKeyValue, resolvePackedMetaObjectValue, setActiveHead, tagWeight, unheadComposablesImports, unpackMeta, useBodyAttrs, useHead, useHeadSafe, useHtmlAttrs, useSeoMeta, useServerBodyAttrs, useServerHead, useServerHeadSafe, useServerHtmlAttrs, useServerSeoMeta, useServerTagBase, useServerTagLink, useServerTagMeta, useServerTagMetaFlat, useServerTagNoscript, useServerTagScript, useServerTagStyle, useServerTagTitle, useServerTitleTemplate, useTagBase, useTagLink, useTagMeta, useTagMetaFlat, useTagNoscript, useTagScript, useTagStyle, useTagTitle, useTitleTemplate, whitelistSafeInput };
diff --git a/parent_dir/node_modules/unhead/dom/dist/index.mjs b/parent_dir/node_modules/unhead/dom/dist/index.mjs
new file mode 100644
index 0000000..e8707e9
--- /dev/null
+++ b/parent_dir/node_modules/unhead/dom/dist/index.mjs
@@ -0,0 +1,199 @@
+import { TagsWithInnerContent, computeHashes, hashTag, HasElementTags, tagDedupeKey, defineHeadPlugin } from '@unhead/shared';
+
+const setAttrs = (ctx, newEntry = false, markSideEffect) => {
+  const { tag, $el } = ctx;
+  if (!$el)
+    return;
+  Object.entries(tag.props).forEach(([k, value]) => {
+    value = String(value);
+    const attrSdeKey = `attr:${k}`;
+    if (k === "class") {
+      if (!value)
+        return;
+      for (const c of value.split(" ")) {
+        const classSdeKey = `${attrSdeKey}:${c}`;
+        if (markSideEffect)
+          markSideEffect(ctx, classSdeKey, () => $el.classList.remove(c));
+        if (!$el.classList.contains(c))
+          $el.classList.add(c);
+      }
+      return;
+    }
+    if (markSideEffect && !k.startsWith("data-h-"))
+      markSideEffect(ctx, attrSdeKey, () => $el.removeAttribute(k));
+    if (newEntry || $el.getAttribute(k) !== value)
+      $el.setAttribute(k, value);
+  });
+  if (TagsWithInnerContent.includes(tag.tag)) {
+    if (tag.textContent && tag.textContent !== $el.textContent)
+      $el.textContent = tag.textContent;
+    else if (tag.innerHTML && tag.innerHTML !== $el.innerHTML)
+      $el.innerHTML = tag.innerHTML;
+  }
+};
+
+let prevHash = false;
+async function renderDOMHead(head, options = {}) {
+  const beforeRenderCtx = { shouldRender: true };
+  await head.hooks.callHook("dom:beforeRender", beforeRenderCtx);
+  if (!beforeRenderCtx.shouldRender)
+    return;
+  const dom = options.document || head.resolvedOptions.document || window.document;
+  const tagContexts = (await head.resolveTags()).map(setupTagRenderCtx);
+  if (head.resolvedOptions.experimentalHashHydration) {
+    prevHash = prevHash || head._hash || false;
+    if (prevHash) {
+      const hash = computeHashes(tagContexts.map((ctx) => ctx.tag._h));
+      if (prevHash === hash)
+        return;
+      prevHash = hash;
+    }
+  }
+  const staleSideEffects = head._popSideEffectQueue();
+  head.headEntries().map((entry) => entry._sde).forEach((sde) => {
+    Object.entries(sde).forEach(([key, fn]) => {
+      staleSideEffects[key] = fn;
+    });
+  });
+  const markSideEffect = (ctx, key, fn) => {
+    key = `${ctx.renderId}:${key}`;
+    if (ctx.entry)
+      ctx.entry._sde[key] = fn;
+    delete staleSideEffects[key];
+  };
+  function setupTagRenderCtx(tag) {
+    const entry = head.headEntries().find((e) => e._i === tag._e);
+    const renderCtx = {
+      renderId: !tag.key && tag._d ? tag._d : hashTag(tag),
+      $el: null,
+      shouldRender: true,
+      tag,
+      entry,
+      markSideEffect: (key, fn) => markSideEffect(renderCtx, key, fn)
+    };
+    return renderCtx;
+  }
+  const renders = [];
+  const pendingRenders = {
+    body: [],
+    head: []
+  };
+  const markEl = (ctx) => {
+    head._elMap[ctx.renderId] = ctx.$el;
+    renders.push(ctx);
+    markSideEffect(ctx, "el", () => {
+      ctx.$el?.remove();
+      delete head._elMap[ctx.renderId];
+    });
+  };
+  for (const ctx of tagContexts) {
+    await head.hooks.callHook("dom:beforeRenderTag", ctx);
+    if (!ctx.shouldRender)
+      continue;
+    const { tag } = ctx;
+    if (tag.tag === "title") {
+      dom.title = tag.textContent || "";
+      renders.push(ctx);
+      continue;
+    }
+    if (tag.tag === "htmlAttrs" || tag.tag === "bodyAttrs") {
+      ctx.$el = dom[tag.tag === "htmlAttrs" ? "documentElement" : "body"];
+      setAttrs(ctx, false, markSideEffect);
+      renders.push(ctx);
+      continue;
+    }
+    ctx.$el = head._elMap[ctx.renderId];
+    if (!ctx.$el && tag.key)
+      ctx.$el = dom.querySelector(`${tag.tagPosition?.startsWith("body") ? "body" : "head"} > ${tag.tag}[data-h-${tag._h}]`);
+    if (ctx.$el) {
+      if (ctx.tag._d)
+        setAttrs(ctx);
+      markEl(ctx);
+      continue;
+    }
+    pendingRenders[tag.tagPosition?.startsWith("body") ? "body" : "head"].push(ctx);
+  }
+  const fragments = {
+    bodyClose: void 0,
+    bodyOpen: void 0,
+    head: void 0
+  };
+  Object.entries(pendingRenders).forEach(([pos, queue]) => {
+    if (!queue.length)
+      return;
+    const children = dom?.[pos]?.children;
+    if (!children)
+      return;
+    for (const $el of [...children].reverse()) {
+      const elTag = $el.tagName.toLowerCase();
+      if (!HasElementTags.includes(elTag))
+        continue;
+      const props = $el.getAttributeNames().reduce((props2, name) => ({ ...props2, [name]: $el.getAttribute(name) }), {});
+      const tmpTag = { tag: elTag, props };
+      if ($el.innerHTML)
+        tmpTag.innerHTML = $el.innerHTML;
+      const tmpRenderId = hashTag(tmpTag);
+      let matchIdx = queue.findIndex((ctx) => ctx?.renderId === tmpRenderId);
+      if (matchIdx === -1) {
+        const tmpDedupeKey = tagDedupeKey(tmpTag);
+        matchIdx = queue.findIndex((ctx) => ctx?.tag._d && ctx.tag._d === tmpDedupeKey);
+      }
+      if (matchIdx !== -1) {
+        const ctx = queue[matchIdx];
+        ctx.$el = $el;
+        setAttrs(ctx);
+        markEl(ctx);
+        delete queue[matchIdx];
+      }
+    }
+    queue.forEach((ctx) => {
+      const pos2 = ctx.tag.tagPosition || "head";
+      fragments[pos2] = fragments[pos2] || dom.createDocumentFragment();
+      if (!ctx.$el) {
+        ctx.$el = dom.createElement(ctx.tag.tag);
+        setAttrs(ctx, true);
+      }
+      fragments[pos2].appendChild(ctx.$el);
+      markEl(ctx);
+    });
+  });
+  if (fragments.head)
+    dom.head.appendChild(fragments.head);
+  if (fragments.bodyOpen)
+    dom.body.insertBefore(fragments.bodyOpen, dom.body.firstChild);
+  if (fragments.bodyClose)
+    dom.body.appendChild(fragments.bodyClose);
+  for (const ctx of renders)
+    await head.hooks.callHook("dom:renderTag", ctx);
+  Object.values(staleSideEffects).forEach((fn) => fn());
+}
+let domUpdatePromise = null;
+async function debouncedRenderDOMHead(head, options = {}) {
+  function doDomUpdate() {
+    domUpdatePromise = null;
+    return renderDOMHead(head, options);
+  }
+  const delayFn = options.delayFn || ((fn) => setTimeout(fn, 10));
+  return domUpdatePromise = domUpdatePromise || new Promise((resolve) => delayFn(() => resolve(doDomUpdate())));
+}
+
+const PatchDomOnEntryUpdatesPlugin = (options) => {
+  return defineHeadPlugin({
+    hooks: {
+      "entries:updated": function(head) {
+        if (typeof options?.document === "undefined" && typeof window === "undefined")
+          return;
+        let delayFn = options?.delayFn;
+        if (!delayFn && typeof requestAnimationFrame !== "undefined")
+          delayFn = requestAnimationFrame;
+        debouncedRenderDOMHead(head, { document: options?.document || window.document, delayFn });
+      }
+    }
+  });
+};
+
+function maybeGetSSRHash(document) {
+  return document?.head.querySelector('meta[name="unhead:ssr"]')?.getAttribute("content") || false;
+}
+
+export { PatchDomOnEntryUpdatesPlugin, debouncedRenderDOMHead, domUpdatePromise, maybeGetSSRHash, renderDOMHead, setAttrs };
diff --git a/parent_dir/node_modules/unhead/shared/dist/index.mjs b/parent_dir/node_modules/unhead/shared/dist/index.mjs
new file mode 100644
index 0000000..45e2a48
--- /dev/null
+++ b/parent_dir/node_modules/unhead/shared/dist/index.mjs
@@ -0,0 +1,83 @@
+function asArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+const SelfClosingTags = ["meta", "link", "base"];
+const TagsWithInnerContent = ["title", "script", "style", "noscript"];
+const HasElementTags = [
+  "base",
+  "meta",
+  "link",
+  "style",
+  "script",
+  "noscript"
+];
+const ValidHeadTags = [
+  "title",
+  "titleTemplate",
+  "templateParams",
+  "base",
+  "htmlAttrs",
+  "bodyAttrs",
+  "meta",
+  "link",
+  "style",
+  "script",
+  "noscript"
+];
+const UniqueTags = ["base", "title", "titleTemplate", "bodyAttrs", "htmlAttrs", "templateParams"];
+const TagConfigKeys = ["tagPosition", "tagPriority", "tagDuplicateStrategy", "innerHTML", "textContent"];
+
+function defineHeadPlugin(plugin) {
+  return plugin;
+}
+
+function hashCode(s) {
+  let h = 9;
+  for (let i = 0; i < s.length; )
+    h = Math.imul(h ^ s.charCodeAt(i++), 9 ** 9);
+  return ((h ^ h >>> 9) + 65536).toString(16).substring(1, 8).toLowerCase();
+}
+function hashTag(tag) {
+  return hashCode(`${tag.tag}:${tag.textContent || tag.innerHTML || ""}:${Object.entries(tag.props).map(([key, value]) => `${key}:${String(value)}`).join(",")}`);
+}
+function computeHashes(hashes) {
+  let h = 9;
+  for (const s of hashes) {
+    for (let i = 0; i < s.length; )
+      h = Math.imul(h ^ s.charCodeAt(i++), 9 ** 9);
+  }
+  return ((h ^ h >>> 9) + 65536).toString(16).substring(1, 8).toLowerCase();
+}
+
+function tagDedupeKey(tag, fn) {
+  const { props, tag: tagName } = tag;
+  if (UniqueTags.includes(tagName))
+    return tagName;
+  if (tagName === "link" && props.rel === "canonical")
+    return "canonical";
+  if (props.charset)
+    return "charset";
+  const name = ["id"];
+  if (tagName === "meta")
+    name.push(...["name", "property", "http-equiv"]);
+  for (const n of name) {
+    if (typeof props[n] !== "undefined") {
+      const val = String(props[n]);
+      if (fn && !fn(val))
+        return false;
+      return `${tagName}:${n}:${val}`;
+    }
+  }
+  return false;
+}
+
+const resolveTitleTemplate = (template, title) => {
+  if (template == null)
+    return title || null;
+  if (typeof template === "function")
+    return template(title);
+  return template;
+};
+
+export { HasElementTags, SelfClosingTags, TagConfigKeys, TagsWithInnerContent, UniqueTags, ValidHeadTags, asArray, computeHashes, defineHeadPlugin, hashCode, hashTag, resolveTitleTemplate, tagDedupeKey };
diff --git a/parent_dir/node_modules/unhead/vue/dist/shared/vue.bc44c3fa.mjs b/parent_dir/node_modules/unhead/vue/dist/shared/vue.bc44c3fa.mjs
new file mode 100644
index 0000000..0d914b2
--- /dev/null
+++ b/parent_dir/node_modules/unhead/vue/dist/shared/vue.bc44c3fa.mjs
@@ -0,0 +1,124 @@
+import { unref, version, getCurrentInstance, inject, nextTick, ref, watchEffect, watch, onBeforeUnmount, onDeactivated, onActivated } from 'vue';
+import { getActiveHead, createServerHead as createServerHead$1, createHead as createHead$1 } from 'unhead';
+import { defineHeadPlugin } from '@unhead/shared';
+
+function resolveUnref(r) {
+  return typeof r === "function" ? r() : unref(r);
+}
+function resolveUnrefHeadInput(ref, lastKey = "") {
+  if (ref instanceof Promise)
+    return ref;
+  const root = resolveUnref(ref);
+  if (!ref || !root)
+    return root;
+  if (Array.isArray(root))
+    return root.map((r) => resolveUnrefHeadInput(r, lastKey));
+  if (typeof root === "object") {
+    return Object.fromEntries(
+      Object.entries(root).map(([k, v]) => {
+        if (k === "titleTemplate" || k.startsWith("on"))
+          return [k, unref(v)];
+        return [k, resolveUnrefHeadInput(v, k)];
+      })
+    );
+  }
+  return root;
+}
+
+const Vue3 = version.startsWith("3");
+const IsBrowser = typeof window !== "undefined";
+
+const headSymbol = "usehead";
+function injectHead() {
+  return getCurrentInstance() && inject(headSymbol) || getActiveHead();
+}
+function vueInstall(head) {
+  const plugin = {
+    install(app) {
+      if (Vue3) {
+        app.config.globalProperties.$unhead = head;
+        app.config.globalProperties.$head = head;
+        app.provide(headSymbol, head);
+      }
+    }
+  };
+  return plugin.install;
+}
+function createServerHead(options = {}) {
+  const head = createServerHead$1({
+    ...options,
+    plugins: [
+      VueReactiveUseHeadPlugin(),
+      ...options?.plugins || []
+    ]
+  });
+  head.install = vueInstall(head);
+  return head;
+}
+function createHead(options = {}) {
+  const head = createHead$1({
+    ...options,
+    // arbitrary delay the dom update for batch updates
+    domDelayFn: (fn) => setTimeout(() => nextTick(() => fn()), 10),
+    plugins: [
+      VueReactiveUseHeadPlugin(),
+      ...options?.plugins || []
+    ]
+  });
+  head.install = vueInstall(head);
+  return head;
+}
+
+const VueReactiveUseHeadPlugin = () => {
+  return defineHeadPlugin({
+    hooks: {
+      "entries:resolve": function(ctx) {
+        for (const entry of ctx.entries)
+          entry.resolvedInput = resolveUnrefHeadInput(entry.input);
+      }
+    }
+  });
+};
+
+function clientUseHead(input, options = {}) {
+  const head = injectHead();
+  const deactivated = ref(false);
+  const resolvedInput = ref({});
+  watchEffect(() => {
+    resolvedInput.value = deactivated.value ? {} : resolveUnrefHeadInput(input);
+  });
+  const entry = head.push(resolvedInput.value, options);
+  watch(resolvedInput, (e) => {
+    entry.patch(e);
+  });
+  const vm = getCurrentInstance();
+  if (vm) {
+    onBeforeUnmount(() => {
+      entry.dispose();
+    });
+    onDeactivated(() => {
+      deactivated.value = true;
+    });
+    onActivated(() => {
+      deactivated.value = false;
+    });
+  }
+  return entry;
+}
+
+function serverUseHead(input, options = {}) {
+  const head = injectHead();
+  return head.push(input, options);
+}
+
+function useHead(input, options = {}) {
+  const head = injectHead();
+  if (head) {
+    const isBrowser = IsBrowser || !!head.resolvedOptions?.document;
+    if (options.mode === "server" && isBrowser || options.mode === "client" && !isBrowser)
+      return;
+    return isBrowser ? clientUseHead(input, options) : serverUseHead(input, options);
+  }
+}
+
+export { VueReactiveUseHeadPlugin as V, createHead as a, createServerHead as c, headSymbol as h, injectHead as i, resolveUnrefHeadInput as r, serverUseHead as s, useHead as u };
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/executeOnClientRender.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/executeOnClientRender.js
new file mode 100644
index 0000000..16a2989
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/executeOnClientRender.js
@@ -0,0 +1,93 @@
+export { executeOnClientRender };
+import { assert, assertUsage, callHookWithTimeout, unique } from './utils';
+import { getHook } from '../shared/getHook';
+import { releasePageContext } from './releasePageContext';
+import { getPageConfig } from '../shared/page-configs/utils';
+async function executeOnClientRender(pageContext, isClientRouting) {
+    const pageContextReadyForRelease = releasePageContext(pageContext, isClientRouting);
+    let hook = null;
+    let hookName;
+    {
+        const renderHook = getHook(pageContext, 'render');
+        // assertWarning(!renderHook, 'Hook render() has been renamed to onRenderHtml() and onRenderClient()', { onlyOnce: true, showStackTrace: false }) // TODO/v1: replace this warning with waning that user should migrate to v1
+        hook = renderHook;
+        hookName = 'render';
+    }
+    {
+        const renderHook = getHook(pageContext, 'onRenderClient');
+        if (renderHook) {
+            hook = renderHook;
+            hookName = 'onClientRender';
+        }
+    }
+    if (!hook) {
+        const url = getUrl(pageContext);
+        if (pageContext._pageConfigs.length > 0) {
+            assertMissingHook(pageContext._pageId, pageContext._pageConfigs, url);
+        }
+        else {
+            const pageClientsFilesLoaded = pageContext._pageFilesLoaded.filter((p) => p.fileType === '.page.client');
+            let errMsg;
+            if (pageClientsFilesLoaded.length === 0) {
+                errMsg = 'No file `*.page.client.*` found for URL ' + url;
+            }
+            else {
+                errMsg =
+                    'One of the following files should export a `render()` hook: ' +
+                        pageClientsFilesLoaded.map((p) => p.filePath).join(' ');
+            }
+            assertUsage(false, errMsg);
+        }
+    }
+    assert(hook);
+    const renderHook = hook.hook;
+    assert(hookName);
+    // We don't use a try-catch wrapper because rendering errors are usually handled by the UI framework. (E.g. React's Error Boundaries.)
+    const hookResult = await callHookWithTimeout(() => renderHook(pageContextReadyForRelease), 'render', hook.hookSrc);
+    assertUsage(hookResult === undefined, `The ${hookName}() hook defined by ${hook.hookSrc} isn't allowed to return a value`);
+}
+function getUrl(pageContext) {
+    let url;
+    // try/catch to avoid passToClient assertUsage(), although I'd expect this to not be needed since we're accessing pageContext and not pageContextReadyForRelease
+    try {
+        url = pageContext.urlOriginal;
+    }
+    catch { }
+    url = url !== null && url !== void 0 ? url : window.location.href;
+    return url;
+}
+function assertMissingHook(pageId, pageConfigs, url) {
+    var _a, _b;
+    const pageConfig = getPageConfig(pageId, pageConfigs);
+    assert(!((_a = pageConfig.configElements.onRenderClient) === null || _a === void 0 ? void 0 : _a.configValue));
+    assert(((_b = pageConfig.configElements.clientRouting) === null || _b === void 0 ? void 0 : _b.configValue) === true);
+    // We miss abstract page config files (that define onClientRender()) that don't apply to any concrete page config
+    //  - A solution is to assertUsage() when an abstract page file doens't apply to any concrete page config
+    const plusConfigFilesDefiningHook = [];
+    let plusConfigFilesAll = [];
+    pageConfigs.forEach((pageConfig) => {
+        plusConfigFilesAll.push(...pageConfig.plusConfigFilePathAll);
+        const configElement = pageConfig.configElements.onRenderClient;
+        if (configElement && configElement.configValue) {
+            plusConfigFilesDefiningHook.push(configElement.configDefinedAt);
+        }
+    });
+    plusConfigFilesAll = unique(plusConfigFilesAll);
+    const indent = '- ';
+    const msgIntro = `No onRenderClient() hook found for URL \`${url}\`. (A onRenderClient() hook is required when using Client Routing: the config \`clientRouting\` is \`true\` for the URL \`${url}\`.)`;
+    if (plusConfigFilesDefiningHook.length === 0) {
+        assertUsage(false, [
+            // TODO: update msg
+            `${msgIntro} No onRenderClient() hook is defined by any of your page config files. Your page config files (which none of them defines \`onClientRender()\`):`,
+            ...plusConfigFilesAll.map((p) => indent + p)
+        ].join('\n'));
+    }
+    else {
+        const plural = plusConfigFilesDefiningHook.length >= 2;
+        assertUsage(false, [
+            `${msgIntro} Note that onRenderClient() is defined at:`,
+            ...plusConfigFilesDefiningHook.map((p) => `${indent}${p}`),
+            `but ${plural ? 'none of them' : "it doesn't"} apply to the URL \`${url}\`.`
+        ].join('\n'));
+    }
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/getBaseServer.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/getBaseServer.js
new file mode 100644
index 0000000..e9db15b
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/getBaseServer.js
@@ -0,0 +1,10 @@
+import { assert } from './utils';
+export function getBaseServer() {
+    const baseServer = import.meta.env.BASE_SERVER;
+    assert(isBaseServer(baseServer));
+    return baseServer;
+}
+// We don't use isBaseServer() defined in utils/parseUrl.ts to avoid loading the whole file in the browser
+function isBaseServer(baseServer) {
+    return baseServer.startsWith('/');
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/getPageContextSerializedInHtml.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/getPageContextSerializedInHtml.js
new file mode 100644
index 0000000..d9b39fe
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/getPageContextSerializedInHtml.js
@@ -0,0 +1,25 @@
+import { parse } from '@brillout/json-serializer/parse';
+import { hasProp, objectAssign, assert } from './utils';
+export { getPageContextSerializedInHtml };
+function getPageContextSerializedInHtml() {
+    var _a;
+    const pageContextJson = (_a = document.getElementById('vite-plugin-ssr_pageContext')) === null || _a === void 0 ? void 0 : _a.textContent;
+    assert(pageContextJson);
+    const parseResult = parse(pageContextJson);
+    assert(hasProp(parseResult, 'pageContext', 'object'));
+    const { pageContext } = parseResult;
+    assert(hasProp(pageContext, '_pageId', 'string'));
+    /*
+    if ('_serverSideErrorWhileStreaming' in pageContext) {
+      const err = getProjectError(
+        `An error occurred on the server while rendering/streaming to HTML. Check your server logs.`
+      )
+      throw err
+    }
+    */
+    objectAssign(pageContext, {
+        _pageContextRetrievedFromServer: { ...pageContext },
+        _comesDirectlyFromServer: true
+    });
+    return pageContext;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/loadPageFilesClientSide.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/loadPageFilesClientSide.js
new file mode 100644
index 0000000..f7b0127
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/loadPageFilesClientSide.js
@@ -0,0 +1,62 @@
+import { getPageFilesClientSide, getExports } from '../shared/getPageFiles';
+import { findPageConfig } from '../shared/page-configs/findPageConfig';
+import { loadPageCode } from '../shared/page-configs/loadPageCode';
+export { loadPageFilesClientSide };
+export { isErrorFetchingStaticAssets };
+const stamp = '__whileFetchingAssets';
+async function loadPageFilesClientSide(pageFilesAll, pageConfigs, pageId) {
+    const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
+    const pageConfig = findPageConfig(pageConfigs, pageId);
+    let pageConfigLoaded;
+    try {
+        // prettier-ignore
+        const result = await Promise.all([
+            pageConfig && loadPageCode(pageConfig, import.meta.env.DEV),
+            ...pageFilesClientSide.map((p) => { var _a; return (_a = p.loadFile) === null || _a === void 0 ? void 0 : _a.call(p); }),
+        ]);
+        pageConfigLoaded = result[0];
+    }
+    catch (err) {
+        // To trigger this catch: add `throw new Error()` in the global scope of +onRenderClient.js
+        if (isFetchError(err)) {
+            Object.assign(err, { [stamp]: true });
+        }
+        throw err;
+    }
+    const { config, configEntries, exports, exportsAll, pageExports } = getExports(pageFilesClientSide, pageConfigLoaded);
+    const pageContextAddendum = {
+        config,
+        configEntries,
+        exports,
+        exportsAll,
+        pageExports,
+        _pageFilesLoaded: pageFilesClientSide
+    };
+    return pageContextAddendum;
+}
+function isErrorFetchingStaticAssets(err) {
+    if (!err) {
+        return false;
+    }
+    return err[stamp] === true;
+}
+// https://stackoverflow.com/questions/75928310/how-to-detect-that-import-some-url-failed-because-some-url-isnt-a-javasc
+function isFetchError(err) {
+    if (!(err instanceof Error))
+        return false;
+    // https://github.com/stacks-network/clarity-js-sdk/blob/e757666b59af00b5db04dd1bf0df016e3a459ea2/packages/clarity/src/providers/registry.ts#L40-L45
+    // https://github.com/modernweb-dev/web/blob/0a59b56e4c1b50af81fbf4588f36a1ceb71f3976/integration/test-runner/tests/test-failure/runTestFailureTest.ts#L11-L18
+    const FAILED_TO_FETCH_MESSAGES = [
+        // chromium
+        'Failed to fetch dynamically imported module',
+        // firefox
+        'error loading dynamically imported module',
+        // safari
+        'Importing a module script failed',
+        // ??
+        'error resolving module specifier',
+        // ??
+        'failed to resolve module'
+    ];
+    return FAILED_TO_FETCH_MESSAGES.some((s) => err.message.toLowerCase().includes(s.toLowerCase()));
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/navigationState.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/navigationState.js
new file mode 100644
index 0000000..2674685
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/navigationState.js
@@ -0,0 +1,14 @@
+import { getCurrentUrl, getGlobalObject } from './utils';
+const globalObject = getGlobalObject('navigationState.ts', {});
+const urlFirst = getCurrentUrl();
+export const navigationState = {
+    markNavigationChange() {
+        globalObject.navigationChanged = true;
+    },
+    get noNavigationChangeYet() {
+        return !globalObject.navigationChanged && this.isFirstUrl(getCurrentUrl());
+    },
+    isFirstUrl(url) {
+        return url === urlFirst;
+    }
+};
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/releasePageContext.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/releasePageContext.js
new file mode 100644
index 0000000..55efc76
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/releasePageContext.js
@@ -0,0 +1,114 @@
+export { releasePageContext };
+import { assert, assertUsage, isObject, objectAssign, getGlobalObject } from './utils';
+import { sortPageContext } from '../shared/sortPageContext';
+const globalObject = getGlobalObject('releasePageContext.ts', {});
+import { addIs404ToPageProps } from '../shared/addIs404ToPageProps';
+// Release `pageContext` for user consumption.
+//
+// This adds `assertPassToClient()`.
+//
+// With Vue support (when `pageContext` is made reactive with Vue).
+//
+// For Vue + Cient Routing, the `pageContext` needs to be made reactive:
+// ```js
+// import { reactive } from 'vue'
+// // See entire example at `/examples/vue-full/`
+// const pageContextReactive = reactive(pageContext)
+// ```
+function releasePageContext(pageContext, isClientRouting) {
+    if (isClientRouting) {
+        const pageContextTyped = pageContext;
+        assert([true, false].includes(pageContextTyped.isHydration));
+        assert([true, false, null].includes(pageContextTyped.isBackwardNavigation));
+    }
+    else {
+        const pageContextTyped = pageContext;
+        assert(pageContextTyped.isHydration === true);
+        assert(pageContextTyped.isBackwardNavigation === null);
+    }
+    assert('config' in pageContext);
+    assert('configEntries' in pageContext);
+    // TODO/v1-release: remove
+    assert('exports' in pageContext);
+    assert('exportsAll' in pageContext);
+    assert('pageExports' in pageContext);
+    assert(isObject(pageContext.pageExports));
+    const Page = pageContext.exports.Page;
+    objectAssign(pageContext, { Page });
+    // For Vue's reactivity
+    resolveGetters(pageContext);
+    // For prettier `console.log(pageContext)`
+    sortPageContext(pageContext);
+    assert([true, false].includes(pageContext._comesDirectlyFromServer));
+    const pageContextReadyForRelease = !pageContext._comesDirectlyFromServer
+        ? // Not possible to achieve `getAssertPassToClientProxy()` if some `onBeforeRender()` hook defined in `.page.js` was called. (We cannot infer what `pageContext` properties came from the server-side or from the client-side. Which is fine because the user will likely dig into why the property is missing in `const pageContext = await runOnBeforeRenderServerHooks()` anyways, which does support throwing the helpul `assertPassToClient()` error message.)
+            pageContext
+        : getProxy(pageContext);
+    addIs404ToPageProps(pageContext);
+    return pageContextReadyForRelease;
+}
+const JAVASCRIPT_BUILT_INS = [
+    'then',
+    'toJSON' // Vue tries to access `toJSON`
+];
+const PASS_TO_CLIENT_BUILT_INS = [
+    '_pageId'
+    // '_serverSideErrorWhileStreaming'
+];
+// Hint the user to use `paassToClient` when accessing undefined `pageContext` props
+function getProxy(pageContext) {
+    return new Proxy(pageContext, { get });
+    function isMissing(prop) {
+        if (prop in pageContext)
+            return false;
+        if (JAVASCRIPT_BUILT_INS.includes(prop))
+            return false;
+        if (typeof prop === 'symbol')
+            return false; // Vue tries to access some symbols
+        if (typeof prop !== 'string')
+            return false;
+        if (prop.startsWith('__v_'))
+            return false; // Vue internals upon `reactive(pageContext)`
+        return true;
+    }
+    function get(_, prop) {
+        if (globalObject.disableAssertPassToClient !== prop) {
+            assertPassToClient(pageContext._pageContextRetrievedFromServer, prop, isMissing(prop));
+        }
+        // We disable `assertPassToClient` for the next attempt to read `prop`, because of how Vue's reactivity work.
+        // (When changing a reactive object, Vue tries to read it's old value first. This triggers a `assertPassToClient()` failure if e.g. `pageContextOldReactive.routeParams = pageContextNew.routeParams` and `pageContextOldReactive` has no `routeParams`.)
+        globalObject.disableAssertPassToClient = prop;
+        window.setTimeout(() => {
+            globalObject.disableAssertPassToClient = undefined;
+        }, 0);
+        return pageContext[prop];
+    }
+}
+function assertPassToClient(pageContextRetrievedFromServer, prop, isMissing) {
+    if (!isMissing) {
+        return;
+    }
+    if (pageContextRetrievedFromServer === null) {
+        // If we didn't receive any `pageContext` from the server
+        // - passToClient is irrelevant
+        // - We cannot determine passToClientInferred
+        return;
+    }
+    const passToClientInferred = Object.keys(pageContextRetrievedFromServer).filter((prop) => !PASS_TO_CLIENT_BUILT_INS.includes(prop));
+    assertUsage(false, [
+        `pageContext.${prop} isn't available in the browser`,
+        `('${prop}' is missing in the passToClient list [${passToClientInferred
+            .map((prop) => `'${prop}'`)
+            .join(', ')}]).`,
+        `Did you forget to add '${prop}' to the passToClient list?`,
+        `See https://vite-plugin-ssr.com/passToClient`
+    ].join(' '));
+}
+// Remove propery descriptor getters because they break Vue's reactivity.
+// E.g. resolve the `pageContext.urlPathname` getter.
+function resolveGetters(pageContext) {
+    Object.entries(pageContext).forEach(([key, val]) => {
+        delete pageContext[key];
+        pageContext[key] = val;
+    });
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/createPageContext.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/createPageContext.js
new file mode 100644
index 0000000..0112170
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/createPageContext.js
@@ -0,0 +1,28 @@
+export { createPageContext };
+import { addComputedUrlProps } from '../../shared/addComputedUrlProps';
+import { getPageFilesAll } from '../../shared/getPageFiles';
+import { getBaseServer } from '../getBaseServer';
+import { assert, isBaseServer, objectAssign, getGlobalObject } from './utils';
+const globalObject = getGlobalObject('createPageContext.ts', {});
+async function createPageContext(pageContextBase) {
+    if (!globalObject.pageFilesData) {
+        globalObject.pageFilesData = await getPageFilesAll(true);
+    }
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = globalObject.pageFilesData;
+    const baseServer = getBaseServer();
+    assert(isBaseServer(baseServer));
+    const pageContext = {
+        _objectCreatedByVitePluginSsr: true,
+        _urlHandler: null,
+        _baseServer: baseServer,
+        _isProduction: import.meta.env.PROD,
+        // TODO: use GlobalContext instead
+        _pageFilesAll: pageFilesAll,
+        _pageConfigs: pageConfigs,
+        _pageConfigGlobal: pageConfigGlobal,
+        _allPageIds: allPageIds
+    };
+    objectAssign(pageContext, pageContextBase);
+    addComputedUrlProps(pageContext);
+    return pageContext;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/entry.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/entry.js
new file mode 100644
index 0000000..a8e7228
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/entry.js
@@ -0,0 +1,7 @@
+import { assertClientRouting } from '../../utils/assertRoutingType';
+assertClientRouting();
+import './pageFiles';
+import { useClientRouter } from './useClientRouter';
+import { onClientEntry_ClientRouting } from './utils';
+onClientEntry_ClientRouting(import.meta.env.PROD);
+useClientRouter();
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/getPageContext.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/getPageContext.js
new file mode 100644
index 0000000..e7eed31
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/getPageContext.js
@@ -0,0 +1,173 @@
+export { getPageContext };
+export { getPageContextErrorPage };
+export { checkIf404 };
+import { navigationState } from '../navigationState';
+import { assert, assertUsage, hasProp, isPlainObject, objectAssign, getProjectError, serverSideRouteTo, callHookWithTimeout, isObject } from './utils';
+import { parse } from '@brillout/json-serializer/parse';
+import { getPageContextSerializedInHtml } from '../getPageContextSerializedInHtml';
+import { analyzePageServerSide } from '../../shared/getPageFiles/analyzePageServerSide';
+import { assertHookResult } from '../../shared/assertHookResult';
+import { route } from '../../shared/route';
+import { getErrorPageId } from '../../shared/error-page';
+import { getHook } from '../../shared/getHook';
+import { releasePageContext } from '../releasePageContext';
+import { loadPageFilesClientSide } from '../loadPageFilesClientSide';
+import { removeBuiltInOverrides } from './getPageContext/removeBuiltInOverrides';
+import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl';
+import { getCodeFilePath, getPageConfig } from '../../shared/page-configs/utils';
+async function getPageContext(pageContext) {
+    if (pageContext._isFirstRenderAttempt && navigationState.isFirstUrl(pageContext.urlOriginal)) {
+        assert(hasProp(pageContext, '_isFirstRenderAttempt', 'true'));
+        return getPageContextFirstRender(pageContext);
+    }
+    else {
+        assert(hasProp(pageContext, '_isFirstRenderAttempt', 'false'));
+        return getPageContextUponNavigation(pageContext);
+    }
+}
+async function getPageContextFirstRender(pageContext) {
+    const pageContextAddendum = getPageContextSerializedInHtml();
+    removeBuiltInOverrides(pageContextAddendum);
+    objectAssign(pageContextAddendum, {
+        isHydration: true,
+        _comesDirectlyFromServer: true
+    });
+    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContext._pageFilesAll, pageContext._pageConfigs, pageContextAddendum._pageId));
+    return pageContextAddendum;
+}
+async function getPageContextErrorPage(pageContext) {
+    const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
+    if (!errorPageId) {
+        throw new Error('No error page');
+    }
+    const pageContextAddendum = {
+        isHydration: false,
+        _pageId: errorPageId,
+        _pageContextRetrievedFromServer: null,
+        _comesDirectlyFromServer: false
+    };
+    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContext._pageFilesAll, pageContext._pageConfigs, pageContextAddendum._pageId));
+    return pageContextAddendum;
+}
+async function getPageContextUponNavigation(pageContext) {
+    let pageContextAddendum = {};
+    objectAssign(pageContextAddendum, {
+        isHydration: false
+    });
+    objectAssign(pageContextAddendum, await getPageContextFromRoute(pageContext));
+    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContext._pageFilesAll, pageContext._pageConfigs, pageContextAddendum._pageId));
+    const pageContextFromHook = await onBeforeRenderExecute({ ...pageContext, ...pageContextAddendum });
+    assert([true, false].includes(pageContextFromHook._comesDirectlyFromServer));
+    if (!pageContextFromHook['_isError']) {
+        objectAssign(pageContextAddendum, pageContextFromHook);
+        return pageContextAddendum;
+    }
+    else {
+        pageContextAddendum = {};
+        assert(pageContextFromHook._comesDirectlyFromServer === true);
+        assert(hasProp(pageContextFromHook, 'is404', 'boolean'));
+        assert(hasProp(pageContextFromHook, 'pageProps', 'object'));
+        assert(hasProp(pageContextFromHook.pageProps, 'is404', 'boolean'));
+        // When the user hasn't define a `_error.page.js` file: the mechanism with `serverSideError: true` is used instead
+        assert(!('serverSideError' in pageContextFromHook));
+        const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
+        assert(errorPageId);
+        objectAssign(pageContextAddendum, {
+            isHydration: false,
+            _pageId: errorPageId
+        });
+        objectAssign(pageContextAddendum, pageContextFromHook);
+        objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContext._pageFilesAll, pageContext._pageConfigs, pageContextAddendum._pageId));
+        return pageContextAddendum;
+    }
+}
+async function onBeforeRenderExecute(pageContext) {
+    // `export { onBeforeRender }` defined in `.page.client.js` or `.page.js`
+    const hook = getHook(pageContext, 'onBeforeRender');
+    if (hook) {
+        const onBeforeRender = hook.hook;
+        const pageContextAddendum = {
+            _comesDirectlyFromServer: false,
+            _pageContextRetrievedFromServer: null
+        };
+        const pageContextReadyForRelease = releasePageContext({
+            ...pageContext,
+            ...pageContextAddendum
+        }, true);
+        const hookResult = await callHookWithTimeout(() => onBeforeRender(pageContextReadyForRelease), 'onBeforeRender', hook.hookSrc);
+        assertHookResult(hookResult, 'onBeforeRender', ['pageContext'], hook.hookSrc);
+        const pageContextFromHook = hookResult === null || hookResult === void 0 ? void 0 : hookResult.pageContext;
+        objectAssign(pageContextAddendum, pageContextFromHook);
+        return pageContextAddendum;
+    }
+    // `export { onBeforeRender }` defined in `.page.server.js`
+    if (await onBeforeRenderServerSideExists(pageContext)) {
+        const pageContextFromServer = await retrievePageContextFromServer(pageContext);
+        const pageContextAddendum = {};
+        Object.assign(pageContextAddendum, pageContextFromServer);
+        objectAssign(pageContextAddendum, {
+            _comesDirectlyFromServer: true,
+            _pageContextRetrievedFromServer: pageContextFromServer
+        });
+        return pageContextAddendum;
+    }
+    // No `export { onBeforeRender }` defined
+    const pageContextAddendum = { _comesDirectlyFromServer: false, _pageContextRetrievedFromServer: null };
+    return pageContextAddendum;
+}
+async function onBeforeRenderServerSideExists(pageContext) {
+    if (pageContext._pageConfigs.length > 0) {
+        const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
+        return (!!getCodeFilePath(pageConfig, 'onBeforeRender') &&
+            pageConfig.configElements.onBeforeRender.configEnv === 'server-only');
+    }
+    else {
+        const { hasOnBeforeRenderServerSideOnlyHook } = await analyzePageServerSide(pageContext._pageFilesAll, pageContext._pageId);
+        return hasOnBeforeRenderServerSideOnlyHook;
+    }
+}
+async function getPageContextFromRoute(pageContext) {
+    const routeResult = await route(pageContext);
+    const pageContextFromRoute = routeResult.pageContextAddendum;
+    if (!pageContextFromRoute._pageId) {
+        const err = new Error('No routing match');
+        markIs404(err);
+        throw err;
+    }
+    assert(hasProp(pageContextFromRoute, '_pageId', 'string'));
+    return pageContextFromRoute;
+}
+function markIs404(err) {
+    objectAssign(err, { _is404: true });
+}
+function checkIf404(err) {
+    return isObject(err) && err._is404 === true;
+}
+async function retrievePageContextFromServer(pageContext) {
+    var _a;
+    const pageContextUrl = getPageContextRequestUrl((_a = pageContext._urlPristine) !== null && _a !== void 0 ? _a : pageContext.urlOriginal);
+    const response = await fetch(pageContextUrl);
+    {
+        const contentType = response.headers.get('content-type');
+        const isRightContentType = contentType && contentType.includes('application/json');
+        // Static hosts + page doesn't exist
+        if (!isRightContentType && response.status === 404) {
+            serverSideRouteTo(pageContext.urlOriginal);
+            const err = new Error("Page doesn't exist");
+            Object.assign(err, { _abortRendering: true });
+            throw err;
+        }
+        assertUsage(isRightContentType, `Wrong HTTP Response Header \`content-type\` value for URL ${pageContextUrl} (it should be \`application/json\` but we got \`${contentType}\`). Make sure to use \`pageContext.httpResponse.contentType\`, see https://github.com/brillout/vite-plugin-ssr/issues/191`);
+    }
+    const responseText = await response.text();
+    const responseObject = parse(responseText);
+    if ('serverSideError' in responseObject) {
+        throw getProjectError('`pageContext` could not be fetched from the server as an error occurred on the server; check your server logs.');
+    }
+    assert(hasProp(responseObject, 'pageContext'));
+    const pageContextFromServer = responseObject.pageContext;
+    assert(isPlainObject(pageContextFromServer));
+    assert(hasProp(pageContextFromServer, '_pageId', 'string'));
+    removeBuiltInOverrides(pageContextFromServer);
+    return pageContextFromServer;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/getPageContext/removeBuiltInOverrides.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/getPageContext/removeBuiltInOverrides.js
new file mode 100644
index 0000000..cf8c20e
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/getPageContext/removeBuiltInOverrides.js
@@ -0,0 +1,22 @@
+export { removeBuiltInOverrides };
+import { assert, assertWarning } from '../utils';
+const BUILT_IN_CLIENT_ROUTER = ['urlPathname', 'urlParsed'];
+const BUILT_IN_CLIENT = ['Page', 'pageExports', 'exports'];
+function removeBuiltInOverrides(pageContext) {
+    const alreadySet = [...BUILT_IN_CLIENT, ...BUILT_IN_CLIENT_ROUTER];
+    alreadySet.forEach((prop) => {
+        if (prop in pageContext) {
+            // We need to cast `BUILT_IN_CLIENT` to `string[]`
+            //  - https://stackoverflow.com/questions/56565528/typescript-const-assertions-how-to-use-array-prototype-includes
+            //  - https://stackoverflow.com/questions/57646355/check-if-string-is-included-in-readonlyarray-in-typescript
+            if (BUILT_IN_CLIENT_ROUTER.includes(prop)) {
+                assert(prop.startsWith('url'));
+                assertWarning(false, `\`pageContext.${prop}\` is already available in the browser when using Client Routing; including \`${prop}\` in \`passToClient\` has no effect.`, { showStackTrace: false, onlyOnce: true });
+            }
+            else {
+                assertWarning(false, `\`pageContext.${prop}\` is a built-in that cannot be overriden; including \`${prop}\` in \`passToClient\` has no effect.`, { showStackTrace: false, onlyOnce: true });
+            }
+            delete pageContext[prop];
+        }
+    });
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/getPageId.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/getPageId.js
new file mode 100644
index 0000000..8169b2a
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/getPageId.js
@@ -0,0 +1,19 @@
+export { getPageId };
+import { route } from '../../shared/route';
+import { createPageContext } from './createPageContext';
+async function getPageId(url) {
+    const pageContext = await createPageContext({
+        urlOriginal: url
+    });
+    const routeContext = await route(pageContext);
+    const pageFilesAll = pageContext._pageFilesAll;
+    const pageConfigs = pageContext._pageConfigs;
+    if (!('pageContextAddendum' in routeContext)) {
+        return { pageId: null, pageFilesAll, pageConfigs };
+    }
+    const pageId = routeContext.pageContextAddendum._pageId;
+    if (!pageId) {
+        return { pageId: null, pageFilesAll, pageConfigs };
+    }
+    return { pageId, pageFilesAll, pageConfigs };
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/history.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/history.js
new file mode 100644
index 0000000..faa3b1d
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/history.js
@@ -0,0 +1,71 @@
+export { initHistoryState, getHistoryState, pushHistory, saveScrollPosition };
+import { assert, hasProp, isObject } from './utils';
+// Fill missing state information.
+//  - The very first render => `history.state` is uninitialized (`null`).
+//  - The vite-plugin-ssr app runs `location.hash = '#section'` => `history.state` is uninitialized (`null`).
+//  - The user clicks on an anchor link `<a href="#section">Section</a>` => `history.state` is uninitialized (`null`).
+//  - `history.state` set by an old vite-plugin-ssr version => state information may be incomplete. (E.g. `state.timestamp` was introduced for `pageContext.isBackwardNavigation` in `0.4.19`.)
+function initHistoryState() {
+    let state = window.history.state;
+    if (!state) {
+        state = {};
+    }
+    let hasModifications = false;
+    if (!('timestamp' in state)) {
+        hasModifications = true;
+        state.timestamp = getTimestamp();
+    }
+    if (!('scrollPosition' in state)) {
+        hasModifications = true;
+        state.scrollPosition = getScrollPosition();
+    }
+    assertState(state);
+    if (hasModifications) {
+        replaceHistoryState(state);
+    }
+}
+function getHistoryState() {
+    const state = window.history.state || {};
+    assertState(state);
+    return state;
+}
+function getScrollPosition() {
+    const scrollPosition = { x: window.scrollX, y: window.scrollY };
+    return scrollPosition;
+}
+function getTimestamp() {
+    return new Date().getTime();
+}
+function saveScrollPosition() {
+    const scrollPosition = getScrollPosition();
+    const state = getHistoryState();
+    replaceHistoryState({ ...state, scrollPosition });
+}
+function pushHistory(url, overwriteLastHistoryEntry) {
+    if (!overwriteLastHistoryEntry) {
+        const timestamp = getTimestamp();
+        pushHistoryState({ timestamp, scrollPosition: null }, url);
+    }
+    else {
+        replaceHistoryState(getHistoryState(), url);
+    }
+}
+function assertState(state) {
+    assert(isObject(state));
+    if ('timestamp' in state) {
+        const { timestamp } = state;
+        assert(typeof timestamp === 'number');
+    }
+    if ('scrollPosition' in state) {
+        const { scrollPosition } = state;
+        if (scrollPosition !== null) {
+            assert(hasProp(scrollPosition, 'x', 'number') && hasProp(scrollPosition, 'y', 'number'));
+        }
+    }
+}
+function replaceHistoryState(state, url) {
+    window.history.replaceState(state, '', url !== null && url !== void 0 ? url : null);
+}
+function pushHistoryState(state, url) {
+    window.history.pushState(state, '', url);
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/navigate.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/navigate.js
new file mode 100644
index 0000000..fa2f1c7
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/navigate.js
@@ -0,0 +1,29 @@
+export { navigate };
+export { defineNavigate };
+import { assertUsage, isBrowser, getGlobalObject, assertClientRouting, checkIfClientRouting } from './utils';
+assertClientRouting();
+const globalObject = getGlobalObject('navigate.ts', {});
+/** Programmatically navigate to a new page, see https://vite-plugin-ssr.com/navigate
+ * @param url - The URL of the new page.
+ * @param keepScrollPosition - Don't scroll to the top of the page, instead keep the current scroll position.
+ * @param overwriteLastHistoryEntry - Don't create a new entry in the browser's history, instead let the new URL replace the current URL. (This effectively removes the current URL from the browser history).
+ */
+async function navigate(url, { keepScrollPosition = false, overwriteLastHistoryEntry = false } = {}) {
+    assertUsage(isBrowser(), '[`navigate(url)`] The `navigate(url)` function is only callable in the browser but you are calling it in Node.js.');
+    const errMsg = 'navigate() only works with Client Routing, see https://vite-plugin-ssr.com/navigate';
+    assertUsage(globalObject.navigate, errMsg);
+    assertUsage(checkIfClientRouting(), errMsg);
+    assertUsage(url, '[navigate(url)] Missing argument `url`.');
+    assertUsage(typeof url === 'string', '[navigate(url)] Argument `url` should be a string (but we got `typeof url === "' + typeof url + '"`.');
+    assertUsage(typeof keepScrollPosition === 'boolean', '[navigate(url, { keepScrollPosition })] Argument `keepScrollPosition` should be a boolean (but we got `typeof keepScrollPosition === "' +
+        typeof keepScrollPosition +
+        '"`.');
+    assertUsage(typeof overwriteLastHistoryEntry === 'boolean', '[navigate(url, { overwriteLastHistoryEntry })] Argument `overwriteLastHistoryEntry` should be a boolean (but we got `typeof keepScrollPosition === "' +
+        typeof overwriteLastHistoryEntry +
+        '"`.');
+    assertUsage(url.startsWith('/'), '[navigate(url)] Argument `url` should start with a leading `/`.');
+    await globalObject.navigate(url, { keepScrollPosition, overwriteLastHistoryEntry });
+}
+function defineNavigate(navigate_) {
+    globalObject.navigate = navigate_;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/pageFiles.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/pageFiles.js
new file mode 100644
index 0000000..33d8243
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/pageFiles.js
@@ -0,0 +1,4 @@
+import { setPageFiles } from '../../shared/getPageFiles';
+// @ts-ignore
+import * as pageFilesExports from 'virtual:vite-plugin-ssr:importUserCode:client:client-routing';
+setPageFiles(pageFilesExports);
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/prefetch.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/prefetch.js
new file mode 100644
index 0000000..1abaf59
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/prefetch.js
@@ -0,0 +1,74 @@
+export { addLinkPrefetchHandlers, prefetch };
+import { assert, assertClientRouting, assertUsage, checkIfClientRouting, isExternalLink } from './utils';
+import { isErrorFetchingStaticAssets, loadPageFilesClientSide } from '../loadPageFilesClientSide';
+import { isClientSideRoutable, skipLink } from './skipLink';
+import { getPageId } from './getPageId';
+import { getPrefetchConfig } from './prefetch/getPrefetchConfig';
+import { isAlreadyPrefetched, markAsAlreadyPrefetched } from './prefetch/alreadyPrefetched';
+import { disableClientRouting } from './useClientRouter';
+assertClientRouting();
+const linkPrefetchHandlerAdded = new Map();
+async function prefetch(url) {
+    assertUsage(checkIfClientRouting(), 'prefetch() only works with Client Routing, see https://vite-plugin-ssr.com/prefetch');
+    assertUsage(!isExternalLink(url), `You are trying to prefetch the URL ${url} of another domain which cannot be prefetched`);
+    if (isAlreadyPrefetched(url))
+        return;
+    markAsAlreadyPrefetched(url);
+    const { pageId, pageFilesAll, pageConfigs } = await getPageId(url);
+    if (pageId) {
+        try {
+            await loadPageFilesClientSide(pageFilesAll, pageConfigs, pageId);
+        }
+        catch (err) {
+            if (isErrorFetchingStaticAssets(err)) {
+                disableClientRouting(err, true);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+}
+function addLinkPrefetchHandlers(pageContext) {
+    // Current URL is already prefetched
+    markAsAlreadyPrefetched(pageContext.urlOriginal);
+    const linkTags = [...document.getElementsByTagName('A')];
+    linkTags.forEach(async (linkTag) => {
+        if (linkPrefetchHandlerAdded.has(linkTag))
+            return;
+        linkPrefetchHandlerAdded.set(linkTag, true);
+        const url = linkTag.getAttribute('href');
+        if (skipLink(linkTag))
+            return;
+        assert(url);
+        try {
+            if (!(await isClientSideRoutable(url)))
+                return;
+        }
+        catch {
+            // If a route() hook has a bug or `throw RenderErrorPage()`
+            return;
+        }
+        if (isAlreadyPrefetched(url))
+            return;
+        const prefetchConfig = getPrefetchConfig(pageContext, linkTag);
+        if (!prefetchConfig.prefetchStaticAssets) {
+            return;
+        }
+        else if (prefetchConfig.prefetchStaticAssets.when === 'HOVER') {
+            linkTag.addEventListener('mouseover', () => prefetch(url));
+            linkTag.addEventListener('touchstart', () => prefetch(url), { passive: true });
+        }
+        else if (prefetchConfig.prefetchStaticAssets.when === 'VIEWPORT') {
+            const observer = new IntersectionObserver((entries) => {
+                entries.forEach((entry) => {
+                    if (entry.isIntersecting) {
+                        prefetch(url);
+                        observer.disconnect();
+                    }
+                });
+            });
+            observer.observe(linkTag);
+        }
+    });
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/prefetch/alreadyPrefetched.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/prefetch/alreadyPrefetched.js
new file mode 100644
index 0000000..4eb20c6
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/prefetch/alreadyPrefetched.js
@@ -0,0 +1,15 @@
+export { isAlreadyPrefetched };
+export { markAsAlreadyPrefetched };
+import { getUrlPathname } from '../utils';
+const linkAlreadyPrefetched = new Map();
+function isAlreadyPrefetched(url) {
+    const prefetchUrl = getPrefetchUrl(url);
+    return linkAlreadyPrefetched.has(prefetchUrl);
+}
+function markAsAlreadyPrefetched(url) {
+    const prefetchUrl = getPrefetchUrl(url);
+    linkAlreadyPrefetched.set(prefetchUrl, true);
+}
+function getPrefetchUrl(url) {
+    return getUrlPathname(url);
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/prefetch/getPrefetchConfig.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/prefetch/getPrefetchConfig.js
new file mode 100644
index 0000000..b1a27c7
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/prefetch/getPrefetchConfig.js
@@ -0,0 +1,63 @@
+export { getPrefetchConfig };
+import { assert, assertUsage, assertInfo, assertWarning, isPlainObject } from '../utils';
+function getPrefetchConfig(pageContext, linkTag) {
+    const prefetchStaticAssets = getStaticAssetsConfig(pageContext, linkTag);
+    return {
+        prefetchPageContext: false,
+        prefetchStaticAssets
+    };
+}
+function getStaticAssetsConfig(pageContext, linkTag) {
+    let prefetchAttribute = getPrefetchAttribute(linkTag);
+    let prefetchStaticAssets = (() => {
+        if (prefetchAttribute !== null) {
+            if (prefetchAttribute === true) {
+                return { when: 'VIEWPORT' };
+            }
+            else {
+                return { when: 'HOVER' };
+            }
+        }
+        if ('prefetchLinks' in pageContext.exports) {
+            assertUsage(prefetchAttribute === null, '`export { prefetchLinks }` is deprecated, use `export { prefetchStaticAssets }` instead.');
+        }
+        if ('prefetchStaticAssets' in pageContext.exports) {
+            const { prefetchStaticAssets } = pageContext.exports;
+            if (prefetchStaticAssets === false) {
+                return false;
+            }
+            const wrongUsageMsg = "`prefetchStaticAssets` should be either `false`, `{ when: 'VIEWPORT' }`, or `{ when: 'HOVER' }`";
+            assertUsage(isPlainObject(prefetchStaticAssets), wrongUsageMsg);
+            const keys = Object.keys(prefetchStaticAssets);
+            assertUsage(keys.length === 1 && keys[0] === 'when', wrongUsageMsg);
+            const { when } = prefetchStaticAssets;
+            if (when === 'HOVER' || when === 'VIEWPORT') {
+                return { when };
+            }
+            assertUsage(false, wrongUsageMsg);
+        }
+        return { when: 'HOVER' };
+    })();
+    if (prefetchStaticAssets && prefetchStaticAssets.when === 'VIEWPORT' && !pageContext._isProduction) {
+        assertInfo(false, 'Viewport prefetching is disabled in development', { onlyOnce: true });
+        prefetchStaticAssets = { when: 'HOVER' };
+    }
+    return prefetchStaticAssets;
+}
+function getPrefetchAttribute(linkTag) {
+    let prefetchAttribute = linkTag.getAttribute('data-prefetch');
+    assertWarning(prefetchAttribute === null, 'The `data-prefetch` attribute is outdated.', {
+        showStackTrace: false,
+        onlyOnce: true
+    });
+    if (prefetchAttribute === null)
+        return null;
+    assert(typeof prefetchAttribute === 'string');
+    if (prefetchAttribute === 'true') {
+        return true;
+    }
+    if (prefetchAttribute === 'false') {
+        return false;
+    }
+    assertUsage(false, `Wrong data-prefetch value: \`"${prefetchAttribute}"\`; it should be \`"true"\` or \`"false"\`.`);
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/skipLink.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/skipLink.js
new file mode 100644
index 0000000..a53662a
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/skipLink.js
@@ -0,0 +1,45 @@
+export { skipLink };
+export { isClientSideRoutable } from './skipLink/isClientSideRoutable';
+import { getBaseServer } from '../getBaseServer';
+import { assert, parseUrl, isBaseServer, isParsable, isExternalLink } from './utils';
+function skipLink(linkTag) {
+    const url = linkTag.getAttribute('href');
+    if (url === null)
+        return true;
+    if (url === '')
+        return true;
+    if (isExternalLink(url))
+        return true;
+    if (isNewTabLink(linkTag))
+        return true;
+    if (isHashUrl(url))
+        return true;
+    if (!hasBaseServer(url)) {
+        return true;
+    }
+    if (!isParsable(url)) {
+        return true;
+    }
+    return false;
+}
+function isNewTabLink(linkTag) {
+    const target = linkTag.getAttribute('target');
+    const rel = linkTag.getAttribute('rel');
+    return target === '_blank' || target === '_external' || rel === 'external' || linkTag.hasAttribute('download');
+}
+function isHashUrl(url) {
+    if (url.startsWith('#')) {
+        return true;
+    }
+    const removeHash = (url) => url.split('#')[0];
+    if (url.includes('#') && removeHash(url) === removeHash(window.location.href)) {
+        return true;
+    }
+    return false;
+}
+function hasBaseServer(url) {
+    const baseServer = getBaseServer();
+    assert(isBaseServer(baseServer));
+    const { hasBaseServer } = parseUrl(url, baseServer);
+    return hasBaseServer;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/skipLink/isClientSideRoutable.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/skipLink/isClientSideRoutable.js
new file mode 100644
index 0000000..a86c0c1
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/skipLink/isClientSideRoutable.js
@@ -0,0 +1,15 @@
+export { isClientSideRoutable };
+import { getPageId } from '../getPageId';
+import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide';
+import { findPageConfig } from '../../../shared/page-configs/findPageConfig';
+import { analyzeClientSide } from '../../../shared/getPageFiles/analyzeClientSide';
+async function isClientSideRoutable(url) {
+    const { pageId, pageFilesAll, pageConfigs } = await getPageId(url);
+    if (!pageId) {
+        return false;
+    }
+    await analyzePageClientSideInit(pageFilesAll, pageId, { sharedPageFilesAlreadyLoaded: false });
+    const pageConfig = findPageConfig(pageConfigs, pageId);
+    const { isClientSideRenderable, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
+    return isClientSideRenderable && isClientRouting;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/useClientRouter.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/useClientRouter.js
new file mode 100644
index 0000000..5a910ae
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/useClientRouter.js
@@ -0,0 +1,424 @@
+export { useClientRouter };
+export { disableClientRouting };
+import { assert, getCurrentUrl, isSameErrorMessage, objectAssign, serverSideRouteTo, throttle, sleep, getGlobalObject, callHookWithTimeout, isObject } from './utils';
+import { navigationState } from '../navigationState';
+import { checkIf404, getPageContext, getPageContextErrorPage } from './getPageContext';
+import { createPageContext } from './createPageContext';
+import { addLinkPrefetchHandlers } from './prefetch';
+import { assertInfo, assertWarning, isReact } from './utils';
+import { executeOnClientRender } from '../executeOnClientRender';
+import { assertHook } from '../../shared/getHook';
+import { isClientSideRoutable, skipLink } from './skipLink';
+import { isErrorFetchingStaticAssets } from '../loadPageFilesClientSide';
+import { initHistoryState, getHistoryState, pushHistory, saveScrollPosition } from './history';
+import { defineNavigate } from './navigate';
+import { isRenderErrorPageException } from '../../shared/route/RenderErrorPage';
+const globalObject = getGlobalObject('useClientRouter.ts', { previousState: getState() });
+setupNativeScrollRestoration();
+initHistoryState();
+function disableClientRouting(err, logError) {
+    assert(isErrorFetchingStaticAssets(err));
+    globalObject.clientRoutingIsDisabled = true;
+    if (logError) {
+        // We don't use console.error() to avoid flooding error trackers such as Sentry
+        console.log(err);
+    }
+    assertInfo(false, [
+        'Failed to fetch static asset.',
+        import.meta.env.PROD ? 'This usually happens when a new frontend is deployed.' : null,
+        'Falling back to Server Routing.',
+        '(The next page navigation will use Server Routing instead of Client Routing.)'
+    ]
+        .filter(Boolean)
+        .join(' '), { onlyOnce: true });
+}
+function useClientRouter() {
+    autoSaveScrollPosition();
+    onLinkClick((url, { keepScrollPosition }) => {
+        const scrollTarget = keepScrollPosition ? 'preserve-scroll' : 'scroll-to-top-or-hash';
+        fetchAndRender({ scrollTarget, url, isBackwardNavigation: false, checkClientSideRenderable: true });
+    });
+    onBrowserHistoryNavigation((scrollTarget, isBackwardNavigation) => {
+        fetchAndRender({ scrollTarget, isBackwardNavigation });
+    });
+    defineNavigate(async (url, { keepScrollPosition = false, overwriteLastHistoryEntry = false } = {}) => {
+        const scrollTarget = keepScrollPosition ? 'preserve-scroll' : 'scroll-to-top-or-hash';
+        await fetchAndRender({
+            scrollTarget,
+            url,
+            overwriteLastHistoryEntry,
+            isBackwardNavigation: false,
+            checkClientSideRenderable: true
+        });
+    });
+    let renderingCounter = 0;
+    let renderPromise;
+    let isTransitioning = false;
+    fetchAndRender({ scrollTarget: 'preserve-scroll', isBackwardNavigation: null });
+    return;
+    async function fetchAndRender({ scrollTarget, url = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, checkClientSideRenderable }) {
+        var _a;
+        if (globalObject.clientRoutingIsDisabled) {
+            serverSideRouteTo(url);
+            return;
+        }
+        if (checkClientSideRenderable) {
+            let isClientRoutable;
+            try {
+                isClientRoutable = await isClientSideRoutable(url);
+            }
+            catch (err) {
+                if (!isRenderErrorPageException(err)) {
+                    // If a route() hook has a bug
+                    throw err;
+                }
+                else {
+                    // If a route() hook `throw RenderErrorPage()`
+                    // RenderErrorPage is handled down below
+                    isClientRoutable = true;
+                }
+            }
+            if (!isClientRoutable) {
+                serverSideRouteTo(url);
+                return;
+            }
+        }
+        const pageContextBase = {
+            urlOriginal: url,
+            isBackwardNavigation
+        };
+        const renderingNumber = ++renderingCounter;
+        assert(renderingNumber >= 1);
+        // Start transition before any await's
+        if (renderingNumber > 1) {
+            if (isTransitioning === false) {
+                (_a = globalObject.onPageTransitionStart) === null || _a === void 0 ? void 0 : _a.call(globalObject, pageContextBase);
+                isTransitioning = true;
+            }
+        }
+        let hydrationCanBeAborted = false;
+        const shouldAbort = () => {
+            {
+                // We should never abort the hydration if `hydrationCanBeAborted` isn't `true`
+                const isHydration = renderingNumber === 1;
+                if (isHydration && hydrationCanBeAborted === false) {
+                    return false;
+                }
+            }
+            // If there is a newer rendering, we should abort all previous renderings
+            if (renderingNumber !== renderingCounter) {
+                return true;
+            }
+            return false;
+        };
+        const pageContext = await createPageContext(pageContextBase);
+        if (shouldAbort()) {
+            return;
+        }
+        const isFirstRenderAttempt = renderingNumber === 1;
+        objectAssign(pageContext, {
+            _isFirstRenderAttempt: isFirstRenderAttempt
+        });
+        let pageContextAddendum;
+        try {
+            pageContextAddendum = await getPageContext(pageContext);
+        }
+        catch (err) {
+            // We never swallow errors on the client-side, even if it's a 404, because:
+            //  - On the client-side, if the user navigates to a 404 then it means that the UI has a broken link.
+            //    - It isn't expected that users can go to some random URL using the client-side router, as it would require, for example, the user to manually change the URL of a link by manually manipulating the DOM which highly unlikely.
+            //    - In contrast, on the server-side, VPS swallows / doesn't show any 404 error log because it's expected that a user may go to some random non-existent URL, and we don't want to flood the app's error tracking with 404 logs.
+            console.error(err);
+            if (checkIfAbort(err, pageContext))
+                return;
+            if (isRenderErrorPageException(err)) {
+                objectAssign(pageContext, { is404: true });
+                objectAssign(pageContext, err.pageContext);
+            }
+            else {
+                objectAssign(pageContext, { is404: checkIf404(err) });
+            }
+            try {
+                pageContextAddendum = await getPageContextErrorPage(pageContext);
+            }
+            catch (err2) {
+                // - When user hasn't defined a `_error.page.js` file
+                // - Some unpexected vite-plugin-ssr internal error
+                if (checkIfAbort(err2, pageContext))
+                    return;
+                if (!isFirstRenderAttempt) {
+                    setTimeout(() => {
+                        // We let the server show the 404 page
+                        window.location.pathname = url;
+                    }, 0);
+                }
+                if (!isSameErrorMessage(err, err2)) {
+                    throw err2;
+                }
+                else {
+                    // Abort
+                    return;
+                }
+            }
+        }
+        objectAssign(pageContext, pageContextAddendum);
+        assertHook(pageContext, 'onPageTransitionStart');
+        globalObject.onPageTransitionStart = pageContext.exports.onPageTransitionStart;
+        if (pageContext.exports.hydrationCanBeAborted) {
+            hydrationCanBeAborted = true;
+        }
+        else {
+            assertWarning(!isReact(), 'You seem to be using React; we recommend setting `hydrationCanBeAborted` to `true`, see https://vite-plugin-ssr.com/clientRouting', { showStackTrace: false, onlyOnce: true });
+        }
+        if (shouldAbort()) {
+            return;
+        }
+        if (renderPromise) {
+            // Always make sure that the previous render has finished,
+            // otherwise that previous render may finish after this one.
+            await renderPromise;
+        }
+        if (shouldAbort()) {
+            return;
+        }
+        changeUrl(url, overwriteLastHistoryEntry);
+        navigationState.markNavigationChange();
+        assert(renderPromise === undefined);
+        renderPromise = (async () => {
+            await executeOnClientRender(pageContext, true);
+            addLinkPrefetchHandlers(pageContext);
+        })();
+        await renderPromise;
+        renderPromise = undefined;
+        if (pageContext._isFirstRenderAttempt) {
+            assertHook(pageContext, 'onHydrationEnd');
+            const { onHydrationEnd } = pageContext.exports;
+            if (onHydrationEnd) {
+                const hookSrc = pageContext.exportsAll.onHydrationEnd[0].exportSource;
+                assert(hookSrc);
+                await callHookWithTimeout(() => onHydrationEnd(pageContext), 'onHydrationEnd', hookSrc);
+            }
+        }
+        else if (renderingNumber === renderingCounter) {
+            if (pageContext.exports.onPageTransitionEnd) {
+                assertHook(pageContext, 'onPageTransitionEnd');
+                pageContext.exports.onPageTransitionEnd(pageContext);
+            }
+            isTransitioning = false;
+        }
+        setScrollPosition(scrollTarget);
+        browserNativeScrollRestoration_disable();
+        globalObject.initialRenderIsDone = true;
+    }
+}
+function onLinkClick(callback) {
+    document.addEventListener('click', onClick);
+    return;
+    // Code adapted from https://github.com/HenrikJoreteg/internal-nav-helper/blob/5199ec5448d0b0db7ec63cf76d88fa6cad878b7d/src/index.js#L11-L29
+    async function onClick(ev) {
+        if (!isNormalLeftClick(ev))
+            return;
+        const linkTag = findLinkTag(ev.target);
+        if (!linkTag)
+            return;
+        const url = linkTag.getAttribute('href');
+        if (skipLink(linkTag))
+            return;
+        assert(url);
+        ev.preventDefault();
+        const keepScrollPosition = ![null, 'false'].includes(linkTag.getAttribute('keep-scroll-position'));
+        callback(url, { keepScrollPosition });
+    }
+    function isNormalLeftClick(ev) {
+        return ev.button === 0 && !ev.ctrlKey && !ev.shiftKey && !ev.altKey && !ev.metaKey;
+    }
+    function findLinkTag(target) {
+        while (target.tagName !== 'A') {
+            const { parentNode } = target;
+            if (!parentNode) {
+                return null;
+            }
+            target = parentNode;
+        }
+        return target;
+    }
+}
+function onBrowserHistoryNavigation(callback) {
+    // The `event` of `window.addEventListener('popstate', (event) => /*...*/)` is useless:
+    //  - The History API doesn't provide the previous state (the popped state): https://stackoverflow.com/questions/48055323/is-history-state-always-the-same-as-popstate-event-state
+    window.addEventListener('popstate', () => {
+        const currentState = getState();
+        const scrollTarget = currentState.historyState.scrollPosition || 'scroll-to-top-or-hash';
+        const isHashNavigation = currentState.urlWithoutHash === globalObject.previousState.urlWithoutHash;
+        const isBackwardNavigation = !currentState.historyState.timestamp || !globalObject.previousState.historyState.timestamp
+            ? null
+            : currentState.historyState.timestamp < globalObject.previousState.historyState.timestamp;
+        globalObject.previousState = currentState;
+        if (isHashNavigation) {
+            // - `history.state` is uninitialized (`null`) when:
+            //   - The vite-plugin-ssr app runs `window.location.hash = '#section'`.
+            //   - The user clicks on an anchor link `<a href="#section">Section</a>`. (Because vite-plugin-ssr's `onLinkClick()` handler skips hash links.)
+            // - `history.state` is `null` when uninitialized: https://developer.mozilla.org/en-US/docs/Web/API/History/state
+            // - Alternatively, we completely take over hash navigation and reproduce the browser's native behavior upon hash navigation.
+            //   - Problem: we cannot intercept `window.location.hash = '#section'`. (Or maybe we can with the `hashchange` event?)
+            //   - Other potential problem: would there be a conflict when the user wants to override the browser's default behavior? E.g. for smooth scrolling, or when using hashes for saving states of some fancy animations.
+            // - Another alternative: we use the browser's scroll restoration mechanism (see `browserNativeScrollRestoration_enable()` below).
+            //   - Problem: not clear when to call `browserNativeScrollRestoration_disable()`/`browserNativeScrollRestoration_enable()`
+            //   - Other potential problem are inconsistencies between browsers: specification says that setting `window.history.scrollRestoration` only affects the current entry in the session history. But this seems to contradict what folks saying.
+            //     - Specification: https://html.spec.whatwg.org/multipage/history.html#the-history-interface
+            //     - https://stackoverflow.com/questions/70188241/history-scrollrestoration-manual-doesnt-prevent-safari-from-restoring-scrol
+            if (window.history.state === null) {
+                // The browser already scrolled to `#${hash}` => the current scroll position is the right one => we save it with `initHistoryState()`.
+                initHistoryState();
+                globalObject.previousState = getState();
+            }
+            else {
+                // If `history.state !== null` then it means that `popstate` was triggered by the user clicking on his browser's forward/backward history button.
+                setScrollPosition(scrollTarget);
+            }
+        }
+        else {
+            // Fetch & render new page
+            callback(scrollTarget, isBackwardNavigation);
+        }
+    });
+}
+function changeUrl(url, overwriteLastHistoryEntry) {
+    if (getCurrentUrl() === url)
+        return;
+    browserNativeScrollRestoration_disable();
+    pushHistory(url, overwriteLastHistoryEntry);
+    globalObject.previousState = getState();
+}
+function getState() {
+    return {
+        urlWithoutHash: getCurrentUrl({ withoutHash: true }),
+        historyState: getHistoryState()
+    };
+}
+function setScrollPosition(scrollTarget) {
+    if (scrollTarget === 'preserve-scroll') {
+        return;
+    }
+    let scrollPosition;
+    if (scrollTarget === 'scroll-to-top-or-hash') {
+        const hash = getUrlHash();
+        // We replicate the browser's native behavior
+        if (hash && hash !== 'top') {
+            const hashTarget = document.getElementById(hash) || document.getElementsByName(hash)[0];
+            if (hashTarget) {
+                hashTarget.scrollIntoView();
+                return;
+            }
+        }
+        scrollPosition = { x: 0, y: 0 };
+    }
+    else {
+        assert('x' in scrollTarget && 'y' in scrollTarget);
+        scrollPosition = scrollTarget;
+    }
+    setScroll(scrollPosition);
+}
+/** Change the browser's scoll position, in a way that works during a repaint. */
+function setScroll(scrollPosition) {
+    const scroll = () => window.scrollTo(scrollPosition.x, scrollPosition.y);
+    const done = () => window.scrollX === scrollPosition.x && window.scrollY === scrollPosition.y;
+    // In principle, this `done()` call should force the repaint to be finished. But that doesn't seem to be the case with `Firefox 97.0.1`.
+    if (done())
+        return;
+    scroll();
+    // Because `done()` doesn't seem to always force the repaint to be finished, we potentially need to retry again.
+    if (done())
+        return;
+    requestAnimationFrame(() => {
+        scroll();
+        if (done())
+            return;
+        setTimeout(async () => {
+            scroll();
+            if (done())
+                return;
+            // In principle, `requestAnimationFrame() -> setTimeout(, 0)` should be enough.
+            //  - https://stackoverflow.com/questions/61281139/waiting-for-repaint-in-javascript
+            //  - But it's not enough for `Firefox 97.0.1`.
+            //  - The following strategy is very agressive. It doesn't need to be that aggressive for Firefox. But we do it to be safe.
+            const start = new Date().getTime();
+            while (true) {
+                await sleep(10);
+                scroll();
+                if (done())
+                    return;
+                const millisecondsElapsed = new Date().getTime() - start;
+                if (millisecondsElapsed > 100)
+                    return;
+            }
+        }, 0);
+    });
+}
+function autoSaveScrollPosition() {
+    // Safari cannot handle more than 100 `history.replaceState()` calls within 30 seconds (https://github.com/brillout/vite-plugin-ssr/issues/46)
+    window.addEventListener('scroll', throttle(saveScrollPosition, Math.ceil(1000 / 3)), { passive: true });
+    onPageHide(saveScrollPosition);
+}
+function getUrlHash() {
+    let { hash } = window.location;
+    if (hash === '')
+        return null;
+    assert(hash.startsWith('#'));
+    hash = hash.slice(1);
+    return hash;
+}
+// We use the browser's native scroll restoration mechanism only for the first render
+function setupNativeScrollRestoration() {
+    browserNativeScrollRestoration_enable();
+    onPageHide(browserNativeScrollRestoration_enable);
+    onPageShow(() => globalObject.initialRenderIsDone && browserNativeScrollRestoration_disable());
+}
+function browserNativeScrollRestoration_disable() {
+    if ('scrollRestoration' in window.history) {
+        window.history.scrollRestoration = 'manual';
+    }
+}
+function browserNativeScrollRestoration_enable() {
+    if ('scrollRestoration' in window.history) {
+        window.history.scrollRestoration = 'auto';
+    }
+}
+function onPageHide(listener) {
+    window.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'hidden') {
+            listener();
+        }
+    });
+}
+function onPageShow(listener) {
+    window.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'visible') {
+            listener();
+        }
+    });
+}
+function checkIfAbort(err, pageContext) {
+    if (isObject(err) && err._abortRendering)
+        return true;
+    if (handleErrorFetchingStaticAssets(err, pageContext)) {
+        return true;
+    }
+    return false;
+}
+function handleErrorFetchingStaticAssets(err, pageContext) {
+    if (!isErrorFetchingStaticAssets(err)) {
+        return false;
+    }
+    if (pageContext._isFirstRenderAttempt) {
+        disableClientRouting(err, false);
+        // This may happen if the frontend was newly deployed during hydration.
+        // Ideally: re-try a couple of times by reloading the page (not entirely trivial to implement since `localStorage` is needed.)
+        throw err;
+    }
+    else {
+        disableClientRouting(err, true);
+    }
+    serverSideRouteTo(pageContext.urlOriginal);
+    return true;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/utils.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/utils.js
new file mode 100644
index 0000000..9e6735e
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/router/utils.js
@@ -0,0 +1,34 @@
+// Utils needed by Client Routing.
+// Ensure we don't bloat the server-side with client utils
+import { isBrowser } from '../../utils/isBrowser';
+import { assert } from '../../utils/assert';
+assert(isBrowser());
+// Ensure we don't bloat Server Routing with Client Routing utils
+import { assertClientRouting } from '../../utils/assertRoutingType';
+assertClientRouting();
+// We load the Server Routing utils: we tolerate the tiny amount of code that is only needed by Server Routing (only 1-2 lines).
+// We re-export some of the utils down below only to list the utils needed by Client Routing.
+export * from '../../client/utils';
+export * from '../../utils/assert';
+export * from '../../utils/assertSingleInstance';
+export * from '../../utils/callHookWithTimeout';
+export * from '../../utils/getCurrentUrl';
+export * from '../../utils/getGlobalObject';
+export * from '../../utils/getUrlPathname';
+export * from '../../utils/hasProp';
+export * from '../../utils/isBrowser';
+export * from '../../utils/isCallable';
+export * from '../../utils/isExternalLink';
+export * from '../../utils/isObject';
+export * from '../../utils/isPlainObject';
+export * from '../../utils/isReact';
+export * from '../../utils/isSameErrorMessage';
+export * from '../../utils/objectAssign';
+export * from '../../utils/parseUrl';
+export * from '../../utils/projectInfo';
+export * from '../../utils/PromiseType';
+export * from '../../utils/serverSideRouteTo';
+export * from '../../utils/sleep';
+export * from '../../utils/slice';
+export * from '../../utils/throttle';
+export * from '../../utils/assertRoutingType';
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/utils.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/utils.js
new file mode 100644
index 0000000..9f86078
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/client/utils.js
@@ -0,0 +1,19 @@
+// Utils needed by Server Routing.
+// Ensure we don't bloat the server-side with client utils
+import { isBrowser } from '../utils/isBrowser';
+import { assert } from '../utils/assert';
+assert(isBrowser());
+export * from '../utils/assert';
+export * from '../utils/assertSingleInstance';
+export * from '../utils/callHookWithTimeout';
+export * from '../utils/checkType'; // Only used by Server Routing (not needed for Client Routing)
+export * from '../utils/getCurrentUrl';
+export * from '../utils/getGlobalObject';
+export * from '../utils/hasProp';
+export * from '../utils/isCallable';
+export * from '../utils/isObject';
+export * from '../utils/objectAssign';
+export * from '../utils/parseUrl';
+export * from '../utils/projectInfo';
+export * from '../utils/slice';
+export * from '../utils/unique'; // Only used by Server Routing (not needed for Client Routing)
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/addComputedUrlProps.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/addComputedUrlProps.js
new file mode 100644
index 0000000..3a7fa3d
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/addComputedUrlProps.js
@@ -0,0 +1,91 @@
+import { assert, parseUrl, assertWarning, isPlainObject, hasPropertyGetter } from './utils';
+export { addComputedUrlProps };
+export { assertURLs };
+function addComputedUrlProps(pageContext) {
+    assert(pageContext.urlOriginal);
+    if ('urlPathname' in pageContext) {
+        assert(hasPropertyGetter(pageContext, 'urlPathname'));
+    }
+    else {
+        Object.defineProperty(pageContext, 'urlPathname', {
+            get: urlPathnameGetter,
+            enumerable: true,
+            configurable: true
+        });
+    }
+    if ('url' in pageContext) {
+        assert(hasPropertyGetter(pageContext, 'url'));
+    }
+    else {
+        Object.defineProperty(pageContext, 'url', {
+            get: urlGetter,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    if ('urlParsed' in pageContext) {
+        assert(hasPropertyGetter(pageContext, 'urlParsed'));
+    }
+    else {
+        Object.defineProperty(pageContext, 'urlParsed', {
+            get: urlParsedGetter,
+            enumerable: true,
+            configurable: true
+        });
+    }
+}
+function getUrlParsed(pageContext) {
+    let urlHandler = pageContext._urlHandler;
+    if (!urlHandler) {
+        urlHandler = (urlOriginal) => urlOriginal;
+    }
+    const url = urlHandler(pageContext.urlOriginal);
+    const baseServer = pageContext._baseServer;
+    assert(baseServer.startsWith('/'));
+    return parseUrl(url, baseServer);
+}
+function urlPathnameGetter() {
+    const { pathname } = getUrlParsed(this);
+    const urlPathname = pathname;
+    assert(urlPathname.startsWith('/'));
+    return urlPathname;
+}
+function urlGetter() {
+    assertWarning(false, '`pageContext.url` is outdated. Use `pageContext.urlPathname`, `pageContext.urlParsed`, or `pageContext.urlOriginal` instead. (See https://vite-plugin-ssr.com/migration/0.4.23 for more information.)', { onlyOnce: true, showStackTrace: true });
+    return urlPathnameGetter.call(this);
+}
+function urlParsedGetter() {
+    const urlParsedOriginal = getUrlParsed(this);
+    const { origin, pathname, pathnameOriginal, search, searchAll, searchOriginal, hash, hashOriginal } = urlParsedOriginal;
+    const urlParsed = {
+        origin,
+        pathname,
+        pathnameOriginal,
+        search,
+        searchAll,
+        searchOriginal,
+        hash,
+        hashOriginal,
+        get hashString() {
+            assertWarning(false, '`pageContext.urlParsed.hashString` has been renamed to `pageContext.urlParsed.hashOriginal`', { onlyOnce: true, showStackTrace: true });
+            return hashOriginal;
+        },
+        get searchString() {
+            assertWarning(false, '`pageContext.urlParsed.searchString` has been renamed to `pageContext.urlParsed.searchOriginal`', { onlyOnce: true, showStackTrace: true });
+            return searchOriginal;
+        }
+    };
+    makeNonEnumerable(urlParsed, 'hashString');
+    makeNonEnumerable(urlParsed, 'searchString');
+    return urlParsed;
+}
+function makeNonEnumerable(obj, prop) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+    Object.defineProperty(obj, prop, { ...descriptor, enumerable: false });
+}
+function assertURLs(pageContext) {
+    assert(typeof pageContext.urlOriginal === 'string');
+    assert(typeof pageContext.urlPathname === 'string');
+    assert(isPlainObject(pageContext.urlParsed));
+    assert(pageContext.urlPathname === pageContext.urlParsed.pathname);
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/addIs404ToPageProps.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/addIs404ToPageProps.js
new file mode 100644
index 0000000..250b227
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/addIs404ToPageProps.js
@@ -0,0 +1,23 @@
+export { addIs404ToPageProps };
+import { assert, assertWarning, hasProp, isObject } from './utils';
+import { isErrorPage } from './error-page';
+function addIs404ToPageProps(pageContext) {
+    assertIs404(pageContext);
+    addIs404(pageContext);
+}
+function assertIs404(pageContext) {
+    if (isErrorPage(pageContext._pageId, pageContext._pageConfigs)) {
+        assert(hasProp(pageContext, 'is404', 'boolean'));
+    }
+}
+function addIs404(pageContext) {
+    if (pageContext.is404 === undefined || pageContext.is404 === null)
+        return;
+    const pageProps = pageContext.pageProps || {};
+    if (!isObject(pageProps)) {
+        assertWarning(false, 'pageContext.pageProps should be an object', { showStackTrace: true, onlyOnce: true });
+        return;
+    }
+    pageProps.is404 = pageProps.is404 || pageContext.is404;
+    pageContext.pageProps = pageProps;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/assertHookResult.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/assertHookResult.js
new file mode 100644
index 0000000..ebead59
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/assertHookResult.js
@@ -0,0 +1,35 @@
+export { assertHookResult };
+export { assertObjectKeys };
+import { assert, assertUsage, isPlainObject, stringifyStringArray } from './utils';
+import { assertPageContextProvidedByUser } from './assertPageContextProvidedByUser';
+function assertHookResult(hookResult, hookName, hookResultKeys, hookSrc, canBePromise = false) {
+    assert(!hookName.endsWith(')'));
+    const errPrefix = `The ${hookName}() hook defined by ${hookSrc}`;
+    assertUsage(hookResult === null || hookResult === undefined || isPlainObject(hookResult), `${errPrefix} should return \`null\`, \`undefined\`, or a plain JavaScript object.`);
+    if (hookResult === undefined || hookResult === null) {
+        return;
+    }
+    assertObjectKeys(hookResult, hookResultKeys, errPrefix);
+    if ('pageContext' in hookResult) {
+        assertPageContextProvidedByUser(hookResult['pageContext'], {
+            hook: { hookName, hookSrc },
+            canBePromise
+        });
+    }
+}
+function assertObjectKeys(obj, keysExpected, errPrefix) {
+    const keysUnknown = [];
+    const keys = Object.keys(obj);
+    for (const key of keys) {
+        if (!keysExpected.includes(key)) {
+            keysUnknown.push(key);
+        }
+    }
+    assertUsage(keysUnknown.length === 0, [
+        errPrefix,
+        'returned an object with unknown keys',
+        stringifyStringArray(keysUnknown) + '.',
+        'Only following keys are allowed:',
+        stringifyStringArray(keysExpected) + '.'
+    ].join(' '));
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/assertPageContextProvidedByUser.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/assertPageContextProvidedByUser.js
new file mode 100644
index 0000000..2149d74
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/assertPageContextProvidedByUser.js
@@ -0,0 +1,19 @@
+import { assert, assertUsage, assertWarning, isObject, isCallable, isPromise } from './utils';
+export { assertPageContextProvidedByUser };
+function assertPageContextProvidedByUser(pageContextProvidedByUser, { hook, errorMessagePrefix, canBePromise }) {
+    if (!errorMessagePrefix) {
+        assert(hook);
+        const { hookName, hookSrc } = hook;
+        assert(!hookName.endsWith(')'));
+        errorMessagePrefix = `The \`pageContext\` provided by the ${hookName}() hook defined by ${hookSrc}`;
+    }
+    if (canBePromise && !isObject(pageContextProvidedByUser)) {
+        assertUsage(isCallable(pageContextProvidedByUser) || isPromise(pageContextProvidedByUser), `${errorMessagePrefix} should be an object, or an async function https://vite-plugin-ssr.com/stream#initial-data-after-stream-end`);
+        return;
+    }
+    assertUsage(isObject(pageContextProvidedByUser), `${errorMessagePrefix} should be an object.`);
+    assertUsage(!('_objectCreatedByVitePluginSsr' in pageContextProvidedByUser), `${errorMessagePrefix} should not be the whole \`pageContext\` object, see https://vite-plugin-ssr.com/pageContext-manipulation#do-not-return-entire-pagecontext`);
+    // In principle, it's possible to use `onBeforeRoute()` to override and define the whole routing.
+    // Is that a good idea to allow users to do this? Beyond deep integration with Vue Router or React Router, is there a use case for this?
+    assertWarning(!('_pageId' in pageContextProvidedByUser), 'You are using `onBeforeRoute()` to override vite-plugin-ssr routing. This is experimental: make sure to contact a vite-plugin-ssr maintainer before using this.', { showStackTrace: false, onlyOnce: true });
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/assertPageFilePath.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/assertPageFilePath.js
new file mode 100644
index 0000000..8ab4626
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/assertPageFilePath.js
@@ -0,0 +1,6 @@
+export { assertPageFilePath };
+import { assert, isNpmPackageModule, assertPosixPath } from './utils';
+function assertPageFilePath(filePath) {
+    assertPosixPath(filePath);
+    assert(filePath.startsWith('/') || isNpmPackageModule(filePath), { filePath });
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/determinePageIdOld.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/determinePageIdOld.js
new file mode 100644
index 0000000..b756dee
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/determinePageIdOld.js
@@ -0,0 +1,9 @@
+export { determinePageIdOld };
+import { slice, assert } from './utils';
+// TODO/v1-release: remove
+function determinePageIdOld(filePath) {
+    const pageSuffix = '.page.';
+    const pageId = slice(filePath.split(pageSuffix), 0, -1).join(pageSuffix);
+    assert(!pageId.includes('\\'));
+    return pageId;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/error-page.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/error-page.js
new file mode 100644
index 0000000..47c09e6
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/error-page.js
@@ -0,0 +1,38 @@
+export { getErrorPageId };
+export { isErrorPageId };
+export { isErrorPage };
+// TODO/v1-release: consider loading this file only for Client Routing
+import { assert, assertUsage, unique } from './utils';
+function getErrorPageId(pageFilesAll, pageConfigs) {
+    if (pageConfigs.length > 0) {
+        const errorPageConfigs = pageConfigs.filter((p) => p.isErrorPage);
+        if (errorPageConfigs.length === 0)
+            return null;
+        assertUsage(errorPageConfigs.length === 1, 'Only one error page can be defined');
+        return errorPageConfigs[0].pageId;
+    }
+    // TODO/v1-release: remove
+    const errorPageIds = unique(pageFilesAll.map(({ pageId }) => pageId).filter((pageId) => isErrorPageId(pageId, false)));
+    assertUsage(errorPageIds.length <= 1, `Only one _error.page.js is allowed, but found several: ${errorPageIds.join(' ')}`);
+    if (errorPageIds.length > 0) {
+        const errorPageId = errorPageIds[0];
+        assert(errorPageId);
+        return errorPageId;
+    }
+    return null;
+}
+// TODO/v1-release: remove
+function isErrorPageId(pageId, _isV1Design) {
+    assert(!pageId.includes('\\'));
+    return pageId.includes('/_error');
+}
+function isErrorPage(pageId, pageConfigs) {
+    if (pageConfigs.length > 0) {
+        const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
+        assert(pageConfig);
+        return pageConfig.isErrorPage;
+    }
+    else {
+        return isErrorPageId(pageId, false);
+    }
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getHook.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getHook.js
new file mode 100644
index 0000000..aac56d2
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getHook.js
@@ -0,0 +1,19 @@
+export { getHook };
+export { assertHook };
+import { assert, assertUsage, isCallable } from './utils';
+function getHook(pageContext, hookName) {
+    if (!(hookName in pageContext.exports)) {
+        return null;
+    }
+    const hook = pageContext.exports[hookName];
+    const file = pageContext.exportsAll[hookName][0];
+    assert(file.exportValue === hook);
+    const hookSrc = file.exportSource;
+    assert(hookSrc);
+    assert(!hookName.endsWith(')'));
+    assertUsage(isCallable(hook), `hook ${hookName}() defined by ${hookSrc} should be a function`);
+    return { hook, hookSrc };
+}
+function assertHook(pageContext, hookName) {
+    getHook(pageContext, hookName);
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageContextRequestUrl.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageContextRequestUrl.js
new file mode 100644
index 0000000..aad97cd
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageContextRequestUrl.js
@@ -0,0 +1,13 @@
+export { getPageContextRequestUrl };
+export { fileExtension };
+export { doNotCreateExtraDirectory };
+// This module isn't loaded by the client-side of Server Routing => we don't inlcude `urlToFile` to `./utils.ts`
+import { urlToFile } from '../utils/urlToFile';
+const fileExtension = '.pageContext.json';
+// `/some-base-url/index.pageContext.json` instead of `/some-base-url.pageContext.json` in order to comply to common reverse proxy setups, see https://github.com/brillout/vite-plugin-ssr/issues/443
+const doNotCreateExtraDirectory = false;
+// See node/renderPage/handlePageContextRequestUrl.ts
+function getPageContextRequestUrl(url) {
+    const pageContextRequestUrl = urlToFile(url, fileExtension, doNotCreateExtraDirectory);
+    return pageContextRequestUrl;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzeClientSide.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzeClientSide.js
new file mode 100644
index 0000000..13ac109
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzeClientSide.js
@@ -0,0 +1,18 @@
+export { analyzeClientSide };
+import { getCodeFilePath, getConfigValue } from '../page-configs/utils';
+import { analyzePageClientSide } from './analyzePageClientSide';
+function analyzeClientSide(pageConfig, pageFilesAll, pageId) {
+    var _a;
+    if (pageConfig) {
+        const isClientRouting = (_a = getConfigValue(pageConfig, 'clientRouting', 'boolean')) !== null && _a !== void 0 ? _a : false;
+        const onRenderClientExists = !!getCodeFilePath(pageConfig, 'onRenderClient');
+        const PageExists = !!getCodeFilePath(pageConfig, 'Page') && pageConfig.configElements.Page.configEnv !== 'server-only';
+        const isClientSideRenderable = onRenderClientExists && PageExists;
+        return { isClientSideRenderable, isClientRouting };
+    }
+    else {
+        // TOOD: globally rename isHtmlOnly to !isClientSideRenderable
+        const { isHtmlOnly, isClientRouting } = analyzePageClientSide(pageFilesAll, pageId);
+        return { isClientSideRenderable: !isHtmlOnly, isClientRouting };
+    }
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzePageClientSide.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzePageClientSide.js
new file mode 100644
index 0000000..c384d6a
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzePageClientSide.js
@@ -0,0 +1,58 @@
+export { analyzePageClientSide };
+export { analyzePageClientSideInit };
+import { analyzeExports } from './analyzePageClientSide/analyzeExports';
+import { determineClientEntry } from './analyzePageClientSide/determineClientEntry';
+import { getPageFilesClientSide } from './getAllPageIdFiles';
+import { getPageFilesServerSide } from './getAllPageIdFiles';
+import { assert } from '../utils';
+import { getExportNames } from './analyzePageClientSide/getExportNames';
+// TODO/v1-release: remove analyzePageClientSide(), use analyzeClientSide() instead
+function analyzePageClientSide(pageFilesAll, pageId) {
+    let pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
+    const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
+    const { isHtmlOnly, isClientRouting } = analyzeExports({ pageFilesClientSide, pageFilesServerSide, pageId });
+    if (isHtmlOnly) {
+        // HTML-only pages don't need any client-side `render()` hook. For apps that have both HTML-only and SSR/SPA pages, we skip the `.page.client.js` file that defines `render()` for HTML-only pages.
+        pageFilesClientSide = pageFilesClientSide.filter((p) => p.isEnv('CLIENT_ONLY') && !getExportNames(p).includes('render'));
+        pageFilesClientSide = removeOverridenPageFiles(pageFilesClientSide);
+    }
+    const { clientEntries, clientDependencies } = determineClientEntry({
+        pageFilesClientSide,
+        pageFilesServerSide,
+        isHtmlOnly,
+        isClientRouting
+    });
+    return { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide };
+}
+async function analyzePageClientSideInit(pageFilesAll, pageId, { sharedPageFilesAlreadyLoaded }) {
+    const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
+    await Promise.all(pageFilesClientSide.map(async (p) => {
+        var _a;
+        assert(p.isEnv('CLIENT_ONLY') || p.isEnv('CLIENT_AND_SERVER'));
+        if (sharedPageFilesAlreadyLoaded && p.isEnv('CLIENT_AND_SERVER')) {
+            return;
+        }
+        // TODO: Is `loadExportNames()` cached ? Does it use filesExports if possible? HMR?
+        await ((_a = p.loadExportNames) === null || _a === void 0 ? void 0 : _a.call(p));
+        /*
+        if (pageFile.exportNames) {
+          return pageFile.exportNames.includes(clientRouting)
+        }
+        if (pageFile.fileExports) {
+          return Object.keys(pageFile.fileExports).includes(clientRouting)
+        }
+        */
+    }));
+}
+// [WIP] Just an experiment needed by https://vite-plugin-ssr.com/banner
+//  - Not sure I want to make something like a public API: the CSS of `_default.page.server.js` are still loaded -> weird DX.
+function removeOverridenPageFiles(pageFilesClientSide) {
+    const pageFilesClientSide_ = [];
+    for (const p of pageFilesClientSide) {
+        pageFilesClientSide_.push(p);
+        if (getExportNames(p).includes('overrideDefaultPages')) {
+            break;
+        }
+    }
+    return pageFilesClientSide_;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzePageClientSide/analyzeExports.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzePageClientSide/analyzeExports.js
new file mode 100644
index 0000000..2f2c600
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzePageClientSide/analyzeExports.js
@@ -0,0 +1,47 @@
+export { analyzeExports };
+import { getExportNames } from './getExportNames';
+import { assertUsage } from '../../utils';
+function analyzeExports({ pageFilesClientSide, pageFilesServerSide, pageId }) {
+    return { isHtmlOnly: isHtmlOnly(), isClientRouting: isClientRouting() };
+    function isHtmlOnly() {
+        {
+            const hasPageIdIsmrphFile = pageFilesServerSide.some((p) => p.pageId === pageId && p.fileType === '.page');
+            if (hasPageIdIsmrphFile) {
+                assertClientSideRenderHook();
+                return false;
+            }
+        }
+        {
+            const hasPageIdServerFile = pageFilesServerSide.some((p) => p.pageId === pageId && p.fileType === '.page.server');
+            if (!hasPageIdServerFile) {
+                return false;
+            }
+        }
+        {
+            const definesClientRenderer = pageFilesClientSide.some((p) => p.pageId === pageId && p.fileType === '.page.client' && getExportNames(p).includes('render'));
+            if (definesClientRenderer) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function assertClientSideRenderHook() {
+        const hasClientSideRenderHook = pageFilesClientSide.some((p) => {
+            return getExportNames(p).includes('render');
+        });
+        assertUsage(hasClientSideRenderHook, [
+            'No client-side `render()` hook found.',
+            'See https://vite-plugin-ssr.com/render-modes for more information.',
+            [
+                'Loaded client-side page files (none of them `export { render }`):',
+                ...pageFilesClientSide.map((p, i) => ` (${i + 1}): ${p.filePath}`)
+            ].join('\n')
+        ].join(' '));
+    }
+    function isClientRouting() {
+        const hasClientRoutingExport = pageFilesClientSide.some((p) => {
+            return getExportNames(p).includes('clientRouting');
+        });
+        return hasClientRoutingExport;
+    }
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzePageClientSide/determineClientEntry.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzePageClientSide/determineClientEntry.js
new file mode 100644
index 0000000..c66b3a1
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzePageClientSide/determineClientEntry.js
@@ -0,0 +1,29 @@
+export { determineClientEntry };
+export { getVPSClientEntry };
+function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtmlOnly, isClientRouting }) {
+    let clientEntries = [];
+    const pageFilesServerSideOnly = pageFilesServerSide.filter((p) => !pageFilesClientSide.includes(p));
+    const clientDependencies = [];
+    clientDependencies.push(...pageFilesClientSide.map((p) => ({ id: p.filePath, onlyAssets: false, eagerlyImported: false })));
+    // CSS & assets
+    clientDependencies.push(...pageFilesServerSideOnly.map((p) => ({ id: p.filePath, onlyAssets: true, eagerlyImported: false })));
+    // Handle SPA & SSR pages.
+    if (isHtmlOnly) {
+        clientEntries = pageFilesClientSide.map((p) => p.filePath);
+    }
+    else {
+        // Add the vps client entry
+        const clientEntry = getVPSClientEntry(isClientRouting);
+        clientDependencies.push({ id: clientEntry, onlyAssets: false, eagerlyImported: false });
+        clientEntries = [clientEntry];
+    }
+    // console.log(pageFilesClientSide, pageFilesServerSide, clientDependencies, clientEntry)
+    return { clientEntries, clientDependencies };
+}
+function getVPSClientEntry(isClientRouting) {
+    return isClientRouting
+        ? // dist/client/entries/entry-client-routing.js
+            '@@vite-plugin-ssr/dist/esm/client/router/entry.js'
+        : // dist/client/entries/entry-server-routing.js
+            '@@vite-plugin-ssr/dist/esm/client/entry.js';
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzePageClientSide/getExportNames.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzePageClientSide/getExportNames.js
new file mode 100644
index 0000000..c6c3870
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzePageClientSide/getExportNames.js
@@ -0,0 +1,13 @@
+export { getExportNames };
+import { assert } from '../../utils';
+function getExportNames(p) {
+    if (p.fileType === '.css') {
+        return [];
+    }
+    if (p.exportNames) {
+        return p.exportNames;
+    }
+    assert(p.fileExports, p.filePath);
+    const exportNames = Object.keys(p.fileExports);
+    return exportNames;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzePageServerSide.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzePageServerSide.js
new file mode 100644
index 0000000..c4bddd6
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/analyzePageServerSide.js
@@ -0,0 +1,20 @@
+export { analyzePageServerSide };
+import { assert } from '../utils';
+import { getPageFilesServerSide } from './getAllPageIdFiles';
+async function analyzePageServerSide(pageFilesAll, pageId) {
+    const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
+    const pageFilesServerSideOnly = pageFilesServerSide.filter((p) => p.fileType === '.page.server');
+    await Promise.all(pageFilesServerSideOnly.map(async (p) => {
+        // In production, `exportNames` are preload
+        if (p.exportNames) {
+            return;
+        }
+        assert(p.loadExportNames, pageId);
+        await p.loadExportNames();
+    }));
+    const hasOnBeforeRenderServerSideOnlyHook = pageFilesServerSideOnly.some(({ exportNames }) => {
+        assert(exportNames);
+        return exportNames.includes('onBeforeRender');
+    });
+    return { hasOnBeforeRenderServerSideOnlyHook };
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/assertExports.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/assertExports.js
new file mode 100644
index 0000000..fe1e940
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/assertExports.js
@@ -0,0 +1,21 @@
+// TODO/v1-release: remove this
+export { assertDefaultExports };
+export { assertExportValues };
+export { forbiddenDefaultExports };
+import { assert, assertUsage } from '../utils';
+const enforceTrue = ['clientRouting'];
+function assertExportValues(pageFile) {
+    enforceTrue.forEach((exportName) => {
+        assert(pageFile.fileExports);
+        if (!(exportName in pageFile.fileExports))
+            return;
+        const explainer = `The value of \`${exportName}\` is only allowed to be \`true\`.`;
+        assertUsage(pageFile.fileExports[exportName] !== false, `${pageFile.filePath} has \`export { ${exportName} }\` with the value \`false\` which is prohibited: remove \`export { ${exportName} }\` instead. (${explainer})`);
+        assertUsage(pageFile.fileExports[exportName] === true, `${pageFile.filePath} has \`export { ${exportName} }\` with a forbidden value. ${explainer}`);
+    });
+}
+// Forbid exports such as `export default { render }`, because only `export { render }` can be statically analyzed by `es-module-lexer`.
+const forbiddenDefaultExports = ['render', 'clientRouting', 'prerender', 'doNotPrerender'];
+function assertDefaultExports(defaultExportName, filePath) {
+    assertUsage(!forbiddenDefaultExports.includes(defaultExportName), `${filePath} has \`export default { ${defaultExportName} }\` which is prohibited, use \`export { ${defaultExportName} }\` instead.`);
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/assertPageConfigs.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/assertPageConfigs.js
new file mode 100644
index 0000000..1213a86
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/assertPageConfigs.js
@@ -0,0 +1,45 @@
+export { assertPageConfigs };
+export { assertPageConfigGlobal };
+import { assert, isObject, hasProp } from '../utils';
+function assertPageConfigs(pageConfigs) {
+    assert(Array.isArray(pageConfigs) || pageConfigs === null);
+    // TODO: remove obsolete comment?
+    // if `plusConfigFilesCannotBeLoaded === null` => then `import.meta.glob('/**/+config.${scriptFileExtensions}', { eager: true })` cannot be transpiled/loaded => code of virtual file cannot be generated or run => assertPageConfigs() is never called
+    assert(pageConfigs !== null);
+    pageConfigs.forEach((pageConfig) => {
+        assert(isObject(pageConfig));
+        assert(hasProp(pageConfig, 'pageId', 'string'));
+        assert(hasProp(pageConfig, 'plusConfigFilePathAll', 'string[]'));
+        assert(hasProp(pageConfig, 'routeFilesystem', 'string') || hasProp(pageConfig, 'routeFilesystem', 'null'));
+        assert(hasProp(pageConfig, 'routeFilesystemDefinedBy', 'string'));
+        assert(hasProp(pageConfig, 'loadCodeFiles', 'function'));
+        assert(hasProp(pageConfig, 'isErrorPage', 'boolean'));
+        assert(hasProp(pageConfig, 'configElements', 'object'));
+        assertConfigElements(pageConfig.configElements, false);
+    });
+}
+function assertPageConfigGlobal(pageConfigGlobal) {
+    assertConfigElements(pageConfigGlobal, true);
+}
+function assertConfigElements(configElements, isGlobalConfig) {
+    assert(isObject(configElements));
+    Object.entries(configElements).forEach(([configName, configElement]) => {
+        assert(isObject(configElement) || configElement === null);
+        if (configElement === null) {
+            assert(isGlobalConfig);
+            return;
+        }
+        assert(hasProp(configElement, 'configDefinedAt', 'string'));
+        assert(hasProp(configElement, 'plusConfigFilePath', 'string') || hasProp(configElement, 'plusConfigFilePath', 'null'));
+        assert(hasProp(configElement, 'configEnv', 'string'));
+        assert(hasProp(configElement, 'codeFilePath', 'string') || hasProp(configElement, 'codeFilePath', 'null'));
+        assert(hasProp(configElement, 'codeFileExport', 'string') || hasProp(configElement, 'codeFileExport', 'null'));
+        assert(hasProp(configElement, 'configValueSerialized', 'string') ||
+            hasProp(configElement, 'configValueSerialized', 'undefined'));
+        if (isGlobalConfig ||
+            // Route files are eagerly loaded (both code files and config value files)
+            configName === 'route') {
+            assert(hasProp(configElement, 'configValue'));
+        }
+    });
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/fileTypes.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/fileTypes.js
new file mode 100644
index 0000000..81ce7ae
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/fileTypes.js
@@ -0,0 +1,47 @@
+export { fileTypes };
+export { isValidFileType };
+export { determineFileType };
+import { assert, assertPosixPath, isNpmPackageModule } from '../utils';
+import { isScriptFile } from '../../utils/isScriptFile';
+const fileTypes = [
+    '.page',
+    '.page.server',
+    '.page.route',
+    '.page.client',
+    // New type `.page.css`/`.page.server.css`/`.page.client.css` for `extensions[number].pageFileDist`.
+    //  - Extensions using `pageFileDist` are expected to use a bundler that generates a `.css` colocated next to the original `.page.js` file (e.g. `/renderer/_default.page.server.css` for `/renderer/_default.page.server.js`.
+    //  - Since these `.page.css` files Bundlers We can therefore expect that there isn't any `.page.server.sass`/...
+    '.css'
+];
+function isValidFileType(filePath) {
+    return ['.js', '.mjs', '.cjs', '.css'].some((ext) => filePath.endsWith(ext));
+}
+function determineFileType(filePath) {
+    assertPosixPath(filePath);
+    {
+        const isCSS = filePath.endsWith('.css');
+        if (isCSS) {
+            assert(isNpmPackageModule(filePath), filePath); // `.css` page files are only supported for npm packages
+            return '.css';
+        }
+    }
+    assert(isScriptFile(filePath), filePath);
+    const fileName = filePath.split('/').slice(-1)[0];
+    const parts = fileName.split('.');
+    const suffix1 = parts.slice(-3)[0];
+    const suffix2 = parts.slice(-2)[0];
+    if (suffix2 === 'page') {
+        return '.page';
+    }
+    assert(suffix1 === 'page', filePath);
+    if (suffix2 === 'server') {
+        return '.page.server';
+    }
+    if (suffix2 === 'client') {
+        return '.page.client';
+    }
+    if (suffix2 === 'route') {
+        return '.page.route';
+    }
+    assert(false, filePath);
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/getAllPageIdFiles.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/getAllPageIdFiles.js
new file mode 100644
index 0000000..b7daaba
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/getAllPageIdFiles.js
@@ -0,0 +1,102 @@
+export { getPageFilesClientSide };
+export { getPageFilesServerSide };
+import { assert, assertUsage, isNotNullish } from '../utils';
+import { assertPageFilePath } from '../assertPageFilePath';
+function getPageFilesClientSide(pageFilesAll, pageId) {
+    return determine(pageFilesAll, pageId, true);
+}
+function getPageFilesServerSide(pageFilesAll, pageId) {
+    return determine(pageFilesAll, pageId, false);
+}
+function determine(pageFilesAll, pageId, envIsClient) {
+    const env = envIsClient ? 'CLIENT_ONLY' : 'SERVER_ONLY';
+    const pageFilesRelevant = pageFilesAll
+        .filter((p) => p.isRelevant(pageId) && p.fileType !== '.page.route')
+        .sort(getPageFilesSorter(envIsClient, pageId));
+    // Load the `.page.js` files specific to `pageId`
+    const getPageIdFile = (iso) => {
+        const files = pageFilesRelevant.filter((p) => p.pageId === pageId && p.isEnv(iso ? 'CLIENT_AND_SERVER' : env));
+        assertUsage(files.length <= 1, `Merge the following files into a single file: ${files.map((p) => p.filePath).join(' ')}`);
+        const pageIdFile = files[0];
+        assert(pageIdFile === undefined || !pageIdFile.isDefaultPageFile);
+        return pageIdFile;
+    };
+    const pageIdFileEnv = getPageIdFile(false);
+    const pageIdFileIso = getPageIdFile(true);
+    // A page can have only one renderer. In other words: Multiple `renderer/` overwrite each other.
+    // Load only load renderer (`/renderer/_default.*`)
+    const getRendererFile = (iso) => pageFilesRelevant.filter((p) => p.isRendererPageFile && p.isEnv(iso ? 'CLIENT_AND_SERVER' : env))[0];
+    const rendererFileEnv = getRendererFile(false);
+    const rendererFileIso = getRendererFile(true);
+    // A page can load multiple `_defaut.page.*` files of the same `fileType`. In other words: non-renderer `_default.page.*` files are cumulative.
+    // The exception being HTML-only pages because we pick a single page file as client entry. We handle that use case at `renderPage()`.
+    const defaultFilesNonRenderer = pageFilesRelevant.filter((p) => p.isDefaultPageFile && !p.isRendererPageFile && (p.isEnv(env) || p.isEnv('CLIENT_AND_SERVER')));
+    // Ordered by `pageContext.exports` precendence
+    const pageFiles = [pageIdFileEnv, pageIdFileIso, ...defaultFilesNonRenderer, rendererFileEnv, rendererFileIso].filter(isNotNullish);
+    return pageFiles;
+}
+function getPageFilesSorter(envIsClient, pageId) {
+    const env = envIsClient ? 'CLIENT_ONLY' : 'SERVER_ONLY';
+    const e1First = -1;
+    const e2First = +1;
+    const noOrder = 0;
+    return (e1, e2) => {
+        // `.page.js` files specific to `pageId` first
+        if (!e1.isDefaultPageFile && e2.isDefaultPageFile) {
+            return e1First;
+        }
+        if (!e2.isDefaultPageFile && e1.isDefaultPageFile) {
+            return e2First;
+        }
+        // Non-renderer `_default.page.*` before `renderer/**/_default.page.*`
+        {
+            const e1_isRenderer = e1.isRendererPageFile;
+            const e2_isRenderer = e2.isRendererPageFile;
+            if (!e1_isRenderer && e2_isRenderer) {
+                return e1First;
+            }
+            if (!e2_isRenderer && e1_isRenderer) {
+                return e2First;
+            }
+            assert(e1_isRenderer === e2_isRenderer);
+        }
+        // Filesystem nearest first
+        {
+            const e1_distance = getPathDistance(pageId, e1.filePath);
+            const e2_distance = getPathDistance(pageId, e2.filePath);
+            if (e1_distance < e2_distance) {
+                return e1First;
+            }
+            if (e2_distance < e1_distance) {
+                return e2First;
+            }
+            assert(e1_distance === e2_distance);
+        }
+        // `.page.server.js`/`.page.client.js` before `.page.js`
+        {
+            if (e1.isEnv(env) && e2.isEnv('CLIENT_AND_SERVER')) {
+                return e1First;
+            }
+            if (e2.isEnv(env) && e1.isEnv('CLIENT_AND_SERVER')) {
+                return e2First;
+            }
+        }
+        return noOrder;
+    };
+}
+function getPathDistance(pathA, pathB) {
+    assertPageFilePath(pathA);
+    assertPageFilePath(pathB);
+    // Index of first different character
+    let idx = 0;
+    for (; idx < pathA.length && idx < pathB.length; idx++) {
+        if (pathA[idx] !== pathB[idx])
+            break;
+    }
+    const pathAWithoutCommon = pathA.slice(idx);
+    const pathBWithoutCommon = pathB.slice(idx);
+    const distanceA = pathAWithoutCommon.split('/').length;
+    const distanceB = pathBWithoutCommon.split('/').length;
+    const distance = distanceA + distanceB;
+    return distance;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/getExports.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/getExports.js
new file mode 100644
index 0000000..4f71234
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/getExports.js
@@ -0,0 +1,136 @@
+export { getExportUnion };
+export { getExports };
+import { isScriptFile, isTemplateFile } from '../../utils/isScriptFile';
+import { assert, hasProp, isObject, assertWarning, assertUsage, makeLast, isBrowser, objectEntries } from '../utils';
+import { assertDefaultExports, forbiddenDefaultExports } from './assertExports';
+function getExports(pageFiles, pageConfig) {
+    const configEntries = {};
+    const config = {};
+    const exportsAll = {};
+    // V0.4 design
+    // TODO/v1-release: remove
+    pageFiles.forEach((pageFile) => {
+        const exportValues = getExportValues(pageFile);
+        exportValues.forEach(({ exportName, exportValue, isFromDefaultExport }) => {
+            var _a;
+            assert(exportName !== 'default');
+            exportsAll[exportName] = (_a = exportsAll[exportName]) !== null && _a !== void 0 ? _a : [];
+            exportsAll[exportName].push({
+                exportValue,
+                exportSource: `${pageFile.filePath} > ${isFromDefaultExport ? `\`export default { ${exportName} }\`` : `\`export { ${exportName} }\``}`,
+                filePath: pageFile.filePath,
+                _filePath: pageFile.filePath,
+                _fileType: pageFile.fileType,
+                _isFromDefaultExport: isFromDefaultExport
+            });
+        });
+    });
+    // V1 design
+    if (pageConfig) {
+        const { configValues } = pageConfig;
+        objectEntries(configValues).forEach(([configName, configValue]) => {
+            var _a, _b, _c;
+            const configElement = pageConfig.configElements[configName];
+            assert(configElement);
+            const { configDefinedByFile, configDefinedAt } = configElement;
+            assert(configDefinedByFile);
+            config[configName] = (_a = config[configName]) !== null && _a !== void 0 ? _a : configValue;
+            configEntries[configName] = (_b = configEntries[configName]) !== null && _b !== void 0 ? _b : [];
+            configEntries[configName].push({
+                configValue,
+                configDefinedAt,
+                configDefinedByFile
+            });
+            // TODO/v1-release: remove
+            const exportName = configName;
+            exportsAll[exportName] = (_c = exportsAll[exportName]) !== null && _c !== void 0 ? _c : [];
+            exportsAll[exportName].push({
+                exportValue: configValue,
+                exportSource: configDefinedAt,
+                filePath: configDefinedByFile,
+                _filePath: configDefinedByFile,
+                _fileType: null,
+                _isFromDefaultExport: null
+            });
+        });
+    }
+    const pageExports = createObjectWithDeprecationWarning();
+    const exports = {};
+    Object.entries(exportsAll).forEach(([exportName, values]) => {
+        values.forEach(({ exportValue, _fileType, _isFromDefaultExport }) => {
+            var _a;
+            exports[exportName] = (_a = exports[exportName]) !== null && _a !== void 0 ? _a : exportValue;
+            // Legacy `pageContext.pageExports`
+            if (_fileType === '.page' && !_isFromDefaultExport) {
+                if (!(exportName in pageExports)) {
+                    pageExports[exportName] = exportValue;
+                }
+            }
+        });
+    });
+    assert(!('default' in exports));
+    assert(!('default' in exportsAll));
+    return {
+        config,
+        configEntries,
+        // TODO/v1-release: remove
+        exports,
+        exportsAll,
+        pageExports
+    };
+}
+function getExportValues(pageFile) {
+    const { filePath, fileExports } = pageFile;
+    assert(fileExports); // assume pageFile.loadFile() was called
+    assert(isScriptFile(filePath));
+    const exportValues = [];
+    Object.entries(fileExports)
+        .sort(makeLast(([exportName]) => exportName === 'default')) // `export { bla }` should override `export default { bla }`
+        .forEach(([exportName, exportValue]) => {
+        let isFromDefaultExport = exportName === 'default';
+        if (isFromDefaultExport) {
+            if (isTemplateFile(filePath)) {
+                exportName = 'Page';
+            }
+            else {
+                assertUsage(isObject(exportValue), `The \`export default\` of ${filePath} should be an object.`);
+                Object.entries(exportValue).forEach(([defaultExportName, defaultExportValue]) => {
+                    assertDefaultExports(defaultExportName, filePath);
+                    exportValues.push({
+                        exportName: defaultExportName,
+                        exportValue: defaultExportValue,
+                        isFromDefaultExport
+                    });
+                });
+                return;
+            }
+        }
+        exportValues.push({
+            exportName,
+            exportValue,
+            isFromDefaultExport
+        });
+    });
+    exportValues.forEach(({ exportName, isFromDefaultExport }) => {
+        assert(!(isFromDefaultExport && forbiddenDefaultExports.includes(exportName)));
+    });
+    return exportValues;
+}
+function createObjectWithDeprecationWarning() {
+    return new Proxy({}, {
+        get(...args) {
+            // We only show the warning in Node.js because when using Client Routing Vue integration uses `Object.assign(pageContextReactive, pageContext)` which will wrongully trigger the warning. There is no cross-browser way to catch whether the property accessor was initiated by an `Object.assign()` call.
+            if (!isBrowser()) {
+                assertWarning(false, '`pageContext.pageExports` is outdated. Use `pageContext.exports` instead, see https://vite-plugin-ssr.com/exports', { onlyOnce: true, showStackTrace: true });
+            }
+            return Reflect.get(...args);
+        }
+    });
+}
+function getExportUnion(exportsAll, propName) {
+    var _a, _b;
+    return ((_b = (_a = exportsAll[propName]) === null || _a === void 0 ? void 0 : _a.map((e) => {
+        assertUsage(hasProp(e, 'exportValue', 'string[]'), `${e.exportSource} should be an array of strings.`);
+        return e.exportValue;
+    }).flat()) !== null && _b !== void 0 ? _b : []);
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/getPageFileObject.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/getPageFileObject.js
new file mode 100644
index 0000000..28ffef1
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/getPageFileObject.js
@@ -0,0 +1,58 @@
+export { getPageFileObject };
+import { determinePageIdOld } from '../determinePageIdOld';
+import { assertPageFilePath } from '../assertPageFilePath';
+import { isErrorPageId } from '../error-page';
+import { assert, slice } from '../utils';
+import { determineFileType } from './fileTypes';
+function getPageFileObject(filePath) {
+    const isRelevant = (pageId) => pageFile.pageId === pageId ||
+        (pageFile.isDefaultPageFile &&
+            (isRendererFilePath(pageFile.filePath) || isAncestorDefaultPage(pageId, pageFile.filePath)));
+    const fileType = determineFileType(filePath);
+    const isEnv = (env) => {
+        assert(fileType !== '.page.route'); // We can't determine `.page.route.js`
+        if (env === 'CLIENT_ONLY') {
+            return fileType === '.page.client' || fileType === '.css';
+        }
+        if (env === 'SERVER_ONLY') {
+            return fileType === '.page.server';
+        }
+        if (env === 'CLIENT_AND_SERVER') {
+            return fileType === '.page';
+        }
+        assert(false);
+    };
+    const pageFile = {
+        filePath,
+        fileType,
+        isEnv,
+        isRelevant,
+        isDefaultPageFile: isDefaultFilePath(filePath),
+        isRendererPageFile: fileType !== '.css' && isDefaultFilePath(filePath) && isRendererFilePath(filePath),
+        isErrorPageFile: isErrorPageId(filePath, false),
+        pageId: determinePageIdOld(filePath)
+    };
+    return pageFile;
+}
+function isDefaultFilePath(filePath) {
+    assertPageFilePath(filePath);
+    if (isErrorPageId(filePath, false)) {
+        return false;
+    }
+    return filePath.includes('/_default');
+}
+function isRendererFilePath(filePath) {
+    assertPageFilePath(filePath);
+    return filePath.includes('/renderer/');
+}
+function isAncestorDefaultPage(pageId, defaultPageFilePath) {
+    assertPageFilePath(pageId);
+    assertPageFilePath(defaultPageFilePath);
+    assert(!pageId.endsWith('/'));
+    assert(!defaultPageFilePath.endsWith('/'));
+    assert(isDefaultFilePath(defaultPageFilePath));
+    const defaultPageDir = slice(defaultPageFilePath.split('/'), 0, -1)
+        .filter((filePathSegment) => filePathSegment !== '_default')
+        .join('/');
+    return pageId.startsWith(defaultPageDir);
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/parseGlobResults.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/parseGlobResults.js
new file mode 100644
index 0000000..01bc760
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/parseGlobResults.js
@@ -0,0 +1,103 @@
+export { parseGlobResults };
+import { assert, hasProp, isCallable, isObject, cast, assertUsage } from '../utils';
+import { assertExportValues } from './assertExports';
+import { getPageFileObject } from './getPageFileObject';
+import { fileTypes } from './fileTypes';
+import { assertPageConfigGlobal, assertPageConfigs } from './assertPageConfigs';
+import { parsePageConfigs } from './parsePageConfigs';
+// TODO: rename to parseVirtualFile
+function parseGlobResults(pageFilesExports) {
+    assert(hasProp(pageFilesExports, 'isGeneratedFile'));
+    assert(pageFilesExports.isGeneratedFile !== false, `vite-plugin-ssr was re-installed(/re-built). Restart your app.`);
+    assert(pageFilesExports.isGeneratedFile === true, `\`isGeneratedFile === ${pageFilesExports.isGeneratedFile}\``);
+    assert(hasProp(pageFilesExports, 'pageFilesLazy', 'object'));
+    assert(hasProp(pageFilesExports, 'pageFilesEager', 'object'));
+    assert(hasProp(pageFilesExports, 'pageFilesExportNamesLazy', 'object'));
+    assert(hasProp(pageFilesExports, 'pageFilesExportNamesEager', 'object'));
+    assert(hasProp(pageFilesExports.pageFilesLazy, '.page'));
+    assert(hasProp(pageFilesExports.pageFilesLazy, '.page.client') || hasProp(pageFilesExports.pageFilesLazy, '.page.server'));
+    assert(hasProp(pageFilesExports, 'pageFilesList', 'string[]'));
+    assert(hasProp(pageFilesExports, 'invalidator', 'object') || hasProp(pageFilesExports, 'invalidator', 'null'));
+    if (pageFilesExports.invalidator) {
+        Object.keys(pageFilesExports.invalidator).forEach((p) => {
+            const filename = p.split('/').slice(-1)[0];
+            assert(filename.startsWith('+'));
+        });
+    }
+    assert(hasProp(pageFilesExports, 'pageConfigs'));
+    assert(hasProp(pageFilesExports, 'pageConfigGlobal'));
+    const { pageConfigs, pageConfigGlobal } = pageFilesExports;
+    assertPageConfigs(pageConfigs);
+    parsePageConfigs(pageConfigs);
+    assertPageConfigGlobal(pageConfigGlobal);
+    const pageFilesMap = {};
+    parseGlobResult(pageFilesExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
+        var _a;
+        pageFile = pageFilesMap[filePath] = (_a = pageFilesMap[filePath]) !== null && _a !== void 0 ? _a : pageFile;
+        const loadModule = globValue;
+        assertLoadModule(loadModule);
+        pageFile.loadFile = async () => {
+            if (!('fileExports' in pageFile)) {
+                pageFile.fileExports = await loadModule();
+                assertExportValues(pageFile);
+            }
+        };
+    });
+    parseGlobResult(pageFilesExports.pageFilesExportNamesLazy).forEach(({ filePath, pageFile, globValue }) => {
+        var _a;
+        pageFile = pageFilesMap[filePath] = (_a = pageFilesMap[filePath]) !== null && _a !== void 0 ? _a : pageFile;
+        const loadModule = globValue;
+        assertLoadModule(loadModule);
+        pageFile.loadExportNames = async () => {
+            if (!('exportNames' in pageFile)) {
+                const moduleExports = await loadModule();
+                // Vite 2 seems to choke following assertion: https://github.com/brillout/vite-plugin-ssr/issues/455
+                assertUsage('exportNames' in moduleExports, 'You seem to be using Vite 2 but the latest vite-plugin-ssr versions only work with Vite 3');
+                assert(hasProp(moduleExports, 'exportNames', 'string[]'), pageFile.filePath);
+                pageFile.exportNames = moduleExports.exportNames;
+            }
+        };
+    });
+    // `pageFilesEager` contains `.page.route.js` files
+    parseGlobResult(pageFilesExports.pageFilesEager).forEach(({ filePath, pageFile, globValue }) => {
+        var _a;
+        pageFile = pageFilesMap[filePath] = (_a = pageFilesMap[filePath]) !== null && _a !== void 0 ? _a : pageFile;
+        const moduleExports = globValue;
+        assert(isObject(moduleExports));
+        pageFile.fileExports = moduleExports;
+    });
+    parseGlobResult(pageFilesExports.pageFilesExportNamesEager).forEach(({ filePath, pageFile, globValue }) => {
+        var _a;
+        pageFile = pageFilesMap[filePath] = (_a = pageFilesMap[filePath]) !== null && _a !== void 0 ? _a : pageFile;
+        const moduleExports = globValue;
+        assert(isObject(moduleExports));
+        assert(hasProp(moduleExports, 'exportNames', 'string[]'), pageFile.filePath);
+        pageFile.exportNames = moduleExports.exportNames;
+    });
+    pageFilesExports.pageFilesList.forEach((filePath) => {
+        var _a;
+        pageFilesMap[filePath] = (_a = pageFilesMap[filePath]) !== null && _a !== void 0 ? _a : getPageFileObject(filePath);
+    });
+    const pageFiles = Object.values(pageFilesMap);
+    pageFiles.forEach(({ filePath }) => {
+        assert(!filePath.includes('\\'));
+    });
+    return { pageFiles, pageConfigs, pageConfigGlobal };
+}
+function parseGlobResult(globObject) {
+    const ret = [];
+    Object.entries(globObject).forEach(([fileType, globFiles]) => {
+        cast(fileType);
+        assert(fileTypes.includes(fileType));
+        assert(isObject(globFiles));
+        Object.entries(globFiles).forEach(([filePath, globValue]) => {
+            const pageFile = getPageFileObject(filePath);
+            assert(pageFile.fileType === fileType);
+            ret.push({ filePath, pageFile, globValue });
+        });
+    });
+    return ret;
+}
+function assertLoadModule(globValue) {
+    assert(isCallable(globValue));
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/parsePageConfigs.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/parsePageConfigs.js
new file mode 100644
index 0000000..a07f17c
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/parsePageConfigs.js
@@ -0,0 +1,33 @@
+// Counterpart: ../../node/plugin/plugins/importUserCode/v1-design/serializePageConfigs.ts
+export { parsePageConfigs };
+import { parse } from '@brillout/json-serializer/parse';
+import { assert, assertUsage, hasProp, isCallable } from '../utils';
+function parsePageConfigs(pageConfigs) {
+    pageConfigs.forEach((pageConfig) => {
+        Object.entries(pageConfig.configElements).forEach(([configName, configElement]) => {
+            parseConfigValue(configElement);
+            if (configName === 'route') {
+                assertRouteConfigValue(configElement);
+            }
+        });
+    });
+}
+function parseConfigValue(configElement) {
+    const { configValueSerialized } = configElement;
+    if (configValueSerialized !== undefined) {
+        configElement.configValue = parse(configValueSerialized);
+    }
+}
+function assertRouteConfigValue(configElement) {
+    assert(hasProp(configElement, 'configValue')); // route files are eagerly loaded
+    const { configValue } = configElement;
+    const configValueType = typeof configValue;
+    assertUsage(configValueType === 'string' || isCallable(configValue), `${configElement.configDefinedAt} has an invalid type '${configValueType}': it should be a string or a function instead, see https://vite-plugin-ssr.com/route`);
+    /* We don't do that to avoid unnecessarily bloating the client-side bundle when using Server Routing
+     *  - When using Server Routing, this file is loaded as well
+     *  - When using Server Routing, client-side validation is superfluous as Route Strings only need to be validated on the server-side
+    if (typeof configValue === 'string') {
+      assertRouteString(configValue, `${configElement.configDefinedAt} defines an`)
+    }
+    */
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/setPageFiles.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/setPageFiles.js
new file mode 100644
index 0000000..fe0ae72
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/getPageFiles/setPageFiles.js
@@ -0,0 +1,43 @@
+export { setPageFiles };
+export { setPageFilesAsync };
+export { getPageFilesAll };
+import { assert, unique } from '../utils';
+import { parseGlobResults } from './parseGlobResults';
+import { getGlobalObject } from '../../utils/getGlobalObject';
+const globalObject = getGlobalObject('setPageFiles.ts', {});
+function setPageFiles(pageFilesExports) {
+    const { pageFiles, pageConfigs, pageConfigGlobal } = parseGlobResults(pageFilesExports);
+    globalObject.pageFilesAll = pageFiles;
+    globalObject.pageConfigs = pageConfigs;
+    globalObject.pageConfigGlobal = pageConfigGlobal;
+}
+function setPageFilesAsync(getPageFilesExports) {
+    globalObject.pageFilesGetter = async () => {
+        setPageFiles(await getPageFilesExports());
+    };
+}
+async function getPageFilesAll(isClientSide, isProduction) {
+    if (isClientSide) {
+        assert(!globalObject.pageFilesGetter);
+        assert(isProduction === undefined);
+    }
+    else {
+        assert(globalObject.pageFilesGetter);
+        assert(typeof isProduction === 'boolean');
+        if (!globalObject.pageFilesAll ||
+            // We reload all glob imports in dev to make auto-reload work
+            !isProduction) {
+            await globalObject.pageFilesGetter();
+        }
+    }
+    const { pageFilesAll, pageConfigs, pageConfigGlobal } = globalObject;
+    assert(pageFilesAll && pageConfigs && pageConfigGlobal);
+    const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
+    return { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal };
+}
+function getAllPageIds(allPageFiles, pageConfigs) {
+    const fileIds = allPageFiles.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);
+    const allPageIds = unique(fileIds);
+    const allPageIds2 = pageConfigs.map((p) => p.pageId);
+    return [...allPageIds, ...allPageIds2];
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/page-configs/findPageConfig.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/page-configs/findPageConfig.js
new file mode 100644
index 0000000..5f96131
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/page-configs/findPageConfig.js
@@ -0,0 +1,9 @@
+export { findPageConfig };
+import { assert } from '../utils';
+function findPageConfig(pageConfigs, pageId) {
+    var _a;
+    const result = pageConfigs.filter((p) => p.pageId === pageId);
+    assert(result.length <= 1);
+    const pageConfig = (_a = result[0]) !== null && _a !== void 0 ? _a : null;
+    return pageConfig;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/page-configs/loadPageCode.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/page-configs/loadPageCode.js
new file mode 100644
index 0000000..f88b79b
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/page-configs/loadPageCode.js
@@ -0,0 +1,34 @@
+export { loadPageCode };
+import { assert, assertDefaultExportUnknown, objectAssign } from '../utils';
+async function loadPageCode(pageConfig, isDev) {
+    const configValues = {};
+    // In dev, Vite already caches the page's virtual module
+    if (!isDev && 'configValues' in pageConfig) {
+        return pageConfig;
+    }
+    const codeFiles = await pageConfig.loadCodeFiles();
+    codeFiles.forEach((codeFile) => {
+        const { configName, codeFilePath } = codeFile;
+        let configValue;
+        if (codeFile.isPlusFile) {
+            const { codeFileExports } = codeFile;
+            if (configName !== 'client') {
+                assertDefaultExportUnknown(codeFileExports, codeFilePath);
+            }
+            configValue = codeFileExports.default;
+        }
+        else {
+            configValue = codeFile.codeFileExportValue;
+        }
+        assert(!(configName in configValues));
+        configValues[configName] = configValue;
+    });
+    Object.entries(pageConfig.configElements).map(([configName, configElement]) => {
+        if (configElement.codeFilePath)
+            return;
+        assert(!(configName in configValues));
+        configValues[configName] = configElement.configValue;
+    });
+    objectAssign(pageConfig, { configValues });
+    return pageConfig;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/page-configs/utils.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/page-configs/utils.js
new file mode 100644
index 0000000..0113aaa
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/page-configs/utils.js
@@ -0,0 +1,41 @@
+export { getConfigValue };
+export { getCodeFilePath };
+export { getPageConfig };
+import { assert, assertUsage } from '../utils';
+// function getConfigValue(pageConfig: PageConfigData, configName: ConfigName): unknown
+function getConfigValue(pageConfig, configName, type) {
+    const configElement = pageConfig.configElements[configName];
+    if (!configElement || isNullish(pageConfig, configName)) {
+        return null;
+    }
+    const { configValue, configDefinedAt } = configElement;
+    assertUsage(typeof configValue === type, `${configDefinedAt} has an invalid type \`${typeof configValue}\`: is should be a ${type} instead`);
+    return configValue;
+}
+function getCodeFilePath(pageConfig, configName) {
+    const configElement = pageConfig.configElements[configName];
+    if (!configElement || isNullish(pageConfig, configName)) {
+        return null;
+    }
+    if (configElement.codeFilePath !== null) {
+        return configElement.codeFilePath;
+    }
+    const { configValue, configDefinedAt } = configElement;
+    assertUsage(typeof configValue === 'string', `${configDefinedAt} has an invalid type \`${typeof configValue}\`: it should be a \`string\` instead`);
+    assertUsage(false, `${configDefinedAt} has an invalid value \`${configValue}\`: it should be a file path instead`);
+}
+function isNullish(pageConfig, configName) {
+    const configElement = pageConfig.configElements[configName];
+    if (!configElement)
+        return true;
+    const { codeFilePath, configValue } = configElement;
+    if (codeFilePath)
+        return false;
+    return configValue === null || configValue === undefined;
+}
+function getPageConfig(pageId, pageConfigs) {
+    const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
+    assert(pageConfigs.length > 0);
+    assert(pageConfig);
+    return pageConfig;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/RenderErrorPage.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/RenderErrorPage.js
new file mode 100644
index 0000000..7e12cee
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/RenderErrorPage.js
@@ -0,0 +1,26 @@
+export { isRenderErrorPageException };
+export { RenderErrorPage };
+export { assertRenderErrorPageExceptionUsage };
+import { assertPageContextProvidedByUser } from '../assertPageContextProvidedByUser';
+import { assertUsage, objectAssign } from './utils';
+const stamp = '__isRenderErrorPageException';
+function isRenderErrorPageException(thing) {
+    assertRenderErrorPageExceptionUsage(thing);
+    return typeof thing === 'object' && thing !== null && stamp in thing;
+}
+function RenderErrorPage({ pageContext } = {}) {
+    {
+        // @ts-ignore
+        const that = this;
+        assertUsage(!(typeof that === 'object' && (that === null || that === void 0 ? void 0 : that.constructor) === RenderErrorPage), "Don't use the `new` operator: use `throw RenderErrorPage()` instead of `throw new RenderErrorPage()`.");
+    }
+    assertPageContextProvidedByUser(pageContext, {
+        errorMessagePrefix: 'The `pageContext` provided in `RenderErrorPage({ pageContext })`'
+    });
+    const err = new Error('RenderErrorPage');
+    objectAssign(err, { pageContext, [stamp]: true });
+    return err;
+}
+function assertRenderErrorPageExceptionUsage(err) {
+    assertUsage(err !== RenderErrorPage, 'Missing parentheses `()` in `throw RenderErrorPage`: it should be `throw RenderErrorPage()`.');
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/callOnBeforeRouteHook.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/callOnBeforeRouteHook.js
new file mode 100644
index 0000000..d60fd88
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/callOnBeforeRouteHook.js
@@ -0,0 +1,38 @@
+import { assertPageContextProvidedByUser } from '../assertPageContextProvidedByUser';
+import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning } from './utils';
+import { assertRouteParams } from './resolveRouteFunction';
+export { callOnBeforeRouteHook };
+async function callOnBeforeRouteHook(onBeforeRouteHook, pageContext) {
+    const hookReturn = await onBeforeRouteHook.onBeforeRoute(pageContext);
+    const errPrefix = `The \`onBeforeRoute()\` hook defined by ${onBeforeRouteHook.hookSrc}`;
+    assertUsage(hookReturn === null ||
+        hookReturn === undefined ||
+        (isObjectWithKeys(hookReturn, ['pageContext']) && hasProp(hookReturn, 'pageContext')), `${errPrefix} should return \`null\`, \`undefined\`, or a plain JavaScript object \`{ pageContext: { /* ... */ } }\`.`);
+    if (hookReturn === null || hookReturn === undefined) {
+        return null;
+    }
+    assertUsage(hasProp(hookReturn, 'pageContext', 'object'), `${errPrefix} returned \`{ pageContext }\` but \`pageContext\` should be a plain JavaScript object.`);
+    if (hasProp(hookReturn.pageContext, '_pageId') && !hasProp(hookReturn.pageContext, '_pageId', 'null')) {
+        const errPrefix2 = `${errPrefix} returned \`{ pageContext: { _pageId } }\` but \`_pageId\` should be`;
+        assertUsage(hasProp(hookReturn.pageContext, '_pageId', 'string'), `${errPrefix2} a string or \`null\``);
+        assertUsage(pageContext._allPageIds.includes(hookReturn.pageContext._pageId), `${errPrefix2} one of following values: \`[${pageContext._allPageIds.map((s) => `'${s}'`).join(', ')}]\`.`);
+    }
+    if (hasProp(hookReturn.pageContext, 'routeParams')) {
+        assertRouteParams(hookReturn.pageContext, `${errPrefix} returned \`{ pageContext: { routeParams } }\` but \`routeParams\` should`);
+    }
+    const pageContextAddendumHook = {};
+    if (hasProp(hookReturn.pageContext, 'url')) {
+        assertWarning(false, `${errPrefix} returned \`{ pageContext: { url } }\` but \`pageContext.url\` has been renamed to \`pageContext.urlOriginal\`. Return \`{ pageContext: { urlOriginal } }\` instead. (See https://vite-plugin-ssr.com/migration/0.4.23 for more information.)`, { showStackTrace: false, onlyOnce: true });
+        hookReturn.pageContext.urlOriginal = hookReturn.pageContext.url;
+        delete hookReturn.pageContext.url;
+    }
+    if (hasProp(hookReturn.pageContext, 'urlOriginal')) {
+        assertUsage(hasProp(hookReturn.pageContext, 'urlOriginal', 'string'), `${errPrefix} returned \`{ pageContext: { urlOriginal } }\` but \`urlOriginal\` should be a string`);
+        objectAssign(pageContextAddendumHook, { _urlPristine: pageContext.urlOriginal });
+    }
+    assertPageContextProvidedByUser(hookReturn.pageContext, {
+        hook: { hookSrc: onBeforeRouteHook.hookSrc, hookName: 'onBeforeRoute' }
+    });
+    objectAssign(pageContextAddendumHook, hookReturn.pageContext);
+    return pageContextAddendumHook;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/debug.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/debug.js
new file mode 100644
index 0000000..4dc8000
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/debug.js
@@ -0,0 +1,12 @@
+export { debug };
+var _debug;
+function debug(...args) {
+    var _a, _b;
+    if (!_debug) {
+        // We use this trick instead of `import { createDebugger } from '../../utils/debug` in order to ensure that the `debug` mechanism is only loaded on the server-side
+        _debug = (_b = (_a = globalThis).__brillout_debug_createDebugger) === null || _b === void 0 ? void 0 : _b.call(_a, 'vps:routing');
+    }
+    if (_debug) {
+        _debug(...args);
+    }
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/deduceRouteStringFromFilesystemPath.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/deduceRouteStringFromFilesystemPath.js
new file mode 100644
index 0000000..6c980f2
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/deduceRouteStringFromFilesystemPath.js
@@ -0,0 +1,49 @@
+import { assert, higherFirst, slice } from './utils';
+export { deduceRouteStringFromFilesystemPath };
+// TODO/next-major-update: remove this and whole filesystemRoot mechanism
+function deduceRouteStringFromFilesystemPath(pageId, filesystemRoots) {
+    // Handle Filesystem Routing Root
+    const filesystemRootsMatch = filesystemRoots
+        .filter(({ filesystemRoot }) => pageId.startsWith(filesystemRoot))
+        .sort(higherFirst(({ filesystemRoot }) => filesystemRoot.length));
+    const fsRoot = filesystemRootsMatch[0];
+    let filesystemRoute;
+    if (fsRoot) {
+        // Example values:
+        //  - `{"pageId":"/pages/index","filesystemRoot":"/","urlRoot":"/client_portal"}`
+        const { filesystemRoot, urlRoot } = fsRoot;
+        const debugInfo = { pageId, filesystemRoot, urlRoot };
+        assert(urlRoot.startsWith('/') && pageId.startsWith('/') && filesystemRoot.startsWith('/'), debugInfo);
+        assert(pageId.startsWith(filesystemRoot), debugInfo);
+        if (filesystemRoot !== '/') {
+            assert(!filesystemRoot.endsWith('/'), debugInfo);
+            filesystemRoute = slice(pageId, filesystemRoot.length, 0);
+        }
+        else {
+            filesystemRoute = pageId;
+        }
+        assert(filesystemRoute.startsWith('/'), debugInfo);
+        filesystemRoute = urlRoot + (urlRoot.endsWith('/') ? '' : '/') + slice(filesystemRoute, 1, 0);
+    }
+    else {
+        filesystemRoute = pageId;
+    }
+    assert(filesystemRoute.startsWith('/'));
+    // Remove `pages/`, `index/, and `src/`, directories
+    filesystemRoute = filesystemRoute
+        .split('/')
+        .filter((dir) => dir !== 'pages' && dir !== 'src' && dir !== 'index')
+        .join('/');
+    // Hanlde `/index.page.*` suffix
+    assert(!filesystemRoute.includes('.page.'));
+    assert(!filesystemRoute.endsWith('.'));
+    if (filesystemRoute.endsWith('/index')) {
+        filesystemRoute = slice(filesystemRoute, 0, -'/index'.length);
+    }
+    if (filesystemRoute === '') {
+        filesystemRoute = '/';
+    }
+    assert(filesystemRoute.startsWith('/'));
+    assert(!filesystemRoute.endsWith('/') || filesystemRoute === '/');
+    return filesystemRoute;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/index.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/index.js
new file mode 100644
index 0000000..e59f870
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/index.js
@@ -0,0 +1,115 @@
+export { route };
+export { loadPageRoutes } from './loadPageRoutes';
+// Ensure we don't bloat runtime of Server Routing
+import { assertClientRouting } from '../../utils/assertRoutingType';
+import { isBrowser } from '../../utils/isBrowser';
+if (isBrowser()) {
+    assertClientRouting();
+}
+import { assert, assertUsage, hasProp, isPlainObject, objectAssign } from './utils';
+import { addComputedUrlProps } from '../addComputedUrlProps';
+import { resolvePrecendence } from './resolvePrecedence';
+import { resolveRouteString } from './resolveRouteString';
+import { resolveRouteFunction } from './resolveRouteFunction';
+import { callOnBeforeRouteHook } from './callOnBeforeRouteHook';
+import { loadPageRoutes } from './loadPageRoutes';
+import { debug } from './debug';
+async function route(pageContext) {
+    addComputedUrlProps(pageContext);
+    const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageContext._pageFilesAll, pageContext._pageConfigs, pageContext._pageConfigGlobal, pageContext._allPageIds);
+    debug('Pages routes:', pageRoutes);
+    const pageContextAddendum = {};
+    if (onBeforeRouteHook) {
+        const pageContextAddendumHook = await callOnBeforeRouteHook(onBeforeRouteHook, pageContext);
+        if (pageContextAddendumHook) {
+            objectAssign(pageContextAddendum, pageContextAddendumHook);
+            if (hasProp(pageContextAddendum, '_pageId', 'string') || hasProp(pageContextAddendum, '_pageId', 'null')) {
+                // We bypass `vite-plugin-ssr`'s routing
+                if (!hasProp(pageContextAddendum, 'routeParams')) {
+                    objectAssign(pageContextAddendum, { routeParams: {} });
+                }
+                else {
+                    assert(hasProp(pageContextAddendum, 'routeParams', 'object'));
+                }
+                objectAssign(pageContextAddendum, {
+                    _routingProvidedByOnBeforeRouteHook: true,
+                    _routeMatches: 'CUSTOM_ROUTE'
+                });
+                return { pageContextAddendum };
+            }
+            // We already assign so that `pageContext.urlOriginal === pageContextAddendum.urlOriginal`; enabling the `onBeforeRoute()` hook to mutate `pageContext.urlOriginal` before routing.
+            objectAssign(pageContext, pageContextAddendum);
+        }
+    }
+    objectAssign(pageContextAddendum, {
+        _routingProvidedByOnBeforeRouteHook: false
+    });
+    // `vite-plugin-ssr`'s routing
+    const allPageIds = pageContext._allPageIds;
+    assert(allPageIds.length >= 0);
+    assertUsage(pageContext._pageFilesAll.length > 0 || pageContext._pageConfigs.length > 0, 'No *.page.js file found. You must create at least one *.page.js file.');
+    assertUsage(allPageIds.length > 0, "You must create at least one *.page.js file that isn't _default.page.*");
+    const { urlPathname } = pageContext;
+    assert(urlPathname.startsWith('/'));
+    const routeMatches = [];
+    await Promise.all(pageRoutes.map(async (pageRoute) => {
+        const { pageId, routeType } = pageRoute;
+        // Filesytem Routing
+        if (pageRoute.routeType === 'FILESYSTEM') {
+            const { routeString } = pageRoute;
+            const match = resolveRouteString(routeString, urlPathname);
+            if (match) {
+                const { routeParams } = match;
+                routeMatches.push({ pageId, routeParams, routeString, routeType });
+            }
+            return;
+        }
+        // Route String defined in `.page.route.js`
+        if (pageRoute.routeType === 'STRING') {
+            const { routeString } = pageRoute;
+            const match = resolveRouteString(routeString, urlPathname);
+            if (match) {
+                const { routeParams } = match;
+                assert(routeType === 'STRING');
+                routeMatches.push({
+                    pageId,
+                    routeString,
+                    routeParams,
+                    routeType
+                });
+            }
+            return;
+        }
+        // Route Function defined in `.page.route.js`
+        if (pageRoute.routeType === 'FUNCTION') {
+            const { routeFunction, allowAsync, routeDefinedAt } = pageRoute;
+            const match = await resolveRouteFunction(routeFunction, allowAsync, pageContext, routeDefinedAt);
+            if (match) {
+                const { routeParams, precedence } = match;
+                routeMatches.push({ pageId, precedence, routeParams, routeType });
+            }
+            return;
+        }
+        assert(false);
+    }));
+    resolvePrecendence(routeMatches);
+    const winner = routeMatches[0];
+    debug(`Route matches for URL \`${urlPathname}\` (in precedence order):`, routeMatches);
+    objectAssign(pageContextAddendum, { _routeMatches: routeMatches });
+    if (!winner) {
+        objectAssign(pageContextAddendum, {
+            _pageId: null,
+            routeParams: {}
+        });
+        return { pageContextAddendum };
+    }
+    {
+        const { routeParams } = winner;
+        assert(isPlainObject(routeParams));
+        objectAssign(pageContextAddendum, {
+            _pageId: winner.pageId,
+            routeParams: winner.routeParams
+        });
+    }
+    return { pageContextAddendum };
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/loadPageRoutes.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/loadPageRoutes.js
new file mode 100644
index 0000000..c844f6d
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/loadPageRoutes.js
@@ -0,0 +1,195 @@
+import { isErrorPageId } from '../error-page';
+import { assert, assertUsage, hasProp, slice } from './utils';
+import { deduceRouteStringFromFilesystemPath } from './deduceRouteStringFromFilesystemPath';
+import { isCallable } from '../utils';
+export { loadPageRoutes };
+export { findPageRouteFile };
+async function loadPageRoutes(
+// TODO: remove all arguments and use GlobalContext instead
+pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
+    await Promise.all(pageFilesAll.filter((p) => p.fileType === '.page.route').map((p) => { var _a; return (_a = p.loadFile) === null || _a === void 0 ? void 0 : _a.call(p); }));
+    const { onBeforeRouteHook, filesystemRoots } = getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal);
+    const pageRoutes = getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds);
+    return { pageRoutes, onBeforeRouteHook };
+}
+function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
+    const pageRoutes = [];
+    let pageIds = [...allPageIds];
+    // V1 Design
+    if (pageConfigs.length > 0) {
+        const comesFromV1PageConfig = true;
+        pageConfigs
+            .filter((p) => !p.isErrorPage)
+            .forEach((pageConfig) => {
+            const pageId = pageConfig.pageId;
+            pageIds = removePageId(pageIds, pageId);
+            let pageRoute = null;
+            {
+                const routeConfig = pageConfig.configElements.route;
+                if (routeConfig) {
+                    assert('configValue' in routeConfig); // Route files are eagerly loaded
+                    const route = routeConfig.configValue;
+                    const routeDefinedAt = routeConfig.configDefinedAt;
+                    assert(routeDefinedAt);
+                    if (typeof route === 'string') {
+                        pageRoute = { pageId, comesFromV1PageConfig, routeString: route, routeDefinedAt, routeType: 'STRING' };
+                    }
+                    else {
+                        assert(isCallable(route));
+                        let allowAsync = false;
+                        const allowSyncConfig = pageConfig.configElements.iKnowThePerformanceRisksOfAsyncRouteFunctions;
+                        if (allowSyncConfig) {
+                            const val = allowSyncConfig.configValue;
+                            assert(typeof val === 'boolean'); // TODO: assertUsage()
+                            allowAsync = val;
+                        }
+                        pageRoute = {
+                            pageId,
+                            comesFromV1PageConfig,
+                            routeFunction: route,
+                            routeDefinedAt,
+                            routeType: 'FUNCTION',
+                            allowAsync
+                        };
+                    }
+                }
+            }
+            if (!pageRoute) {
+                const { routeFilesystem, routeFilesystemDefinedBy } = pageConfig;
+                assert(routeFilesystem);
+                assert(routeFilesystem.startsWith('/'));
+                assert(routeFilesystemDefinedBy);
+                pageRoute = {
+                    pageId,
+                    routeFilesystemDefinedBy,
+                    comesFromV1PageConfig,
+                    routeString: routeFilesystem,
+                    routeDefinedAt: null,
+                    routeType: 'FILESYSTEM'
+                };
+            }
+            assert(pageRoute);
+            pageRoutes.push(pageRoute);
+        });
+    }
+    // Old design
+    // TODO/v1-release: remove
+    if (pageConfigs.length === 0) {
+        const comesFromV1PageConfig = false;
+        pageIds
+            .filter((pageId) => !isErrorPageId(pageId, false))
+            .forEach((pageId) => {
+            const pageRouteFile = findPageRouteFile(pageId, pageFilesAll);
+            if (!pageRouteFile) {
+                const routeString = deduceRouteStringFromFilesystemPath(pageId, filesystemRoots);
+                assert(routeString.startsWith('/'));
+                assert(!routeString.endsWith('/') || routeString === '/');
+                pageRoutes.push({
+                    pageId,
+                    comesFromV1PageConfig,
+                    routeString,
+                    routeDefinedAt: null,
+                    routeFilesystemDefinedBy: `${pageId}.page.*`,
+                    routeType: 'FILESYSTEM'
+                });
+            }
+            else {
+                const { filePath, fileExports } = pageRouteFile;
+                assert(fileExports);
+                assertUsage('default' in fileExports, `${filePath} should have a default export.`);
+                if (hasProp(fileExports, 'default', 'string')) {
+                    const routeString = fileExports.default;
+                    assertUsage(routeString.startsWith('/'), `A Route String should start with a leading \`/\` but \`${filePath}\` has \`export default '${routeString}'\`. Make sure to \`export default '/${routeString}'\` instead.`);
+                    pageRoutes.push({
+                        pageId,
+                        comesFromV1PageConfig,
+                        routeString,
+                        routeDefinedAt: filePath,
+                        routeType: 'STRING'
+                    });
+                    return;
+                }
+                if (hasProp(fileExports, 'default', 'function')) {
+                    const routeFunction = fileExports.default;
+                    let allowAsync = false;
+                    const allowKey = 'iKnowThePerformanceRisksOfAsyncRouteFunctions';
+                    if (allowKey in fileExports) {
+                        assertUsage(hasProp(fileExports, allowKey, 'boolean'), `The export \`${allowKey}\` of ${filePath} should be a boolean.`);
+                        allowAsync = fileExports[allowKey];
+                    }
+                    pageRoutes.push({
+                        pageId,
+                        comesFromV1PageConfig,
+                        routeFunction,
+                        routeDefinedAt: filePath,
+                        allowAsync,
+                        routeType: 'FUNCTION'
+                    });
+                    return;
+                }
+                assertUsage(false, `The default export of ${filePath} should be a string or a function.`);
+            }
+        });
+    }
+    return pageRoutes;
+}
+function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
+    // V1 Design
+    if (pageConfigs.length > 0) {
+        if (pageConfigGlobal.onBeforeRoute) {
+            const hookFn = pageConfigGlobal.onBeforeRoute.configValue;
+            if (hookFn) {
+                const hookFilePath = pageConfigGlobal.onBeforeRoute.codeFilePath;
+                assert(hookFilePath);
+                assertUsage(isCallable(hookFn), `The hook onBeforeRoute() defined by ${hookFilePath} should be a function.`);
+                const onBeforeRouteHook = {
+                    hookSrc: hookFilePath,
+                    onBeforeRoute: hookFn
+                };
+                return { onBeforeRouteHook, filesystemRoots: [] };
+            }
+        }
+        return { onBeforeRouteHook: null, filesystemRoots: [] };
+    }
+    // Old design
+    // TODO/v1-release: remove
+    let onBeforeRouteHook = null;
+    const filesystemRoots = [];
+    pageFilesAll
+        .filter((p) => p.fileType === '.page.route' && p.isDefaultPageFile)
+        .forEach(({ filePath, fileExports }) => {
+        assert(fileExports);
+        if ('onBeforeRoute' in fileExports) {
+            assertUsage(hasProp(fileExports, 'onBeforeRoute', 'function'), `\`export { onBeforeRoute }\` of ${filePath} should be a function.`);
+            const { onBeforeRoute } = fileExports;
+            onBeforeRouteHook = { hookSrc: `${filePath} > \`export { onBeforeRoute }\``, onBeforeRoute };
+        }
+        if ('filesystemRoutingRoot' in fileExports) {
+            assertUsage(hasProp(fileExports, 'filesystemRoutingRoot', 'string'), `\`export { filesystemRoutingRoot }\` of ${filePath} should be a string.`);
+            assertUsage(hasProp(fileExports, 'filesystemRoutingRoot', 'string'), `\`export { filesystemRoutingRoot }\` of ${filePath} is \`'${fileExports.filesystemRoutingRoot}'\` but it should start with a leading slash \`/\`.`);
+            filesystemRoots.push({
+                filesystemRoot: dirname(filePath),
+                urlRoot: fileExports.filesystemRoutingRoot
+            });
+        }
+    });
+    return { onBeforeRouteHook, filesystemRoots };
+}
+function findPageRouteFile(pageId, pageFilesAll) {
+    return pageFilesAll.find((p) => p.pageId === pageId && p.fileType === '.page.route');
+}
+function dirname(filePath) {
+    assert(filePath.startsWith('/'));
+    assert(!filePath.endsWith('/'));
+    const paths = filePath.split('/');
+    const dirPath = slice(paths, 0, -1).join('/') || '/';
+    assert(dirPath.startsWith('/'));
+    assert(!dirPath.endsWith('/') || dirPath === '/');
+    return dirPath;
+}
+function removePageId(pageIds, pageId) {
+    const { length } = pageIds;
+    pageIds = pageIds.filter((id) => id !== pageId);
+    assert(pageIds.length === length - 1);
+    return pageIds;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/resolvePrecedence.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/resolvePrecedence.js
new file mode 100644
index 0000000..4245844
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/resolvePrecedence.js
@@ -0,0 +1,70 @@
+export { resolvePrecendence };
+// export type { RouteMatch }
+import { analyzeRouteString } from './resolveRouteString';
+import { higherFirst } from './utils';
+import { makeFirst } from './utils';
+import { isStaticRouteString } from './resolveRouteString';
+// See https://vite-plugin-ssr.com/route-function#precedence
+function resolvePrecendence(routeMatches) {
+    // prettier-ignore
+    routeMatches
+        .sort(sortMatches)
+        .sort(makeFirst((routeMatch) => routeMatch.routeType === 'FUNCTION' && !!routeMatch.precedence && routeMatch.precedence < 0))
+        .sort(makeFirst((routeMatch) => routeMatch.routeType === 'STRING' && isStaticRouteString(routeMatch.routeString) === false))
+        .sort(makeFirst((routeMatch) => routeMatch.routeType === 'FUNCTION' && !routeMatch.precedence))
+        .sort(makeFirst((routeMatch) => routeMatch.routeType === 'STRING' && isStaticRouteString(routeMatch.routeString) === true))
+        .sort(makeFirst((routeMatch) => routeMatch.routeType === 'FILESYSTEM'))
+        .sort(makeFirst((routeMatch) => routeMatch.routeType === 'FUNCTION' && !!routeMatch.precedence && routeMatch.precedence > 0));
+}
+// -1 => routeMatch1 higher precedence
+// +1 => routeMatch2 higher precedence
+function sortMatches(routeMatch1, routeMatch2) {
+    var _a, _b;
+    {
+        const precedence1 = (_a = routeMatch1.precedence) !== null && _a !== void 0 ? _a : 0;
+        const precedence2 = (_b = routeMatch2.precedence) !== null && _b !== void 0 ? _b : 0;
+        if (precedence1 !== precedence2) {
+            return precedence1 > precedence2 ? -1 : 1;
+        }
+    }
+    if (!routeMatch2.routeString) {
+        return 0;
+    }
+    if (!routeMatch1.routeString) {
+        return 0;
+    }
+    // Return route with highest number of static path segments at beginning first
+    {
+        const getValue = (routeString) => analyzeRouteString(routeString).numberOfStaticSegmentsBeginning;
+        const result = higherFirst(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        if (result !== 0) {
+            return result;
+        }
+    }
+    // Return route with highest number of static path segments in total first
+    {
+        const getValue = (routeString) => analyzeRouteString(routeString).numberOfStaticSegements;
+        const result = higherFirst(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        if (result !== 0) {
+            return result;
+        }
+    }
+    // Return route with most parameter segements first
+    {
+        const getValue = (routeString) => analyzeRouteString(routeString).numberOfParameterSegments;
+        const result = higherFirst(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        if (result !== 0) {
+            return result;
+        }
+    }
+    // Return catch-all routes last
+    {
+        if (analyzeRouteString(routeMatch2.routeString).isCatchAll) {
+            return -1;
+        }
+        if (analyzeRouteString(routeMatch1.routeString).isCatchAll) {
+            return 1;
+        }
+    }
+    return 0;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/resolveRouteFunction.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/resolveRouteFunction.js
new file mode 100644
index 0000000..d2629c2
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/resolveRouteFunction.js
@@ -0,0 +1,49 @@
+export { resolveRouteFunction };
+export { assertRouteParams };
+import { assertURLs } from '../addComputedUrlProps';
+import { assert, assertUsage, hasProp, isPlainObject, isPromise, isStringRecord } from './utils';
+async function resolveRouteFunction(routeFunction, allowAsync, pageContext, routeDefinedAt) {
+    assertURLs(pageContext);
+    let result = routeFunction(pageContext);
+    assertUsage(!isPromise(result) || allowAsync, `The Route Function ${routeDefinedAt} returned a promise; async route functions are opt-in, see https://vite-plugin-ssr.com/route-function#async`);
+    result = await result;
+    if (result === false) {
+        return null;
+    }
+    if (result === true) {
+        result = {};
+    }
+    assertUsage(isPlainObject(result), `The Route Function ${routeDefinedAt} should return a boolean or a plain JavaScript object, instead it returns \`${hasProp(result, 'constructor') ? result.constructor : result}\`.`);
+    if ('match' in result) {
+        const { match } = result;
+        assertUsage(typeof match === 'boolean', `The \`match\` value returned by the Route Function ${routeDefinedAt} should be a boolean.`);
+        if (!match) {
+            return null;
+        }
+    }
+    let precedence = null;
+    if ('precedence' in result) {
+        precedence = result.precedence;
+        assertUsage(typeof precedence === 'number', `The \`precedence\` value returned by the Route Function ${routeDefinedAt} should be a number.`);
+    }
+    assertRouteParams(result, `The \`routeParams\` object returned by the Route Function ${routeDefinedAt} should`);
+    const routeParams = result.routeParams || {};
+    assertUsage(!('pageContext' in result), 'Providing `pageContext` in Route Functions is prohibited, see https://vite-plugin-ssr.com/route-function#cannot-provide-pagecontext');
+    assert(isPlainObject(routeParams));
+    Object.keys(result).forEach((key) => {
+        assertUsage(key === 'match' || key === 'routeParams' || key === 'precedence', `The Route Function ${routeDefinedAt} returned an object with an unknown key \`{ ${key} }\`. Allowed keys: ['match', 'routeParams', 'precedence'].`);
+    });
+    return {
+        precedence,
+        routeParams
+    };
+}
+function assertRouteParams(result, errPrefix) {
+    assert(errPrefix.endsWith(' should'));
+    if (!hasProp(result, 'routeParams')) {
+        return;
+    }
+    assert(errPrefix.endsWith(' should'));
+    assertUsage(isPlainObject(result.routeParams), `${errPrefix} be a plain JavaScript object.`);
+    assertUsage(isStringRecord(result.routeParams), `${errPrefix} only hold string values.`);
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/resolveRouteString.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/resolveRouteString.js
new file mode 100644
index 0000000..25d217f
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/resolveRouteString.js
@@ -0,0 +1,92 @@
+export { resolveRouteString };
+export { getUrlFromRouteString };
+export { isStaticRouteString };
+export { analyzeRouteString };
+// export { assertRouteString }
+import { assertWarning } from '../utils';
+import { assert, assertUsage } from './utils';
+const PARAM_TOKEN_NEW = '@';
+const PARAM_TOKEN_OLD = ':';
+function assertRouteString(routeString, errMsgPrefix) {
+    assertUsage(routeString.startsWith('/') || routeString === '*', (() => {
+        if (!errMsgPrefix) {
+            errMsgPrefix = 'Invalid';
+        }
+        else {
+            errMsgPrefix = errMsgPrefix + ' invalid';
+        }
+        const routeStr = [`'${routeString}'`, routeString !== '' ? null : '(empty string)'].filter(Boolean).join(' ');
+        const errMsg = `${errMsgPrefix} Route String ${routeStr}: Route Strings should start with a leading slash '/' (or be '*')`;
+        return errMsg;
+    })());
+}
+function resolveRouteString(routeString, urlPathname) {
+    assertRouteString(routeString);
+    assert(urlPathname.startsWith('/'));
+    const routeSegments = routeString.split('/');
+    const urlSegments = urlPathname.split('/');
+    const routeParams = {};
+    assertGlob(routeString);
+    if (routeString === '*') {
+        routeString = '/*';
+    }
+    for (let i = 0; i < Math.max(routeSegments.length, urlSegments.length); i++) {
+        const routeSegment = routeSegments[i];
+        const urlSegment = urlSegments[i];
+        if (routeSegment === '*') {
+            routeParams['*'] = urlSegments.slice(Math.max(1, i)).join('/');
+            return { routeParams };
+        }
+        else if (routeSegment && isParam(routeSegment)) {
+            assertWarning(!routeSegment.startsWith(PARAM_TOKEN_OLD), `Outdated Route String \`${routeString}\`, use \`${routeString
+                .split(PARAM_TOKEN_OLD)
+                .join(PARAM_TOKEN_NEW)}\` instead.`, { showStackTrace: false, onlyOnce: true });
+            if (!urlSegment) {
+                return null;
+            }
+            routeParams[routeSegment.slice(1)] = urlSegment;
+        }
+        else {
+            if ((routeSegment || '') !== (urlSegment || '')) {
+                return null;
+            }
+        }
+    }
+    return { routeParams };
+}
+function getUrlFromRouteString(routeString) {
+    assert(routeString.startsWith('/'));
+    if (isStaticRouteString(routeString)) {
+        const url = routeString;
+        return url;
+    }
+    return null;
+}
+function assertGlob(routeString) {
+    const numberOfGlobChars = routeString.split('*').length - 1;
+    assertUsage(numberOfGlobChars <= 1, `Invalid Route String \`${routeString}\`: Route Strings are not allowed to contain more than one glob character \`*\`.`);
+    assertUsage(numberOfGlobChars === 0 || (numberOfGlobChars === 1 && routeString.endsWith('*')), `Invalid Route String \`${routeString}\`: make sure your Route String ends with the glob character \`*\`.`);
+}
+function analyzeRouteString(routeString) {
+    const routeSegments = routeString.split('/').filter((routeSegment) => routeSegment !== '' && routeSegment !== '*');
+    let numberOfStaticSegmentsBeginning = 0;
+    for (const routeSegment of routeSegments) {
+        if (isParam(routeSegment)) {
+            break;
+        }
+        numberOfStaticSegmentsBeginning++;
+    }
+    const numberOfStaticSegements = routeSegments.filter((s) => !isParam(s)).length;
+    const numberOfParameterSegments = routeSegments.filter((s) => isParam(s)).length;
+    const isCatchAll = routeString.endsWith('*');
+    return { numberOfParameterSegments, numberOfStaticSegmentsBeginning, numberOfStaticSegements, isCatchAll };
+}
+function isParam(routeSegment) {
+    return routeSegment.startsWith(PARAM_TOKEN_NEW) || routeSegment.startsWith(PARAM_TOKEN_OLD);
+}
+function isStaticRouteString(routeString) {
+    const url = routeString;
+    const match = resolveRouteString(routeString, url);
+    assert(match);
+    return Object.keys(match.routeParams).length === 0;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/utils.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/utils.js
new file mode 100644
index 0000000..35fa2ef
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/route/utils.js
@@ -0,0 +1,20 @@
+// Utils needed by:
+//  - runtime of server
+//  - runtime of client (Client Routing)
+// Ensure we don't bloat runtime of Server Routing with the utils down below
+import { assertClientRouting } from '../../utils/assertRoutingType';
+import { isBrowser } from '../../utils/isBrowser';
+if (isBrowser()) {
+    assertClientRouting();
+}
+export * from '../../utils/assert';
+export * from '../../utils/hasProp';
+export * from '../../utils/isObjectWithKeys';
+export * from '../../utils/sorter';
+export * from '../../utils/isPromise';
+export * from '../../utils/isPlainObject';
+export * from '../../utils/objectAssign';
+export * from '../../utils/slice';
+export * from '../../utils/isStringRecord';
+export * from '../../utils/unique';
+export * from '../../utils/isBrowser';
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/sortPageContext.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/sortPageContext.js
new file mode 100644
index 0000000..f2b169f
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/shared/sortPageContext.js
@@ -0,0 +1,14 @@
+import { compareString } from './utils';
+export { sortPageContext };
+// Sort `pageContext` keys alphabetically, in order to make reading `console.log(pageContext)` easier
+function sortPageContext(pageContext) {
+    const entries = Object.entries(pageContext);
+    for (const key in pageContext) {
+        delete pageContext[key];
+    }
+    entries
+        .sort(([key1], [key2]) => compareString(key1, key2))
+        .forEach(([key, val]) => {
+        pageContext[key] = val;
+    });
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/assert.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/assert.js
new file mode 100644
index 0000000..1be2eb2
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/assert.js
@@ -0,0 +1,105 @@
+export { assert };
+export { assertUsage };
+export { assertWarning };
+export { assertInfo };
+export { getProjectError };
+export { logPrefix };
+export { addOnBeforeLogHook };
+import { createErrorWithCleanStackTrace } from './createErrorWithCleanStackTrace';
+import { getGlobalObject } from './getGlobalObject';
+import { projectInfo } from './projectInfo';
+const globalObject = getGlobalObject('assert.ts', {
+    alreadyLogged: new Set()
+});
+const logPrefix = `[${projectInfo.npmPackageName}@${projectInfo.projectVersion}]`;
+const internalErrorPrefix = `${logPrefix}[Bug]`;
+const usageErrorPrefix = `${logPrefix}[Wrong Usage]`;
+const warningPrefix = `${logPrefix}[Warning]`;
+const infoPrefix = `${logPrefix}[Info]`;
+const numberOfStackTraceLinesToRemove = 2;
+function assert(condition, debugInfo) {
+    var _a;
+    if (condition) {
+        return;
+    }
+    const debugStr = (() => {
+        if (!debugInfo) {
+            return null;
+        }
+        const debugInfoSerialized = typeof debugInfo === 'string' ? debugInfo : '`' + JSON.stringify(debugInfo) + '`';
+        return `Debug info (this is for the ${projectInfo.projectName} maintainers; you can ignore this): ${debugInfoSerialized}`;
+    })();
+    const internalError = createErrorWithCleanStackTrace([
+        `${internalErrorPrefix} You stumbled upon a bug in ${projectInfo.projectName}'s source code.`,
+        `Go to ${projectInfo.githubRepository}/issues/new and copy-paste this error. (The error's stack trace is usually enough to fix the problem).`,
+        'A maintainer will fix the bug (usually under 24 hours).',
+        `Don't hesitate to reach out as it makes ${projectInfo.projectName} more robust.`,
+        debugStr
+    ]
+        .filter(Boolean)
+        .join(' '), numberOfStackTraceLinesToRemove);
+    (_a = globalObject.onBeforeLog) === null || _a === void 0 ? void 0 : _a.call(globalObject);
+    throw internalError;
+}
+function assertUsage(condition, errorMessage) {
+    var _a;
+    if (condition) {
+        return;
+    }
+    const whiteSpace = errorMessage.startsWith('[') ? '' : ' ';
+    const errMsg = `${usageErrorPrefix}${whiteSpace}${errorMessage}`;
+    const usageError = createErrorWithCleanStackTrace(errMsg, numberOfStackTraceLinesToRemove);
+    (_a = globalObject.onBeforeLog) === null || _a === void 0 ? void 0 : _a.call(globalObject);
+    throw usageError;
+}
+function getProjectError(errorMessage) {
+    const sep = errorMessage.startsWith('[') ? '' : ' ';
+    const pluginError = createErrorWithCleanStackTrace(`${logPrefix}${sep}${errorMessage}`, numberOfStackTraceLinesToRemove);
+    return pluginError;
+}
+function assertWarning(condition, errorMessage, { onlyOnce, showStackTrace }) {
+    var _a;
+    if (condition) {
+        return;
+    }
+    const msg = `${warningPrefix} ${errorMessage}`;
+    if (onlyOnce) {
+        const { alreadyLogged } = globalObject;
+        const key = onlyOnce === true ? msg : onlyOnce;
+        if (alreadyLogged.has(key)) {
+            return;
+        }
+        else {
+            alreadyLogged.add(key);
+        }
+    }
+    (_a = globalObject.onBeforeLog) === null || _a === void 0 ? void 0 : _a.call(globalObject);
+    if (showStackTrace) {
+        console.warn(new Error(msg));
+    }
+    else {
+        console.warn(msg);
+    }
+}
+function assertInfo(condition, errorMessage, { onlyOnce }) {
+    var _a;
+    if (condition) {
+        return;
+    }
+    const msg = `${infoPrefix} ${errorMessage}`;
+    if (onlyOnce) {
+        const { alreadyLogged } = globalObject;
+        const key = msg;
+        if (alreadyLogged.has(key)) {
+            return;
+        }
+        else {
+            alreadyLogged.add(key);
+        }
+    }
+    (_a = globalObject.onBeforeLog) === null || _a === void 0 ? void 0 : _a.call(globalObject);
+    console.log(msg);
+}
+function addOnBeforeLogHook(onBeforeLog) {
+    globalObject.onBeforeLog = onBeforeLog;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/assertDefaultExport.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/assertDefaultExport.js
new file mode 100644
index 0000000..fb76e1d
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/assertDefaultExport.js
@@ -0,0 +1,42 @@
+export { assertDefaultExportUnknown };
+export { assertDefaultExportObject };
+import { assert, assertUsage, assertWarning } from './assert';
+import { isObject } from './isObject';
+const IGNORE = [
+    // vite-plugin-solid adds `export { $$registrations }`
+    '$$registrations',
+    // @vitejs/plugin-vue adds `export { _rerender_only }`
+    '_rerender_only'
+];
+function assertDefaultExportUnknown(fileExports, filePath) {
+    assertSingleDefaultExport(fileExports, filePath, true);
+}
+function assertDefaultExportObject(fileExports, filePath) {
+    assertSingleDefaultExport(fileExports, filePath, false);
+    const defaultExport = fileExports.default;
+    assertUsage(isObject(defaultExport), `${filePath} should default export an object: its \`export default\` is a \`${typeof defaultExport}\` but it should be an object instead`);
+}
+function assertSingleDefaultExport(fileExports, filePath, defaultExportValueIsUnknown) {
+    const exportsAll = Object.keys(fileExports);
+    const exportsRelevant = exportsAll.filter((exportName) => !IGNORE.includes(exportName));
+    const exportsInvalid = exportsRelevant.filter((e) => e !== 'default');
+    const exportsHasDefault = exportsRelevant.includes('default');
+    if (exportsInvalid.length === 0) {
+        if (exportsHasDefault) {
+            return;
+        }
+        else {
+            assert(exportsRelevant.length === 0);
+            assertUsage(false, `${filePath} doesn't export any value, but it should have a \`export default\` instead`);
+        }
+    }
+    else {
+        const exportsInvalidStr = exportsInvalid.join(', ');
+        if (defaultExportValueIsUnknown) {
+            assertWarning(exportsInvalid.length === 0, `${filePath} should only have a default export: remove \`export { ${exportsInvalidStr} }\``, { onlyOnce: true, showStackTrace: false });
+        }
+        else {
+            assertWarning(exportsInvalid.length === 0, `${filePath} replace \`export { ${exportsInvalidStr} }\` with \`export default { ${exportsInvalidStr} }\``, { onlyOnce: true, showStackTrace: false });
+        }
+    }
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/assertRoutingType.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/assertRoutingType.js
new file mode 100644
index 0000000..d1ae9c8
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/assertRoutingType.js
@@ -0,0 +1,23 @@
+export { assertClientRouting };
+export { assertServerRouting };
+export { checkIfClientRouting };
+import { assertUsage, assertWarning } from './assert';
+import { getGlobalObject } from './getGlobalObject';
+import { isBrowser } from './isBrowser';
+const state = getGlobalObject('utils/assertRouterType.ts', {});
+function assertClientRouting() {
+    assertNoContradiction(checkIfClientRouting());
+    state.isClientRouting = true;
+}
+function checkIfClientRouting() {
+    return state.isClientRouting !== false;
+}
+function assertServerRouting() {
+    assertNoContradiction(state.isClientRouting !== true);
+    state.isClientRouting = false;
+}
+function assertNoContradiction(noContradiction) {
+    // If an assertion fails because of a wrong usage, then we assume that the user is trying to import from 'vite-plugin-ssr/client/router' while not setting `clientRouting` to `true`. Note that 'vite-plugin-ssr/client' only exports the type `PageContextBuiltInClient` and that the package.json#exports entry 'vite-plugin-ssr/client' will eventually be removed.
+    assertUsage(isBrowser(), "`import { something } from 'vite-plugin-ssr/client/router'` is forbidden on the server-side");
+    assertWarning(noContradiction, "You shouldn't `import { something } from 'vite-plugin-ssr/client/router'` when using Server Routing. The 'vite-plugin-ssr/client/router' utilities work only with Client Routing. In particular, don't `import { navigate }` nor `import { prefetch }` when using Server Routing as these will unnecessarily bloat your client-side bundle.", { showStackTrace: false, onlyOnce: true });
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/assertSingleInstance.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/assertSingleInstance.js
new file mode 100644
index 0000000..0cca295
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/assertSingleInstance.js
@@ -0,0 +1,94 @@
+export { onClientEntry_ServerRouting };
+export { onClientEntry_ClientRouting };
+export { onProjectInfo };
+//  - Throw error if there are two different versions of vite-plugin-ssr loaded
+//  - Show warning if entry of Client Routing and entry of Server Routing are both loaded
+//  - Show warning if vite-plugin-ssr is loaded twice
+import { unique } from './unique';
+import { getGlobalObject } from './getGlobalObject';
+/* Use original assertUsage() & assertWarning() after all CJS is removed from node_modules/vite-plugin-ssr/dist/
+import { assertUsage, assertWarning } from './assert'
+*/
+const globalObject = getGlobalObject('assertPackageInstances.ts', {
+    instances: [],
+    alreadyLogged: new Set()
+});
+const makeSure = "Make sure your client-side code doesn't include(/bundle)";
+const clientEntryClonflict = `The client runtime of Server Routing and the client runtime of Client Routing are both being loaded. ${makeSure} both for a given page.`;
+const clientNotSingleInstance = `Two vite-plugin-ssr client runtime instances are being loaded. ${makeSure} vite-plugin-ssr twice. (In order to reduce the size of your client-side JavaScript bundles.)`;
+function assertSingleInstance() {
+    {
+        const versions = unique(globalObject.instances);
+        if (versions.length > 1) {
+            const errMsg = `Both \`vite-plugin-ssr@${versions[0]}\` and \`vite-plugin-ssr@${versions[1]}\` loaded. Only one version should be loaded.`;
+            /*/ Not sure whether circular dependency can cause problems? In principle not since client-side code is ESM.
+            console.warn(errMsg)
+            /*/
+            assertUsage(false, errMsg);
+            //*/
+        }
+    }
+    if (globalObject.checkSingleInstance && globalObject.instances.length > 1) {
+        /*/ Not sure whether circular dependency can cause problems? In principle not since client-side code is ESM.
+        console.warn(clientNotSingleInstance)
+        /*/
+        assertWarning(false, clientNotSingleInstance, { onlyOnce: true, showStackTrace: true });
+        //*/
+    }
+}
+function onClientEntry_ServerRouting(isProduction) {
+    assertWarning(globalObject.isClientRouting !== true, clientEntryClonflict, { onlyOnce: true, showStackTrace: true });
+    assertWarning(globalObject.isClientRouting === undefined, clientNotSingleInstance, {
+        onlyOnce: true,
+        showStackTrace: true
+    });
+    globalObject.isClientRouting = false;
+    if (isProduction)
+        globalObject.checkSingleInstance = true;
+    assertSingleInstance();
+}
+function onClientEntry_ClientRouting(isProduction) {
+    assertWarning(globalObject.isClientRouting !== false, clientEntryClonflict, { onlyOnce: true, showStackTrace: true });
+    assertWarning(globalObject.isClientRouting === undefined, clientNotSingleInstance, {
+        onlyOnce: true,
+        showStackTrace: true
+    });
+    globalObject.isClientRouting = true;
+    if (isProduction)
+        globalObject.checkSingleInstance = true;
+    assertSingleInstance();
+}
+// Called by utils/projectInfo.ts which is loaded by all entries (since utils/asserts.ts depends on utils/projectInfo.ts, we can have confidence that onProjectInfo() is called by each entry). That way we don't have to call a callback for every entry (there are a *lot* of entries: `client/router/`, `client/`, `node/runtime/`, `node/plugin/`, `node/cli`).
+function onProjectInfo(projectVersion) {
+    globalObject.instances.push(projectVersion);
+    assertSingleInstance();
+}
+function assertUsage(condition, errorMessage) {
+    if (condition) {
+        return;
+    }
+    const errMsg = `[vite-plugin-ssr][Wrong Usage] ${errorMessage}`;
+    throw new Error(errMsg);
+}
+function assertWarning(condition, errorMessage, { onlyOnce, showStackTrace }) {
+    if (condition) {
+        return;
+    }
+    const msg = `[vite-plugin-ssr][Warning] ${errorMessage}`;
+    if (onlyOnce) {
+        const { alreadyLogged } = globalObject;
+        const key = onlyOnce === true ? msg : onlyOnce;
+        if (alreadyLogged.has(key)) {
+            return;
+        }
+        else {
+            alreadyLogged.add(key);
+        }
+    }
+    if (showStackTrace) {
+        console.warn(new Error(msg));
+    }
+    else {
+        console.warn(msg);
+    }
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/callHookWithTimeout.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/callHookWithTimeout.js
new file mode 100644
index 0000000..2d5f886
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/callHookWithTimeout.js
@@ -0,0 +1,53 @@
+export { callHookWithTimeout };
+import { logPrefix, getProjectError } from './assert';
+import { humanizeTime } from './humanizeTime';
+function callHookWithTimeout(hookFn, hookName, hookSrc) {
+    const { timeoutErr, timeoutWarn } = getTimeouts(hookName);
+    let resolve;
+    let reject;
+    const promise = new Promise((resolve_, reject_) => {
+        resolve = (ret) => {
+            clearTimeouts();
+            resolve_(ret);
+        };
+        reject = (err) => {
+            clearTimeouts();
+            reject_(err);
+        };
+    });
+    const clearTimeouts = () => {
+        clearTimeout(t1);
+        clearTimeout(t2);
+    };
+    const t1 = setTimeout(() => {
+        const msg = `${logPrefix}[Warning] The ${hookName}() hook defined by ${hookSrc} is taking more than ${humanizeTime(timeoutWarn)}`;
+        console.warn(msg);
+    }, timeoutWarn);
+    const t2 = setTimeout(() => {
+        const err = getProjectError(`Hook timeout: the ${hookName}() hook defined by ${hookSrc} didn't finish after ${humanizeTime(timeoutErr)}`);
+        reject(err);
+    }, timeoutErr);
+    (async () => {
+        try {
+            const ret = await hookFn();
+            resolve(ret);
+        }
+        catch (err) {
+            reject(err);
+        }
+    })();
+    return promise;
+}
+function getTimeouts(hookName) {
+    let timeoutErr = 40 * 1000;
+    let timeoutWarn = 4 * 1000;
+    if (hookName === 'onBeforeRoute') {
+        timeoutErr = 5 * 1000;
+        timeoutWarn = 1 * 1000;
+    }
+    if (hookName === 'onBeforePrerender') {
+        timeoutErr = 10 * 60 * 1000;
+        timeoutWarn = 30 * 1000;
+    }
+    return { timeoutErr, timeoutWarn };
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/compareString.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/compareString.js
new file mode 100644
index 0000000..21c5a70
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/compareString.js
@@ -0,0 +1,8 @@
+export { compareString };
+function compareString(str1, str2) {
+    if (str1.toLowerCase() < str2.toLowerCase())
+        return -1;
+    if (str1.toLowerCase() > str2.toLowerCase())
+        return 1;
+    return 0;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/createErrorWithCleanStackTrace.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/createErrorWithCleanStackTrace.js
new file mode 100644
index 0000000..96e20e8
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/createErrorWithCleanStackTrace.js
@@ -0,0 +1,43 @@
+export { createErrorWithCleanStackTrace };
+import { isNodeJS } from './isNodeJS';
+function createErrorWithCleanStackTrace(errorMessage, numberOfStackTraceLinesToRemove) {
+    let err;
+    {
+        var stackTraceLimit__original = Error.stackTraceLimit;
+        Error.stackTraceLimit = Infinity;
+        err = new Error(errorMessage);
+        Error.stackTraceLimit = stackTraceLimit__original;
+    }
+    if (isNodeJS()) {
+        err.stack = clean(err.stack, numberOfStackTraceLinesToRemove);
+    }
+    return err;
+}
+function clean(errStack, numberOfStackTraceLinesToRemove) {
+    if (!errStack) {
+        return errStack;
+    }
+    const stackLines = splitByLine(errStack);
+    let linesRemoved = 0;
+    const stackLine__cleaned = stackLines
+        .filter((line) => {
+        // Remove internal stack traces
+        if (line.includes(' (internal/') || line.includes(' (node:internal')) {
+            return false;
+        }
+        if (linesRemoved < numberOfStackTraceLinesToRemove && isStackTraceLine(line)) {
+            linesRemoved++;
+            return false;
+        }
+        return true;
+    })
+        .join('\n');
+    return stackLine__cleaned;
+}
+function isStackTraceLine(line) {
+    return line.startsWith('    at ');
+}
+function splitByLine(str) {
+    // https://stackoverflow.com/questions/21895233/how-in-node-to-split-string-by-newline-n
+    return str.split(/\r?\n/);
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/filesystemPathHandling.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/filesystemPathHandling.js
new file mode 100644
index 0000000..22aeae1
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/filesystemPathHandling.js
@@ -0,0 +1,38 @@
+export { toPosixPath };
+export { assertPosixPath };
+export { toSystemPath };
+export { isPosixPath };
+import { assert } from './assert';
+const sepPosix = '/';
+const sepWin32 = '\\';
+function isPosixPath(path) {
+    return !path.includes(sepWin32);
+}
+function toPosixPath(path) {
+    const pathPosix = path.split(sepWin32).join(sepPosix);
+    assertPosixPath(pathPosix);
+    return pathPosix;
+}
+function assertPosixPath(path) {
+    const errMsg = (msg) => `Not a posix path: ${msg}`;
+    assert(path !== null, errMsg('null'));
+    assert(typeof path === 'string', errMsg(`typeof path === '${typeof path}'`));
+    assert(path !== '', errMsg('(empty string)'));
+    assert(path);
+    assert(!path.includes(sepWin32), errMsg(path));
+}
+function toSystemPath(path) {
+    if (isPosixEnv()) {
+        return toPosixPath(path);
+    }
+    if (isWin32Env()) {
+        return path.split(sepPosix).join(sepWin32);
+    }
+    assert(false);
+}
+function isWin32Env() {
+    return process.platform === 'win32';
+}
+function isPosixEnv() {
+    return !isWin32Env();
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/getCurrentUrl.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/getCurrentUrl.js
new file mode 100644
index 0000000..c4f3b04
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/getCurrentUrl.js
@@ -0,0 +1,16 @@
+export { getCurrentUrl };
+import { parseUrl } from './parseUrl';
+import { assert } from './assert';
+function getCurrentUrl(options) {
+    const url = window.location.href;
+    const { searchOriginal, hashOriginal, pathname } = parseUrl(url, '/');
+    let urlCurrent;
+    if (options === null || options === void 0 ? void 0 : options.withoutHash) {
+        urlCurrent = `${pathname}${searchOriginal || ''}`;
+    }
+    else {
+        urlCurrent = `${pathname}${searchOriginal || ''}${hashOriginal || ''}`;
+    }
+    assert(urlCurrent.startsWith('/'));
+    return urlCurrent;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/getGlobalObject.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/getGlobalObject.js
new file mode 100644
index 0000000..f962ab3
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/getGlobalObject.js
@@ -0,0 +1,7 @@
+export function getGlobalObject(
+// We use the filename as key; each `getGlobalObject()` call should live in a unique filename.
+key, defaultValue) {
+    const allGlobalObjects = (globalThis.__vite_plugin_ssr = globalThis.__vite_plugin_ssr || {});
+    const globalObject = (allGlobalObjects[key] = allGlobalObjects[key] || defaultValue);
+    return globalObject;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/getUrlPathname.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/getUrlPathname.js
new file mode 100644
index 0000000..9478b18
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/getUrlPathname.js
@@ -0,0 +1,6 @@
+export { getUrlPathname };
+import { parseUrl } from './parseUrl';
+function getUrlPathname(url) {
+    const urlPathname = parseUrl(url, '/').pathname;
+    return urlPathname;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/hasProp.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/hasProp.js
new file mode 100644
index 0000000..afda8af
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/hasProp.js
@@ -0,0 +1,45 @@
+export { hasProp };
+// - https://2ality.com/2020/06/type-guards-assertion-functions-typescript.html
+// - https://www.typescriptlang.org/play?#code/GYVwdgxgLglg9mABDAzgFQJ4AcCmdgAUAbgIYA2IOAXIiWBgDSJTbWIDkARnHGTnewCUNUhRzIUibr35gA3AFgAUKEiwEEzLnzFylGnUbNWNdmBABbTjgBOQkXvGpE5q7cUrw0eElRa8hKL6tPRMLLimKFA2MGAA5vaIQU6SUTHxHqreGn6sOskGocYRHOAA1mBwAO5gickSiOWVNZle6r7oeYGOhUbhbGmxcYgAvKVgFdW1wlI8fHSIAN7KiMiExeIjW+OTNeyIgksrq4g2OFAgNkjRlMcAvsdnF1cb+EmOo9v9Hg9KyhAIKK0GhNKajRAAFgATMplCQUChbFACLltIQSEwzJZrHZBIJ-oCZAA6MhwOIEEj4v6eNQ+WgIpEEAFgAAmMHaIImzTAM3hiJsUEkzLZ7SOShOa0QTIQIp8hyelzAx1WUAAFjZqi4cFVEABRGwamwEdgAQQZArpADESDAyEJlHcgA
+import { isCallable } from './isCallable';
+import { isObject } from './isObject';
+// prettier-ignore
+function hasProp(obj, prop, type = 'unknown') {
+    if (!isObject(obj))
+        return false;
+    if (!(prop in obj)) {
+        return type === 'undefined';
+    }
+    if (type === 'unknown') {
+        return true;
+    }
+    const propValue = obj[prop];
+    if (type === 'array') {
+        return Array.isArray(propValue);
+    }
+    if (type === 'object') {
+        return isObject(propValue);
+    }
+    if (type === 'string[]') {
+        return Array.isArray(propValue) && propValue.every(el => typeof el === 'string');
+    }
+    if (type === 'function') {
+        return isCallable(propValue);
+    }
+    if (Array.isArray(type)) {
+        return typeof propValue === 'string' && type.includes(propValue);
+    }
+    if (type === 'null') {
+        return propValue === null;
+    }
+    if (type === 'undefined') {
+        return propValue === undefined;
+    }
+    if (type === 'true') {
+        return propValue === true;
+    }
+    if (type === 'false') {
+        return propValue === false;
+    }
+    return typeof propValue === type;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/hasPropertyGetter.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/hasPropertyGetter.js
new file mode 100644
index 0000000..4b8b80d
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/hasPropertyGetter.js
@@ -0,0 +1,4 @@
+export function hasPropertyGetter(obj, prop) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+    return !!descriptor && !('value' in descriptor) && !!descriptor.get;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/humanizeTime.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/humanizeTime.js
new file mode 100644
index 0000000..95e7c18
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/humanizeTime.js
@@ -0,0 +1,22 @@
+export { humanizeTime };
+function humanizeTime(milliseconds) {
+    const seconds = milliseconds / 1000;
+    if (seconds < 120) {
+        const n = round(seconds);
+        return `${n} second${plural(n)}`;
+    }
+    {
+        const minutes = seconds / 60;
+        const n = round(minutes);
+        return `${n} minute${plural(n)}`;
+    }
+}
+function round(n) {
+    let rounded = n.toFixed(1);
+    if (rounded.endsWith('.0'))
+        rounded = rounded.slice(0, -2);
+    return rounded;
+}
+function plural(n) {
+    return n === '1' ? '' : 's';
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isBrowser.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isBrowser.js
new file mode 100644
index 0000000..a4a787b
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isBrowser.js
@@ -0,0 +1,4 @@
+export function isBrowser() {
+    // Using `typeof window !== 'undefined'` alone is not enough because some users use https://www.npmjs.com/package/ssr-window
+    return typeof window !== 'undefined' && typeof window.scrollY === 'number';
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isCallable.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isCallable.js
new file mode 100644
index 0000000..4500bc0
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isCallable.js
@@ -0,0 +1,3 @@
+export function isCallable(thing) {
+    return thing instanceof Function || typeof thing === 'function';
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isExternalLink.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isExternalLink.js
new file mode 100644
index 0000000..78f2c7c
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isExternalLink.js
@@ -0,0 +1,4 @@
+export { isExternalLink };
+function isExternalLink(url) {
+    return !url.startsWith('/') && !url.startsWith('.') && !url.startsWith('?') && url !== '';
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isNodeJS.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isNodeJS.js
new file mode 100644
index 0000000..b9508dc
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isNodeJS.js
@@ -0,0 +1,13 @@
+export function isNodeJS() {
+    if (typeof process === 'undefined')
+        return false;
+    if (!process.cwd)
+        return false;
+    // https://stackoverflow.com/questions/4224606/how-to-check-whether-a-script-is-running-under-node-js/35813135#35813135
+    if (!process.versions || typeof process.versions.node === 'undefined')
+        return false;
+    // https://stackoverflow.com/questions/4224606/how-to-check-whether-a-script-is-running-under-node-js/35813135#comment92529277_35813135
+    if (!process.release || process.release.name !== 'node')
+        return false;
+    return true;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isNotNullish.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isNotNullish.js
new file mode 100644
index 0000000..d4445f8
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isNotNullish.js
@@ -0,0 +1 @@
+export const isNotNullish = (p) => p !== null && p !== undefined;
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isNpmPackageName.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isNpmPackageName.js
new file mode 100644
index 0000000..eed0708
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isNpmPackageName.js
@@ -0,0 +1,63 @@
+export { isNpmPackageName };
+export { isNpmPackageModule };
+export { isNpmPackageImportPath };
+export { getNpmPackageName };
+export { getNpmPackageImportPath };
+import { assert } from './assert';
+const invalidNameRE = /[^a-zA-Z-_]/;
+function isNpmPackageModule(str) {
+    const res = parseNpmPath(str);
+    return res !== null;
+}
+function isNpmPackageName(str) {
+    const res = parseNpmPath(str);
+    return res !== null && res.importPath === null;
+}
+function isNpmPackageImportPath(str) {
+    const res = parseNpmPath(str);
+    return res !== null && res.importPath !== null;
+}
+function getNpmPackageName(str) {
+    const res = parseNpmPath(str);
+    if (!res)
+        return null;
+    return res.npmPackageName;
+}
+function getNpmPackageImportPath(str) {
+    const res = parseNpmPath(str);
+    if (!res)
+        return null;
+    return res.importPath;
+}
+function parseNpmPath(str) {
+    if (str === undefined || str.includes('\\') || str.startsWith('/')) {
+        return null;
+    }
+    let scope = null;
+    if (str.startsWith('@')) {
+        if (!str.includes('/')) {
+            return null;
+        }
+        const [first, ...rest] = str.split('/');
+        scope = first;
+        str = rest.join('/');
+        assert(scope && scope.startsWith('@'));
+    }
+    if (str === '') {
+        return null;
+    }
+    const [first, ...rest] = str.split('/');
+    const name = first;
+    const importPath = rest.length === 0 ? null : rest.join('/');
+    assert(name);
+    assert(importPath === null || !importPath.startsWith('/'));
+    if (invalidNameRE.test(name) || (scope && invalidNameRE.test(scope.slice(1)))) {
+        return null;
+    }
+    assert(!name.startsWith('/'));
+    const npmPackageName = scope ? `${scope}/${name}` : name;
+    return {
+        npmPackageName,
+        importPath
+    };
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isObject.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isObject.js
new file mode 100644
index 0000000..44b7f6f
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isObject.js
@@ -0,0 +1,3 @@
+export function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isObjectWithKeys.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isObjectWithKeys.js
new file mode 100644
index 0000000..664812f
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isObjectWithKeys.js
@@ -0,0 +1,13 @@
+import { isPlainObject } from './isPlainObject';
+export { isObjectWithKeys };
+function isObjectWithKeys(obj, keys) {
+    if (!isPlainObject(obj)) {
+        return false;
+    }
+    for (const key of Object.keys(obj)) {
+        if (!keys.includes(key)) {
+            return false;
+        }
+    }
+    return true;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isPlainObject.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isPlainObject.js
new file mode 100644
index 0000000..003fd54
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isPlainObject.js
@@ -0,0 +1,15 @@
+export { isPlainObject };
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    // Support `Object.create(null)`
+    if (Object.getPrototypeOf(value) === null) {
+        return true;
+    }
+    return (
+    /* Doesn't work in Cloudlfare Pages workers
+    value.constructor === Object
+    */
+    value.constructor.name === 'Object');
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isPromise.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isPromise.js
new file mode 100644
index 0000000..9e794a1
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isPromise.js
@@ -0,0 +1,4 @@
+import { isCallable } from './isCallable';
+export function isPromise(val) {
+    return typeof val === 'object' && val !== null && 'then' in val && isCallable(val.then);
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isReact.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isReact.js
new file mode 100644
index 0000000..a311c01
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isReact.js
@@ -0,0 +1,21 @@
+// There doesn't seem to be a reliable way to detect React:
+//  - https://stackoverflow.com/questions/73156433/detect-with-javascript-whether-the-website-is-using-react
+export function isReact() {
+    var _a, _b, _c, _d;
+    // Heuristic using values set by React (Dev Tools)
+    // - `window.__REACT_DEVTOOLS_GLOBAL_HOOK__` is an internal API for React Dev Tools
+    //   - https://stackoverflow.com/questions/46807826/how-does-react-developer-tools-determine-that-the-webpage-is-using-react/46808361#46808361
+    //   - In principle, `window.__REACT_DEVTOOLS_GLOBAL_HOOK__` should exist only if React Dev Tools is installed. (Although it seems that it's sometimes defined even when React Dev Tools isn't installed; I don't know why.)
+    // - We use `isReact1`/`isReact2` merely to validate `isReact3` and `isReact4`. Because `isReact1`/`isReact2` can be false negatives:
+    //   - React populates `__REACT_DEVTOOLS_GLOBAL_HOOK__.renderers` fairly late => false negative early in the rendering phase
+    //   - `window.__REACT_DEVTOOLS_GLOBAL_HOOK__` is `undefined` if React Dev Tools isn't installed => false negative
+    const isReact1 = !!((_b = (_a = window.__REACT_DEVTOOLS_GLOBAL_HOOK__) === null || _a === void 0 ? void 0 : _a.renderers) === null || _b === void 0 ? void 0 : _b.size);
+    const isReact2 = !!((_d = (_c = window.__REACT_DEVTOOLS_GLOBAL_HOOK__) === null || _c === void 0 ? void 0 : _c.rendererInterfaces) === null || _d === void 0 ? void 0 : _d.size);
+    // Heuristic using values set by `@vitejs/plugin-react`
+    const isReact3 = !!window.__vite_plugin_react_preamble_installed__;
+    /* Also set by Preact Vite plugin `@preact/preset-vite`
+    const isReact4 = !!(window as any).$RefreshReg$
+    */
+    // console.log({ isReact1, isReact2, isReact3 })
+    return isReact1 || isReact2 || isReact3;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isSameErrorMessage.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isSameErrorMessage.js
new file mode 100644
index 0000000..192cc35
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isSameErrorMessage.js
@@ -0,0 +1,4 @@
+export { isSameErrorMessage };
+function isSameErrorMessage(err1, err2) {
+    return (err1 === null || err1 === void 0 ? void 0 : err1.message) === (err2 === null || err2 === void 0 ? void 0 : err2.message);
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isScriptFile.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isScriptFile.js
new file mode 100644
index 0000000..9b09177
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isScriptFile.js
@@ -0,0 +1,50 @@
+export { isScriptFile };
+export { isTemplateFile };
+export { scriptFileExtensions };
+export { scriptFileExtensionList };
+import { assert } from './assert';
+// We can't use a RegExp:
+//  - Needs to work with Micromatch: https://github.com/micromatch/micromatch because:
+//    - Vite's `import.meta.glob()` uses Micromatch
+//  - We need this to be a whitelist because:
+//   - A pattern `*([a-zA-Z0-9]` doesn't work.
+//     - Because of ReScript: `.res` are ReScript source files which need to be ignored. (The ReScript compiler generates `.js` files alongside `.res` files.)
+//   - Black listing doesn't work.
+//     - We cannot implement a blacklist with a glob pattern.
+//     - A post `import.meta.glob()` blacklist filtering doesn't work because Vite would still process the files (e.g. including them in the bundle).
+// prettier-ignore
+const extJavaScript = [
+    'js',
+    'ts',
+    'cjs',
+    'cts',
+    'mjs',
+    'mts',
+    'jsx',
+    'tsx',
+    'cjsx',
+    'ctsx',
+    'mjsx',
+    'mtsx',
+];
+// prettier-ignore
+const extTemplates = [
+    'vue',
+    'svelte',
+    'marko',
+    'md',
+    'mdx'
+];
+const scriptFileExtensionList = [...extJavaScript, ...extTemplates];
+const scriptFileExtensions = '(' + scriptFileExtensionList.join('|') + ')';
+function isScriptFile(filePath) {
+    const yes = scriptFileExtensionList.some((ext) => filePath.endsWith('.' + ext));
+    assert(!isJavaScriptFile(filePath) || yes);
+    return yes;
+}
+function isJavaScriptFile(filePath) {
+    return /\.(c|m)?(j|t)sx?$/.test(filePath);
+}
+function isTemplateFile(filePath) {
+    return extTemplates.some((ext) => filePath.endsWith('.' + ext));
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isStringRecord.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isStringRecord.js
new file mode 100644
index 0000000..3760c2a
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/isStringRecord.js
@@ -0,0 +1,3 @@
+export function isStringRecord(thing) {
+    return typeof thing === 'object' && thing !== null && Object.values(thing).every((val) => typeof val === 'string');
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/objectAssign.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/objectAssign.js
new file mode 100644
index 0000000..0abcb60
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/objectAssign.js
@@ -0,0 +1,5 @@
+export { objectAssign };
+// Same as `Object.assign()` but with type inference
+function objectAssign(obj, objAddendum) {
+    Object.assign(obj, objAddendum);
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/objectEntries.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/objectEntries.js
new file mode 100644
index 0000000..a38c53d
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/objectEntries.js
@@ -0,0 +1,5 @@
+export { objectEntries };
+// Same as `Object.entries()` but with type inference
+function objectEntries(obj) {
+    return Object.entries(obj);
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/parseUrl.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/parseUrl.js
new file mode 100644
index 0000000..295b0d5
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/parseUrl.js
@@ -0,0 +1,214 @@
+export { parseUrl };
+export { isParsable };
+export { prependBase };
+export { assertUsageBaseServer };
+export { normalizeBaseServer };
+export { isBaseServer };
+export { isBaseAssets };
+import { slice } from './slice';
+import { assert, assertUsage } from './assert';
+function isParsable(url) {
+    // `parseUrl()` works with these URLs
+    return (url.startsWith('/') ||
+        url.startsWith('http') ||
+        url.startsWith('tauri://') ||
+        url.startsWith('.') ||
+        url.startsWith('?') ||
+        url.startsWith('#') ||
+        url === '');
+}
+function parseUrl(url, baseServer) {
+    assert(isParsable(url), { url });
+    assert(baseServer.startsWith('/'), { url, baseServer });
+    // Hash
+    const [urlWithoutHash, ...hashList] = url.split('#');
+    assert(urlWithoutHash !== undefined);
+    const hashOriginal = ['', ...hashList].join('#') || null;
+    assert(hashOriginal === null || hashOriginal.startsWith('#'));
+    const hash = hashOriginal === null ? '' : decodeSafe(hashOriginal.slice(1));
+    // Search
+    const [urlWithoutSearch, ...searchList] = urlWithoutHash.split('?');
+    assert(urlWithoutSearch !== undefined);
+    const searchOriginal = ['', ...searchList].join('?') || null;
+    assert(searchOriginal === null || searchOriginal.startsWith('?'), { url, searchOriginal });
+    const search = {};
+    const searchAll = {};
+    Array.from(new URLSearchParams(searchOriginal || '')).forEach(([key, val]) => {
+        search[key] = val;
+        searchAll[key] = [...(searchAll[key] || []), val];
+    });
+    // Origin + pathname
+    const { origin, pathnameResolved } = parseWithNewUrl(urlWithoutSearch, baseServer);
+    assert(origin === null || origin === decodeSafe(origin), { origin }); // AFAICT decoding the origin is useless
+    assert(pathnameResolved.startsWith('/'), { url, pathnameResolved });
+    assert(origin === null || url.startsWith(origin), { url, origin });
+    // `pathnameOriginal`
+    const pathnameOriginal = urlWithoutSearch.slice((origin || '').length);
+    {
+        const urlRecreated = `${origin || ''}${pathnameOriginal}${searchOriginal || ''}${hashOriginal || ''}`;
+        assert(url === urlRecreated, { url, urlRecreated });
+    }
+    // Base URL
+    let { pathname, hasBaseServer } = analyzeBaseServer(pathnameResolved, baseServer);
+    pathname = decodePathname(pathname);
+    assert(pathname.startsWith('/'));
+    return {
+        origin,
+        pathname,
+        pathnameOriginal: pathnameOriginal,
+        hasBaseServer,
+        search,
+        searchAll,
+        searchOriginal,
+        hash,
+        hashOriginal
+    };
+}
+function decodeSafe(urlComponent) {
+    try {
+        return decodeURIComponent(urlComponent);
+    }
+    catch { }
+    try {
+        return decodeURI(urlComponent);
+    }
+    catch { }
+    return urlComponent;
+}
+function decodePathname(urlPathname) {
+    return urlPathname
+        .split('/')
+        .map((dir) => decodeSafe(dir).split('/').join('%2F'))
+        .join('/');
+}
+function parseWithNewUrl(urlWithoutSearch, baseServer) {
+    var _a;
+    // `new URL('//', 'https://example.org')` throws `ERR_INVALID_URL`
+    if (urlWithoutSearch.startsWith('//')) {
+        return { origin: null, pathnameResolved: urlWithoutSearch };
+    }
+    let isTauriProtocol = false;
+    const PROTOCOL_TAURI = 'tauri://';
+    const PROTOCOL_FAKE = 'http://';
+    if (urlWithoutSearch.startsWith(PROTOCOL_TAURI)) {
+        isTauriProtocol = true;
+        urlWithoutSearch = PROTOCOL_FAKE + urlWithoutSearch.slice(PROTOCOL_TAURI.length);
+    }
+    let origin;
+    let pathnameResolved;
+    try {
+        // `new URL(url)` throws an error if `url` doesn't have an origin
+        const urlParsed = new URL(urlWithoutSearch);
+        origin = urlParsed.origin;
+        pathnameResolved = urlParsed.pathname;
+    }
+    catch (err) {
+        // `url` has no origin
+        origin = null;
+        // In the browser, this is the Base URL of the current URL
+        let base = typeof window !== 'undefined' &&
+            (
+            // We need to access safely in case the user sets `window` in Node.js
+            (_a = window === null || window === void 0 ? void 0 : window.document) === null || _a === void 0 ? void 0 : _a.baseURI);
+        base = base || 'http://fake.example.org' + baseServer;
+        // `new Url()` supports:
+        //  - `url === '/absolute/path'`
+        //  - `url === './relative/path'`
+        //  - `url === '?queryWithoutPath'`
+        //  - `url === '''`
+        // `base` in `new URL(url, base)` is used for resolving relative paths (`new URL()` doesn't remove `base` from `pathname`)
+        const urlParsed = new URL(urlWithoutSearch, base);
+        pathnameResolved = urlParsed.pathname;
+    }
+    if (!pathnameResolved)
+        pathnameResolved = '/';
+    if (isTauriProtocol) {
+        assert(origin);
+        assert(origin.startsWith(PROTOCOL_FAKE));
+        origin = PROTOCOL_TAURI + origin.slice(PROTOCOL_FAKE.length);
+    }
+    assert(pathnameResolved.startsWith('/'), { urlWithoutSearch, pathnameResolved });
+    // The URL pathname should be the URL without origin, query string, and hash.
+    //  - https://developer.mozilla.org/en-US/docs/Web/API/URL/pathname
+    assert(pathnameResolved === pathnameResolved.split('?')[0].split('#')[0]);
+    return { origin, pathnameResolved };
+}
+function assertUsageBaseServer(baseServer, usageErrorMessagePrefix = '') {
+    assertUsage(!baseServer.startsWith('http'), usageErrorMessagePrefix +
+        '`base` is not allowed to start with `http`. Consider using `baseAssets` instead, see https://vite-plugin-ssr.com/base-url');
+    assertUsage(baseServer.startsWith('/'), usageErrorMessagePrefix + 'Wrong `base` value `' + baseServer + '`; `base` should start with `/`.');
+    assert(isBaseServer(baseServer));
+}
+function assertUrlPathname(urlPathname) {
+    assert(urlPathname.startsWith('/'));
+    assert(!urlPathname.includes('?'));
+    assert(!urlPathname.includes('#'));
+}
+function analyzeBaseServer(urlPathnameWithBase, baseServer) {
+    assertUrlPathname(urlPathnameWithBase);
+    assert(isBaseServer(baseServer));
+    // Mutable
+    let urlPathname = urlPathnameWithBase;
+    assert(urlPathname.startsWith('/'));
+    assert(baseServer.startsWith('/'));
+    if (baseServer === '/') {
+        const pathname = urlPathnameWithBase;
+        return { pathname, hasBaseServer: true };
+    }
+    // Support `url === '/some-base-url' && baseServer === '/some-base-url/'`
+    let baseServerNormalized = baseServer;
+    if (baseServer.endsWith('/') && urlPathname === slice(baseServer, 0, -1)) {
+        baseServerNormalized = slice(baseServer, 0, -1);
+        assert(urlPathname === baseServerNormalized);
+    }
+    if (!urlPathname.startsWith(baseServerNormalized)) {
+        const pathname = urlPathnameWithBase;
+        return { pathname, hasBaseServer: false };
+    }
+    assert(urlPathname.startsWith('/') || urlPathname.startsWith('http'));
+    assert(urlPathname.startsWith(baseServerNormalized));
+    urlPathname = urlPathname.slice(baseServerNormalized.length);
+    if (!urlPathname.startsWith('/'))
+        urlPathname = '/' + urlPathname;
+    assert(urlPathname.startsWith('/'));
+    return { pathname: urlPathname, hasBaseServer: true };
+}
+function prependBase(url, baseServer) {
+    if (baseServer.startsWith('http')) {
+        const baseAssets = baseServer;
+        const baseAssetsNormalized = normalizeBaseAssets(baseAssets);
+        assert(!baseAssetsNormalized.endsWith('/'));
+        assert(url.startsWith('/'));
+        return `${baseAssetsNormalized}${url}`;
+    }
+    assert(isBaseServer(baseServer));
+    const baseServerNormalized = normalizeBaseServer(baseServer);
+    if (baseServerNormalized === '/')
+        return url;
+    assert(!baseServerNormalized.endsWith('/'));
+    assert(url.startsWith('/'));
+    return `${baseServerNormalized}${url}`;
+}
+function normalizeBaseServer(baseServer) {
+    let baseServerNormalized = baseServer;
+    if (baseServerNormalized.endsWith('/') && baseServerNormalized !== '/') {
+        baseServerNormalized = slice(baseServerNormalized, 0, -1);
+    }
+    // We can and should expect `baseServer` to not contain `/` doublets.
+    assert(!baseServerNormalized.endsWith('/') || baseServerNormalized === '/');
+    return baseServerNormalized;
+}
+function isBaseServer(baseServer) {
+    return baseServer.startsWith('/');
+}
+function isBaseAssets(base) {
+    return base.startsWith('/') || base.startsWith('http://') || base.startsWith('https://');
+}
+function normalizeBaseAssets(baseAssets) {
+    let baseAssetsNormalized = baseAssets;
+    if (baseAssetsNormalized.endsWith('/')) {
+        baseAssetsNormalized = slice(baseAssetsNormalized, 0, -1);
+    }
+    assert(!baseAssetsNormalized.endsWith('/'));
+    return baseAssetsNormalized;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/projectInfo.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/projectInfo.js
new file mode 100644
index 0000000..d274227
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/projectInfo.js
@@ -0,0 +1,10 @@
+import { onProjectInfo } from './assertSingleInstance';
+const PROJECT_VERSION = '0.4.123';
+export const projectInfo = {
+    projectName: 'vite-plugin-ssr',
+    projectVersion: PROJECT_VERSION,
+    npmPackageName: 'vite-plugin-ssr',
+    githubRepository: 'https://github.com/brillout/vite-plugin-ssr'
+};
+// Trick: since `utils/asserts.ts` depends on this file (`utils/projectInfo.ts`), we can have confidence that this file is always instantiated. So that we don't have to initialize this code snippet at every possible entry. (There are a *lot* of entries: `client/router/`, `client/`, `node/`, `node/plugin/`, `node/cli`, etc.)
+onProjectInfo(projectInfo.projectVersion);
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/serverSideRouteTo.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/serverSideRouteTo.js
new file mode 100644
index 0000000..42850ca
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/serverSideRouteTo.js
@@ -0,0 +1,4 @@
+export { serverSideRouteTo };
+function serverSideRouteTo(url) {
+    window.location.href = url;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/sleep.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/sleep.js
new file mode 100644
index 0000000..75573f1
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/sleep.js
@@ -0,0 +1,4 @@
+export { sleep };
+function sleep(milliseconds) {
+    return new Promise((r) => setTimeout(r, milliseconds));
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/slice.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/slice.js
new file mode 100644
index 0000000..4f15a99
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/slice.js
@@ -0,0 +1,33 @@
+import { assert } from './assert';
+export { slice };
+function slice(thing, from, to) {
+    if (typeof thing === 'string') {
+        return sliceArray(thing.split(''), from, to).join('');
+    }
+    else {
+        return sliceArray(thing, from, to);
+    }
+}
+function sliceArray(list, from, to) {
+    const listSlice = [];
+    let start = from >= 0 ? from : list.length + from;
+    assert(start >= 0 && start <= list.length);
+    let end = to >= 0 ? to : list.length + to;
+    assert(end >= 0 && end <= list.length);
+    while (true) {
+        if (start === end) {
+            break;
+        }
+        if (start === list.length) {
+            start = 0;
+        }
+        if (start === end) {
+            break;
+        }
+        const el = list[start];
+        assert(el !== undefined);
+        listSlice.push(el);
+        start++;
+    }
+    return listSlice;
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/sorter.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/sorter.js
new file mode 100644
index 0000000..b86e25a
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/sorter.js
@@ -0,0 +1,56 @@
+import { assert } from './assert';
+export { higherFirst };
+export { lowerFirst };
+export { makeFirst };
+export { makeLast };
+// -1 => element1 first
+// +1 => element2 first
+function higherFirst(getValue) {
+    return (element1, element2) => {
+        const val1 = getValue(element1);
+        const val2 = getValue(element2);
+        if (val1 === val2) {
+            return 0;
+        }
+        return val1 > val2 ? -1 : 1;
+    };
+}
+function lowerFirst(getValue) {
+    return (element1, element2) => {
+        const val1 = getValue(element1);
+        const val2 = getValue(element2);
+        if (val1 === val2) {
+            return 0;
+        }
+        return val1 < val2 ? -1 : 1;
+    };
+}
+function makeFirst(getValue) {
+    return (element1, element2) => {
+        const val1 = getValue(element1);
+        const val2 = getValue(element2);
+        assert([true, false, null].includes(val1));
+        assert([true, false, null].includes(val2));
+        if (val1 === val2) {
+            return 0;
+        }
+        if (val1 === true || val2 === false) {
+            return -1; // element1 first
+        }
+        if (val2 === true || val1 === false) {
+            return 1; // element2 first
+        }
+        assert(false);
+    };
+}
+function makeLast(getValue) {
+    return makeFirst((element) => {
+        const val = getValue(element);
+        if (val === null) {
+            return null;
+        }
+        else {
+            return !val;
+        }
+    });
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/stringifyStringArray.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/stringifyStringArray.js
new file mode 100644
index 0000000..b918d32
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/stringifyStringArray.js
@@ -0,0 +1,4 @@
+export { stringifyStringArray };
+function stringifyStringArray(stringList) {
+    return '[' + stringList.map((str) => "'" + str + "'").join(', ') + ']';
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/throttle.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/throttle.js
new file mode 100644
index 0000000..5d0e21a
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/throttle.js
@@ -0,0 +1,13 @@
+export { throttle };
+function throttle(func, waitTime) {
+    let isQueued = false;
+    return () => {
+        if (!isQueued) {
+            isQueued = true;
+            setTimeout(() => {
+                isQueued = false;
+                func();
+            }, waitTime);
+        }
+    };
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/unique.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/unique.js
new file mode 100644
index 0000000..a48e5b2
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/unique.js
@@ -0,0 +1,4 @@
+export { unique };
+function unique(arr) {
+    return Array.from(new Set(arr));
+}
diff --git a/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/urlToFile.js b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/urlToFile.js
new file mode 100644
index 0000000..0fd2fbc
--- /dev/null
+++ b/parent_dir/node_modules/vite-plugin-ssr/dist/esm/utils/urlToFile.js
@@ -0,0 +1,33 @@
+export { urlToFile };
+export { baseServer };
+import { assert } from './assert';
+import { parseUrl } from './parseUrl';
+import { slice } from './slice';
+// - When doing a `.pageContext.json` HTTP request, the base URL should be preserved. (The server-side will handle the base URL.)
+// - While prerendering there is no base URL
+const baseServer = '/';
+function urlToFile(url, fileExtension, doNotCreateExtraDirectory) {
+    const { pathnameOriginal, searchOriginal, hashOriginal } = parseUrl(url, baseServer);
+    if (url.startsWith('/')) {
+        assert(url === `${pathnameOriginal}${searchOriginal || ''}${hashOriginal || ''}`, { url });
+    }
+    const hasTrailingSlash = pathnameOriginal.endsWith('/');
+    let pathnameModified;
+    if (doNotCreateExtraDirectory && pathnameOriginal !== '/') {
+        if (hasTrailingSlash) {
+            pathnameModified = slice(pathnameOriginal, 0, -1);
+        }
+        else {
+            pathnameModified = pathnameOriginal;
+        }
+        assert(!pathnameModified.endsWith('/'), { url });
+        assert(pathnameModified !== '');
+    }
+    else {
+        pathnameModified = pathnameOriginal + (hasTrailingSlash ? '' : '/') + 'index';
+    }
+    assert(pathnameModified);
+    pathnameModified = pathnameModified + fileExtension;
+    const fileUrl = `${pathnameModified}${searchOriginal || ''}${hashOriginal || ''}`;
+    return fileUrl;
+}
diff --git a/parent_dir/node_modules/vue-cookies/vue-cookies.js b/parent_dir/node_modules/vue-cookies/vue-cookies.js
new file mode 100644
index 0000000..a49a63e
--- /dev/null
+++ b/parent_dir/node_modules/vue-cookies/vue-cookies.js
@@ -0,0 +1,151 @@
+/**
+ * Vue Cookies v1.8.3
+ * https://github.com/cmp-cc/vue-cookies
+ *
+ * Copyright 2016, cmp-cc
+ * Released under the MIT license
+ */
+
+ (function () {
+
+  var defaultConfig = {
+    expires: '1d',
+    path: '; path=/',
+    domain: '',
+    secure: '',
+    sameSite: '; SameSite=Lax'
+  };
+
+  var VueCookies = {
+    // install of Vue
+    install: function (Vue, options) {
+      if (options) this.config(options.expires, options.path, options.domain, options.secure, options.sameSite);
+      if (Vue.prototype) Vue.prototype.$cookies = this;
+      if (Vue.config && Vue.config.globalProperties) {
+        Vue.config.globalProperties.$cookies = this;
+        Vue.provide('$cookies', this);
+      }
+      Vue.$cookies = this;
+    },
+    config: function (expires, path, domain, secure, sameSite) {
+      defaultConfig.expires = expires ? expires : '1d';
+      defaultConfig.path = path ? '; path=' + path : '; path=/';
+      defaultConfig.domain = domain ? '; domain=' + domain : '';
+      defaultConfig.secure = secure ? '; Secure' : '';
+      defaultConfig.sameSite = sameSite ? '; SameSite=' + sameSite : '; SameSite=Lax';
+    },
+    get: function (key) {
+      var value = decodeURIComponent(document.cookie.replace(new RegExp('(?:(?:^|.*;)\\s*' + encodeURIComponent(key).replace(/[\-\.\+\*]/g, '\\$&') + '\\s*\\=\\s*([^;]*).*$)|^.*$'), '$1')) || null;
+
+      if (value && ((value.substring(0, 1) === '{' && value.substring(value.length - 1, value.length) === '}') || (value.substring(0, 1) === '[' && value.substring(value.length - 1, value.length) === ']'))) {
+        try {
+          value = JSON.parse(value);
+        } catch (e) {
+          return value;
+        }
+      }
+      return value;
+    },
+    set: function (key, value, expires, path, domain, secure, sameSite) {
+      if (!key) {
+        throw new Error('Cookie name is not found in the first argument.');
+      } else if (/^(?:expires|max\-age|path|domain|secure|SameSite)$/i.test(key)) {
+        throw new Error('Cookie name illegality. Cannot be set to ["expires","max-age","path","domain","secure","SameSite"]\t current key name: ' + key);
+      }
+      // support json object
+      if (value && typeof value === 'object') {
+        value = JSON.stringify(value);
+      }
+      var _expires = '';
+      expires = expires == undefined ? defaultConfig.expires : expires;
+      if (expires && expires != 0) {
+        switch (expires.constructor) {
+          case Number:
+            if (expires === Infinity || expires === -1) _expires = '; expires=Fri, 31 Dec 9999 23:59:59 GMT';
+            else _expires = '; max-age=' + expires;
+            break;
+          case String:
+            if (/^(?:\d+(y|m|d|h|min|s))$/i.test(expires)) {
+              // get capture number group
+              var _expireTime = expires.replace(/^(\d+)(?:y|m|d|h|min|s)$/i, '$1');
+              // get capture type group , to lower case
+              switch (expires.replace(/^(?:\d+)(y|m|d|h|min|s)$/i, '$1').toLowerCase()) {
+                  // Frequency sorting
+                case 'm':
+                  _expires = '; max-age=' + +_expireTime * 2592000;
+                  break; // 60 * 60 * 24 * 30
+                case 'd':
+                  _expires = '; max-age=' + +_expireTime * 86400;
+                  break; // 60 * 60 * 24
+                case 'h':
+                  _expires = '; max-age=' + +_expireTime * 3600;
+                  break; // 60 * 60
+                case 'min':
+                  _expires = '; max-age=' + +_expireTime * 60;
+                  break; // 60
+                case 's':
+                  _expires = '; max-age=' + _expireTime;
+                  break;
+                case 'y':
+                  _expires = '; max-age=' + +_expireTime * 31104000;
+                  break; // 60 * 60 * 24 * 30 * 12
+                default:
+                  new Error('unknown exception of "set operation"');
+              }
+            } else {
+              _expires = '; expires=' + expires;
+            }
+            break;
+          case Date:
+            _expires = '; expires=' + expires.toUTCString();
+            break;
+        }
+      }
+      document.cookie =
+          encodeURIComponent(key) + '=' + encodeURIComponent(value) +
+          _expires +
+          (domain ? '; domain=' + domain : defaultConfig.domain) +
+          (path ? '; path=' + path : defaultConfig.path) +
+          (secure == undefined ? defaultConfig.secure : secure ? '; Secure' : '') +
+          (sameSite == undefined ? defaultConfig.sameSite : (sameSite ? '; SameSite=' + sameSite : ''));
+      return this;
+    },
+    remove: function (key, path, domain) {
+      if (!key || !this.isKey(key)) {
+        return false;
+      }
+      document.cookie = encodeURIComponent(key) +
+          '=; expires=Thu, 01 Jan 1970 00:00:00 GMT' +
+          (domain ? '; domain=' + domain : defaultConfig.domain) +
+          (path ? '; path=' + path : defaultConfig.path) +
+          '; SameSite=Lax';
+      return true;
+    },
+    isKey: function (key) {
+      return (new RegExp('(?:^|;\\s*)' + encodeURIComponent(key).replace(/[\-\.\+\*]/g, '\\$&') + '\\s*\\=')).test(document.cookie);
+    },
+    keys: function () {
+      if (!document.cookie) return [];
+      var _keys = document.cookie.replace(/((?:^|\s*;)[^\=]+)(?=;|$)|^\s*|\s*(?:\=[^;]*)?(?:\1|$)/g, '').split(/\s*(?:\=[^;]*)?;\s*/);
+      for (var _index = 0; _index < _keys.length; _index++) {
+        _keys[_index] = decodeURIComponent(_keys[_index]);
+      }
+      return _keys;
+    }
+  };
+
+  if (typeof exports == 'object') {
+    module.exports = VueCookies;
+  } else if (typeof define == 'function' && define.amd) {
+    define([], function () {
+      return VueCookies;
+    });
+  } else if (window.Vue && window.Vue.use) {
+    Vue.use(VueCookies);
+  }
+  // vue-cookies can exist independently,no dependencies library
+  if (typeof window !== 'undefined') {
+    window.$cookies = VueCookies;
+  }
+
+})();
diff --git a/parent_dir/node_modules/vue-i18n/dist/vue-i18n.esm-bundler.js b/parent_dir/node_modules/vue-i18n/dist/vue-i18n.esm-bundler.js
new file mode 100644
index 0000000..10f86d3
--- /dev/null
+++ b/parent_dir/node_modules/vue-i18n/dist/vue-i18n.esm-bundler.js
@@ -0,0 +1,2817 @@
+/*!
+  * vue-i18n v9.2.2
+  * (c) 2022 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+import { getGlobalThis, format, makeSymbol, isPlainObject, isArray, isString, hasOwn, isObject, isBoolean, isRegExp, isFunction, inBrowser, assign, isNumber, warn, createEmitter, isEmptyObject } from '@intlify/shared';
+import { CoreWarnCodes, CompileErrorCodes, createCompileError, DEFAULT_LOCALE, updateFallbackLocale, setFallbackContext, createCoreContext, clearDateTimeFormat, clearNumberFormat, setAdditionalMeta, getFallbackContext, NOT_REOSLVED, isTranslateFallbackWarn, isTranslateMissingWarn, parseTranslateArgs, translate, MISSING_RESOLVE_VALUE, parseDateTimeArgs, datetime, parseNumberArgs, number, fallbackWithLocaleChain, NUMBER_FORMAT_OPTIONS_KEYS, DATETIME_FORMAT_OPTIONS_KEYS, registerMessageCompiler, compileToFunction, registerMessageResolver, resolveValue, registerLocaleFallbacker, setDevToolsHook } from '@intlify/core-base';
+import { createVNode, Text, ref, computed, watch, getCurrentInstance, Fragment, h, effectScope, inject, onMounted, onUnmounted, shallowRef, onBeforeMount, isRef } from 'vue';
+import { setupDevtoolsPlugin } from '@vue/devtools-api';
+import { VueDevToolsLabels, VueDevToolsPlaceholders, VueDevToolsTimelineColors } from '@intlify/vue-devtools';
+
+/**
+ * Vue I18n Version
+ *
+ * @remarks
+ * Semver format. Same format as the package.json `version` field.
+ *
+ * @VueI18nGeneral
+ */
+const VERSION = '9.2.2';
+/**
+ * This is only called in esm-bundler builds.
+ * istanbul-ignore-next
+ */
+function initFeatureFlags() {
+    let needWarn = false;
+    if (typeof __VUE_I18N_FULL_INSTALL__ !== 'boolean') {
+        needWarn = true;
+        getGlobalThis().__VUE_I18N_FULL_INSTALL__ = true;
+    }
+    if (typeof __VUE_I18N_LEGACY_API__ !== 'boolean') {
+        needWarn = true;
+        getGlobalThis().__VUE_I18N_LEGACY_API__ = true;
+    }
+    if (typeof __INTLIFY_PROD_DEVTOOLS__ !== 'boolean') {
+        getGlobalThis().__INTLIFY_PROD_DEVTOOLS__ = false;
+    }
+    if ((process.env.NODE_ENV !== 'production') && needWarn) {
+        console.warn(`You are running the esm-bundler build of vue-i18n. It is recommended to ` +
+            `configure your bundler to explicitly replace feature flag globals ` +
+            `with boolean literals to get proper tree-shaking in the final bundle.`);
+    }
+}
+
+let code$1 = CoreWarnCodes.__EXTEND_POINT__;
+const inc$1 = () => ++code$1;
+const I18nWarnCodes = {
+    FALLBACK_TO_ROOT: code$1,
+    NOT_SUPPORTED_PRESERVE: inc$1(),
+    NOT_SUPPORTED_FORMATTER: inc$1(),
+    NOT_SUPPORTED_PRESERVE_DIRECTIVE: inc$1(),
+    NOT_SUPPORTED_GET_CHOICE_INDEX: inc$1(),
+    COMPONENT_NAME_LEGACY_COMPATIBLE: inc$1(),
+    NOT_FOUND_PARENT_SCOPE: inc$1() // 13
+};
+const warnMessages = {
+    [I18nWarnCodes.FALLBACK_TO_ROOT]: `Fall back to {type} '{key}' with root locale.`,
+    [I18nWarnCodes.NOT_SUPPORTED_PRESERVE]: `Not supported 'preserve'.`,
+    [I18nWarnCodes.NOT_SUPPORTED_FORMATTER]: `Not supported 'formatter'.`,
+    [I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE]: `Not supported 'preserveDirectiveContent'.`,
+    [I18nWarnCodes.NOT_SUPPORTED_GET_CHOICE_INDEX]: `Not supported 'getChoiceIndex'.`,
+    [I18nWarnCodes.COMPONENT_NAME_LEGACY_COMPATIBLE]: `Component name legacy compatible: '{name}' -> 'i18n'`,
+    [I18nWarnCodes.NOT_FOUND_PARENT_SCOPE]: `Not found parent scope. use the global scope.`
+};
+function getWarnMessage(code, ...args) {
+    return format(warnMessages[code], ...args);
+}
+
+let code = CompileErrorCodes.__EXTEND_POINT__;
+const inc = () => ++code;
+const I18nErrorCodes = {
+    // composer module errors
+    UNEXPECTED_RETURN_TYPE: code,
+    // legacy module errors
+    INVALID_ARGUMENT: inc(),
+    // i18n module errors
+    MUST_BE_CALL_SETUP_TOP: inc(),
+    NOT_INSLALLED: inc(),
+    NOT_AVAILABLE_IN_LEGACY_MODE: inc(),
+    // directive module errors
+    REQUIRED_VALUE: inc(),
+    INVALID_VALUE: inc(),
+    // vue-devtools errors
+    CANNOT_SETUP_VUE_DEVTOOLS_PLUGIN: inc(),
+    NOT_INSLALLED_WITH_PROVIDE: inc(),
+    // unexpected error
+    UNEXPECTED_ERROR: inc(),
+    // not compatible legacy vue-i18n constructor
+    NOT_COMPATIBLE_LEGACY_VUE_I18N: inc(),
+    // bridge support vue 2.x only
+    BRIDGE_SUPPORT_VUE_2_ONLY: inc(),
+    // need to define `i18n` option in `allowComposition: true` and `useScope: 'local' at `useI18n``
+    MUST_DEFINE_I18N_OPTION_IN_ALLOW_COMPOSITION: inc(),
+    // Not available Compostion API in Legacy API mode. Please make sure that the legacy API mode is working properly
+    NOT_AVAILABLE_COMPOSITION_IN_LEGACY: inc(),
+    // for enhancement
+    __EXTEND_POINT__: inc() // 29
+};
+function createI18nError(code, ...args) {
+    return createCompileError(code, null, (process.env.NODE_ENV !== 'production') ? { messages: errorMessages, args } : undefined);
+}
+const errorMessages = {
+    [I18nErrorCodes.UNEXPECTED_RETURN_TYPE]: 'Unexpected return type in composer',
+    [I18nErrorCodes.INVALID_ARGUMENT]: 'Invalid argument',
+    [I18nErrorCodes.MUST_BE_CALL_SETUP_TOP]: 'Must be called at the top of a `setup` function',
+    [I18nErrorCodes.NOT_INSLALLED]: 'Need to install with `app.use` function',
+    [I18nErrorCodes.UNEXPECTED_ERROR]: 'Unexpected error',
+    [I18nErrorCodes.NOT_AVAILABLE_IN_LEGACY_MODE]: 'Not available in legacy mode',
+    [I18nErrorCodes.REQUIRED_VALUE]: `Required in value: {0}`,
+    [I18nErrorCodes.INVALID_VALUE]: `Invalid value`,
+    [I18nErrorCodes.CANNOT_SETUP_VUE_DEVTOOLS_PLUGIN]: `Cannot setup vue-devtools plugin`,
+    [I18nErrorCodes.NOT_INSLALLED_WITH_PROVIDE]: 'Need to install with `provide` function',
+    [I18nErrorCodes.NOT_COMPATIBLE_LEGACY_VUE_I18N]: 'Not compatible legacy VueI18n.',
+    [I18nErrorCodes.BRIDGE_SUPPORT_VUE_2_ONLY]: 'vue-i18n-bridge support Vue 2.x only',
+    [I18nErrorCodes.MUST_DEFINE_I18N_OPTION_IN_ALLOW_COMPOSITION]: 'Must define ‘i18n’ option or custom block in Composition API with using local scope in Legacy API mode',
+    [I18nErrorCodes.NOT_AVAILABLE_COMPOSITION_IN_LEGACY]: 'Not available Compostion API in Legacy API mode. Please make sure that the legacy API mode is working properly'
+};
+
+const TransrateVNodeSymbol = 
+/* #__PURE__*/ makeSymbol('__transrateVNode');
+const DatetimePartsSymbol = /* #__PURE__*/ makeSymbol('__datetimeParts');
+const NumberPartsSymbol = /* #__PURE__*/ makeSymbol('__numberParts');
+const EnableEmitter = /* #__PURE__*/ makeSymbol('__enableEmitter');
+const DisableEmitter = /* #__PURE__*/ makeSymbol('__disableEmitter');
+const SetPluralRulesSymbol = makeSymbol('__setPluralRules');
+makeSymbol('__intlifyMeta');
+const InejctWithOption = /* #__PURE__*/ makeSymbol('__injectWithOption');
+const __VUE_I18N_BRIDGE__ =  '__VUE_I18N_BRIDGE__';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Transform flat json in obj to normal json in obj
+ */
+function handleFlatJson(obj) {
+    // check obj
+    if (!isObject(obj)) {
+        return obj;
+    }
+    for (const key in obj) {
+        // check key
+        if (!hasOwn(obj, key)) {
+            continue;
+        }
+        // handle for normal json
+        if (!key.includes('.')) {
+            // recursive process value if value is also a object
+            if (isObject(obj[key])) {
+                handleFlatJson(obj[key]);
+            }
+        }
+        // handle for flat json, transform to normal json
+        else {
+            // go to the last object
+            const subKeys = key.split('.');
+            const lastIndex = subKeys.length - 1;
+            let currentObj = obj;
+            for (let i = 0; i < lastIndex; i++) {
+                if (!(subKeys[i] in currentObj)) {
+                    currentObj[subKeys[i]] = {};
+                }
+                currentObj = currentObj[subKeys[i]];
+            }
+            // update last object value, delete old property
+            currentObj[subKeys[lastIndex]] = obj[key];
+            delete obj[key];
+            // recursive process value if value is also a object
+            if (isObject(currentObj[subKeys[lastIndex]])) {
+                handleFlatJson(currentObj[subKeys[lastIndex]]);
+            }
+        }
+    }
+    return obj;
+}
+function getLocaleMessages(locale, options) {
+    const { messages, __i18n, messageResolver, flatJson } = options;
+    // prettier-ignore
+    const ret = isPlainObject(messages)
+        ? messages
+        : isArray(__i18n)
+            ? {}
+            : { [locale]: {} };
+    // merge locale messages of i18n custom block
+    if (isArray(__i18n)) {
+        __i18n.forEach(custom => {
+            if ('locale' in custom && 'resource' in custom) {
+                const { locale, resource } = custom;
+                if (locale) {
+                    ret[locale] = ret[locale] || {};
+                    deepCopy(resource, ret[locale]);
+                }
+                else {
+                    deepCopy(resource, ret);
+                }
+            }
+            else {
+                isString(custom) && deepCopy(JSON.parse(custom), ret);
+            }
+        });
+    }
+    // handle messages for flat json
+    if (messageResolver == null && flatJson) {
+        for (const key in ret) {
+            if (hasOwn(ret, key)) {
+                handleFlatJson(ret[key]);
+            }
+        }
+    }
+    return ret;
+}
+const isNotObjectOrIsArray = (val) => !isObject(val) || isArray(val);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+function deepCopy(src, des) {
+    // src and des should both be objects, and non of then can be a array
+    if (isNotObjectOrIsArray(src) || isNotObjectOrIsArray(des)) {
+        throw createI18nError(I18nErrorCodes.INVALID_VALUE);
+    }
+    for (const key in src) {
+        if (hasOwn(src, key)) {
+            if (isNotObjectOrIsArray(src[key]) || isNotObjectOrIsArray(des[key])) {
+                // replace with src[key] when:
+                // src[key] or des[key] is not a object, or
+                // src[key] or des[key] is a array
+                des[key] = src[key];
+            }
+            else {
+                // src[key] and des[key] are both object, merge them
+                deepCopy(src[key], des[key]);
+            }
+        }
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getComponentOptions(instance) {
+    return instance.type ;
+}
+function adjustI18nResources(global, options, componentOptions // eslint-disable-line @typescript-eslint/no-explicit-any
+) {
+    let messages = isObject(options.messages) ? options.messages : {};
+    if ('__i18nGlobal' in componentOptions) {
+        messages = getLocaleMessages(global.locale.value, {
+            messages,
+            __i18n: componentOptions.__i18nGlobal
+        });
+    }
+    // merge locale messages
+    const locales = Object.keys(messages);
+    if (locales.length) {
+        locales.forEach(locale => {
+            global.mergeLocaleMessage(locale, messages[locale]);
+        });
+    }
+    {
+        // merge datetime formats
+        if (isObject(options.datetimeFormats)) {
+            const locales = Object.keys(options.datetimeFormats);
+            if (locales.length) {
+                locales.forEach(locale => {
+                    global.mergeDateTimeFormat(locale, options.datetimeFormats[locale]);
+                });
+            }
+        }
+        // merge number formats
+        if (isObject(options.numberFormats)) {
+            const locales = Object.keys(options.numberFormats);
+            if (locales.length) {
+                locales.forEach(locale => {
+                    global.mergeNumberFormat(locale, options.numberFormats[locale]);
+                });
+            }
+        }
+    }
+}
+function createTextNode(key) {
+    return createVNode(Text, null, key, 0)
+        ;
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// extend VNode interface
+const DEVTOOLS_META = '__INTLIFY_META__';
+let composerID = 0;
+function defineCoreMissingHandler(missing) {
+    return ((ctx, locale, key, type) => {
+        return missing(locale, key, getCurrentInstance() || undefined, type);
+    });
+}
+// for Intlify DevTools
+const getMetaInfo =  () => {
+    const instance = getCurrentInstance();
+    let meta = null; // eslint-disable-line @typescript-eslint/no-explicit-any
+    return instance && (meta = getComponentOptions(instance)[DEVTOOLS_META])
+        ? { [DEVTOOLS_META]: meta } // eslint-disable-line @typescript-eslint/no-explicit-any
+        : null;
+};
+/**
+ * Create composer interface factory
+ *
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+function createComposer(options = {}, VueI18nLegacy) {
+    const { __root } = options;
+    const _isGlobal = __root === undefined;
+    let _inheritLocale = isBoolean(options.inheritLocale)
+        ? options.inheritLocale
+        : true;
+    const _locale = ref(
+    // prettier-ignore
+    __root && _inheritLocale
+        ? __root.locale.value
+        : isString(options.locale)
+            ? options.locale
+            : DEFAULT_LOCALE);
+    const _fallbackLocale = ref(
+    // prettier-ignore
+    __root && _inheritLocale
+        ? __root.fallbackLocale.value
+        : isString(options.fallbackLocale) ||
+            isArray(options.fallbackLocale) ||
+            isPlainObject(options.fallbackLocale) ||
+            options.fallbackLocale === false
+            ? options.fallbackLocale
+            : _locale.value);
+    const _messages = ref(getLocaleMessages(_locale.value, options));
+    // prettier-ignore
+    const _datetimeFormats = ref(isPlainObject(options.datetimeFormats)
+            ? options.datetimeFormats
+            : { [_locale.value]: {} })
+        ;
+    // prettier-ignore
+    const _numberFormats = ref(isPlainObject(options.numberFormats)
+            ? options.numberFormats
+            : { [_locale.value]: {} })
+        ;
+    // warning suppress options
+    // prettier-ignore
+    let _missingWarn = __root
+        ? __root.missingWarn
+        : isBoolean(options.missingWarn) || isRegExp(options.missingWarn)
+            ? options.missingWarn
+            : true;
+    // prettier-ignore
+    let _fallbackWarn = __root
+        ? __root.fallbackWarn
+        : isBoolean(options.fallbackWarn) || isRegExp(options.fallbackWarn)
+            ? options.fallbackWarn
+            : true;
+    // prettier-ignore
+    let _fallbackRoot = __root
+        ? __root.fallbackRoot
+        : isBoolean(options.fallbackRoot)
+            ? options.fallbackRoot
+            : true;
+    // configure fall back to root
+    let _fallbackFormat = !!options.fallbackFormat;
+    // runtime missing
+    let _missing = isFunction(options.missing) ? options.missing : null;
+    let _runtimeMissing = isFunction(options.missing)
+        ? defineCoreMissingHandler(options.missing)
+        : null;
+    // postTranslation handler
+    let _postTranslation = isFunction(options.postTranslation)
+        ? options.postTranslation
+        : null;
+    // prettier-ignore
+    let _warnHtmlMessage = __root
+        ? __root.warnHtmlMessage
+        : isBoolean(options.warnHtmlMessage)
+            ? options.warnHtmlMessage
+            : true;
+    let _escapeParameter = !!options.escapeParameter;
+    // custom linked modifiers
+    // prettier-ignore
+    const _modifiers = __root
+        ? __root.modifiers
+        : isPlainObject(options.modifiers)
+            ? options.modifiers
+            : {};
+    // pluralRules
+    let _pluralRules = options.pluralRules || (__root && __root.pluralRules);
+    // runtime context
+    // eslint-disable-next-line prefer-const
+    let _context;
+    const getCoreContext = () => {
+        _isGlobal && setFallbackContext(null);
+        const ctxOptions = {
+            version: VERSION,
+            locale: _locale.value,
+            fallbackLocale: _fallbackLocale.value,
+            messages: _messages.value,
+            modifiers: _modifiers,
+            pluralRules: _pluralRules,
+            missing: _runtimeMissing === null ? undefined : _runtimeMissing,
+            missingWarn: _missingWarn,
+            fallbackWarn: _fallbackWarn,
+            fallbackFormat: _fallbackFormat,
+            unresolving: true,
+            postTranslation: _postTranslation === null ? undefined : _postTranslation,
+            warnHtmlMessage: _warnHtmlMessage,
+            escapeParameter: _escapeParameter,
+            messageResolver: options.messageResolver,
+            __meta: { framework: 'vue' }
+        };
+        {
+            ctxOptions.datetimeFormats = _datetimeFormats.value;
+            ctxOptions.numberFormats = _numberFormats.value;
+            ctxOptions.__datetimeFormatters = isPlainObject(_context)
+                ? _context.__datetimeFormatters
+                : undefined;
+            ctxOptions.__numberFormatters = isPlainObject(_context)
+                ? _context.__numberFormatters
+                : undefined;
+        }
+        if ((process.env.NODE_ENV !== 'production')) {
+            ctxOptions.__v_emitter = isPlainObject(_context)
+                ? _context.__v_emitter
+                : undefined;
+        }
+        const ctx = createCoreContext(ctxOptions);
+        _isGlobal && setFallbackContext(ctx);
+        return ctx;
+    };
+    _context = getCoreContext();
+    updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
+    // track reactivity
+    function trackReactivityValues() {
+        return [
+                _locale.value,
+                _fallbackLocale.value,
+                _messages.value,
+                _datetimeFormats.value,
+                _numberFormats.value
+            ]
+            ;
+    }
+    // locale
+    const locale = computed({
+        get: () => _locale.value,
+        set: val => {
+            _locale.value = val;
+            _context.locale = _locale.value;
+        }
+    });
+    // fallbackLocale
+    const fallbackLocale = computed({
+        get: () => _fallbackLocale.value,
+        set: val => {
+            _fallbackLocale.value = val;
+            _context.fallbackLocale = _fallbackLocale.value;
+            updateFallbackLocale(_context, _locale.value, val);
+        }
+    });
+    // messages
+    const messages = computed(() => _messages.value);
+    // datetimeFormats
+    const datetimeFormats = /* #__PURE__*/ computed(() => _datetimeFormats.value);
+    // numberFormats
+    const numberFormats = /* #__PURE__*/ computed(() => _numberFormats.value);
+    // getPostTranslationHandler
+    function getPostTranslationHandler() {
+        return isFunction(_postTranslation) ? _postTranslation : null;
+    }
+    // setPostTranslationHandler
+    function setPostTranslationHandler(handler) {
+        _postTranslation = handler;
+        _context.postTranslation = handler;
+    }
+    // getMissingHandler
+    function getMissingHandler() {
+        return _missing;
+    }
+    // setMissingHandler
+    function setMissingHandler(handler) {
+        if (handler !== null) {
+            _runtimeMissing = defineCoreMissingHandler(handler);
+        }
+        _missing = handler;
+        _context.missing = _runtimeMissing;
+    }
+    function isResolvedTranslateMessage(type, arg // eslint-disable-line @typescript-eslint/no-explicit-any
+    ) {
+        return type !== 'translate' || !arg.resolvedMessage;
+    }
+    const wrapWithDeps = (fn, argumentParser, warnType, fallbackSuccess, fallbackFail, successCondition) => {
+        trackReactivityValues(); // track reactive dependency
+        // NOTE: experimental !!
+        let ret;
+        if ((process.env.NODE_ENV !== 'production') || __INTLIFY_PROD_DEVTOOLS__) {
+            try {
+                setAdditionalMeta(getMetaInfo());
+                if (!_isGlobal) {
+                    _context.fallbackContext = __root
+                        ? getFallbackContext()
+                        : undefined;
+                }
+                ret = fn(_context);
+            }
+            finally {
+                setAdditionalMeta(null);
+                if (!_isGlobal) {
+                    _context.fallbackContext = undefined;
+                }
+            }
+        }
+        else {
+            ret = fn(_context);
+        }
+        if (isNumber(ret) && ret === NOT_REOSLVED) {
+            const [key, arg2] = argumentParser();
+            if ((process.env.NODE_ENV !== 'production') &&
+                __root &&
+                isString(key) &&
+                isResolvedTranslateMessage(warnType, arg2)) {
+                if (_fallbackRoot &&
+                    (isTranslateFallbackWarn(_fallbackWarn, key) ||
+                        isTranslateMissingWarn(_missingWarn, key))) {
+                    warn(getWarnMessage(I18nWarnCodes.FALLBACK_TO_ROOT, {
+                        key,
+                        type: warnType
+                    }));
+                }
+                // for vue-devtools timeline event
+                if ((process.env.NODE_ENV !== 'production')) {
+                    const { __v_emitter: emitter } = _context;
+                    if (emitter && _fallbackRoot) {
+                        emitter.emit("fallback" /* FALBACK */, {
+                            type: warnType,
+                            key,
+                            to: 'global',
+                            groupId: `${warnType}:${key}`
+                        });
+                    }
+                }
+            }
+            return __root && _fallbackRoot
+                ? fallbackSuccess(__root)
+                : fallbackFail(key);
+        }
+        else if (successCondition(ret)) {
+            return ret;
+        }
+        else {
+            /* istanbul ignore next */
+            throw createI18nError(I18nErrorCodes.UNEXPECTED_RETURN_TYPE);
+        }
+    };
+    // t
+    function t(...args) {
+        return wrapWithDeps(context => Reflect.apply(translate, null, [context, ...args]), () => parseTranslateArgs(...args), 'translate', root => Reflect.apply(root.t, root, [...args]), key => key, val => isString(val));
+    }
+    // rt
+    function rt(...args) {
+        const [arg1, arg2, arg3] = args;
+        if (arg3 && !isObject(arg3)) {
+            throw createI18nError(I18nErrorCodes.INVALID_ARGUMENT);
+        }
+        return t(...[arg1, arg2, assign({ resolvedMessage: true }, arg3 || {})]);
+    }
+    // d
+    function d(...args) {
+        return wrapWithDeps(context => Reflect.apply(datetime, null, [context, ...args]), () => parseDateTimeArgs(...args), 'datetime format', root => Reflect.apply(root.d, root, [...args]), () => MISSING_RESOLVE_VALUE, val => isString(val));
+    }
+    // n
+    function n(...args) {
+        return wrapWithDeps(context => Reflect.apply(number, null, [context, ...args]), () => parseNumberArgs(...args), 'number format', root => Reflect.apply(root.n, root, [...args]), () => MISSING_RESOLVE_VALUE, val => isString(val));
+    }
+    // for custom processor
+    function normalize(values) {
+        return values.map(val => isString(val) || isNumber(val) || isBoolean(val)
+            ? createTextNode(String(val))
+            : val);
+    }
+    const interpolate = (val) => val;
+    const processor = {
+        normalize,
+        interpolate,
+        type: 'vnode'
+    };
+    // transrateVNode, using for `i18n-t` component
+    function transrateVNode(...args) {
+        return wrapWithDeps(context => {
+            let ret;
+            const _context = context;
+            try {
+                _context.processor = processor;
+                ret = Reflect.apply(translate, null, [_context, ...args]);
+            }
+            finally {
+                _context.processor = null;
+            }
+            return ret;
+        }, () => parseTranslateArgs(...args), 'translate', 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        root => root[TransrateVNodeSymbol](...args), key => [createTextNode(key)], val => isArray(val));
+    }
+    // numberParts, using for `i18n-n` component
+    function numberParts(...args) {
+        return wrapWithDeps(context => Reflect.apply(number, null, [context, ...args]), () => parseNumberArgs(...args), 'number format', 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        root => root[NumberPartsSymbol](...args), () => [], val => isString(val) || isArray(val));
+    }
+    // datetimeParts, using for `i18n-d` component
+    function datetimeParts(...args) {
+        return wrapWithDeps(context => Reflect.apply(datetime, null, [context, ...args]), () => parseDateTimeArgs(...args), 'datetime format', 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        root => root[DatetimePartsSymbol](...args), () => [], val => isString(val) || isArray(val));
+    }
+    function setPluralRules(rules) {
+        _pluralRules = rules;
+        _context.pluralRules = _pluralRules;
+    }
+    // te
+    function te(key, locale) {
+        const targetLocale = isString(locale) ? locale : _locale.value;
+        const message = getLocaleMessage(targetLocale);
+        return _context.messageResolver(message, key) !== null;
+    }
+    function resolveMessages(key) {
+        let messages = null;
+        const locales = fallbackWithLocaleChain(_context, _fallbackLocale.value, _locale.value);
+        for (let i = 0; i < locales.length; i++) {
+            const targetLocaleMessages = _messages.value[locales[i]] || {};
+            const messageValue = _context.messageResolver(targetLocaleMessages, key);
+            if (messageValue != null) {
+                messages = messageValue;
+                break;
+            }
+        }
+        return messages;
+    }
+    // tm
+    function tm(key) {
+        const messages = resolveMessages(key);
+        // prettier-ignore
+        return messages != null
+            ? messages
+            : __root
+                ? __root.tm(key) || {}
+                : {};
+    }
+    // getLocaleMessage
+    function getLocaleMessage(locale) {
+        return (_messages.value[locale] || {});
+    }
+    // setLocaleMessage
+    function setLocaleMessage(locale, message) {
+        _messages.value[locale] = message;
+        _context.messages = _messages.value;
+    }
+    // mergeLocaleMessage
+    function mergeLocaleMessage(locale, message) {
+        _messages.value[locale] = _messages.value[locale] || {};
+        deepCopy(message, _messages.value[locale]);
+        _context.messages = _messages.value;
+    }
+    // getDateTimeFormat
+    function getDateTimeFormat(locale) {
+        return _datetimeFormats.value[locale] || {};
+    }
+    // setDateTimeFormat
+    function setDateTimeFormat(locale, format) {
+        _datetimeFormats.value[locale] = format;
+        _context.datetimeFormats = _datetimeFormats.value;
+        clearDateTimeFormat(_context, locale, format);
+    }
+    // mergeDateTimeFormat
+    function mergeDateTimeFormat(locale, format) {
+        _datetimeFormats.value[locale] = assign(_datetimeFormats.value[locale] || {}, format);
+        _context.datetimeFormats = _datetimeFormats.value;
+        clearDateTimeFormat(_context, locale, format);
+    }
+    // getNumberFormat
+    function getNumberFormat(locale) {
+        return _numberFormats.value[locale] || {};
+    }
+    // setNumberFormat
+    function setNumberFormat(locale, format) {
+        _numberFormats.value[locale] = format;
+        _context.numberFormats = _numberFormats.value;
+        clearNumberFormat(_context, locale, format);
+    }
+    // mergeNumberFormat
+    function mergeNumberFormat(locale, format) {
+        _numberFormats.value[locale] = assign(_numberFormats.value[locale] || {}, format);
+        _context.numberFormats = _numberFormats.value;
+        clearNumberFormat(_context, locale, format);
+    }
+    // for debug
+    composerID++;
+    // watch root locale & fallbackLocale
+    if (__root && inBrowser) {
+        watch(__root.locale, (val) => {
+            if (_inheritLocale) {
+                _locale.value = val;
+                _context.locale = val;
+                updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
+            }
+        });
+        watch(__root.fallbackLocale, (val) => {
+            if (_inheritLocale) {
+                _fallbackLocale.value = val;
+                _context.fallbackLocale = val;
+                updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
+            }
+        });
+    }
+    // define basic composition API!
+    const composer = {
+        id: composerID,
+        locale,
+        fallbackLocale,
+        get inheritLocale() {
+            return _inheritLocale;
+        },
+        set inheritLocale(val) {
+            _inheritLocale = val;
+            if (val && __root) {
+                _locale.value = __root.locale.value;
+                _fallbackLocale.value = __root.fallbackLocale.value;
+                updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
+            }
+        },
+        get availableLocales() {
+            return Object.keys(_messages.value).sort();
+        },
+        messages,
+        get modifiers() {
+            return _modifiers;
+        },
+        get pluralRules() {
+            return _pluralRules || {};
+        },
+        get isGlobal() {
+            return _isGlobal;
+        },
+        get missingWarn() {
+            return _missingWarn;
+        },
+        set missingWarn(val) {
+            _missingWarn = val;
+            _context.missingWarn = _missingWarn;
+        },
+        get fallbackWarn() {
+            return _fallbackWarn;
+        },
+        set fallbackWarn(val) {
+            _fallbackWarn = val;
+            _context.fallbackWarn = _fallbackWarn;
+        },
+        get fallbackRoot() {
+            return _fallbackRoot;
+        },
+        set fallbackRoot(val) {
+            _fallbackRoot = val;
+        },
+        get fallbackFormat() {
+            return _fallbackFormat;
+        },
+        set fallbackFormat(val) {
+            _fallbackFormat = val;
+            _context.fallbackFormat = _fallbackFormat;
+        },
+        get warnHtmlMessage() {
+            return _warnHtmlMessage;
+        },
+        set warnHtmlMessage(val) {
+            _warnHtmlMessage = val;
+            _context.warnHtmlMessage = val;
+        },
+        get escapeParameter() {
+            return _escapeParameter;
+        },
+        set escapeParameter(val) {
+            _escapeParameter = val;
+            _context.escapeParameter = val;
+        },
+        t,
+        getLocaleMessage,
+        setLocaleMessage,
+        mergeLocaleMessage,
+        getPostTranslationHandler,
+        setPostTranslationHandler,
+        getMissingHandler,
+        setMissingHandler,
+        [SetPluralRulesSymbol]: setPluralRules
+    };
+    {
+        composer.datetimeFormats = datetimeFormats;
+        composer.numberFormats = numberFormats;
+        composer.rt = rt;
+        composer.te = te;
+        composer.tm = tm;
+        composer.d = d;
+        composer.n = n;
+        composer.getDateTimeFormat = getDateTimeFormat;
+        composer.setDateTimeFormat = setDateTimeFormat;
+        composer.mergeDateTimeFormat = mergeDateTimeFormat;
+        composer.getNumberFormat = getNumberFormat;
+        composer.setNumberFormat = setNumberFormat;
+        composer.mergeNumberFormat = mergeNumberFormat;
+        composer[InejctWithOption] = options.__injectWithOption;
+        composer[TransrateVNodeSymbol] = transrateVNode;
+        composer[DatetimePartsSymbol] = datetimeParts;
+        composer[NumberPartsSymbol] = numberParts;
+    }
+    // for vue-devtools timeline event
+    if ((process.env.NODE_ENV !== 'production')) {
+        composer[EnableEmitter] = (emitter) => {
+            _context.__v_emitter = emitter;
+        };
+        composer[DisableEmitter] = () => {
+            _context.__v_emitter = undefined;
+        };
+    }
+    return composer;
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Convert to I18n Composer Options from VueI18n Options
+ *
+ * @internal
+ */
+function convertComposerOptions(options) {
+    const locale = isString(options.locale) ? options.locale : DEFAULT_LOCALE;
+    const fallbackLocale = isString(options.fallbackLocale) ||
+        isArray(options.fallbackLocale) ||
+        isPlainObject(options.fallbackLocale) ||
+        options.fallbackLocale === false
+        ? options.fallbackLocale
+        : locale;
+    const missing = isFunction(options.missing) ? options.missing : undefined;
+    const missingWarn = isBoolean(options.silentTranslationWarn) ||
+        isRegExp(options.silentTranslationWarn)
+        ? !options.silentTranslationWarn
+        : true;
+    const fallbackWarn = isBoolean(options.silentFallbackWarn) ||
+        isRegExp(options.silentFallbackWarn)
+        ? !options.silentFallbackWarn
+        : true;
+    const fallbackRoot = isBoolean(options.fallbackRoot)
+        ? options.fallbackRoot
+        : true;
+    const fallbackFormat = !!options.formatFallbackMessages;
+    const modifiers = isPlainObject(options.modifiers) ? options.modifiers : {};
+    const pluralizationRules = options.pluralizationRules;
+    const postTranslation = isFunction(options.postTranslation)
+        ? options.postTranslation
+        : undefined;
+    const warnHtmlMessage = isString(options.warnHtmlInMessage)
+        ? options.warnHtmlInMessage !== 'off'
+        : true;
+    const escapeParameter = !!options.escapeParameterHtml;
+    const inheritLocale = isBoolean(options.sync) ? options.sync : true;
+    if ((process.env.NODE_ENV !== 'production') && options.formatter) {
+        warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_FORMATTER));
+    }
+    if ((process.env.NODE_ENV !== 'production') && options.preserveDirectiveContent) {
+        warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE));
+    }
+    let messages = options.messages;
+    if (isPlainObject(options.sharedMessages)) {
+        const sharedMessages = options.sharedMessages;
+        const locales = Object.keys(sharedMessages);
+        messages = locales.reduce((messages, locale) => {
+            const message = messages[locale] || (messages[locale] = {});
+            assign(message, sharedMessages[locale]);
+            return messages;
+        }, (messages || {}));
+    }
+    const { __i18n, __root, __injectWithOption } = options;
+    const datetimeFormats = options.datetimeFormats;
+    const numberFormats = options.numberFormats;
+    const flatJson = options.flatJson;
+    return {
+        locale,
+        fallbackLocale,
+        messages,
+        flatJson,
+        datetimeFormats,
+        numberFormats,
+        missing,
+        missingWarn,
+        fallbackWarn,
+        fallbackRoot,
+        fallbackFormat,
+        modifiers,
+        pluralRules: pluralizationRules,
+        postTranslation,
+        warnHtmlMessage,
+        escapeParameter,
+        messageResolver: options.messageResolver,
+        inheritLocale,
+        __i18n,
+        __root,
+        __injectWithOption
+    };
+}
+/**
+ * create VueI18n interface factory
+ *
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+function createVueI18n(options = {}, VueI18nLegacy) {
+    {
+        const composer = createComposer(convertComposerOptions(options));
+        // defines VueI18n
+        const vueI18n = {
+            // id
+            id: composer.id,
+            // locale
+            get locale() {
+                return composer.locale.value;
+            },
+            set locale(val) {
+                composer.locale.value = val;
+            },
+            // fallbackLocale
+            get fallbackLocale() {
+                return composer.fallbackLocale.value;
+            },
+            set fallbackLocale(val) {
+                composer.fallbackLocale.value = val;
+            },
+            // messages
+            get messages() {
+                return composer.messages.value;
+            },
+            // datetimeFormats
+            get datetimeFormats() {
+                return composer.datetimeFormats.value;
+            },
+            // numberFormats
+            get numberFormats() {
+                return composer.numberFormats.value;
+            },
+            // availableLocales
+            get availableLocales() {
+                return composer.availableLocales;
+            },
+            // formatter
+            get formatter() {
+                (process.env.NODE_ENV !== 'production') && warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_FORMATTER));
+                // dummy
+                return {
+                    interpolate() {
+                        return [];
+                    }
+                };
+            },
+            set formatter(val) {
+                (process.env.NODE_ENV !== 'production') && warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_FORMATTER));
+            },
+            // missing
+            get missing() {
+                return composer.getMissingHandler();
+            },
+            set missing(handler) {
+                composer.setMissingHandler(handler);
+            },
+            // silentTranslationWarn
+            get silentTranslationWarn() {
+                return isBoolean(composer.missingWarn)
+                    ? !composer.missingWarn
+                    : composer.missingWarn;
+            },
+            set silentTranslationWarn(val) {
+                composer.missingWarn = isBoolean(val) ? !val : val;
+            },
+            // silentFallbackWarn
+            get silentFallbackWarn() {
+                return isBoolean(composer.fallbackWarn)
+                    ? !composer.fallbackWarn
+                    : composer.fallbackWarn;
+            },
+            set silentFallbackWarn(val) {
+                composer.fallbackWarn = isBoolean(val) ? !val : val;
+            },
+            // modifiers
+            get modifiers() {
+                return composer.modifiers;
+            },
+            // formatFallbackMessages
+            get formatFallbackMessages() {
+                return composer.fallbackFormat;
+            },
+            set formatFallbackMessages(val) {
+                composer.fallbackFormat = val;
+            },
+            // postTranslation
+            get postTranslation() {
+                return composer.getPostTranslationHandler();
+            },
+            set postTranslation(handler) {
+                composer.setPostTranslationHandler(handler);
+            },
+            // sync
+            get sync() {
+                return composer.inheritLocale;
+            },
+            set sync(val) {
+                composer.inheritLocale = val;
+            },
+            // warnInHtmlMessage
+            get warnHtmlInMessage() {
+                return composer.warnHtmlMessage ? 'warn' : 'off';
+            },
+            set warnHtmlInMessage(val) {
+                composer.warnHtmlMessage = val !== 'off';
+            },
+            // escapeParameterHtml
+            get escapeParameterHtml() {
+                return composer.escapeParameter;
+            },
+            set escapeParameterHtml(val) {
+                composer.escapeParameter = val;
+            },
+            // preserveDirectiveContent
+            get preserveDirectiveContent() {
+                (process.env.NODE_ENV !== 'production') &&
+                    warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE));
+                return true;
+            },
+            set preserveDirectiveContent(val) {
+                (process.env.NODE_ENV !== 'production') &&
+                    warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE));
+            },
+            // pluralizationRules
+            get pluralizationRules() {
+                return composer.pluralRules || {};
+            },
+            // for internal
+            __composer: composer,
+            // t
+            t(...args) {
+                const [arg1, arg2, arg3] = args;
+                const options = {};
+                let list = null;
+                let named = null;
+                if (!isString(arg1)) {
+                    throw createI18nError(I18nErrorCodes.INVALID_ARGUMENT);
+                }
+                const key = arg1;
+                if (isString(arg2)) {
+                    options.locale = arg2;
+                }
+                else if (isArray(arg2)) {
+                    list = arg2;
+                }
+                else if (isPlainObject(arg2)) {
+                    named = arg2;
+                }
+                if (isArray(arg3)) {
+                    list = arg3;
+                }
+                else if (isPlainObject(arg3)) {
+                    named = arg3;
+                }
+                // return composer.t(key, (list || named || {}) as any, options)
+                return Reflect.apply(composer.t, composer, [
+                    key,
+                    (list || named || {}),
+                    options
+                ]);
+            },
+            rt(...args) {
+                return Reflect.apply(composer.rt, composer, [...args]);
+            },
+            // tc
+            tc(...args) {
+                const [arg1, arg2, arg3] = args;
+                const options = { plural: 1 };
+                let list = null;
+                let named = null;
+                if (!isString(arg1)) {
+                    throw createI18nError(I18nErrorCodes.INVALID_ARGUMENT);
+                }
+                const key = arg1;
+                if (isString(arg2)) {
+                    options.locale = arg2;
+                }
+                else if (isNumber(arg2)) {
+                    options.plural = arg2;
+                }
+                else if (isArray(arg2)) {
+                    list = arg2;
+                }
+                else if (isPlainObject(arg2)) {
+                    named = arg2;
+                }
+                if (isString(arg3)) {
+                    options.locale = arg3;
+                }
+                else if (isArray(arg3)) {
+                    list = arg3;
+                }
+                else if (isPlainObject(arg3)) {
+                    named = arg3;
+                }
+                // return composer.t(key, (list || named || {}) as any, options)
+                return Reflect.apply(composer.t, composer, [
+                    key,
+                    (list || named || {}),
+                    options
+                ]);
+            },
+            // te
+            te(key, locale) {
+                return composer.te(key, locale);
+            },
+            // tm
+            tm(key) {
+                return composer.tm(key);
+            },
+            // getLocaleMessage
+            getLocaleMessage(locale) {
+                return composer.getLocaleMessage(locale);
+            },
+            // setLocaleMessage
+            setLocaleMessage(locale, message) {
+                composer.setLocaleMessage(locale, message);
+            },
+            // mergeLocaleMessage
+            mergeLocaleMessage(locale, message) {
+                composer.mergeLocaleMessage(locale, message);
+            },
+            // d
+            d(...args) {
+                return Reflect.apply(composer.d, composer, [...args]);
+            },
+            // getDateTimeFormat
+            getDateTimeFormat(locale) {
+                return composer.getDateTimeFormat(locale);
+            },
+            // setDateTimeFormat
+            setDateTimeFormat(locale, format) {
+                composer.setDateTimeFormat(locale, format);
+            },
+            // mergeDateTimeFormat
+            mergeDateTimeFormat(locale, format) {
+                composer.mergeDateTimeFormat(locale, format);
+            },
+            // n
+            n(...args) {
+                return Reflect.apply(composer.n, composer, [...args]);
+            },
+            // getNumberFormat
+            getNumberFormat(locale) {
+                return composer.getNumberFormat(locale);
+            },
+            // setNumberFormat
+            setNumberFormat(locale, format) {
+                composer.setNumberFormat(locale, format);
+            },
+            // mergeNumberFormat
+            mergeNumberFormat(locale, format) {
+                composer.mergeNumberFormat(locale, format);
+            },
+            // getChoiceIndex
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            getChoiceIndex(choice, choicesLength) {
+                (process.env.NODE_ENV !== 'production') &&
+                    warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_GET_CHOICE_INDEX));
+                return -1;
+            },
+            // for internal
+            __onComponentInstanceCreated(target) {
+                const { componentInstanceCreatedListener } = options;
+                if (componentInstanceCreatedListener) {
+                    componentInstanceCreatedListener(target, vueI18n);
+                }
+            }
+        };
+        // for vue-devtools timeline event
+        if ((process.env.NODE_ENV !== 'production')) {
+            vueI18n.__enableEmitter = (emitter) => {
+                const __composer = composer;
+                __composer[EnableEmitter] && __composer[EnableEmitter](emitter);
+            };
+            vueI18n.__disableEmitter = () => {
+                const __composer = composer;
+                __composer[DisableEmitter] && __composer[DisableEmitter]();
+            };
+        }
+        return vueI18n;
+    }
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+const baseFormatProps = {
+    tag: {
+        type: [String, Object]
+    },
+    locale: {
+        type: String
+    },
+    scope: {
+        type: String,
+        // NOTE: avoid https://github.com/microsoft/rushstack/issues/1050
+        validator: (val /* ComponetI18nScope */) => val === 'parent' || val === 'global',
+        default: 'parent' /* ComponetI18nScope */
+    },
+    i18n: {
+        type: Object
+    }
+};
+
+function getInterpolateArg(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+{ slots }, // SetupContext,
+keys) {
+    if (keys.length === 1 && keys[0] === 'default') {
+        // default slot with list
+        const ret = slots.default ? slots.default() : [];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return ret.reduce((slot, current) => {
+            return (slot = [
+                ...slot,
+                ...(isArray(current.children) ? current.children : [current])
+            ]);
+        }, []);
+    }
+    else {
+        // named slots
+        return keys.reduce((arg, key) => {
+            const slot = slots[key];
+            if (slot) {
+                arg[key] = slot();
+            }
+            return arg;
+        }, {});
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getFragmentableTag(tag) {
+    return Fragment ;
+}
+
+/**
+ * Translation Component
+ *
+ * @remarks
+ * See the following items for property about details
+ *
+ * @VueI18nSee [TranslationProps](component#translationprops)
+ * @VueI18nSee [BaseFormatProps](component#baseformatprops)
+ * @VueI18nSee [Component Interpolation](../guide/advanced/component)
+ *
+ * @example
+ * ```html
+ * <div id="app">
+ *   <!-- ... -->
+ *   <i18n path="term" tag="label" for="tos">
+ *     <a :href="url" target="_blank">{{ $t('tos') }}</a>
+ *   </i18n>
+ *   <!-- ... -->
+ * </div>
+ * ```
+ * ```js
+ * import { createApp } from 'vue'
+ * import { createI18n } from 'vue-i18n'
+ *
+ * const messages = {
+ *   en: {
+ *     tos: 'Term of Service',
+ *     term: 'I accept xxx {0}.'
+ *   },
+ *   ja: {
+ *     tos: '利用規約',
+ *     term: '私は xxx の{0}に同意します。'
+ *   }
+ * }
+ *
+ * const i18n = createI18n({
+ *   locale: 'en',
+ *   messages
+ * })
+ *
+ * const app = createApp({
+ *   data: {
+ *     url: '/term'
+ *   }
+ * }).use(i18n).mount('#app')
+ * ```
+ *
+ * @VueI18nComponent
+ */
+const Translation =  /* defineComponent */ {
+    /* eslint-disable */
+    name: 'i18n-t',
+    props: assign({
+        keypath: {
+            type: String,
+            required: true
+        },
+        plural: {
+            type: [Number, String],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            validator: (val) => isNumber(val) || !isNaN(val)
+        }
+    }, baseFormatProps),
+    /* eslint-enable */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    setup(props, context) {
+        const { slots, attrs } = context;
+        // NOTE: avoid https://github.com/microsoft/rushstack/issues/1050
+        const i18n = props.i18n ||
+            useI18n({
+                useScope: props.scope,
+                __useComponent: true
+            });
+        return () => {
+            const keys = Object.keys(slots).filter(key => key !== '_');
+            const options = {};
+            if (props.locale) {
+                options.locale = props.locale;
+            }
+            if (props.plural !== undefined) {
+                options.plural = isString(props.plural) ? +props.plural : props.plural;
+            }
+            const arg = getInterpolateArg(context, keys);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const children = i18n[TransrateVNodeSymbol](props.keypath, arg, options);
+            const assignedAttrs = assign({}, attrs);
+            const tag = isString(props.tag) || isObject(props.tag)
+                ? props.tag
+                : getFragmentableTag();
+            return h(tag, assignedAttrs, children);
+        };
+    }
+};
+
+function isVNode(target) {
+    return isArray(target) && !isString(target[0]);
+}
+function renderFormatter(props, context, slotKeys, partFormatter) {
+    const { slots, attrs } = context;
+    return () => {
+        const options = { part: true };
+        let overrides = {};
+        if (props.locale) {
+            options.locale = props.locale;
+        }
+        if (isString(props.format)) {
+            options.key = props.format;
+        }
+        else if (isObject(props.format)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (isString(props.format.key)) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                options.key = props.format.key;
+            }
+            // Filter out number format options only
+            overrides = Object.keys(props.format).reduce((options, prop) => {
+                return slotKeys.includes(prop)
+                    ? assign({}, options, { [prop]: props.format[prop] }) // eslint-disable-line @typescript-eslint/no-explicit-any
+                    : options;
+            }, {});
+        }
+        const parts = partFormatter(...[props.value, options, overrides]);
+        let children = [options.key];
+        if (isArray(parts)) {
+            children = parts.map((part, index) => {
+                const slot = slots[part.type];
+                const node = slot
+                    ? slot({ [part.type]: part.value, index, parts })
+                    : [part.value];
+                if (isVNode(node)) {
+                    node[0].key = `${part.type}-${index}`;
+                }
+                return node;
+            });
+        }
+        else if (isString(parts)) {
+            children = [parts];
+        }
+        const assignedAttrs = assign({}, attrs);
+        const tag = isString(props.tag) || isObject(props.tag)
+            ? props.tag
+            : getFragmentableTag();
+        return h(tag, assignedAttrs, children);
+    };
+}
+
+/**
+ * Number Format Component
+ *
+ * @remarks
+ * See the following items for property about details
+ *
+ * @VueI18nSee [FormattableProps](component#formattableprops)
+ * @VueI18nSee [BaseFormatProps](component#baseformatprops)
+ * @VueI18nSee [Custom Formatting](../guide/essentials/number#custom-formatting)
+ *
+ * @VueI18nDanger
+ * Not supported IE, due to no support `Intl.NumberFormat#formatToParts` in [IE](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/formatToParts)
+ *
+ * If you want to use it, you need to use [polyfill](https://github.com/formatjs/formatjs/tree/main/packages/intl-numberformat)
+ *
+ * @VueI18nComponent
+ */
+const NumberFormat =  /* defineComponent */ {
+    /* eslint-disable */
+    name: 'i18n-n',
+    props: assign({
+        value: {
+            type: Number,
+            required: true
+        },
+        format: {
+            type: [String, Object]
+        }
+    }, baseFormatProps),
+    /* eslint-enable */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    setup(props, context) {
+        const i18n = props.i18n ||
+            useI18n({ useScope: 'parent', __useComponent: true });
+        return renderFormatter(props, context, NUMBER_FORMAT_OPTIONS_KEYS, (...args) => 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        i18n[NumberPartsSymbol](...args));
+    }
+};
+
+/**
+ * Datetime Format Component
+ *
+ * @remarks
+ * See the following items for property about details
+ *
+ * @VueI18nSee [FormattableProps](component#formattableprops)
+ * @VueI18nSee [BaseFormatProps](component#baseformatprops)
+ * @VueI18nSee [Custom Formatting](../guide/essentials/datetime#custom-formatting)
+ *
+ * @VueI18nDanger
+ * Not supported IE, due to no support `Intl.DateTimeFormat#formatToParts` in [IE](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatToParts)
+ *
+ * If you want to use it, you need to use [polyfill](https://github.com/formatjs/formatjs/tree/main/packages/intl-datetimeformat)
+ *
+ * @VueI18nComponent
+ */
+const DatetimeFormat =  /*defineComponent */ {
+    /* eslint-disable */
+    name: 'i18n-d',
+    props: assign({
+        value: {
+            type: [Number, Date],
+            required: true
+        },
+        format: {
+            type: [String, Object]
+        }
+    }, baseFormatProps),
+    /* eslint-enable */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    setup(props, context) {
+        const i18n = props.i18n ||
+            useI18n({ useScope: 'parent', __useComponent: true });
+        return renderFormatter(props, context, DATETIME_FORMAT_OPTIONS_KEYS, (...args) => 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        i18n[DatetimePartsSymbol](...args));
+    }
+};
+
+function getComposer$2(i18n, instance) {
+    const i18nInternal = i18n;
+    if (i18n.mode === 'composition') {
+        return (i18nInternal.__getInstance(instance) || i18n.global);
+    }
+    else {
+        const vueI18n = i18nInternal.__getInstance(instance);
+        return vueI18n != null
+            ? vueI18n.__composer
+            : i18n.global.__composer;
+    }
+}
+function vTDirective(i18n) {
+    const _process = (binding) => {
+        const { instance, modifiers, value } = binding;
+        /* istanbul ignore if */
+        if (!instance || !instance.$) {
+            throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+        }
+        const composer = getComposer$2(i18n, instance.$);
+        if ((process.env.NODE_ENV !== 'production') && modifiers.preserve) {
+            warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE));
+        }
+        const parsedValue = parseValue(value);
+        return [
+            Reflect.apply(composer.t, composer, [...makeParams(parsedValue)]),
+            composer
+        ];
+    };
+    const register = (el, binding) => {
+        const [textContent, composer] = _process(binding);
+        if (inBrowser && i18n.global === composer) {
+            // global scope only
+            el.__i18nWatcher = watch(composer.locale, () => {
+                binding.instance && binding.instance.$forceUpdate();
+            });
+        }
+        el.__composer = composer;
+        el.textContent = textContent;
+    };
+    const unregister = (el) => {
+        if (inBrowser && el.__i18nWatcher) {
+            el.__i18nWatcher();
+            el.__i18nWatcher = undefined;
+            delete el.__i18nWatcher;
+        }
+        if (el.__composer) {
+            el.__composer = undefined;
+            delete el.__composer;
+        }
+    };
+    const update = (el, { value }) => {
+        if (el.__composer) {
+            const composer = el.__composer;
+            const parsedValue = parseValue(value);
+            el.textContent = Reflect.apply(composer.t, composer, [
+                ...makeParams(parsedValue)
+            ]);
+        }
+    };
+    const getSSRProps = (binding) => {
+        const [textContent] = _process(binding);
+        return { textContent };
+    };
+    return {
+        created: register,
+        unmounted: unregister,
+        beforeUpdate: update,
+        getSSRProps
+    };
+}
+function parseValue(value) {
+    if (isString(value)) {
+        return { path: value };
+    }
+    else if (isPlainObject(value)) {
+        if (!('path' in value)) {
+            throw createI18nError(I18nErrorCodes.REQUIRED_VALUE, 'path');
+        }
+        return value;
+    }
+    else {
+        throw createI18nError(I18nErrorCodes.INVALID_VALUE);
+    }
+}
+function makeParams(value) {
+    const { path, locale, args, choice, plural } = value;
+    const options = {};
+    const named = args || {};
+    if (isString(locale)) {
+        options.locale = locale;
+    }
+    if (isNumber(choice)) {
+        options.plural = choice;
+    }
+    if (isNumber(plural)) {
+        options.plural = plural;
+    }
+    return [path, named, options];
+}
+
+function apply(app, i18n, ...options) {
+    const pluginOptions = isPlainObject(options[0])
+        ? options[0]
+        : {};
+    const useI18nComponentName = !!pluginOptions.useI18nComponentName;
+    const globalInstall = isBoolean(pluginOptions.globalInstall)
+        ? pluginOptions.globalInstall
+        : true;
+    if ((process.env.NODE_ENV !== 'production') && globalInstall && useI18nComponentName) {
+        warn(getWarnMessage(I18nWarnCodes.COMPONENT_NAME_LEGACY_COMPATIBLE, {
+            name: Translation.name
+        }));
+    }
+    if (globalInstall) {
+        // install components
+        app.component(!useI18nComponentName ? Translation.name : 'i18n', Translation);
+        app.component(NumberFormat.name, NumberFormat);
+        app.component(DatetimeFormat.name, DatetimeFormat);
+    }
+    // install directive
+    {
+        app.directive('t', vTDirective(i18n));
+    }
+}
+
+const VUE_I18N_COMPONENT_TYPES = 'vue-i18n: composer properties';
+let devtoolsApi;
+async function enableDevTools(app, i18n) {
+    return new Promise((resolve, reject) => {
+        try {
+            setupDevtoolsPlugin({
+                id: "vue-devtools-plugin-vue-i18n" /* PLUGIN */,
+                label: VueDevToolsLabels["vue-devtools-plugin-vue-i18n" /* PLUGIN */],
+                packageName: 'vue-i18n',
+                homepage: 'https://vue-i18n.intlify.dev',
+                logo: 'https://vue-i18n.intlify.dev/vue-i18n-devtools-logo.png',
+                componentStateTypes: [VUE_I18N_COMPONENT_TYPES],
+                app: app // eslint-disable-line @typescript-eslint/no-explicit-any
+            }, api => {
+                devtoolsApi = api;
+                api.on.visitComponentTree(({ componentInstance, treeNode }) => {
+                    updateComponentTreeTags(componentInstance, treeNode, i18n);
+                });
+                api.on.inspectComponent(({ componentInstance, instanceData }) => {
+                    if (componentInstance.vnode.el &&
+                        componentInstance.vnode.el.__VUE_I18N__ &&
+                        instanceData) {
+                        if (i18n.mode === 'legacy') {
+                            // ignore global scope on legacy mode
+                            if (componentInstance.vnode.el.__VUE_I18N__ !==
+                                i18n.global.__composer) {
+                                inspectComposer(instanceData, componentInstance.vnode.el.__VUE_I18N__);
+                            }
+                        }
+                        else {
+                            inspectComposer(instanceData, componentInstance.vnode.el.__VUE_I18N__);
+                        }
+                    }
+                });
+                api.addInspector({
+                    id: "vue-i18n-resource-inspector" /* CUSTOM_INSPECTOR */,
+                    label: VueDevToolsLabels["vue-i18n-resource-inspector" /* CUSTOM_INSPECTOR */],
+                    icon: 'language',
+                    treeFilterPlaceholder: VueDevToolsPlaceholders["vue-i18n-resource-inspector" /* CUSTOM_INSPECTOR */]
+                });
+                api.on.getInspectorTree(payload => {
+                    if (payload.app === app &&
+                        payload.inspectorId === "vue-i18n-resource-inspector" /* CUSTOM_INSPECTOR */) {
+                        registerScope(payload, i18n);
+                    }
+                });
+                const roots = new Map();
+                api.on.getInspectorState(async (payload) => {
+                    if (payload.app === app &&
+                        payload.inspectorId === "vue-i18n-resource-inspector" /* CUSTOM_INSPECTOR */) {
+                        api.unhighlightElement();
+                        inspectScope(payload, i18n);
+                        if (payload.nodeId === 'global') {
+                            if (!roots.has(payload.app)) {
+                                const [root] = await api.getComponentInstances(payload.app);
+                                roots.set(payload.app, root);
+                            }
+                            api.highlightElement(roots.get(payload.app));
+                        }
+                        else {
+                            const instance = getComponentInstance(payload.nodeId, i18n);
+                            instance && api.highlightElement(instance);
+                        }
+                    }
+                });
+                api.on.editInspectorState(payload => {
+                    if (payload.app === app &&
+                        payload.inspectorId === "vue-i18n-resource-inspector" /* CUSTOM_INSPECTOR */) {
+                        editScope(payload, i18n);
+                    }
+                });
+                api.addTimelineLayer({
+                    id: "vue-i18n-timeline" /* TIMELINE */,
+                    label: VueDevToolsLabels["vue-i18n-timeline" /* TIMELINE */],
+                    color: VueDevToolsTimelineColors["vue-i18n-timeline" /* TIMELINE */]
+                });
+                resolve(true);
+            });
+        }
+        catch (e) {
+            console.error(e);
+            reject(false);
+        }
+    });
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getI18nScopeLable(instance) {
+    return (instance.type.name ||
+        instance.type.displayName ||
+        instance.type.__file ||
+        'Anonymous');
+}
+function updateComponentTreeTags(instance, // eslint-disable-line @typescript-eslint/no-explicit-any
+treeNode, i18n) {
+    // prettier-ignore
+    const global = i18n.mode === 'composition'
+        ? i18n.global
+        : i18n.global.__composer;
+    if (instance && instance.vnode.el && instance.vnode.el.__VUE_I18N__) {
+        // add custom tags local scope only
+        if (instance.vnode.el.__VUE_I18N__ !== global) {
+            const tag = {
+                label: `i18n (${getI18nScopeLable(instance)} Scope)`,
+                textColor: 0x000000,
+                backgroundColor: 0xffcd19
+            };
+            treeNode.tags.push(tag);
+        }
+    }
+}
+function inspectComposer(instanceData, composer) {
+    const type = VUE_I18N_COMPONENT_TYPES;
+    instanceData.state.push({
+        type,
+        key: 'locale',
+        editable: true,
+        value: composer.locale.value
+    });
+    instanceData.state.push({
+        type,
+        key: 'availableLocales',
+        editable: false,
+        value: composer.availableLocales
+    });
+    instanceData.state.push({
+        type,
+        key: 'fallbackLocale',
+        editable: true,
+        value: composer.fallbackLocale.value
+    });
+    instanceData.state.push({
+        type,
+        key: 'inheritLocale',
+        editable: true,
+        value: composer.inheritLocale
+    });
+    instanceData.state.push({
+        type,
+        key: 'messages',
+        editable: false,
+        value: getLocaleMessageValue(composer.messages.value)
+    });
+    {
+        instanceData.state.push({
+            type,
+            key: 'datetimeFormats',
+            editable: false,
+            value: composer.datetimeFormats.value
+        });
+        instanceData.state.push({
+            type,
+            key: 'numberFormats',
+            editable: false,
+            value: composer.numberFormats.value
+        });
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getLocaleMessageValue(messages) {
+    const value = {};
+    Object.keys(messages).forEach((key) => {
+        const v = messages[key];
+        if (isFunction(v) && 'source' in v) {
+            value[key] = getMessageFunctionDetails(v);
+        }
+        else if (isObject(v)) {
+            value[key] = getLocaleMessageValue(v);
+        }
+        else {
+            value[key] = v;
+        }
+    });
+    return value;
+}
+const ESC = {
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    '&': '&amp;'
+};
+function escape(s) {
+    return s.replace(/[<>"&]/g, escapeChar);
+}
+function escapeChar(a) {
+    return ESC[a] || a;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getMessageFunctionDetails(func) {
+    const argString = func.source ? `("${escape(func.source)}")` : `(?)`;
+    return {
+        _custom: {
+            type: 'function',
+            display: `<span>ƒ</span> ${argString}`
+        }
+    };
+}
+function registerScope(payload, i18n) {
+    payload.rootNodes.push({
+        id: 'global',
+        label: 'Global Scope'
+    });
+    // prettier-ignore
+    const global = i18n.mode === 'composition'
+        ? i18n.global
+        : i18n.global.__composer;
+    for (const [keyInstance, instance] of i18n.__instances) {
+        // prettier-ignore
+        const composer = i18n.mode === 'composition'
+            ? instance
+            : instance.__composer;
+        if (global === composer) {
+            continue;
+        }
+        payload.rootNodes.push({
+            id: composer.id.toString(),
+            label: `${getI18nScopeLable(keyInstance)} Scope`
+        });
+    }
+}
+function getComponentInstance(nodeId, i18n) {
+    let instance = null;
+    if (nodeId !== 'global') {
+        for (const [component, composer] of i18n.__instances.entries()) {
+            if (composer.id.toString() === nodeId) {
+                instance = component;
+                break;
+            }
+        }
+    }
+    return instance;
+}
+function getComposer$1(nodeId, i18n) {
+    if (nodeId === 'global') {
+        return i18n.mode === 'composition'
+            ? i18n.global
+            : i18n.global.__composer;
+    }
+    else {
+        const instance = Array.from(i18n.__instances.values()).find(item => item.id.toString() === nodeId);
+        if (instance) {
+            return i18n.mode === 'composition'
+                ? instance
+                : instance.__composer;
+        }
+        else {
+            return null;
+        }
+    }
+}
+function inspectScope(payload, i18n
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    const composer = getComposer$1(payload.nodeId, i18n);
+    if (composer) {
+        // TODO:
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        payload.state = makeScopeInspectState(composer);
+    }
+    return null;
+}
+function makeScopeInspectState(composer) {
+    const state = {};
+    const localeType = 'Locale related info';
+    const localeStates = [
+        {
+            type: localeType,
+            key: 'locale',
+            editable: true,
+            value: composer.locale.value
+        },
+        {
+            type: localeType,
+            key: 'fallbackLocale',
+            editable: true,
+            value: composer.fallbackLocale.value
+        },
+        {
+            type: localeType,
+            key: 'availableLocales',
+            editable: false,
+            value: composer.availableLocales
+        },
+        {
+            type: localeType,
+            key: 'inheritLocale',
+            editable: true,
+            value: composer.inheritLocale
+        }
+    ];
+    state[localeType] = localeStates;
+    const localeMessagesType = 'Locale messages info';
+    const localeMessagesStates = [
+        {
+            type: localeMessagesType,
+            key: 'messages',
+            editable: false,
+            value: getLocaleMessageValue(composer.messages.value)
+        }
+    ];
+    state[localeMessagesType] = localeMessagesStates;
+    {
+        const datetimeFormatsType = 'Datetime formats info';
+        const datetimeFormatsStates = [
+            {
+                type: datetimeFormatsType,
+                key: 'datetimeFormats',
+                editable: false,
+                value: composer.datetimeFormats.value
+            }
+        ];
+        state[datetimeFormatsType] = datetimeFormatsStates;
+        const numberFormatsType = 'Datetime formats info';
+        const numberFormatsStates = [
+            {
+                type: numberFormatsType,
+                key: 'numberFormats',
+                editable: false,
+                value: composer.numberFormats.value
+            }
+        ];
+        state[numberFormatsType] = numberFormatsStates;
+    }
+    return state;
+}
+function addTimelineEvent(event, payload) {
+    if (devtoolsApi) {
+        let groupId;
+        if (payload && 'groupId' in payload) {
+            groupId = payload.groupId;
+            delete payload.groupId;
+        }
+        devtoolsApi.addTimelineEvent({
+            layerId: "vue-i18n-timeline" /* TIMELINE */,
+            event: {
+                title: event,
+                groupId,
+                time: Date.now(),
+                meta: {},
+                data: payload || {},
+                logType: event === "compile-error" /* COMPILE_ERROR */
+                    ? 'error'
+                    : event === "fallback" /* FALBACK */ ||
+                        event === "missing" /* MISSING */
+                        ? 'warning'
+                        : 'default'
+            }
+        });
+    }
+}
+function editScope(payload, i18n) {
+    const composer = getComposer$1(payload.nodeId, i18n);
+    if (composer) {
+        const [field] = payload.path;
+        if (field === 'locale' && isString(payload.state.value)) {
+            composer.locale.value = payload.state.value;
+        }
+        else if (field === 'fallbackLocale' &&
+            (isString(payload.state.value) ||
+                isArray(payload.state.value) ||
+                isObject(payload.state.value))) {
+            composer.fallbackLocale.value = payload.state.value;
+        }
+        else if (field === 'inheritLocale' && isBoolean(payload.state.value)) {
+            composer.inheritLocale = payload.state.value;
+        }
+    }
+}
+
+/**
+ * Supports compatibility for legacy vue-i18n APIs
+ * This mixin is used when we use vue-i18n@v9.x or later
+ */
+function defineMixin(vuei18n, composer, i18n) {
+    return {
+        beforeCreate() {
+            const instance = getCurrentInstance();
+            /* istanbul ignore if */
+            if (!instance) {
+                throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+            }
+            const options = this.$options;
+            if (options.i18n) {
+                const optionsI18n = options.i18n;
+                if (options.__i18n) {
+                    optionsI18n.__i18n = options.__i18n;
+                }
+                optionsI18n.__root = composer;
+                if (this === this.$root) {
+                    this.$i18n = mergeToRoot(vuei18n, optionsI18n);
+                }
+                else {
+                    optionsI18n.__injectWithOption = true;
+                    this.$i18n = createVueI18n(optionsI18n);
+                }
+            }
+            else if (options.__i18n) {
+                if (this === this.$root) {
+                    this.$i18n = mergeToRoot(vuei18n, options);
+                }
+                else {
+                    this.$i18n = createVueI18n({
+                        __i18n: options.__i18n,
+                        __injectWithOption: true,
+                        __root: composer
+                    });
+                }
+            }
+            else {
+                // set global
+                this.$i18n = vuei18n;
+            }
+            if (options.__i18nGlobal) {
+                adjustI18nResources(composer, options, options);
+            }
+            vuei18n.__onComponentInstanceCreated(this.$i18n);
+            i18n.__setInstance(instance, this.$i18n);
+            // defines vue-i18n legacy APIs
+            this.$t = (...args) => this.$i18n.t(...args);
+            this.$rt = (...args) => this.$i18n.rt(...args);
+            this.$tc = (...args) => this.$i18n.tc(...args);
+            this.$te = (key, locale) => this.$i18n.te(key, locale);
+            this.$d = (...args) => this.$i18n.d(...args);
+            this.$n = (...args) => this.$i18n.n(...args);
+            this.$tm = (key) => this.$i18n.tm(key);
+        },
+        mounted() {
+            /* istanbul ignore if */
+            if (((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) &&
+                !false &&
+                this.$el &&
+                this.$i18n) {
+                this.$el.__VUE_I18N__ = this.$i18n.__composer;
+                const emitter = (this.__v_emitter =
+                    createEmitter());
+                const _vueI18n = this.$i18n;
+                _vueI18n.__enableEmitter && _vueI18n.__enableEmitter(emitter);
+                emitter.on('*', addTimelineEvent);
+            }
+        },
+        unmounted() {
+            const instance = getCurrentInstance();
+            /* istanbul ignore if */
+            if (!instance) {
+                throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+            }
+            /* istanbul ignore if */
+            if (((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) &&
+                !false &&
+                this.$el &&
+                this.$el.__VUE_I18N__) {
+                if (this.__v_emitter) {
+                    this.__v_emitter.off('*', addTimelineEvent);
+                    delete this.__v_emitter;
+                }
+                if (this.$i18n) {
+                    const _vueI18n = this.$i18n;
+                    _vueI18n.__disableEmitter && _vueI18n.__disableEmitter();
+                    delete this.$el.__VUE_I18N__;
+                }
+            }
+            delete this.$t;
+            delete this.$rt;
+            delete this.$tc;
+            delete this.$te;
+            delete this.$d;
+            delete this.$n;
+            delete this.$tm;
+            i18n.__deleteInstance(instance);
+            delete this.$i18n;
+        }
+    };
+}
+function mergeToRoot(root, options) {
+    root.locale = options.locale || root.locale;
+    root.fallbackLocale = options.fallbackLocale || root.fallbackLocale;
+    root.missing = options.missing || root.missing;
+    root.silentTranslationWarn =
+        options.silentTranslationWarn || root.silentFallbackWarn;
+    root.silentFallbackWarn =
+        options.silentFallbackWarn || root.silentFallbackWarn;
+    root.formatFallbackMessages =
+        options.formatFallbackMessages || root.formatFallbackMessages;
+    root.postTranslation = options.postTranslation || root.postTranslation;
+    root.warnHtmlInMessage = options.warnHtmlInMessage || root.warnHtmlInMessage;
+    root.escapeParameterHtml =
+        options.escapeParameterHtml || root.escapeParameterHtml;
+    root.sync = options.sync || root.sync;
+    root.__composer[SetPluralRulesSymbol](options.pluralizationRules || root.pluralizationRules);
+    const messages = getLocaleMessages(root.locale, {
+        messages: options.messages,
+        __i18n: options.__i18n
+    });
+    Object.keys(messages).forEach(locale => root.mergeLocaleMessage(locale, messages[locale]));
+    if (options.datetimeFormats) {
+        Object.keys(options.datetimeFormats).forEach(locale => root.mergeDateTimeFormat(locale, options.datetimeFormats[locale]));
+    }
+    if (options.numberFormats) {
+        Object.keys(options.numberFormats).forEach(locale => root.mergeNumberFormat(locale, options.numberFormats[locale]));
+    }
+    return root;
+}
+
+/**
+ * Injection key for {@link useI18n}
+ *
+ * @remarks
+ * The global injection key for I18n instances with `useI18n`. this injection key is used in Web Components.
+ * Specify the i18n instance created by {@link createI18n} together with `provide` function.
+ *
+ * @VueI18nGeneral
+ */
+const I18nInjectionKey = 
+/* #__PURE__*/ makeSymbol('global-vue-i18n');
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+function createI18n(options = {}, VueI18nLegacy) {
+    // prettier-ignore
+    const __legacyMode = __VUE_I18N_LEGACY_API__ && isBoolean(options.legacy)
+            ? options.legacy
+            : __VUE_I18N_LEGACY_API__;
+    // prettier-ignore
+    const __globalInjection = isBoolean(options.globalInjection)
+        ? options.globalInjection
+        : true;
+    // prettier-ignore
+    const __allowComposition = __VUE_I18N_LEGACY_API__ && __legacyMode
+            ? !!options.allowComposition
+            : true;
+    const __instances = new Map();
+    const [globalScope, __global] = createGlobal(options, __legacyMode);
+    const symbol = makeSymbol((process.env.NODE_ENV !== 'production') ? 'vue-i18n' : '');
+    function __getInstance(component) {
+        return __instances.get(component) || null;
+    }
+    function __setInstance(component, instance) {
+        __instances.set(component, instance);
+    }
+    function __deleteInstance(component) {
+        __instances.delete(component);
+    }
+    {
+        const i18n = {
+            // mode
+            get mode() {
+                return __VUE_I18N_LEGACY_API__ && __legacyMode
+                    ? 'legacy'
+                    : 'composition';
+            },
+            // allowComposition
+            get allowComposition() {
+                return __allowComposition;
+            },
+            // install plugin
+            async install(app, ...options) {
+                if (((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) &&
+                    !false) {
+                    app.__VUE_I18N__ = i18n;
+                }
+                // setup global provider
+                app.__VUE_I18N_SYMBOL__ = symbol;
+                app.provide(app.__VUE_I18N_SYMBOL__, i18n);
+                // global method and properties injection for Composition API
+                if (!__legacyMode && __globalInjection) {
+                    injectGlobalFields(app, i18n.global);
+                }
+                // install built-in components and directive
+                if (__VUE_I18N_FULL_INSTALL__) {
+                    apply(app, i18n, ...options);
+                }
+                // setup mixin for Legacy API
+                if (__VUE_I18N_LEGACY_API__ && __legacyMode) {
+                    app.mixin(defineMixin(__global, __global.__composer, i18n));
+                }
+                // release global scope
+                const unmountApp = app.unmount;
+                app.unmount = () => {
+                    i18n.dispose();
+                    unmountApp();
+                };
+                // setup vue-devtools plugin
+                if (((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) && !false) {
+                    const ret = await enableDevTools(app, i18n);
+                    if (!ret) {
+                        throw createI18nError(I18nErrorCodes.CANNOT_SETUP_VUE_DEVTOOLS_PLUGIN);
+                    }
+                    const emitter = createEmitter();
+                    if (__legacyMode) {
+                        const _vueI18n = __global;
+                        _vueI18n.__enableEmitter && _vueI18n.__enableEmitter(emitter);
+                    }
+                    else {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const _composer = __global;
+                        _composer[EnableEmitter] && _composer[EnableEmitter](emitter);
+                    }
+                    emitter.on('*', addTimelineEvent);
+                }
+            },
+            // global accessor
+            get global() {
+                return __global;
+            },
+            dispose() {
+                globalScope.stop();
+            },
+            // @internal
+            __instances,
+            // @internal
+            __getInstance,
+            // @internal
+            __setInstance,
+            // @internal
+            __deleteInstance
+        };
+        return i18n;
+    }
+}
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+function useI18n(options = {}) {
+    const instance = getCurrentInstance();
+    if (instance == null) {
+        throw createI18nError(I18nErrorCodes.MUST_BE_CALL_SETUP_TOP);
+    }
+    if (!instance.isCE &&
+        instance.appContext.app != null &&
+        !instance.appContext.app.__VUE_I18N_SYMBOL__) {
+        throw createI18nError(I18nErrorCodes.NOT_INSLALLED);
+    }
+    const i18n = getI18nInstance(instance);
+    const global = getGlobalComposer(i18n);
+    const componentOptions = getComponentOptions(instance);
+    const scope = getScope(options, componentOptions);
+    if (__VUE_I18N_LEGACY_API__) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (i18n.mode === 'legacy' && !options.__useComponent) {
+            if (!i18n.allowComposition) {
+                throw createI18nError(I18nErrorCodes.NOT_AVAILABLE_IN_LEGACY_MODE);
+            }
+            return useI18nForLegacy(instance, scope, global, options);
+        }
+    }
+    if (scope === 'global') {
+        adjustI18nResources(global, options, componentOptions);
+        return global;
+    }
+    if (scope === 'parent') {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let composer = getComposer(i18n, instance, options.__useComponent);
+        if (composer == null) {
+            if ((process.env.NODE_ENV !== 'production')) {
+                warn(getWarnMessage(I18nWarnCodes.NOT_FOUND_PARENT_SCOPE));
+            }
+            composer = global;
+        }
+        return composer;
+    }
+    const i18nInternal = i18n;
+    let composer = i18nInternal.__getInstance(instance);
+    if (composer == null) {
+        const composerOptions = assign({}, options);
+        if ('__i18n' in componentOptions) {
+            composerOptions.__i18n = componentOptions.__i18n;
+        }
+        if (global) {
+            composerOptions.__root = global;
+        }
+        composer = createComposer(composerOptions);
+        setupLifeCycle(i18nInternal, instance, composer);
+        i18nInternal.__setInstance(instance, composer);
+    }
+    return composer;
+}
+/**
+ * Cast to VueI18n legacy compatible type
+ *
+ * @remarks
+ * This API is provided only with [vue-i18n-bridge](https://vue-i18n.intlify.dev/guide/migration/ways.html#what-is-vue-i18n-bridge).
+ *
+ * The purpose of this function is to convert an {@link I18n} instance created with {@link createI18n | createI18n(legacy: true)} into a `vue-i18n@v8.x` compatible instance of `new VueI18n` in a TypeScript environment.
+ *
+ * @param i18n - An instance of {@link I18n}
+ * @returns A i18n instance which is casted to {@link VueI18n} type
+ *
+ * @VueI18nTip
+ * :new: provided by **vue-i18n-bridge only**
+ *
+ * @VueI18nGeneral
+ */
+const castToVueI18n =  (i18n
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) => {
+    if (!(__VUE_I18N_BRIDGE__ in i18n)) {
+        throw createI18nError(I18nErrorCodes.NOT_COMPATIBLE_LEGACY_VUE_I18N);
+    }
+    return i18n;
+};
+function createGlobal(options, legacyMode, VueI18nLegacy // eslint-disable-line @typescript-eslint/no-explicit-any
+) {
+    const scope = effectScope();
+    {
+        const obj = __VUE_I18N_LEGACY_API__ && legacyMode
+            ? scope.run(() => createVueI18n(options))
+            : scope.run(() => createComposer(options));
+        if (obj == null) {
+            throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+        }
+        return [scope, obj];
+    }
+}
+function getI18nInstance(instance) {
+    {
+        const i18n = inject(!instance.isCE
+            ? instance.appContext.app.__VUE_I18N_SYMBOL__
+            : I18nInjectionKey);
+        /* istanbul ignore if */
+        if (!i18n) {
+            throw createI18nError(!instance.isCE
+                ? I18nErrorCodes.UNEXPECTED_ERROR
+                : I18nErrorCodes.NOT_INSLALLED_WITH_PROVIDE);
+        }
+        return i18n;
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getScope(options, componentOptions) {
+    // prettier-ignore
+    return isEmptyObject(options)
+        ? ('__i18n' in componentOptions)
+            ? 'local'
+            : 'global'
+        : !options.useScope
+            ? 'local'
+            : options.useScope;
+}
+function getGlobalComposer(i18n) {
+    // prettier-ignore
+    return i18n.mode === 'composition'
+            ? i18n.global
+            : i18n.global.__composer
+        ;
+}
+function getComposer(i18n, target, useComponent = false) {
+    let composer = null;
+    const root = target.root;
+    let current = target.parent;
+    while (current != null) {
+        const i18nInternal = i18n;
+        if (i18n.mode === 'composition') {
+            composer = i18nInternal.__getInstance(current);
+        }
+        else {
+            if (__VUE_I18N_LEGACY_API__) {
+                const vueI18n = i18nInternal.__getInstance(current);
+                if (vueI18n != null) {
+                    composer = vueI18n
+                        .__composer;
+                    if (useComponent &&
+                        composer &&
+                        !composer[InejctWithOption] // eslint-disable-line @typescript-eslint/no-explicit-any
+                    ) {
+                        composer = null;
+                    }
+                }
+            }
+        }
+        if (composer != null) {
+            break;
+        }
+        if (root === current) {
+            break;
+        }
+        current = current.parent;
+    }
+    return composer;
+}
+function setupLifeCycle(i18n, target, composer) {
+    let emitter = null;
+    {
+        onMounted(() => {
+            // inject composer instance to DOM for intlify-devtools
+            if (((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) &&
+                !false &&
+                target.vnode.el) {
+                target.vnode.el.__VUE_I18N__ = composer;
+                emitter = createEmitter();
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const _composer = composer;
+                _composer[EnableEmitter] && _composer[EnableEmitter](emitter);
+                emitter.on('*', addTimelineEvent);
+            }
+        }, target);
+        onUnmounted(() => {
+            // remove composer instance from DOM for intlify-devtools
+            if (((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) &&
+                !false &&
+                target.vnode.el &&
+                target.vnode.el.__VUE_I18N__) {
+                emitter && emitter.off('*', addTimelineEvent);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const _composer = composer;
+                _composer[DisableEmitter] && _composer[DisableEmitter]();
+                delete target.vnode.el.__VUE_I18N__;
+            }
+            i18n.__deleteInstance(target);
+        }, target);
+    }
+}
+function useI18nForLegacy(instance, scope, root, options = {} // eslint-disable-line @typescript-eslint/no-explicit-any
+) {
+    const isLocale = scope === 'local';
+    const _composer = shallowRef(null);
+    if (isLocale &&
+        instance.proxy &&
+        !(instance.proxy.$options.i18n || instance.proxy.$options.__i18n)) {
+        throw createI18nError(I18nErrorCodes.MUST_DEFINE_I18N_OPTION_IN_ALLOW_COMPOSITION);
+    }
+    const _inheritLocale = isBoolean(options.inheritLocale)
+        ? options.inheritLocale
+        : true;
+    const _locale = ref(
+    // prettier-ignore
+    isLocale && _inheritLocale
+        ? root.locale.value
+        : isString(options.locale)
+            ? options.locale
+            : DEFAULT_LOCALE);
+    const _fallbackLocale = ref(
+    // prettier-ignore
+    isLocale && _inheritLocale
+        ? root.fallbackLocale.value
+        : isString(options.fallbackLocale) ||
+            isArray(options.fallbackLocale) ||
+            isPlainObject(options.fallbackLocale) ||
+            options.fallbackLocale === false
+            ? options.fallbackLocale
+            : _locale.value);
+    const _messages = ref(getLocaleMessages(_locale.value, options));
+    // prettier-ignore
+    const _datetimeFormats = ref(isPlainObject(options.datetimeFormats)
+        ? options.datetimeFormats
+        : { [_locale.value]: {} });
+    // prettier-ignore
+    const _numberFormats = ref(isPlainObject(options.numberFormats)
+        ? options.numberFormats
+        : { [_locale.value]: {} });
+    // prettier-ignore
+    const _missingWarn = isLocale
+        ? root.missingWarn
+        : isBoolean(options.missingWarn) || isRegExp(options.missingWarn)
+            ? options.missingWarn
+            : true;
+    // prettier-ignore
+    const _fallbackWarn = isLocale
+        ? root.fallbackWarn
+        : isBoolean(options.fallbackWarn) || isRegExp(options.fallbackWarn)
+            ? options.fallbackWarn
+            : true;
+    // prettier-ignore
+    const _fallbackRoot = isLocale
+        ? root.fallbackRoot
+        : isBoolean(options.fallbackRoot)
+            ? options.fallbackRoot
+            : true;
+    // configure fall back to root
+    const _fallbackFormat = !!options.fallbackFormat;
+    // runtime missing
+    const _missing = isFunction(options.missing) ? options.missing : null;
+    // postTranslation handler
+    const _postTranslation = isFunction(options.postTranslation)
+        ? options.postTranslation
+        : null;
+    // prettier-ignore
+    const _warnHtmlMessage = isLocale
+        ? root.warnHtmlMessage
+        : isBoolean(options.warnHtmlMessage)
+            ? options.warnHtmlMessage
+            : true;
+    const _escapeParameter = !!options.escapeParameter;
+    // prettier-ignore
+    const _modifiers = isLocale
+        ? root.modifiers
+        : isPlainObject(options.modifiers)
+            ? options.modifiers
+            : {};
+    // pluralRules
+    const _pluralRules = options.pluralRules || (isLocale && root.pluralRules);
+    // track reactivity
+    function trackReactivityValues() {
+        return [
+            _locale.value,
+            _fallbackLocale.value,
+            _messages.value,
+            _datetimeFormats.value,
+            _numberFormats.value
+        ];
+    }
+    // locale
+    const locale = computed({
+        get: () => {
+            return _composer.value ? _composer.value.locale.value : _locale.value;
+        },
+        set: val => {
+            if (_composer.value) {
+                _composer.value.locale.value = val;
+            }
+            _locale.value = val;
+        }
+    });
+    // fallbackLocale
+    const fallbackLocale = computed({
+        get: () => {
+            return _composer.value
+                ? _composer.value.fallbackLocale.value
+                : _fallbackLocale.value;
+        },
+        set: val => {
+            if (_composer.value) {
+                _composer.value.fallbackLocale.value = val;
+            }
+            _fallbackLocale.value = val;
+        }
+    });
+    // messages
+    const messages = computed(() => {
+        if (_composer.value) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return _composer.value.messages.value;
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return _messages.value;
+        }
+    });
+    const datetimeFormats = computed(() => _datetimeFormats.value);
+    const numberFormats = computed(() => _numberFormats.value);
+    function getPostTranslationHandler() {
+        return _composer.value
+            ? _composer.value.getPostTranslationHandler()
+            : _postTranslation;
+    }
+    function setPostTranslationHandler(handler) {
+        if (_composer.value) {
+            _composer.value.setPostTranslationHandler(handler);
+        }
+    }
+    function getMissingHandler() {
+        return _composer.value ? _composer.value.getMissingHandler() : _missing;
+    }
+    function setMissingHandler(handler) {
+        if (_composer.value) {
+            _composer.value.setMissingHandler(handler);
+        }
+    }
+    function warpWithDeps(fn) {
+        trackReactivityValues();
+        return fn();
+    }
+    function t(...args) {
+        return _composer.value
+            ? warpWithDeps(() => Reflect.apply(_composer.value.t, null, [...args]))
+            : warpWithDeps(() => '');
+    }
+    function rt(...args) {
+        return _composer.value
+            ? Reflect.apply(_composer.value.rt, null, [...args])
+            : '';
+    }
+    function d(...args) {
+        return _composer.value
+            ? warpWithDeps(() => Reflect.apply(_composer.value.d, null, [...args]))
+            : warpWithDeps(() => '');
+    }
+    function n(...args) {
+        return _composer.value
+            ? warpWithDeps(() => Reflect.apply(_composer.value.n, null, [...args]))
+            : warpWithDeps(() => '');
+    }
+    function tm(key) {
+        return _composer.value ? _composer.value.tm(key) : {};
+    }
+    function te(key, locale) {
+        return _composer.value ? _composer.value.te(key, locale) : false;
+    }
+    function getLocaleMessage(locale) {
+        return _composer.value ? _composer.value.getLocaleMessage(locale) : {};
+    }
+    function setLocaleMessage(locale, message) {
+        if (_composer.value) {
+            _composer.value.setLocaleMessage(locale, message);
+            _messages.value[locale] = message;
+        }
+    }
+    function mergeLocaleMessage(locale, message) {
+        if (_composer.value) {
+            _composer.value.mergeLocaleMessage(locale, message);
+        }
+    }
+    function getDateTimeFormat(locale) {
+        return _composer.value ? _composer.value.getDateTimeFormat(locale) : {};
+    }
+    function setDateTimeFormat(locale, format) {
+        if (_composer.value) {
+            _composer.value.setDateTimeFormat(locale, format);
+            _datetimeFormats.value[locale] = format;
+        }
+    }
+    function mergeDateTimeFormat(locale, format) {
+        if (_composer.value) {
+            _composer.value.mergeDateTimeFormat(locale, format);
+        }
+    }
+    function getNumberFormat(locale) {
+        return _composer.value ? _composer.value.getNumberFormat(locale) : {};
+    }
+    function setNumberFormat(locale, format) {
+        if (_composer.value) {
+            _composer.value.setNumberFormat(locale, format);
+            _numberFormats.value[locale] = format;
+        }
+    }
+    function mergeNumberFormat(locale, format) {
+        if (_composer.value) {
+            _composer.value.mergeNumberFormat(locale, format);
+        }
+    }
+    const wrapper = {
+        get id() {
+            return _composer.value ? _composer.value.id : -1;
+        },
+        locale,
+        fallbackLocale,
+        messages,
+        datetimeFormats,
+        numberFormats,
+        get inheritLocale() {
+            return _composer.value ? _composer.value.inheritLocale : _inheritLocale;
+        },
+        set inheritLocale(val) {
+            if (_composer.value) {
+                _composer.value.inheritLocale = val;
+            }
+        },
+        get availableLocales() {
+            return _composer.value
+                ? _composer.value.availableLocales
+                : Object.keys(_messages.value);
+        },
+        get modifiers() {
+            return (_composer.value ? _composer.value.modifiers : _modifiers);
+        },
+        get pluralRules() {
+            return (_composer.value ? _composer.value.pluralRules : _pluralRules);
+        },
+        get isGlobal() {
+            return _composer.value ? _composer.value.isGlobal : false;
+        },
+        get missingWarn() {
+            return _composer.value ? _composer.value.missingWarn : _missingWarn;
+        },
+        set missingWarn(val) {
+            if (_composer.value) {
+                _composer.value.missingWarn = val;
+            }
+        },
+        get fallbackWarn() {
+            return _composer.value ? _composer.value.fallbackWarn : _fallbackWarn;
+        },
+        set fallbackWarn(val) {
+            if (_composer.value) {
+                _composer.value.missingWarn = val;
+            }
+        },
+        get fallbackRoot() {
+            return _composer.value ? _composer.value.fallbackRoot : _fallbackRoot;
+        },
+        set fallbackRoot(val) {
+            if (_composer.value) {
+                _composer.value.fallbackRoot = val;
+            }
+        },
+        get fallbackFormat() {
+            return _composer.value ? _composer.value.fallbackFormat : _fallbackFormat;
+        },
+        set fallbackFormat(val) {
+            if (_composer.value) {
+                _composer.value.fallbackFormat = val;
+            }
+        },
+        get warnHtmlMessage() {
+            return _composer.value
+                ? _composer.value.warnHtmlMessage
+                : _warnHtmlMessage;
+        },
+        set warnHtmlMessage(val) {
+            if (_composer.value) {
+                _composer.value.warnHtmlMessage = val;
+            }
+        },
+        get escapeParameter() {
+            return _composer.value
+                ? _composer.value.escapeParameter
+                : _escapeParameter;
+        },
+        set escapeParameter(val) {
+            if (_composer.value) {
+                _composer.value.escapeParameter = val;
+            }
+        },
+        t,
+        getPostTranslationHandler,
+        setPostTranslationHandler,
+        getMissingHandler,
+        setMissingHandler,
+        rt,
+        d,
+        n,
+        tm,
+        te,
+        getLocaleMessage,
+        setLocaleMessage,
+        mergeLocaleMessage,
+        getDateTimeFormat,
+        setDateTimeFormat,
+        mergeDateTimeFormat,
+        getNumberFormat,
+        setNumberFormat,
+        mergeNumberFormat
+    };
+    function sync(composer) {
+        composer.locale.value = _locale.value;
+        composer.fallbackLocale.value = _fallbackLocale.value;
+        Object.keys(_messages.value).forEach(locale => {
+            composer.mergeLocaleMessage(locale, _messages.value[locale]);
+        });
+        Object.keys(_datetimeFormats.value).forEach(locale => {
+            composer.mergeDateTimeFormat(locale, _datetimeFormats.value[locale]);
+        });
+        Object.keys(_numberFormats.value).forEach(locale => {
+            composer.mergeNumberFormat(locale, _numberFormats.value[locale]);
+        });
+        composer.escapeParameter = _escapeParameter;
+        composer.fallbackFormat = _fallbackFormat;
+        composer.fallbackRoot = _fallbackRoot;
+        composer.fallbackWarn = _fallbackWarn;
+        composer.missingWarn = _missingWarn;
+        composer.warnHtmlMessage = _warnHtmlMessage;
+    }
+    onBeforeMount(() => {
+        if (instance.proxy == null || instance.proxy.$i18n == null) {
+            throw createI18nError(I18nErrorCodes.NOT_AVAILABLE_COMPOSITION_IN_LEGACY);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const composer = (_composer.value = instance.proxy.$i18n
+            .__composer);
+        if (scope === 'global') {
+            _locale.value = composer.locale.value;
+            _fallbackLocale.value = composer.fallbackLocale.value;
+            _messages.value = composer.messages.value;
+            _datetimeFormats.value = composer.datetimeFormats.value;
+            _numberFormats.value = composer.numberFormats.value;
+        }
+        else if (isLocale) {
+            sync(composer);
+        }
+    });
+    return wrapper;
+}
+const globalExportProps = [
+    'locale',
+    'fallbackLocale',
+    'availableLocales'
+];
+const globalExportMethods = ['t', 'rt', 'd', 'n', 'tm'] ;
+function injectGlobalFields(app, composer) {
+    const i18n = Object.create(null);
+    globalExportProps.forEach(prop => {
+        const desc = Object.getOwnPropertyDescriptor(composer, prop);
+        if (!desc) {
+            throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+        }
+        const wrap = isRef(desc.value) // check computed props
+            ? {
+                get() {
+                    return desc.value.value;
+                },
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                set(val) {
+                    desc.value.value = val;
+                }
+            }
+            : {
+                get() {
+                    return desc.get && desc.get();
+                }
+            };
+        Object.defineProperty(i18n, prop, wrap);
+    });
+    app.config.globalProperties.$i18n = i18n;
+    globalExportMethods.forEach(method => {
+        const desc = Object.getOwnPropertyDescriptor(composer, method);
+        if (!desc || !desc.value) {
+            throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+        }
+        Object.defineProperty(app.config.globalProperties, `$${method}`, desc);
+    });
+}
+
+// register message compiler at vue-i18n
+registerMessageCompiler(compileToFunction);
+// register message resolver at vue-i18n
+registerMessageResolver(resolveValue);
+// register fallback locale at vue-i18n
+registerLocaleFallbacker(fallbackWithLocaleChain);
+{
+    initFeatureFlags();
+}
+// NOTE: experimental !!
+if ((process.env.NODE_ENV !== 'production') || __INTLIFY_PROD_DEVTOOLS__) {
+    const target = getGlobalThis();
+    target.__INTLIFY__ = true;
+    setDevToolsHook(target.__INTLIFY_DEVTOOLS_GLOBAL_HOOK__);
+}
+if ((process.env.NODE_ENV !== 'production')) ;
+
+export { DatetimeFormat, I18nInjectionKey, NumberFormat, Translation, VERSION, castToVueI18n, createI18n, useI18n, vTDirective };
diff --git a/parent_dir/node_modules/vue/devtools-api/lib/esm/const.js b/parent_dir/node_modules/vue/devtools-api/lib/esm/const.js
new file mode 100644
index 0000000..872ea3e
--- /dev/null
+++ b/parent_dir/node_modules/vue/devtools-api/lib/esm/const.js
@@ -0,0 +1,2 @@
+export const HOOK_SETUP = 'devtools-plugin:setup';
+export const HOOK_PLUGIN_SETTINGS_SET = 'plugin:settings:set';
diff --git a/parent_dir/node_modules/vue/devtools-api/lib/esm/env.js b/parent_dir/node_modules/vue/devtools-api/lib/esm/env.js
new file mode 100644
index 0000000..6713a93
--- /dev/null
+++ b/parent_dir/node_modules/vue/devtools-api/lib/esm/env.js
@@ -0,0 +1,12 @@
+export function getDevtoolsGlobalHook() {
+    return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__;
+}
+export function getTarget() {
+    // @ts-ignore
+    return (typeof navigator !== 'undefined' && typeof window !== 'undefined')
+        ? window
+        : typeof global !== 'undefined'
+            ? global
+            : {};
+}
+export const isProxyAvailable = typeof Proxy === 'function';
diff --git a/parent_dir/node_modules/vue/devtools-api/lib/esm/index.js b/parent_dir/node_modules/vue/devtools-api/lib/esm/index.js
new file mode 100644
index 0000000..39259bc
--- /dev/null
+++ b/parent_dir/node_modules/vue/devtools-api/lib/esm/index.js
@@ -0,0 +1,26 @@
+import { getTarget, getDevtoolsGlobalHook, isProxyAvailable } from './env.js';
+import { HOOK_SETUP } from './const.js';
+import { ApiProxy } from './proxy.js';
+export * from './api/index.js';
+export * from './plugin.js';
+export * from './time.js';
+export function setupDevtoolsPlugin(pluginDescriptor, setupFn) {
+    const descriptor = pluginDescriptor;
+    const target = getTarget();
+    const hook = getDevtoolsGlobalHook();
+    const enableProxy = isProxyAvailable && descriptor.enableEarlyProxy;
+    if (hook && (target.__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__ || !enableProxy)) {
+        hook.emit(HOOK_SETUP, pluginDescriptor, setupFn);
+    }
+    else {
+        const proxy = enableProxy ? new ApiProxy(descriptor, hook) : null;
+        const list = target.__VUE_DEVTOOLS_PLUGINS__ = target.__VUE_DEVTOOLS_PLUGINS__ || [];
+        list.push({
+            pluginDescriptor: descriptor,
+            setupFn,
+            proxy,
+        });
+        if (proxy)
+            setupFn(proxy.proxiedTarget);
+    }
+}
diff --git a/parent_dir/node_modules/vue/devtools-api/lib/esm/proxy.js b/parent_dir/node_modules/vue/devtools-api/lib/esm/proxy.js
new file mode 100644
index 0000000..639077e
--- /dev/null
+++ b/parent_dir/node_modules/vue/devtools-api/lib/esm/proxy.js
@@ -0,0 +1,107 @@
+import { HOOK_PLUGIN_SETTINGS_SET } from './const.js';
+import { now } from './time.js';
+export class ApiProxy {
+    constructor(plugin, hook) {
+        this.target = null;
+        this.targetQueue = [];
+        this.onQueue = [];
+        this.plugin = plugin;
+        this.hook = hook;
+        const defaultSettings = {};
+        if (plugin.settings) {
+            for (const id in plugin.settings) {
+                const item = plugin.settings[id];
+                defaultSettings[id] = item.defaultValue;
+            }
+        }
+        const localSettingsSaveId = `__vue-devtools-plugin-settings__${plugin.id}`;
+        let currentSettings = Object.assign({}, defaultSettings);
+        try {
+            const raw = localStorage.getItem(localSettingsSaveId);
+            const data = JSON.parse(raw);
+            Object.assign(currentSettings, data);
+        }
+        catch (e) {
+            // noop
+        }
+        this.fallbacks = {
+            getSettings() {
+                return currentSettings;
+            },
+            setSettings(value) {
+                try {
+                    localStorage.setItem(localSettingsSaveId, JSON.stringify(value));
+                }
+                catch (e) {
+                    // noop
+                }
+                currentSettings = value;
+            },
+            now() {
+                return now();
+            },
+        };
+        if (hook) {
+            hook.on(HOOK_PLUGIN_SETTINGS_SET, (pluginId, value) => {
+                if (pluginId === this.plugin.id) {
+                    this.fallbacks.setSettings(value);
+                }
+            });
+        }
+        this.proxiedOn = new Proxy({}, {
+            get: (_target, prop) => {
+                if (this.target) {
+                    return this.target.on[prop];
+                }
+                else {
+                    return (...args) => {
+                        this.onQueue.push({
+                            method: prop,
+                            args,
+                        });
+                    };
+                }
+            },
+        });
+        this.proxiedTarget = new Proxy({}, {
+            get: (_target, prop) => {
+                if (this.target) {
+                    return this.target[prop];
+                }
+                else if (prop === 'on') {
+                    return this.proxiedOn;
+                }
+                else if (Object.keys(this.fallbacks).includes(prop)) {
+                    return (...args) => {
+                        this.targetQueue.push({
+                            method: prop,
+                            args,
+                            resolve: () => { },
+                        });
+                        return this.fallbacks[prop](...args);
+                    };
+                }
+                else {
+                    return (...args) => {
+                        return new Promise(resolve => {
+                            this.targetQueue.push({
+                                method: prop,
+                                args,
+                                resolve,
+                            });
+                        });
+                    };
+                }
+            },
+        });
+    }
+    async setRealTarget(target) {
+        this.target = target;
+        for (const item of this.onQueue) {
+            this.target.on[item.method](...item.args);
+        }
+        for (const item of this.targetQueue) {
+            item.resolve(await this.target[item.method](...item.args));
+        }
+    }
+}
diff --git a/parent_dir/node_modules/vue/devtools-api/lib/esm/time.js b/parent_dir/node_modules/vue/devtools-api/lib/esm/time.js
new file mode 100644
index 0000000..99bedb5
--- /dev/null
+++ b/parent_dir/node_modules/vue/devtools-api/lib/esm/time.js
@@ -0,0 +1,23 @@
+let supported;
+let perf;
+export function isPerformanceSupported() {
+    var _a;
+    if (supported !== undefined) {
+        return supported;
+    }
+    if (typeof window !== 'undefined' && window.performance) {
+        supported = true;
+        perf = window.performance;
+    }
+    else if (typeof global !== 'undefined' && ((_a = global.perf_hooks) === null || _a === void 0 ? void 0 : _a.performance)) {
+        supported = true;
+        perf = global.perf_hooks.performance;
+    }
+    else {
+        supported = false;
+    }
+    return supported;
+}
+export function now() {
+    return isPerformanceSupported() ? perf.now() : Date.now();
+}
diff --git a/parent_dir/node_modules/vue/reactivity/dist/reactivity.esm-bundler.js b/parent_dir/node_modules/vue/reactivity/dist/reactivity.esm-bundler.js
new file mode 100644
index 0000000..da73db3
--- /dev/null
+++ b/parent_dir/node_modules/vue/reactivity/dist/reactivity.esm-bundler.js
@@ -0,0 +1,1247 @@
+import { extend, isArray, isMap, isIntegerKey, hasOwn, isSymbol, isObject, hasChanged, makeMap, capitalize, toRawType, def, isFunction, NOOP } from '@vue/shared';
+
+function warn(msg, ...args) {
+  console.warn(`[Vue warn] ${msg}`, ...args);
+}
+
+let activeEffectScope;
+class EffectScope {
+  constructor(detached = false) {
+    this.detached = detached;
+    /**
+     * @internal
+     */
+    this._active = true;
+    /**
+     * @internal
+     */
+    this.effects = [];
+    /**
+     * @internal
+     */
+    this.cleanups = [];
+    this.parent = activeEffectScope;
+    if (!detached && activeEffectScope) {
+      this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
+        this
+      ) - 1;
+    }
+  }
+  get active() {
+    return this._active;
+  }
+  run(fn) {
+    if (this._active) {
+      const currentEffectScope = activeEffectScope;
+      try {
+        activeEffectScope = this;
+        return fn();
+      } finally {
+        activeEffectScope = currentEffectScope;
+      }
+    } else if (!!(process.env.NODE_ENV !== "production")) {
+      warn(`cannot run an inactive effect scope.`);
+    }
+  }
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  on() {
+    activeEffectScope = this;
+  }
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  off() {
+    activeEffectScope = this.parent;
+  }
+  stop(fromParent) {
+    if (this._active) {
+      let i, l;
+      for (i = 0, l = this.effects.length; i < l; i++) {
+        this.effects[i].stop();
+      }
+      for (i = 0, l = this.cleanups.length; i < l; i++) {
+        this.cleanups[i]();
+      }
+      if (this.scopes) {
+        for (i = 0, l = this.scopes.length; i < l; i++) {
+          this.scopes[i].stop(true);
+        }
+      }
+      if (!this.detached && this.parent && !fromParent) {
+        const last = this.parent.scopes.pop();
+        if (last && last !== this) {
+          this.parent.scopes[this.index] = last;
+          last.index = this.index;
+        }
+      }
+      this.parent = void 0;
+      this._active = false;
+    }
+  }
+}
+function effectScope(detached) {
+  return new EffectScope(detached);
+}
+function recordEffectScope(effect, scope = activeEffectScope) {
+  if (scope && scope.active) {
+    scope.effects.push(effect);
+  }
+}
+function getCurrentScope() {
+  return activeEffectScope;
+}
+function onScopeDispose(fn) {
+  if (activeEffectScope) {
+    activeEffectScope.cleanups.push(fn);
+  } else if (!!(process.env.NODE_ENV !== "production")) {
+    warn(
+      `onScopeDispose() is called when there is no active effect scope to be associated with.`
+    );
+  }
+}
+
+const createDep = (effects) => {
+  const dep = new Set(effects);
+  dep.w = 0;
+  dep.n = 0;
+  return dep;
+};
+const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
+const newTracked = (dep) => (dep.n & trackOpBit) > 0;
+const initDepMarkers = ({ deps }) => {
+  if (deps.length) {
+    for (let i = 0; i < deps.length; i++) {
+      deps[i].w |= trackOpBit;
+    }
+  }
+};
+const finalizeDepMarkers = (effect) => {
+  const { deps } = effect;
+  if (deps.length) {
+    let ptr = 0;
+    for (let i = 0; i < deps.length; i++) {
+      const dep = deps[i];
+      if (wasTracked(dep) && !newTracked(dep)) {
+        dep.delete(effect);
+      } else {
+        deps[ptr++] = dep;
+      }
+      dep.w &= ~trackOpBit;
+      dep.n &= ~trackOpBit;
+    }
+    deps.length = ptr;
+  }
+};
+
+const targetMap = /* @__PURE__ */ new WeakMap();
+let effectTrackDepth = 0;
+let trackOpBit = 1;
+const maxMarkerBits = 30;
+let activeEffect;
+const ITERATE_KEY = Symbol(!!(process.env.NODE_ENV !== "production") ? "iterate" : "");
+const MAP_KEY_ITERATE_KEY = Symbol(!!(process.env.NODE_ENV !== "production") ? "Map key iterate" : "");
+class ReactiveEffect {
+  constructor(fn, scheduler = null, scope) {
+    this.fn = fn;
+    this.scheduler = scheduler;
+    this.active = true;
+    this.deps = [];
+    this.parent = void 0;
+    recordEffectScope(this, scope);
+  }
+  run() {
+    if (!this.active) {
+      return this.fn();
+    }
+    let parent = activeEffect;
+    let lastShouldTrack = shouldTrack;
+    while (parent) {
+      if (parent === this) {
+        return;
+      }
+      parent = parent.parent;
+    }
+    try {
+      this.parent = activeEffect;
+      activeEffect = this;
+      shouldTrack = true;
+      trackOpBit = 1 << ++effectTrackDepth;
+      if (effectTrackDepth <= maxMarkerBits) {
+        initDepMarkers(this);
+      } else {
+        cleanupEffect(this);
+      }
+      return this.fn();
+    } finally {
+      if (effectTrackDepth <= maxMarkerBits) {
+        finalizeDepMarkers(this);
+      }
+      trackOpBit = 1 << --effectTrackDepth;
+      activeEffect = this.parent;
+      shouldTrack = lastShouldTrack;
+      this.parent = void 0;
+      if (this.deferStop) {
+        this.stop();
+      }
+    }
+  }
+  stop() {
+    if (activeEffect === this) {
+      this.deferStop = true;
+    } else if (this.active) {
+      cleanupEffect(this);
+      if (this.onStop) {
+        this.onStop();
+      }
+      this.active = false;
+    }
+  }
+}
+function cleanupEffect(effect2) {
+  const { deps } = effect2;
+  if (deps.length) {
+    for (let i = 0; i < deps.length; i++) {
+      deps[i].delete(effect2);
+    }
+    deps.length = 0;
+  }
+}
+function effect(fn, options) {
+  if (fn.effect) {
+    fn = fn.effect.fn;
+  }
+  const _effect = new ReactiveEffect(fn);
+  if (options) {
+    extend(_effect, options);
+    if (options.scope)
+      recordEffectScope(_effect, options.scope);
+  }
+  if (!options || !options.lazy) {
+    _effect.run();
+  }
+  const runner = _effect.run.bind(_effect);
+  runner.effect = _effect;
+  return runner;
+}
+function stop(runner) {
+  runner.effect.stop();
+}
+let shouldTrack = true;
+const trackStack = [];
+function pauseTracking() {
+  trackStack.push(shouldTrack);
+  shouldTrack = false;
+}
+function enableTracking() {
+  trackStack.push(shouldTrack);
+  shouldTrack = true;
+}
+function resetTracking() {
+  const last = trackStack.pop();
+  shouldTrack = last === void 0 ? true : last;
+}
+function track(target, type, key) {
+  if (shouldTrack && activeEffect) {
+    let depsMap = targetMap.get(target);
+    if (!depsMap) {
+      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
+    }
+    let dep = depsMap.get(key);
+    if (!dep) {
+      depsMap.set(key, dep = createDep());
+    }
+    const eventInfo = !!(process.env.NODE_ENV !== "production") ? { effect: activeEffect, target, type, key } : void 0;
+    trackEffects(dep, eventInfo);
+  }
+}
+function trackEffects(dep, debuggerEventExtraInfo) {
+  let shouldTrack2 = false;
+  if (effectTrackDepth <= maxMarkerBits) {
+    if (!newTracked(dep)) {
+      dep.n |= trackOpBit;
+      shouldTrack2 = !wasTracked(dep);
+    }
+  } else {
+    shouldTrack2 = !dep.has(activeEffect);
+  }
+  if (shouldTrack2) {
+    dep.add(activeEffect);
+    activeEffect.deps.push(dep);
+    if (!!(process.env.NODE_ENV !== "production") && activeEffect.onTrack) {
+      activeEffect.onTrack(
+        extend(
+          {
+            effect: activeEffect
+          },
+          debuggerEventExtraInfo
+        )
+      );
+    }
+  }
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+  const depsMap = targetMap.get(target);
+  if (!depsMap) {
+    return;
+  }
+  let deps = [];
+  if (type === "clear") {
+    deps = [...depsMap.values()];
+  } else if (key === "length" && isArray(target)) {
+    const newLength = Number(newValue);
+    depsMap.forEach((dep, key2) => {
+      if (key2 === "length" || key2 >= newLength) {
+        deps.push(dep);
+      }
+    });
+  } else {
+    if (key !== void 0) {
+      deps.push(depsMap.get(key));
+    }
+    switch (type) {
+      case "add":
+        if (!isArray(target)) {
+          deps.push(depsMap.get(ITERATE_KEY));
+          if (isMap(target)) {
+            deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+          }
+        } else if (isIntegerKey(key)) {
+          deps.push(depsMap.get("length"));
+        }
+        break;
+      case "delete":
+        if (!isArray(target)) {
+          deps.push(depsMap.get(ITERATE_KEY));
+          if (isMap(target)) {
+            deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+          }
+        }
+        break;
+      case "set":
+        if (isMap(target)) {
+          deps.push(depsMap.get(ITERATE_KEY));
+        }
+        break;
+    }
+  }
+  const eventInfo = !!(process.env.NODE_ENV !== "production") ? { target, type, key, newValue, oldValue, oldTarget } : void 0;
+  if (deps.length === 1) {
+    if (deps[0]) {
+      if (!!(process.env.NODE_ENV !== "production")) {
+        triggerEffects(deps[0], eventInfo);
+      } else {
+        triggerEffects(deps[0]);
+      }
+    }
+  } else {
+    const effects = [];
+    for (const dep of deps) {
+      if (dep) {
+        effects.push(...dep);
+      }
+    }
+    if (!!(process.env.NODE_ENV !== "production")) {
+      triggerEffects(createDep(effects), eventInfo);
+    } else {
+      triggerEffects(createDep(effects));
+    }
+  }
+}
+function triggerEffects(dep, debuggerEventExtraInfo) {
+  const effects = isArray(dep) ? dep : [...dep];
+  for (const effect2 of effects) {
+    if (effect2.computed) {
+      triggerEffect(effect2, debuggerEventExtraInfo);
+    }
+  }
+  for (const effect2 of effects) {
+    if (!effect2.computed) {
+      triggerEffect(effect2, debuggerEventExtraInfo);
+    }
+  }
+}
+function triggerEffect(effect2, debuggerEventExtraInfo) {
+  if (effect2 !== activeEffect || effect2.allowRecurse) {
+    if (!!(process.env.NODE_ENV !== "production") && effect2.onTrigger) {
+      effect2.onTrigger(extend({ effect: effect2 }, debuggerEventExtraInfo));
+    }
+    if (effect2.scheduler) {
+      effect2.scheduler();
+    } else {
+      effect2.run();
+    }
+  }
+}
+function getDepFromReactive(object, key) {
+  var _a;
+  return (_a = targetMap.get(object)) == null ? void 0 : _a.get(key);
+}
+
+const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
+const builtInSymbols = new Set(
+  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
+);
+const get$1 = /* @__PURE__ */ createGetter();
+const shallowGet = /* @__PURE__ */ createGetter(false, true);
+const readonlyGet = /* @__PURE__ */ createGetter(true);
+const shallowReadonlyGet = /* @__PURE__ */ createGetter(true, true);
+const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
+function createArrayInstrumentations() {
+  const instrumentations = {};
+  ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
+    instrumentations[key] = function(...args) {
+      const arr = toRaw(this);
+      for (let i = 0, l = this.length; i < l; i++) {
+        track(arr, "get", i + "");
+      }
+      const res = arr[key](...args);
+      if (res === -1 || res === false) {
+        return arr[key](...args.map(toRaw));
+      } else {
+        return res;
+      }
+    };
+  });
+  ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
+    instrumentations[key] = function(...args) {
+      pauseTracking();
+      const res = toRaw(this)[key].apply(this, args);
+      resetTracking();
+      return res;
+    };
+  });
+  return instrumentations;
+}
+function hasOwnProperty(key) {
+  const obj = toRaw(this);
+  track(obj, "has", key);
+  return obj.hasOwnProperty(key);
+}
+function createGetter(isReadonly2 = false, shallow = false) {
+  return function get2(target, key, receiver) {
+    if (key === "__v_isReactive") {
+      return !isReadonly2;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly2;
+    } else if (key === "__v_isShallow") {
+      return shallow;
+    } else if (key === "__v_raw" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
+      return target;
+    }
+    const targetIsArray = isArray(target);
+    if (!isReadonly2) {
+      if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
+        return Reflect.get(arrayInstrumentations, key, receiver);
+      }
+      if (key === "hasOwnProperty") {
+        return hasOwnProperty;
+      }
+    }
+    const res = Reflect.get(target, key, receiver);
+    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+      return res;
+    }
+    if (!isReadonly2) {
+      track(target, "get", key);
+    }
+    if (shallow) {
+      return res;
+    }
+    if (isRef(res)) {
+      return targetIsArray && isIntegerKey(key) ? res : res.value;
+    }
+    if (isObject(res)) {
+      return isReadonly2 ? readonly(res) : reactive(res);
+    }
+    return res;
+  };
+}
+const set$1 = /* @__PURE__ */ createSetter();
+const shallowSet = /* @__PURE__ */ createSetter(true);
+function createSetter(shallow = false) {
+  return function set2(target, key, value, receiver) {
+    let oldValue = target[key];
+    if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
+      return false;
+    }
+    if (!shallow) {
+      if (!isShallow(value) && !isReadonly(value)) {
+        oldValue = toRaw(oldValue);
+        value = toRaw(value);
+      }
+      if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
+        oldValue.value = value;
+        return true;
+      }
+    }
+    const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
+    const result = Reflect.set(target, key, value, receiver);
+    if (target === toRaw(receiver)) {
+      if (!hadKey) {
+        trigger(target, "add", key, value);
+      } else if (hasChanged(value, oldValue)) {
+        trigger(target, "set", key, value, oldValue);
+      }
+    }
+    return result;
+  };
+}
+function deleteProperty(target, key) {
+  const hadKey = hasOwn(target, key);
+  const oldValue = target[key];
+  const result = Reflect.deleteProperty(target, key);
+  if (result && hadKey) {
+    trigger(target, "delete", key, void 0, oldValue);
+  }
+  return result;
+}
+function has$1(target, key) {
+  const result = Reflect.has(target, key);
+  if (!isSymbol(key) || !builtInSymbols.has(key)) {
+    track(target, "has", key);
+  }
+  return result;
+}
+function ownKeys(target) {
+  track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
+  return Reflect.ownKeys(target);
+}
+const mutableHandlers = {
+  get: get$1,
+  set: set$1,
+  deleteProperty,
+  has: has$1,
+  ownKeys
+};
+const readonlyHandlers = {
+  get: readonlyGet,
+  set(target, key) {
+    if (!!(process.env.NODE_ENV !== "production")) {
+      warn(
+        `Set operation on key "${String(key)}" failed: target is readonly.`,
+        target
+      );
+    }
+    return true;
+  },
+  deleteProperty(target, key) {
+    if (!!(process.env.NODE_ENV !== "production")) {
+      warn(
+        `Delete operation on key "${String(key)}" failed: target is readonly.`,
+        target
+      );
+    }
+    return true;
+  }
+};
+const shallowReactiveHandlers = /* @__PURE__ */ extend(
+  {},
+  mutableHandlers,
+  {
+    get: shallowGet,
+    set: shallowSet
+  }
+);
+const shallowReadonlyHandlers = /* @__PURE__ */ extend(
+  {},
+  readonlyHandlers,
+  {
+    get: shallowReadonlyGet
+  }
+);
+
+const toShallow = (value) => value;
+const getProto = (v) => Reflect.getPrototypeOf(v);
+function get(target, key, isReadonly = false, isShallow = false) {
+  target = target["__v_raw"];
+  const rawTarget = toRaw(target);
+  const rawKey = toRaw(key);
+  if (!isReadonly) {
+    if (key !== rawKey) {
+      track(rawTarget, "get", key);
+    }
+    track(rawTarget, "get", rawKey);
+  }
+  const { has: has2 } = getProto(rawTarget);
+  const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+  if (has2.call(rawTarget, key)) {
+    return wrap(target.get(key));
+  } else if (has2.call(rawTarget, rawKey)) {
+    return wrap(target.get(rawKey));
+  } else if (target !== rawTarget) {
+    target.get(key);
+  }
+}
+function has(key, isReadonly = false) {
+  const target = this["__v_raw"];
+  const rawTarget = toRaw(target);
+  const rawKey = toRaw(key);
+  if (!isReadonly) {
+    if (key !== rawKey) {
+      track(rawTarget, "has", key);
+    }
+    track(rawTarget, "has", rawKey);
+  }
+  return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+}
+function size(target, isReadonly = false) {
+  target = target["__v_raw"];
+  !isReadonly && track(toRaw(target), "iterate", ITERATE_KEY);
+  return Reflect.get(target, "size", target);
+}
+function add(value) {
+  value = toRaw(value);
+  const target = toRaw(this);
+  const proto = getProto(target);
+  const hadKey = proto.has.call(target, value);
+  if (!hadKey) {
+    target.add(value);
+    trigger(target, "add", value, value);
+  }
+  return this;
+}
+function set(key, value) {
+  value = toRaw(value);
+  const target = toRaw(this);
+  const { has: has2, get: get2 } = getProto(target);
+  let hadKey = has2.call(target, key);
+  if (!hadKey) {
+    key = toRaw(key);
+    hadKey = has2.call(target, key);
+  } else if (!!(process.env.NODE_ENV !== "production")) {
+    checkIdentityKeys(target, has2, key);
+  }
+  const oldValue = get2.call(target, key);
+  target.set(key, value);
+  if (!hadKey) {
+    trigger(target, "add", key, value);
+  } else if (hasChanged(value, oldValue)) {
+    trigger(target, "set", key, value, oldValue);
+  }
+  return this;
+}
+function deleteEntry(key) {
+  const target = toRaw(this);
+  const { has: has2, get: get2 } = getProto(target);
+  let hadKey = has2.call(target, key);
+  if (!hadKey) {
+    key = toRaw(key);
+    hadKey = has2.call(target, key);
+  } else if (!!(process.env.NODE_ENV !== "production")) {
+    checkIdentityKeys(target, has2, key);
+  }
+  const oldValue = get2 ? get2.call(target, key) : void 0;
+  const result = target.delete(key);
+  if (hadKey) {
+    trigger(target, "delete", key, void 0, oldValue);
+  }
+  return result;
+}
+function clear() {
+  const target = toRaw(this);
+  const hadItems = target.size !== 0;
+  const oldTarget = !!(process.env.NODE_ENV !== "production") ? isMap(target) ? new Map(target) : new Set(target) : void 0;
+  const result = target.clear();
+  if (hadItems) {
+    trigger(target, "clear", void 0, void 0, oldTarget);
+  }
+  return result;
+}
+function createForEach(isReadonly, isShallow) {
+  return function forEach(callback, thisArg) {
+    const observed = this;
+    const target = observed["__v_raw"];
+    const rawTarget = toRaw(target);
+    const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+    !isReadonly && track(rawTarget, "iterate", ITERATE_KEY);
+    return target.forEach((value, key) => {
+      return callback.call(thisArg, wrap(value), wrap(key), observed);
+    });
+  };
+}
+function createIterableMethod(method, isReadonly, isShallow) {
+  return function(...args) {
+    const target = this["__v_raw"];
+    const rawTarget = toRaw(target);
+    const targetIsMap = isMap(rawTarget);
+    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+    const isKeyOnly = method === "keys" && targetIsMap;
+    const innerIterator = target[method](...args);
+    const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+    !isReadonly && track(
+      rawTarget,
+      "iterate",
+      isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
+    );
+    return {
+      // iterator protocol
+      next() {
+        const { value, done } = innerIterator.next();
+        return done ? { value, done } : {
+          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+          done
+        };
+      },
+      // iterable protocol
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  };
+}
+function createReadonlyMethod(type) {
+  return function(...args) {
+    if (!!(process.env.NODE_ENV !== "production")) {
+      const key = args[0] ? `on key "${args[0]}" ` : ``;
+      console.warn(
+        `${capitalize(type)} operation ${key}failed: target is readonly.`,
+        toRaw(this)
+      );
+    }
+    return type === "delete" ? false : this;
+  };
+}
+function createInstrumentations() {
+  const mutableInstrumentations2 = {
+    get(key) {
+      return get(this, key);
+    },
+    get size() {
+      return size(this);
+    },
+    has,
+    add,
+    set,
+    delete: deleteEntry,
+    clear,
+    forEach: createForEach(false, false)
+  };
+  const shallowInstrumentations2 = {
+    get(key) {
+      return get(this, key, false, true);
+    },
+    get size() {
+      return size(this);
+    },
+    has,
+    add,
+    set,
+    delete: deleteEntry,
+    clear,
+    forEach: createForEach(false, true)
+  };
+  const readonlyInstrumentations2 = {
+    get(key) {
+      return get(this, key, true);
+    },
+    get size() {
+      return size(this, true);
+    },
+    has(key) {
+      return has.call(this, key, true);
+    },
+    add: createReadonlyMethod("add"),
+    set: createReadonlyMethod("set"),
+    delete: createReadonlyMethod("delete"),
+    clear: createReadonlyMethod("clear"),
+    forEach: createForEach(true, false)
+  };
+  const shallowReadonlyInstrumentations2 = {
+    get(key) {
+      return get(this, key, true, true);
+    },
+    get size() {
+      return size(this, true);
+    },
+    has(key) {
+      return has.call(this, key, true);
+    },
+    add: createReadonlyMethod("add"),
+    set: createReadonlyMethod("set"),
+    delete: createReadonlyMethod("delete"),
+    clear: createReadonlyMethod("clear"),
+    forEach: createForEach(true, true)
+  };
+  const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
+  iteratorMethods.forEach((method) => {
+    mutableInstrumentations2[method] = createIterableMethod(
+      method,
+      false,
+      false
+    );
+    readonlyInstrumentations2[method] = createIterableMethod(
+      method,
+      true,
+      false
+    );
+    shallowInstrumentations2[method] = createIterableMethod(
+      method,
+      false,
+      true
+    );
+    shallowReadonlyInstrumentations2[method] = createIterableMethod(
+      method,
+      true,
+      true
+    );
+  });
+  return [
+    mutableInstrumentations2,
+    readonlyInstrumentations2,
+    shallowInstrumentations2,
+    shallowReadonlyInstrumentations2
+  ];
+}
+const [
+  mutableInstrumentations,
+  readonlyInstrumentations,
+  shallowInstrumentations,
+  shallowReadonlyInstrumentations
+] = /* @__PURE__ */ createInstrumentations();
+function createInstrumentationGetter(isReadonly, shallow) {
+  const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
+  return (target, key, receiver) => {
+    if (key === "__v_isReactive") {
+      return !isReadonly;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly;
+    } else if (key === "__v_raw") {
+      return target;
+    }
+    return Reflect.get(
+      hasOwn(instrumentations, key) && key in target ? instrumentations : target,
+      key,
+      receiver
+    );
+  };
+}
+const mutableCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
+};
+const shallowCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(false, true)
+};
+const readonlyCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
+};
+const shallowReadonlyCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(true, true)
+};
+function checkIdentityKeys(target, has2, key) {
+  const rawKey = toRaw(key);
+  if (rawKey !== key && has2.call(target, rawKey)) {
+    const type = toRawType(target);
+    console.warn(
+      `Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`
+    );
+  }
+}
+
+const reactiveMap = /* @__PURE__ */ new WeakMap();
+const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+const readonlyMap = /* @__PURE__ */ new WeakMap();
+const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
+function targetTypeMap(rawType) {
+  switch (rawType) {
+    case "Object":
+    case "Array":
+      return 1 /* COMMON */;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2 /* COLLECTION */;
+    default:
+      return 0 /* INVALID */;
+  }
+}
+function getTargetType(value) {
+  return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap(toRawType(value));
+}
+function reactive(target) {
+  if (isReadonly(target)) {
+    return target;
+  }
+  return createReactiveObject(
+    target,
+    false,
+    mutableHandlers,
+    mutableCollectionHandlers,
+    reactiveMap
+  );
+}
+function shallowReactive(target) {
+  return createReactiveObject(
+    target,
+    false,
+    shallowReactiveHandlers,
+    shallowCollectionHandlers,
+    shallowReactiveMap
+  );
+}
+function readonly(target) {
+  return createReactiveObject(
+    target,
+    true,
+    readonlyHandlers,
+    readonlyCollectionHandlers,
+    readonlyMap
+  );
+}
+function shallowReadonly(target) {
+  return createReactiveObject(
+    target,
+    true,
+    shallowReadonlyHandlers,
+    shallowReadonlyCollectionHandlers,
+    shallowReadonlyMap
+  );
+}
+function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+  if (!isObject(target)) {
+    if (!!(process.env.NODE_ENV !== "production")) {
+      console.warn(`value cannot be made reactive: ${String(target)}`);
+    }
+    return target;
+  }
+  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
+    return target;
+  }
+  const existingProxy = proxyMap.get(target);
+  if (existingProxy) {
+    return existingProxy;
+  }
+  const targetType = getTargetType(target);
+  if (targetType === 0 /* INVALID */) {
+    return target;
+  }
+  const proxy = new Proxy(
+    target,
+    targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers
+  );
+  proxyMap.set(target, proxy);
+  return proxy;
+}
+function isReactive(value) {
+  if (isReadonly(value)) {
+    return isReactive(value["__v_raw"]);
+  }
+  return !!(value && value["__v_isReactive"]);
+}
+function isReadonly(value) {
+  return !!(value && value["__v_isReadonly"]);
+}
+function isShallow(value) {
+  return !!(value && value["__v_isShallow"]);
+}
+function isProxy(value) {
+  return isReactive(value) || isReadonly(value);
+}
+function toRaw(observed) {
+  const raw = observed && observed["__v_raw"];
+  return raw ? toRaw(raw) : observed;
+}
+function markRaw(value) {
+  def(value, "__v_skip", true);
+  return value;
+}
+const toReactive = (value) => isObject(value) ? reactive(value) : value;
+const toReadonly = (value) => isObject(value) ? readonly(value) : value;
+
+function trackRefValue(ref2) {
+  if (shouldTrack && activeEffect) {
+    ref2 = toRaw(ref2);
+    if (!!(process.env.NODE_ENV !== "production")) {
+      trackEffects(ref2.dep || (ref2.dep = createDep()), {
+        target: ref2,
+        type: "get",
+        key: "value"
+      });
+    } else {
+      trackEffects(ref2.dep || (ref2.dep = createDep()));
+    }
+  }
+}
+function triggerRefValue(ref2, newVal) {
+  ref2 = toRaw(ref2);
+  const dep = ref2.dep;
+  if (dep) {
+    if (!!(process.env.NODE_ENV !== "production")) {
+      triggerEffects(dep, {
+        target: ref2,
+        type: "set",
+        key: "value",
+        newValue: newVal
+      });
+    } else {
+      triggerEffects(dep);
+    }
+  }
+}
+function isRef(r) {
+  return !!(r && r.__v_isRef === true);
+}
+function ref(value) {
+  return createRef(value, false);
+}
+function shallowRef(value) {
+  return createRef(value, true);
+}
+function createRef(rawValue, shallow) {
+  if (isRef(rawValue)) {
+    return rawValue;
+  }
+  return new RefImpl(rawValue, shallow);
+}
+class RefImpl {
+  constructor(value, __v_isShallow) {
+    this.__v_isShallow = __v_isShallow;
+    this.dep = void 0;
+    this.__v_isRef = true;
+    this._rawValue = __v_isShallow ? value : toRaw(value);
+    this._value = __v_isShallow ? value : toReactive(value);
+  }
+  get value() {
+    trackRefValue(this);
+    return this._value;
+  }
+  set value(newVal) {
+    const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
+    newVal = useDirectValue ? newVal : toRaw(newVal);
+    if (hasChanged(newVal, this._rawValue)) {
+      this._rawValue = newVal;
+      this._value = useDirectValue ? newVal : toReactive(newVal);
+      triggerRefValue(this, newVal);
+    }
+  }
+}
+function triggerRef(ref2) {
+  triggerRefValue(ref2, !!(process.env.NODE_ENV !== "production") ? ref2.value : void 0);
+}
+function unref(ref2) {
+  return isRef(ref2) ? ref2.value : ref2;
+}
+function toValue(source) {
+  return isFunction(source) ? source() : unref(source);
+}
+const shallowUnwrapHandlers = {
+  get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
+  set: (target, key, value, receiver) => {
+    const oldValue = target[key];
+    if (isRef(oldValue) && !isRef(value)) {
+      oldValue.value = value;
+      return true;
+    } else {
+      return Reflect.set(target, key, value, receiver);
+    }
+  }
+};
+function proxyRefs(objectWithRefs) {
+  return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
+}
+class CustomRefImpl {
+  constructor(factory) {
+    this.dep = void 0;
+    this.__v_isRef = true;
+    const { get, set } = factory(
+      () => trackRefValue(this),
+      () => triggerRefValue(this)
+    );
+    this._get = get;
+    this._set = set;
+  }
+  get value() {
+    return this._get();
+  }
+  set value(newVal) {
+    this._set(newVal);
+  }
+}
+function customRef(factory) {
+  return new CustomRefImpl(factory);
+}
+function toRefs(object) {
+  if (!!(process.env.NODE_ENV !== "production") && !isProxy(object)) {
+    console.warn(`toRefs() expects a reactive object but received a plain one.`);
+  }
+  const ret = isArray(object) ? new Array(object.length) : {};
+  for (const key in object) {
+    ret[key] = propertyToRef(object, key);
+  }
+  return ret;
+}
+class ObjectRefImpl {
+  constructor(_object, _key, _defaultValue) {
+    this._object = _object;
+    this._key = _key;
+    this._defaultValue = _defaultValue;
+    this.__v_isRef = true;
+  }
+  get value() {
+    const val = this._object[this._key];
+    return val === void 0 ? this._defaultValue : val;
+  }
+  set value(newVal) {
+    this._object[this._key] = newVal;
+  }
+  get dep() {
+    return getDepFromReactive(toRaw(this._object), this._key);
+  }
+}
+class GetterRefImpl {
+  constructor(_getter) {
+    this._getter = _getter;
+    this.__v_isRef = true;
+    this.__v_isReadonly = true;
+  }
+  get value() {
+    return this._getter();
+  }
+}
+function toRef(source, key, defaultValue) {
+  if (isRef(source)) {
+    return source;
+  } else if (isFunction(source)) {
+    return new GetterRefImpl(source);
+  } else if (isObject(source) && arguments.length > 1) {
+    return propertyToRef(source, key, defaultValue);
+  } else {
+    return ref(source);
+  }
+}
+function propertyToRef(source, key, defaultValue) {
+  const val = source[key];
+  return isRef(val) ? val : new ObjectRefImpl(
+    source,
+    key,
+    defaultValue
+  );
+}
+
+class ComputedRefImpl {
+  constructor(getter, _setter, isReadonly, isSSR) {
+    this._setter = _setter;
+    this.dep = void 0;
+    this.__v_isRef = true;
+    this["__v_isReadonly"] = false;
+    this._dirty = true;
+    this.effect = new ReactiveEffect(getter, () => {
+      if (!this._dirty) {
+        this._dirty = true;
+        triggerRefValue(this);
+      }
+    });
+    this.effect.computed = this;
+    this.effect.active = this._cacheable = !isSSR;
+    this["__v_isReadonly"] = isReadonly;
+  }
+  get value() {
+    const self = toRaw(this);
+    trackRefValue(self);
+    if (self._dirty || !self._cacheable) {
+      self._dirty = false;
+      self._value = self.effect.run();
+    }
+    return self._value;
+  }
+  set value(newValue) {
+    this._setter(newValue);
+  }
+}
+function computed(getterOrOptions, debugOptions, isSSR = false) {
+  let getter;
+  let setter;
+  const onlyGetter = isFunction(getterOrOptions);
+  if (onlyGetter) {
+    getter = getterOrOptions;
+    setter = !!(process.env.NODE_ENV !== "production") ? () => {
+      console.warn("Write operation failed: computed value is readonly");
+    } : NOOP;
+  } else {
+    getter = getterOrOptions.get;
+    setter = getterOrOptions.set;
+  }
+  const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
+  if (!!(process.env.NODE_ENV !== "production") && debugOptions && !isSSR) {
+    cRef.effect.onTrack = debugOptions.onTrack;
+    cRef.effect.onTrigger = debugOptions.onTrigger;
+  }
+  return cRef;
+}
+
+const tick = /* @__PURE__ */ Promise.resolve();
+const queue = [];
+let queued = false;
+const scheduler = (fn) => {
+  queue.push(fn);
+  if (!queued) {
+    queued = true;
+    tick.then(flush);
+  }
+};
+const flush = () => {
+  for (let i = 0; i < queue.length; i++) {
+    queue[i]();
+  }
+  queue.length = 0;
+  queued = false;
+};
+class DeferredComputedRefImpl {
+  constructor(getter) {
+    this.dep = void 0;
+    this._dirty = true;
+    this.__v_isRef = true;
+    this["__v_isReadonly"] = true;
+    let compareTarget;
+    let hasCompareTarget = false;
+    let scheduled = false;
+    this.effect = new ReactiveEffect(getter, (computedTrigger) => {
+      if (this.dep) {
+        if (computedTrigger) {
+          compareTarget = this._value;
+          hasCompareTarget = true;
+        } else if (!scheduled) {
+          const valueToCompare = hasCompareTarget ? compareTarget : this._value;
+          scheduled = true;
+          hasCompareTarget = false;
+          scheduler(() => {
+            if (this.effect.active && this._get() !== valueToCompare) {
+              triggerRefValue(this);
+            }
+            scheduled = false;
+          });
+        }
+        for (const e of this.dep) {
+          if (e.computed instanceof DeferredComputedRefImpl) {
+            e.scheduler(
+              true
+              /* computedTrigger */
+            );
+          }
+        }
+      }
+      this._dirty = true;
+    });
+    this.effect.computed = this;
+  }
+  _get() {
+    if (this._dirty) {
+      this._dirty = false;
+      return this._value = this.effect.run();
+    }
+    return this._value;
+  }
+  get value() {
+    trackRefValue(this);
+    return toRaw(this)._get();
+  }
+}
+function deferredComputed(getter) {
+  return new DeferredComputedRefImpl(getter);
+}
+
+export { EffectScope, ITERATE_KEY, ReactiveEffect, computed, customRef, deferredComputed, effect, effectScope, enableTracking, getCurrentScope, isProxy, isReactive, isReadonly, isRef, isShallow, markRaw, onScopeDispose, pauseTracking, proxyRefs, reactive, readonly, ref, resetTracking, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, toValue, track, trigger, triggerRef, unref };
diff --git a/parent_dir/node_modules/vue/runtime-core/dist/runtime-core.esm-bundler.js b/parent_dir/node_modules/vue/runtime-core/dist/runtime-core.esm-bundler.js
new file mode 100644
index 0000000..860d66f
--- /dev/null
+++ b/parent_dir/node_modules/vue/runtime-core/dist/runtime-core.esm-bundler.js
@@ -0,0 +1,7740 @@
+import { pauseTracking, resetTracking, isRef, toRaw, getCurrentScope, isShallow as isShallow$1, isReactive, ReactiveEffect, ref, shallowReadonly, track, reactive, shallowReactive, trigger, isProxy, proxyRefs, markRaw, EffectScope, computed as computed$1, isReadonly } from '@vue/reactivity';
+export { EffectScope, ReactiveEffect, customRef, effect, effectScope, getCurrentScope, isProxy, isReactive, isReadonly, isRef, isShallow, markRaw, onScopeDispose, proxyRefs, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, toValue, triggerRef, unref } from '@vue/reactivity';
+import { isString, isFunction, isPromise, isArray, NOOP, getGlobalThis, extend, EMPTY_OBJ, toHandlerKey, looseToNumber, hyphenate, camelize, isObject, isOn, hasOwn, isModelListener, toNumber, hasChanged, remove, isSet, isMap, isPlainObject, isBuiltInDirective, invokeArrayFns, isRegExp, capitalize, isGloballyWhitelisted, NO, def, isReservedProp, EMPTY_ARR, toRawType, makeMap, normalizeClass, normalizeStyle } from '@vue/shared';
+export { camelize, capitalize, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey } from '@vue/shared';
+
+const stack = [];
+function pushWarningContext(vnode) {
+  stack.push(vnode);
+}
+function popWarningContext() {
+  stack.pop();
+}
+function warn(msg, ...args) {
+  if (!!!(process.env.NODE_ENV !== "production"))
+    return;
+  pauseTracking();
+  const instance = stack.length ? stack[stack.length - 1].component : null;
+  const appWarnHandler = instance && instance.appContext.config.warnHandler;
+  const trace = getComponentTrace();
+  if (appWarnHandler) {
+    callWithErrorHandling(
+      appWarnHandler,
+      instance,
+      11,
+      [
+        msg + args.join(""),
+        instance && instance.proxy,
+        trace.map(
+          ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
+        ).join("\n"),
+        trace
+      ]
+    );
+  } else {
+    const warnArgs = [`[Vue warn]: ${msg}`, ...args];
+    if (trace.length && // avoid spamming console during tests
+    true) {
+      warnArgs.push(`
+`, ...formatTrace(trace));
+    }
+    console.warn(...warnArgs);
+  }
+  resetTracking();
+}
+function getComponentTrace() {
+  let currentVNode = stack[stack.length - 1];
+  if (!currentVNode) {
+    return [];
+  }
+  const normalizedStack = [];
+  while (currentVNode) {
+    const last = normalizedStack[0];
+    if (last && last.vnode === currentVNode) {
+      last.recurseCount++;
+    } else {
+      normalizedStack.push({
+        vnode: currentVNode,
+        recurseCount: 0
+      });
+    }
+    const parentInstance = currentVNode.component && currentVNode.component.parent;
+    currentVNode = parentInstance && parentInstance.vnode;
+  }
+  return normalizedStack;
+}
+function formatTrace(trace) {
+  const logs = [];
+  trace.forEach((entry, i) => {
+    logs.push(...i === 0 ? [] : [`
+`], ...formatTraceEntry(entry));
+  });
+  return logs;
+}
+function formatTraceEntry({ vnode, recurseCount }) {
+  const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
+  const isRoot = vnode.component ? vnode.component.parent == null : false;
+  const open = ` at <${formatComponentName(
+    vnode.component,
+    vnode.type,
+    isRoot
+  )}`;
+  const close = `>` + postfix;
+  return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
+}
+function formatProps(props) {
+  const res = [];
+  const keys = Object.keys(props);
+  keys.slice(0, 3).forEach((key) => {
+    res.push(...formatProp(key, props[key]));
+  });
+  if (keys.length > 3) {
+    res.push(` ...`);
+  }
+  return res;
+}
+function formatProp(key, value, raw) {
+  if (isString(value)) {
+    value = JSON.stringify(value);
+    return raw ? value : [`${key}=${value}`];
+  } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
+    return raw ? value : [`${key}=${value}`];
+  } else if (isRef(value)) {
+    value = formatProp(key, toRaw(value.value), true);
+    return raw ? value : [`${key}=Ref<`, value, `>`];
+  } else if (isFunction(value)) {
+    return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+  } else {
+    value = toRaw(value);
+    return raw ? value : [`${key}=`, value];
+  }
+}
+function assertNumber(val, type) {
+  if (!!!(process.env.NODE_ENV !== "production"))
+    return;
+  if (val === void 0) {
+    return;
+  } else if (typeof val !== "number") {
+    warn(`${type} is not a valid number - got ${JSON.stringify(val)}.`);
+  } else if (isNaN(val)) {
+    warn(`${type} is NaN - the duration expression might be incorrect.`);
+  }
+}
+
+const ErrorTypeStrings = {
+  ["sp"]: "serverPrefetch hook",
+  ["bc"]: "beforeCreate hook",
+  ["c"]: "created hook",
+  ["bm"]: "beforeMount hook",
+  ["m"]: "mounted hook",
+  ["bu"]: "beforeUpdate hook",
+  ["u"]: "updated",
+  ["bum"]: "beforeUnmount hook",
+  ["um"]: "unmounted hook",
+  ["a"]: "activated hook",
+  ["da"]: "deactivated hook",
+  ["ec"]: "errorCaptured hook",
+  ["rtc"]: "renderTracked hook",
+  ["rtg"]: "renderTriggered hook",
+  [0]: "setup function",
+  [1]: "render function",
+  [2]: "watcher getter",
+  [3]: "watcher callback",
+  [4]: "watcher cleanup function",
+  [5]: "native event handler",
+  [6]: "component event handler",
+  [7]: "vnode hook",
+  [8]: "directive hook",
+  [9]: "transition hook",
+  [10]: "app errorHandler",
+  [11]: "app warnHandler",
+  [12]: "ref function",
+  [13]: "async component loader",
+  [14]: "scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core"
+};
+function callWithErrorHandling(fn, instance, type, args) {
+  let res;
+  try {
+    res = args ? fn(...args) : fn();
+  } catch (err) {
+    handleError(err, instance, type);
+  }
+  return res;
+}
+function callWithAsyncErrorHandling(fn, instance, type, args) {
+  if (isFunction(fn)) {
+    const res = callWithErrorHandling(fn, instance, type, args);
+    if (res && isPromise(res)) {
+      res.catch((err) => {
+        handleError(err, instance, type);
+      });
+    }
+    return res;
+  }
+  const values = [];
+  for (let i = 0; i < fn.length; i++) {
+    values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
+  }
+  return values;
+}
+function handleError(err, instance, type, throwInDev = true) {
+  const contextVNode = instance ? instance.vnode : null;
+  if (instance) {
+    let cur = instance.parent;
+    const exposedInstance = instance.proxy;
+    const errorInfo = !!(process.env.NODE_ENV !== "production") ? ErrorTypeStrings[type] : type;
+    while (cur) {
+      const errorCapturedHooks = cur.ec;
+      if (errorCapturedHooks) {
+        for (let i = 0; i < errorCapturedHooks.length; i++) {
+          if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
+            return;
+          }
+        }
+      }
+      cur = cur.parent;
+    }
+    const appErrorHandler = instance.appContext.config.errorHandler;
+    if (appErrorHandler) {
+      callWithErrorHandling(
+        appErrorHandler,
+        null,
+        10,
+        [err, exposedInstance, errorInfo]
+      );
+      return;
+    }
+  }
+  logError(err, type, contextVNode, throwInDev);
+}
+function logError(err, type, contextVNode, throwInDev = true) {
+  if (!!(process.env.NODE_ENV !== "production")) {
+    const info = ErrorTypeStrings[type];
+    if (contextVNode) {
+      pushWarningContext(contextVNode);
+    }
+    warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+    if (contextVNode) {
+      popWarningContext();
+    }
+    if (throwInDev) {
+      throw err;
+    } else {
+      console.error(err);
+    }
+  } else {
+    console.error(err);
+  }
+}
+
+let isFlushing = false;
+let isFlushPending = false;
+const queue = [];
+let flushIndex = 0;
+const pendingPostFlushCbs = [];
+let activePostFlushCbs = null;
+let postFlushIndex = 0;
+const resolvedPromise = /* @__PURE__ */ Promise.resolve();
+let currentFlushPromise = null;
+const RECURSION_LIMIT = 100;
+function nextTick(fn) {
+  const p = currentFlushPromise || resolvedPromise;
+  return fn ? p.then(this ? fn.bind(this) : fn) : p;
+}
+function findInsertionIndex(id) {
+  let start = flushIndex + 1;
+  let end = queue.length;
+  while (start < end) {
+    const middle = start + end >>> 1;
+    const middleJobId = getId(queue[middle]);
+    middleJobId < id ? start = middle + 1 : end = middle;
+  }
+  return start;
+}
+function queueJob(job) {
+  if (!queue.length || !queue.includes(
+    job,
+    isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex
+  )) {
+    if (job.id == null) {
+      queue.push(job);
+    } else {
+      queue.splice(findInsertionIndex(job.id), 0, job);
+    }
+    queueFlush();
+  }
+}
+function queueFlush() {
+  if (!isFlushing && !isFlushPending) {
+    isFlushPending = true;
+    currentFlushPromise = resolvedPromise.then(flushJobs);
+  }
+}
+function invalidateJob(job) {
+  const i = queue.indexOf(job);
+  if (i > flushIndex) {
+    queue.splice(i, 1);
+  }
+}
+function queuePostFlushCb(cb) {
+  if (!isArray(cb)) {
+    if (!activePostFlushCbs || !activePostFlushCbs.includes(
+      cb,
+      cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex
+    )) {
+      pendingPostFlushCbs.push(cb);
+    }
+  } else {
+    pendingPostFlushCbs.push(...cb);
+  }
+  queueFlush();
+}
+function flushPreFlushCbs(seen, i = isFlushing ? flushIndex + 1 : 0) {
+  if (!!(process.env.NODE_ENV !== "production")) {
+    seen = seen || /* @__PURE__ */ new Map();
+  }
+  for (; i < queue.length; i++) {
+    const cb = queue[i];
+    if (cb && cb.pre) {
+      if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates(seen, cb)) {
+        continue;
+      }
+      queue.splice(i, 1);
+      i--;
+      cb();
+    }
+  }
+}
+function flushPostFlushCbs(seen) {
+  if (pendingPostFlushCbs.length) {
+    const deduped = [...new Set(pendingPostFlushCbs)];
+    pendingPostFlushCbs.length = 0;
+    if (activePostFlushCbs) {
+      activePostFlushCbs.push(...deduped);
+      return;
+    }
+    activePostFlushCbs = deduped;
+    if (!!(process.env.NODE_ENV !== "production")) {
+      seen = seen || /* @__PURE__ */ new Map();
+    }
+    activePostFlushCbs.sort((a, b) => getId(a) - getId(b));
+    for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
+      if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) {
+        continue;
+      }
+      activePostFlushCbs[postFlushIndex]();
+    }
+    activePostFlushCbs = null;
+    postFlushIndex = 0;
+  }
+}
+const getId = (job) => job.id == null ? Infinity : job.id;
+const comparator = (a, b) => {
+  const diff = getId(a) - getId(b);
+  if (diff === 0) {
+    if (a.pre && !b.pre)
+      return -1;
+    if (b.pre && !a.pre)
+      return 1;
+  }
+  return diff;
+};
+function flushJobs(seen) {
+  isFlushPending = false;
+  isFlushing = true;
+  if (!!(process.env.NODE_ENV !== "production")) {
+    seen = seen || /* @__PURE__ */ new Map();
+  }
+  queue.sort(comparator);
+  const check = !!(process.env.NODE_ENV !== "production") ? (job) => checkRecursiveUpdates(seen, job) : NOOP;
+  try {
+    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
+      const job = queue[flushIndex];
+      if (job && job.active !== false) {
+        if (!!(process.env.NODE_ENV !== "production") && check(job)) {
+          continue;
+        }
+        callWithErrorHandling(job, null, 14);
+      }
+    }
+  } finally {
+    flushIndex = 0;
+    queue.length = 0;
+    flushPostFlushCbs(seen);
+    isFlushing = false;
+    currentFlushPromise = null;
+    if (queue.length || pendingPostFlushCbs.length) {
+      flushJobs(seen);
+    }
+  }
+}
+function checkRecursiveUpdates(seen, fn) {
+  if (!seen.has(fn)) {
+    seen.set(fn, 1);
+  } else {
+    const count = seen.get(fn);
+    if (count > RECURSION_LIMIT) {
+      const instance = fn.ownerInstance;
+      const componentName = instance && getComponentName(instance.type);
+      warn(
+        `Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`
+      );
+      return true;
+    } else {
+      seen.set(fn, count + 1);
+    }
+  }
+}
+
+let isHmrUpdating = false;
+const hmrDirtyComponents = /* @__PURE__ */ new Set();
+if (!!(process.env.NODE_ENV !== "production")) {
+  getGlobalThis().__VUE_HMR_RUNTIME__ = {
+    createRecord: tryWrap(createRecord),
+    rerender: tryWrap(rerender),
+    reload: tryWrap(reload)
+  };
+}
+const map = /* @__PURE__ */ new Map();
+function registerHMR(instance) {
+  const id = instance.type.__hmrId;
+  let record = map.get(id);
+  if (!record) {
+    createRecord(id, instance.type);
+    record = map.get(id);
+  }
+  record.instances.add(instance);
+}
+function unregisterHMR(instance) {
+  map.get(instance.type.__hmrId).instances.delete(instance);
+}
+function createRecord(id, initialDef) {
+  if (map.has(id)) {
+    return false;
+  }
+  map.set(id, {
+    initialDef: normalizeClassComponent(initialDef),
+    instances: /* @__PURE__ */ new Set()
+  });
+  return true;
+}
+function normalizeClassComponent(component) {
+  return isClassComponent(component) ? component.__vccOpts : component;
+}
+function rerender(id, newRender) {
+  const record = map.get(id);
+  if (!record) {
+    return;
+  }
+  record.initialDef.render = newRender;
+  [...record.instances].forEach((instance) => {
+    if (newRender) {
+      instance.render = newRender;
+      normalizeClassComponent(instance.type).render = newRender;
+    }
+    instance.renderCache = [];
+    isHmrUpdating = true;
+    instance.update();
+    isHmrUpdating = false;
+  });
+}
+function reload(id, newComp) {
+  const record = map.get(id);
+  if (!record)
+    return;
+  newComp = normalizeClassComponent(newComp);
+  updateComponentDef(record.initialDef, newComp);
+  const instances = [...record.instances];
+  for (const instance of instances) {
+    const oldComp = normalizeClassComponent(instance.type);
+    if (!hmrDirtyComponents.has(oldComp)) {
+      if (oldComp !== record.initialDef) {
+        updateComponentDef(oldComp, newComp);
+      }
+      hmrDirtyComponents.add(oldComp);
+    }
+    instance.appContext.propsCache.delete(instance.type);
+    instance.appContext.emitsCache.delete(instance.type);
+    instance.appContext.optionsCache.delete(instance.type);
+    if (instance.ceReload) {
+      hmrDirtyComponents.add(oldComp);
+      instance.ceReload(newComp.styles);
+      hmrDirtyComponents.delete(oldComp);
+    } else if (instance.parent) {
+      queueJob(instance.parent.update);
+    } else if (instance.appContext.reload) {
+      instance.appContext.reload();
+    } else if (typeof window !== "undefined") {
+      window.location.reload();
+    } else {
+      console.warn(
+        "[HMR] Root or manually mounted instance modified. Full reload required."
+      );
+    }
+  }
+  queuePostFlushCb(() => {
+    for (const instance of instances) {
+      hmrDirtyComponents.delete(
+        normalizeClassComponent(instance.type)
+      );
+    }
+  });
+}
+function updateComponentDef(oldComp, newComp) {
+  extend(oldComp, newComp);
+  for (const key in oldComp) {
+    if (key !== "__file" && !(key in newComp)) {
+      delete oldComp[key];
+    }
+  }
+}
+function tryWrap(fn) {
+  return (id, arg) => {
+    try {
+      return fn(id, arg);
+    } catch (e) {
+      console.error(e);
+      console.warn(
+        `[HMR] Something went wrong during Vue component hot-reload. Full reload required.`
+      );
+    }
+  };
+}
+
+let devtools;
+let buffer = [];
+let devtoolsNotInstalled = false;
+function emit$1(event, ...args) {
+  if (devtools) {
+    devtools.emit(event, ...args);
+  } else if (!devtoolsNotInstalled) {
+    buffer.push({ event, args });
+  }
+}
+function setDevtoolsHook(hook, target) {
+  var _a, _b;
+  devtools = hook;
+  if (devtools) {
+    devtools.enabled = true;
+    buffer.forEach(({ event, args }) => devtools.emit(event, ...args));
+    buffer = [];
+  } else if (
+    // handle late devtools injection - only do this if we are in an actual
+    // browser environment to avoid the timer handle stalling test runner exit
+    // (#4815)
+    typeof window !== "undefined" && // some envs mock window but not fully
+    window.HTMLElement && // also exclude jsdom
+    !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
+  ) {
+    const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
+    replay.push((newHook) => {
+      setDevtoolsHook(newHook, target);
+    });
+    setTimeout(() => {
+      if (!devtools) {
+        target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
+        devtoolsNotInstalled = true;
+        buffer = [];
+      }
+    }, 3e3);
+  } else {
+    devtoolsNotInstalled = true;
+    buffer = [];
+  }
+}
+function devtoolsInitApp(app, version) {
+  emit$1("app:init" /* APP_INIT */, app, version, {
+    Fragment,
+    Text,
+    Comment,
+    Static
+  });
+}
+function devtoolsUnmountApp(app) {
+  emit$1("app:unmount" /* APP_UNMOUNT */, app);
+}
+const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook(
+  "component:added" /* COMPONENT_ADDED */
+);
+const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */);
+const _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook(
+  "component:removed" /* COMPONENT_REMOVED */
+);
+const devtoolsComponentRemoved = (component) => {
+  if (devtools && typeof devtools.cleanupBuffer === "function" && // remove the component if it wasn't buffered
+  !devtools.cleanupBuffer(component)) {
+    _devtoolsComponentRemoved(component);
+  }
+};
+function createDevtoolsComponentHook(hook) {
+  return (component) => {
+    emit$1(
+      hook,
+      component.appContext.app,
+      component.uid,
+      component.parent ? component.parent.uid : void 0,
+      component
+    );
+  };
+}
+const devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook(
+  "perf:start" /* PERFORMANCE_START */
+);
+const devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook(
+  "perf:end" /* PERFORMANCE_END */
+);
+function createDevtoolsPerformanceHook(hook) {
+  return (component, type, time) => {
+    emit$1(hook, component.appContext.app, component.uid, component, type, time);
+  };
+}
+function devtoolsComponentEmit(component, event, params) {
+  emit$1(
+    "component:emit" /* COMPONENT_EMIT */,
+    component.appContext.app,
+    component,
+    event,
+    params
+  );
+}
+
+function emit(instance, event, ...rawArgs) {
+  if (instance.isUnmounted)
+    return;
+  const props = instance.vnode.props || EMPTY_OBJ;
+  if (!!(process.env.NODE_ENV !== "production")) {
+    const {
+      emitsOptions,
+      propsOptions: [propsOptions]
+    } = instance;
+    if (emitsOptions) {
+      if (!(event in emitsOptions) && true) {
+        if (!propsOptions || !(toHandlerKey(event) in propsOptions)) {
+          warn(
+            `Component emitted event "${event}" but it is neither declared in the emits option nor as an "${toHandlerKey(event)}" prop.`
+          );
+        }
+      } else {
+        const validator = emitsOptions[event];
+        if (isFunction(validator)) {
+          const isValid = validator(...rawArgs);
+          if (!isValid) {
+            warn(
+              `Invalid event arguments: event validation failed for event "${event}".`
+            );
+          }
+        }
+      }
+    }
+  }
+  let args = rawArgs;
+  const isModelListener = event.startsWith("update:");
+  const modelArg = isModelListener && event.slice(7);
+  if (modelArg && modelArg in props) {
+    const modifiersKey = `${modelArg === "modelValue" ? "model" : modelArg}Modifiers`;
+    const { number, trim } = props[modifiersKey] || EMPTY_OBJ;
+    if (trim) {
+      args = rawArgs.map((a) => isString(a) ? a.trim() : a);
+    }
+    if (number) {
+      args = rawArgs.map(looseToNumber);
+    }
+  }
+  if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+    devtoolsComponentEmit(instance, event, args);
+  }
+  if (!!(process.env.NODE_ENV !== "production")) {
+    const lowerCaseEvent = event.toLowerCase();
+    if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) {
+      warn(
+        `Event "${lowerCaseEvent}" is emitted in component ${formatComponentName(
+          instance,
+          instance.type
+        )} but the handler is registered for "${event}". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "${hyphenate(event)}" instead of "${event}".`
+      );
+    }
+  }
+  let handlerName;
+  let handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249)
+  props[handlerName = toHandlerKey(camelize(event))];
+  if (!handler && isModelListener) {
+    handler = props[handlerName = toHandlerKey(hyphenate(event))];
+  }
+  if (handler) {
+    callWithAsyncErrorHandling(
+      handler,
+      instance,
+      6,
+      args
+    );
+  }
+  const onceHandler = props[handlerName + `Once`];
+  if (onceHandler) {
+    if (!instance.emitted) {
+      instance.emitted = {};
+    } else if (instance.emitted[handlerName]) {
+      return;
+    }
+    instance.emitted[handlerName] = true;
+    callWithAsyncErrorHandling(
+      onceHandler,
+      instance,
+      6,
+      args
+    );
+  }
+}
+function normalizeEmitsOptions(comp, appContext, asMixin = false) {
+  const cache = appContext.emitsCache;
+  const cached = cache.get(comp);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const raw = comp.emits;
+  let normalized = {};
+  let hasExtends = false;
+  if (__VUE_OPTIONS_API__ && !isFunction(comp)) {
+    const extendEmits = (raw2) => {
+      const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
+      if (normalizedFromExtend) {
+        hasExtends = true;
+        extend(normalized, normalizedFromExtend);
+      }
+    };
+    if (!asMixin && appContext.mixins.length) {
+      appContext.mixins.forEach(extendEmits);
+    }
+    if (comp.extends) {
+      extendEmits(comp.extends);
+    }
+    if (comp.mixins) {
+      comp.mixins.forEach(extendEmits);
+    }
+  }
+  if (!raw && !hasExtends) {
+    if (isObject(comp)) {
+      cache.set(comp, null);
+    }
+    return null;
+  }
+  if (isArray(raw)) {
+    raw.forEach((key) => normalized[key] = null);
+  } else {
+    extend(normalized, raw);
+  }
+  if (isObject(comp)) {
+    cache.set(comp, normalized);
+  }
+  return normalized;
+}
+function isEmitListener(options, key) {
+  if (!options || !isOn(key)) {
+    return false;
+  }
+  key = key.slice(2).replace(/Once$/, "");
+  return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key);
+}
+
+let currentRenderingInstance = null;
+let currentScopeId = null;
+function setCurrentRenderingInstance(instance) {
+  const prev = currentRenderingInstance;
+  currentRenderingInstance = instance;
+  currentScopeId = instance && instance.type.__scopeId || null;
+  return prev;
+}
+function pushScopeId(id) {
+  currentScopeId = id;
+}
+function popScopeId() {
+  currentScopeId = null;
+}
+const withScopeId = (_id) => withCtx;
+function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
+  if (!ctx)
+    return fn;
+  if (fn._n) {
+    return fn;
+  }
+  const renderFnWithContext = (...args) => {
+    if (renderFnWithContext._d) {
+      setBlockTracking(-1);
+    }
+    const prevInstance = setCurrentRenderingInstance(ctx);
+    let res;
+    try {
+      res = fn(...args);
+    } finally {
+      setCurrentRenderingInstance(prevInstance);
+      if (renderFnWithContext._d) {
+        setBlockTracking(1);
+      }
+    }
+    if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+      devtoolsComponentUpdated(ctx);
+    }
+    return res;
+  };
+  renderFnWithContext._n = true;
+  renderFnWithContext._c = true;
+  renderFnWithContext._d = true;
+  return renderFnWithContext;
+}
+
+let accessedAttrs = false;
+function markAttrsAccessed() {
+  accessedAttrs = true;
+}
+function renderComponentRoot(instance) {
+  const {
+    type: Component,
+    vnode,
+    proxy,
+    withProxy,
+    props,
+    propsOptions: [propsOptions],
+    slots,
+    attrs,
+    emit,
+    render,
+    renderCache,
+    data,
+    setupState,
+    ctx,
+    inheritAttrs
+  } = instance;
+  let result;
+  let fallthroughAttrs;
+  const prev = setCurrentRenderingInstance(instance);
+  if (!!(process.env.NODE_ENV !== "production")) {
+    accessedAttrs = false;
+  }
+  try {
+    if (vnode.shapeFlag & 4) {
+      const proxyToUse = withProxy || proxy;
+      result = normalizeVNode(
+        render.call(
+          proxyToUse,
+          proxyToUse,
+          renderCache,
+          props,
+          setupState,
+          data,
+          ctx
+        )
+      );
+      fallthroughAttrs = attrs;
+    } else {
+      const render2 = Component;
+      if (!!(process.env.NODE_ENV !== "production") && attrs === props) {
+        markAttrsAccessed();
+      }
+      result = normalizeVNode(
+        render2.length > 1 ? render2(
+          props,
+          !!(process.env.NODE_ENV !== "production") ? {
+            get attrs() {
+              markAttrsAccessed();
+              return attrs;
+            },
+            slots,
+            emit
+          } : { attrs, slots, emit }
+        ) : render2(
+          props,
+          null
+          /* we know it doesn't need it */
+        )
+      );
+      fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
+    }
+  } catch (err) {
+    blockStack.length = 0;
+    handleError(err, instance, 1);
+    result = createVNode(Comment);
+  }
+  let root = result;
+  let setRoot = void 0;
+  if (!!(process.env.NODE_ENV !== "production") && result.patchFlag > 0 && result.patchFlag & 2048) {
+    [root, setRoot] = getChildRoot(result);
+  }
+  if (fallthroughAttrs && inheritAttrs !== false) {
+    const keys = Object.keys(fallthroughAttrs);
+    const { shapeFlag } = root;
+    if (keys.length) {
+      if (shapeFlag & (1 | 6)) {
+        if (propsOptions && keys.some(isModelListener)) {
+          fallthroughAttrs = filterModelListeners(
+            fallthroughAttrs,
+            propsOptions
+          );
+        }
+        root = cloneVNode(root, fallthroughAttrs);
+      } else if (!!(process.env.NODE_ENV !== "production") && !accessedAttrs && root.type !== Comment) {
+        const allAttrs = Object.keys(attrs);
+        const eventAttrs = [];
+        const extraAttrs = [];
+        for (let i = 0, l = allAttrs.length; i < l; i++) {
+          const key = allAttrs[i];
+          if (isOn(key)) {
+            if (!isModelListener(key)) {
+              eventAttrs.push(key[2].toLowerCase() + key.slice(3));
+            }
+          } else {
+            extraAttrs.push(key);
+          }
+        }
+        if (extraAttrs.length) {
+          warn(
+            `Extraneous non-props attributes (${extraAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes.`
+          );
+        }
+        if (eventAttrs.length) {
+          warn(
+            `Extraneous non-emits event listeners (${eventAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes. If the listener is intended to be a component custom event listener only, declare it using the "emits" option.`
+          );
+        }
+      }
+    }
+  }
+  if (vnode.dirs) {
+    if (!!(process.env.NODE_ENV !== "production") && !isElementRoot(root)) {
+      warn(
+        `Runtime directive used on component with non-element root node. The directives will not function as intended.`
+      );
+    }
+    root = cloneVNode(root);
+    root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
+  }
+  if (vnode.transition) {
+    if (!!(process.env.NODE_ENV !== "production") && !isElementRoot(root)) {
+      warn(
+        `Component inside <Transition> renders non-element root node that cannot be animated.`
+      );
+    }
+    root.transition = vnode.transition;
+  }
+  if (!!(process.env.NODE_ENV !== "production") && setRoot) {
+    setRoot(root);
+  } else {
+    result = root;
+  }
+  setCurrentRenderingInstance(prev);
+  return result;
+}
+const getChildRoot = (vnode) => {
+  const rawChildren = vnode.children;
+  const dynamicChildren = vnode.dynamicChildren;
+  const childRoot = filterSingleRoot(rawChildren);
+  if (!childRoot) {
+    return [vnode, void 0];
+  }
+  const index = rawChildren.indexOf(childRoot);
+  const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;
+  const setRoot = (updatedRoot) => {
+    rawChildren[index] = updatedRoot;
+    if (dynamicChildren) {
+      if (dynamicIndex > -1) {
+        dynamicChildren[dynamicIndex] = updatedRoot;
+      } else if (updatedRoot.patchFlag > 0) {
+        vnode.dynamicChildren = [...dynamicChildren, updatedRoot];
+      }
+    }
+  };
+  return [normalizeVNode(childRoot), setRoot];
+};
+function filterSingleRoot(children) {
+  let singleRoot;
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    if (isVNode(child)) {
+      if (child.type !== Comment || child.children === "v-if") {
+        if (singleRoot) {
+          return;
+        } else {
+          singleRoot = child;
+        }
+      }
+    } else {
+      return;
+    }
+  }
+  return singleRoot;
+}
+const getFunctionalFallthrough = (attrs) => {
+  let res;
+  for (const key in attrs) {
+    if (key === "class" || key === "style" || isOn(key)) {
+      (res || (res = {}))[key] = attrs[key];
+    }
+  }
+  return res;
+};
+const filterModelListeners = (attrs, props) => {
+  const res = {};
+  for (const key in attrs) {
+    if (!isModelListener(key) || !(key.slice(9) in props)) {
+      res[key] = attrs[key];
+    }
+  }
+  return res;
+};
+const isElementRoot = (vnode) => {
+  return vnode.shapeFlag & (6 | 1) || vnode.type === Comment;
+};
+function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
+  const { props: prevProps, children: prevChildren, component } = prevVNode;
+  const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
+  const emits = component.emitsOptions;
+  if (!!(process.env.NODE_ENV !== "production") && (prevChildren || nextChildren) && isHmrUpdating) {
+    return true;
+  }
+  if (nextVNode.dirs || nextVNode.transition) {
+    return true;
+  }
+  if (optimized && patchFlag >= 0) {
+    if (patchFlag & 1024) {
+      return true;
+    }
+    if (patchFlag & 16) {
+      if (!prevProps) {
+        return !!nextProps;
+      }
+      return hasPropsChanged(prevProps, nextProps, emits);
+    } else if (patchFlag & 8) {
+      const dynamicProps = nextVNode.dynamicProps;
+      for (let i = 0; i < dynamicProps.length; i++) {
+        const key = dynamicProps[i];
+        if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
+          return true;
+        }
+      }
+    }
+  } else {
+    if (prevChildren || nextChildren) {
+      if (!nextChildren || !nextChildren.$stable) {
+        return true;
+      }
+    }
+    if (prevProps === nextProps) {
+      return false;
+    }
+    if (!prevProps) {
+      return !!nextProps;
+    }
+    if (!nextProps) {
+      return true;
+    }
+    return hasPropsChanged(prevProps, nextProps, emits);
+  }
+  return false;
+}
+function hasPropsChanged(prevProps, nextProps, emitsOptions) {
+  const nextKeys = Object.keys(nextProps);
+  if (nextKeys.length !== Object.keys(prevProps).length) {
+    return true;
+  }
+  for (let i = 0; i < nextKeys.length; i++) {
+    const key = nextKeys[i];
+    if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {
+      return true;
+    }
+  }
+  return false;
+}
+function updateHOCHostEl({ vnode, parent }, el) {
+  while (parent && parent.subTree === vnode) {
+    (vnode = parent.vnode).el = el;
+    parent = parent.parent;
+  }
+}
+
+const isSuspense = (type) => type.__isSuspense;
+const SuspenseImpl = {
+  name: "Suspense",
+  // In order to make Suspense tree-shakable, we need to avoid importing it
+  // directly in the renderer. The renderer checks for the __isSuspense flag
+  // on a vnode's type and calls the `process` method, passing in renderer
+  // internals.
+  __isSuspense: true,
+  process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) {
+    if (n1 == null) {
+      mountSuspense(
+        n2,
+        container,
+        anchor,
+        parentComponent,
+        parentSuspense,
+        isSVG,
+        slotScopeIds,
+        optimized,
+        rendererInternals
+      );
+    } else {
+      patchSuspense(
+        n1,
+        n2,
+        container,
+        anchor,
+        parentComponent,
+        isSVG,
+        slotScopeIds,
+        optimized,
+        rendererInternals
+      );
+    }
+  },
+  hydrate: hydrateSuspense,
+  create: createSuspenseBoundary,
+  normalize: normalizeSuspenseChildren
+};
+const Suspense = SuspenseImpl ;
+function triggerEvent(vnode, name) {
+  const eventListener = vnode.props && vnode.props[name];
+  if (isFunction(eventListener)) {
+    eventListener();
+  }
+}
+function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) {
+  const {
+    p: patch,
+    o: { createElement }
+  } = rendererInternals;
+  const hiddenContainer = createElement("div");
+  const suspense = vnode.suspense = createSuspenseBoundary(
+    vnode,
+    parentSuspense,
+    parentComponent,
+    container,
+    hiddenContainer,
+    anchor,
+    isSVG,
+    slotScopeIds,
+    optimized,
+    rendererInternals
+  );
+  patch(
+    null,
+    suspense.pendingBranch = vnode.ssContent,
+    hiddenContainer,
+    null,
+    parentComponent,
+    suspense,
+    isSVG,
+    slotScopeIds
+  );
+  if (suspense.deps > 0) {
+    triggerEvent(vnode, "onPending");
+    triggerEvent(vnode, "onFallback");
+    patch(
+      null,
+      vnode.ssFallback,
+      container,
+      anchor,
+      parentComponent,
+      null,
+      // fallback tree will not have suspense context
+      isSVG,
+      slotScopeIds
+    );
+    setActiveBranch(suspense, vnode.ssFallback);
+  } else {
+    suspense.resolve(false, true);
+  }
+}
+function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) {
+  const suspense = n2.suspense = n1.suspense;
+  suspense.vnode = n2;
+  n2.el = n1.el;
+  const newBranch = n2.ssContent;
+  const newFallback = n2.ssFallback;
+  const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;
+  if (pendingBranch) {
+    suspense.pendingBranch = newBranch;
+    if (isSameVNodeType(newBranch, pendingBranch)) {
+      patch(
+        pendingBranch,
+        newBranch,
+        suspense.hiddenContainer,
+        null,
+        parentComponent,
+        suspense,
+        isSVG,
+        slotScopeIds,
+        optimized
+      );
+      if (suspense.deps <= 0) {
+        suspense.resolve();
+      } else if (isInFallback) {
+        patch(
+          activeBranch,
+          newFallback,
+          container,
+          anchor,
+          parentComponent,
+          null,
+          // fallback tree will not have suspense context
+          isSVG,
+          slotScopeIds,
+          optimized
+        );
+        setActiveBranch(suspense, newFallback);
+      }
+    } else {
+      suspense.pendingId++;
+      if (isHydrating) {
+        suspense.isHydrating = false;
+        suspense.activeBranch = pendingBranch;
+      } else {
+        unmount(pendingBranch, parentComponent, suspense);
+      }
+      suspense.deps = 0;
+      suspense.effects.length = 0;
+      suspense.hiddenContainer = createElement("div");
+      if (isInFallback) {
+        patch(
+          null,
+          newBranch,
+          suspense.hiddenContainer,
+          null,
+          parentComponent,
+          suspense,
+          isSVG,
+          slotScopeIds,
+          optimized
+        );
+        if (suspense.deps <= 0) {
+          suspense.resolve();
+        } else {
+          patch(
+            activeBranch,
+            newFallback,
+            container,
+            anchor,
+            parentComponent,
+            null,
+            // fallback tree will not have suspense context
+            isSVG,
+            slotScopeIds,
+            optimized
+          );
+          setActiveBranch(suspense, newFallback);
+        }
+      } else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
+        patch(
+          activeBranch,
+          newBranch,
+          container,
+          anchor,
+          parentComponent,
+          suspense,
+          isSVG,
+          slotScopeIds,
+          optimized
+        );
+        suspense.resolve(true);
+      } else {
+        patch(
+          null,
+          newBranch,
+          suspense.hiddenContainer,
+          null,
+          parentComponent,
+          suspense,
+          isSVG,
+          slotScopeIds,
+          optimized
+        );
+        if (suspense.deps <= 0) {
+          suspense.resolve();
+        }
+      }
+    }
+  } else {
+    if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
+      patch(
+        activeBranch,
+        newBranch,
+        container,
+        anchor,
+        parentComponent,
+        suspense,
+        isSVG,
+        slotScopeIds,
+        optimized
+      );
+      setActiveBranch(suspense, newBranch);
+    } else {
+      triggerEvent(n2, "onPending");
+      suspense.pendingBranch = newBranch;
+      suspense.pendingId++;
+      patch(
+        null,
+        newBranch,
+        suspense.hiddenContainer,
+        null,
+        parentComponent,
+        suspense,
+        isSVG,
+        slotScopeIds,
+        optimized
+      );
+      if (suspense.deps <= 0) {
+        suspense.resolve();
+      } else {
+        const { timeout, pendingId } = suspense;
+        if (timeout > 0) {
+          setTimeout(() => {
+            if (suspense.pendingId === pendingId) {
+              suspense.fallback(newFallback);
+            }
+          }, timeout);
+        } else if (timeout === 0) {
+          suspense.fallback(newFallback);
+        }
+      }
+    }
+  }
+}
+let hasWarned = false;
+function createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
+  if (!!(process.env.NODE_ENV !== "production") && true && !hasWarned) {
+    hasWarned = true;
+    console[console.info ? "info" : "log"](
+      `<Suspense> is an experimental feature and its API will likely change.`
+    );
+  }
+  const {
+    p: patch,
+    m: move,
+    um: unmount,
+    n: next,
+    o: { parentNode, remove }
+  } = rendererInternals;
+  let parentSuspenseId;
+  const isSuspensible = isVNodeSuspensible(vnode);
+  if (isSuspensible) {
+    if (parentSuspense == null ? void 0 : parentSuspense.pendingBranch) {
+      parentSuspenseId = parentSuspense.pendingId;
+      parentSuspense.deps++;
+    }
+  }
+  const timeout = vnode.props ? toNumber(vnode.props.timeout) : void 0;
+  if (!!(process.env.NODE_ENV !== "production")) {
+    assertNumber(timeout, `Suspense timeout`);
+  }
+  const suspense = {
+    vnode,
+    parent: parentSuspense,
+    parentComponent,
+    isSVG,
+    container,
+    hiddenContainer,
+    anchor,
+    deps: 0,
+    pendingId: 0,
+    timeout: typeof timeout === "number" ? timeout : -1,
+    activeBranch: null,
+    pendingBranch: null,
+    isInFallback: true,
+    isHydrating,
+    isUnmounted: false,
+    effects: [],
+    resolve(resume = false, sync = false) {
+      if (!!(process.env.NODE_ENV !== "production")) {
+        if (!resume && !suspense.pendingBranch) {
+          throw new Error(
+            `suspense.resolve() is called without a pending branch.`
+          );
+        }
+        if (suspense.isUnmounted) {
+          throw new Error(
+            `suspense.resolve() is called on an already unmounted suspense boundary.`
+          );
+        }
+      }
+      const {
+        vnode: vnode2,
+        activeBranch,
+        pendingBranch,
+        pendingId,
+        effects,
+        parentComponent: parentComponent2,
+        container: container2
+      } = suspense;
+      if (suspense.isHydrating) {
+        suspense.isHydrating = false;
+      } else if (!resume) {
+        const delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in";
+        if (delayEnter) {
+          activeBranch.transition.afterLeave = () => {
+            if (pendingId === suspense.pendingId) {
+              move(pendingBranch, container2, anchor2, 0);
+            }
+          };
+        }
+        let { anchor: anchor2 } = suspense;
+        if (activeBranch) {
+          anchor2 = next(activeBranch);
+          unmount(activeBranch, parentComponent2, suspense, true);
+        }
+        if (!delayEnter) {
+          move(pendingBranch, container2, anchor2, 0);
+        }
+      }
+      setActiveBranch(suspense, pendingBranch);
+      suspense.pendingBranch = null;
+      suspense.isInFallback = false;
+      let parent = suspense.parent;
+      let hasUnresolvedAncestor = false;
+      while (parent) {
+        if (parent.pendingBranch) {
+          parent.effects.push(...effects);
+          hasUnresolvedAncestor = true;
+          break;
+        }
+        parent = parent.parent;
+      }
+      if (!hasUnresolvedAncestor) {
+        queuePostFlushCb(effects);
+      }
+      suspense.effects = [];
+      if (isSuspensible) {
+        if (parentSuspense && parentSuspense.pendingBranch && parentSuspenseId === parentSuspense.pendingId) {
+          parentSuspense.deps--;
+          if (parentSuspense.deps === 0 && !sync) {
+            parentSuspense.resolve();
+          }
+        }
+      }
+      triggerEvent(vnode2, "onResolve");
+    },
+    fallback(fallbackVNode) {
+      if (!suspense.pendingBranch) {
+        return;
+      }
+      const { vnode: vnode2, activeBranch, parentComponent: parentComponent2, container: container2, isSVG: isSVG2 } = suspense;
+      triggerEvent(vnode2, "onFallback");
+      const anchor2 = next(activeBranch);
+      const mountFallback = () => {
+        if (!suspense.isInFallback) {
+          return;
+        }
+        patch(
+          null,
+          fallbackVNode,
+          container2,
+          anchor2,
+          parentComponent2,
+          null,
+          // fallback tree will not have suspense context
+          isSVG2,
+          slotScopeIds,
+          optimized
+        );
+        setActiveBranch(suspense, fallbackVNode);
+      };
+      const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "out-in";
+      if (delayEnter) {
+        activeBranch.transition.afterLeave = mountFallback;
+      }
+      suspense.isInFallback = true;
+      unmount(
+        activeBranch,
+        parentComponent2,
+        null,
+        // no suspense so unmount hooks fire now
+        true
+        // shouldRemove
+      );
+      if (!delayEnter) {
+        mountFallback();
+      }
+    },
+    move(container2, anchor2, type) {
+      suspense.activeBranch && move(suspense.activeBranch, container2, anchor2, type);
+      suspense.container = container2;
+    },
+    next() {
+      return suspense.activeBranch && next(suspense.activeBranch);
+    },
+    registerDep(instance, setupRenderEffect) {
+      const isInPendingSuspense = !!suspense.pendingBranch;
+      if (isInPendingSuspense) {
+        suspense.deps++;
+      }
+      const hydratedEl = instance.vnode.el;
+      instance.asyncDep.catch((err) => {
+        handleError(err, instance, 0);
+      }).then((asyncSetupResult) => {
+        if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) {
+          return;
+        }
+        instance.asyncResolved = true;
+        const { vnode: vnode2 } = instance;
+        if (!!(process.env.NODE_ENV !== "production")) {
+          pushWarningContext(vnode2);
+        }
+        handleSetupResult(instance, asyncSetupResult, false);
+        if (hydratedEl) {
+          vnode2.el = hydratedEl;
+        }
+        const placeholder = !hydratedEl && instance.subTree.el;
+        setupRenderEffect(
+          instance,
+          vnode2,
+          // component may have been moved before resolve.
+          // if this is not a hydration, instance.subTree will be the comment
+          // placeholder.
+          parentNode(hydratedEl || instance.subTree.el),
+          // anchor will not be used if this is hydration, so only need to
+          // consider the comment placeholder case.
+          hydratedEl ? null : next(instance.subTree),
+          suspense,
+          isSVG,
+          optimized
+        );
+        if (placeholder) {
+          remove(placeholder);
+        }
+        updateHOCHostEl(instance, vnode2.el);
+        if (!!(process.env.NODE_ENV !== "production")) {
+          popWarningContext();
+        }
+        if (isInPendingSuspense && --suspense.deps === 0) {
+          suspense.resolve();
+        }
+      });
+    },
+    unmount(parentSuspense2, doRemove) {
+      suspense.isUnmounted = true;
+      if (suspense.activeBranch) {
+        unmount(
+          suspense.activeBranch,
+          parentComponent,
+          parentSuspense2,
+          doRemove
+        );
+      }
+      if (suspense.pendingBranch) {
+        unmount(
+          suspense.pendingBranch,
+          parentComponent,
+          parentSuspense2,
+          doRemove
+        );
+      }
+    }
+  };
+  return suspense;
+}
+function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals, hydrateNode) {
+  const suspense = vnode.suspense = createSuspenseBoundary(
+    vnode,
+    parentSuspense,
+    parentComponent,
+    node.parentNode,
+    document.createElement("div"),
+    null,
+    isSVG,
+    slotScopeIds,
+    optimized,
+    rendererInternals,
+    true
+    /* hydrating */
+  );
+  const result = hydrateNode(
+    node,
+    suspense.pendingBranch = vnode.ssContent,
+    parentComponent,
+    suspense,
+    slotScopeIds,
+    optimized
+  );
+  if (suspense.deps === 0) {
+    suspense.resolve(false, true);
+  }
+  return result;
+}
+function normalizeSuspenseChildren(vnode) {
+  const { shapeFlag, children } = vnode;
+  const isSlotChildren = shapeFlag & 32;
+  vnode.ssContent = normalizeSuspenseSlot(
+    isSlotChildren ? children.default : children
+  );
+  vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment);
+}
+function normalizeSuspenseSlot(s) {
+  let block;
+  if (isFunction(s)) {
+    const trackBlock = isBlockTreeEnabled && s._c;
+    if (trackBlock) {
+      s._d = false;
+      openBlock();
+    }
+    s = s();
+    if (trackBlock) {
+      s._d = true;
+      block = currentBlock;
+      closeBlock();
+    }
+  }
+  if (isArray(s)) {
+    const singleChild = filterSingleRoot(s);
+    if (!!(process.env.NODE_ENV !== "production") && !singleChild) {
+      warn(`<Suspense> slots expect a single root node.`);
+    }
+    s = singleChild;
+  }
+  s = normalizeVNode(s);
+  if (block && !s.dynamicChildren) {
+    s.dynamicChildren = block.filter((c) => c !== s);
+  }
+  return s;
+}
+function queueEffectWithSuspense(fn, suspense) {
+  if (suspense && suspense.pendingBranch) {
+    if (isArray(fn)) {
+      suspense.effects.push(...fn);
+    } else {
+      suspense.effects.push(fn);
+    }
+  } else {
+    queuePostFlushCb(fn);
+  }
+}
+function setActiveBranch(suspense, branch) {
+  suspense.activeBranch = branch;
+  const { vnode, parentComponent } = suspense;
+  const el = vnode.el = branch.el;
+  if (parentComponent && parentComponent.subTree === vnode) {
+    parentComponent.vnode.el = el;
+    updateHOCHostEl(parentComponent, el);
+  }
+}
+function isVNodeSuspensible(vnode) {
+  var _a;
+  return ((_a = vnode.props) == null ? void 0 : _a.suspensible) != null && vnode.props.suspensible !== false;
+}
+
+function watchEffect(effect, options) {
+  return doWatch(effect, null, options);
+}
+function watchPostEffect(effect, options) {
+  return doWatch(
+    effect,
+    null,
+    !!(process.env.NODE_ENV !== "production") ? extend({}, options, { flush: "post" }) : { flush: "post" }
+  );
+}
+function watchSyncEffect(effect, options) {
+  return doWatch(
+    effect,
+    null,
+    !!(process.env.NODE_ENV !== "production") ? extend({}, options, { flush: "sync" }) : { flush: "sync" }
+  );
+}
+const INITIAL_WATCHER_VALUE = {};
+function watch(source, cb, options) {
+  if (!!(process.env.NODE_ENV !== "production") && !isFunction(cb)) {
+    warn(
+      `\`watch(fn, options?)\` signature has been moved to a separate API. Use \`watchEffect(fn, options?)\` instead. \`watch\` now only supports \`watch(source, cb, options?) signature.`
+    );
+  }
+  return doWatch(source, cb, options);
+}
+function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ) {
+  var _a;
+  if (!!(process.env.NODE_ENV !== "production") && !cb) {
+    if (immediate !== void 0) {
+      warn(
+        `watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`
+      );
+    }
+    if (deep !== void 0) {
+      warn(
+        `watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`
+      );
+    }
+  }
+  const warnInvalidSource = (s) => {
+    warn(
+      `Invalid watch source: `,
+      s,
+      `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`
+    );
+  };
+  const instance = getCurrentScope() === ((_a = currentInstance) == null ? void 0 : _a.scope) ? currentInstance : null;
+  let getter;
+  let forceTrigger = false;
+  let isMultiSource = false;
+  if (isRef(source)) {
+    getter = () => source.value;
+    forceTrigger = isShallow$1(source);
+  } else if (isReactive(source)) {
+    getter = () => source;
+    deep = true;
+  } else if (isArray(source)) {
+    isMultiSource = true;
+    forceTrigger = source.some((s) => isReactive(s) || isShallow$1(s));
+    getter = () => source.map((s) => {
+      if (isRef(s)) {
+        return s.value;
+      } else if (isReactive(s)) {
+        return traverse(s);
+      } else if (isFunction(s)) {
+        return callWithErrorHandling(s, instance, 2);
+      } else {
+        !!(process.env.NODE_ENV !== "production") && warnInvalidSource(s);
+      }
+    });
+  } else if (isFunction(source)) {
+    if (cb) {
+      getter = () => callWithErrorHandling(source, instance, 2);
+    } else {
+      getter = () => {
+        if (instance && instance.isUnmounted) {
+          return;
+        }
+        if (cleanup) {
+          cleanup();
+        }
+        return callWithAsyncErrorHandling(
+          source,
+          instance,
+          3,
+          [onCleanup]
+        );
+      };
+    }
+  } else {
+    getter = NOOP;
+    !!(process.env.NODE_ENV !== "production") && warnInvalidSource(source);
+  }
+  if (cb && deep) {
+    const baseGetter = getter;
+    getter = () => traverse(baseGetter());
+  }
+  let cleanup;
+  let onCleanup = (fn) => {
+    cleanup = effect.onStop = () => {
+      callWithErrorHandling(fn, instance, 4);
+    };
+  };
+  let ssrCleanup;
+  if (isInSSRComponentSetup) {
+    onCleanup = NOOP;
+    if (!cb) {
+      getter();
+    } else if (immediate) {
+      callWithAsyncErrorHandling(cb, instance, 3, [
+        getter(),
+        isMultiSource ? [] : void 0,
+        onCleanup
+      ]);
+    }
+    if (flush === "sync") {
+      const ctx = useSSRContext();
+      ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
+    } else {
+      return NOOP;
+    }
+  }
+  let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
+  const job = () => {
+    if (!effect.active) {
+      return;
+    }
+    if (cb) {
+      const newValue = effect.run();
+      if (deep || forceTrigger || (isMultiSource ? newValue.some(
+        (v, i) => hasChanged(v, oldValue[i])
+      ) : hasChanged(newValue, oldValue)) || false) {
+        if (cleanup) {
+          cleanup();
+        }
+        callWithAsyncErrorHandling(cb, instance, 3, [
+          newValue,
+          // pass undefined as the old value when it's changed for the first time
+          oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
+          onCleanup
+        ]);
+        oldValue = newValue;
+      }
+    } else {
+      effect.run();
+    }
+  };
+  job.allowRecurse = !!cb;
+  let scheduler;
+  if (flush === "sync") {
+    scheduler = job;
+  } else if (flush === "post") {
+    scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
+  } else {
+    job.pre = true;
+    if (instance)
+      job.id = instance.uid;
+    scheduler = () => queueJob(job);
+  }
+  const effect = new ReactiveEffect(getter, scheduler);
+  if (!!(process.env.NODE_ENV !== "production")) {
+    effect.onTrack = onTrack;
+    effect.onTrigger = onTrigger;
+  }
+  if (cb) {
+    if (immediate) {
+      job();
+    } else {
+      oldValue = effect.run();
+    }
+  } else if (flush === "post") {
+    queuePostRenderEffect(
+      effect.run.bind(effect),
+      instance && instance.suspense
+    );
+  } else {
+    effect.run();
+  }
+  const unwatch = () => {
+    effect.stop();
+    if (instance && instance.scope) {
+      remove(instance.scope.effects, effect);
+    }
+  };
+  if (ssrCleanup)
+    ssrCleanup.push(unwatch);
+  return unwatch;
+}
+function instanceWatch(source, value, options) {
+  const publicThis = this.proxy;
+  const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
+  let cb;
+  if (isFunction(value)) {
+    cb = value;
+  } else {
+    cb = value.handler;
+    options = value;
+  }
+  const cur = currentInstance;
+  setCurrentInstance(this);
+  const res = doWatch(getter, cb.bind(publicThis), options);
+  if (cur) {
+    setCurrentInstance(cur);
+  } else {
+    unsetCurrentInstance();
+  }
+  return res;
+}
+function createPathGetter(ctx, path) {
+  const segments = path.split(".");
+  return () => {
+    let cur = ctx;
+    for (let i = 0; i < segments.length && cur; i++) {
+      cur = cur[segments[i]];
+    }
+    return cur;
+  };
+}
+function traverse(value, seen) {
+  if (!isObject(value) || value["__v_skip"]) {
+    return value;
+  }
+  seen = seen || /* @__PURE__ */ new Set();
+  if (seen.has(value)) {
+    return value;
+  }
+  seen.add(value);
+  if (isRef(value)) {
+    traverse(value.value, seen);
+  } else if (isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      traverse(value[i], seen);
+    }
+  } else if (isSet(value) || isMap(value)) {
+    value.forEach((v) => {
+      traverse(v, seen);
+    });
+  } else if (isPlainObject(value)) {
+    for (const key in value) {
+      traverse(value[key], seen);
+    }
+  }
+  return value;
+}
+
+function validateDirectiveName(name) {
+  if (isBuiltInDirective(name)) {
+    warn("Do not use built-in directive ids as custom directive id: " + name);
+  }
+}
+function withDirectives(vnode, directives) {
+  const internalInstance = currentRenderingInstance;
+  if (internalInstance === null) {
+    !!(process.env.NODE_ENV !== "production") && warn(`withDirectives can only be used inside render functions.`);
+    return vnode;
+  }
+  const instance = getExposeProxy(internalInstance) || internalInstance.proxy;
+  const bindings = vnode.dirs || (vnode.dirs = []);
+  for (let i = 0; i < directives.length; i++) {
+    let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
+    if (dir) {
+      if (isFunction(dir)) {
+        dir = {
+          mounted: dir,
+          updated: dir
+        };
+      }
+      if (dir.deep) {
+        traverse(value);
+      }
+      bindings.push({
+        dir,
+        instance,
+        value,
+        oldValue: void 0,
+        arg,
+        modifiers
+      });
+    }
+  }
+  return vnode;
+}
+function invokeDirectiveHook(vnode, prevVNode, instance, name) {
+  const bindings = vnode.dirs;
+  const oldBindings = prevVNode && prevVNode.dirs;
+  for (let i = 0; i < bindings.length; i++) {
+    const binding = bindings[i];
+    if (oldBindings) {
+      binding.oldValue = oldBindings[i].value;
+    }
+    let hook = binding.dir[name];
+    if (hook) {
+      pauseTracking();
+      callWithAsyncErrorHandling(hook, instance, 8, [
+        vnode.el,
+        binding,
+        vnode,
+        prevVNode
+      ]);
+      resetTracking();
+    }
+  }
+}
+
+function useTransitionState() {
+  const state = {
+    isMounted: false,
+    isLeaving: false,
+    isUnmounting: false,
+    leavingVNodes: /* @__PURE__ */ new Map()
+  };
+  onMounted(() => {
+    state.isMounted = true;
+  });
+  onBeforeUnmount(() => {
+    state.isUnmounting = true;
+  });
+  return state;
+}
+const TransitionHookValidator = [Function, Array];
+const BaseTransitionPropsValidators = {
+  mode: String,
+  appear: Boolean,
+  persisted: Boolean,
+  // enter
+  onBeforeEnter: TransitionHookValidator,
+  onEnter: TransitionHookValidator,
+  onAfterEnter: TransitionHookValidator,
+  onEnterCancelled: TransitionHookValidator,
+  // leave
+  onBeforeLeave: TransitionHookValidator,
+  onLeave: TransitionHookValidator,
+  onAfterLeave: TransitionHookValidator,
+  onLeaveCancelled: TransitionHookValidator,
+  // appear
+  onBeforeAppear: TransitionHookValidator,
+  onAppear: TransitionHookValidator,
+  onAfterAppear: TransitionHookValidator,
+  onAppearCancelled: TransitionHookValidator
+};
+const BaseTransitionImpl = {
+  name: `BaseTransition`,
+  props: BaseTransitionPropsValidators,
+  setup(props, { slots }) {
+    const instance = getCurrentInstance();
+    const state = useTransitionState();
+    let prevTransitionKey;
+    return () => {
+      const children = slots.default && getTransitionRawChildren(slots.default(), true);
+      if (!children || !children.length) {
+        return;
+      }
+      let child = children[0];
+      if (children.length > 1) {
+        let hasFound = false;
+        for (const c of children) {
+          if (c.type !== Comment) {
+            if (!!(process.env.NODE_ENV !== "production") && hasFound) {
+              warn(
+                "<transition> can only be used on a single element or component. Use <transition-group> for lists."
+              );
+              break;
+            }
+            child = c;
+            hasFound = true;
+            if (!!!(process.env.NODE_ENV !== "production"))
+              break;
+          }
+        }
+      }
+      const rawProps = toRaw(props);
+      const { mode } = rawProps;
+      if (!!(process.env.NODE_ENV !== "production") && mode && mode !== "in-out" && mode !== "out-in" && mode !== "default") {
+        warn(`invalid <transition> mode: ${mode}`);
+      }
+      if (state.isLeaving) {
+        return emptyPlaceholder(child);
+      }
+      const innerChild = getKeepAliveChild(child);
+      if (!innerChild) {
+        return emptyPlaceholder(child);
+      }
+      const enterHooks = resolveTransitionHooks(
+        innerChild,
+        rawProps,
+        state,
+        instance
+      );
+      setTransitionHooks(innerChild, enterHooks);
+      const oldChild = instance.subTree;
+      const oldInnerChild = oldChild && getKeepAliveChild(oldChild);
+      let transitionKeyChanged = false;
+      const { getTransitionKey } = innerChild.type;
+      if (getTransitionKey) {
+        const key = getTransitionKey();
+        if (prevTransitionKey === void 0) {
+          prevTransitionKey = key;
+        } else if (key !== prevTransitionKey) {
+          prevTransitionKey = key;
+          transitionKeyChanged = true;
+        }
+      }
+      if (oldInnerChild && oldInnerChild.type !== Comment && (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) {
+        const leavingHooks = resolveTransitionHooks(
+          oldInnerChild,
+          rawProps,
+          state,
+          instance
+        );
+        setTransitionHooks(oldInnerChild, leavingHooks);
+        if (mode === "out-in") {
+          state.isLeaving = true;
+          leavingHooks.afterLeave = () => {
+            state.isLeaving = false;
+            if (instance.update.active !== false) {
+              instance.update();
+            }
+          };
+          return emptyPlaceholder(child);
+        } else if (mode === "in-out" && innerChild.type !== Comment) {
+          leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
+            const leavingVNodesCache = getLeavingNodesForType(
+              state,
+              oldInnerChild
+            );
+            leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
+            el._leaveCb = () => {
+              earlyRemove();
+              el._leaveCb = void 0;
+              delete enterHooks.delayedLeave;
+            };
+            enterHooks.delayedLeave = delayedLeave;
+          };
+        }
+      }
+      return child;
+    };
+  }
+};
+const BaseTransition = BaseTransitionImpl;
+function getLeavingNodesForType(state, vnode) {
+  const { leavingVNodes } = state;
+  let leavingVNodesCache = leavingVNodes.get(vnode.type);
+  if (!leavingVNodesCache) {
+    leavingVNodesCache = /* @__PURE__ */ Object.create(null);
+    leavingVNodes.set(vnode.type, leavingVNodesCache);
+  }
+  return leavingVNodesCache;
+}
+function resolveTransitionHooks(vnode, props, state, instance) {
+  const {
+    appear,
+    mode,
+    persisted = false,
+    onBeforeEnter,
+    onEnter,
+    onAfterEnter,
+    onEnterCancelled,
+    onBeforeLeave,
+    onLeave,
+    onAfterLeave,
+    onLeaveCancelled,
+    onBeforeAppear,
+    onAppear,
+    onAfterAppear,
+    onAppearCancelled
+  } = props;
+  const key = String(vnode.key);
+  const leavingVNodesCache = getLeavingNodesForType(state, vnode);
+  const callHook = (hook, args) => {
+    hook && callWithAsyncErrorHandling(
+      hook,
+      instance,
+      9,
+      args
+    );
+  };
+  const callAsyncHook = (hook, args) => {
+    const done = args[1];
+    callHook(hook, args);
+    if (isArray(hook)) {
+      if (hook.every((hook2) => hook2.length <= 1))
+        done();
+    } else if (hook.length <= 1) {
+      done();
+    }
+  };
+  const hooks = {
+    mode,
+    persisted,
+    beforeEnter(el) {
+      let hook = onBeforeEnter;
+      if (!state.isMounted) {
+        if (appear) {
+          hook = onBeforeAppear || onBeforeEnter;
+        } else {
+          return;
+        }
+      }
+      if (el._leaveCb) {
+        el._leaveCb(
+          true
+          /* cancelled */
+        );
+      }
+      const leavingVNode = leavingVNodesCache[key];
+      if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el._leaveCb) {
+        leavingVNode.el._leaveCb();
+      }
+      callHook(hook, [el]);
+    },
+    enter(el) {
+      let hook = onEnter;
+      let afterHook = onAfterEnter;
+      let cancelHook = onEnterCancelled;
+      if (!state.isMounted) {
+        if (appear) {
+          hook = onAppear || onEnter;
+          afterHook = onAfterAppear || onAfterEnter;
+          cancelHook = onAppearCancelled || onEnterCancelled;
+        } else {
+          return;
+        }
+      }
+      let called = false;
+      const done = el._enterCb = (cancelled) => {
+        if (called)
+          return;
+        called = true;
+        if (cancelled) {
+          callHook(cancelHook, [el]);
+        } else {
+          callHook(afterHook, [el]);
+        }
+        if (hooks.delayedLeave) {
+          hooks.delayedLeave();
+        }
+        el._enterCb = void 0;
+      };
+      if (hook) {
+        callAsyncHook(hook, [el, done]);
+      } else {
+        done();
+      }
+    },
+    leave(el, remove) {
+      const key2 = String(vnode.key);
+      if (el._enterCb) {
+        el._enterCb(
+          true
+          /* cancelled */
+        );
+      }
+      if (state.isUnmounting) {
+        return remove();
+      }
+      callHook(onBeforeLeave, [el]);
+      let called = false;
+      const done = el._leaveCb = (cancelled) => {
+        if (called)
+          return;
+        called = true;
+        remove();
+        if (cancelled) {
+          callHook(onLeaveCancelled, [el]);
+        } else {
+          callHook(onAfterLeave, [el]);
+        }
+        el._leaveCb = void 0;
+        if (leavingVNodesCache[key2] === vnode) {
+          delete leavingVNodesCache[key2];
+        }
+      };
+      leavingVNodesCache[key2] = vnode;
+      if (onLeave) {
+        callAsyncHook(onLeave, [el, done]);
+      } else {
+        done();
+      }
+    },
+    clone(vnode2) {
+      return resolveTransitionHooks(vnode2, props, state, instance);
+    }
+  };
+  return hooks;
+}
+function emptyPlaceholder(vnode) {
+  if (isKeepAlive(vnode)) {
+    vnode = cloneVNode(vnode);
+    vnode.children = null;
+    return vnode;
+  }
+}
+function getKeepAliveChild(vnode) {
+  return isKeepAlive(vnode) ? vnode.children ? vnode.children[0] : void 0 : vnode;
+}
+function setTransitionHooks(vnode, hooks) {
+  if (vnode.shapeFlag & 6 && vnode.component) {
+    setTransitionHooks(vnode.component.subTree, hooks);
+  } else if (vnode.shapeFlag & 128) {
+    vnode.ssContent.transition = hooks.clone(vnode.ssContent);
+    vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
+  } else {
+    vnode.transition = hooks;
+  }
+}
+function getTransitionRawChildren(children, keepComment = false, parentKey) {
+  let ret = [];
+  let keyedFragmentCount = 0;
+  for (let i = 0; i < children.length; i++) {
+    let child = children[i];
+    const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
+    if (child.type === Fragment) {
+      if (child.patchFlag & 128)
+        keyedFragmentCount++;
+      ret = ret.concat(
+        getTransitionRawChildren(child.children, keepComment, key)
+      );
+    } else if (keepComment || child.type !== Comment) {
+      ret.push(key != null ? cloneVNode(child, { key }) : child);
+    }
+  }
+  if (keyedFragmentCount > 1) {
+    for (let i = 0; i < ret.length; i++) {
+      ret[i].patchFlag = -2;
+    }
+  }
+  return ret;
+}
+
+function defineComponent(options, extraOptions) {
+  return isFunction(options) ? (
+    // #8326: extend call and options.name access are considered side-effects
+    // by Rollup, so we have to wrap it in a pure-annotated IIFE.
+    /* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))()
+  ) : options;
+}
+
+const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
+function defineAsyncComponent(source) {
+  if (isFunction(source)) {
+    source = { loader: source };
+  }
+  const {
+    loader,
+    loadingComponent,
+    errorComponent,
+    delay = 200,
+    timeout,
+    // undefined = never times out
+    suspensible = true,
+    onError: userOnError
+  } = source;
+  let pendingRequest = null;
+  let resolvedComp;
+  let retries = 0;
+  const retry = () => {
+    retries++;
+    pendingRequest = null;
+    return load();
+  };
+  const load = () => {
+    let thisRequest;
+    return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {
+      err = err instanceof Error ? err : new Error(String(err));
+      if (userOnError) {
+        return new Promise((resolve, reject) => {
+          const userRetry = () => resolve(retry());
+          const userFail = () => reject(err);
+          userOnError(err, userRetry, userFail, retries + 1);
+        });
+      } else {
+        throw err;
+      }
+    }).then((comp) => {
+      if (thisRequest !== pendingRequest && pendingRequest) {
+        return pendingRequest;
+      }
+      if (!!(process.env.NODE_ENV !== "production") && !comp) {
+        warn(
+          `Async component loader resolved to undefined. If you are using retry(), make sure to return its return value.`
+        );
+      }
+      if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
+        comp = comp.default;
+      }
+      if (!!(process.env.NODE_ENV !== "production") && comp && !isObject(comp) && !isFunction(comp)) {
+        throw new Error(`Invalid async component load result: ${comp}`);
+      }
+      resolvedComp = comp;
+      return comp;
+    }));
+  };
+  return defineComponent({
+    name: "AsyncComponentWrapper",
+    __asyncLoader: load,
+    get __asyncResolved() {
+      return resolvedComp;
+    },
+    setup() {
+      const instance = currentInstance;
+      if (resolvedComp) {
+        return () => createInnerComp(resolvedComp, instance);
+      }
+      const onError = (err) => {
+        pendingRequest = null;
+        handleError(
+          err,
+          instance,
+          13,
+          !errorComponent
+          /* do not throw in dev if user provided error component */
+        );
+      };
+      if (suspensible && instance.suspense || isInSSRComponentSetup) {
+        return load().then((comp) => {
+          return () => createInnerComp(comp, instance);
+        }).catch((err) => {
+          onError(err);
+          return () => errorComponent ? createVNode(errorComponent, {
+            error: err
+          }) : null;
+        });
+      }
+      const loaded = ref(false);
+      const error = ref();
+      const delayed = ref(!!delay);
+      if (delay) {
+        setTimeout(() => {
+          delayed.value = false;
+        }, delay);
+      }
+      if (timeout != null) {
+        setTimeout(() => {
+          if (!loaded.value && !error.value) {
+            const err = new Error(
+              `Async component timed out after ${timeout}ms.`
+            );
+            onError(err);
+            error.value = err;
+          }
+        }, timeout);
+      }
+      load().then(() => {
+        loaded.value = true;
+        if (instance.parent && isKeepAlive(instance.parent.vnode)) {
+          queueJob(instance.parent.update);
+        }
+      }).catch((err) => {
+        onError(err);
+        error.value = err;
+      });
+      return () => {
+        if (loaded.value && resolvedComp) {
+          return createInnerComp(resolvedComp, instance);
+        } else if (error.value && errorComponent) {
+          return createVNode(errorComponent, {
+            error: error.value
+          });
+        } else if (loadingComponent && !delayed.value) {
+          return createVNode(loadingComponent);
+        }
+      };
+    }
+  });
+}
+function createInnerComp(comp, parent) {
+  const { ref: ref2, props, children, ce } = parent.vnode;
+  const vnode = createVNode(comp, props, children);
+  vnode.ref = ref2;
+  vnode.ce = ce;
+  delete parent.vnode.ce;
+  return vnode;
+}
+
+const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
+const KeepAliveImpl = {
+  name: `KeepAlive`,
+  // Marker for special handling inside the renderer. We are not using a ===
+  // check directly on KeepAlive in the renderer, because importing it directly
+  // would prevent it from being tree-shaken.
+  __isKeepAlive: true,
+  props: {
+    include: [String, RegExp, Array],
+    exclude: [String, RegExp, Array],
+    max: [String, Number]
+  },
+  setup(props, { slots }) {
+    const instance = getCurrentInstance();
+    const sharedContext = instance.ctx;
+    if (!sharedContext.renderer) {
+      return () => {
+        const children = slots.default && slots.default();
+        return children && children.length === 1 ? children[0] : children;
+      };
+    }
+    const cache = /* @__PURE__ */ new Map();
+    const keys = /* @__PURE__ */ new Set();
+    let current = null;
+    if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+      instance.__v_cache = cache;
+    }
+    const parentSuspense = instance.suspense;
+    const {
+      renderer: {
+        p: patch,
+        m: move,
+        um: _unmount,
+        o: { createElement }
+      }
+    } = sharedContext;
+    const storageContainer = createElement("div");
+    sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => {
+      const instance2 = vnode.component;
+      move(vnode, container, anchor, 0, parentSuspense);
+      patch(
+        instance2.vnode,
+        vnode,
+        container,
+        anchor,
+        instance2,
+        parentSuspense,
+        isSVG,
+        vnode.slotScopeIds,
+        optimized
+      );
+      queuePostRenderEffect(() => {
+        instance2.isDeactivated = false;
+        if (instance2.a) {
+          invokeArrayFns(instance2.a);
+        }
+        const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
+        if (vnodeHook) {
+          invokeVNodeHook(vnodeHook, instance2.parent, vnode);
+        }
+      }, parentSuspense);
+      if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+        devtoolsComponentAdded(instance2);
+      }
+    };
+    sharedContext.deactivate = (vnode) => {
+      const instance2 = vnode.component;
+      move(vnode, storageContainer, null, 1, parentSuspense);
+      queuePostRenderEffect(() => {
+        if (instance2.da) {
+          invokeArrayFns(instance2.da);
+        }
+        const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
+        if (vnodeHook) {
+          invokeVNodeHook(vnodeHook, instance2.parent, vnode);
+        }
+        instance2.isDeactivated = true;
+      }, parentSuspense);
+      if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+        devtoolsComponentAdded(instance2);
+      }
+    };
+    function unmount(vnode) {
+      resetShapeFlag(vnode);
+      _unmount(vnode, instance, parentSuspense, true);
+    }
+    function pruneCache(filter) {
+      cache.forEach((vnode, key) => {
+        const name = getComponentName(vnode.type);
+        if (name && (!filter || !filter(name))) {
+          pruneCacheEntry(key);
+        }
+      });
+    }
+    function pruneCacheEntry(key) {
+      const cached = cache.get(key);
+      if (!current || !isSameVNodeType(cached, current)) {
+        unmount(cached);
+      } else if (current) {
+        resetShapeFlag(current);
+      }
+      cache.delete(key);
+      keys.delete(key);
+    }
+    watch(
+      () => [props.include, props.exclude],
+      ([include, exclude]) => {
+        include && pruneCache((name) => matches(include, name));
+        exclude && pruneCache((name) => !matches(exclude, name));
+      },
+      // prune post-render after `current` has been updated
+      { flush: "post", deep: true }
+    );
+    let pendingCacheKey = null;
+    const cacheSubtree = () => {
+      if (pendingCacheKey != null) {
+        cache.set(pendingCacheKey, getInnerChild(instance.subTree));
+      }
+    };
+    onMounted(cacheSubtree);
+    onUpdated(cacheSubtree);
+    onBeforeUnmount(() => {
+      cache.forEach((cached) => {
+        const { subTree, suspense } = instance;
+        const vnode = getInnerChild(subTree);
+        if (cached.type === vnode.type && cached.key === vnode.key) {
+          resetShapeFlag(vnode);
+          const da = vnode.component.da;
+          da && queuePostRenderEffect(da, suspense);
+          return;
+        }
+        unmount(cached);
+      });
+    });
+    return () => {
+      pendingCacheKey = null;
+      if (!slots.default) {
+        return null;
+      }
+      const children = slots.default();
+      const rawVNode = children[0];
+      if (children.length > 1) {
+        if (!!(process.env.NODE_ENV !== "production")) {
+          warn(`KeepAlive should contain exactly one component child.`);
+        }
+        current = null;
+        return children;
+      } else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) {
+        current = null;
+        return rawVNode;
+      }
+      let vnode = getInnerChild(rawVNode);
+      const comp = vnode.type;
+      const name = getComponentName(
+        isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp
+      );
+      const { include, exclude, max } = props;
+      if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) {
+        current = vnode;
+        return rawVNode;
+      }
+      const key = vnode.key == null ? comp : vnode.key;
+      const cachedVNode = cache.get(key);
+      if (vnode.el) {
+        vnode = cloneVNode(vnode);
+        if (rawVNode.shapeFlag & 128) {
+          rawVNode.ssContent = vnode;
+        }
+      }
+      pendingCacheKey = key;
+      if (cachedVNode) {
+        vnode.el = cachedVNode.el;
+        vnode.component = cachedVNode.component;
+        if (vnode.transition) {
+          setTransitionHooks(vnode, vnode.transition);
+        }
+        vnode.shapeFlag |= 512;
+        keys.delete(key);
+        keys.add(key);
+      } else {
+        keys.add(key);
+        if (max && keys.size > parseInt(max, 10)) {
+          pruneCacheEntry(keys.values().next().value);
+        }
+      }
+      vnode.shapeFlag |= 256;
+      current = vnode;
+      return isSuspense(rawVNode.type) ? rawVNode : vnode;
+    };
+  }
+};
+const KeepAlive = KeepAliveImpl;
+function matches(pattern, name) {
+  if (isArray(pattern)) {
+    return pattern.some((p) => matches(p, name));
+  } else if (isString(pattern)) {
+    return pattern.split(",").includes(name);
+  } else if (isRegExp(pattern)) {
+    return pattern.test(name);
+  }
+  return false;
+}
+function onActivated(hook, target) {
+  registerKeepAliveHook(hook, "a", target);
+}
+function onDeactivated(hook, target) {
+  registerKeepAliveHook(hook, "da", target);
+}
+function registerKeepAliveHook(hook, type, target = currentInstance) {
+  const wrappedHook = hook.__wdc || (hook.__wdc = () => {
+    let current = target;
+    while (current) {
+      if (current.isDeactivated) {
+        return;
+      }
+      current = current.parent;
+    }
+    return hook();
+  });
+  injectHook(type, wrappedHook, target);
+  if (target) {
+    let current = target.parent;
+    while (current && current.parent) {
+      if (isKeepAlive(current.parent.vnode)) {
+        injectToKeepAliveRoot(wrappedHook, type, target, current);
+      }
+      current = current.parent;
+    }
+  }
+}
+function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
+  const injected = injectHook(
+    type,
+    hook,
+    keepAliveRoot,
+    true
+    /* prepend */
+  );
+  onUnmounted(() => {
+    remove(keepAliveRoot[type], injected);
+  }, target);
+}
+function resetShapeFlag(vnode) {
+  vnode.shapeFlag &= ~256;
+  vnode.shapeFlag &= ~512;
+}
+function getInnerChild(vnode) {
+  return vnode.shapeFlag & 128 ? vnode.ssContent : vnode;
+}
+
+function injectHook(type, hook, target = currentInstance, prepend = false) {
+  if (target) {
+    const hooks = target[type] || (target[type] = []);
+    const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
+      if (target.isUnmounted) {
+        return;
+      }
+      pauseTracking();
+      setCurrentInstance(target);
+      const res = callWithAsyncErrorHandling(hook, target, type, args);
+      unsetCurrentInstance();
+      resetTracking();
+      return res;
+    });
+    if (prepend) {
+      hooks.unshift(wrappedHook);
+    } else {
+      hooks.push(wrappedHook);
+    }
+    return wrappedHook;
+  } else if (!!(process.env.NODE_ENV !== "production")) {
+    const apiName = toHandlerKey(ErrorTypeStrings[type].replace(/ hook$/, ""));
+    warn(
+      `${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup().` + (` If you are using async setup(), make sure to register lifecycle hooks before the first await statement.` )
+    );
+  }
+}
+const createHook = (lifecycle) => (hook, target = currentInstance) => (
+  // post-create lifecycle registrations are noops during SSR (except for serverPrefetch)
+  (!isInSSRComponentSetup || lifecycle === "sp") && injectHook(lifecycle, (...args) => hook(...args), target)
+);
+const onBeforeMount = createHook("bm");
+const onMounted = createHook("m");
+const onBeforeUpdate = createHook("bu");
+const onUpdated = createHook("u");
+const onBeforeUnmount = createHook("bum");
+const onUnmounted = createHook("um");
+const onServerPrefetch = createHook("sp");
+const onRenderTriggered = createHook(
+  "rtg"
+);
+const onRenderTracked = createHook(
+  "rtc"
+);
+function onErrorCaptured(hook, target = currentInstance) {
+  injectHook("ec", hook, target);
+}
+
+const COMPONENTS = "components";
+const DIRECTIVES = "directives";
+function resolveComponent(name, maybeSelfReference) {
+  return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
+}
+const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
+function resolveDynamicComponent(component) {
+  if (isString(component)) {
+    return resolveAsset(COMPONENTS, component, false) || component;
+  } else {
+    return component || NULL_DYNAMIC_COMPONENT;
+  }
+}
+function resolveDirective(name) {
+  return resolveAsset(DIRECTIVES, name);
+}
+function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
+  const instance = currentRenderingInstance || currentInstance;
+  if (instance) {
+    const Component = instance.type;
+    if (type === COMPONENTS) {
+      const selfName = getComponentName(
+        Component,
+        false
+        /* do not include inferred name to avoid breaking existing code */
+      );
+      if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) {
+        return Component;
+      }
+    }
+    const res = (
+      // local registration
+      // check instance[type] first which is resolved for options API
+      resolve(instance[type] || Component[type], name) || // global registration
+      resolve(instance.appContext[type], name)
+    );
+    if (!res && maybeSelfReference) {
+      return Component;
+    }
+    if (!!(process.env.NODE_ENV !== "production") && warnMissing && !res) {
+      const extra = type === COMPONENTS ? `
+If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : ``;
+      warn(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`);
+    }
+    return res;
+  } else if (!!(process.env.NODE_ENV !== "production")) {
+    warn(
+      `resolve${capitalize(type.slice(0, -1))} can only be used in render() or setup().`
+    );
+  }
+}
+function resolve(registry, name) {
+  return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]);
+}
+
+function renderList(source, renderItem, cache, index) {
+  let ret;
+  const cached = cache && cache[index];
+  if (isArray(source) || isString(source)) {
+    ret = new Array(source.length);
+    for (let i = 0, l = source.length; i < l; i++) {
+      ret[i] = renderItem(source[i], i, void 0, cached && cached[i]);
+    }
+  } else if (typeof source === "number") {
+    if (!!(process.env.NODE_ENV !== "production") && !Number.isInteger(source)) {
+      warn(`The v-for range expect an integer value but got ${source}.`);
+    }
+    ret = new Array(source);
+    for (let i = 0; i < source; i++) {
+      ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
+    }
+  } else if (isObject(source)) {
+    if (source[Symbol.iterator]) {
+      ret = Array.from(
+        source,
+        (item, i) => renderItem(item, i, void 0, cached && cached[i])
+      );
+    } else {
+      const keys = Object.keys(source);
+      ret = new Array(keys.length);
+      for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        ret[i] = renderItem(source[key], key, i, cached && cached[i]);
+      }
+    }
+  } else {
+    ret = [];
+  }
+  if (cache) {
+    cache[index] = ret;
+  }
+  return ret;
+}
+
+function createSlots(slots, dynamicSlots) {
+  for (let i = 0; i < dynamicSlots.length; i++) {
+    const slot = dynamicSlots[i];
+    if (isArray(slot)) {
+      for (let j = 0; j < slot.length; j++) {
+        slots[slot[j].name] = slot[j].fn;
+      }
+    } else if (slot) {
+      slots[slot.name] = slot.key ? (...args) => {
+        const res = slot.fn(...args);
+        if (res)
+          res.key = slot.key;
+        return res;
+      } : slot.fn;
+    }
+  }
+  return slots;
+}
+
+function renderSlot(slots, name, props = {}, fallback, noSlotted) {
+  if (currentRenderingInstance.isCE || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.isCE) {
+    if (name !== "default")
+      props.name = name;
+    return createVNode("slot", props, fallback && fallback());
+  }
+  let slot = slots[name];
+  if (!!(process.env.NODE_ENV !== "production") && slot && slot.length > 1) {
+    warn(
+      `SSR-optimized slot function detected in a non-SSR-optimized render function. You need to mark this component with $dynamic-slots in the parent template.`
+    );
+    slot = () => [];
+  }
+  if (slot && slot._c) {
+    slot._d = false;
+  }
+  openBlock();
+  const validSlotContent = slot && ensureValidVNode(slot(props));
+  const rendered = createBlock(
+    Fragment,
+    {
+      key: props.key || // slot content array of a dynamic conditional slot may have a branch
+      // key attached in the `createSlots` helper, respect that
+      validSlotContent && validSlotContent.key || `_${name}`
+    },
+    validSlotContent || (fallback ? fallback() : []),
+    validSlotContent && slots._ === 1 ? 64 : -2
+  );
+  if (!noSlotted && rendered.scopeId) {
+    rendered.slotScopeIds = [rendered.scopeId + "-s"];
+  }
+  if (slot && slot._c) {
+    slot._d = true;
+  }
+  return rendered;
+}
+function ensureValidVNode(vnodes) {
+  return vnodes.some((child) => {
+    if (!isVNode(child))
+      return true;
+    if (child.type === Comment)
+      return false;
+    if (child.type === Fragment && !ensureValidVNode(child.children))
+      return false;
+    return true;
+  }) ? vnodes : null;
+}
+
+function toHandlers(obj, preserveCaseIfNecessary) {
+  const ret = {};
+  if (!!(process.env.NODE_ENV !== "production") && !isObject(obj)) {
+    warn(`v-on with no argument expects an object value.`);
+    return ret;
+  }
+  for (const key in obj) {
+    ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : toHandlerKey(key)] = obj[key];
+  }
+  return ret;
+}
+
+const getPublicInstance = (i) => {
+  if (!i)
+    return null;
+  if (isStatefulComponent(i))
+    return getExposeProxy(i) || i.proxy;
+  return getPublicInstance(i.parent);
+};
+const publicPropertiesMap = (
+  // Move PURE marker to new line to workaround compiler discarding it
+  // due to type annotation
+  /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {
+    $: (i) => i,
+    $el: (i) => i.vnode.el,
+    $data: (i) => i.data,
+    $props: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly(i.props) : i.props,
+    $attrs: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly(i.attrs) : i.attrs,
+    $slots: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly(i.slots) : i.slots,
+    $refs: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly(i.refs) : i.refs,
+    $parent: (i) => getPublicInstance(i.parent),
+    $root: (i) => getPublicInstance(i.root),
+    $emit: (i) => i.emit,
+    $options: (i) => __VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type,
+    $forceUpdate: (i) => i.f || (i.f = () => queueJob(i.update)),
+    $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
+    $watch: (i) => __VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP
+  })
+);
+const isReservedPrefix = (key) => key === "_" || key === "$";
+const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
+const PublicInstanceProxyHandlers = {
+  get({ _: instance }, key) {
+    const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
+    if (!!(process.env.NODE_ENV !== "production") && key === "__isVue") {
+      return true;
+    }
+    let normalizedProps;
+    if (key[0] !== "$") {
+      const n = accessCache[key];
+      if (n !== void 0) {
+        switch (n) {
+          case 1 /* SETUP */:
+            return setupState[key];
+          case 2 /* DATA */:
+            return data[key];
+          case 4 /* CONTEXT */:
+            return ctx[key];
+          case 3 /* PROPS */:
+            return props[key];
+        }
+      } else if (hasSetupBinding(setupState, key)) {
+        accessCache[key] = 1 /* SETUP */;
+        return setupState[key];
+      } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+        accessCache[key] = 2 /* DATA */;
+        return data[key];
+      } else if (
+        // only cache other properties when instance has declared (thus stable)
+        // props
+        (normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)
+      ) {
+        accessCache[key] = 3 /* PROPS */;
+        return props[key];
+      } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+        accessCache[key] = 4 /* CONTEXT */;
+        return ctx[key];
+      } else if (!__VUE_OPTIONS_API__ || shouldCacheAccess) {
+        accessCache[key] = 0 /* OTHER */;
+      }
+    }
+    const publicGetter = publicPropertiesMap[key];
+    let cssModule, globalProperties;
+    if (publicGetter) {
+      if (key === "$attrs") {
+        track(instance, "get", key);
+        !!(process.env.NODE_ENV !== "production") && markAttrsAccessed();
+      } else if (!!(process.env.NODE_ENV !== "production") && key === "$slots") {
+        track(instance, "get", key);
+      }
+      return publicGetter(instance);
+    } else if (
+      // css module (injected by vue-loader)
+      (cssModule = type.__cssModules) && (cssModule = cssModule[key])
+    ) {
+      return cssModule;
+    } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+      accessCache[key] = 4 /* CONTEXT */;
+      return ctx[key];
+    } else if (
+      // global properties
+      globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)
+    ) {
+      {
+        return globalProperties[key];
+      }
+    } else if (!!(process.env.NODE_ENV !== "production") && currentRenderingInstance && (!isString(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading
+    // to infinite warning loop
+    key.indexOf("__v") !== 0)) {
+      if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn(data, key)) {
+        warn(
+          `Property ${JSON.stringify(
+            key
+          )} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`
+        );
+      } else if (instance === currentRenderingInstance) {
+        warn(
+          `Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`
+        );
+      }
+    }
+  },
+  set({ _: instance }, key, value) {
+    const { data, setupState, ctx } = instance;
+    if (hasSetupBinding(setupState, key)) {
+      setupState[key] = value;
+      return true;
+    } else if (!!(process.env.NODE_ENV !== "production") && setupState.__isScriptSetup && hasOwn(setupState, key)) {
+      warn(`Cannot mutate <script setup> binding "${key}" from Options API.`);
+      return false;
+    } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+      data[key] = value;
+      return true;
+    } else if (hasOwn(instance.props, key)) {
+      !!(process.env.NODE_ENV !== "production") && warn(`Attempting to mutate prop "${key}". Props are readonly.`);
+      return false;
+    }
+    if (key[0] === "$" && key.slice(1) in instance) {
+      !!(process.env.NODE_ENV !== "production") && warn(
+        `Attempting to mutate public property "${key}". Properties starting with $ are reserved and readonly.`
+      );
+      return false;
+    } else {
+      if (!!(process.env.NODE_ENV !== "production") && key in instance.appContext.config.globalProperties) {
+        Object.defineProperty(ctx, key, {
+          enumerable: true,
+          configurable: true,
+          value
+        });
+      } else {
+        ctx[key] = value;
+      }
+    }
+    return true;
+  },
+  has({
+    _: { data, setupState, accessCache, ctx, appContext, propsOptions }
+  }, key) {
+    let normalizedProps;
+    return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
+  },
+  defineProperty(target, key, descriptor) {
+    if (descriptor.get != null) {
+      target._.accessCache[key] = 0;
+    } else if (hasOwn(descriptor, "value")) {
+      this.set(target, key, descriptor.value, null);
+    }
+    return Reflect.defineProperty(target, key, descriptor);
+  }
+};
+if (!!(process.env.NODE_ENV !== "production") && true) {
+  PublicInstanceProxyHandlers.ownKeys = (target) => {
+    warn(
+      `Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead.`
+    );
+    return Reflect.ownKeys(target);
+  };
+}
+const RuntimeCompiledPublicInstanceProxyHandlers = /* @__PURE__ */ extend(
+  {},
+  PublicInstanceProxyHandlers,
+  {
+    get(target, key) {
+      if (key === Symbol.unscopables) {
+        return;
+      }
+      return PublicInstanceProxyHandlers.get(target, key, target);
+    },
+    has(_, key) {
+      const has = key[0] !== "_" && !isGloballyWhitelisted(key);
+      if (!!(process.env.NODE_ENV !== "production") && !has && PublicInstanceProxyHandlers.has(_, key)) {
+        warn(
+          `Property ${JSON.stringify(
+            key
+          )} should not start with _ which is a reserved prefix for Vue internals.`
+        );
+      }
+      return has;
+    }
+  }
+);
+function createDevRenderContext(instance) {
+  const target = {};
+  Object.defineProperty(target, `_`, {
+    configurable: true,
+    enumerable: false,
+    get: () => instance
+  });
+  Object.keys(publicPropertiesMap).forEach((key) => {
+    Object.defineProperty(target, key, {
+      configurable: true,
+      enumerable: false,
+      get: () => publicPropertiesMap[key](instance),
+      // intercepted by the proxy so no need for implementation,
+      // but needed to prevent set errors
+      set: NOOP
+    });
+  });
+  return target;
+}
+function exposePropsOnRenderContext(instance) {
+  const {
+    ctx,
+    propsOptions: [propsOptions]
+  } = instance;
+  if (propsOptions) {
+    Object.keys(propsOptions).forEach((key) => {
+      Object.defineProperty(ctx, key, {
+        enumerable: true,
+        configurable: true,
+        get: () => instance.props[key],
+        set: NOOP
+      });
+    });
+  }
+}
+function exposeSetupStateOnRenderContext(instance) {
+  const { ctx, setupState } = instance;
+  Object.keys(toRaw(setupState)).forEach((key) => {
+    if (!setupState.__isScriptSetup) {
+      if (isReservedPrefix(key[0])) {
+        warn(
+          `setup() return property ${JSON.stringify(
+            key
+          )} should not start with "$" or "_" which are reserved prefixes for Vue internals.`
+        );
+        return;
+      }
+      Object.defineProperty(ctx, key, {
+        enumerable: true,
+        configurable: true,
+        get: () => setupState[key],
+        set: NOOP
+      });
+    }
+  });
+}
+
+const warnRuntimeUsage = (method) => warn(
+  `${method}() is a compiler-hint helper that is only usable inside <script setup> of a single file component. Its arguments should be compiled away and passing it at runtime has no effect.`
+);
+function defineProps() {
+  if (!!(process.env.NODE_ENV !== "production")) {
+    warnRuntimeUsage(`defineProps`);
+  }
+  return null;
+}
+function defineEmits() {
+  if (!!(process.env.NODE_ENV !== "production")) {
+    warnRuntimeUsage(`defineEmits`);
+  }
+  return null;
+}
+function defineExpose(exposed) {
+  if (!!(process.env.NODE_ENV !== "production")) {
+    warnRuntimeUsage(`defineExpose`);
+  }
+}
+function defineOptions(options) {
+  if (!!(process.env.NODE_ENV !== "production")) {
+    warnRuntimeUsage(`defineOptions`);
+  }
+}
+function defineSlots() {
+  if (!!(process.env.NODE_ENV !== "production")) {
+    warnRuntimeUsage(`defineSlots`);
+  }
+  return null;
+}
+function defineModel() {
+  if (!!(process.env.NODE_ENV !== "production")) {
+    warnRuntimeUsage("defineModel");
+  }
+}
+function withDefaults(props, defaults) {
+  if (!!(process.env.NODE_ENV !== "production")) {
+    warnRuntimeUsage(`withDefaults`);
+  }
+  return null;
+}
+function useSlots() {
+  return getContext().slots;
+}
+function useAttrs() {
+  return getContext().attrs;
+}
+function useModel(props, name, options) {
+  const i = getCurrentInstance();
+  if (!!(process.env.NODE_ENV !== "production") && !i) {
+    warn(`useModel() called without active instance.`);
+    return ref();
+  }
+  if (!!(process.env.NODE_ENV !== "production") && !i.propsOptions[0][name]) {
+    warn(`useModel() called with prop "${name}" which is not declared.`);
+    return ref();
+  }
+  if (options && options.local) {
+    const proxy = ref(props[name]);
+    watch(
+      () => props[name],
+      (v) => proxy.value = v
+    );
+    watch(proxy, (value) => {
+      if (value !== props[name]) {
+        i.emit(`update:${name}`, value);
+      }
+    });
+    return proxy;
+  } else {
+    return {
+      __v_isRef: true,
+      get value() {
+        return props[name];
+      },
+      set value(value) {
+        i.emit(`update:${name}`, value);
+      }
+    };
+  }
+}
+function getContext() {
+  const i = getCurrentInstance();
+  if (!!(process.env.NODE_ENV !== "production") && !i) {
+    warn(`useContext() called without active instance.`);
+  }
+  return i.setupContext || (i.setupContext = createSetupContext(i));
+}
+function normalizePropsOrEmits(props) {
+  return isArray(props) ? props.reduce(
+    (normalized, p) => (normalized[p] = null, normalized),
+    {}
+  ) : props;
+}
+function mergeDefaults(raw, defaults) {
+  const props = normalizePropsOrEmits(raw);
+  for (const key in defaults) {
+    if (key.startsWith("__skip"))
+      continue;
+    let opt = props[key];
+    if (opt) {
+      if (isArray(opt) || isFunction(opt)) {
+        opt = props[key] = { type: opt, default: defaults[key] };
+      } else {
+        opt.default = defaults[key];
+      }
+    } else if (opt === null) {
+      opt = props[key] = { default: defaults[key] };
+    } else if (!!(process.env.NODE_ENV !== "production")) {
+      warn(`props default key "${key}" has no corresponding declaration.`);
+    }
+    if (opt && defaults[`__skip_${key}`]) {
+      opt.skipFactory = true;
+    }
+  }
+  return props;
+}
+function mergeModels(a, b) {
+  if (!a || !b)
+    return a || b;
+  if (isArray(a) && isArray(b))
+    return a.concat(b);
+  return extend({}, normalizePropsOrEmits(a), normalizePropsOrEmits(b));
+}
+function createPropsRestProxy(props, excludedKeys) {
+  const ret = {};
+  for (const key in props) {
+    if (!excludedKeys.includes(key)) {
+      Object.defineProperty(ret, key, {
+        enumerable: true,
+        get: () => props[key]
+      });
+    }
+  }
+  return ret;
+}
+function withAsyncContext(getAwaitable) {
+  const ctx = getCurrentInstance();
+  if (!!(process.env.NODE_ENV !== "production") && !ctx) {
+    warn(
+      `withAsyncContext called without active current instance. This is likely a bug.`
+    );
+  }
+  let awaitable = getAwaitable();
+  unsetCurrentInstance();
+  if (isPromise(awaitable)) {
+    awaitable = awaitable.catch((e) => {
+      setCurrentInstance(ctx);
+      throw e;
+    });
+  }
+  return [awaitable, () => setCurrentInstance(ctx)];
+}
+
+function createDuplicateChecker() {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return (type, key) => {
+    if (cache[key]) {
+      warn(`${type} property "${key}" is already defined in ${cache[key]}.`);
+    } else {
+      cache[key] = type;
+    }
+  };
+}
+let shouldCacheAccess = true;
+function applyOptions(instance) {
+  const options = resolveMergedOptions(instance);
+  const publicThis = instance.proxy;
+  const ctx = instance.ctx;
+  shouldCacheAccess = false;
+  if (options.beforeCreate) {
+    callHook(options.beforeCreate, instance, "bc");
+  }
+  const {
+    // state
+    data: dataOptions,
+    computed: computedOptions,
+    methods,
+    watch: watchOptions,
+    provide: provideOptions,
+    inject: injectOptions,
+    // lifecycle
+    created,
+    beforeMount,
+    mounted,
+    beforeUpdate,
+    updated,
+    activated,
+    deactivated,
+    beforeDestroy,
+    beforeUnmount,
+    destroyed,
+    unmounted,
+    render,
+    renderTracked,
+    renderTriggered,
+    errorCaptured,
+    serverPrefetch,
+    // public API
+    expose,
+    inheritAttrs,
+    // assets
+    components,
+    directives,
+    filters
+  } = options;
+  const checkDuplicateProperties = !!(process.env.NODE_ENV !== "production") ? createDuplicateChecker() : null;
+  if (!!(process.env.NODE_ENV !== "production")) {
+    const [propsOptions] = instance.propsOptions;
+    if (propsOptions) {
+      for (const key in propsOptions) {
+        checkDuplicateProperties("Props" /* PROPS */, key);
+      }
+    }
+  }
+  if (injectOptions) {
+    resolveInjections(injectOptions, ctx, checkDuplicateProperties);
+  }
+  if (methods) {
+    for (const key in methods) {
+      const methodHandler = methods[key];
+      if (isFunction(methodHandler)) {
+        if (!!(process.env.NODE_ENV !== "production")) {
+          Object.defineProperty(ctx, key, {
+            value: methodHandler.bind(publicThis),
+            configurable: true,
+            enumerable: true,
+            writable: true
+          });
+        } else {
+          ctx[key] = methodHandler.bind(publicThis);
+        }
+        if (!!(process.env.NODE_ENV !== "production")) {
+          checkDuplicateProperties("Methods" /* METHODS */, key);
+        }
+      } else if (!!(process.env.NODE_ENV !== "production")) {
+        warn(
+          `Method "${key}" has type "${typeof methodHandler}" in the component definition. Did you reference the function correctly?`
+        );
+      }
+    }
+  }
+  if (dataOptions) {
+    if (!!(process.env.NODE_ENV !== "production") && !isFunction(dataOptions)) {
+      warn(
+        `The data option must be a function. Plain object usage is no longer supported.`
+      );
+    }
+    const data = dataOptions.call(publicThis, publicThis);
+    if (!!(process.env.NODE_ENV !== "production") && isPromise(data)) {
+      warn(
+        `data() returned a Promise - note data() cannot be async; If you intend to perform data fetching before component renders, use async setup() + <Suspense>.`
+      );
+    }
+    if (!isObject(data)) {
+      !!(process.env.NODE_ENV !== "production") && warn(`data() should return an object.`);
+    } else {
+      instance.data = reactive(data);
+      if (!!(process.env.NODE_ENV !== "production")) {
+        for (const key in data) {
+          checkDuplicateProperties("Data" /* DATA */, key);
+          if (!isReservedPrefix(key[0])) {
+            Object.defineProperty(ctx, key, {
+              configurable: true,
+              enumerable: true,
+              get: () => data[key],
+              set: NOOP
+            });
+          }
+        }
+      }
+    }
+  }
+  shouldCacheAccess = true;
+  if (computedOptions) {
+    for (const key in computedOptions) {
+      const opt = computedOptions[key];
+      const get = isFunction(opt) ? opt.bind(publicThis, publicThis) : isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP;
+      if (!!(process.env.NODE_ENV !== "production") && get === NOOP) {
+        warn(`Computed property "${key}" has no getter.`);
+      }
+      const set = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : !!(process.env.NODE_ENV !== "production") ? () => {
+        warn(
+          `Write operation failed: computed property "${key}" is readonly.`
+        );
+      } : NOOP;
+      const c = computed({
+        get,
+        set
+      });
+      Object.defineProperty(ctx, key, {
+        enumerable: true,
+        configurable: true,
+        get: () => c.value,
+        set: (v) => c.value = v
+      });
+      if (!!(process.env.NODE_ENV !== "production")) {
+        checkDuplicateProperties("Computed" /* COMPUTED */, key);
+      }
+    }
+  }
+  if (watchOptions) {
+    for (const key in watchOptions) {
+      createWatcher(watchOptions[key], ctx, publicThis, key);
+    }
+  }
+  if (provideOptions) {
+    const provides = isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
+    Reflect.ownKeys(provides).forEach((key) => {
+      provide(key, provides[key]);
+    });
+  }
+  if (created) {
+    callHook(created, instance, "c");
+  }
+  function registerLifecycleHook(register, hook) {
+    if (isArray(hook)) {
+      hook.forEach((_hook) => register(_hook.bind(publicThis)));
+    } else if (hook) {
+      register(hook.bind(publicThis));
+    }
+  }
+  registerLifecycleHook(onBeforeMount, beforeMount);
+  registerLifecycleHook(onMounted, mounted);
+  registerLifecycleHook(onBeforeUpdate, beforeUpdate);
+  registerLifecycleHook(onUpdated, updated);
+  registerLifecycleHook(onActivated, activated);
+  registerLifecycleHook(onDeactivated, deactivated);
+  registerLifecycleHook(onErrorCaptured, errorCaptured);
+  registerLifecycleHook(onRenderTracked, renderTracked);
+  registerLifecycleHook(onRenderTriggered, renderTriggered);
+  registerLifecycleHook(onBeforeUnmount, beforeUnmount);
+  registerLifecycleHook(onUnmounted, unmounted);
+  registerLifecycleHook(onServerPrefetch, serverPrefetch);
+  if (isArray(expose)) {
+    if (expose.length) {
+      const exposed = instance.exposed || (instance.exposed = {});
+      expose.forEach((key) => {
+        Object.defineProperty(exposed, key, {
+          get: () => publicThis[key],
+          set: (val) => publicThis[key] = val
+        });
+      });
+    } else if (!instance.exposed) {
+      instance.exposed = {};
+    }
+  }
+  if (render && instance.render === NOOP) {
+    instance.render = render;
+  }
+  if (inheritAttrs != null) {
+    instance.inheritAttrs = inheritAttrs;
+  }
+  if (components)
+    instance.components = components;
+  if (directives)
+    instance.directives = directives;
+}
+function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) {
+  if (isArray(injectOptions)) {
+    injectOptions = normalizeInject(injectOptions);
+  }
+  for (const key in injectOptions) {
+    const opt = injectOptions[key];
+    let injected;
+    if (isObject(opt)) {
+      if ("default" in opt) {
+        injected = inject(
+          opt.from || key,
+          opt.default,
+          true
+          /* treat default function as factory */
+        );
+      } else {
+        injected = inject(opt.from || key);
+      }
+    } else {
+      injected = inject(opt);
+    }
+    if (isRef(injected)) {
+      Object.defineProperty(ctx, key, {
+        enumerable: true,
+        configurable: true,
+        get: () => injected.value,
+        set: (v) => injected.value = v
+      });
+    } else {
+      ctx[key] = injected;
+    }
+    if (!!(process.env.NODE_ENV !== "production")) {
+      checkDuplicateProperties("Inject" /* INJECT */, key);
+    }
+  }
+}
+function callHook(hook, instance, type) {
+  callWithAsyncErrorHandling(
+    isArray(hook) ? hook.map((h) => h.bind(instance.proxy)) : hook.bind(instance.proxy),
+    instance,
+    type
+  );
+}
+function createWatcher(raw, ctx, publicThis, key) {
+  const getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
+  if (isString(raw)) {
+    const handler = ctx[raw];
+    if (isFunction(handler)) {
+      watch(getter, handler);
+    } else if (!!(process.env.NODE_ENV !== "production")) {
+      warn(`Invalid watch handler specified by key "${raw}"`, handler);
+    }
+  } else if (isFunction(raw)) {
+    watch(getter, raw.bind(publicThis));
+  } else if (isObject(raw)) {
+    if (isArray(raw)) {
+      raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
+    } else {
+      const handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
+      if (isFunction(handler)) {
+        watch(getter, handler, raw);
+      } else if (!!(process.env.NODE_ENV !== "production")) {
+        warn(`Invalid watch handler specified by key "${raw.handler}"`, handler);
+      }
+    }
+  } else if (!!(process.env.NODE_ENV !== "production")) {
+    warn(`Invalid watch option: "${key}"`, raw);
+  }
+}
+function resolveMergedOptions(instance) {
+  const base = instance.type;
+  const { mixins, extends: extendsOptions } = base;
+  const {
+    mixins: globalMixins,
+    optionsCache: cache,
+    config: { optionMergeStrategies }
+  } = instance.appContext;
+  const cached = cache.get(base);
+  let resolved;
+  if (cached) {
+    resolved = cached;
+  } else if (!globalMixins.length && !mixins && !extendsOptions) {
+    {
+      resolved = base;
+    }
+  } else {
+    resolved = {};
+    if (globalMixins.length) {
+      globalMixins.forEach(
+        (m) => mergeOptions(resolved, m, optionMergeStrategies, true)
+      );
+    }
+    mergeOptions(resolved, base, optionMergeStrategies);
+  }
+  if (isObject(base)) {
+    cache.set(base, resolved);
+  }
+  return resolved;
+}
+function mergeOptions(to, from, strats, asMixin = false) {
+  const { mixins, extends: extendsOptions } = from;
+  if (extendsOptions) {
+    mergeOptions(to, extendsOptions, strats, true);
+  }
+  if (mixins) {
+    mixins.forEach(
+      (m) => mergeOptions(to, m, strats, true)
+    );
+  }
+  for (const key in from) {
+    if (asMixin && key === "expose") {
+      !!(process.env.NODE_ENV !== "production") && warn(
+        `"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.`
+      );
+    } else {
+      const strat = internalOptionMergeStrats[key] || strats && strats[key];
+      to[key] = strat ? strat(to[key], from[key]) : from[key];
+    }
+  }
+  return to;
+}
+const internalOptionMergeStrats = {
+  data: mergeDataFn,
+  props: mergeEmitsOrPropsOptions,
+  emits: mergeEmitsOrPropsOptions,
+  // objects
+  methods: mergeObjectOptions,
+  computed: mergeObjectOptions,
+  // lifecycle
+  beforeCreate: mergeAsArray,
+  created: mergeAsArray,
+  beforeMount: mergeAsArray,
+  mounted: mergeAsArray,
+  beforeUpdate: mergeAsArray,
+  updated: mergeAsArray,
+  beforeDestroy: mergeAsArray,
+  beforeUnmount: mergeAsArray,
+  destroyed: mergeAsArray,
+  unmounted: mergeAsArray,
+  activated: mergeAsArray,
+  deactivated: mergeAsArray,
+  errorCaptured: mergeAsArray,
+  serverPrefetch: mergeAsArray,
+  // assets
+  components: mergeObjectOptions,
+  directives: mergeObjectOptions,
+  // watch
+  watch: mergeWatchOptions,
+  // provide / inject
+  provide: mergeDataFn,
+  inject: mergeInject
+};
+function mergeDataFn(to, from) {
+  if (!from) {
+    return to;
+  }
+  if (!to) {
+    return from;
+  }
+  return function mergedDataFn() {
+    return (extend)(
+      isFunction(to) ? to.call(this, this) : to,
+      isFunction(from) ? from.call(this, this) : from
+    );
+  };
+}
+function mergeInject(to, from) {
+  return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
+}
+function normalizeInject(raw) {
+  if (isArray(raw)) {
+    const res = {};
+    for (let i = 0; i < raw.length; i++) {
+      res[raw[i]] = raw[i];
+    }
+    return res;
+  }
+  return raw;
+}
+function mergeAsArray(to, from) {
+  return to ? [...new Set([].concat(to, from))] : from;
+}
+function mergeObjectOptions(to, from) {
+  return to ? extend(/* @__PURE__ */ Object.create(null), to, from) : from;
+}
+function mergeEmitsOrPropsOptions(to, from) {
+  if (to) {
+    if (isArray(to) && isArray(from)) {
+      return [.../* @__PURE__ */ new Set([...to, ...from])];
+    }
+    return extend(
+      /* @__PURE__ */ Object.create(null),
+      normalizePropsOrEmits(to),
+      normalizePropsOrEmits(from != null ? from : {})
+    );
+  } else {
+    return from;
+  }
+}
+function mergeWatchOptions(to, from) {
+  if (!to)
+    return from;
+  if (!from)
+    return to;
+  const merged = extend(/* @__PURE__ */ Object.create(null), to);
+  for (const key in from) {
+    merged[key] = mergeAsArray(to[key], from[key]);
+  }
+  return merged;
+}
+
+function createAppContext() {
+  return {
+    app: null,
+    config: {
+      isNativeTag: NO,
+      performance: false,
+      globalProperties: {},
+      optionMergeStrategies: {},
+      errorHandler: void 0,
+      warnHandler: void 0,
+      compilerOptions: {}
+    },
+    mixins: [],
+    components: {},
+    directives: {},
+    provides: /* @__PURE__ */ Object.create(null),
+    optionsCache: /* @__PURE__ */ new WeakMap(),
+    propsCache: /* @__PURE__ */ new WeakMap(),
+    emitsCache: /* @__PURE__ */ new WeakMap()
+  };
+}
+let uid$1 = 0;
+function createAppAPI(render, hydrate) {
+  return function createApp(rootComponent, rootProps = null) {
+    if (!isFunction(rootComponent)) {
+      rootComponent = extend({}, rootComponent);
+    }
+    if (rootProps != null && !isObject(rootProps)) {
+      !!(process.env.NODE_ENV !== "production") && warn(`root props passed to app.mount() must be an object.`);
+      rootProps = null;
+    }
+    const context = createAppContext();
+    if (!!(process.env.NODE_ENV !== "production")) {
+      Object.defineProperty(context.config, "unwrapInjectedRef", {
+        get() {
+          return true;
+        },
+        set() {
+          warn(
+            `app.config.unwrapInjectedRef has been deprecated. 3.3 now alawys unwraps injected refs in Options API.`
+          );
+        }
+      });
+    }
+    const installedPlugins = /* @__PURE__ */ new Set();
+    let isMounted = false;
+    const app = context.app = {
+      _uid: uid$1++,
+      _component: rootComponent,
+      _props: rootProps,
+      _container: null,
+      _context: context,
+      _instance: null,
+      version,
+      get config() {
+        return context.config;
+      },
+      set config(v) {
+        if (!!(process.env.NODE_ENV !== "production")) {
+          warn(
+            `app.config cannot be replaced. Modify individual options instead.`
+          );
+        }
+      },
+      use(plugin, ...options) {
+        if (installedPlugins.has(plugin)) {
+          !!(process.env.NODE_ENV !== "production") && warn(`Plugin has already been applied to target app.`);
+        } else if (plugin && isFunction(plugin.install)) {
+          installedPlugins.add(plugin);
+          plugin.install(app, ...options);
+        } else if (isFunction(plugin)) {
+          installedPlugins.add(plugin);
+          plugin(app, ...options);
+        } else if (!!(process.env.NODE_ENV !== "production")) {
+          warn(
+            `A plugin must either be a function or an object with an "install" function.`
+          );
+        }
+        return app;
+      },
+      mixin(mixin) {
+        if (__VUE_OPTIONS_API__) {
+          if (!context.mixins.includes(mixin)) {
+            context.mixins.push(mixin);
+          } else if (!!(process.env.NODE_ENV !== "production")) {
+            warn(
+              "Mixin has already been applied to target app" + (mixin.name ? `: ${mixin.name}` : "")
+            );
+          }
+        } else if (!!(process.env.NODE_ENV !== "production")) {
+          warn("Mixins are only available in builds supporting Options API");
+        }
+        return app;
+      },
+      component(name, component) {
+        if (!!(process.env.NODE_ENV !== "production")) {
+          validateComponentName(name, context.config);
+        }
+        if (!component) {
+          return context.components[name];
+        }
+        if (!!(process.env.NODE_ENV !== "production") && context.components[name]) {
+          warn(`Component "${name}" has already been registered in target app.`);
+        }
+        context.components[name] = component;
+        return app;
+      },
+      directive(name, directive) {
+        if (!!(process.env.NODE_ENV !== "production")) {
+          validateDirectiveName(name);
+        }
+        if (!directive) {
+          return context.directives[name];
+        }
+        if (!!(process.env.NODE_ENV !== "production") && context.directives[name]) {
+          warn(`Directive "${name}" has already been registered in target app.`);
+        }
+        context.directives[name] = directive;
+        return app;
+      },
+      mount(rootContainer, isHydrate, isSVG) {
+        if (!isMounted) {
+          if (!!(process.env.NODE_ENV !== "production") && rootContainer.__vue_app__) {
+            warn(
+              `There is already an app instance mounted on the host container.
+ If you want to mount another app on the same host container, you need to unmount the previous app by calling \`app.unmount()\` first.`
+            );
+          }
+          const vnode = createVNode(
+            rootComponent,
+            rootProps
+          );
+          vnode.appContext = context;
+          if (!!(process.env.NODE_ENV !== "production")) {
+            context.reload = () => {
+              render(cloneVNode(vnode), rootContainer, isSVG);
+            };
+          }
+          if (isHydrate && hydrate) {
+            hydrate(vnode, rootContainer);
+          } else {
+            render(vnode, rootContainer, isSVG);
+          }
+          isMounted = true;
+          app._container = rootContainer;
+          rootContainer.__vue_app__ = app;
+          if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+            app._instance = vnode.component;
+            devtoolsInitApp(app, version);
+          }
+          return getExposeProxy(vnode.component) || vnode.component.proxy;
+        } else if (!!(process.env.NODE_ENV !== "production")) {
+          warn(
+            `App has already been mounted.
+If you want to remount the same app, move your app creation logic into a factory function and create fresh app instances for each mount - e.g. \`const createMyApp = () => createApp(App)\``
+          );
+        }
+      },
+      unmount() {
+        if (isMounted) {
+          render(null, app._container);
+          if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+            app._instance = null;
+            devtoolsUnmountApp(app);
+          }
+          delete app._container.__vue_app__;
+        } else if (!!(process.env.NODE_ENV !== "production")) {
+          warn(`Cannot unmount an app that is not mounted.`);
+        }
+      },
+      provide(key, value) {
+        if (!!(process.env.NODE_ENV !== "production") && key in context.provides) {
+          warn(
+            `App already provides property with key "${String(key)}". It will be overwritten with the new value.`
+          );
+        }
+        context.provides[key] = value;
+        return app;
+      },
+      runWithContext(fn) {
+        currentApp = app;
+        try {
+          return fn();
+        } finally {
+          currentApp = null;
+        }
+      }
+    };
+    return app;
+  };
+}
+let currentApp = null;
+
+function provide(key, value) {
+  if (!currentInstance) {
+    if (!!(process.env.NODE_ENV !== "production")) {
+      warn(`provide() can only be used inside setup().`);
+    }
+  } else {
+    let provides = currentInstance.provides;
+    const parentProvides = currentInstance.parent && currentInstance.parent.provides;
+    if (parentProvides === provides) {
+      provides = currentInstance.provides = Object.create(parentProvides);
+    }
+    provides[key] = value;
+  }
+}
+function inject(key, defaultValue, treatDefaultAsFactory = false) {
+  const instance = currentInstance || currentRenderingInstance;
+  if (instance || currentApp) {
+    const provides = instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : currentApp._context.provides;
+    if (provides && key in provides) {
+      return provides[key];
+    } else if (arguments.length > 1) {
+      return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
+    } else if (!!(process.env.NODE_ENV !== "production")) {
+      warn(`injection "${String(key)}" not found.`);
+    }
+  } else if (!!(process.env.NODE_ENV !== "production")) {
+    warn(`inject() can only be used inside setup() or functional components.`);
+  }
+}
+function hasInjectionContext() {
+  return !!(currentInstance || currentRenderingInstance || currentApp);
+}
+
+function initProps(instance, rawProps, isStateful, isSSR = false) {
+  const props = {};
+  const attrs = {};
+  def(attrs, InternalObjectKey, 1);
+  instance.propsDefaults = /* @__PURE__ */ Object.create(null);
+  setFullProps(instance, rawProps, props, attrs);
+  for (const key in instance.propsOptions[0]) {
+    if (!(key in props)) {
+      props[key] = void 0;
+    }
+  }
+  if (!!(process.env.NODE_ENV !== "production")) {
+    validateProps(rawProps || {}, props, instance);
+  }
+  if (isStateful) {
+    instance.props = isSSR ? props : shallowReactive(props);
+  } else {
+    if (!instance.type.props) {
+      instance.props = attrs;
+    } else {
+      instance.props = props;
+    }
+  }
+  instance.attrs = attrs;
+}
+function isInHmrContext(instance) {
+  while (instance) {
+    if (instance.type.__hmrId)
+      return true;
+    instance = instance.parent;
+  }
+}
+function updateProps(instance, rawProps, rawPrevProps, optimized) {
+  const {
+    props,
+    attrs,
+    vnode: { patchFlag }
+  } = instance;
+  const rawCurrentProps = toRaw(props);
+  const [options] = instance.propsOptions;
+  let hasAttrsChanged = false;
+  if (
+    // always force full diff in dev
+    // - #1942 if hmr is enabled with sfc component
+    // - vite#872 non-sfc component used by sfc component
+    !(!!(process.env.NODE_ENV !== "production") && isInHmrContext(instance)) && (optimized || patchFlag > 0) && !(patchFlag & 16)
+  ) {
+    if (patchFlag & 8) {
+      const propsToUpdate = instance.vnode.dynamicProps;
+      for (let i = 0; i < propsToUpdate.length; i++) {
+        let key = propsToUpdate[i];
+        if (isEmitListener(instance.emitsOptions, key)) {
+          continue;
+        }
+        const value = rawProps[key];
+        if (options) {
+          if (hasOwn(attrs, key)) {
+            if (value !== attrs[key]) {
+              attrs[key] = value;
+              hasAttrsChanged = true;
+            }
+          } else {
+            const camelizedKey = camelize(key);
+            props[camelizedKey] = resolvePropValue(
+              options,
+              rawCurrentProps,
+              camelizedKey,
+              value,
+              instance,
+              false
+              /* isAbsent */
+            );
+          }
+        } else {
+          if (value !== attrs[key]) {
+            attrs[key] = value;
+            hasAttrsChanged = true;
+          }
+        }
+      }
+    }
+  } else {
+    if (setFullProps(instance, rawProps, props, attrs)) {
+      hasAttrsChanged = true;
+    }
+    let kebabKey;
+    for (const key in rawCurrentProps) {
+      if (!rawProps || // for camelCase
+      !hasOwn(rawProps, key) && // it's possible the original props was passed in as kebab-case
+      // and converted to camelCase (#955)
+      ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
+        if (options) {
+          if (rawPrevProps && // for camelCase
+          (rawPrevProps[key] !== void 0 || // for kebab-case
+          rawPrevProps[kebabKey] !== void 0)) {
+            props[key] = resolvePropValue(
+              options,
+              rawCurrentProps,
+              key,
+              void 0,
+              instance,
+              true
+              /* isAbsent */
+            );
+          }
+        } else {
+          delete props[key];
+        }
+      }
+    }
+    if (attrs !== rawCurrentProps) {
+      for (const key in attrs) {
+        if (!rawProps || !hasOwn(rawProps, key) && true) {
+          delete attrs[key];
+          hasAttrsChanged = true;
+        }
+      }
+    }
+  }
+  if (hasAttrsChanged) {
+    trigger(instance, "set", "$attrs");
+  }
+  if (!!(process.env.NODE_ENV !== "production")) {
+    validateProps(rawProps || {}, props, instance);
+  }
+}
+function setFullProps(instance, rawProps, props, attrs) {
+  const [options, needCastKeys] = instance.propsOptions;
+  let hasAttrsChanged = false;
+  let rawCastValues;
+  if (rawProps) {
+    for (let key in rawProps) {
+      if (isReservedProp(key)) {
+        continue;
+      }
+      const value = rawProps[key];
+      let camelKey;
+      if (options && hasOwn(options, camelKey = camelize(key))) {
+        if (!needCastKeys || !needCastKeys.includes(camelKey)) {
+          props[camelKey] = value;
+        } else {
+          (rawCastValues || (rawCastValues = {}))[camelKey] = value;
+        }
+      } else if (!isEmitListener(instance.emitsOptions, key)) {
+        if (!(key in attrs) || value !== attrs[key]) {
+          attrs[key] = value;
+          hasAttrsChanged = true;
+        }
+      }
+    }
+  }
+  if (needCastKeys) {
+    const rawCurrentProps = toRaw(props);
+    const castValues = rawCastValues || EMPTY_OBJ;
+    for (let i = 0; i < needCastKeys.length; i++) {
+      const key = needCastKeys[i];
+      props[key] = resolvePropValue(
+        options,
+        rawCurrentProps,
+        key,
+        castValues[key],
+        instance,
+        !hasOwn(castValues, key)
+      );
+    }
+  }
+  return hasAttrsChanged;
+}
+function resolvePropValue(options, props, key, value, instance, isAbsent) {
+  const opt = options[key];
+  if (opt != null) {
+    const hasDefault = hasOwn(opt, "default");
+    if (hasDefault && value === void 0) {
+      const defaultValue = opt.default;
+      if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
+        const { propsDefaults } = instance;
+        if (key in propsDefaults) {
+          value = propsDefaults[key];
+        } else {
+          setCurrentInstance(instance);
+          value = propsDefaults[key] = defaultValue.call(
+            null,
+            props
+          );
+          unsetCurrentInstance();
+        }
+      } else {
+        value = defaultValue;
+      }
+    }
+    if (opt[0 /* shouldCast */]) {
+      if (isAbsent && !hasDefault) {
+        value = false;
+      } else if (opt[1 /* shouldCastTrue */] && (value === "" || value === hyphenate(key))) {
+        value = true;
+      }
+    }
+  }
+  return value;
+}
+function normalizePropsOptions(comp, appContext, asMixin = false) {
+  const cache = appContext.propsCache;
+  const cached = cache.get(comp);
+  if (cached) {
+    return cached;
+  }
+  const raw = comp.props;
+  const normalized = {};
+  const needCastKeys = [];
+  let hasExtends = false;
+  if (__VUE_OPTIONS_API__ && !isFunction(comp)) {
+    const extendProps = (raw2) => {
+      hasExtends = true;
+      const [props, keys] = normalizePropsOptions(raw2, appContext, true);
+      extend(normalized, props);
+      if (keys)
+        needCastKeys.push(...keys);
+    };
+    if (!asMixin && appContext.mixins.length) {
+      appContext.mixins.forEach(extendProps);
+    }
+    if (comp.extends) {
+      extendProps(comp.extends);
+    }
+    if (comp.mixins) {
+      comp.mixins.forEach(extendProps);
+    }
+  }
+  if (!raw && !hasExtends) {
+    if (isObject(comp)) {
+      cache.set(comp, EMPTY_ARR);
+    }
+    return EMPTY_ARR;
+  }
+  if (isArray(raw)) {
+    for (let i = 0; i < raw.length; i++) {
+      if (!!(process.env.NODE_ENV !== "production") && !isString(raw[i])) {
+        warn(`props must be strings when using array syntax.`, raw[i]);
+      }
+      const normalizedKey = camelize(raw[i]);
+      if (validatePropName(normalizedKey)) {
+        normalized[normalizedKey] = EMPTY_OBJ;
+      }
+    }
+  } else if (raw) {
+    if (!!(process.env.NODE_ENV !== "production") && !isObject(raw)) {
+      warn(`invalid props options`, raw);
+    }
+    for (const key in raw) {
+      const normalizedKey = camelize(key);
+      if (validatePropName(normalizedKey)) {
+        const opt = raw[key];
+        const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? { type: opt } : extend({}, opt);
+        if (prop) {
+          const booleanIndex = getTypeIndex(Boolean, prop.type);
+          const stringIndex = getTypeIndex(String, prop.type);
+          prop[0 /* shouldCast */] = booleanIndex > -1;
+          prop[1 /* shouldCastTrue */] = stringIndex < 0 || booleanIndex < stringIndex;
+          if (booleanIndex > -1 || hasOwn(prop, "default")) {
+            needCastKeys.push(normalizedKey);
+          }
+        }
+      }
+    }
+  }
+  const res = [normalized, needCastKeys];
+  if (isObject(comp)) {
+    cache.set(comp, res);
+  }
+  return res;
+}
+function validatePropName(key) {
+  if (key[0] !== "$") {
+    return true;
+  } else if (!!(process.env.NODE_ENV !== "production")) {
+    warn(`Invalid prop name: "${key}" is a reserved property.`);
+  }
+  return false;
+}
+function getType(ctor) {
+  const match = ctor && ctor.toString().match(/^\s*(function|class) (\w+)/);
+  return match ? match[2] : ctor === null ? "null" : "";
+}
+function isSameType(a, b) {
+  return getType(a) === getType(b);
+}
+function getTypeIndex(type, expectedTypes) {
+  if (isArray(expectedTypes)) {
+    return expectedTypes.findIndex((t) => isSameType(t, type));
+  } else if (isFunction(expectedTypes)) {
+    return isSameType(expectedTypes, type) ? 0 : -1;
+  }
+  return -1;
+}
+function validateProps(rawProps, props, instance) {
+  const resolvedValues = toRaw(props);
+  const options = instance.propsOptions[0];
+  for (const key in options) {
+    let opt = options[key];
+    if (opt == null)
+      continue;
+    validateProp(
+      key,
+      resolvedValues[key],
+      opt,
+      !hasOwn(rawProps, key) && !hasOwn(rawProps, hyphenate(key))
+    );
+  }
+}
+function validateProp(name, value, prop, isAbsent) {
+  const { type, required, validator, skipCheck } = prop;
+  if (required && isAbsent) {
+    warn('Missing required prop: "' + name + '"');
+    return;
+  }
+  if (value == null && !required) {
+    return;
+  }
+  if (type != null && type !== true && !skipCheck) {
+    let isValid = false;
+    const types = isArray(type) ? type : [type];
+    const expectedTypes = [];
+    for (let i = 0; i < types.length && !isValid; i++) {
+      const { valid, expectedType } = assertType(value, types[i]);
+      expectedTypes.push(expectedType || "");
+      isValid = valid;
+    }
+    if (!isValid) {
+      warn(getInvalidTypeMessage(name, value, expectedTypes));
+      return;
+    }
+  }
+  if (validator && !validator(value)) {
+    warn('Invalid prop: custom validator check failed for prop "' + name + '".');
+  }
+}
+const isSimpleType = /* @__PURE__ */ makeMap(
+  "String,Number,Boolean,Function,Symbol,BigInt"
+);
+function assertType(value, type) {
+  let valid;
+  const expectedType = getType(type);
+  if (isSimpleType(expectedType)) {
+    const t = typeof value;
+    valid = t === expectedType.toLowerCase();
+    if (!valid && t === "object") {
+      valid = value instanceof type;
+    }
+  } else if (expectedType === "Object") {
+    valid = isObject(value);
+  } else if (expectedType === "Array") {
+    valid = isArray(value);
+  } else if (expectedType === "null") {
+    valid = value === null;
+  } else {
+    valid = value instanceof type;
+  }
+  return {
+    valid,
+    expectedType
+  };
+}
+function getInvalidTypeMessage(name, value, expectedTypes) {
+  let message = `Invalid prop: type check failed for prop "${name}". Expected ${expectedTypes.map(capitalize).join(" | ")}`;
+  const expectedType = expectedTypes[0];
+  const receivedType = toRawType(value);
+  const expectedValue = styleValue(value, expectedType);
+  const receivedValue = styleValue(value, receivedType);
+  if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) {
+    message += ` with value ${expectedValue}`;
+  }
+  message += `, got ${receivedType} `;
+  if (isExplicable(receivedType)) {
+    message += `with value ${receivedValue}.`;
+  }
+  return message;
+}
+function styleValue(value, type) {
+  if (type === "String") {
+    return `"${value}"`;
+  } else if (type === "Number") {
+    return `${Number(value)}`;
+  } else {
+    return `${value}`;
+  }
+}
+function isExplicable(type) {
+  const explicitTypes = ["string", "number", "boolean"];
+  return explicitTypes.some((elem) => type.toLowerCase() === elem);
+}
+function isBoolean(...args) {
+  return args.some((elem) => elem.toLowerCase() === "boolean");
+}
+
+const isInternalKey = (key) => key[0] === "_" || key === "$stable";
+const normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
+const normalizeSlot = (key, rawSlot, ctx) => {
+  if (rawSlot._n) {
+    return rawSlot;
+  }
+  const normalized = withCtx((...args) => {
+    if (!!(process.env.NODE_ENV !== "production") && currentInstance) {
+      warn(
+        `Slot "${key}" invoked outside of the render function: this will not track dependencies used in the slot. Invoke the slot function inside the render function instead.`
+      );
+    }
+    return normalizeSlotValue(rawSlot(...args));
+  }, ctx);
+  normalized._c = false;
+  return normalized;
+};
+const normalizeObjectSlots = (rawSlots, slots, instance) => {
+  const ctx = rawSlots._ctx;
+  for (const key in rawSlots) {
+    if (isInternalKey(key))
+      continue;
+    const value = rawSlots[key];
+    if (isFunction(value)) {
+      slots[key] = normalizeSlot(key, value, ctx);
+    } else if (value != null) {
+      if (!!(process.env.NODE_ENV !== "production") && true) {
+        warn(
+          `Non-function value encountered for slot "${key}". Prefer function slots for better performance.`
+        );
+      }
+      const normalized = normalizeSlotValue(value);
+      slots[key] = () => normalized;
+    }
+  }
+};
+const normalizeVNodeSlots = (instance, children) => {
+  if (!!(process.env.NODE_ENV !== "production") && !isKeepAlive(instance.vnode) && true) {
+    warn(
+      `Non-function value encountered for default slot. Prefer function slots for better performance.`
+    );
+  }
+  const normalized = normalizeSlotValue(children);
+  instance.slots.default = () => normalized;
+};
+const initSlots = (instance, children) => {
+  if (instance.vnode.shapeFlag & 32) {
+    const type = children._;
+    if (type) {
+      instance.slots = toRaw(children);
+      def(children, "_", type);
+    } else {
+      normalizeObjectSlots(
+        children,
+        instance.slots = {});
+    }
+  } else {
+    instance.slots = {};
+    if (children) {
+      normalizeVNodeSlots(instance, children);
+    }
+  }
+  def(instance.slots, InternalObjectKey, 1);
+};
+const updateSlots = (instance, children, optimized) => {
+  const { vnode, slots } = instance;
+  let needDeletionCheck = true;
+  let deletionComparisonTarget = EMPTY_OBJ;
+  if (vnode.shapeFlag & 32) {
+    const type = children._;
+    if (type) {
+      if (!!(process.env.NODE_ENV !== "production") && isHmrUpdating) {
+        extend(slots, children);
+        trigger(instance, "set", "$slots");
+      } else if (optimized && type === 1) {
+        needDeletionCheck = false;
+      } else {
+        extend(slots, children);
+        if (!optimized && type === 1) {
+          delete slots._;
+        }
+      }
+    } else {
+      needDeletionCheck = !children.$stable;
+      normalizeObjectSlots(children, slots);
+    }
+    deletionComparisonTarget = children;
+  } else if (children) {
+    normalizeVNodeSlots(instance, children);
+    deletionComparisonTarget = { default: 1 };
+  }
+  if (needDeletionCheck) {
+    for (const key in slots) {
+      if (!isInternalKey(key) && !(key in deletionComparisonTarget)) {
+        delete slots[key];
+      }
+    }
+  }
+};
+
+function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
+  if (isArray(rawRef)) {
+    rawRef.forEach(
+      (r, i) => setRef(
+        r,
+        oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef),
+        parentSuspense,
+        vnode,
+        isUnmount
+      )
+    );
+    return;
+  }
+  if (isAsyncWrapper(vnode) && !isUnmount) {
+    return;
+  }
+  const refValue = vnode.shapeFlag & 4 ? getExposeProxy(vnode.component) || vnode.component.proxy : vnode.el;
+  const value = isUnmount ? null : refValue;
+  const { i: owner, r: ref } = rawRef;
+  if (!!(process.env.NODE_ENV !== "production") && !owner) {
+    warn(
+      `Missing ref owner context. ref cannot be used on hoisted vnodes. A vnode with ref must be created inside the render function.`
+    );
+    return;
+  }
+  const oldRef = oldRawRef && oldRawRef.r;
+  const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;
+  const setupState = owner.setupState;
+  if (oldRef != null && oldRef !== ref) {
+    if (isString(oldRef)) {
+      refs[oldRef] = null;
+      if (hasOwn(setupState, oldRef)) {
+        setupState[oldRef] = null;
+      }
+    } else if (isRef(oldRef)) {
+      oldRef.value = null;
+    }
+  }
+  if (isFunction(ref)) {
+    callWithErrorHandling(ref, owner, 12, [value, refs]);
+  } else {
+    const _isString = isString(ref);
+    const _isRef = isRef(ref);
+    if (_isString || _isRef) {
+      const doSet = () => {
+        if (rawRef.f) {
+          const existing = _isString ? hasOwn(setupState, ref) ? setupState[ref] : refs[ref] : ref.value;
+          if (isUnmount) {
+            isArray(existing) && remove(existing, refValue);
+          } else {
+            if (!isArray(existing)) {
+              if (_isString) {
+                refs[ref] = [refValue];
+                if (hasOwn(setupState, ref)) {
+                  setupState[ref] = refs[ref];
+                }
+              } else {
+                ref.value = [refValue];
+                if (rawRef.k)
+                  refs[rawRef.k] = ref.value;
+              }
+            } else if (!existing.includes(refValue)) {
+              existing.push(refValue);
+            }
+          }
+        } else if (_isString) {
+          refs[ref] = value;
+          if (hasOwn(setupState, ref)) {
+            setupState[ref] = value;
+          }
+        } else if (_isRef) {
+          ref.value = value;
+          if (rawRef.k)
+            refs[rawRef.k] = value;
+        } else if (!!(process.env.NODE_ENV !== "production")) {
+          warn("Invalid template ref type:", ref, `(${typeof ref})`);
+        }
+      };
+      if (value) {
+        doSet.id = -1;
+        queuePostRenderEffect(doSet, parentSuspense);
+      } else {
+        doSet();
+      }
+    } else if (!!(process.env.NODE_ENV !== "production")) {
+      warn("Invalid template ref type:", ref, `(${typeof ref})`);
+    }
+  }
+}
+
+let hasMismatch = false;
+const isSVGContainer = (container) => /svg/.test(container.namespaceURI) && container.tagName !== "foreignObject";
+const isComment = (node) => node.nodeType === 8 /* COMMENT */;
+function createHydrationFunctions(rendererInternals) {
+  const {
+    mt: mountComponent,
+    p: patch,
+    o: {
+      patchProp,
+      createText,
+      nextSibling,
+      parentNode,
+      remove,
+      insert,
+      createComment
+    }
+  } = rendererInternals;
+  const hydrate = (vnode, container) => {
+    if (!container.hasChildNodes()) {
+      !!(process.env.NODE_ENV !== "production") && warn(
+        `Attempting to hydrate existing markup but container is empty. Performing full mount instead.`
+      );
+      patch(null, vnode, container);
+      flushPostFlushCbs();
+      container._vnode = vnode;
+      return;
+    }
+    hasMismatch = false;
+    hydrateNode(container.firstChild, vnode, null, null, null);
+    flushPostFlushCbs();
+    container._vnode = vnode;
+    if (hasMismatch && true) {
+      console.error(`Hydration completed but contains mismatches.`);
+    }
+  };
+  const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
+    const isFragmentStart = isComment(node) && node.data === "[";
+    const onMismatch = () => handleMismatch(
+      node,
+      vnode,
+      parentComponent,
+      parentSuspense,
+      slotScopeIds,
+      isFragmentStart
+    );
+    const { type, ref, shapeFlag, patchFlag } = vnode;
+    let domType = node.nodeType;
+    vnode.el = node;
+    if (patchFlag === -2) {
+      optimized = false;
+      vnode.dynamicChildren = null;
+    }
+    let nextNode = null;
+    switch (type) {
+      case Text:
+        if (domType !== 3 /* TEXT */) {
+          if (vnode.children === "") {
+            insert(vnode.el = createText(""), parentNode(node), node);
+            nextNode = node;
+          } else {
+            nextNode = onMismatch();
+          }
+        } else {
+          if (node.data !== vnode.children) {
+            hasMismatch = true;
+            !!(process.env.NODE_ENV !== "production") && warn(
+              `Hydration text mismatch:
+- Client: ${JSON.stringify(node.data)}
+- Server: ${JSON.stringify(vnode.children)}`
+            );
+            node.data = vnode.children;
+          }
+          nextNode = nextSibling(node);
+        }
+        break;
+      case Comment:
+        if (domType !== 8 /* COMMENT */ || isFragmentStart) {
+          nextNode = onMismatch();
+        } else {
+          nextNode = nextSibling(node);
+        }
+        break;
+      case Static:
+        if (isFragmentStart) {
+          node = nextSibling(node);
+          domType = node.nodeType;
+        }
+        if (domType === 1 /* ELEMENT */ || domType === 3 /* TEXT */) {
+          nextNode = node;
+          const needToAdoptContent = !vnode.children.length;
+          for (let i = 0; i < vnode.staticCount; i++) {
+            if (needToAdoptContent)
+              vnode.children += nextNode.nodeType === 1 /* ELEMENT */ ? nextNode.outerHTML : nextNode.data;
+            if (i === vnode.staticCount - 1) {
+              vnode.anchor = nextNode;
+            }
+            nextNode = nextSibling(nextNode);
+          }
+          return isFragmentStart ? nextSibling(nextNode) : nextNode;
+        } else {
+          onMismatch();
+        }
+        break;
+      case Fragment:
+        if (!isFragmentStart) {
+          nextNode = onMismatch();
+        } else {
+          nextNode = hydrateFragment(
+            node,
+            vnode,
+            parentComponent,
+            parentSuspense,
+            slotScopeIds,
+            optimized
+          );
+        }
+        break;
+      default:
+        if (shapeFlag & 1) {
+          if (domType !== 1 /* ELEMENT */ || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) {
+            nextNode = onMismatch();
+          } else {
+            nextNode = hydrateElement(
+              node,
+              vnode,
+              parentComponent,
+              parentSuspense,
+              slotScopeIds,
+              optimized
+            );
+          }
+        } else if (shapeFlag & 6) {
+          vnode.slotScopeIds = slotScopeIds;
+          const container = parentNode(node);
+          mountComponent(
+            vnode,
+            container,
+            null,
+            parentComponent,
+            parentSuspense,
+            isSVGContainer(container),
+            optimized
+          );
+          nextNode = isFragmentStart ? locateClosingAsyncAnchor(node) : nextSibling(node);
+          if (nextNode && isComment(nextNode) && nextNode.data === "teleport end") {
+            nextNode = nextSibling(nextNode);
+          }
+          if (isAsyncWrapper(vnode)) {
+            let subTree;
+            if (isFragmentStart) {
+              subTree = createVNode(Fragment);
+              subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild;
+            } else {
+              subTree = node.nodeType === 3 ? createTextVNode("") : createVNode("div");
+            }
+            subTree.el = node;
+            vnode.component.subTree = subTree;
+          }
+        } else if (shapeFlag & 64) {
+          if (domType !== 8 /* COMMENT */) {
+            nextNode = onMismatch();
+          } else {
+            nextNode = vnode.type.hydrate(
+              node,
+              vnode,
+              parentComponent,
+              parentSuspense,
+              slotScopeIds,
+              optimized,
+              rendererInternals,
+              hydrateChildren
+            );
+          }
+        } else if (shapeFlag & 128) {
+          nextNode = vnode.type.hydrate(
+            node,
+            vnode,
+            parentComponent,
+            parentSuspense,
+            isSVGContainer(parentNode(node)),
+            slotScopeIds,
+            optimized,
+            rendererInternals,
+            hydrateNode
+          );
+        } else if (!!(process.env.NODE_ENV !== "production")) {
+          warn("Invalid HostVNode type:", type, `(${typeof type})`);
+        }
+    }
+    if (ref != null) {
+      setRef(ref, null, parentSuspense, vnode);
+    }
+    return nextNode;
+  };
+  const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
+    optimized = optimized || !!vnode.dynamicChildren;
+    const { type, props, patchFlag, shapeFlag, dirs } = vnode;
+    const forcePatchValue = type === "input" && dirs || type === "option";
+    if (!!(process.env.NODE_ENV !== "production") || forcePatchValue || patchFlag !== -1) {
+      if (dirs) {
+        invokeDirectiveHook(vnode, null, parentComponent, "created");
+      }
+      if (props) {
+        if (forcePatchValue || !optimized || patchFlag & (16 | 32)) {
+          for (const key in props) {
+            if (forcePatchValue && key.endsWith("value") || isOn(key) && !isReservedProp(key)) {
+              patchProp(
+                el,
+                key,
+                null,
+                props[key],
+                false,
+                void 0,
+                parentComponent
+              );
+            }
+          }
+        } else if (props.onClick) {
+          patchProp(
+            el,
+            "onClick",
+            null,
+            props.onClick,
+            false,
+            void 0,
+            parentComponent
+          );
+        }
+      }
+      let vnodeHooks;
+      if (vnodeHooks = props && props.onVnodeBeforeMount) {
+        invokeVNodeHook(vnodeHooks, parentComponent, vnode);
+      }
+      if (dirs) {
+        invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
+      }
+      if ((vnodeHooks = props && props.onVnodeMounted) || dirs) {
+        queueEffectWithSuspense(() => {
+          vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
+          dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
+        }, parentSuspense);
+      }
+      if (shapeFlag & 16 && // skip if element has innerHTML / textContent
+      !(props && (props.innerHTML || props.textContent))) {
+        let next = hydrateChildren(
+          el.firstChild,
+          vnode,
+          el,
+          parentComponent,
+          parentSuspense,
+          slotScopeIds,
+          optimized
+        );
+        let hasWarned = false;
+        while (next) {
+          hasMismatch = true;
+          if (!!(process.env.NODE_ENV !== "production") && !hasWarned) {
+            warn(
+              `Hydration children mismatch in <${vnode.type}>: server rendered element contains more child nodes than client vdom.`
+            );
+            hasWarned = true;
+          }
+          const cur = next;
+          next = next.nextSibling;
+          remove(cur);
+        }
+      } else if (shapeFlag & 8) {
+        if (el.textContent !== vnode.children) {
+          hasMismatch = true;
+          !!(process.env.NODE_ENV !== "production") && warn(
+            `Hydration text content mismatch in <${vnode.type}>:
+- Client: ${el.textContent}
+- Server: ${vnode.children}`
+          );
+          el.textContent = vnode.children;
+        }
+      }
+    }
+    return el.nextSibling;
+  };
+  const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => {
+    optimized = optimized || !!parentVNode.dynamicChildren;
+    const children = parentVNode.children;
+    const l = children.length;
+    let hasWarned = false;
+    for (let i = 0; i < l; i++) {
+      const vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]);
+      if (node) {
+        node = hydrateNode(
+          node,
+          vnode,
+          parentComponent,
+          parentSuspense,
+          slotScopeIds,
+          optimized
+        );
+      } else if (vnode.type === Text && !vnode.children) {
+        continue;
+      } else {
+        hasMismatch = true;
+        if (!!(process.env.NODE_ENV !== "production") && !hasWarned) {
+          warn(
+            `Hydration children mismatch in <${container.tagName.toLowerCase()}>: server rendered element contains fewer child nodes than client vdom.`
+          );
+          hasWarned = true;
+        }
+        patch(
+          null,
+          vnode,
+          container,
+          null,
+          parentComponent,
+          parentSuspense,
+          isSVGContainer(container),
+          slotScopeIds
+        );
+      }
+    }
+    return node;
+  };
+  const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
+    const { slotScopeIds: fragmentSlotScopeIds } = vnode;
+    if (fragmentSlotScopeIds) {
+      slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
+    }
+    const container = parentNode(node);
+    const next = hydrateChildren(
+      nextSibling(node),
+      vnode,
+      container,
+      parentComponent,
+      parentSuspense,
+      slotScopeIds,
+      optimized
+    );
+    if (next && isComment(next) && next.data === "]") {
+      return nextSibling(vnode.anchor = next);
+    } else {
+      hasMismatch = true;
+      insert(vnode.anchor = createComment(`]`), container, next);
+      return next;
+    }
+  };
+  const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
+    hasMismatch = true;
+    !!(process.env.NODE_ENV !== "production") && warn(
+      `Hydration node mismatch:
+- Client vnode:`,
+      vnode.type,
+      `
+- Server rendered DOM:`,
+      node,
+      node.nodeType === 3 /* TEXT */ ? `(text)` : isComment(node) && node.data === "[" ? `(start of fragment)` : ``
+    );
+    vnode.el = null;
+    if (isFragment) {
+      const end = locateClosingAsyncAnchor(node);
+      while (true) {
+        const next2 = nextSibling(node);
+        if (next2 && next2 !== end) {
+          remove(next2);
+        } else {
+          break;
+        }
+      }
+    }
+    const next = nextSibling(node);
+    const container = parentNode(node);
+    remove(node);
+    patch(
+      null,
+      vnode,
+      container,
+      next,
+      parentComponent,
+      parentSuspense,
+      isSVGContainer(container),
+      slotScopeIds
+    );
+    return next;
+  };
+  const locateClosingAsyncAnchor = (node) => {
+    let match = 0;
+    while (node) {
+      node = nextSibling(node);
+      if (node && isComment(node)) {
+        if (node.data === "[")
+          match++;
+        if (node.data === "]") {
+          if (match === 0) {
+            return nextSibling(node);
+          } else {
+            match--;
+          }
+        }
+      }
+    }
+    return node;
+  };
+  return [hydrate, hydrateNode];
+}
+
+let supported;
+let perf;
+function startMeasure(instance, type) {
+  if (instance.appContext.config.performance && isSupported()) {
+    perf.mark(`vue-${type}-${instance.uid}`);
+  }
+  if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+    devtoolsPerfStart(instance, type, isSupported() ? perf.now() : Date.now());
+  }
+}
+function endMeasure(instance, type) {
+  if (instance.appContext.config.performance && isSupported()) {
+    const startTag = `vue-${type}-${instance.uid}`;
+    const endTag = startTag + `:end`;
+    perf.mark(endTag);
+    perf.measure(
+      `<${formatComponentName(instance, instance.type)}> ${type}`,
+      startTag,
+      endTag
+    );
+    perf.clearMarks(startTag);
+    perf.clearMarks(endTag);
+  }
+  if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+    devtoolsPerfEnd(instance, type, isSupported() ? perf.now() : Date.now());
+  }
+}
+function isSupported() {
+  if (supported !== void 0) {
+    return supported;
+  }
+  if (typeof window !== "undefined" && window.performance) {
+    supported = true;
+    perf = window.performance;
+  } else {
+    supported = false;
+  }
+  return supported;
+}
+
+function initFeatureFlags() {
+  const needWarn = [];
+  if (typeof __VUE_OPTIONS_API__ !== "boolean") {
+    !!(process.env.NODE_ENV !== "production") && needWarn.push(`__VUE_OPTIONS_API__`);
+    getGlobalThis().__VUE_OPTIONS_API__ = true;
+  }
+  if (typeof __VUE_PROD_DEVTOOLS__ !== "boolean") {
+    !!(process.env.NODE_ENV !== "production") && needWarn.push(`__VUE_PROD_DEVTOOLS__`);
+    getGlobalThis().__VUE_PROD_DEVTOOLS__ = false;
+  }
+  if (!!(process.env.NODE_ENV !== "production") && needWarn.length) {
+    const multi = needWarn.length > 1;
+    console.warn(
+      `Feature flag${multi ? `s` : ``} ${needWarn.join(", ")} ${multi ? `are` : `is`} not explicitly defined. You are running the esm-bundler build of Vue, which expects these compile-time feature flags to be globally injected via the bundler config in order to get better tree-shaking in the production bundle.
+
+For more details, see https://link.vuejs.org/feature-flags.`
+    );
+  }
+}
+
+const queuePostRenderEffect = queueEffectWithSuspense ;
+function createRenderer(options) {
+  return baseCreateRenderer(options);
+}
+function createHydrationRenderer(options) {
+  return baseCreateRenderer(options, createHydrationFunctions);
+}
+function baseCreateRenderer(options, createHydrationFns) {
+  {
+    initFeatureFlags();
+  }
+  const target = getGlobalThis();
+  target.__VUE__ = true;
+  if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+    setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__, target);
+  }
+  const {
+    insert: hostInsert,
+    remove: hostRemove,
+    patchProp: hostPatchProp,
+    createElement: hostCreateElement,
+    createText: hostCreateText,
+    createComment: hostCreateComment,
+    setText: hostSetText,
+    setElementText: hostSetElementText,
+    parentNode: hostParentNode,
+    nextSibling: hostNextSibling,
+    setScopeId: hostSetScopeId = NOOP,
+    insertStaticContent: hostInsertStaticContent
+  } = options;
+  const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, slotScopeIds = null, optimized = !!(process.env.NODE_ENV !== "production") && isHmrUpdating ? false : !!n2.dynamicChildren) => {
+    if (n1 === n2) {
+      return;
+    }
+    if (n1 && !isSameVNodeType(n1, n2)) {
+      anchor = getNextHostNode(n1);
+      unmount(n1, parentComponent, parentSuspense, true);
+      n1 = null;
+    }
+    if (n2.patchFlag === -2) {
+      optimized = false;
+      n2.dynamicChildren = null;
+    }
+    const { type, ref, shapeFlag } = n2;
+    switch (type) {
+      case Text:
+        processText(n1, n2, container, anchor);
+        break;
+      case Comment:
+        processCommentNode(n1, n2, container, anchor);
+        break;
+      case Static:
+        if (n1 == null) {
+          mountStaticNode(n2, container, anchor, isSVG);
+        } else if (!!(process.env.NODE_ENV !== "production")) {
+          patchStaticNode(n1, n2, container, isSVG);
+        }
+        break;
+      case Fragment:
+        processFragment(
+          n1,
+          n2,
+          container,
+          anchor,
+          parentComponent,
+          parentSuspense,
+          isSVG,
+          slotScopeIds,
+          optimized
+        );
+        break;
+      default:
+        if (shapeFlag & 1) {
+          processElement(
+            n1,
+            n2,
+            container,
+            anchor,
+            parentComponent,
+            parentSuspense,
+            isSVG,
+            slotScopeIds,
+            optimized
+          );
+        } else if (shapeFlag & 6) {
+          processComponent(
+            n1,
+            n2,
+            container,
+            anchor,
+            parentComponent,
+            parentSuspense,
+            isSVG,
+            slotScopeIds,
+            optimized
+          );
+        } else if (shapeFlag & 64) {
+          type.process(
+            n1,
+            n2,
+            container,
+            anchor,
+            parentComponent,
+            parentSuspense,
+            isSVG,
+            slotScopeIds,
+            optimized,
+            internals
+          );
+        } else if (shapeFlag & 128) {
+          type.process(
+            n1,
+            n2,
+            container,
+            anchor,
+            parentComponent,
+            parentSuspense,
+            isSVG,
+            slotScopeIds,
+            optimized,
+            internals
+          );
+        } else if (!!(process.env.NODE_ENV !== "production")) {
+          warn("Invalid VNode type:", type, `(${typeof type})`);
+        }
+    }
+    if (ref != null && parentComponent) {
+      setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
+    }
+  };
+  const processText = (n1, n2, container, anchor) => {
+    if (n1 == null) {
+      hostInsert(
+        n2.el = hostCreateText(n2.children),
+        container,
+        anchor
+      );
+    } else {
+      const el = n2.el = n1.el;
+      if (n2.children !== n1.children) {
+        hostSetText(el, n2.children);
+      }
+    }
+  };
+  const processCommentNode = (n1, n2, container, anchor) => {
+    if (n1 == null) {
+      hostInsert(
+        n2.el = hostCreateComment(n2.children || ""),
+        container,
+        anchor
+      );
+    } else {
+      n2.el = n1.el;
+    }
+  };
+  const mountStaticNode = (n2, container, anchor, isSVG) => {
+    [n2.el, n2.anchor] = hostInsertStaticContent(
+      n2.children,
+      container,
+      anchor,
+      isSVG,
+      n2.el,
+      n2.anchor
+    );
+  };
+  const patchStaticNode = (n1, n2, container, isSVG) => {
+    if (n2.children !== n1.children) {
+      const anchor = hostNextSibling(n1.anchor);
+      removeStaticNode(n1);
+      [n2.el, n2.anchor] = hostInsertStaticContent(
+        n2.children,
+        container,
+        anchor,
+        isSVG
+      );
+    } else {
+      n2.el = n1.el;
+      n2.anchor = n1.anchor;
+    }
+  };
+  const moveStaticNode = ({ el, anchor }, container, nextSibling) => {
+    let next;
+    while (el && el !== anchor) {
+      next = hostNextSibling(el);
+      hostInsert(el, container, nextSibling);
+      el = next;
+    }
+    hostInsert(anchor, container, nextSibling);
+  };
+  const removeStaticNode = ({ el, anchor }) => {
+    let next;
+    while (el && el !== anchor) {
+      next = hostNextSibling(el);
+      hostRemove(el);
+      el = next;
+    }
+    hostRemove(anchor);
+  };
+  const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+    isSVG = isSVG || n2.type === "svg";
+    if (n1 == null) {
+      mountElement(
+        n2,
+        container,
+        anchor,
+        parentComponent,
+        parentSuspense,
+        isSVG,
+        slotScopeIds,
+        optimized
+      );
+    } else {
+      patchElement(
+        n1,
+        n2,
+        parentComponent,
+        parentSuspense,
+        isSVG,
+        slotScopeIds,
+        optimized
+      );
+    }
+  };
+  const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+    let el;
+    let vnodeHook;
+    const { type, props, shapeFlag, transition, dirs } = vnode;
+    el = vnode.el = hostCreateElement(
+      vnode.type,
+      isSVG,
+      props && props.is,
+      props
+    );
+    if (shapeFlag & 8) {
+      hostSetElementText(el, vnode.children);
+    } else if (shapeFlag & 16) {
+      mountChildren(
+        vnode.children,
+        el,
+        null,
+        parentComponent,
+        parentSuspense,
+        isSVG && type !== "foreignObject",
+        slotScopeIds,
+        optimized
+      );
+    }
+    if (dirs) {
+      invokeDirectiveHook(vnode, null, parentComponent, "created");
+    }
+    setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);
+    if (props) {
+      for (const key in props) {
+        if (key !== "value" && !isReservedProp(key)) {
+          hostPatchProp(
+            el,
+            key,
+            null,
+            props[key],
+            isSVG,
+            vnode.children,
+            parentComponent,
+            parentSuspense,
+            unmountChildren
+          );
+        }
+      }
+      if ("value" in props) {
+        hostPatchProp(el, "value", null, props.value);
+      }
+      if (vnodeHook = props.onVnodeBeforeMount) {
+        invokeVNodeHook(vnodeHook, parentComponent, vnode);
+      }
+    }
+    if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+      Object.defineProperty(el, "__vnode", {
+        value: vnode,
+        enumerable: false
+      });
+      Object.defineProperty(el, "__vueParentComponent", {
+        value: parentComponent,
+        enumerable: false
+      });
+    }
+    if (dirs) {
+      invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
+    }
+    const needCallTransitionHooks = (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
+    if (needCallTransitionHooks) {
+      transition.beforeEnter(el);
+    }
+    hostInsert(el, container, anchor);
+    if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
+      queuePostRenderEffect(() => {
+        vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
+        needCallTransitionHooks && transition.enter(el);
+        dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
+      }, parentSuspense);
+    }
+  };
+  const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {
+    if (scopeId) {
+      hostSetScopeId(el, scopeId);
+    }
+    if (slotScopeIds) {
+      for (let i = 0; i < slotScopeIds.length; i++) {
+        hostSetScopeId(el, slotScopeIds[i]);
+      }
+    }
+    if (parentComponent) {
+      let subTree = parentComponent.subTree;
+      if (!!(process.env.NODE_ENV !== "production") && subTree.patchFlag > 0 && subTree.patchFlag & 2048) {
+        subTree = filterSingleRoot(subTree.children) || subTree;
+      }
+      if (vnode === subTree) {
+        const parentVNode = parentComponent.vnode;
+        setScopeId(
+          el,
+          parentVNode,
+          parentVNode.scopeId,
+          parentVNode.slotScopeIds,
+          parentComponent.parent
+        );
+      }
+    }
+  };
+  const mountChildren = (children, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, start = 0) => {
+    for (let i = start; i < children.length; i++) {
+      const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]);
+      patch(
+        null,
+        child,
+        container,
+        anchor,
+        parentComponent,
+        parentSuspense,
+        isSVG,
+        slotScopeIds,
+        optimized
+      );
+    }
+  };
+  const patchElement = (n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+    const el = n2.el = n1.el;
+    let { patchFlag, dynamicChildren, dirs } = n2;
+    patchFlag |= n1.patchFlag & 16;
+    const oldProps = n1.props || EMPTY_OBJ;
+    const newProps = n2.props || EMPTY_OBJ;
+    let vnodeHook;
+    parentComponent && toggleRecurse(parentComponent, false);
+    if (vnodeHook = newProps.onVnodeBeforeUpdate) {
+      invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
+    }
+    if (dirs) {
+      invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");
+    }
+    parentComponent && toggleRecurse(parentComponent, true);
+    if (!!(process.env.NODE_ENV !== "production") && isHmrUpdating) {
+      patchFlag = 0;
+      optimized = false;
+      dynamicChildren = null;
+    }
+    const areChildrenSVG = isSVG && n2.type !== "foreignObject";
+    if (dynamicChildren) {
+      patchBlockChildren(
+        n1.dynamicChildren,
+        dynamicChildren,
+        el,
+        parentComponent,
+        parentSuspense,
+        areChildrenSVG,
+        slotScopeIds
+      );
+      if (!!(process.env.NODE_ENV !== "production")) {
+        traverseStaticChildren(n1, n2);
+      }
+    } else if (!optimized) {
+      patchChildren(
+        n1,
+        n2,
+        el,
+        null,
+        parentComponent,
+        parentSuspense,
+        areChildrenSVG,
+        slotScopeIds,
+        false
+      );
+    }
+    if (patchFlag > 0) {
+      if (patchFlag & 16) {
+        patchProps(
+          el,
+          n2,
+          oldProps,
+          newProps,
+          parentComponent,
+          parentSuspense,
+          isSVG
+        );
+      } else {
+        if (patchFlag & 2) {
+          if (oldProps.class !== newProps.class) {
+            hostPatchProp(el, "class", null, newProps.class, isSVG);
+          }
+        }
+        if (patchFlag & 4) {
+          hostPatchProp(el, "style", oldProps.style, newProps.style, isSVG);
+        }
+        if (patchFlag & 8) {
+          const propsToUpdate = n2.dynamicProps;
+          for (let i = 0; i < propsToUpdate.length; i++) {
+            const key = propsToUpdate[i];
+            const prev = oldProps[key];
+            const next = newProps[key];
+            if (next !== prev || key === "value") {
+              hostPatchProp(
+                el,
+                key,
+                prev,
+                next,
+                isSVG,
+                n1.children,
+                parentComponent,
+                parentSuspense,
+                unmountChildren
+              );
+            }
+          }
+        }
+      }
+      if (patchFlag & 1) {
+        if (n1.children !== n2.children) {
+          hostSetElementText(el, n2.children);
+        }
+      }
+    } else if (!optimized && dynamicChildren == null) {
+      patchProps(
+        el,
+        n2,
+        oldProps,
+        newProps,
+        parentComponent,
+        parentSuspense,
+        isSVG
+      );
+    }
+    if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
+      queuePostRenderEffect(() => {
+        vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
+        dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
+      }, parentSuspense);
+    }
+  };
+  const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, isSVG, slotScopeIds) => {
+    for (let i = 0; i < newChildren.length; i++) {
+      const oldVNode = oldChildren[i];
+      const newVNode = newChildren[i];
+      const container = (
+        // oldVNode may be an errored async setup() component inside Suspense
+        // which will not have a mounted element
+        oldVNode.el && // - In the case of a Fragment, we need to provide the actual parent
+        // of the Fragment itself so it can move its children.
+        (oldVNode.type === Fragment || // - In the case of different nodes, there is going to be a replacement
+        // which also requires the correct parent container
+        !isSameVNodeType(oldVNode, newVNode) || // - In the case of a component, it could contain anything.
+        oldVNode.shapeFlag & (6 | 64)) ? hostParentNode(oldVNode.el) : (
+          // In other cases, the parent container is not actually used so we
+          // just pass the block element here to avoid a DOM parentNode call.
+          fallbackContainer
+        )
+      );
+      patch(
+        oldVNode,
+        newVNode,
+        container,
+        null,
+        parentComponent,
+        parentSuspense,
+        isSVG,
+        slotScopeIds,
+        true
+      );
+    }
+  };
+  const patchProps = (el, vnode, oldProps, newProps, parentComponent, parentSuspense, isSVG) => {
+    if (oldProps !== newProps) {
+      if (oldProps !== EMPTY_OBJ) {
+        for (const key in oldProps) {
+          if (!isReservedProp(key) && !(key in newProps)) {
+            hostPatchProp(
+              el,
+              key,
+              oldProps[key],
+              null,
+              isSVG,
+              vnode.children,
+              parentComponent,
+              parentSuspense,
+              unmountChildren
+            );
+          }
+        }
+      }
+      for (const key in newProps) {
+        if (isReservedProp(key))
+          continue;
+        const next = newProps[key];
+        const prev = oldProps[key];
+        if (next !== prev && key !== "value") {
+          hostPatchProp(
+            el,
+            key,
+            prev,
+            next,
+            isSVG,
+            vnode.children,
+            parentComponent,
+            parentSuspense,
+            unmountChildren
+          );
+        }
+      }
+      if ("value" in newProps) {
+        hostPatchProp(el, "value", oldProps.value, newProps.value);
+      }
+    }
+  };
+  const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+    const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");
+    const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");
+    let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
+    if (!!(process.env.NODE_ENV !== "production") && // #5523 dev root fragment may inherit directives
+    (isHmrUpdating || patchFlag & 2048)) {
+      patchFlag = 0;
+      optimized = false;
+      dynamicChildren = null;
+    }
+    if (fragmentSlotScopeIds) {
+      slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
+    }
+    if (n1 == null) {
+      hostInsert(fragmentStartAnchor, container, anchor);
+      hostInsert(fragmentEndAnchor, container, anchor);
+      mountChildren(
+        n2.children,
+        container,
+        fragmentEndAnchor,
+        parentComponent,
+        parentSuspense,
+        isSVG,
+        slotScopeIds,
+        optimized
+      );
+    } else {
+      if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && // #2715 the previous fragment could've been a BAILed one as a result
+      // of renderSlot() with no valid children
+      n1.dynamicChildren) {
+        patchBlockChildren(
+          n1.dynamicChildren,
+          dynamicChildren,
+          container,
+          parentComponent,
+          parentSuspense,
+          isSVG,
+          slotScopeIds
+        );
+        if (!!(process.env.NODE_ENV !== "production")) {
+          traverseStaticChildren(n1, n2);
+        } else if (
+          // #2080 if the stable fragment has a key, it's a <template v-for> that may
+          //  get moved around. Make sure all root level vnodes inherit el.
+          // #2134 or if it's a component root, it may also get moved around
+          // as the component is being moved.
+          n2.key != null || parentComponent && n2 === parentComponent.subTree
+        ) {
+          traverseStaticChildren(
+            n1,
+            n2,
+            true
+            /* shallow */
+          );
+        }
+      } else {
+        patchChildren(
+          n1,
+          n2,
+          container,
+          fragmentEndAnchor,
+          parentComponent,
+          parentSuspense,
+          isSVG,
+          slotScopeIds,
+          optimized
+        );
+      }
+    }
+  };
+  const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+    n2.slotScopeIds = slotScopeIds;
+    if (n1 == null) {
+      if (n2.shapeFlag & 512) {
+        parentComponent.ctx.activate(
+          n2,
+          container,
+          anchor,
+          isSVG,
+          optimized
+        );
+      } else {
+        mountComponent(
+          n2,
+          container,
+          anchor,
+          parentComponent,
+          parentSuspense,
+          isSVG,
+          optimized
+        );
+      }
+    } else {
+      updateComponent(n1, n2, optimized);
+    }
+  };
+  const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
+    const instance = (initialVNode.component = createComponentInstance(
+      initialVNode,
+      parentComponent,
+      parentSuspense
+    ));
+    if (!!(process.env.NODE_ENV !== "production") && instance.type.__hmrId) {
+      registerHMR(instance);
+    }
+    if (!!(process.env.NODE_ENV !== "production")) {
+      pushWarningContext(initialVNode);
+      startMeasure(instance, `mount`);
+    }
+    if (isKeepAlive(initialVNode)) {
+      instance.ctx.renderer = internals;
+    }
+    {
+      if (!!(process.env.NODE_ENV !== "production")) {
+        startMeasure(instance, `init`);
+      }
+      setupComponent(instance);
+      if (!!(process.env.NODE_ENV !== "production")) {
+        endMeasure(instance, `init`);
+      }
+    }
+    if (instance.asyncDep) {
+      parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect);
+      if (!initialVNode.el) {
+        const placeholder = instance.subTree = createVNode(Comment);
+        processCommentNode(null, placeholder, container, anchor);
+      }
+      return;
+    }
+    setupRenderEffect(
+      instance,
+      initialVNode,
+      container,
+      anchor,
+      parentSuspense,
+      isSVG,
+      optimized
+    );
+    if (!!(process.env.NODE_ENV !== "production")) {
+      popWarningContext();
+      endMeasure(instance, `mount`);
+    }
+  };
+  const updateComponent = (n1, n2, optimized) => {
+    const instance = n2.component = n1.component;
+    if (shouldUpdateComponent(n1, n2, optimized)) {
+      if (instance.asyncDep && !instance.asyncResolved) {
+        if (!!(process.env.NODE_ENV !== "production")) {
+          pushWarningContext(n2);
+        }
+        updateComponentPreRender(instance, n2, optimized);
+        if (!!(process.env.NODE_ENV !== "production")) {
+          popWarningContext();
+        }
+        return;
+      } else {
+        instance.next = n2;
+        invalidateJob(instance.update);
+        instance.update();
+      }
+    } else {
+      n2.el = n1.el;
+      instance.vnode = n2;
+    }
+  };
+  const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized) => {
+    const componentUpdateFn = () => {
+      if (!instance.isMounted) {
+        let vnodeHook;
+        const { el, props } = initialVNode;
+        const { bm, m, parent } = instance;
+        const isAsyncWrapperVNode = isAsyncWrapper(initialVNode);
+        toggleRecurse(instance, false);
+        if (bm) {
+          invokeArrayFns(bm);
+        }
+        if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) {
+          invokeVNodeHook(vnodeHook, parent, initialVNode);
+        }
+        toggleRecurse(instance, true);
+        if (el && hydrateNode) {
+          const hydrateSubTree = () => {
+            if (!!(process.env.NODE_ENV !== "production")) {
+              startMeasure(instance, `render`);
+            }
+            instance.subTree = renderComponentRoot(instance);
+            if (!!(process.env.NODE_ENV !== "production")) {
+              endMeasure(instance, `render`);
+            }
+            if (!!(process.env.NODE_ENV !== "production")) {
+              startMeasure(instance, `hydrate`);
+            }
+            hydrateNode(
+              el,
+              instance.subTree,
+              instance,
+              parentSuspense,
+              null
+            );
+            if (!!(process.env.NODE_ENV !== "production")) {
+              endMeasure(instance, `hydrate`);
+            }
+          };
+          if (isAsyncWrapperVNode) {
+            initialVNode.type.__asyncLoader().then(
+              // note: we are moving the render call into an async callback,
+              // which means it won't track dependencies - but it's ok because
+              // a server-rendered async wrapper is already in resolved state
+              // and it will never need to change.
+              () => !instance.isUnmounted && hydrateSubTree()
+            );
+          } else {
+            hydrateSubTree();
+          }
+        } else {
+          if (!!(process.env.NODE_ENV !== "production")) {
+            startMeasure(instance, `render`);
+          }
+          const subTree = instance.subTree = renderComponentRoot(instance);
+          if (!!(process.env.NODE_ENV !== "production")) {
+            endMeasure(instance, `render`);
+          }
+          if (!!(process.env.NODE_ENV !== "production")) {
+            startMeasure(instance, `patch`);
+          }
+          patch(
+            null,
+            subTree,
+            container,
+            anchor,
+            instance,
+            parentSuspense,
+            isSVG
+          );
+          if (!!(process.env.NODE_ENV !== "production")) {
+            endMeasure(instance, `patch`);
+          }
+          initialVNode.el = subTree.el;
+        }
+        if (m) {
+          queuePostRenderEffect(m, parentSuspense);
+        }
+        if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {
+          const scopedInitialVNode = initialVNode;
+          queuePostRenderEffect(
+            () => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode),
+            parentSuspense
+          );
+        }
+        if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) {
+          instance.a && queuePostRenderEffect(instance.a, parentSuspense);
+        }
+        instance.isMounted = true;
+        if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+          devtoolsComponentAdded(instance);
+        }
+        initialVNode = container = anchor = null;
+      } else {
+        let { next, bu, u, parent, vnode } = instance;
+        let originNext = next;
+        let vnodeHook;
+        if (!!(process.env.NODE_ENV !== "production")) {
+          pushWarningContext(next || instance.vnode);
+        }
+        toggleRecurse(instance, false);
+        if (next) {
+          next.el = vnode.el;
+          updateComponentPreRender(instance, next, optimized);
+        } else {
+          next = vnode;
+        }
+        if (bu) {
+          invokeArrayFns(bu);
+        }
+        if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) {
+          invokeVNodeHook(vnodeHook, parent, next, vnode);
+        }
+        toggleRecurse(instance, true);
+        if (!!(process.env.NODE_ENV !== "production")) {
+          startMeasure(instance, `render`);
+        }
+        const nextTree = renderComponentRoot(instance);
+        if (!!(process.env.NODE_ENV !== "production")) {
+          endMeasure(instance, `render`);
+        }
+        const prevTree = instance.subTree;
+        instance.subTree = nextTree;
+        if (!!(process.env.NODE_ENV !== "production")) {
+          startMeasure(instance, `patch`);
+        }
+        patch(
+          prevTree,
+          nextTree,
+          // parent may have changed if it's in a teleport
+          hostParentNode(prevTree.el),
+          // anchor may have changed if it's in a fragment
+          getNextHostNode(prevTree),
+          instance,
+          parentSuspense,
+          isSVG
+        );
+        if (!!(process.env.NODE_ENV !== "production")) {
+          endMeasure(instance, `patch`);
+        }
+        next.el = nextTree.el;
+        if (originNext === null) {
+          updateHOCHostEl(instance, nextTree.el);
+        }
+        if (u) {
+          queuePostRenderEffect(u, parentSuspense);
+        }
+        if (vnodeHook = next.props && next.props.onVnodeUpdated) {
+          queuePostRenderEffect(
+            () => invokeVNodeHook(vnodeHook, parent, next, vnode),
+            parentSuspense
+          );
+        }
+        if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+          devtoolsComponentUpdated(instance);
+        }
+        if (!!(process.env.NODE_ENV !== "production")) {
+          popWarningContext();
+        }
+      }
+    };
+    const effect = instance.effect = new ReactiveEffect(
+      componentUpdateFn,
+      () => queueJob(update),
+      instance.scope
+      // track it in component's effect scope
+    );
+    const update = instance.update = () => effect.run();
+    update.id = instance.uid;
+    toggleRecurse(instance, true);
+    if (!!(process.env.NODE_ENV !== "production")) {
+      effect.onTrack = instance.rtc ? (e) => invokeArrayFns(instance.rtc, e) : void 0;
+      effect.onTrigger = instance.rtg ? (e) => invokeArrayFns(instance.rtg, e) : void 0;
+      update.ownerInstance = instance;
+    }
+    update();
+  };
+  const updateComponentPreRender = (instance, nextVNode, optimized) => {
+    nextVNode.component = instance;
+    const prevProps = instance.vnode.props;
+    instance.vnode = nextVNode;
+    instance.next = null;
+    updateProps(instance, nextVNode.props, prevProps, optimized);
+    updateSlots(instance, nextVNode.children, optimized);
+    pauseTracking();
+    flushPreFlushCbs();
+    resetTracking();
+  };
+  const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized = false) => {
+    const c1 = n1 && n1.children;
+    const prevShapeFlag = n1 ? n1.shapeFlag : 0;
+    const c2 = n2.children;
+    const { patchFlag, shapeFlag } = n2;
+    if (patchFlag > 0) {
+      if (patchFlag & 128) {
+        patchKeyedChildren(
+          c1,
+          c2,
+          container,
+          anchor,
+          parentComponent,
+          parentSuspense,
+          isSVG,
+          slotScopeIds,
+          optimized
+        );
+        return;
+      } else if (patchFlag & 256) {
+        patchUnkeyedChildren(
+          c1,
+          c2,
+          container,
+          anchor,
+          parentComponent,
+          parentSuspense,
+          isSVG,
+          slotScopeIds,
+          optimized
+        );
+        return;
+      }
+    }
+    if (shapeFlag & 8) {
+      if (prevShapeFlag & 16) {
+        unmountChildren(c1, parentComponent, parentSuspense);
+      }
+      if (c2 !== c1) {
+        hostSetElementText(container, c2);
+      }
+    } else {
+      if (prevShapeFlag & 16) {
+        if (shapeFlag & 16) {
+          patchKeyedChildren(
+            c1,
+            c2,
+            container,
+            anchor,
+            parentComponent,
+            parentSuspense,
+            isSVG,
+            slotScopeIds,
+            optimized
+          );
+        } else {
+          unmountChildren(c1, parentComponent, parentSuspense, true);
+        }
+      } else {
+        if (prevShapeFlag & 8) {
+          hostSetElementText(container, "");
+        }
+        if (shapeFlag & 16) {
+          mountChildren(
+            c2,
+            container,
+            anchor,
+            parentComponent,
+            parentSuspense,
+            isSVG,
+            slotScopeIds,
+            optimized
+          );
+        }
+      }
+    }
+  };
+  const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+    c1 = c1 || EMPTY_ARR;
+    c2 = c2 || EMPTY_ARR;
+    const oldLength = c1.length;
+    const newLength = c2.length;
+    const commonLength = Math.min(oldLength, newLength);
+    let i;
+    for (i = 0; i < commonLength; i++) {
+      const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
+      patch(
+        c1[i],
+        nextChild,
+        container,
+        null,
+        parentComponent,
+        parentSuspense,
+        isSVG,
+        slotScopeIds,
+        optimized
+      );
+    }
+    if (oldLength > newLength) {
+      unmountChildren(
+        c1,
+        parentComponent,
+        parentSuspense,
+        true,
+        false,
+        commonLength
+      );
+    } else {
+      mountChildren(
+        c2,
+        container,
+        anchor,
+        parentComponent,
+        parentSuspense,
+        isSVG,
+        slotScopeIds,
+        optimized,
+        commonLength
+      );
+    }
+  };
+  const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+    let i = 0;
+    const l2 = c2.length;
+    let e1 = c1.length - 1;
+    let e2 = l2 - 1;
+    while (i <= e1 && i <= e2) {
+      const n1 = c1[i];
+      const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
+      if (isSameVNodeType(n1, n2)) {
+        patch(
+          n1,
+          n2,
+          container,
+          null,
+          parentComponent,
+          parentSuspense,
+          isSVG,
+          slotScopeIds,
+          optimized
+        );
+      } else {
+        break;
+      }
+      i++;
+    }
+    while (i <= e1 && i <= e2) {
+      const n1 = c1[e1];
+      const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]);
+      if (isSameVNodeType(n1, n2)) {
+        patch(
+          n1,
+          n2,
+          container,
+          null,
+          parentComponent,
+          parentSuspense,
+          isSVG,
+          slotScopeIds,
+          optimized
+        );
+      } else {
+        break;
+      }
+      e1--;
+      e2--;
+    }
+    if (i > e1) {
+      if (i <= e2) {
+        const nextPos = e2 + 1;
+        const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;
+        while (i <= e2) {
+          patch(
+            null,
+            c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]),
+            container,
+            anchor,
+            parentComponent,
+            parentSuspense,
+            isSVG,
+            slotScopeIds,
+            optimized
+          );
+          i++;
+        }
+      }
+    } else if (i > e2) {
+      while (i <= e1) {
+        unmount(c1[i], parentComponent, parentSuspense, true);
+        i++;
+      }
+    } else {
+      const s1 = i;
+      const s2 = i;
+      const keyToNewIndexMap = /* @__PURE__ */ new Map();
+      for (i = s2; i <= e2; i++) {
+        const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
+        if (nextChild.key != null) {
+          if (!!(process.env.NODE_ENV !== "production") && keyToNewIndexMap.has(nextChild.key)) {
+            warn(
+              `Duplicate keys found during update:`,
+              JSON.stringify(nextChild.key),
+              `Make sure keys are unique.`
+            );
+          }
+          keyToNewIndexMap.set(nextChild.key, i);
+        }
+      }
+      let j;
+      let patched = 0;
+      const toBePatched = e2 - s2 + 1;
+      let moved = false;
+      let maxNewIndexSoFar = 0;
+      const newIndexToOldIndexMap = new Array(toBePatched);
+      for (i = 0; i < toBePatched; i++)
+        newIndexToOldIndexMap[i] = 0;
+      for (i = s1; i <= e1; i++) {
+        const prevChild = c1[i];
+        if (patched >= toBePatched) {
+          unmount(prevChild, parentComponent, parentSuspense, true);
+          continue;
+        }
+        let newIndex;
+        if (prevChild.key != null) {
+          newIndex = keyToNewIndexMap.get(prevChild.key);
+        } else {
+          for (j = s2; j <= e2; j++) {
+            if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) {
+              newIndex = j;
+              break;
+            }
+          }
+        }
+        if (newIndex === void 0) {
+          unmount(prevChild, parentComponent, parentSuspense, true);
+        } else {
+          newIndexToOldIndexMap[newIndex - s2] = i + 1;
+          if (newIndex >= maxNewIndexSoFar) {
+            maxNewIndexSoFar = newIndex;
+          } else {
+            moved = true;
+          }
+          patch(
+            prevChild,
+            c2[newIndex],
+            container,
+            null,
+            parentComponent,
+            parentSuspense,
+            isSVG,
+            slotScopeIds,
+            optimized
+          );
+          patched++;
+        }
+      }
+      const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : EMPTY_ARR;
+      j = increasingNewIndexSequence.length - 1;
+      for (i = toBePatched - 1; i >= 0; i--) {
+        const nextIndex = s2 + i;
+        const nextChild = c2[nextIndex];
+        const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;
+        if (newIndexToOldIndexMap[i] === 0) {
+          patch(
+            null,
+            nextChild,
+            container,
+            anchor,
+            parentComponent,
+            parentSuspense,
+            isSVG,
+            slotScopeIds,
+            optimized
+          );
+        } else if (moved) {
+          if (j < 0 || i !== increasingNewIndexSequence[j]) {
+            move(nextChild, container, anchor, 2);
+          } else {
+            j--;
+          }
+        }
+      }
+    }
+  };
+  const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
+    const { el, type, transition, children, shapeFlag } = vnode;
+    if (shapeFlag & 6) {
+      move(vnode.component.subTree, container, anchor, moveType);
+      return;
+    }
+    if (shapeFlag & 128) {
+      vnode.suspense.move(container, anchor, moveType);
+      return;
+    }
+    if (shapeFlag & 64) {
+      type.move(vnode, container, anchor, internals);
+      return;
+    }
+    if (type === Fragment) {
+      hostInsert(el, container, anchor);
+      for (let i = 0; i < children.length; i++) {
+        move(children[i], container, anchor, moveType);
+      }
+      hostInsert(vnode.anchor, container, anchor);
+      return;
+    }
+    if (type === Static) {
+      moveStaticNode(vnode, container, anchor);
+      return;
+    }
+    const needTransition = moveType !== 2 && shapeFlag & 1 && transition;
+    if (needTransition) {
+      if (moveType === 0) {
+        transition.beforeEnter(el);
+        hostInsert(el, container, anchor);
+        queuePostRenderEffect(() => transition.enter(el), parentSuspense);
+      } else {
+        const { leave, delayLeave, afterLeave } = transition;
+        const remove2 = () => hostInsert(el, container, anchor);
+        const performLeave = () => {
+          leave(el, () => {
+            remove2();
+            afterLeave && afterLeave();
+          });
+        };
+        if (delayLeave) {
+          delayLeave(el, remove2, performLeave);
+        } else {
+          performLeave();
+        }
+      }
+    } else {
+      hostInsert(el, container, anchor);
+    }
+  };
+  const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {
+    const {
+      type,
+      props,
+      ref,
+      children,
+      dynamicChildren,
+      shapeFlag,
+      patchFlag,
+      dirs
+    } = vnode;
+    if (ref != null) {
+      setRef(ref, null, parentSuspense, vnode, true);
+    }
+    if (shapeFlag & 256) {
+      parentComponent.ctx.deactivate(vnode);
+      return;
+    }
+    const shouldInvokeDirs = shapeFlag & 1 && dirs;
+    const shouldInvokeVnodeHook = !isAsyncWrapper(vnode);
+    let vnodeHook;
+    if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeBeforeUnmount)) {
+      invokeVNodeHook(vnodeHook, parentComponent, vnode);
+    }
+    if (shapeFlag & 6) {
+      unmountComponent(vnode.component, parentSuspense, doRemove);
+    } else {
+      if (shapeFlag & 128) {
+        vnode.suspense.unmount(parentSuspense, doRemove);
+        return;
+      }
+      if (shouldInvokeDirs) {
+        invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount");
+      }
+      if (shapeFlag & 64) {
+        vnode.type.remove(
+          vnode,
+          parentComponent,
+          parentSuspense,
+          optimized,
+          internals,
+          doRemove
+        );
+      } else if (dynamicChildren && // #1153: fast path should not be taken for non-stable (v-for) fragments
+      (type !== Fragment || patchFlag > 0 && patchFlag & 64)) {
+        unmountChildren(
+          dynamicChildren,
+          parentComponent,
+          parentSuspense,
+          false,
+          true
+        );
+      } else if (type === Fragment && patchFlag & (128 | 256) || !optimized && shapeFlag & 16) {
+        unmountChildren(children, parentComponent, parentSuspense);
+      }
+      if (doRemove) {
+        remove(vnode);
+      }
+    }
+    if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {
+      queuePostRenderEffect(() => {
+        vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
+        shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
+      }, parentSuspense);
+    }
+  };
+  const remove = (vnode) => {
+    const { type, el, anchor, transition } = vnode;
+    if (type === Fragment) {
+      if (!!(process.env.NODE_ENV !== "production") && vnode.patchFlag > 0 && vnode.patchFlag & 2048 && transition && !transition.persisted) {
+        vnode.children.forEach((child) => {
+          if (child.type === Comment) {
+            hostRemove(child.el);
+          } else {
+            remove(child);
+          }
+        });
+      } else {
+        removeFragment(el, anchor);
+      }
+      return;
+    }
+    if (type === Static) {
+      removeStaticNode(vnode);
+      return;
+    }
+    const performRemove = () => {
+      hostRemove(el);
+      if (transition && !transition.persisted && transition.afterLeave) {
+        transition.afterLeave();
+      }
+    };
+    if (vnode.shapeFlag & 1 && transition && !transition.persisted) {
+      const { leave, delayLeave } = transition;
+      const performLeave = () => leave(el, performRemove);
+      if (delayLeave) {
+        delayLeave(vnode.el, performRemove, performLeave);
+      } else {
+        performLeave();
+      }
+    } else {
+      performRemove();
+    }
+  };
+  const removeFragment = (cur, end) => {
+    let next;
+    while (cur !== end) {
+      next = hostNextSibling(cur);
+      hostRemove(cur);
+      cur = next;
+    }
+    hostRemove(end);
+  };
+  const unmountComponent = (instance, parentSuspense, doRemove) => {
+    if (!!(process.env.NODE_ENV !== "production") && instance.type.__hmrId) {
+      unregisterHMR(instance);
+    }
+    const { bum, scope, update, subTree, um } = instance;
+    if (bum) {
+      invokeArrayFns(bum);
+    }
+    scope.stop();
+    if (update) {
+      update.active = false;
+      unmount(subTree, instance, parentSuspense, doRemove);
+    }
+    if (um) {
+      queuePostRenderEffect(um, parentSuspense);
+    }
+    queuePostRenderEffect(() => {
+      instance.isUnmounted = true;
+    }, parentSuspense);
+    if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) {
+      parentSuspense.deps--;
+      if (parentSuspense.deps === 0) {
+        parentSuspense.resolve();
+      }
+    }
+    if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+      devtoolsComponentRemoved(instance);
+    }
+  };
+  const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
+    for (let i = start; i < children.length; i++) {
+      unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);
+    }
+  };
+  const getNextHostNode = (vnode) => {
+    if (vnode.shapeFlag & 6) {
+      return getNextHostNode(vnode.component.subTree);
+    }
+    if (vnode.shapeFlag & 128) {
+      return vnode.suspense.next();
+    }
+    return hostNextSibling(vnode.anchor || vnode.el);
+  };
+  const render = (vnode, container, isSVG) => {
+    if (vnode == null) {
+      if (container._vnode) {
+        unmount(container._vnode, null, null, true);
+      }
+    } else {
+      patch(container._vnode || null, vnode, container, null, null, null, isSVG);
+    }
+    flushPreFlushCbs();
+    flushPostFlushCbs();
+    container._vnode = vnode;
+  };
+  const internals = {
+    p: patch,
+    um: unmount,
+    m: move,
+    r: remove,
+    mt: mountComponent,
+    mc: mountChildren,
+    pc: patchChildren,
+    pbc: patchBlockChildren,
+    n: getNextHostNode,
+    o: options
+  };
+  let hydrate;
+  let hydrateNode;
+  if (createHydrationFns) {
+    [hydrate, hydrateNode] = createHydrationFns(
+      internals
+    );
+  }
+  return {
+    render,
+    hydrate,
+    createApp: createAppAPI(render, hydrate)
+  };
+}
+function toggleRecurse({ effect, update }, allowed) {
+  effect.allowRecurse = update.allowRecurse = allowed;
+}
+function traverseStaticChildren(n1, n2, shallow = false) {
+  const ch1 = n1.children;
+  const ch2 = n2.children;
+  if (isArray(ch1) && isArray(ch2)) {
+    for (let i = 0; i < ch1.length; i++) {
+      const c1 = ch1[i];
+      let c2 = ch2[i];
+      if (c2.shapeFlag & 1 && !c2.dynamicChildren) {
+        if (c2.patchFlag <= 0 || c2.patchFlag === 32) {
+          c2 = ch2[i] = cloneIfMounted(ch2[i]);
+          c2.el = c1.el;
+        }
+        if (!shallow)
+          traverseStaticChildren(c1, c2);
+      }
+      if (c2.type === Text) {
+        c2.el = c1.el;
+      }
+      if (!!(process.env.NODE_ENV !== "production") && c2.type === Comment && !c2.el) {
+        c2.el = c1.el;
+      }
+    }
+  }
+}
+function getSequence(arr) {
+  const p = arr.slice();
+  const result = [0];
+  let i, j, u, v, c;
+  const len = arr.length;
+  for (i = 0; i < len; i++) {
+    const arrI = arr[i];
+    if (arrI !== 0) {
+      j = result[result.length - 1];
+      if (arr[j] < arrI) {
+        p[i] = j;
+        result.push(i);
+        continue;
+      }
+      u = 0;
+      v = result.length - 1;
+      while (u < v) {
+        c = u + v >> 1;
+        if (arr[result[c]] < arrI) {
+          u = c + 1;
+        } else {
+          v = c;
+        }
+      }
+      if (arrI < arr[result[u]]) {
+        if (u > 0) {
+          p[i] = result[u - 1];
+        }
+        result[u] = i;
+      }
+    }
+  }
+  u = result.length;
+  v = result[u - 1];
+  while (u-- > 0) {
+    result[u] = v;
+    v = p[v];
+  }
+  return result;
+}
+
+const isTeleport = (type) => type.__isTeleport;
+const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === "");
+const isTargetSVG = (target) => typeof SVGElement !== "undefined" && target instanceof SVGElement;
+const resolveTarget = (props, select) => {
+  const targetSelector = props && props.to;
+  if (isString(targetSelector)) {
+    if (!select) {
+      !!(process.env.NODE_ENV !== "production") && warn(
+        `Current renderer does not support string target for Teleports. (missing querySelector renderer option)`
+      );
+      return null;
+    } else {
+      const target = select(targetSelector);
+      if (!target) {
+        !!(process.env.NODE_ENV !== "production") && warn(
+          `Failed to locate Teleport target with selector "${targetSelector}". Note the target element must exist before the component is mounted - i.e. the target cannot be rendered by the component itself, and ideally should be outside of the entire Vue component tree.`
+        );
+      }
+      return target;
+    }
+  } else {
+    if (!!(process.env.NODE_ENV !== "production") && !targetSelector && !isTeleportDisabled(props)) {
+      warn(`Invalid Teleport target: ${targetSelector}`);
+    }
+    return targetSelector;
+  }
+};
+const TeleportImpl = {
+  __isTeleport: true,
+  process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals) {
+    const {
+      mc: mountChildren,
+      pc: patchChildren,
+      pbc: patchBlockChildren,
+      o: { insert, querySelector, createText, createComment }
+    } = internals;
+    const disabled = isTeleportDisabled(n2.props);
+    let { shapeFlag, children, dynamicChildren } = n2;
+    if (!!(process.env.NODE_ENV !== "production") && isHmrUpdating) {
+      optimized = false;
+      dynamicChildren = null;
+    }
+    if (n1 == null) {
+      const placeholder = n2.el = !!(process.env.NODE_ENV !== "production") ? createComment("teleport start") : createText("");
+      const mainAnchor = n2.anchor = !!(process.env.NODE_ENV !== "production") ? createComment("teleport end") : createText("");
+      insert(placeholder, container, anchor);
+      insert(mainAnchor, container, anchor);
+      const target = n2.target = resolveTarget(n2.props, querySelector);
+      const targetAnchor = n2.targetAnchor = createText("");
+      if (target) {
+        insert(targetAnchor, target);
+        isSVG = isSVG || isTargetSVG(target);
+      } else if (!!(process.env.NODE_ENV !== "production") && !disabled) {
+        warn("Invalid Teleport target on mount:", target, `(${typeof target})`);
+      }
+      const mount = (container2, anchor2) => {
+        if (shapeFlag & 16) {
+          mountChildren(
+            children,
+            container2,
+            anchor2,
+            parentComponent,
+            parentSuspense,
+            isSVG,
+            slotScopeIds,
+            optimized
+          );
+        }
+      };
+      if (disabled) {
+        mount(container, mainAnchor);
+      } else if (target) {
+        mount(target, targetAnchor);
+      }
+    } else {
+      n2.el = n1.el;
+      const mainAnchor = n2.anchor = n1.anchor;
+      const target = n2.target = n1.target;
+      const targetAnchor = n2.targetAnchor = n1.targetAnchor;
+      const wasDisabled = isTeleportDisabled(n1.props);
+      const currentContainer = wasDisabled ? container : target;
+      const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;
+      isSVG = isSVG || isTargetSVG(target);
+      if (dynamicChildren) {
+        patchBlockChildren(
+          n1.dynamicChildren,
+          dynamicChildren,
+          currentContainer,
+          parentComponent,
+          parentSuspense,
+          isSVG,
+          slotScopeIds
+        );
+        traverseStaticChildren(n1, n2, true);
+      } else if (!optimized) {
+        patchChildren(
+          n1,
+          n2,
+          currentContainer,
+          currentAnchor,
+          parentComponent,
+          parentSuspense,
+          isSVG,
+          slotScopeIds,
+          false
+        );
+      }
+      if (disabled) {
+        if (!wasDisabled) {
+          moveTeleport(
+            n2,
+            container,
+            mainAnchor,
+            internals,
+            1
+          );
+        }
+      } else {
+        if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
+          const nextTarget = n2.target = resolveTarget(
+            n2.props,
+            querySelector
+          );
+          if (nextTarget) {
+            moveTeleport(
+              n2,
+              nextTarget,
+              null,
+              internals,
+              0
+            );
+          } else if (!!(process.env.NODE_ENV !== "production")) {
+            warn(
+              "Invalid Teleport target on update:",
+              target,
+              `(${typeof target})`
+            );
+          }
+        } else if (wasDisabled) {
+          moveTeleport(
+            n2,
+            target,
+            targetAnchor,
+            internals,
+            1
+          );
+        }
+      }
+    }
+    updateCssVars(n2);
+  },
+  remove(vnode, parentComponent, parentSuspense, optimized, { um: unmount, o: { remove: hostRemove } }, doRemove) {
+    const { shapeFlag, children, anchor, targetAnchor, target, props } = vnode;
+    if (target) {
+      hostRemove(targetAnchor);
+    }
+    if (doRemove || !isTeleportDisabled(props)) {
+      hostRemove(anchor);
+      if (shapeFlag & 16) {
+        for (let i = 0; i < children.length; i++) {
+          const child = children[i];
+          unmount(
+            child,
+            parentComponent,
+            parentSuspense,
+            true,
+            !!child.dynamicChildren
+          );
+        }
+      }
+    }
+  },
+  move: moveTeleport,
+  hydrate: hydrateTeleport
+};
+function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
+  if (moveType === 0) {
+    insert(vnode.targetAnchor, container, parentAnchor);
+  }
+  const { el, anchor, shapeFlag, children, props } = vnode;
+  const isReorder = moveType === 2;
+  if (isReorder) {
+    insert(el, container, parentAnchor);
+  }
+  if (!isReorder || isTeleportDisabled(props)) {
+    if (shapeFlag & 16) {
+      for (let i = 0; i < children.length; i++) {
+        move(
+          children[i],
+          container,
+          parentAnchor,
+          2
+        );
+      }
+    }
+  }
+  if (isReorder) {
+    insert(anchor, container, parentAnchor);
+  }
+}
+function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, {
+  o: { nextSibling, parentNode, querySelector }
+}, hydrateChildren) {
+  const target = vnode.target = resolveTarget(
+    vnode.props,
+    querySelector
+  );
+  if (target) {
+    const targetNode = target._lpa || target.firstChild;
+    if (vnode.shapeFlag & 16) {
+      if (isTeleportDisabled(vnode.props)) {
+        vnode.anchor = hydrateChildren(
+          nextSibling(node),
+          vnode,
+          parentNode(node),
+          parentComponent,
+          parentSuspense,
+          slotScopeIds,
+          optimized
+        );
+        vnode.targetAnchor = targetNode;
+      } else {
+        vnode.anchor = nextSibling(node);
+        let targetAnchor = targetNode;
+        while (targetAnchor) {
+          targetAnchor = nextSibling(targetAnchor);
+          if (targetAnchor && targetAnchor.nodeType === 8 && targetAnchor.data === "teleport anchor") {
+            vnode.targetAnchor = targetAnchor;
+            target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
+            break;
+          }
+        }
+        hydrateChildren(
+          targetNode,
+          vnode,
+          target,
+          parentComponent,
+          parentSuspense,
+          slotScopeIds,
+          optimized
+        );
+      }
+    }
+    updateCssVars(vnode);
+  }
+  return vnode.anchor && nextSibling(vnode.anchor);
+}
+const Teleport = TeleportImpl;
+function updateCssVars(vnode) {
+  const ctx = vnode.ctx;
+  if (ctx && ctx.ut) {
+    let node = vnode.children[0].el;
+    while (node !== vnode.targetAnchor) {
+      if (node.nodeType === 1)
+        node.setAttribute("data-v-owner", ctx.uid);
+      node = node.nextSibling;
+    }
+    ctx.ut();
+  }
+}
+
+const Fragment = Symbol.for("v-fgt");
+const Text = Symbol.for("v-txt");
+const Comment = Symbol.for("v-cmt");
+const Static = Symbol.for("v-stc");
+const blockStack = [];
+let currentBlock = null;
+function openBlock(disableTracking = false) {
+  blockStack.push(currentBlock = disableTracking ? null : []);
+}
+function closeBlock() {
+  blockStack.pop();
+  currentBlock = blockStack[blockStack.length - 1] || null;
+}
+let isBlockTreeEnabled = 1;
+function setBlockTracking(value) {
+  isBlockTreeEnabled += value;
+}
+function setupBlock(vnode) {
+  vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || EMPTY_ARR : null;
+  closeBlock();
+  if (isBlockTreeEnabled > 0 && currentBlock) {
+    currentBlock.push(vnode);
+  }
+  return vnode;
+}
+function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {
+  return setupBlock(
+    createBaseVNode(
+      type,
+      props,
+      children,
+      patchFlag,
+      dynamicProps,
+      shapeFlag,
+      true
+      /* isBlock */
+    )
+  );
+}
+function createBlock(type, props, children, patchFlag, dynamicProps) {
+  return setupBlock(
+    createVNode(
+      type,
+      props,
+      children,
+      patchFlag,
+      dynamicProps,
+      true
+      /* isBlock: prevent a block from tracking itself */
+    )
+  );
+}
+function isVNode(value) {
+  return value ? value.__v_isVNode === true : false;
+}
+function isSameVNodeType(n1, n2) {
+  if (!!(process.env.NODE_ENV !== "production") && n2.shapeFlag & 6 && hmrDirtyComponents.has(n2.type)) {
+    n1.shapeFlag &= ~256;
+    n2.shapeFlag &= ~512;
+    return false;
+  }
+  return n1.type === n2.type && n1.key === n2.key;
+}
+let vnodeArgsTransformer;
+function transformVNodeArgs(transformer) {
+  vnodeArgsTransformer = transformer;
+}
+const createVNodeWithArgsTransform = (...args) => {
+  return _createVNode(
+    ...vnodeArgsTransformer ? vnodeArgsTransformer(args, currentRenderingInstance) : args
+  );
+};
+const InternalObjectKey = `__vInternal`;
+const normalizeKey = ({ key }) => key != null ? key : null;
+const normalizeRef = ({
+  ref,
+  ref_key,
+  ref_for
+}) => {
+  if (typeof ref === "number") {
+    ref = "" + ref;
+  }
+  return ref != null ? isString(ref) || isRef(ref) || isFunction(ref) ? { i: currentRenderingInstance, r: ref, k: ref_key, f: !!ref_for } : ref : null;
+};
+function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
+  const vnode = {
+    __v_isVNode: true,
+    __v_skip: true,
+    type,
+    props,
+    key: props && normalizeKey(props),
+    ref: props && normalizeRef(props),
+    scopeId: currentScopeId,
+    slotScopeIds: null,
+    children,
+    component: null,
+    suspense: null,
+    ssContent: null,
+    ssFallback: null,
+    dirs: null,
+    transition: null,
+    el: null,
+    anchor: null,
+    target: null,
+    targetAnchor: null,
+    staticCount: 0,
+    shapeFlag,
+    patchFlag,
+    dynamicProps,
+    dynamicChildren: null,
+    appContext: null,
+    ctx: currentRenderingInstance
+  };
+  if (needFullChildrenNormalization) {
+    normalizeChildren(vnode, children);
+    if (shapeFlag & 128) {
+      type.normalize(vnode);
+    }
+  } else if (children) {
+    vnode.shapeFlag |= isString(children) ? 8 : 16;
+  }
+  if (!!(process.env.NODE_ENV !== "production") && vnode.key !== vnode.key) {
+    warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);
+  }
+  if (isBlockTreeEnabled > 0 && // avoid a block node from tracking itself
+  !isBlockNode && // has current parent block
+  currentBlock && // presence of a patch flag indicates this node needs patching on updates.
+  // component nodes also should always be patched, because even if the
+  // component doesn't need to update, it needs to persist the instance on to
+  // the next vnode so that it can be properly unmounted later.
+  (vnode.patchFlag > 0 || shapeFlag & 6) && // the EVENTS flag is only for hydration and if it is the only flag, the
+  // vnode should not be considered dynamic due to handler caching.
+  vnode.patchFlag !== 32) {
+    currentBlock.push(vnode);
+  }
+  return vnode;
+}
+const createVNode = !!(process.env.NODE_ENV !== "production") ? createVNodeWithArgsTransform : _createVNode;
+function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
+  if (!type || type === NULL_DYNAMIC_COMPONENT) {
+    if (!!(process.env.NODE_ENV !== "production") && !type) {
+      warn(`Invalid vnode type when creating vnode: ${type}.`);
+    }
+    type = Comment;
+  }
+  if (isVNode(type)) {
+    const cloned = cloneVNode(
+      type,
+      props,
+      true
+      /* mergeRef: true */
+    );
+    if (children) {
+      normalizeChildren(cloned, children);
+    }
+    if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
+      if (cloned.shapeFlag & 6) {
+        currentBlock[currentBlock.indexOf(type)] = cloned;
+      } else {
+        currentBlock.push(cloned);
+      }
+    }
+    cloned.patchFlag |= -2;
+    return cloned;
+  }
+  if (isClassComponent(type)) {
+    type = type.__vccOpts;
+  }
+  if (props) {
+    props = guardReactiveProps(props);
+    let { class: klass, style } = props;
+    if (klass && !isString(klass)) {
+      props.class = normalizeClass(klass);
+    }
+    if (isObject(style)) {
+      if (isProxy(style) && !isArray(style)) {
+        style = extend({}, style);
+      }
+      props.style = normalizeStyle(style);
+    }
+  }
+  const shapeFlag = isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject(type) ? 4 : isFunction(type) ? 2 : 0;
+  if (!!(process.env.NODE_ENV !== "production") && shapeFlag & 4 && isProxy(type)) {
+    type = toRaw(type);
+    warn(
+      `Vue received a Component which was made a reactive object. This can lead to unnecessary performance overhead, and should be avoided by marking the component with \`markRaw\` or using \`shallowRef\` instead of \`ref\`.`,
+      `
+Component that was made reactive: `,
+      type
+    );
+  }
+  return createBaseVNode(
+    type,
+    props,
+    children,
+    patchFlag,
+    dynamicProps,
+    shapeFlag,
+    isBlockNode,
+    true
+  );
+}
+function guardReactiveProps(props) {
+  if (!props)
+    return null;
+  return isProxy(props) || InternalObjectKey in props ? extend({}, props) : props;
+}
+function cloneVNode(vnode, extraProps, mergeRef = false) {
+  const { props, ref, patchFlag, children } = vnode;
+  const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
+  const cloned = {
+    __v_isVNode: true,
+    __v_skip: true,
+    type: vnode.type,
+    props: mergedProps,
+    key: mergedProps && normalizeKey(mergedProps),
+    ref: extraProps && extraProps.ref ? (
+      // #2078 in the case of <component :is="vnode" ref="extra"/>
+      // if the vnode itself already has a ref, cloneVNode will need to merge
+      // the refs so the single vnode can be set on multiple refs
+      mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps)
+    ) : ref,
+    scopeId: vnode.scopeId,
+    slotScopeIds: vnode.slotScopeIds,
+    children: !!(process.env.NODE_ENV !== "production") && patchFlag === -1 && isArray(children) ? children.map(deepCloneVNode) : children,
+    target: vnode.target,
+    targetAnchor: vnode.targetAnchor,
+    staticCount: vnode.staticCount,
+    shapeFlag: vnode.shapeFlag,
+    // if the vnode is cloned with extra props, we can no longer assume its
+    // existing patch flag to be reliable and need to add the FULL_PROPS flag.
+    // note: preserve flag for fragments since they use the flag for children
+    // fast paths only.
+    patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
+    dynamicProps: vnode.dynamicProps,
+    dynamicChildren: vnode.dynamicChildren,
+    appContext: vnode.appContext,
+    dirs: vnode.dirs,
+    transition: vnode.transition,
+    // These should technically only be non-null on mounted VNodes. However,
+    // they *should* be copied for kept-alive vnodes. So we just always copy
+    // them since them being non-null during a mount doesn't affect the logic as
+    // they will simply be overwritten.
+    component: vnode.component,
+    suspense: vnode.suspense,
+    ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
+    ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
+    el: vnode.el,
+    anchor: vnode.anchor,
+    ctx: vnode.ctx,
+    ce: vnode.ce
+  };
+  return cloned;
+}
+function deepCloneVNode(vnode) {
+  const cloned = cloneVNode(vnode);
+  if (isArray(vnode.children)) {
+    cloned.children = vnode.children.map(deepCloneVNode);
+  }
+  return cloned;
+}
+function createTextVNode(text = " ", flag = 0) {
+  return createVNode(Text, null, text, flag);
+}
+function createStaticVNode(content, numberOfNodes) {
+  const vnode = createVNode(Static, null, content);
+  vnode.staticCount = numberOfNodes;
+  return vnode;
+}
+function createCommentVNode(text = "", asBlock = false) {
+  return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
+}
+function normalizeVNode(child) {
+  if (child == null || typeof child === "boolean") {
+    return createVNode(Comment);
+  } else if (isArray(child)) {
+    return createVNode(
+      Fragment,
+      null,
+      // #3666, avoid reference pollution when reusing vnode
+      child.slice()
+    );
+  } else if (typeof child === "object") {
+    return cloneIfMounted(child);
+  } else {
+    return createVNode(Text, null, String(child));
+  }
+}
+function cloneIfMounted(child) {
+  return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
+}
+function normalizeChildren(vnode, children) {
+  let type = 0;
+  const { shapeFlag } = vnode;
+  if (children == null) {
+    children = null;
+  } else if (isArray(children)) {
+    type = 16;
+  } else if (typeof children === "object") {
+    if (shapeFlag & (1 | 64)) {
+      const slot = children.default;
+      if (slot) {
+        slot._c && (slot._d = false);
+        normalizeChildren(vnode, slot());
+        slot._c && (slot._d = true);
+      }
+      return;
+    } else {
+      type = 32;
+      const slotFlag = children._;
+      if (!slotFlag && !(InternalObjectKey in children)) {
+        children._ctx = currentRenderingInstance;
+      } else if (slotFlag === 3 && currentRenderingInstance) {
+        if (currentRenderingInstance.slots._ === 1) {
+          children._ = 1;
+        } else {
+          children._ = 2;
+          vnode.patchFlag |= 1024;
+        }
+      }
+    }
+  } else if (isFunction(children)) {
+    children = { default: children, _ctx: currentRenderingInstance };
+    type = 32;
+  } else {
+    children = String(children);
+    if (shapeFlag & 64) {
+      type = 16;
+      children = [createTextVNode(children)];
+    } else {
+      type = 8;
+    }
+  }
+  vnode.children = children;
+  vnode.shapeFlag |= type;
+}
+function mergeProps(...args) {
+  const ret = {};
+  for (let i = 0; i < args.length; i++) {
+    const toMerge = args[i];
+    for (const key in toMerge) {
+      if (key === "class") {
+        if (ret.class !== toMerge.class) {
+          ret.class = normalizeClass([ret.class, toMerge.class]);
+        }
+      } else if (key === "style") {
+        ret.style = normalizeStyle([ret.style, toMerge.style]);
+      } else if (isOn(key)) {
+        const existing = ret[key];
+        const incoming = toMerge[key];
+        if (incoming && existing !== incoming && !(isArray(existing) && existing.includes(incoming))) {
+          ret[key] = existing ? [].concat(existing, incoming) : incoming;
+        }
+      } else if (key !== "") {
+        ret[key] = toMerge[key];
+      }
+    }
+  }
+  return ret;
+}
+function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
+  callWithAsyncErrorHandling(hook, instance, 7, [
+    vnode,
+    prevVNode
+  ]);
+}
+
+const emptyAppContext = createAppContext();
+let uid = 0;
+function createComponentInstance(vnode, parent, suspense) {
+  const type = vnode.type;
+  const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
+  const instance = {
+    uid: uid++,
+    vnode,
+    type,
+    parent,
+    appContext,
+    root: null,
+    // to be immediately set
+    next: null,
+    subTree: null,
+    // will be set synchronously right after creation
+    effect: null,
+    update: null,
+    // will be set synchronously right after creation
+    scope: new EffectScope(
+      true
+      /* detached */
+    ),
+    render: null,
+    proxy: null,
+    exposed: null,
+    exposeProxy: null,
+    withProxy: null,
+    provides: parent ? parent.provides : Object.create(appContext.provides),
+    accessCache: null,
+    renderCache: [],
+    // local resolved assets
+    components: null,
+    directives: null,
+    // resolved props and emits options
+    propsOptions: normalizePropsOptions(type, appContext),
+    emitsOptions: normalizeEmitsOptions(type, appContext),
+    // emit
+    emit: null,
+    // to be set immediately
+    emitted: null,
+    // props default value
+    propsDefaults: EMPTY_OBJ,
+    // inheritAttrs
+    inheritAttrs: type.inheritAttrs,
+    // state
+    ctx: EMPTY_OBJ,
+    data: EMPTY_OBJ,
+    props: EMPTY_OBJ,
+    attrs: EMPTY_OBJ,
+    slots: EMPTY_OBJ,
+    refs: EMPTY_OBJ,
+    setupState: EMPTY_OBJ,
+    setupContext: null,
+    attrsProxy: null,
+    slotsProxy: null,
+    // suspense related
+    suspense,
+    suspenseId: suspense ? suspense.pendingId : 0,
+    asyncDep: null,
+    asyncResolved: false,
+    // lifecycle hooks
+    // not using enums here because it results in computed properties
+    isMounted: false,
+    isUnmounted: false,
+    isDeactivated: false,
+    bc: null,
+    c: null,
+    bm: null,
+    m: null,
+    bu: null,
+    u: null,
+    um: null,
+    bum: null,
+    da: null,
+    a: null,
+    rtg: null,
+    rtc: null,
+    ec: null,
+    sp: null
+  };
+  if (!!(process.env.NODE_ENV !== "production")) {
+    instance.ctx = createDevRenderContext(instance);
+  } else {
+    instance.ctx = { _: instance };
+  }
+  instance.root = parent ? parent.root : instance;
+  instance.emit = emit.bind(null, instance);
+  if (vnode.ce) {
+    vnode.ce(instance);
+  }
+  return instance;
+}
+let currentInstance = null;
+const getCurrentInstance = () => currentInstance || currentRenderingInstance;
+let internalSetCurrentInstance;
+let globalCurrentInstanceSetters;
+let settersKey = "__VUE_INSTANCE_SETTERS__";
+{
+  if (!(globalCurrentInstanceSetters = getGlobalThis()[settersKey])) {
+    globalCurrentInstanceSetters = getGlobalThis()[settersKey] = [];
+  }
+  globalCurrentInstanceSetters.push((i) => currentInstance = i);
+  internalSetCurrentInstance = (instance) => {
+    if (globalCurrentInstanceSetters.length > 1) {
+      globalCurrentInstanceSetters.forEach((s) => s(instance));
+    } else {
+      globalCurrentInstanceSetters[0](instance);
+    }
+  };
+}
+const setCurrentInstance = (instance) => {
+  internalSetCurrentInstance(instance);
+  instance.scope.on();
+};
+const unsetCurrentInstance = () => {
+  currentInstance && currentInstance.scope.off();
+  internalSetCurrentInstance(null);
+};
+const isBuiltInTag = /* @__PURE__ */ makeMap("slot,component");
+function validateComponentName(name, config) {
+  const appIsNativeTag = config.isNativeTag || NO;
+  if (isBuiltInTag(name) || appIsNativeTag(name)) {
+    warn(
+      "Do not use built-in or reserved HTML elements as component id: " + name
+    );
+  }
+}
+function isStatefulComponent(instance) {
+  return instance.vnode.shapeFlag & 4;
+}
+let isInSSRComponentSetup = false;
+function setupComponent(instance, isSSR = false) {
+  isInSSRComponentSetup = isSSR;
+  const { props, children } = instance.vnode;
+  const isStateful = isStatefulComponent(instance);
+  initProps(instance, props, isStateful, isSSR);
+  initSlots(instance, children);
+  const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
+  isInSSRComponentSetup = false;
+  return setupResult;
+}
+function setupStatefulComponent(instance, isSSR) {
+  var _a;
+  const Component = instance.type;
+  if (!!(process.env.NODE_ENV !== "production")) {
+    if (Component.name) {
+      validateComponentName(Component.name, instance.appContext.config);
+    }
+    if (Component.components) {
+      const names = Object.keys(Component.components);
+      for (let i = 0; i < names.length; i++) {
+        validateComponentName(names[i], instance.appContext.config);
+      }
+    }
+    if (Component.directives) {
+      const names = Object.keys(Component.directives);
+      for (let i = 0; i < names.length; i++) {
+        validateDirectiveName(names[i]);
+      }
+    }
+    if (Component.compilerOptions && isRuntimeOnly()) {
+      warn(
+        `"compilerOptions" is only supported when using a build of Vue that includes the runtime compiler. Since you are using a runtime-only build, the options should be passed via your build tool config instead.`
+      );
+    }
+  }
+  instance.accessCache = /* @__PURE__ */ Object.create(null);
+  instance.proxy = markRaw(new Proxy(instance.ctx, PublicInstanceProxyHandlers));
+  if (!!(process.env.NODE_ENV !== "production")) {
+    exposePropsOnRenderContext(instance);
+  }
+  const { setup } = Component;
+  if (setup) {
+    const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
+    setCurrentInstance(instance);
+    pauseTracking();
+    const setupResult = callWithErrorHandling(
+      setup,
+      instance,
+      0,
+      [!!(process.env.NODE_ENV !== "production") ? shallowReadonly(instance.props) : instance.props, setupContext]
+    );
+    resetTracking();
+    unsetCurrentInstance();
+    if (isPromise(setupResult)) {
+      setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
+      if (isSSR) {
+        return setupResult.then((resolvedResult) => {
+          handleSetupResult(instance, resolvedResult, isSSR);
+        }).catch((e) => {
+          handleError(e, instance, 0);
+        });
+      } else {
+        instance.asyncDep = setupResult;
+        if (!!(process.env.NODE_ENV !== "production") && !instance.suspense) {
+          const name = (_a = Component.name) != null ? _a : "Anonymous";
+          warn(
+            `Component <${name}>: setup function returned a promise, but no <Suspense> boundary was found in the parent component tree. A component with async setup() must be nested in a <Suspense> in order to be rendered.`
+          );
+        }
+      }
+    } else {
+      handleSetupResult(instance, setupResult, isSSR);
+    }
+  } else {
+    finishComponentSetup(instance, isSSR);
+  }
+}
+function handleSetupResult(instance, setupResult, isSSR) {
+  if (isFunction(setupResult)) {
+    if (instance.type.__ssrInlineRender) {
+      instance.ssrRender = setupResult;
+    } else {
+      instance.render = setupResult;
+    }
+  } else if (isObject(setupResult)) {
+    if (!!(process.env.NODE_ENV !== "production") && isVNode(setupResult)) {
+      warn(
+        `setup() should not return VNodes directly - return a render function instead.`
+      );
+    }
+    if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+      instance.devtoolsRawSetupState = setupResult;
+    }
+    instance.setupState = proxyRefs(setupResult);
+    if (!!(process.env.NODE_ENV !== "production")) {
+      exposeSetupStateOnRenderContext(instance);
+    }
+  } else if (!!(process.env.NODE_ENV !== "production") && setupResult !== void 0) {
+    warn(
+      `setup() should return an object. Received: ${setupResult === null ? "null" : typeof setupResult}`
+    );
+  }
+  finishComponentSetup(instance, isSSR);
+}
+let compile;
+let installWithProxy;
+function registerRuntimeCompiler(_compile) {
+  compile = _compile;
+  installWithProxy = (i) => {
+    if (i.render._rc) {
+      i.withProxy = new Proxy(i.ctx, RuntimeCompiledPublicInstanceProxyHandlers);
+    }
+  };
+}
+const isRuntimeOnly = () => !compile;
+function finishComponentSetup(instance, isSSR, skipOptions) {
+  const Component = instance.type;
+  if (!instance.render) {
+    if (!isSSR && compile && !Component.render) {
+      const template = Component.template || resolveMergedOptions(instance).template;
+      if (template) {
+        if (!!(process.env.NODE_ENV !== "production")) {
+          startMeasure(instance, `compile`);
+        }
+        const { isCustomElement, compilerOptions } = instance.appContext.config;
+        const { delimiters, compilerOptions: componentCompilerOptions } = Component;
+        const finalCompilerOptions = extend(
+          extend(
+            {
+              isCustomElement,
+              delimiters
+            },
+            compilerOptions
+          ),
+          componentCompilerOptions
+        );
+        Component.render = compile(template, finalCompilerOptions);
+        if (!!(process.env.NODE_ENV !== "production")) {
+          endMeasure(instance, `compile`);
+        }
+      }
+    }
+    instance.render = Component.render || NOOP;
+    if (installWithProxy) {
+      installWithProxy(instance);
+    }
+  }
+  if (__VUE_OPTIONS_API__ && true) {
+    setCurrentInstance(instance);
+    pauseTracking();
+    applyOptions(instance);
+    resetTracking();
+    unsetCurrentInstance();
+  }
+  if (!!(process.env.NODE_ENV !== "production") && !Component.render && instance.render === NOOP && !isSSR) {
+    if (!compile && Component.template) {
+      warn(
+        `Component provided template option but runtime compilation is not supported in this build of Vue.` + (` Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".` )
+        /* should not happen */
+      );
+    } else {
+      warn(`Component is missing template or render function.`);
+    }
+  }
+}
+function getAttrsProxy(instance) {
+  return instance.attrsProxy || (instance.attrsProxy = new Proxy(
+    instance.attrs,
+    !!(process.env.NODE_ENV !== "production") ? {
+      get(target, key) {
+        markAttrsAccessed();
+        track(instance, "get", "$attrs");
+        return target[key];
+      },
+      set() {
+        warn(`setupContext.attrs is readonly.`);
+        return false;
+      },
+      deleteProperty() {
+        warn(`setupContext.attrs is readonly.`);
+        return false;
+      }
+    } : {
+      get(target, key) {
+        track(instance, "get", "$attrs");
+        return target[key];
+      }
+    }
+  ));
+}
+function getSlotsProxy(instance) {
+  return instance.slotsProxy || (instance.slotsProxy = new Proxy(instance.slots, {
+    get(target, key) {
+      track(instance, "get", "$slots");
+      return target[key];
+    }
+  }));
+}
+function createSetupContext(instance) {
+  const expose = (exposed) => {
+    if (!!(process.env.NODE_ENV !== "production")) {
+      if (instance.exposed) {
+        warn(`expose() should be called only once per setup().`);
+      }
+      if (exposed != null) {
+        let exposedType = typeof exposed;
+        if (exposedType === "object") {
+          if (isArray(exposed)) {
+            exposedType = "array";
+          } else if (isRef(exposed)) {
+            exposedType = "ref";
+          }
+        }
+        if (exposedType !== "object") {
+          warn(
+            `expose() should be passed a plain object, received ${exposedType}.`
+          );
+        }
+      }
+    }
+    instance.exposed = exposed || {};
+  };
+  if (!!(process.env.NODE_ENV !== "production")) {
+    return Object.freeze({
+      get attrs() {
+        return getAttrsProxy(instance);
+      },
+      get slots() {
+        return getSlotsProxy(instance);
+      },
+      get emit() {
+        return (event, ...args) => instance.emit(event, ...args);
+      },
+      expose
+    });
+  } else {
+    return {
+      get attrs() {
+        return getAttrsProxy(instance);
+      },
+      slots: instance.slots,
+      emit: instance.emit,
+      expose
+    };
+  }
+}
+function getExposeProxy(instance) {
+  if (instance.exposed) {
+    return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
+      get(target, key) {
+        if (key in target) {
+          return target[key];
+        } else if (key in publicPropertiesMap) {
+          return publicPropertiesMap[key](instance);
+        }
+      },
+      has(target, key) {
+        return key in target || key in publicPropertiesMap;
+      }
+    }));
+  }
+}
+const classifyRE = /(?:^|[-_])(\w)/g;
+const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
+function getComponentName(Component, includeInferred = true) {
+  return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
+}
+function formatComponentName(instance, Component, isRoot = false) {
+  let name = getComponentName(Component);
+  if (!name && Component.__file) {
+    const match = Component.__file.match(/([^/\\]+)\.\w+$/);
+    if (match) {
+      name = match[1];
+    }
+  }
+  if (!name && instance && instance.parent) {
+    const inferFromRegistry = (registry) => {
+      for (const key in registry) {
+        if (registry[key] === Component) {
+          return key;
+        }
+      }
+    };
+    name = inferFromRegistry(
+      instance.components || instance.parent.type.components
+    ) || inferFromRegistry(instance.appContext.components);
+  }
+  return name ? classify(name) : isRoot ? `App` : `Anonymous`;
+}
+function isClassComponent(value) {
+  return isFunction(value) && "__vccOpts" in value;
+}
+
+const computed = (getterOrOptions, debugOptions) => {
+  return computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
+};
+
+function h(type, propsOrChildren, children) {
+  const l = arguments.length;
+  if (l === 2) {
+    if (isObject(propsOrChildren) && !isArray(propsOrChildren)) {
+      if (isVNode(propsOrChildren)) {
+        return createVNode(type, null, [propsOrChildren]);
+      }
+      return createVNode(type, propsOrChildren);
+    } else {
+      return createVNode(type, null, propsOrChildren);
+    }
+  } else {
+    if (l > 3) {
+      children = Array.prototype.slice.call(arguments, 2);
+    } else if (l === 3 && isVNode(children)) {
+      children = [children];
+    }
+    return createVNode(type, propsOrChildren, children);
+  }
+}
+
+const ssrContextKey = Symbol.for("v-scx");
+const useSSRContext = () => {
+  {
+    const ctx = inject(ssrContextKey);
+    if (!ctx) {
+      !!(process.env.NODE_ENV !== "production") && warn(
+        `Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.`
+      );
+    }
+    return ctx;
+  }
+};
+
+function isShallow(value) {
+  return !!(value && value["__v_isShallow"]);
+}
+
+function initCustomFormatter() {
+  if (!!!(process.env.NODE_ENV !== "production") || typeof window === "undefined") {
+    return;
+  }
+  const vueStyle = { style: "color:#3ba776" };
+  const numberStyle = { style: "color:#0b1bc9" };
+  const stringStyle = { style: "color:#b62e24" };
+  const keywordStyle = { style: "color:#9d288c" };
+  const formatter = {
+    header(obj) {
+      if (!isObject(obj)) {
+        return null;
+      }
+      if (obj.__isVue) {
+        return ["div", vueStyle, `VueInstance`];
+      } else if (isRef(obj)) {
+        return [
+          "div",
+          {},
+          ["span", vueStyle, genRefFlag(obj)],
+          "<",
+          formatValue(obj.value),
+          `>`
+        ];
+      } else if (isReactive(obj)) {
+        return [
+          "div",
+          {},
+          ["span", vueStyle, isShallow(obj) ? "ShallowReactive" : "Reactive"],
+          "<",
+          formatValue(obj),
+          `>${isReadonly(obj) ? ` (readonly)` : ``}`
+        ];
+      } else if (isReadonly(obj)) {
+        return [
+          "div",
+          {},
+          ["span", vueStyle, isShallow(obj) ? "ShallowReadonly" : "Readonly"],
+          "<",
+          formatValue(obj),
+          ">"
+        ];
+      }
+      return null;
+    },
+    hasBody(obj) {
+      return obj && obj.__isVue;
+    },
+    body(obj) {
+      if (obj && obj.__isVue) {
+        return [
+          "div",
+          {},
+          ...formatInstance(obj.$)
+        ];
+      }
+    }
+  };
+  function formatInstance(instance) {
+    const blocks = [];
+    if (instance.type.props && instance.props) {
+      blocks.push(createInstanceBlock("props", toRaw(instance.props)));
+    }
+    if (instance.setupState !== EMPTY_OBJ) {
+      blocks.push(createInstanceBlock("setup", instance.setupState));
+    }
+    if (instance.data !== EMPTY_OBJ) {
+      blocks.push(createInstanceBlock("data", toRaw(instance.data)));
+    }
+    const computed = extractKeys(instance, "computed");
+    if (computed) {
+      blocks.push(createInstanceBlock("computed", computed));
+    }
+    const injected = extractKeys(instance, "inject");
+    if (injected) {
+      blocks.push(createInstanceBlock("injected", injected));
+    }
+    blocks.push([
+      "div",
+      {},
+      [
+        "span",
+        {
+          style: keywordStyle.style + ";opacity:0.66"
+        },
+        "$ (internal): "
+      ],
+      ["object", { object: instance }]
+    ]);
+    return blocks;
+  }
+  function createInstanceBlock(type, target) {
+    target = extend({}, target);
+    if (!Object.keys(target).length) {
+      return ["span", {}];
+    }
+    return [
+      "div",
+      { style: "line-height:1.25em;margin-bottom:0.6em" },
+      [
+        "div",
+        {
+          style: "color:#476582"
+        },
+        type
+      ],
+      [
+        "div",
+        {
+          style: "padding-left:1.25em"
+        },
+        ...Object.keys(target).map((key) => {
+          return [
+            "div",
+            {},
+            ["span", keywordStyle, key + ": "],
+            formatValue(target[key], false)
+          ];
+        })
+      ]
+    ];
+  }
+  function formatValue(v, asRaw = true) {
+    if (typeof v === "number") {
+      return ["span", numberStyle, v];
+    } else if (typeof v === "string") {
+      return ["span", stringStyle, JSON.stringify(v)];
+    } else if (typeof v === "boolean") {
+      return ["span", keywordStyle, v];
+    } else if (isObject(v)) {
+      return ["object", { object: asRaw ? toRaw(v) : v }];
+    } else {
+      return ["span", stringStyle, String(v)];
+    }
+  }
+  function extractKeys(instance, type) {
+    const Comp = instance.type;
+    if (isFunction(Comp)) {
+      return;
+    }
+    const extracted = {};
+    for (const key in instance.ctx) {
+      if (isKeyOfType(Comp, key, type)) {
+        extracted[key] = instance.ctx[key];
+      }
+    }
+    return extracted;
+  }
+  function isKeyOfType(Comp, key, type) {
+    const opts = Comp[type];
+    if (isArray(opts) && opts.includes(key) || isObject(opts) && key in opts) {
+      return true;
+    }
+    if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {
+      return true;
+    }
+    if (Comp.mixins && Comp.mixins.some((m) => isKeyOfType(m, key, type))) {
+      return true;
+    }
+  }
+  function genRefFlag(v) {
+    if (isShallow(v)) {
+      return `ShallowRef`;
+    }
+    if (v.effect) {
+      return `ComputedRef`;
+    }
+    return `Ref`;
+  }
+  if (window.devtoolsFormatters) {
+    window.devtoolsFormatters.push(formatter);
+  } else {
+    window.devtoolsFormatters = [formatter];
+  }
+}
+
+function withMemo(memo, render, cache, index) {
+  const cached = cache[index];
+  if (cached && isMemoSame(cached, memo)) {
+    return cached;
+  }
+  const ret = render();
+  ret.memo = memo.slice();
+  return cache[index] = ret;
+}
+function isMemoSame(cached, memo) {
+  const prev = cached.memo;
+  if (prev.length != memo.length) {
+    return false;
+  }
+  for (let i = 0; i < prev.length; i++) {
+    if (hasChanged(prev[i], memo[i])) {
+      return false;
+    }
+  }
+  if (isBlockTreeEnabled > 0 && currentBlock) {
+    currentBlock.push(cached);
+  }
+  return true;
+}
+
+const version = "3.3.4";
+const _ssrUtils = {
+  createComponentInstance,
+  setupComponent,
+  renderComponentRoot,
+  setCurrentRenderingInstance,
+  isVNode: isVNode,
+  normalizeVNode
+};
+const ssrUtils = _ssrUtils ;
+const resolveFilter = null;
+const compatUtils = null;
+
+export { BaseTransition, BaseTransitionPropsValidators, Comment, Fragment, KeepAlive, Static, Suspense, Teleport, Text, assertNumber, callWithAsyncErrorHandling, callWithErrorHandling, cloneVNode, compatUtils, computed, createBlock, createCommentVNode, createElementBlock, createBaseVNode as createElementVNode, createHydrationRenderer, createPropsRestProxy, createRenderer, createSlots, createStaticVNode, createTextVNode, createVNode, defineAsyncComponent, defineComponent, defineEmits, defineExpose, defineModel, defineOptions, defineProps, defineSlots, devtools, getCurrentInstance, getTransitionRawChildren, guardReactiveProps, h, handleError, hasInjectionContext, initCustomFormatter, inject, isMemoSame, isRuntimeOnly, isVNode, mergeDefaults, mergeModels, mergeProps, nextTick, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onServerPrefetch, onUnmounted, onUpdated, openBlock, popScopeId, provide, pushScopeId, queuePostFlushCb, registerRuntimeCompiler, renderList, renderSlot, resolveComponent, resolveDirective, resolveDynamicComponent, resolveFilter, resolveTransitionHooks, setBlockTracking, setDevtoolsHook, setTransitionHooks, ssrContextKey, ssrUtils, toHandlers, transformVNodeArgs, useAttrs, useModel, useSSRContext, useSlots, useTransitionState, version, warn, watch, watchEffect, watchPostEffect, watchSyncEffect, withAsyncContext, withCtx, withDefaults, withDirectives, withMemo, withScopeId };
diff --git a/parent_dir/node_modules/vue/runtime-dom/dist/runtime-dom.esm-bundler.js b/parent_dir/node_modules/vue/runtime-dom/dist/runtime-dom.esm-bundler.js
new file mode 100644
index 0000000..d7e0bdf
--- /dev/null
+++ b/parent_dir/node_modules/vue/runtime-dom/dist/runtime-dom.esm-bundler.js
@@ -0,0 +1,1516 @@
+import { warn, camelize, callWithAsyncErrorHandling, defineComponent, nextTick, createVNode, getCurrentInstance, watchPostEffect, onMounted, onUnmounted, Fragment, Static, h, BaseTransition, BaseTransitionPropsValidators, assertNumber, useTransitionState, onUpdated, toRaw, getTransitionRawChildren, setTransitionHooks, resolveTransitionHooks, isRuntimeOnly, createRenderer, createHydrationRenderer } from '@vue/runtime-core';
+export * from '@vue/runtime-core';
+import { isString, isArray, hyphenate, capitalize, isSpecialBooleanAttr, includeBooleanAttr, isOn, isModelListener, isFunction, camelize as camelize$1, toNumber, extend, EMPTY_OBJ, isObject, looseToNumber, looseIndexOf, isSet, looseEqual, invokeArrayFns, isHTMLTag, isSVGTag } from '@vue/shared';
+
+const svgNS = "http://www.w3.org/2000/svg";
+const doc = typeof document !== "undefined" ? document : null;
+const templateContainer = doc && /* @__PURE__ */ doc.createElement("template");
+const nodeOps = {
+  insert: (child, parent, anchor) => {
+    parent.insertBefore(child, anchor || null);
+  },
+  remove: (child) => {
+    const parent = child.parentNode;
+    if (parent) {
+      parent.removeChild(child);
+    }
+  },
+  createElement: (tag, isSVG, is, props) => {
+    const el = isSVG ? doc.createElementNS(svgNS, tag) : doc.createElement(tag, is ? { is } : void 0);
+    if (tag === "select" && props && props.multiple != null) {
+      el.setAttribute("multiple", props.multiple);
+    }
+    return el;
+  },
+  createText: (text) => doc.createTextNode(text),
+  createComment: (text) => doc.createComment(text),
+  setText: (node, text) => {
+    node.nodeValue = text;
+  },
+  setElementText: (el, text) => {
+    el.textContent = text;
+  },
+  parentNode: (node) => node.parentNode,
+  nextSibling: (node) => node.nextSibling,
+  querySelector: (selector) => doc.querySelector(selector),
+  setScopeId(el, id) {
+    el.setAttribute(id, "");
+  },
+  // __UNSAFE__
+  // Reason: innerHTML.
+  // Static content here can only come from compiled templates.
+  // As long as the user only uses trusted templates, this is safe.
+  insertStaticContent(content, parent, anchor, isSVG, start, end) {
+    const before = anchor ? anchor.previousSibling : parent.lastChild;
+    if (start && (start === end || start.nextSibling)) {
+      while (true) {
+        parent.insertBefore(start.cloneNode(true), anchor);
+        if (start === end || !(start = start.nextSibling))
+          break;
+      }
+    } else {
+      templateContainer.innerHTML = isSVG ? `<svg>${content}</svg>` : content;
+      const template = templateContainer.content;
+      if (isSVG) {
+        const wrapper = template.firstChild;
+        while (wrapper.firstChild) {
+          template.appendChild(wrapper.firstChild);
+        }
+        template.removeChild(wrapper);
+      }
+      parent.insertBefore(template, anchor);
+    }
+    return [
+      // first
+      before ? before.nextSibling : parent.firstChild,
+      // last
+      anchor ? anchor.previousSibling : parent.lastChild
+    ];
+  }
+};
+
+function patchClass(el, value, isSVG) {
+  const transitionClasses = el._vtc;
+  if (transitionClasses) {
+    value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" ");
+  }
+  if (value == null) {
+    el.removeAttribute("class");
+  } else if (isSVG) {
+    el.setAttribute("class", value);
+  } else {
+    el.className = value;
+  }
+}
+
+function patchStyle(el, prev, next) {
+  const style = el.style;
+  const isCssString = isString(next);
+  if (next && !isCssString) {
+    if (prev && !isString(prev)) {
+      for (const key in prev) {
+        if (next[key] == null) {
+          setStyle(style, key, "");
+        }
+      }
+    }
+    for (const key in next) {
+      setStyle(style, key, next[key]);
+    }
+  } else {
+    const currentDisplay = style.display;
+    if (isCssString) {
+      if (prev !== next) {
+        style.cssText = next;
+      }
+    } else if (prev) {
+      el.removeAttribute("style");
+    }
+    if ("_vod" in el) {
+      style.display = currentDisplay;
+    }
+  }
+}
+const semicolonRE = /[^\\];\s*$/;
+const importantRE = /\s*!important$/;
+function setStyle(style, name, val) {
+  if (isArray(val)) {
+    val.forEach((v) => setStyle(style, name, v));
+  } else {
+    if (val == null)
+      val = "";
+    if (!!(process.env.NODE_ENV !== "production")) {
+      if (semicolonRE.test(val)) {
+        warn(
+          `Unexpected semicolon at the end of '${name}' style value: '${val}'`
+        );
+      }
+    }
+    if (name.startsWith("--")) {
+      style.setProperty(name, val);
+    } else {
+      const prefixed = autoPrefix(style, name);
+      if (importantRE.test(val)) {
+        style.setProperty(
+          hyphenate(prefixed),
+          val.replace(importantRE, ""),
+          "important"
+        );
+      } else {
+        style[prefixed] = val;
+      }
+    }
+  }
+}
+const prefixes = ["Webkit", "Moz", "ms"];
+const prefixCache = {};
+function autoPrefix(style, rawName) {
+  const cached = prefixCache[rawName];
+  if (cached) {
+    return cached;
+  }
+  let name = camelize(rawName);
+  if (name !== "filter" && name in style) {
+    return prefixCache[rawName] = name;
+  }
+  name = capitalize(name);
+  for (let i = 0; i < prefixes.length; i++) {
+    const prefixed = prefixes[i] + name;
+    if (prefixed in style) {
+      return prefixCache[rawName] = prefixed;
+    }
+  }
+  return rawName;
+}
+
+const xlinkNS = "http://www.w3.org/1999/xlink";
+function patchAttr(el, key, value, isSVG, instance) {
+  if (isSVG && key.startsWith("xlink:")) {
+    if (value == null) {
+      el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
+    } else {
+      el.setAttributeNS(xlinkNS, key, value);
+    }
+  } else {
+    const isBoolean = isSpecialBooleanAttr(key);
+    if (value == null || isBoolean && !includeBooleanAttr(value)) {
+      el.removeAttribute(key);
+    } else {
+      el.setAttribute(key, isBoolean ? "" : value);
+    }
+  }
+}
+
+function patchDOMProp(el, key, value, prevChildren, parentComponent, parentSuspense, unmountChildren) {
+  if (key === "innerHTML" || key === "textContent") {
+    if (prevChildren) {
+      unmountChildren(prevChildren, parentComponent, parentSuspense);
+    }
+    el[key] = value == null ? "" : value;
+    return;
+  }
+  const tag = el.tagName;
+  if (key === "value" && tag !== "PROGRESS" && // custom elements may use _value internally
+  !tag.includes("-")) {
+    el._value = value;
+    const oldValue = tag === "OPTION" ? el.getAttribute("value") : el.value;
+    const newValue = value == null ? "" : value;
+    if (oldValue !== newValue) {
+      el.value = newValue;
+    }
+    if (value == null) {
+      el.removeAttribute(key);
+    }
+    return;
+  }
+  let needRemove = false;
+  if (value === "" || value == null) {
+    const type = typeof el[key];
+    if (type === "boolean") {
+      value = includeBooleanAttr(value);
+    } else if (value == null && type === "string") {
+      value = "";
+      needRemove = true;
+    } else if (type === "number") {
+      value = 0;
+      needRemove = true;
+    }
+  }
+  try {
+    el[key] = value;
+  } catch (e) {
+    if (!!(process.env.NODE_ENV !== "production") && !needRemove) {
+      warn(
+        `Failed setting prop "${key}" on <${tag.toLowerCase()}>: value ${value} is invalid.`,
+        e
+      );
+    }
+  }
+  needRemove && el.removeAttribute(key);
+}
+
+function addEventListener(el, event, handler, options) {
+  el.addEventListener(event, handler, options);
+}
+function removeEventListener(el, event, handler, options) {
+  el.removeEventListener(event, handler, options);
+}
+function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
+  const invokers = el._vei || (el._vei = {});
+  const existingInvoker = invokers[rawName];
+  if (nextValue && existingInvoker) {
+    existingInvoker.value = nextValue;
+  } else {
+    const [name, options] = parseName(rawName);
+    if (nextValue) {
+      const invoker = invokers[rawName] = createInvoker(nextValue, instance);
+      addEventListener(el, name, invoker, options);
+    } else if (existingInvoker) {
+      removeEventListener(el, name, existingInvoker, options);
+      invokers[rawName] = void 0;
+    }
+  }
+}
+const optionsModifierRE = /(?:Once|Passive|Capture)$/;
+function parseName(name) {
+  let options;
+  if (optionsModifierRE.test(name)) {
+    options = {};
+    let m;
+    while (m = name.match(optionsModifierRE)) {
+      name = name.slice(0, name.length - m[0].length);
+      options[m[0].toLowerCase()] = true;
+    }
+  }
+  const event = name[2] === ":" ? name.slice(3) : hyphenate(name.slice(2));
+  return [event, options];
+}
+let cachedNow = 0;
+const p = /* @__PURE__ */ Promise.resolve();
+const getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = Date.now());
+function createInvoker(initialValue, instance) {
+  const invoker = (e) => {
+    if (!e._vts) {
+      e._vts = Date.now();
+    } else if (e._vts <= invoker.attached) {
+      return;
+    }
+    callWithAsyncErrorHandling(
+      patchStopImmediatePropagation(e, invoker.value),
+      instance,
+      5,
+      [e]
+    );
+  };
+  invoker.value = initialValue;
+  invoker.attached = getNow();
+  return invoker;
+}
+function patchStopImmediatePropagation(e, value) {
+  if (isArray(value)) {
+    const originalStop = e.stopImmediatePropagation;
+    e.stopImmediatePropagation = () => {
+      originalStop.call(e);
+      e._stopped = true;
+    };
+    return value.map((fn) => (e2) => !e2._stopped && fn && fn(e2));
+  } else {
+    return value;
+  }
+}
+
+const nativeOnRE = /^on[a-z]/;
+const patchProp = (el, key, prevValue, nextValue, isSVG = false, prevChildren, parentComponent, parentSuspense, unmountChildren) => {
+  if (key === "class") {
+    patchClass(el, nextValue, isSVG);
+  } else if (key === "style") {
+    patchStyle(el, prevValue, nextValue);
+  } else if (isOn(key)) {
+    if (!isModelListener(key)) {
+      patchEvent(el, key, prevValue, nextValue, parentComponent);
+    }
+  } else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {
+    patchDOMProp(
+      el,
+      key,
+      nextValue,
+      prevChildren,
+      parentComponent,
+      parentSuspense,
+      unmountChildren
+    );
+  } else {
+    if (key === "true-value") {
+      el._trueValue = nextValue;
+    } else if (key === "false-value") {
+      el._falseValue = nextValue;
+    }
+    patchAttr(el, key, nextValue, isSVG);
+  }
+};
+function shouldSetAsProp(el, key, value, isSVG) {
+  if (isSVG) {
+    if (key === "innerHTML" || key === "textContent") {
+      return true;
+    }
+    if (key in el && nativeOnRE.test(key) && isFunction(value)) {
+      return true;
+    }
+    return false;
+  }
+  if (key === "spellcheck" || key === "draggable" || key === "translate") {
+    return false;
+  }
+  if (key === "form") {
+    return false;
+  }
+  if (key === "list" && el.tagName === "INPUT") {
+    return false;
+  }
+  if (key === "type" && el.tagName === "TEXTAREA") {
+    return false;
+  }
+  if (nativeOnRE.test(key) && isString(value)) {
+    return false;
+  }
+  return key in el;
+}
+
+function defineCustomElement(options, hydrate2) {
+  const Comp = defineComponent(options);
+  class VueCustomElement extends VueElement {
+    constructor(initialProps) {
+      super(Comp, initialProps, hydrate2);
+    }
+  }
+  VueCustomElement.def = Comp;
+  return VueCustomElement;
+}
+const defineSSRCustomElement = (options) => {
+  return defineCustomElement(options, hydrate);
+};
+const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class {
+};
+class VueElement extends BaseClass {
+  constructor(_def, _props = {}, hydrate2) {
+    super();
+    this._def = _def;
+    this._props = _props;
+    /**
+     * @internal
+     */
+    this._instance = null;
+    this._connected = false;
+    this._resolved = false;
+    this._numberProps = null;
+    if (this.shadowRoot && hydrate2) {
+      hydrate2(this._createVNode(), this.shadowRoot);
+    } else {
+      if (!!(process.env.NODE_ENV !== "production") && this.shadowRoot) {
+        warn(
+          `Custom element has pre-rendered declarative shadow root but is not defined as hydratable. Use \`defineSSRCustomElement\`.`
+        );
+      }
+      this.attachShadow({ mode: "open" });
+      if (!this._def.__asyncLoader) {
+        this._resolveProps(this._def);
+      }
+    }
+  }
+  connectedCallback() {
+    this._connected = true;
+    if (!this._instance) {
+      if (this._resolved) {
+        this._update();
+      } else {
+        this._resolveDef();
+      }
+    }
+  }
+  disconnectedCallback() {
+    this._connected = false;
+    nextTick(() => {
+      if (!this._connected) {
+        render(null, this.shadowRoot);
+        this._instance = null;
+      }
+    });
+  }
+  /**
+   * resolve inner component definition (handle possible async component)
+   */
+  _resolveDef() {
+    this._resolved = true;
+    for (let i = 0; i < this.attributes.length; i++) {
+      this._setAttr(this.attributes[i].name);
+    }
+    new MutationObserver((mutations) => {
+      for (const m of mutations) {
+        this._setAttr(m.attributeName);
+      }
+    }).observe(this, { attributes: true });
+    const resolve = (def, isAsync = false) => {
+      const { props, styles } = def;
+      let numberProps;
+      if (props && !isArray(props)) {
+        for (const key in props) {
+          const opt = props[key];
+          if (opt === Number || opt && opt.type === Number) {
+            if (key in this._props) {
+              this._props[key] = toNumber(this._props[key]);
+            }
+            (numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[camelize$1(key)] = true;
+          }
+        }
+      }
+      this._numberProps = numberProps;
+      if (isAsync) {
+        this._resolveProps(def);
+      }
+      this._applyStyles(styles);
+      this._update();
+    };
+    const asyncDef = this._def.__asyncLoader;
+    if (asyncDef) {
+      asyncDef().then((def) => resolve(def, true));
+    } else {
+      resolve(this._def);
+    }
+  }
+  _resolveProps(def) {
+    const { props } = def;
+    const declaredPropKeys = isArray(props) ? props : Object.keys(props || {});
+    for (const key of Object.keys(this)) {
+      if (key[0] !== "_" && declaredPropKeys.includes(key)) {
+        this._setProp(key, this[key], true, false);
+      }
+    }
+    for (const key of declaredPropKeys.map(camelize$1)) {
+      Object.defineProperty(this, key, {
+        get() {
+          return this._getProp(key);
+        },
+        set(val) {
+          this._setProp(key, val);
+        }
+      });
+    }
+  }
+  _setAttr(key) {
+    let value = this.getAttribute(key);
+    const camelKey = camelize$1(key);
+    if (this._numberProps && this._numberProps[camelKey]) {
+      value = toNumber(value);
+    }
+    this._setProp(camelKey, value, false);
+  }
+  /**
+   * @internal
+   */
+  _getProp(key) {
+    return this._props[key];
+  }
+  /**
+   * @internal
+   */
+  _setProp(key, val, shouldReflect = true, shouldUpdate = true) {
+    if (val !== this._props[key]) {
+      this._props[key] = val;
+      if (shouldUpdate && this._instance) {
+        this._update();
+      }
+      if (shouldReflect) {
+        if (val === true) {
+          this.setAttribute(hyphenate(key), "");
+        } else if (typeof val === "string" || typeof val === "number") {
+          this.setAttribute(hyphenate(key), val + "");
+        } else if (!val) {
+          this.removeAttribute(hyphenate(key));
+        }
+      }
+    }
+  }
+  _update() {
+    render(this._createVNode(), this.shadowRoot);
+  }
+  _createVNode() {
+    const vnode = createVNode(this._def, extend({}, this._props));
+    if (!this._instance) {
+      vnode.ce = (instance) => {
+        this._instance = instance;
+        instance.isCE = true;
+        if (!!(process.env.NODE_ENV !== "production")) {
+          instance.ceReload = (newStyles) => {
+            if (this._styles) {
+              this._styles.forEach((s) => this.shadowRoot.removeChild(s));
+              this._styles.length = 0;
+            }
+            this._applyStyles(newStyles);
+            this._instance = null;
+            this._update();
+          };
+        }
+        const dispatch = (event, args) => {
+          this.dispatchEvent(
+            new CustomEvent(event, {
+              detail: args
+            })
+          );
+        };
+        instance.emit = (event, ...args) => {
+          dispatch(event, args);
+          if (hyphenate(event) !== event) {
+            dispatch(hyphenate(event), args);
+          }
+        };
+        let parent = this;
+        while (parent = parent && (parent.parentNode || parent.host)) {
+          if (parent instanceof VueElement) {
+            instance.parent = parent._instance;
+            instance.provides = parent._instance.provides;
+            break;
+          }
+        }
+      };
+    }
+    return vnode;
+  }
+  _applyStyles(styles) {
+    if (styles) {
+      styles.forEach((css) => {
+        const s = document.createElement("style");
+        s.textContent = css;
+        this.shadowRoot.appendChild(s);
+        if (!!(process.env.NODE_ENV !== "production")) {
+          (this._styles || (this._styles = [])).push(s);
+        }
+      });
+    }
+  }
+}
+
+function useCssModule(name = "$style") {
+  {
+    const instance = getCurrentInstance();
+    if (!instance) {
+      !!(process.env.NODE_ENV !== "production") && warn(`useCssModule must be called inside setup()`);
+      return EMPTY_OBJ;
+    }
+    const modules = instance.type.__cssModules;
+    if (!modules) {
+      !!(process.env.NODE_ENV !== "production") && warn(`Current instance does not have CSS modules injected.`);
+      return EMPTY_OBJ;
+    }
+    const mod = modules[name];
+    if (!mod) {
+      !!(process.env.NODE_ENV !== "production") && warn(`Current instance does not have CSS module named "${name}".`);
+      return EMPTY_OBJ;
+    }
+    return mod;
+  }
+}
+
+function useCssVars(getter) {
+  const instance = getCurrentInstance();
+  if (!instance) {
+    !!(process.env.NODE_ENV !== "production") && warn(`useCssVars is called without current active component instance.`);
+    return;
+  }
+  const updateTeleports = instance.ut = (vars = getter(instance.proxy)) => {
+    Array.from(
+      document.querySelectorAll(`[data-v-owner="${instance.uid}"]`)
+    ).forEach((node) => setVarsOnNode(node, vars));
+  };
+  const setVars = () => {
+    const vars = getter(instance.proxy);
+    setVarsOnVNode(instance.subTree, vars);
+    updateTeleports(vars);
+  };
+  watchPostEffect(setVars);
+  onMounted(() => {
+    const ob = new MutationObserver(setVars);
+    ob.observe(instance.subTree.el.parentNode, { childList: true });
+    onUnmounted(() => ob.disconnect());
+  });
+}
+function setVarsOnVNode(vnode, vars) {
+  if (vnode.shapeFlag & 128) {
+    const suspense = vnode.suspense;
+    vnode = suspense.activeBranch;
+    if (suspense.pendingBranch && !suspense.isHydrating) {
+      suspense.effects.push(() => {
+        setVarsOnVNode(suspense.activeBranch, vars);
+      });
+    }
+  }
+  while (vnode.component) {
+    vnode = vnode.component.subTree;
+  }
+  if (vnode.shapeFlag & 1 && vnode.el) {
+    setVarsOnNode(vnode.el, vars);
+  } else if (vnode.type === Fragment) {
+    vnode.children.forEach((c) => setVarsOnVNode(c, vars));
+  } else if (vnode.type === Static) {
+    let { el, anchor } = vnode;
+    while (el) {
+      setVarsOnNode(el, vars);
+      if (el === anchor)
+        break;
+      el = el.nextSibling;
+    }
+  }
+}
+function setVarsOnNode(el, vars) {
+  if (el.nodeType === 1) {
+    const style = el.style;
+    for (const key in vars) {
+      style.setProperty(`--${key}`, vars[key]);
+    }
+  }
+}
+
+const TRANSITION = "transition";
+const ANIMATION = "animation";
+const Transition = (props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots);
+Transition.displayName = "Transition";
+const DOMTransitionPropsValidators = {
+  name: String,
+  type: String,
+  css: {
+    type: Boolean,
+    default: true
+  },
+  duration: [String, Number, Object],
+  enterFromClass: String,
+  enterActiveClass: String,
+  enterToClass: String,
+  appearFromClass: String,
+  appearActiveClass: String,
+  appearToClass: String,
+  leaveFromClass: String,
+  leaveActiveClass: String,
+  leaveToClass: String
+};
+const TransitionPropsValidators = Transition.props = /* @__PURE__ */ extend(
+  {},
+  BaseTransitionPropsValidators,
+  DOMTransitionPropsValidators
+);
+const callHook = (hook, args = []) => {
+  if (isArray(hook)) {
+    hook.forEach((h2) => h2(...args));
+  } else if (hook) {
+    hook(...args);
+  }
+};
+const hasExplicitCallback = (hook) => {
+  return hook ? isArray(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;
+};
+function resolveTransitionProps(rawProps) {
+  const baseProps = {};
+  for (const key in rawProps) {
+    if (!(key in DOMTransitionPropsValidators)) {
+      baseProps[key] = rawProps[key];
+    }
+  }
+  if (rawProps.css === false) {
+    return baseProps;
+  }
+  const {
+    name = "v",
+    type,
+    duration,
+    enterFromClass = `${name}-enter-from`,
+    enterActiveClass = `${name}-enter-active`,
+    enterToClass = `${name}-enter-to`,
+    appearFromClass = enterFromClass,
+    appearActiveClass = enterActiveClass,
+    appearToClass = enterToClass,
+    leaveFromClass = `${name}-leave-from`,
+    leaveActiveClass = `${name}-leave-active`,
+    leaveToClass = `${name}-leave-to`
+  } = rawProps;
+  const durations = normalizeDuration(duration);
+  const enterDuration = durations && durations[0];
+  const leaveDuration = durations && durations[1];
+  const {
+    onBeforeEnter,
+    onEnter,
+    onEnterCancelled,
+    onLeave,
+    onLeaveCancelled,
+    onBeforeAppear = onBeforeEnter,
+    onAppear = onEnter,
+    onAppearCancelled = onEnterCancelled
+  } = baseProps;
+  const finishEnter = (el, isAppear, done) => {
+    removeTransitionClass(el, isAppear ? appearToClass : enterToClass);
+    removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);
+    done && done();
+  };
+  const finishLeave = (el, done) => {
+    el._isLeaving = false;
+    removeTransitionClass(el, leaveFromClass);
+    removeTransitionClass(el, leaveToClass);
+    removeTransitionClass(el, leaveActiveClass);
+    done && done();
+  };
+  const makeEnterHook = (isAppear) => {
+    return (el, done) => {
+      const hook = isAppear ? onAppear : onEnter;
+      const resolve = () => finishEnter(el, isAppear, done);
+      callHook(hook, [el, resolve]);
+      nextFrame(() => {
+        removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);
+        addTransitionClass(el, isAppear ? appearToClass : enterToClass);
+        if (!hasExplicitCallback(hook)) {
+          whenTransitionEnds(el, type, enterDuration, resolve);
+        }
+      });
+    };
+  };
+  return extend(baseProps, {
+    onBeforeEnter(el) {
+      callHook(onBeforeEnter, [el]);
+      addTransitionClass(el, enterFromClass);
+      addTransitionClass(el, enterActiveClass);
+    },
+    onBeforeAppear(el) {
+      callHook(onBeforeAppear, [el]);
+      addTransitionClass(el, appearFromClass);
+      addTransitionClass(el, appearActiveClass);
+    },
+    onEnter: makeEnterHook(false),
+    onAppear: makeEnterHook(true),
+    onLeave(el, done) {
+      el._isLeaving = true;
+      const resolve = () => finishLeave(el, done);
+      addTransitionClass(el, leaveFromClass);
+      forceReflow();
+      addTransitionClass(el, leaveActiveClass);
+      nextFrame(() => {
+        if (!el._isLeaving) {
+          return;
+        }
+        removeTransitionClass(el, leaveFromClass);
+        addTransitionClass(el, leaveToClass);
+        if (!hasExplicitCallback(onLeave)) {
+          whenTransitionEnds(el, type, leaveDuration, resolve);
+        }
+      });
+      callHook(onLeave, [el, resolve]);
+    },
+    onEnterCancelled(el) {
+      finishEnter(el, false);
+      callHook(onEnterCancelled, [el]);
+    },
+    onAppearCancelled(el) {
+      finishEnter(el, true);
+      callHook(onAppearCancelled, [el]);
+    },
+    onLeaveCancelled(el) {
+      finishLeave(el);
+      callHook(onLeaveCancelled, [el]);
+    }
+  });
+}
+function normalizeDuration(duration) {
+  if (duration == null) {
+    return null;
+  } else if (isObject(duration)) {
+    return [NumberOf(duration.enter), NumberOf(duration.leave)];
+  } else {
+    const n = NumberOf(duration);
+    return [n, n];
+  }
+}
+function NumberOf(val) {
+  const res = toNumber(val);
+  if (!!(process.env.NODE_ENV !== "production")) {
+    assertNumber(res, "<transition> explicit duration");
+  }
+  return res;
+}
+function addTransitionClass(el, cls) {
+  cls.split(/\s+/).forEach((c) => c && el.classList.add(c));
+  (el._vtc || (el._vtc = /* @__PURE__ */ new Set())).add(cls);
+}
+function removeTransitionClass(el, cls) {
+  cls.split(/\s+/).forEach((c) => c && el.classList.remove(c));
+  const { _vtc } = el;
+  if (_vtc) {
+    _vtc.delete(cls);
+    if (!_vtc.size) {
+      el._vtc = void 0;
+    }
+  }
+}
+function nextFrame(cb) {
+  requestAnimationFrame(() => {
+    requestAnimationFrame(cb);
+  });
+}
+let endId = 0;
+function whenTransitionEnds(el, expectedType, explicitTimeout, resolve) {
+  const id = el._endId = ++endId;
+  const resolveIfNotStale = () => {
+    if (id === el._endId) {
+      resolve();
+    }
+  };
+  if (explicitTimeout) {
+    return setTimeout(resolveIfNotStale, explicitTimeout);
+  }
+  const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
+  if (!type) {
+    return resolve();
+  }
+  const endEvent = type + "end";
+  let ended = 0;
+  const end = () => {
+    el.removeEventListener(endEvent, onEnd);
+    resolveIfNotStale();
+  };
+  const onEnd = (e) => {
+    if (e.target === el && ++ended >= propCount) {
+      end();
+    }
+  };
+  setTimeout(() => {
+    if (ended < propCount) {
+      end();
+    }
+  }, timeout + 1);
+  el.addEventListener(endEvent, onEnd);
+}
+function getTransitionInfo(el, expectedType) {
+  const styles = window.getComputedStyle(el);
+  const getStyleProperties = (key) => (styles[key] || "").split(", ");
+  const transitionDelays = getStyleProperties(`${TRANSITION}Delay`);
+  const transitionDurations = getStyleProperties(`${TRANSITION}Duration`);
+  const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+  const animationDelays = getStyleProperties(`${ANIMATION}Delay`);
+  const animationDurations = getStyleProperties(`${ANIMATION}Duration`);
+  const animationTimeout = getTimeout(animationDelays, animationDurations);
+  let type = null;
+  let timeout = 0;
+  let propCount = 0;
+  if (expectedType === TRANSITION) {
+    if (transitionTimeout > 0) {
+      type = TRANSITION;
+      timeout = transitionTimeout;
+      propCount = transitionDurations.length;
+    }
+  } else if (expectedType === ANIMATION) {
+    if (animationTimeout > 0) {
+      type = ANIMATION;
+      timeout = animationTimeout;
+      propCount = animationDurations.length;
+    }
+  } else {
+    timeout = Math.max(transitionTimeout, animationTimeout);
+    type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null;
+    propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0;
+  }
+  const hasTransform = type === TRANSITION && /\b(transform|all)(,|$)/.test(
+    getStyleProperties(`${TRANSITION}Property`).toString()
+  );
+  return {
+    type,
+    timeout,
+    propCount,
+    hasTransform
+  };
+}
+function getTimeout(delays, durations) {
+  while (delays.length < durations.length) {
+    delays = delays.concat(delays);
+  }
+  return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
+}
+function toMs(s) {
+  return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
+}
+function forceReflow() {
+  return document.body.offsetHeight;
+}
+
+const positionMap = /* @__PURE__ */ new WeakMap();
+const newPositionMap = /* @__PURE__ */ new WeakMap();
+const TransitionGroupImpl = {
+  name: "TransitionGroup",
+  props: /* @__PURE__ */ extend({}, TransitionPropsValidators, {
+    tag: String,
+    moveClass: String
+  }),
+  setup(props, { slots }) {
+    const instance = getCurrentInstance();
+    const state = useTransitionState();
+    let prevChildren;
+    let children;
+    onUpdated(() => {
+      if (!prevChildren.length) {
+        return;
+      }
+      const moveClass = props.moveClass || `${props.name || "v"}-move`;
+      if (!hasCSSTransform(
+        prevChildren[0].el,
+        instance.vnode.el,
+        moveClass
+      )) {
+        return;
+      }
+      prevChildren.forEach(callPendingCbs);
+      prevChildren.forEach(recordPosition);
+      const movedChildren = prevChildren.filter(applyTranslation);
+      forceReflow();
+      movedChildren.forEach((c) => {
+        const el = c.el;
+        const style = el.style;
+        addTransitionClass(el, moveClass);
+        style.transform = style.webkitTransform = style.transitionDuration = "";
+        const cb = el._moveCb = (e) => {
+          if (e && e.target !== el) {
+            return;
+          }
+          if (!e || /transform$/.test(e.propertyName)) {
+            el.removeEventListener("transitionend", cb);
+            el._moveCb = null;
+            removeTransitionClass(el, moveClass);
+          }
+        };
+        el.addEventListener("transitionend", cb);
+      });
+    });
+    return () => {
+      const rawProps = toRaw(props);
+      const cssTransitionProps = resolveTransitionProps(rawProps);
+      let tag = rawProps.tag || Fragment;
+      prevChildren = children;
+      children = slots.default ? getTransitionRawChildren(slots.default()) : [];
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        if (child.key != null) {
+          setTransitionHooks(
+            child,
+            resolveTransitionHooks(child, cssTransitionProps, state, instance)
+          );
+        } else if (!!(process.env.NODE_ENV !== "production")) {
+          warn(`<TransitionGroup> children must be keyed.`);
+        }
+      }
+      if (prevChildren) {
+        for (let i = 0; i < prevChildren.length; i++) {
+          const child = prevChildren[i];
+          setTransitionHooks(
+            child,
+            resolveTransitionHooks(child, cssTransitionProps, state, instance)
+          );
+          positionMap.set(child, child.el.getBoundingClientRect());
+        }
+      }
+      return createVNode(tag, null, children);
+    };
+  }
+};
+const removeMode = (props) => delete props.mode;
+/* @__PURE__ */ removeMode(TransitionGroupImpl.props);
+const TransitionGroup = TransitionGroupImpl;
+function callPendingCbs(c) {
+  const el = c.el;
+  if (el._moveCb) {
+    el._moveCb();
+  }
+  if (el._enterCb) {
+    el._enterCb();
+  }
+}
+function recordPosition(c) {
+  newPositionMap.set(c, c.el.getBoundingClientRect());
+}
+function applyTranslation(c) {
+  const oldPos = positionMap.get(c);
+  const newPos = newPositionMap.get(c);
+  const dx = oldPos.left - newPos.left;
+  const dy = oldPos.top - newPos.top;
+  if (dx || dy) {
+    const s = c.el.style;
+    s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;
+    s.transitionDuration = "0s";
+    return c;
+  }
+}
+function hasCSSTransform(el, root, moveClass) {
+  const clone = el.cloneNode();
+  if (el._vtc) {
+    el._vtc.forEach((cls) => {
+      cls.split(/\s+/).forEach((c) => c && clone.classList.remove(c));
+    });
+  }
+  moveClass.split(/\s+/).forEach((c) => c && clone.classList.add(c));
+  clone.style.display = "none";
+  const container = root.nodeType === 1 ? root : root.parentNode;
+  container.appendChild(clone);
+  const { hasTransform } = getTransitionInfo(clone);
+  container.removeChild(clone);
+  return hasTransform;
+}
+
+const getModelAssigner = (vnode) => {
+  const fn = vnode.props["onUpdate:modelValue"] || false;
+  return isArray(fn) ? (value) => invokeArrayFns(fn, value) : fn;
+};
+function onCompositionStart(e) {
+  e.target.composing = true;
+}
+function onCompositionEnd(e) {
+  const target = e.target;
+  if (target.composing) {
+    target.composing = false;
+    target.dispatchEvent(new Event("input"));
+  }
+}
+const vModelText = {
+  created(el, { modifiers: { lazy, trim, number } }, vnode) {
+    el._assign = getModelAssigner(vnode);
+    const castToNumber = number || vnode.props && vnode.props.type === "number";
+    addEventListener(el, lazy ? "change" : "input", (e) => {
+      if (e.target.composing)
+        return;
+      let domValue = el.value;
+      if (trim) {
+        domValue = domValue.trim();
+      }
+      if (castToNumber) {
+        domValue = looseToNumber(domValue);
+      }
+      el._assign(domValue);
+    });
+    if (trim) {
+      addEventListener(el, "change", () => {
+        el.value = el.value.trim();
+      });
+    }
+    if (!lazy) {
+      addEventListener(el, "compositionstart", onCompositionStart);
+      addEventListener(el, "compositionend", onCompositionEnd);
+      addEventListener(el, "change", onCompositionEnd);
+    }
+  },
+  // set value on mounted so it's after min/max for type="range"
+  mounted(el, { value }) {
+    el.value = value == null ? "" : value;
+  },
+  beforeUpdate(el, { value, modifiers: { lazy, trim, number } }, vnode) {
+    el._assign = getModelAssigner(vnode);
+    if (el.composing)
+      return;
+    if (document.activeElement === el && el.type !== "range") {
+      if (lazy) {
+        return;
+      }
+      if (trim && el.value.trim() === value) {
+        return;
+      }
+      if ((number || el.type === "number") && looseToNumber(el.value) === value) {
+        return;
+      }
+    }
+    const newValue = value == null ? "" : value;
+    if (el.value !== newValue) {
+      el.value = newValue;
+    }
+  }
+};
+const vModelCheckbox = {
+  // #4096 array checkboxes need to be deep traversed
+  deep: true,
+  created(el, _, vnode) {
+    el._assign = getModelAssigner(vnode);
+    addEventListener(el, "change", () => {
+      const modelValue = el._modelValue;
+      const elementValue = getValue(el);
+      const checked = el.checked;
+      const assign = el._assign;
+      if (isArray(modelValue)) {
+        const index = looseIndexOf(modelValue, elementValue);
+        const found = index !== -1;
+        if (checked && !found) {
+          assign(modelValue.concat(elementValue));
+        } else if (!checked && found) {
+          const filtered = [...modelValue];
+          filtered.splice(index, 1);
+          assign(filtered);
+        }
+      } else if (isSet(modelValue)) {
+        const cloned = new Set(modelValue);
+        if (checked) {
+          cloned.add(elementValue);
+        } else {
+          cloned.delete(elementValue);
+        }
+        assign(cloned);
+      } else {
+        assign(getCheckboxValue(el, checked));
+      }
+    });
+  },
+  // set initial checked on mount to wait for true-value/false-value
+  mounted: setChecked,
+  beforeUpdate(el, binding, vnode) {
+    el._assign = getModelAssigner(vnode);
+    setChecked(el, binding, vnode);
+  }
+};
+function setChecked(el, { value, oldValue }, vnode) {
+  el._modelValue = value;
+  if (isArray(value)) {
+    el.checked = looseIndexOf(value, vnode.props.value) > -1;
+  } else if (isSet(value)) {
+    el.checked = value.has(vnode.props.value);
+  } else if (value !== oldValue) {
+    el.checked = looseEqual(value, getCheckboxValue(el, true));
+  }
+}
+const vModelRadio = {
+  created(el, { value }, vnode) {
+    el.checked = looseEqual(value, vnode.props.value);
+    el._assign = getModelAssigner(vnode);
+    addEventListener(el, "change", () => {
+      el._assign(getValue(el));
+    });
+  },
+  beforeUpdate(el, { value, oldValue }, vnode) {
+    el._assign = getModelAssigner(vnode);
+    if (value !== oldValue) {
+      el.checked = looseEqual(value, vnode.props.value);
+    }
+  }
+};
+const vModelSelect = {
+  // <select multiple> value need to be deep traversed
+  deep: true,
+  created(el, { value, modifiers: { number } }, vnode) {
+    const isSetModel = isSet(value);
+    addEventListener(el, "change", () => {
+      const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map(
+        (o) => number ? looseToNumber(getValue(o)) : getValue(o)
+      );
+      el._assign(
+        el.multiple ? isSetModel ? new Set(selectedVal) : selectedVal : selectedVal[0]
+      );
+    });
+    el._assign = getModelAssigner(vnode);
+  },
+  // set value in mounted & updated because <select> relies on its children
+  // <option>s.
+  mounted(el, { value }) {
+    setSelected(el, value);
+  },
+  beforeUpdate(el, _binding, vnode) {
+    el._assign = getModelAssigner(vnode);
+  },
+  updated(el, { value }) {
+    setSelected(el, value);
+  }
+};
+function setSelected(el, value) {
+  const isMultiple = el.multiple;
+  if (isMultiple && !isArray(value) && !isSet(value)) {
+    !!(process.env.NODE_ENV !== "production") && warn(
+      `<select multiple v-model> expects an Array or Set value for its binding, but got ${Object.prototype.toString.call(value).slice(8, -1)}.`
+    );
+    return;
+  }
+  for (let i = 0, l = el.options.length; i < l; i++) {
+    const option = el.options[i];
+    const optionValue = getValue(option);
+    if (isMultiple) {
+      if (isArray(value)) {
+        option.selected = looseIndexOf(value, optionValue) > -1;
+      } else {
+        option.selected = value.has(optionValue);
+      }
+    } else {
+      if (looseEqual(getValue(option), value)) {
+        if (el.selectedIndex !== i)
+          el.selectedIndex = i;
+        return;
+      }
+    }
+  }
+  if (!isMultiple && el.selectedIndex !== -1) {
+    el.selectedIndex = -1;
+  }
+}
+function getValue(el) {
+  return "_value" in el ? el._value : el.value;
+}
+function getCheckboxValue(el, checked) {
+  const key = checked ? "_trueValue" : "_falseValue";
+  return key in el ? el[key] : checked;
+}
+const vModelDynamic = {
+  created(el, binding, vnode) {
+    callModelHook(el, binding, vnode, null, "created");
+  },
+  mounted(el, binding, vnode) {
+    callModelHook(el, binding, vnode, null, "mounted");
+  },
+  beforeUpdate(el, binding, vnode, prevVNode) {
+    callModelHook(el, binding, vnode, prevVNode, "beforeUpdate");
+  },
+  updated(el, binding, vnode, prevVNode) {
+    callModelHook(el, binding, vnode, prevVNode, "updated");
+  }
+};
+function resolveDynamicModel(tagName, type) {
+  switch (tagName) {
+    case "SELECT":
+      return vModelSelect;
+    case "TEXTAREA":
+      return vModelText;
+    default:
+      switch (type) {
+        case "checkbox":
+          return vModelCheckbox;
+        case "radio":
+          return vModelRadio;
+        default:
+          return vModelText;
+      }
+  }
+}
+function callModelHook(el, binding, vnode, prevVNode, hook) {
+  const modelToUse = resolveDynamicModel(
+    el.tagName,
+    vnode.props && vnode.props.type
+  );
+  const fn = modelToUse[hook];
+  fn && fn(el, binding, vnode, prevVNode);
+}
+function initVModelForSSR() {
+  vModelText.getSSRProps = ({ value }) => ({ value });
+  vModelRadio.getSSRProps = ({ value }, vnode) => {
+    if (vnode.props && looseEqual(vnode.props.value, value)) {
+      return { checked: true };
+    }
+  };
+  vModelCheckbox.getSSRProps = ({ value }, vnode) => {
+    if (isArray(value)) {
+      if (vnode.props && looseIndexOf(value, vnode.props.value) > -1) {
+        return { checked: true };
+      }
+    } else if (isSet(value)) {
+      if (vnode.props && value.has(vnode.props.value)) {
+        return { checked: true };
+      }
+    } else if (value) {
+      return { checked: true };
+    }
+  };
+  vModelDynamic.getSSRProps = (binding, vnode) => {
+    if (typeof vnode.type !== "string") {
+      return;
+    }
+    const modelToUse = resolveDynamicModel(
+      // resolveDynamicModel expects an uppercase tag name, but vnode.type is lowercase
+      vnode.type.toUpperCase(),
+      vnode.props && vnode.props.type
+    );
+    if (modelToUse.getSSRProps) {
+      return modelToUse.getSSRProps(binding, vnode);
+    }
+  };
+}
+
+const systemModifiers = ["ctrl", "shift", "alt", "meta"];
+const modifierGuards = {
+  stop: (e) => e.stopPropagation(),
+  prevent: (e) => e.preventDefault(),
+  self: (e) => e.target !== e.currentTarget,
+  ctrl: (e) => !e.ctrlKey,
+  shift: (e) => !e.shiftKey,
+  alt: (e) => !e.altKey,
+  meta: (e) => !e.metaKey,
+  left: (e) => "button" in e && e.button !== 0,
+  middle: (e) => "button" in e && e.button !== 1,
+  right: (e) => "button" in e && e.button !== 2,
+  exact: (e, modifiers) => systemModifiers.some((m) => e[`${m}Key`] && !modifiers.includes(m))
+};
+const withModifiers = (fn, modifiers) => {
+  return (event, ...args) => {
+    for (let i = 0; i < modifiers.length; i++) {
+      const guard = modifierGuards[modifiers[i]];
+      if (guard && guard(event, modifiers))
+        return;
+    }
+    return fn(event, ...args);
+  };
+};
+const keyNames = {
+  esc: "escape",
+  space: " ",
+  up: "arrow-up",
+  left: "arrow-left",
+  right: "arrow-right",
+  down: "arrow-down",
+  delete: "backspace"
+};
+const withKeys = (fn, modifiers) => {
+  return (event) => {
+    if (!("key" in event)) {
+      return;
+    }
+    const eventKey = hyphenate(event.key);
+    if (modifiers.some((k) => k === eventKey || keyNames[k] === eventKey)) {
+      return fn(event);
+    }
+  };
+};
+
+const vShow = {
+  beforeMount(el, { value }, { transition }) {
+    el._vod = el.style.display === "none" ? "" : el.style.display;
+    if (transition && value) {
+      transition.beforeEnter(el);
+    } else {
+      setDisplay(el, value);
+    }
+  },
+  mounted(el, { value }, { transition }) {
+    if (transition && value) {
+      transition.enter(el);
+    }
+  },
+  updated(el, { value, oldValue }, { transition }) {
+    if (!value === !oldValue)
+      return;
+    if (transition) {
+      if (value) {
+        transition.beforeEnter(el);
+        setDisplay(el, true);
+        transition.enter(el);
+      } else {
+        transition.leave(el, () => {
+          setDisplay(el, false);
+        });
+      }
+    } else {
+      setDisplay(el, value);
+    }
+  },
+  beforeUnmount(el, { value }) {
+    setDisplay(el, value);
+  }
+};
+function setDisplay(el, value) {
+  el.style.display = value ? el._vod : "none";
+}
+function initVShowForSSR() {
+  vShow.getSSRProps = ({ value }) => {
+    if (!value) {
+      return { style: { display: "none" } };
+    }
+  };
+}
+
+const rendererOptions = /* @__PURE__ */ extend({ patchProp }, nodeOps);
+let renderer;
+let enabledHydration = false;
+function ensureRenderer() {
+  return renderer || (renderer = createRenderer(rendererOptions));
+}
+function ensureHydrationRenderer() {
+  renderer = enabledHydration ? renderer : createHydrationRenderer(rendererOptions);
+  enabledHydration = true;
+  return renderer;
+}
+const render = (...args) => {
+  ensureRenderer().render(...args);
+};
+const hydrate = (...args) => {
+  ensureHydrationRenderer().hydrate(...args);
+};
+const createApp = (...args) => {
+  const app = ensureRenderer().createApp(...args);
+  if (!!(process.env.NODE_ENV !== "production")) {
+    injectNativeTagCheck(app);
+    injectCompilerOptionsCheck(app);
+  }
+  const { mount } = app;
+  app.mount = (containerOrSelector) => {
+    const container = normalizeContainer(containerOrSelector);
+    if (!container)
+      return;
+    const component = app._component;
+    if (!isFunction(component) && !component.render && !component.template) {
+      component.template = container.innerHTML;
+    }
+    container.innerHTML = "";
+    const proxy = mount(container, false, container instanceof SVGElement);
+    if (container instanceof Element) {
+      container.removeAttribute("v-cloak");
+      container.setAttribute("data-v-app", "");
+    }
+    return proxy;
+  };
+  return app;
+};
+const createSSRApp = (...args) => {
+  const app = ensureHydrationRenderer().createApp(...args);
+  if (!!(process.env.NODE_ENV !== "production")) {
+    injectNativeTagCheck(app);
+    injectCompilerOptionsCheck(app);
+  }
+  const { mount } = app;
+  app.mount = (containerOrSelector) => {
+    const container = normalizeContainer(containerOrSelector);
+    if (container) {
+      return mount(container, true, container instanceof SVGElement);
+    }
+  };
+  return app;
+};
+function injectNativeTagCheck(app) {
+  Object.defineProperty(app.config, "isNativeTag", {
+    value: (tag) => isHTMLTag(tag) || isSVGTag(tag),
+    writable: false
+  });
+}
+function injectCompilerOptionsCheck(app) {
+  if (isRuntimeOnly()) {
+    const isCustomElement = app.config.isCustomElement;
+    Object.defineProperty(app.config, "isCustomElement", {
+      get() {
+        return isCustomElement;
+      },
+      set() {
+        warn(
+          `The \`isCustomElement\` config option is deprecated. Use \`compilerOptions.isCustomElement\` instead.`
+        );
+      }
+    });
+    const compilerOptions = app.config.compilerOptions;
+    const msg = `The \`compilerOptions\` config option is only respected when using a build of Vue.js that includes the runtime compiler (aka "full build"). Since you are using the runtime-only build, \`compilerOptions\` must be passed to \`@vue/compiler-dom\` in the build setup instead.
+- For vue-loader: pass it via vue-loader's \`compilerOptions\` loader option.
+- For vue-cli: see https://cli.vuejs.org/guide/webpack.html#modifying-options-of-a-loader
+- For vite: pass it via @vitejs/plugin-vue options. See https://github.com/vitejs/vite-plugin-vue/tree/main/packages/plugin-vue#example-for-passing-options-to-vuecompiler-sfc`;
+    Object.defineProperty(app.config, "compilerOptions", {
+      get() {
+        warn(msg);
+        return compilerOptions;
+      },
+      set() {
+        warn(msg);
+      }
+    });
+  }
+}
+function normalizeContainer(container) {
+  if (isString(container)) {
+    const res = document.querySelector(container);
+    if (!!(process.env.NODE_ENV !== "production") && !res) {
+      warn(
+        `Failed to mount app: mount target selector "${container}" returned null.`
+      );
+    }
+    return res;
+  }
+  if (!!(process.env.NODE_ENV !== "production") && window.ShadowRoot && container instanceof window.ShadowRoot && container.mode === "closed") {
+    warn(
+      `mounting on a ShadowRoot with \`{mode: "closed"}\` may lead to unpredictable bugs`
+    );
+  }
+  return container;
+}
+let ssrDirectiveInitialized = false;
+const initDirectivesForSSR = () => {
+  if (!ssrDirectiveInitialized) {
+    ssrDirectiveInitialized = true;
+    initVModelForSSR();
+    initVShowForSSR();
+  }
+} ;
+
+export { Transition, TransitionGroup, VueElement, createApp, createSSRApp, defineCustomElement, defineSSRCustomElement, hydrate, initDirectivesForSSR, render, useCssModule, useCssVars, vModelCheckbox, vModelDynamic, vModelRadio, vModelSelect, vModelText, vShow, withKeys, withModifiers };
diff --git a/parent_dir/node_modules/vue/shared/dist/shared.esm-bundler.js b/parent_dir/node_modules/vue/shared/dist/shared.esm-bundler.js
new file mode 100644
index 0000000..ecf3d06
--- /dev/null
+++ b/parent_dir/node_modules/vue/shared/dist/shared.esm-bundler.js
@@ -0,0 +1,408 @@
+function makeMap(str, expectsLowerCase) {
+  const map = /* @__PURE__ */ Object.create(null);
+  const list = str.split(",");
+  for (let i = 0; i < list.length; i++) {
+    map[list[i]] = true;
+  }
+  return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
+}
+
+const EMPTY_OBJ = !!(process.env.NODE_ENV !== "production") ? Object.freeze({}) : {};
+const EMPTY_ARR = !!(process.env.NODE_ENV !== "production") ? Object.freeze([]) : [];
+const NOOP = () => {
+};
+const NO = () => false;
+const onRE = /^on[^a-z]/;
+const isOn = (key) => onRE.test(key);
+const isModelListener = (key) => key.startsWith("onUpdate:");
+const extend = Object.assign;
+const remove = (arr, el) => {
+  const i = arr.indexOf(el);
+  if (i > -1) {
+    arr.splice(i, 1);
+  }
+};
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwn = (val, key) => hasOwnProperty.call(val, key);
+const isArray = Array.isArray;
+const isMap = (val) => toTypeString(val) === "[object Map]";
+const isSet = (val) => toTypeString(val) === "[object Set]";
+const isDate = (val) => toTypeString(val) === "[object Date]";
+const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
+const isFunction = (val) => typeof val === "function";
+const isString = (val) => typeof val === "string";
+const isSymbol = (val) => typeof val === "symbol";
+const isObject = (val) => val !== null && typeof val === "object";
+const isPromise = (val) => {
+  return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const toRawType = (value) => {
+  return toTypeString(value).slice(8, -1);
+};
+const isPlainObject = (val) => toTypeString(val) === "[object Object]";
+const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+const isReservedProp = /* @__PURE__ */ makeMap(
+  // the leading comma is intentional so empty string "" is also included
+  ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
+);
+const isBuiltInDirective = /* @__PURE__ */ makeMap(
+  "bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
+);
+const cacheStringFunction = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return (str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+};
+const camelizeRE = /-(\w)/g;
+const camelize = cacheStringFunction((str) => {
+  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+});
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cacheStringFunction(
+  (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
+);
+const capitalize = cacheStringFunction(
+  (str) => str.charAt(0).toUpperCase() + str.slice(1)
+);
+const toHandlerKey = cacheStringFunction(
+  (str) => str ? `on${capitalize(str)}` : ``
+);
+const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+const invokeArrayFns = (fns, arg) => {
+  for (let i = 0; i < fns.length; i++) {
+    fns[i](arg);
+  }
+};
+const def = (obj, key, value) => {
+  Object.defineProperty(obj, key, {
+    configurable: true,
+    enumerable: false,
+    value
+  });
+};
+const looseToNumber = (val) => {
+  const n = parseFloat(val);
+  return isNaN(n) ? val : n;
+};
+const toNumber = (val) => {
+  const n = isString(val) ? Number(val) : NaN;
+  return isNaN(n) ? val : n;
+};
+let _globalThis;
+const getGlobalThis = () => {
+  return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
+};
+const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
+function genPropsAccessExp(name) {
+  return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`;
+}
+
+const PatchFlagNames = {
+  [1]: `TEXT`,
+  [2]: `CLASS`,
+  [4]: `STYLE`,
+  [8]: `PROPS`,
+  [16]: `FULL_PROPS`,
+  [32]: `HYDRATE_EVENTS`,
+  [64]: `STABLE_FRAGMENT`,
+  [128]: `KEYED_FRAGMENT`,
+  [256]: `UNKEYED_FRAGMENT`,
+  [512]: `NEED_PATCH`,
+  [1024]: `DYNAMIC_SLOTS`,
+  [2048]: `DEV_ROOT_FRAGMENT`,
+  [-1]: `HOISTED`,
+  [-2]: `BAIL`
+};
+
+const slotFlagsText = {
+  [1]: "STABLE",
+  [2]: "DYNAMIC",
+  [3]: "FORWARDED"
+};
+
+const GLOBALS_WHITE_LISTED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console";
+const isGloballyWhitelisted = /* @__PURE__ */ makeMap(GLOBALS_WHITE_LISTED);
+
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+  let lines = source.split(/(\r?\n)/);
+  const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
+  lines = lines.filter((_, idx) => idx % 2 === 0);
+  let count = 0;
+  const res = [];
+  for (let i = 0; i < lines.length; i++) {
+    count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
+    if (count >= start) {
+      for (let j = i - range; j <= i + range || end > count; j++) {
+        if (j < 0 || j >= lines.length)
+          continue;
+        const line = j + 1;
+        res.push(
+          `${line}${" ".repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`
+        );
+        const lineLength = lines[j].length;
+        const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
+        if (j === i) {
+          const pad = start - (count - (lineLength + newLineSeqLength));
+          const length = Math.max(
+            1,
+            end > count ? lineLength - pad : end - start
+          );
+          res.push(`   |  ` + " ".repeat(pad) + "^".repeat(length));
+        } else if (j > i) {
+          if (end > count) {
+            const length = Math.max(Math.min(end - count, lineLength), 1);
+            res.push(`   |  ` + "^".repeat(length));
+          }
+          count += lineLength + newLineSeqLength;
+        }
+      }
+      break;
+    }
+  }
+  return res.join("\n");
+}
+
+function normalizeStyle(value) {
+  if (isArray(value)) {
+    const res = {};
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
+      if (normalized) {
+        for (const key in normalized) {
+          res[key] = normalized[key];
+        }
+      }
+    }
+    return res;
+  } else if (isString(value)) {
+    return value;
+  } else if (isObject(value)) {
+    return value;
+  }
+}
+const listDelimiterRE = /;(?![^(]*\))/g;
+const propertyDelimiterRE = /:([^]+)/;
+const styleCommentRE = /\/\*[^]*?\*\//g;
+function parseStringStyle(cssText) {
+  const ret = {};
+  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
+    if (item) {
+      const tmp = item.split(propertyDelimiterRE);
+      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
+    }
+  });
+  return ret;
+}
+function stringifyStyle(styles) {
+  let ret = "";
+  if (!styles || isString(styles)) {
+    return ret;
+  }
+  for (const key in styles) {
+    const value = styles[key];
+    const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
+    if (isString(value) || typeof value === "number") {
+      ret += `${normalizedKey}:${value};`;
+    }
+  }
+  return ret;
+}
+function normalizeClass(value) {
+  let res = "";
+  if (isString(value)) {
+    res = value;
+  } else if (isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const normalized = normalizeClass(value[i]);
+      if (normalized) {
+        res += normalized + " ";
+      }
+    }
+  } else if (isObject(value)) {
+    for (const name in value) {
+      if (value[name]) {
+        res += name + " ";
+      }
+    }
+  }
+  return res.trim();
+}
+function normalizeProps(props) {
+  if (!props)
+    return null;
+  let { class: klass, style } = props;
+  if (klass && !isString(klass)) {
+    props.class = normalizeClass(klass);
+  }
+  if (style) {
+    props.style = normalizeStyle(style);
+  }
+  return props;
+}
+
+const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot";
+const SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view";
+const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
+const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
+const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
+const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
+
+const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
+const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
+const isBooleanAttr = /* @__PURE__ */ makeMap(
+  specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
+);
+function includeBooleanAttr(value) {
+  return !!value || value === "";
+}
+const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/;
+const attrValidationCache = {};
+function isSSRSafeAttrName(name) {
+  if (attrValidationCache.hasOwnProperty(name)) {
+    return attrValidationCache[name];
+  }
+  const isUnsafe = unsafeAttrCharRE.test(name);
+  if (isUnsafe) {
+    console.error(`unsafe attribute name: ${name}`);
+  }
+  return attrValidationCache[name] = !isUnsafe;
+}
+const propsToAttrMap = {
+  acceptCharset: "accept-charset",
+  className: "class",
+  htmlFor: "for",
+  httpEquiv: "http-equiv"
+};
+const isKnownHtmlAttr = /* @__PURE__ */ makeMap(
+  `accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`
+);
+const isKnownSvgAttr = /* @__PURE__ */ makeMap(
+  `xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`
+);
+
+const escapeRE = /["'&<>]/;
+function escapeHtml(string) {
+  const str = "" + string;
+  const match = escapeRE.exec(str);
+  if (!match) {
+    return str;
+  }
+  let html = "";
+  let escaped;
+  let index;
+  let lastIndex = 0;
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        escaped = "&quot;";
+        break;
+      case 38:
+        escaped = "&amp;";
+        break;
+      case 39:
+        escaped = "&#39;";
+        break;
+      case 60:
+        escaped = "&lt;";
+        break;
+      case 62:
+        escaped = "&gt;";
+        break;
+      default:
+        continue;
+    }
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+    lastIndex = index + 1;
+    html += escaped;
+  }
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+}
+const commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;
+function escapeHtmlComment(src) {
+  return src.replace(commentStripRE, "");
+}
+
+function looseCompareArrays(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let equal = true;
+  for (let i = 0; equal && i < a.length; i++) {
+    equal = looseEqual(a[i], b[i]);
+  }
+  return equal;
+}
+function looseEqual(a, b) {
+  if (a === b)
+    return true;
+  let aValidType = isDate(a);
+  let bValidType = isDate(b);
+  if (aValidType || bValidType) {
+    return aValidType && bValidType ? a.getTime() === b.getTime() : false;
+  }
+  aValidType = isSymbol(a);
+  bValidType = isSymbol(b);
+  if (aValidType || bValidType) {
+    return a === b;
+  }
+  aValidType = isArray(a);
+  bValidType = isArray(b);
+  if (aValidType || bValidType) {
+    return aValidType && bValidType ? looseCompareArrays(a, b) : false;
+  }
+  aValidType = isObject(a);
+  bValidType = isObject(b);
+  if (aValidType || bValidType) {
+    if (!aValidType || !bValidType) {
+      return false;
+    }
+    const aKeysCount = Object.keys(a).length;
+    const bKeysCount = Object.keys(b).length;
+    if (aKeysCount !== bKeysCount) {
+      return false;
+    }
+    for (const key in a) {
+      const aHasKey = a.hasOwnProperty(key);
+      const bHasKey = b.hasOwnProperty(key);
+      if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+  }
+  return String(a) === String(b);
+}
+function looseIndexOf(arr, val) {
+  return arr.findIndex((item) => looseEqual(item, val));
+}
+
+const toDisplayString = (val) => {
+  return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val);
+};
+const replacer = (_key, val) => {
+  if (val && val.__v_isRef) {
+    return replacer(_key, val.value);
+  } else if (isMap(val)) {
+    return {
+      [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val2]) => {
+        entries[`${key} =>`] = val2;
+        return entries;
+      }, {})
+    };
+  } else if (isSet(val)) {
+    return {
+      [`Set(${val.size})`]: [...val.values()]
+    };
+  } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
+    return String(val);
+  }
+  return val;
+};
+
+export { EMPTY_ARR, EMPTY_OBJ, NO, NOOP, PatchFlagNames, camelize, capitalize, def, escapeHtml, escapeHtmlComment, extend, genPropsAccessExp, generateCodeFrame, getGlobalThis, hasChanged, hasOwn, hyphenate, includeBooleanAttr, invokeArrayFns, isArray, isBooleanAttr, isBuiltInDirective, isDate, isFunction, isGloballyWhitelisted, isHTMLTag, isIntegerKey, isKnownHtmlAttr, isKnownSvgAttr, isMap, isModelListener, isObject, isOn, isPlainObject, isPromise, isRegExp, isReservedProp, isSSRSafeAttrName, isSVGTag, isSet, isSpecialBooleanAttr, isString, isSymbol, isVoidTag, looseEqual, looseIndexOf, looseToNumber, makeMap, normalizeClass, normalizeProps, normalizeStyle, objectToString, parseStringStyle, propsToAttrMap, remove, slotFlagsText, stringifyStyle, toDisplayString, toHandlerKey, toNumber, toRawType, toTypeString };
diff --git a/parent_dir/node_modules/vue3-lazyload/dist/index.mjs b/parent_dir/node_modules/vue3-lazyload/dist/index.mjs
new file mode 100644
index 0000000..7c47d8a
--- /dev/null
+++ b/parent_dir/node_modules/vue3-lazyload/dist/index.mjs
@@ -0,0 +1,267 @@
+import { ref, onMounted, onUnmounted, watch } from 'vue-demi';
+
+var LifecycleEnum = /* @__PURE__ */ ((LifecycleEnum2) => {
+  LifecycleEnum2["LOADING"] = "loading";
+  LifecycleEnum2["LOADED"] = "loaded";
+  LifecycleEnum2["ERROR"] = "error";
+  return LifecycleEnum2;
+})(LifecycleEnum || {});
+
+const inBrowser = typeof window !== "undefined" && window !== null;
+const hasIntersectionObserver = checkIntersectionObserver();
+const isEnumerable = Object.prototype.propertyIsEnumerable;
+const getSymbols = Object.getOwnPropertySymbols;
+function isObject(val) {
+  return typeof val === "function" || toString.call(val) === "[object Object]";
+}
+function isPrimitive(val) {
+  return typeof val === "object" ? val === null : typeof val !== "function";
+}
+function isValidKey(key) {
+  return key !== "__proto__" && key !== "constructor" && key !== "prototype";
+}
+function checkIntersectionObserver() {
+  if (inBrowser && "IntersectionObserver" in window && "IntersectionObserverEntry" in window && "intersectionRatio" in window.IntersectionObserverEntry.prototype) {
+    if (!("isIntersecting" in window.IntersectionObserverEntry.prototype)) {
+      Object.defineProperty(window.IntersectionObserverEntry.prototype, "isIntersecting", {
+        get() {
+          return this.intersectionRatio > 0;
+        }
+      });
+    }
+    return true;
+  }
+  return false;
+}
+function assignSymbols(target, ...args) {
+  if (!isObject(target))
+    throw new TypeError("expected the first argument to be an object");
+  if (args.length === 0 || typeof Symbol !== "function" || typeof getSymbols !== "function")
+    return target;
+  for (const arg of args) {
+    const names = getSymbols(arg);
+    for (const key of names) {
+      if (isEnumerable.call(arg, key))
+        target[key] = arg[key];
+    }
+  }
+  return target;
+}
+function assign(target, ...args) {
+  let i = 0;
+  if (isPrimitive(target))
+    target = args[i++];
+  if (!target)
+    target = {};
+  for (; i < args.length; i++) {
+    if (isObject(args[i])) {
+      for (const key of Object.keys(args[i])) {
+        if (isValidKey(key)) {
+          if (isObject(target[key]) && isObject(args[i][key]))
+            assign(target[key], args[i][key]);
+          else
+            target[key] = args[i][key];
+        }
+      }
+      assignSymbols(target, args[i]);
+    }
+  }
+  return target;
+}
+
+const DEFAULT_LOADING = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
+const DEFAULT_ERROR = "";
+
+const DEFAULT_OBSERVER_OPTIONS = {
+  rootMargin: "0px",
+  threshold: 0
+};
+const TIMEOUT_ID_DATA_ATTR = "data-lazy-timeout-id";
+class Lazy {
+  constructor(options) {
+    this.options = {
+      loading: DEFAULT_LOADING,
+      error: DEFAULT_ERROR,
+      observerOptions: DEFAULT_OBSERVER_OPTIONS,
+      log: true,
+      lifecycle: {}
+    };
+    this._images = /* @__PURE__ */ new WeakMap();
+    this.config(options);
+  }
+  config(options = {}) {
+    assign(this.options, options);
+  }
+  mount(el, binding) {
+    if (!el)
+      return;
+    const { src, loading, error, lifecycle, delay } = this._valueFormatter(typeof binding === "string" ? binding : binding.value);
+    this._lifecycle(LifecycleEnum.LOADING, lifecycle, el);
+    el.setAttribute("src", loading || DEFAULT_LOADING);
+    if (!hasIntersectionObserver) {
+      this.loadImages(el, src, error, lifecycle);
+      this._log(() => {
+        throw new Error("Not support IntersectionObserver!");
+      });
+    }
+    this._initIntersectionObserver(el, src, error, lifecycle, delay);
+  }
+  update(el, binding) {
+    if (!el)
+      return;
+    this._realObserver(el)?.unobserve(el);
+    const { src, error, lifecycle, delay } = this._valueFormatter(typeof binding === "string" ? binding : binding.value);
+    this._initIntersectionObserver(el, src, error, lifecycle, delay);
+  }
+  unmount(el) {
+    if (!el)
+      return;
+    this._realObserver(el)?.unobserve(el);
+    this._images.delete(el);
+  }
+  loadImages(el, src, error, lifecycle) {
+    this._setImageSrc(el, src, error, lifecycle);
+  }
+  _setImageSrc(el, src, error, lifecycle) {
+    if (el.tagName.toLowerCase() === "img") {
+      if (src) {
+        const preSrc = el.getAttribute("src");
+        if (preSrc !== src)
+          el.setAttribute("src", src);
+      }
+      this._listenImageStatus(el, () => {
+        this._lifecycle(LifecycleEnum.LOADED, lifecycle, el);
+      }, () => {
+        el.onload = null;
+        this._lifecycle(LifecycleEnum.ERROR, lifecycle, el);
+        this._realObserver(el)?.disconnect();
+        if (error) {
+          const newImageSrc = el.getAttribute("src");
+          if (newImageSrc !== error)
+            el.setAttribute("src", error);
+        }
+        this._log(() => {
+          throw new Error(`Image failed to load!And failed src was: ${src} `);
+        });
+      });
+    } else {
+      el.style.backgroundImage = `url('${src}')`;
+    }
+  }
+  _initIntersectionObserver(el, src, error, lifecycle, delay) {
+    const observerOptions = this.options.observerOptions;
+    this._images.set(el, new IntersectionObserver((entries) => {
+      Array.prototype.forEach.call(entries, (entry) => {
+        if (delay && delay > 0)
+          this._delayedIntersectionCallback(el, entry, delay, src, error, lifecycle);
+        else
+          this._intersectionCallback(el, entry, src, error, lifecycle);
+      });
+    }, observerOptions));
+    this._realObserver(el)?.observe(el);
+  }
+  _intersectionCallback(el, entry, src, error, lifecycle) {
+    if (entry.isIntersecting) {
+      this._realObserver(el)?.unobserve(entry.target);
+      this._setImageSrc(el, src, error, lifecycle);
+    }
+  }
+  _delayedIntersectionCallback(el, entry, delay, src, error, lifecycle) {
+    if (entry.isIntersecting) {
+      if (entry.target.hasAttribute(TIMEOUT_ID_DATA_ATTR))
+        return;
+      const timeoutId = setTimeout(() => {
+        this._intersectionCallback(el, entry, src, error, lifecycle);
+        entry.target.removeAttribute(TIMEOUT_ID_DATA_ATTR);
+      }, delay);
+      entry.target.setAttribute(TIMEOUT_ID_DATA_ATTR, String(timeoutId));
+    } else {
+      if (entry.target.hasAttribute(TIMEOUT_ID_DATA_ATTR)) {
+        clearTimeout(Number(entry.target.getAttribute(TIMEOUT_ID_DATA_ATTR)));
+        entry.target.removeAttribute(TIMEOUT_ID_DATA_ATTR);
+      }
+    }
+  }
+  _listenImageStatus(image, success, error) {
+    image.onload = success;
+    image.onerror = error;
+  }
+  _valueFormatter(value) {
+    let src = value;
+    let loading = this.options.loading;
+    let error = this.options.error;
+    let lifecycle = this.options.lifecycle;
+    let delay = this.options.delay;
+    if (isObject(value)) {
+      src = value.src;
+      loading = value.loading || this.options.loading;
+      error = value.error || this.options.error;
+      lifecycle = value.lifecycle || this.options.lifecycle;
+      delay = value.delay || this.options.delay;
+    }
+    return {
+      src,
+      loading,
+      error,
+      lifecycle,
+      delay
+    };
+  }
+  _log(callback) {
+    if (this.options.log)
+      callback();
+  }
+  _lifecycle(life, lifecycle, el) {
+    switch (life) {
+      case LifecycleEnum.LOADING:
+        el?.setAttribute("lazy", LifecycleEnum.LOADING);
+        if (lifecycle?.loading)
+          lifecycle.loading(el);
+        break;
+      case LifecycleEnum.LOADED:
+        el?.setAttribute("lazy", LifecycleEnum.LOADED);
+        if (lifecycle?.loaded)
+          lifecycle.loaded(el);
+        break;
+      case LifecycleEnum.ERROR:
+        el?.setAttribute("lazy", LifecycleEnum.ERROR);
+        if (lifecycle?.error)
+          lifecycle.error(el);
+        break;
+    }
+  }
+  _realObserver(el) {
+    return this._images.get(el);
+  }
+}
+
+function useLazyload(src, options) {
+  const lazyRef = ref(null);
+  const lazy = new Lazy(options);
+  onMounted(() => {
+    lazyRef.value && lazy.mount(lazyRef.value, src.value);
+  });
+  onUnmounted(() => {
+    lazyRef.value && lazy.unmount(lazyRef.value);
+  });
+  watch(src, (newVal) => {
+    if (src.value)
+      lazy.update(lazyRef.value, newVal);
+  });
+  return lazyRef;
+}
+
+const index = {
+  install(Vue, options) {
+    const lazy = new Lazy(options);
+    Vue.config.globalProperties.$Lazyload = lazy;
+    Vue.provide("Lazyload", lazy);
+    Vue.directive("lazy", {
+      mounted: lazy.mount.bind(lazy),
+      updated: lazy.update.bind(lazy),
+      unmounted: lazy.unmount.bind(lazy)
+    });
+  }
+};
+
+export { index as default, useLazyload };
diff --git a/parent_dir/node_modules/vueuse/core/index.mjs b/parent_dir/node_modules/vueuse/core/index.mjs
new file mode 100644
index 0000000..f8ce0d6
--- /dev/null
+++ b/parent_dir/node_modules/vueuse/core/index.mjs
@@ -0,0 +1,7293 @@
+import { noop, makeDestructurable, camelize, toValue, isClient, isObject, tryOnScopeDispose, isIOS, tryOnMounted, computedWithControl, objectOmit, promiseTimeout, until, increaseWithUnit, objectEntries, createSingletonPromise, useTimeoutFn, pausableWatch, toRef, createEventHook, timestamp, pausableFilter, watchIgnorable, debounceFilter, createFilterWrapper, bypassFilter, toRefs, notNullish, useIntervalFn, containsProp, hasOwn, throttleFilter, useDebounceFn, useThrottleFn, clamp, syncRef, objectPick, tryOnUnmounted, watchWithFilter, tryOnBeforeUnmount, identity, isDef, isWorker } from '@vueuse/shared';
+export * from '@vueuse/shared';
+import { isRef, ref, shallowRef, watchEffect, computed, inject, isVue3, version, defineComponent, h, TransitionGroup, shallowReactive, Fragment, watch, getCurrentInstance, customRef, onUpdated, onMounted, readonly, nextTick, reactive, markRaw, unref, getCurrentScope, isVue2, set, del, isReadonly, onBeforeUpdate } from 'vue-demi';
+
+function computedAsync(evaluationCallback, initialState, optionsOrRef) {
+  let options;
+  if (isRef(optionsOrRef)) {
+    options = {
+      evaluating: optionsOrRef
+    };
+  } else {
+    options = optionsOrRef || {};
+  }
+  const {
+    lazy = false,
+    evaluating = void 0,
+    shallow = true,
+    onError = noop
+  } = options;
+  const started = ref(!lazy);
+  const current = shallow ? shallowRef(initialState) : ref(initialState);
+  let counter = 0;
+  watchEffect(async (onInvalidate) => {
+    if (!started.value)
+      return;
+    counter++;
+    const counterAtBeginning = counter;
+    let hasFinished = false;
+    if (evaluating) {
+      Promise.resolve().then(() => {
+        evaluating.value = true;
+      });
+    }
+    try {
+      const result = await evaluationCallback((cancelCallback) => {
+        onInvalidate(() => {
+          if (evaluating)
+            evaluating.value = false;
+          if (!hasFinished)
+            cancelCallback();
+        });
+      });
+      if (counterAtBeginning === counter)
+        current.value = result;
+    } catch (e) {
+      onError(e);
+    } finally {
+      if (evaluating && counterAtBeginning === counter)
+        evaluating.value = false;
+      hasFinished = true;
+    }
+  });
+  if (lazy) {
+    return computed(() => {
+      started.value = true;
+      return current.value;
+    });
+  } else {
+    return current;
+  }
+}
+
+function computedInject(key, options, defaultSource, treatDefaultAsFactory) {
+  let source = inject(key);
+  if (defaultSource)
+    source = inject(key, defaultSource);
+  if (treatDefaultAsFactory)
+    source = inject(key, defaultSource, treatDefaultAsFactory);
+  if (typeof options === "function") {
+    return computed((ctx) => options(source, ctx));
+  } else {
+    return computed({
+      get: (ctx) => options.get(source, ctx),
+      set: options.set
+    });
+  }
+}
+
+function createReusableTemplate(options = {}) {
+  if (!isVue3 && !version.startsWith("2.7.")) {
+    if (process.env.NODE_ENV !== "production")
+      throw new Error("[VueUse] createReusableTemplate only works in Vue 2.7 or above.");
+    return;
+  }
+  const {
+    inheritAttrs = true
+  } = options;
+  const render = shallowRef();
+  const define = /* #__PURE__ */ defineComponent({
+    setup(_, { slots }) {
+      return () => {
+        render.value = slots.default;
+      };
+    }
+  });
+  const reuse = /* #__PURE__ */ defineComponent({
+    inheritAttrs,
+    setup(_, { attrs, slots }) {
+      return () => {
+        var _a;
+        if (!render.value && process.env.NODE_ENV !== "production")
+          throw new Error("[VueUse] Failed to find the definition of reusable template");
+        const vnode = (_a = render.value) == null ? void 0 : _a.call(render, { ...keysToCamelKebabCase(attrs), $slots: slots });
+        return inheritAttrs && (vnode == null ? void 0 : vnode.length) === 1 ? vnode[0] : vnode;
+      };
+    }
+  });
+  return makeDestructurable(
+    { define, reuse },
+    [define, reuse]
+  );
+}
+function keysToCamelKebabCase(obj) {
+  const newObj = {};
+  for (const key in obj)
+    newObj[camelize(key)] = obj[key];
+  return newObj;
+}
+
+function createTemplatePromise(options = {}) {
+  if (!isVue3) {
+    if (process.env.NODE_ENV !== "production")
+      throw new Error("[VueUse] createTemplatePromise only works in Vue 3 or above.");
+    return;
+  }
+  let index = 0;
+  const instances = ref([]);
+  function create(...args) {
+    const props = shallowReactive({
+      key: index++,
+      args,
+      promise: void 0,
+      resolve: () => {
+      },
+      reject: () => {
+      },
+      isResolving: false,
+      options
+    });
+    instances.value.push(props);
+    props.promise = new Promise((_resolve, _reject) => {
+      props.resolve = (v) => {
+        props.isResolving = true;
+        return _resolve(v);
+      };
+      props.reject = _reject;
+    }).finally(() => {
+      props.promise = void 0;
+      const index2 = instances.value.indexOf(props);
+      if (index2 !== -1)
+        instances.value.splice(index2, 1);
+    });
+    return props.promise;
+  }
+  function start(...args) {
+    if (options.singleton && instances.value.length > 0)
+      return instances.value[0].promise;
+    return create(...args);
+  }
+  const component = /* #__PURE__ */ defineComponent((_, { slots }) => {
+    const renderList = () => instances.value.map((props) => {
+      var _a;
+      return h(Fragment, { key: props.key }, (_a = slots.default) == null ? void 0 : _a.call(slots, props));
+    });
+    if (options.transition)
+      return () => h(TransitionGroup, options.transition, renderList);
+    return renderList;
+  });
+  component.start = start;
+  return component;
+}
+
+function createUnrefFn(fn) {
+  return function(...args) {
+    return fn.apply(this, args.map((i) => toValue(i)));
+  };
+}
+
+function unrefElement(elRef) {
+  var _a;
+  const plain = toValue(elRef);
+  return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
+}
+
+const defaultWindow = isClient ? window : void 0;
+const defaultDocument = isClient ? window.document : void 0;
+const defaultNavigator = isClient ? window.navigator : void 0;
+const defaultLocation = isClient ? window.location : void 0;
+
+function useEventListener(...args) {
+  let target;
+  let events;
+  let listeners;
+  let options;
+  if (typeof args[0] === "string" || Array.isArray(args[0])) {
+    [events, listeners, options] = args;
+    target = defaultWindow;
+  } else {
+    [target, events, listeners, options] = args;
+  }
+  if (!target)
+    return noop;
+  if (!Array.isArray(events))
+    events = [events];
+  if (!Array.isArray(listeners))
+    listeners = [listeners];
+  const cleanups = [];
+  const cleanup = () => {
+    cleanups.forEach((fn) => fn());
+    cleanups.length = 0;
+  };
+  const register = (el, event, listener, options2) => {
+    el.addEventListener(event, listener, options2);
+    return () => el.removeEventListener(event, listener, options2);
+  };
+  const stopWatch = watch(
+    () => [unrefElement(target), toValue(options)],
+    ([el, options2]) => {
+      cleanup();
+      if (!el)
+        return;
+      const optionsClone = isObject(options2) ? { ...options2 } : options2;
+      cleanups.push(
+        ...events.flatMap((event) => {
+          return listeners.map((listener) => register(el, event, listener, optionsClone));
+        })
+      );
+    },
+    { immediate: true, flush: "post" }
+  );
+  const stop = () => {
+    stopWatch();
+    cleanup();
+  };
+  tryOnScopeDispose(stop);
+  return stop;
+}
+
+let _iOSWorkaround = false;
+function onClickOutside(target, handler, options = {}) {
+  const { window = defaultWindow, ignore = [], capture = true, detectIframe = false } = options;
+  if (!window)
+    return noop;
+  if (isIOS && !_iOSWorkaround) {
+    _iOSWorkaround = true;
+    Array.from(window.document.body.children).forEach((el) => el.addEventListener("click", noop));
+    window.document.documentElement.addEventListener("click", noop);
+  }
+  let shouldListen = true;
+  const shouldIgnore = (event) => {
+    return ignore.some((target2) => {
+      if (typeof target2 === "string") {
+        return Array.from(window.document.querySelectorAll(target2)).some((el) => el === event.target || event.composedPath().includes(el));
+      } else {
+        const el = unrefElement(target2);
+        return el && (event.target === el || event.composedPath().includes(el));
+      }
+    });
+  };
+  const listener = (event) => {
+    const el = unrefElement(target);
+    if (!el || el === event.target || event.composedPath().includes(el))
+      return;
+    if (event.detail === 0)
+      shouldListen = !shouldIgnore(event);
+    if (!shouldListen) {
+      shouldListen = true;
+      return;
+    }
+    handler(event);
+  };
+  const cleanup = [
+    useEventListener(window, "click", listener, { passive: true, capture }),
+    useEventListener(window, "pointerdown", (e) => {
+      const el = unrefElement(target);
+      shouldListen = !shouldIgnore(e) && !!(el && !e.composedPath().includes(el));
+    }, { passive: true }),
+    detectIframe && useEventListener(window, "blur", (event) => {
+      setTimeout(() => {
+        var _a;
+        const el = unrefElement(target);
+        if (((_a = window.document.activeElement) == null ? void 0 : _a.tagName) === "IFRAME" && !(el == null ? void 0 : el.contains(window.document.activeElement)))
+          handler(event);
+      }, 0);
+    })
+  ].filter(Boolean);
+  const stop = () => cleanup.forEach((fn) => fn());
+  return stop;
+}
+
+function createKeyPredicate(keyFilter) {
+  if (typeof keyFilter === "function")
+    return keyFilter;
+  else if (typeof keyFilter === "string")
+    return (event) => event.key === keyFilter;
+  else if (Array.isArray(keyFilter))
+    return (event) => keyFilter.includes(event.key);
+  return () => true;
+}
+function onKeyStroke(...args) {
+  let key;
+  let handler;
+  let options = {};
+  if (args.length === 3) {
+    key = args[0];
+    handler = args[1];
+    options = args[2];
+  } else if (args.length === 2) {
+    if (typeof args[1] === "object") {
+      key = true;
+      handler = args[0];
+      options = args[1];
+    } else {
+      key = args[0];
+      handler = args[1];
+    }
+  } else {
+    key = true;
+    handler = args[0];
+  }
+  const {
+    target = defaultWindow,
+    eventName = "keydown",
+    passive = false,
+    dedupe = false
+  } = options;
+  const predicate = createKeyPredicate(key);
+  const listener = (e) => {
+    if (e.repeat && toValue(dedupe))
+      return;
+    if (predicate(e))
+      handler(e);
+  };
+  return useEventListener(target, eventName, listener, passive);
+}
+function onKeyDown(key, handler, options = {}) {
+  return onKeyStroke(key, handler, { ...options, eventName: "keydown" });
+}
+function onKeyPressed(key, handler, options = {}) {
+  return onKeyStroke(key, handler, { ...options, eventName: "keypress" });
+}
+function onKeyUp(key, handler, options = {}) {
+  return onKeyStroke(key, handler, { ...options, eventName: "keyup" });
+}
+
+const DEFAULT_DELAY = 500;
+const DEFAULT_THRESHOLD = 10;
+function onLongPress(target, handler, options) {
+  var _a, _b;
+  const elementRef = computed(() => unrefElement(target));
+  let timeout;
+  let posStart;
+  function clear() {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = void 0;
+    }
+    posStart = void 0;
+  }
+  function onDown(ev) {
+    var _a2, _b2, _c, _d;
+    if (((_a2 = options == null ? void 0 : options.modifiers) == null ? void 0 : _a2.self) && ev.target !== elementRef.value)
+      return;
+    clear();
+    if ((_b2 = options == null ? void 0 : options.modifiers) == null ? void 0 : _b2.prevent)
+      ev.preventDefault();
+    if ((_c = options == null ? void 0 : options.modifiers) == null ? void 0 : _c.stop)
+      ev.stopPropagation();
+    posStart = {
+      x: ev.x,
+      y: ev.y
+    };
+    timeout = setTimeout(
+      () => handler(ev),
+      (_d = options == null ? void 0 : options.delay) != null ? _d : DEFAULT_DELAY
+    );
+  }
+  function onMove(ev) {
+    var _a2, _b2, _c, _d;
+    if (((_a2 = options == null ? void 0 : options.modifiers) == null ? void 0 : _a2.self) && ev.target !== elementRef.value)
+      return;
+    if (!posStart || (options == null ? void 0 : options.distanceThreshold) === false)
+      return;
+    if ((_b2 = options == null ? void 0 : options.modifiers) == null ? void 0 : _b2.prevent)
+      ev.preventDefault();
+    if ((_c = options == null ? void 0 : options.modifiers) == null ? void 0 : _c.stop)
+      ev.stopPropagation();
+    const dx = ev.x - posStart.x;
+    const dy = ev.y - posStart.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    if (distance >= ((_d = options == null ? void 0 : options.distanceThreshold) != null ? _d : DEFAULT_THRESHOLD))
+      clear();
+  }
+  const listenerOptions = {
+    capture: (_a = options == null ? void 0 : options.modifiers) == null ? void 0 : _a.capture,
+    once: (_b = options == null ? void 0 : options.modifiers) == null ? void 0 : _b.once
+  };
+  const cleanup = [
+    useEventListener(elementRef, "pointerdown", onDown, listenerOptions),
+    useEventListener(elementRef, "pointermove", onMove, listenerOptions),
+    useEventListener(elementRef, ["pointerup", "pointerleave"], clear, listenerOptions)
+  ];
+  const stop = () => cleanup.forEach((fn) => fn());
+  return stop;
+}
+
+function isFocusedElementEditable() {
+  const { activeElement, body } = document;
+  if (!activeElement)
+    return false;
+  if (activeElement === body)
+    return false;
+  switch (activeElement.tagName) {
+    case "INPUT":
+    case "TEXTAREA":
+      return true;
+  }
+  return activeElement.hasAttribute("contenteditable");
+}
+function isTypedCharValid({
+  keyCode,
+  metaKey,
+  ctrlKey,
+  altKey
+}) {
+  if (metaKey || ctrlKey || altKey)
+    return false;
+  if (keyCode >= 48 && keyCode <= 57)
+    return true;
+  if (keyCode >= 65 && keyCode <= 90)
+    return true;
+  if (keyCode >= 97 && keyCode <= 122)
+    return true;
+  return false;
+}
+function onStartTyping(callback, options = {}) {
+  const { document: document2 = defaultDocument } = options;
+  const keydown = (event) => {
+    !isFocusedElementEditable() && isTypedCharValid(event) && callback(event);
+  };
+  if (document2)
+    useEventListener(document2, "keydown", keydown, { passive: true });
+}
+
+function templateRef(key, initialValue = null) {
+  const instance = getCurrentInstance();
+  let _trigger = () => {
+  };
+  const element = customRef((track, trigger) => {
+    _trigger = trigger;
+    return {
+      get() {
+        var _a, _b;
+        track();
+        return (_b = (_a = instance == null ? void 0 : instance.proxy) == null ? void 0 : _a.$refs[key]) != null ? _b : initialValue;
+      },
+      set() {
+      }
+    };
+  });
+  tryOnMounted(_trigger);
+  onUpdated(_trigger);
+  return element;
+}
+
+function useActiveElement(options = {}) {
+  var _a;
+  const {
+    window = defaultWindow,
+    deep = true
+  } = options;
+  const document = (_a = options.document) != null ? _a : window == null ? void 0 : window.document;
+  const getDeepActiveElement = () => {
+    var _a2;
+    let element = document == null ? void 0 : document.activeElement;
+    if (deep) {
+      while (element == null ? void 0 : element.shadowRoot)
+        element = (_a2 = element == null ? void 0 : element.shadowRoot) == null ? void 0 : _a2.activeElement;
+    }
+    return element;
+  };
+  const activeElement = computedWithControl(
+    () => null,
+    () => getDeepActiveElement()
+  );
+  if (window) {
+    useEventListener(window, "blur", (event) => {
+      if (event.relatedTarget !== null)
+        return;
+      activeElement.trigger();
+    }, true);
+    useEventListener(window, "focus", activeElement.trigger, true);
+  }
+  return activeElement;
+}
+
+function useMounted() {
+  const isMounted = ref(false);
+  if (getCurrentInstance()) {
+    onMounted(() => {
+      isMounted.value = true;
+    });
+  }
+  return isMounted;
+}
+
+function useSupported(callback) {
+  const isMounted = useMounted();
+  return computed(() => {
+    isMounted.value;
+    return Boolean(callback());
+  });
+}
+
+function useRafFn(fn, options = {}) {
+  const {
+    immediate = true,
+    fpsLimit = void 0,
+    window = defaultWindow
+  } = options;
+  const isActive = ref(false);
+  const intervalLimit = fpsLimit ? 1e3 / fpsLimit : null;
+  let previousFrameTimestamp = 0;
+  let rafId = null;
+  function loop(timestamp) {
+    if (!isActive.value || !window)
+      return;
+    const delta = timestamp - (previousFrameTimestamp || timestamp);
+    if (intervalLimit && delta < intervalLimit) {
+      rafId = window.requestAnimationFrame(loop);
+      return;
+    }
+    fn({ delta, timestamp });
+    previousFrameTimestamp = timestamp;
+    rafId = window.requestAnimationFrame(loop);
+  }
+  function resume() {
+    if (!isActive.value && window) {
+      isActive.value = true;
+      rafId = window.requestAnimationFrame(loop);
+    }
+  }
+  function pause() {
+    isActive.value = false;
+    if (rafId != null && window) {
+      window.cancelAnimationFrame(rafId);
+      rafId = null;
+    }
+  }
+  if (immediate)
+    resume();
+  tryOnScopeDispose(pause);
+  return {
+    isActive: readonly(isActive),
+    pause,
+    resume
+  };
+}
+
+function useAnimate(target, keyframes, options) {
+  let config;
+  let animateOptions;
+  if (isObject(options)) {
+    config = options;
+    animateOptions = objectOmit(options, ["window", "immediate", "commitStyles", "persist", "onReady", "onError"]);
+  } else {
+    config = { duration: options };
+    animateOptions = options;
+  }
+  const {
+    window = defaultWindow,
+    immediate = true,
+    commitStyles,
+    persist,
+    playbackRate: _playbackRate = 1,
+    onReady,
+    onError = (e) => {
+      console.error(e);
+    }
+  } = config;
+  const isSupported = useSupported(() => window && HTMLElement && "animate" in HTMLElement.prototype);
+  const animate = shallowRef(void 0);
+  const store = shallowReactive({
+    startTime: null,
+    currentTime: null,
+    timeline: null,
+    playbackRate: _playbackRate,
+    pending: false,
+    playState: immediate ? "idle" : "paused",
+    replaceState: "active"
+  });
+  const pending = computed(() => store.pending);
+  const playState = computed(() => store.playState);
+  const replaceState = computed(() => store.replaceState);
+  const startTime = computed({
+    get() {
+      return store.startTime;
+    },
+    set(value) {
+      store.startTime = value;
+      if (animate.value)
+        animate.value.startTime = value;
+    }
+  });
+  const currentTime = computed({
+    get() {
+      return store.currentTime;
+    },
+    set(value) {
+      store.currentTime = value;
+      if (animate.value) {
+        animate.value.currentTime = value;
+        syncResume();
+      }
+    }
+  });
+  const timeline = computed({
+    get() {
+      return store.timeline;
+    },
+    set(value) {
+      store.timeline = value;
+      if (animate.value)
+        animate.value.timeline = value;
+    }
+  });
+  const playbackRate = computed({
+    get() {
+      return store.playbackRate;
+    },
+    set(value) {
+      store.playbackRate = value;
+      if (animate.value)
+        animate.value.playbackRate = value;
+    }
+  });
+  const play = () => {
+    if (animate.value) {
+      try {
+        animate.value.play();
+        syncResume();
+      } catch (e) {
+        syncPause();
+        onError(e);
+      }
+    } else {
+      update();
+    }
+  };
+  const pause = () => {
+    var _a;
+    try {
+      (_a = animate.value) == null ? void 0 : _a.pause();
+      syncPause();
+    } catch (e) {
+      onError(e);
+    }
+  };
+  const reverse = () => {
+    var _a;
+    !animate.value && update();
+    try {
+      (_a = animate.value) == null ? void 0 : _a.reverse();
+      syncResume();
+    } catch (e) {
+      syncPause();
+      onError(e);
+    }
+  };
+  const finish = () => {
+    var _a;
+    try {
+      (_a = animate.value) == null ? void 0 : _a.finish();
+      syncPause();
+    } catch (e) {
+      onError(e);
+    }
+  };
+  const cancel = () => {
+    var _a;
+    try {
+      (_a = animate.value) == null ? void 0 : _a.cancel();
+      syncPause();
+    } catch (e) {
+      onError(e);
+    }
+  };
+  watch(() => unrefElement(target), (el) => {
+    el && update();
+  });
+  watch(() => keyframes, (value) => {
+    !animate.value && update();
+    if (!unrefElement(target) && animate.value) {
+      animate.value.effect = new KeyframeEffect(
+        unrefElement(target),
+        toValue(value),
+        animateOptions
+      );
+    }
+  }, { deep: true });
+  tryOnMounted(() => {
+    nextTick(() => update(true));
+  });
+  tryOnScopeDispose(cancel);
+  function update(init) {
+    const el = unrefElement(target);
+    if (!isSupported.value || !el)
+      return;
+    animate.value = el.animate(toValue(keyframes), animateOptions);
+    if (commitStyles)
+      animate.value.commitStyles();
+    if (persist)
+      animate.value.persist();
+    if (_playbackRate !== 1)
+      animate.value.playbackRate = _playbackRate;
+    if (init && !immediate)
+      animate.value.pause();
+    else
+      syncResume();
+    onReady == null ? void 0 : onReady(animate.value);
+  }
+  useEventListener(animate, ["cancel", "finish", "remove"], syncPause);
+  const { resume: resumeRef, pause: pauseRef } = useRafFn(() => {
+    if (!animate.value)
+      return;
+    store.pending = animate.value.pending;
+    store.playState = animate.value.playState;
+    store.replaceState = animate.value.replaceState;
+    store.startTime = animate.value.startTime;
+    store.currentTime = animate.value.currentTime;
+    store.timeline = animate.value.timeline;
+    store.playbackRate = animate.value.playbackRate;
+  }, { immediate: false });
+  function syncResume() {
+    if (isSupported.value)
+      resumeRef();
+  }
+  function syncPause() {
+    if (isSupported.value && window)
+      window.requestAnimationFrame(pauseRef);
+  }
+  return {
+    isSupported,
+    animate,
+    // actions
+    play,
+    pause,
+    reverse,
+    finish,
+    cancel,
+    // state
+    pending,
+    playState,
+    replaceState,
+    startTime,
+    currentTime,
+    timeline,
+    playbackRate
+  };
+}
+
+function useAsyncQueue(tasks, options) {
+  const {
+    interrupt = true,
+    onError = noop,
+    onFinished = noop,
+    signal
+  } = options || {};
+  const promiseState = {
+    aborted: "aborted",
+    fulfilled: "fulfilled",
+    pending: "pending",
+    rejected: "rejected"
+  };
+  const initialResult = Array.from(Array.from({ length: tasks.length }), () => ({ state: promiseState.pending, data: null }));
+  const result = reactive(initialResult);
+  const activeIndex = ref(-1);
+  if (!tasks || tasks.length === 0) {
+    onFinished();
+    return {
+      activeIndex,
+      result
+    };
+  }
+  function updateResult(state, res) {
+    activeIndex.value++;
+    result[activeIndex.value].data = res;
+    result[activeIndex.value].state = state;
+  }
+  tasks.reduce((prev, curr) => {
+    return prev.then((prevRes) => {
+      var _a;
+      if (signal == null ? void 0 : signal.aborted) {
+        updateResult(promiseState.aborted, new Error("aborted"));
+        return;
+      }
+      if (((_a = result[activeIndex.value]) == null ? void 0 : _a.state) === promiseState.rejected && interrupt) {
+        onFinished();
+        return;
+      }
+      const done = curr(prevRes).then((currentRes) => {
+        updateResult(promiseState.fulfilled, currentRes);
+        activeIndex.value === tasks.length - 1 && onFinished();
+        return currentRes;
+      });
+      if (!signal)
+        return done;
+      return Promise.race([done, whenAborted(signal)]);
+    }).catch((e) => {
+      if (signal == null ? void 0 : signal.aborted) {
+        updateResult(promiseState.aborted, e);
+        return e;
+      }
+      updateResult(promiseState.rejected, e);
+      onError();
+      return e;
+    });
+  }, Promise.resolve());
+  return {
+    activeIndex,
+    result
+  };
+}
+function whenAborted(signal) {
+  return new Promise((resolve, reject) => {
+    const error = new Error("aborted");
+    if (signal.aborted)
+      reject(error);
+    else
+      signal.addEventListener("abort", () => reject(error), { once: true });
+  });
+}
+
+function useAsyncState(promise, initialState, options) {
+  const {
+    immediate = true,
+    delay = 0,
+    onError = noop,
+    onSuccess = noop,
+    resetOnExecute = true,
+    shallow = true,
+    throwError
+  } = options != null ? options : {};
+  const state = shallow ? shallowRef(initialState) : ref(initialState);
+  const isReady = ref(false);
+  const isLoading = ref(false);
+  const error = shallowRef(void 0);
+  async function execute(delay2 = 0, ...args) {
+    if (resetOnExecute)
+      state.value = initialState;
+    error.value = void 0;
+    isReady.value = false;
+    isLoading.value = true;
+    if (delay2 > 0)
+      await promiseTimeout(delay2);
+    const _promise = typeof promise === "function" ? promise(...args) : promise;
+    try {
+      const data = await _promise;
+      state.value = data;
+      isReady.value = true;
+      onSuccess(data);
+    } catch (e) {
+      error.value = e;
+      onError(e);
+      if (throwError)
+        throw e;
+    } finally {
+      isLoading.value = false;
+    }
+    return state.value;
+  }
+  if (immediate)
+    execute(delay);
+  const shell = {
+    state,
+    isReady,
+    isLoading,
+    error,
+    execute
+  };
+  function waitUntilIsLoaded() {
+    return new Promise((resolve, reject) => {
+      until(isLoading).toBe(false).then(() => resolve(shell)).catch(reject);
+    });
+  }
+  return {
+    ...shell,
+    then(onFulfilled, onRejected) {
+      return waitUntilIsLoaded().then(onFulfilled, onRejected);
+    }
+  };
+}
+
+const defaults = {
+  array: (v) => JSON.stringify(v),
+  object: (v) => JSON.stringify(v),
+  set: (v) => JSON.stringify(Array.from(v)),
+  map: (v) => JSON.stringify(Object.fromEntries(v)),
+  null: () => ""
+};
+function getDefaultSerialization(target) {
+  if (!target)
+    return defaults.null;
+  if (target instanceof Map)
+    return defaults.map;
+  else if (target instanceof Set)
+    return defaults.set;
+  else if (Array.isArray(target))
+    return defaults.array;
+  else
+    return defaults.object;
+}
+
+function useBase64(target, options) {
+  const base64 = ref("");
+  const promise = ref();
+  function execute() {
+    if (!isClient)
+      return;
+    promise.value = new Promise((resolve, reject) => {
+      try {
+        const _target = toValue(target);
+        if (_target == null) {
+          resolve("");
+        } else if (typeof _target === "string") {
+          resolve(blobToBase64(new Blob([_target], { type: "text/plain" })));
+        } else if (_target instanceof Blob) {
+          resolve(blobToBase64(_target));
+        } else if (_target instanceof ArrayBuffer) {
+          resolve(window.btoa(String.fromCharCode(...new Uint8Array(_target))));
+        } else if (_target instanceof HTMLCanvasElement) {
+          resolve(_target.toDataURL(options == null ? void 0 : options.type, options == null ? void 0 : options.quality));
+        } else if (_target instanceof HTMLImageElement) {
+          const img = _target.cloneNode(false);
+          img.crossOrigin = "Anonymous";
+          imgLoaded(img).then(() => {
+            const canvas = document.createElement("canvas");
+            const ctx = canvas.getContext("2d");
+            canvas.width = img.width;
+            canvas.height = img.height;
+            ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
+            resolve(canvas.toDataURL(options == null ? void 0 : options.type, options == null ? void 0 : options.quality));
+          }).catch(reject);
+        } else if (typeof _target === "object") {
+          const _serializeFn = (options == null ? void 0 : options.serializer) || getDefaultSerialization(_target);
+          const serialized = _serializeFn(_target);
+          return resolve(blobToBase64(new Blob([serialized], { type: "application/json" })));
+        } else {
+          reject(new Error("target is unsupported types"));
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+    promise.value.then((res) => base64.value = res);
+    return promise.value;
+  }
+  if (isRef(target) || typeof target === "function")
+    watch(target, execute, { immediate: true });
+  else
+    execute();
+  return {
+    base64,
+    promise,
+    execute
+  };
+}
+function imgLoaded(img) {
+  return new Promise((resolve, reject) => {
+    if (!img.complete) {
+      img.onload = () => {
+        resolve();
+      };
+      img.onerror = reject;
+    } else {
+      resolve();
+    }
+  });
+}
+function blobToBase64(blob) {
+  return new Promise((resolve, reject) => {
+    const fr = new FileReader();
+    fr.onload = (e) => {
+      resolve(e.target.result);
+    };
+    fr.onerror = reject;
+    fr.readAsDataURL(blob);
+  });
+}
+
+function useBattery(options = {}) {
+  const { navigator = defaultNavigator } = options;
+  const events = ["chargingchange", "chargingtimechange", "dischargingtimechange", "levelchange"];
+  const isSupported = useSupported(() => navigator && "getBattery" in navigator && typeof navigator.getBattery === "function");
+  const charging = ref(false);
+  const chargingTime = ref(0);
+  const dischargingTime = ref(0);
+  const level = ref(1);
+  let battery;
+  function updateBatteryInfo() {
+    charging.value = this.charging;
+    chargingTime.value = this.chargingTime || 0;
+    dischargingTime.value = this.dischargingTime || 0;
+    level.value = this.level;
+  }
+  if (isSupported.value) {
+    navigator.getBattery().then((_battery) => {
+      battery = _battery;
+      updateBatteryInfo.call(battery);
+      useEventListener(battery, events, updateBatteryInfo, { passive: true });
+    });
+  }
+  return {
+    isSupported,
+    charging,
+    chargingTime,
+    dischargingTime,
+    level
+  };
+}
+
+function useBluetooth(options) {
+  let {
+    acceptAllDevices = false
+  } = options || {};
+  const {
+    filters = void 0,
+    optionalServices = void 0,
+    navigator = defaultNavigator
+  } = options || {};
+  const isSupported = useSupported(() => navigator && "bluetooth" in navigator);
+  const device = shallowRef(void 0);
+  const error = shallowRef(null);
+  watch(device, () => {
+    connectToBluetoothGATTServer();
+  });
+  async function requestDevice() {
+    if (!isSupported.value)
+      return;
+    error.value = null;
+    if (filters && filters.length > 0)
+      acceptAllDevices = false;
+    try {
+      device.value = await (navigator == null ? void 0 : navigator.bluetooth.requestDevice({
+        acceptAllDevices,
+        filters,
+        optionalServices
+      }));
+    } catch (err) {
+      error.value = err;
+    }
+  }
+  const server = ref();
+  const isConnected = computed(() => {
+    var _a;
+    return ((_a = server.value) == null ? void 0 : _a.connected) || false;
+  });
+  async function connectToBluetoothGATTServer() {
+    error.value = null;
+    if (device.value && device.value.gatt) {
+      device.value.addEventListener("gattserverdisconnected", () => {
+      });
+      try {
+        server.value = await device.value.gatt.connect();
+      } catch (err) {
+        error.value = err;
+      }
+    }
+  }
+  tryOnMounted(() => {
+    var _a;
+    if (device.value)
+      (_a = device.value.gatt) == null ? void 0 : _a.connect();
+  });
+  tryOnScopeDispose(() => {
+    var _a;
+    if (device.value)
+      (_a = device.value.gatt) == null ? void 0 : _a.disconnect();
+  });
+  return {
+    isSupported,
+    isConnected,
+    // Device:
+    device,
+    requestDevice,
+    // Server:
+    server,
+    // Errors:
+    error
+  };
+}
+
+function useMediaQuery(query, options = {}) {
+  const { window = defaultWindow } = options;
+  const isSupported = useSupported(() => window && "matchMedia" in window && typeof window.matchMedia === "function");
+  let mediaQuery;
+  const matches = ref(false);
+  const handler = (event) => {
+    matches.value = event.matches;
+  };
+  const cleanup = () => {
+    if (!mediaQuery)
+      return;
+    if ("removeEventListener" in mediaQuery)
+      mediaQuery.removeEventListener("change", handler);
+    else
+      mediaQuery.removeListener(handler);
+  };
+  const stopWatch = watchEffect(() => {
+    if (!isSupported.value)
+      return;
+    cleanup();
+    mediaQuery = window.matchMedia(toValue(query));
+    if ("addEventListener" in mediaQuery)
+      mediaQuery.addEventListener("change", handler);
+    else
+      mediaQuery.addListener(handler);
+    matches.value = mediaQuery.matches;
+  });
+  tryOnScopeDispose(() => {
+    stopWatch();
+    cleanup();
+    mediaQuery = void 0;
+  });
+  return matches;
+}
+
+const breakpointsTailwind = {
+  "sm": 640,
+  "md": 768,
+  "lg": 1024,
+  "xl": 1280,
+  "2xl": 1536
+};
+const breakpointsBootstrapV5 = {
+  xs: 0,
+  sm: 576,
+  md: 768,
+  lg: 992,
+  xl: 1200,
+  xxl: 1400
+};
+const breakpointsVuetify = {
+  xs: 600,
+  sm: 960,
+  md: 1264,
+  lg: 1904
+};
+const breakpointsAntDesign = {
+  xs: 480,
+  sm: 576,
+  md: 768,
+  lg: 992,
+  xl: 1200,
+  xxl: 1600
+};
+const breakpointsQuasar = {
+  xs: 600,
+  sm: 1024,
+  md: 1440,
+  lg: 1920
+};
+const breakpointsSematic = {
+  mobileS: 320,
+  mobileM: 375,
+  mobileL: 425,
+  tablet: 768,
+  laptop: 1024,
+  laptopL: 1440,
+  desktop4K: 2560
+};
+const breakpointsMasterCss = {
+  "3xs": 360,
+  "2xs": 480,
+  "xs": 600,
+  "sm": 768,
+  "md": 1024,
+  "lg": 1280,
+  "xl": 1440,
+  "2xl": 1600,
+  "3xl": 1920,
+  "4xl": 2560
+};
+const breakpointsPrimeFlex = {
+  sm: 576,
+  md: 768,
+  lg: 992,
+  xl: 1200
+};
+
+function useBreakpoints(breakpoints, options = {}) {
+  function getValue(k, delta) {
+    let v = toValue(breakpoints[k]);
+    if (delta != null)
+      v = increaseWithUnit(v, delta);
+    if (typeof v === "number")
+      v = `${v}px`;
+    return v;
+  }
+  const { window = defaultWindow } = options;
+  function match(query) {
+    if (!window)
+      return false;
+    return window.matchMedia(query).matches;
+  }
+  const greaterOrEqual = (k) => {
+    return useMediaQuery(() => `(min-width: ${getValue(k)})`, options);
+  };
+  const shortcutMethods = Object.keys(breakpoints).reduce((shortcuts, k) => {
+    Object.defineProperty(shortcuts, k, {
+      get: () => greaterOrEqual(k),
+      enumerable: true,
+      configurable: true
+    });
+    return shortcuts;
+  }, {});
+  return Object.assign(shortcutMethods, {
+    greater(k) {
+      return useMediaQuery(() => `(min-width: ${getValue(k, 0.1)})`, options);
+    },
+    greaterOrEqual,
+    smaller(k) {
+      return useMediaQuery(() => `(max-width: ${getValue(k, -0.1)})`, options);
+    },
+    smallerOrEqual(k) {
+      return useMediaQuery(() => `(max-width: ${getValue(k)})`, options);
+    },
+    between(a, b) {
+      return useMediaQuery(() => `(min-width: ${getValue(a)}) and (max-width: ${getValue(b, -0.1)})`, options);
+    },
+    isGreater(k) {
+      return match(`(min-width: ${getValue(k, 0.1)})`);
+    },
+    isGreaterOrEqual(k) {
+      return match(`(min-width: ${getValue(k)})`);
+    },
+    isSmaller(k) {
+      return match(`(max-width: ${getValue(k, -0.1)})`);
+    },
+    isSmallerOrEqual(k) {
+      return match(`(max-width: ${getValue(k)})`);
+    },
+    isInBetween(a, b) {
+      return match(`(min-width: ${getValue(a)}) and (max-width: ${getValue(b, -0.1)})`);
+    },
+    current() {
+      const points = Object.keys(breakpoints).map((i) => [i, greaterOrEqual(i)]);
+      return computed(() => points.filter(([, v]) => v.value).map(([k]) => k));
+    }
+  });
+}
+
+function useBroadcastChannel(options) {
+  const {
+    name,
+    window = defaultWindow
+  } = options;
+  const isSupported = useSupported(() => window && "BroadcastChannel" in window);
+  const isClosed = ref(false);
+  const channel = ref();
+  const data = ref();
+  const error = shallowRef(null);
+  const post = (data2) => {
+    if (channel.value)
+      channel.value.postMessage(data2);
+  };
+  const close = () => {
+    if (channel.value)
+      channel.value.close();
+    isClosed.value = true;
+  };
+  if (isSupported.value) {
+    tryOnMounted(() => {
+      error.value = null;
+      channel.value = new BroadcastChannel(name);
+      channel.value.addEventListener("message", (e) => {
+        data.value = e.data;
+      }, { passive: true });
+      channel.value.addEventListener("messageerror", (e) => {
+        error.value = e;
+      }, { passive: true });
+      channel.value.addEventListener("close", () => {
+        isClosed.value = true;
+      });
+    });
+  }
+  tryOnScopeDispose(() => {
+    close();
+  });
+  return {
+    isSupported,
+    channel,
+    data,
+    post,
+    close,
+    error,
+    isClosed
+  };
+}
+
+const WRITABLE_PROPERTIES = [
+  "hash",
+  "host",
+  "hostname",
+  "href",
+  "pathname",
+  "port",
+  "protocol",
+  "search"
+];
+function useBrowserLocation(options = {}) {
+  const { window = defaultWindow } = options;
+  const refs = Object.fromEntries(
+    WRITABLE_PROPERTIES.map((key) => [key, ref()])
+  );
+  for (const [key, ref2] of objectEntries(refs)) {
+    watch(ref2, (value) => {
+      if (!(window == null ? void 0 : window.location) || window.location[key] === value)
+        return;
+      window.location[key] = value;
+    });
+  }
+  const buildState = (trigger) => {
+    var _a;
+    const { state: state2, length } = (window == null ? void 0 : window.history) || {};
+    const { origin } = (window == null ? void 0 : window.location) || {};
+    for (const key of WRITABLE_PROPERTIES)
+      refs[key].value = (_a = window == null ? void 0 : window.location) == null ? void 0 : _a[key];
+    return reactive({
+      trigger,
+      state: state2,
+      length,
+      origin,
+      ...refs
+    });
+  };
+  const state = ref(buildState("load"));
+  if (window) {
+    useEventListener(window, "popstate", () => state.value = buildState("popstate"), { passive: true });
+    useEventListener(window, "hashchange", () => state.value = buildState("hashchange"), { passive: true });
+  }
+  return state;
+}
+
+function useCached(refValue, comparator = (a, b) => a === b, watchOptions) {
+  const cachedValue = ref(refValue.value);
+  watch(() => refValue.value, (value) => {
+    if (!comparator(value, cachedValue.value))
+      cachedValue.value = value;
+  }, watchOptions);
+  return cachedValue;
+}
+
+function usePermission(permissionDesc, options = {}) {
+  const {
+    controls = false,
+    navigator = defaultNavigator
+  } = options;
+  const isSupported = useSupported(() => navigator && "permissions" in navigator);
+  let permissionStatus;
+  const desc = typeof permissionDesc === "string" ? { name: permissionDesc } : permissionDesc;
+  const state = ref();
+  const onChange = () => {
+    if (permissionStatus)
+      state.value = permissionStatus.state;
+  };
+  const query = createSingletonPromise(async () => {
+    if (!isSupported.value)
+      return;
+    if (!permissionStatus) {
+      try {
+        permissionStatus = await navigator.permissions.query(desc);
+        useEventListener(permissionStatus, "change", onChange);
+        onChange();
+      } catch (e) {
+        state.value = "prompt";
+      }
+    }
+    return permissionStatus;
+  });
+  query();
+  if (controls) {
+    return {
+      state,
+      isSupported,
+      query
+    };
+  } else {
+    return state;
+  }
+}
+
+function useClipboard(options = {}) {
+  const {
+    navigator = defaultNavigator,
+    read = false,
+    source,
+    copiedDuring = 1500,
+    legacy = false
+  } = options;
+  const isClipboardApiSupported = useSupported(() => navigator && "clipboard" in navigator);
+  const permissionRead = usePermission("clipboard-read");
+  const permissionWrite = usePermission("clipboard-write");
+  const isSupported = computed(() => isClipboardApiSupported.value || legacy);
+  const text = ref("");
+  const copied = ref(false);
+  const timeout = useTimeoutFn(() => copied.value = false, copiedDuring);
+  function updateText() {
+    if (isClipboardApiSupported.value && permissionRead.value !== "denied") {
+      navigator.clipboard.readText().then((value) => {
+        text.value = value;
+      });
+    } else {
+      text.value = legacyRead();
+    }
+  }
+  if (isSupported.value && read)
+    useEventListener(["copy", "cut"], updateText);
+  async function copy(value = toValue(source)) {
+    if (isSupported.value && value != null) {
+      if (isClipboardApiSupported.value && permissionWrite.value !== "denied")
+        await navigator.clipboard.writeText(value);
+      else
+        legacyCopy(value);
+      text.value = value;
+      copied.value = true;
+      timeout.start();
+    }
+  }
+  function legacyCopy(value) {
+    const ta = document.createElement("textarea");
+    ta.value = value != null ? value : "";
+    ta.style.position = "absolute";
+    ta.style.opacity = "0";
+    document.body.appendChild(ta);
+    ta.select();
+    document.execCommand("copy");
+    ta.remove();
+  }
+  function legacyRead() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = document == null ? void 0 : document.getSelection) == null ? void 0 : _a.call(document)) == null ? void 0 : _b.toString()) != null ? _c : "";
+  }
+  return {
+    isSupported,
+    text,
+    copied,
+    copy
+  };
+}
+
+function useClipboardItems(options = {}) {
+  const {
+    navigator = defaultNavigator,
+    read = false,
+    source,
+    copiedDuring = 1500
+  } = options;
+  const isSupported = useSupported(() => navigator && "clipboard" in navigator);
+  const content = ref([]);
+  const copied = ref(false);
+  const timeout = useTimeoutFn(() => copied.value = false, copiedDuring);
+  function updateContent() {
+    if (isSupported.value) {
+      navigator.clipboard.read().then((items) => {
+        content.value = items;
+      });
+    }
+  }
+  if (isSupported.value && read)
+    useEventListener(["copy", "cut"], updateContent);
+  async function copy(value = toValue(source)) {
+    if (isSupported.value && value != null) {
+      await navigator.clipboard.write(value);
+      content.value = value;
+      copied.value = true;
+      timeout.start();
+    }
+  }
+  return {
+    isSupported,
+    content,
+    copied,
+    copy
+  };
+}
+
+function cloneFnJSON(source) {
+  return JSON.parse(JSON.stringify(source));
+}
+function useCloned(source, options = {}) {
+  const cloned = ref({});
+  const {
+    manual,
+    clone = cloneFnJSON,
+    // watch options
+    deep = true,
+    immediate = true
+  } = options;
+  function sync() {
+    cloned.value = clone(toValue(source));
+  }
+  if (!manual && (isRef(source) || typeof source === "function")) {
+    watch(source, sync, {
+      ...options,
+      deep,
+      immediate
+    });
+  } else {
+    sync();
+  }
+  return { cloned, sync };
+}
+
+const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+const globalKey = "__vueuse_ssr_handlers__";
+const handlers = /* @__PURE__ */ getHandlers();
+function getHandlers() {
+  if (!(globalKey in _global))
+    _global[globalKey] = _global[globalKey] || {};
+  return _global[globalKey];
+}
+function getSSRHandler(key, fallback) {
+  return handlers[key] || fallback;
+}
+function setSSRHandler(key, fn) {
+  handlers[key] = fn;
+}
+
+function guessSerializerType(rawInit) {
+  return rawInit == null ? "any" : rawInit instanceof Set ? "set" : rawInit instanceof Map ? "map" : rawInit instanceof Date ? "date" : typeof rawInit === "boolean" ? "boolean" : typeof rawInit === "string" ? "string" : typeof rawInit === "object" ? "object" : !Number.isNaN(rawInit) ? "number" : "any";
+}
+
+const StorageSerializers = {
+  boolean: {
+    read: (v) => v === "true",
+    write: (v) => String(v)
+  },
+  object: {
+    read: (v) => JSON.parse(v),
+    write: (v) => JSON.stringify(v)
+  },
+  number: {
+    read: (v) => Number.parseFloat(v),
+    write: (v) => String(v)
+  },
+  any: {
+    read: (v) => v,
+    write: (v) => String(v)
+  },
+  string: {
+    read: (v) => v,
+    write: (v) => String(v)
+  },
+  map: {
+    read: (v) => new Map(JSON.parse(v)),
+    write: (v) => JSON.stringify(Array.from(v.entries()))
+  },
+  set: {
+    read: (v) => new Set(JSON.parse(v)),
+    write: (v) => JSON.stringify(Array.from(v))
+  },
+  date: {
+    read: (v) => new Date(v),
+    write: (v) => v.toISOString()
+  }
+};
+const customStorageEventName = "vueuse-storage";
+function useStorage(key, defaults, storage, options = {}) {
+  var _a;
+  const {
+    flush = "pre",
+    deep = true,
+    listenToStorageChanges = true,
+    writeDefaults = true,
+    mergeDefaults = false,
+    shallow,
+    window = defaultWindow,
+    eventFilter,
+    onError = (e) => {
+      console.error(e);
+    },
+    initOnMounted
+  } = options;
+  const data = (shallow ? shallowRef : ref)(typeof defaults === "function" ? defaults() : defaults);
+  if (!storage) {
+    try {
+      storage = getSSRHandler("getDefaultStorage", () => {
+        var _a2;
+        return (_a2 = defaultWindow) == null ? void 0 : _a2.localStorage;
+      })();
+    } catch (e) {
+      onError(e);
+    }
+  }
+  if (!storage)
+    return data;
+  const rawInit = toValue(defaults);
+  const type = guessSerializerType(rawInit);
+  const serializer = (_a = options.serializer) != null ? _a : StorageSerializers[type];
+  const { pause: pauseWatch, resume: resumeWatch } = pausableWatch(
+    data,
+    () => write(data.value),
+    { flush, deep, eventFilter }
+  );
+  if (window && listenToStorageChanges) {
+    tryOnMounted(() => {
+      useEventListener(window, "storage", update);
+      useEventListener(window, customStorageEventName, updateFromCustomEvent);
+      if (initOnMounted)
+        update();
+    });
+  }
+  if (!initOnMounted)
+    update();
+  return data;
+  function write(v) {
+    try {
+      if (v == null) {
+        storage.removeItem(key);
+      } else {
+        const serialized = serializer.write(v);
+        const oldValue = storage.getItem(key);
+        if (oldValue !== serialized) {
+          storage.setItem(key, serialized);
+          if (window) {
+            window.dispatchEvent(new CustomEvent(customStorageEventName, {
+              detail: {
+                key,
+                oldValue,
+                newValue: serialized,
+                storageArea: storage
+              }
+            }));
+          }
+        }
+      }
+    } catch (e) {
+      onError(e);
+    }
+  }
+  function read(event) {
+    const rawValue = event ? event.newValue : storage.getItem(key);
+    if (rawValue == null) {
+      if (writeDefaults && rawInit != null)
+        storage.setItem(key, serializer.write(rawInit));
+      return rawInit;
+    } else if (!event && mergeDefaults) {
+      const value = serializer.read(rawValue);
+      if (typeof mergeDefaults === "function")
+        return mergeDefaults(value, rawInit);
+      else if (type === "object" && !Array.isArray(value))
+        return { ...rawInit, ...value };
+      return value;
+    } else if (typeof rawValue !== "string") {
+      return rawValue;
+    } else {
+      return serializer.read(rawValue);
+    }
+  }
+  function updateFromCustomEvent(event) {
+    update(event.detail);
+  }
+  function update(event) {
+    if (event && event.storageArea !== storage)
+      return;
+    if (event && event.key == null) {
+      data.value = rawInit;
+      return;
+    }
+    if (event && event.key !== key)
+      return;
+    pauseWatch();
+    try {
+      if ((event == null ? void 0 : event.newValue) !== serializer.write(data.value))
+        data.value = read(event);
+    } catch (e) {
+      onError(e);
+    } finally {
+      if (event)
+        nextTick(resumeWatch);
+      else
+        resumeWatch();
+    }
+  }
+}
+
+function usePreferredDark(options) {
+  return useMediaQuery("(prefers-color-scheme: dark)", options);
+}
+
+function useColorMode(options = {}) {
+  const {
+    selector = "html",
+    attribute = "class",
+    initialValue = "auto",
+    window = defaultWindow,
+    storage,
+    storageKey = "vueuse-color-scheme",
+    listenToStorageChanges = true,
+    storageRef,
+    emitAuto,
+    disableTransition = true
+  } = options;
+  const modes = {
+    auto: "",
+    light: "light",
+    dark: "dark",
+    ...options.modes || {}
+  };
+  const preferredDark = usePreferredDark({ window });
+  const system = computed(() => preferredDark.value ? "dark" : "light");
+  const store = storageRef || (storageKey == null ? toRef(initialValue) : useStorage(storageKey, initialValue, storage, { window, listenToStorageChanges }));
+  const state = computed(() => store.value === "auto" ? system.value : store.value);
+  const updateHTMLAttrs = getSSRHandler(
+    "updateHTMLAttrs",
+    (selector2, attribute2, value) => {
+      const el = typeof selector2 === "string" ? window == null ? void 0 : window.document.querySelector(selector2) : unrefElement(selector2);
+      if (!el)
+        return;
+      let style;
+      if (disableTransition) {
+        style = window.document.createElement("style");
+        const styleString = "*,*::before,*::after{-webkit-transition:none!important;-moz-transition:none!important;-o-transition:none!important;-ms-transition:none!important;transition:none!important}";
+        style.appendChild(document.createTextNode(styleString));
+        window.document.head.appendChild(style);
+      }
+      if (attribute2 === "class") {
+        const current = value.split(/\s/g);
+        Object.values(modes).flatMap((i) => (i || "").split(/\s/g)).filter(Boolean).forEach((v) => {
+          if (current.includes(v))
+            el.classList.add(v);
+          else
+            el.classList.remove(v);
+        });
+      } else {
+        el.setAttribute(attribute2, value);
+      }
+      if (disableTransition) {
+        window.getComputedStyle(style).opacity;
+        document.head.removeChild(style);
+      }
+    }
+  );
+  function defaultOnChanged(mode) {
+    var _a;
+    updateHTMLAttrs(selector, attribute, (_a = modes[mode]) != null ? _a : mode);
+  }
+  function onChanged(mode) {
+    if (options.onChanged)
+      options.onChanged(mode, defaultOnChanged);
+    else
+      defaultOnChanged(mode);
+  }
+  watch(state, onChanged, { flush: "post", immediate: true });
+  tryOnMounted(() => onChanged(state.value));
+  const auto = computed({
+    get() {
+      return emitAuto ? store.value : state.value;
+    },
+    set(v) {
+      store.value = v;
+    }
+  });
+  try {
+    return Object.assign(auto, { store, system, state });
+  } catch (e) {
+    return auto;
+  }
+}
+
+function useConfirmDialog(revealed = ref(false)) {
+  const confirmHook = createEventHook();
+  const cancelHook = createEventHook();
+  const revealHook = createEventHook();
+  let _resolve = noop;
+  const reveal = (data) => {
+    revealHook.trigger(data);
+    revealed.value = true;
+    return new Promise((resolve) => {
+      _resolve = resolve;
+    });
+  };
+  const confirm = (data) => {
+    revealed.value = false;
+    confirmHook.trigger(data);
+    _resolve({ data, isCanceled: false });
+  };
+  const cancel = (data) => {
+    revealed.value = false;
+    cancelHook.trigger(data);
+    _resolve({ data, isCanceled: true });
+  };
+  return {
+    isRevealed: computed(() => revealed.value),
+    reveal,
+    confirm,
+    cancel,
+    onReveal: revealHook.on,
+    onConfirm: confirmHook.on,
+    onCancel: cancelHook.on
+  };
+}
+
+function useMutationObserver(target, callback, options = {}) {
+  const { window = defaultWindow, ...mutationOptions } = options;
+  let observer;
+  const isSupported = useSupported(() => window && "MutationObserver" in window);
+  const cleanup = () => {
+    if (observer) {
+      observer.disconnect();
+      observer = void 0;
+    }
+  };
+  const stopWatch = watch(
+    () => unrefElement(target),
+    (el) => {
+      cleanup();
+      if (isSupported.value && window && el) {
+        observer = new MutationObserver(callback);
+        observer.observe(el, mutationOptions);
+      }
+    },
+    { immediate: true }
+  );
+  const takeRecords = () => {
+    return observer == null ? void 0 : observer.takeRecords();
+  };
+  const stop = () => {
+    cleanup();
+    stopWatch();
+  };
+  tryOnScopeDispose(stop);
+  return {
+    isSupported,
+    stop,
+    takeRecords
+  };
+}
+
+function useCssVar(prop, target, options = {}) {
+  const { window = defaultWindow, initialValue = "", observe = false } = options;
+  const variable = ref(initialValue);
+  const elRef = computed(() => {
+    var _a;
+    return unrefElement(target) || ((_a = window == null ? void 0 : window.document) == null ? void 0 : _a.documentElement);
+  });
+  function updateCssVar() {
+    var _a;
+    const key = toValue(prop);
+    const el = toValue(elRef);
+    if (el && window) {
+      const value = (_a = window.getComputedStyle(el).getPropertyValue(key)) == null ? void 0 : _a.trim();
+      variable.value = value || initialValue;
+    }
+  }
+  if (observe) {
+    useMutationObserver(elRef, updateCssVar, {
+      attributeFilter: ["style", "class"],
+      window
+    });
+  }
+  watch(
+    [elRef, () => toValue(prop)],
+    updateCssVar,
+    { immediate: true }
+  );
+  watch(
+    variable,
+    (val) => {
+      var _a;
+      if ((_a = elRef.value) == null ? void 0 : _a.style)
+        elRef.value.style.setProperty(toValue(prop), val);
+    }
+  );
+  return variable;
+}
+
+function useCurrentElement() {
+  const vm = getCurrentInstance();
+  const currentElement = computedWithControl(
+    () => null,
+    () => vm.proxy.$el
+  );
+  onUpdated(currentElement.trigger);
+  onMounted(currentElement.trigger);
+  return currentElement;
+}
+
+function useCycleList(list, options) {
+  const state = shallowRef(getInitialValue());
+  const listRef = toRef(list);
+  const index = computed({
+    get() {
+      var _a;
+      const targetList = listRef.value;
+      let index2 = (options == null ? void 0 : options.getIndexOf) ? options.getIndexOf(state.value, targetList) : targetList.indexOf(state.value);
+      if (index2 < 0)
+        index2 = (_a = options == null ? void 0 : options.fallbackIndex) != null ? _a : 0;
+      return index2;
+    },
+    set(v) {
+      set(v);
+    }
+  });
+  function set(i) {
+    const targetList = listRef.value;
+    const length = targetList.length;
+    const index2 = (i % length + length) % length;
+    const value = targetList[index2];
+    state.value = value;
+    return value;
+  }
+  function shift(delta = 1) {
+    return set(index.value + delta);
+  }
+  function next(n = 1) {
+    return shift(n);
+  }
+  function prev(n = 1) {
+    return shift(-n);
+  }
+  function getInitialValue() {
+    var _a, _b;
+    return (_b = toValue((_a = options == null ? void 0 : options.initialValue) != null ? _a : toValue(list)[0])) != null ? _b : void 0;
+  }
+  watch(listRef, () => set(index.value));
+  return {
+    state,
+    index,
+    next,
+    prev
+  };
+}
+
+function useDark(options = {}) {
+  const {
+    valueDark = "dark",
+    valueLight = "",
+    window = defaultWindow
+  } = options;
+  const mode = useColorMode({
+    ...options,
+    onChanged: (mode2, defaultHandler) => {
+      var _a;
+      if (options.onChanged)
+        (_a = options.onChanged) == null ? void 0 : _a.call(options, mode2 === "dark", defaultHandler, mode2);
+      else
+        defaultHandler(mode2);
+    },
+    modes: {
+      dark: valueDark,
+      light: valueLight
+    }
+  });
+  const system = computed(() => {
+    if (mode.system) {
+      return mode.system.value;
+    } else {
+      const preferredDark = usePreferredDark({ window });
+      return preferredDark.value ? "dark" : "light";
+    }
+  });
+  const isDark = computed({
+    get() {
+      return mode.value === "dark";
+    },
+    set(v) {
+      const modeVal = v ? "dark" : "light";
+      if (system.value === modeVal)
+        mode.value = "auto";
+      else
+        mode.value = modeVal;
+    }
+  });
+  return isDark;
+}
+
+function fnBypass(v) {
+  return v;
+}
+function fnSetSource(source, value) {
+  return source.value = value;
+}
+function defaultDump(clone) {
+  return clone ? typeof clone === "function" ? clone : cloneFnJSON : fnBypass;
+}
+function defaultParse(clone) {
+  return clone ? typeof clone === "function" ? clone : cloneFnJSON : fnBypass;
+}
+function useManualRefHistory(source, options = {}) {
+  const {
+    clone = false,
+    dump = defaultDump(clone),
+    parse = defaultParse(clone),
+    setSource = fnSetSource
+  } = options;
+  function _createHistoryRecord() {
+    return markRaw({
+      snapshot: dump(source.value),
+      timestamp: timestamp()
+    });
+  }
+  const last = ref(_createHistoryRecord());
+  const undoStack = ref([]);
+  const redoStack = ref([]);
+  const _setSource = (record) => {
+    setSource(source, parse(record.snapshot));
+    last.value = record;
+  };
+  const commit = () => {
+    undoStack.value.unshift(last.value);
+    last.value = _createHistoryRecord();
+    if (options.capacity && undoStack.value.length > options.capacity)
+      undoStack.value.splice(options.capacity, Number.POSITIVE_INFINITY);
+    if (redoStack.value.length)
+      redoStack.value.splice(0, redoStack.value.length);
+  };
+  const clear = () => {
+    undoStack.value.splice(0, undoStack.value.length);
+    redoStack.value.splice(0, redoStack.value.length);
+  };
+  const undo = () => {
+    const state = undoStack.value.shift();
+    if (state) {
+      redoStack.value.unshift(last.value);
+      _setSource(state);
+    }
+  };
+  const redo = () => {
+    const state = redoStack.value.shift();
+    if (state) {
+      undoStack.value.unshift(last.value);
+      _setSource(state);
+    }
+  };
+  const reset = () => {
+    _setSource(last.value);
+  };
+  const history = computed(() => [last.value, ...undoStack.value]);
+  const canUndo = computed(() => undoStack.value.length > 0);
+  const canRedo = computed(() => redoStack.value.length > 0);
+  return {
+    source,
+    undoStack,
+    redoStack,
+    last,
+    history,
+    canUndo,
+    canRedo,
+    clear,
+    commit,
+    reset,
+    undo,
+    redo
+  };
+}
+
+function useRefHistory(source, options = {}) {
+  const {
+    deep = false,
+    flush = "pre",
+    eventFilter
+  } = options;
+  const {
+    eventFilter: composedFilter,
+    pause,
+    resume: resumeTracking,
+    isActive: isTracking
+  } = pausableFilter(eventFilter);
+  const {
+    ignoreUpdates,
+    ignorePrevAsyncUpdates,
+    stop
+  } = watchIgnorable(
+    source,
+    commit,
+    { deep, flush, eventFilter: composedFilter }
+  );
+  function setSource(source2, value) {
+    ignorePrevAsyncUpdates();
+    ignoreUpdates(() => {
+      source2.value = value;
+    });
+  }
+  const manualHistory = useManualRefHistory(source, { ...options, clone: options.clone || deep, setSource });
+  const { clear, commit: manualCommit } = manualHistory;
+  function commit() {
+    ignorePrevAsyncUpdates();
+    manualCommit();
+  }
+  function resume(commitNow) {
+    resumeTracking();
+    if (commitNow)
+      commit();
+  }
+  function batch(fn) {
+    let canceled = false;
+    const cancel = () => canceled = true;
+    ignoreUpdates(() => {
+      fn(cancel);
+    });
+    if (!canceled)
+      commit();
+  }
+  function dispose() {
+    stop();
+    clear();
+  }
+  return {
+    ...manualHistory,
+    isTracking,
+    pause,
+    resume,
+    commit,
+    batch,
+    dispose
+  };
+}
+
+function useDebouncedRefHistory(source, options = {}) {
+  const filter = options.debounce ? debounceFilter(options.debounce) : void 0;
+  const history = useRefHistory(source, { ...options, eventFilter: filter });
+  return {
+    ...history
+  };
+}
+
+function useDeviceMotion(options = {}) {
+  const {
+    window = defaultWindow,
+    eventFilter = bypassFilter
+  } = options;
+  const acceleration = ref({ x: null, y: null, z: null });
+  const rotationRate = ref({ alpha: null, beta: null, gamma: null });
+  const interval = ref(0);
+  const accelerationIncludingGravity = ref({
+    x: null,
+    y: null,
+    z: null
+  });
+  if (window) {
+    const onDeviceMotion = createFilterWrapper(
+      eventFilter,
+      (event) => {
+        acceleration.value = event.acceleration;
+        accelerationIncludingGravity.value = event.accelerationIncludingGravity;
+        rotationRate.value = event.rotationRate;
+        interval.value = event.interval;
+      }
+    );
+    useEventListener(window, "devicemotion", onDeviceMotion);
+  }
+  return {
+    acceleration,
+    accelerationIncludingGravity,
+    rotationRate,
+    interval
+  };
+}
+
+function useDeviceOrientation(options = {}) {
+  const { window = defaultWindow } = options;
+  const isSupported = useSupported(() => window && "DeviceOrientationEvent" in window);
+  const isAbsolute = ref(false);
+  const alpha = ref(null);
+  const beta = ref(null);
+  const gamma = ref(null);
+  if (window && isSupported.value) {
+    useEventListener(window, "deviceorientation", (event) => {
+      isAbsolute.value = event.absolute;
+      alpha.value = event.alpha;
+      beta.value = event.beta;
+      gamma.value = event.gamma;
+    });
+  }
+  return {
+    isSupported,
+    isAbsolute,
+    alpha,
+    beta,
+    gamma
+  };
+}
+
+function useDevicePixelRatio(options = {}) {
+  const {
+    window = defaultWindow
+  } = options;
+  const pixelRatio = ref(1);
+  if (window) {
+    let observe2 = function() {
+      pixelRatio.value = window.devicePixelRatio;
+      cleanup2();
+      media = window.matchMedia(`(resolution: ${pixelRatio.value}dppx)`);
+      media.addEventListener("change", observe2, { once: true });
+    }, cleanup2 = function() {
+      media == null ? void 0 : media.removeEventListener("change", observe2);
+    };
+    let media;
+    observe2();
+    tryOnScopeDispose(cleanup2);
+  }
+  return { pixelRatio };
+}
+
+function useDevicesList(options = {}) {
+  const {
+    navigator = defaultNavigator,
+    requestPermissions = false,
+    constraints = { audio: true, video: true },
+    onUpdated
+  } = options;
+  const devices = ref([]);
+  const videoInputs = computed(() => devices.value.filter((i) => i.kind === "videoinput"));
+  const audioInputs = computed(() => devices.value.filter((i) => i.kind === "audioinput"));
+  const audioOutputs = computed(() => devices.value.filter((i) => i.kind === "audiooutput"));
+  const isSupported = useSupported(() => navigator && navigator.mediaDevices && navigator.mediaDevices.enumerateDevices);
+  const permissionGranted = ref(false);
+  let stream;
+  async function update() {
+    if (!isSupported.value)
+      return;
+    devices.value = await navigator.mediaDevices.enumerateDevices();
+    onUpdated == null ? void 0 : onUpdated(devices.value);
+    if (stream) {
+      stream.getTracks().forEach((t) => t.stop());
+      stream = null;
+    }
+  }
+  async function ensurePermissions() {
+    if (!isSupported.value)
+      return false;
+    if (permissionGranted.value)
+      return true;
+    const { state, query } = usePermission("camera", { controls: true });
+    await query();
+    if (state.value !== "granted") {
+      stream = await navigator.mediaDevices.getUserMedia(constraints);
+      update();
+      permissionGranted.value = true;
+    } else {
+      permissionGranted.value = true;
+    }
+    return permissionGranted.value;
+  }
+  if (isSupported.value) {
+    if (requestPermissions)
+      ensurePermissions();
+    useEventListener(navigator.mediaDevices, "devicechange", update);
+    update();
+  }
+  return {
+    devices,
+    ensurePermissions,
+    permissionGranted,
+    videoInputs,
+    audioInputs,
+    audioOutputs,
+    isSupported
+  };
+}
+
+function useDisplayMedia(options = {}) {
+  var _a;
+  const enabled = ref((_a = options.enabled) != null ? _a : false);
+  const video = options.video;
+  const audio = options.audio;
+  const { navigator = defaultNavigator } = options;
+  const isSupported = useSupported(() => {
+    var _a2;
+    return (_a2 = navigator == null ? void 0 : navigator.mediaDevices) == null ? void 0 : _a2.getDisplayMedia;
+  });
+  const constraint = { audio, video };
+  const stream = shallowRef();
+  async function _start() {
+    if (!isSupported.value || stream.value)
+      return;
+    stream.value = await navigator.mediaDevices.getDisplayMedia(constraint);
+    return stream.value;
+  }
+  async function _stop() {
+    var _a2;
+    (_a2 = stream.value) == null ? void 0 : _a2.getTracks().forEach((t) => t.stop());
+    stream.value = void 0;
+  }
+  function stop() {
+    _stop();
+    enabled.value = false;
+  }
+  async function start() {
+    await _start();
+    if (stream.value)
+      enabled.value = true;
+    return stream.value;
+  }
+  watch(
+    enabled,
+    (v) => {
+      if (v)
+        _start();
+      else
+        _stop();
+    },
+    { immediate: true }
+  );
+  return {
+    isSupported,
+    stream,
+    start,
+    stop,
+    enabled
+  };
+}
+
+function useDocumentVisibility(options = {}) {
+  const { document = defaultDocument } = options;
+  if (!document)
+    return ref("visible");
+  const visibility = ref(document.visibilityState);
+  useEventListener(document, "visibilitychange", () => {
+    visibility.value = document.visibilityState;
+  });
+  return visibility;
+}
+
+function useDraggable(target, options = {}) {
+  var _a, _b;
+  const {
+    pointerTypes,
+    preventDefault,
+    stopPropagation,
+    exact,
+    onMove,
+    onEnd,
+    onStart,
+    initialValue,
+    axis = "both",
+    draggingElement = defaultWindow,
+    containerElement,
+    handle: draggingHandle = target
+  } = options;
+  const position = ref(
+    (_a = toValue(initialValue)) != null ? _a : { x: 0, y: 0 }
+  );
+  const pressedDelta = ref();
+  const filterEvent = (e) => {
+    if (pointerTypes)
+      return pointerTypes.includes(e.pointerType);
+    return true;
+  };
+  const handleEvent = (e) => {
+    if (toValue(preventDefault))
+      e.preventDefault();
+    if (toValue(stopPropagation))
+      e.stopPropagation();
+  };
+  const start = (e) => {
+    var _a2;
+    if (!filterEvent(e))
+      return;
+    if (toValue(exact) && e.target !== toValue(target))
+      return;
+    const container = toValue(containerElement);
+    const containerRect = (_a2 = container == null ? void 0 : container.getBoundingClientRect) == null ? void 0 : _a2.call(container);
+    const targetRect = toValue(target).getBoundingClientRect();
+    const pos = {
+      x: e.clientX - (container ? targetRect.left - containerRect.left + container.scrollLeft : targetRect.left),
+      y: e.clientY - (container ? targetRect.top - containerRect.top + container.scrollTop : targetRect.top)
+    };
+    if ((onStart == null ? void 0 : onStart(pos, e)) === false)
+      return;
+    pressedDelta.value = pos;
+    handleEvent(e);
+  };
+  const move = (e) => {
+    var _a2;
+    if (!filterEvent(e))
+      return;
+    if (!pressedDelta.value)
+      return;
+    const container = toValue(containerElement);
+    const containerRect = (_a2 = container == null ? void 0 : container.getBoundingClientRect) == null ? void 0 : _a2.call(container);
+    const targetRect = toValue(target).getBoundingClientRect();
+    let { x, y } = position.value;
+    if (axis === "x" || axis === "both") {
+      x = e.clientX - pressedDelta.value.x;
+      if (container)
+        x = Math.min(Math.max(0, x), containerRect.width + container.scrollLeft - targetRect.width);
+    }
+    if (axis === "y" || axis === "both") {
+      y = e.clientY - pressedDelta.value.y;
+      if (container)
+        y = Math.min(Math.max(0, y), containerRect.height + container.scrollTop - targetRect.height);
+    }
+    position.value = {
+      x,
+      y
+    };
+    onMove == null ? void 0 : onMove(position.value, e);
+    handleEvent(e);
+  };
+  const end = (e) => {
+    if (!filterEvent(e))
+      return;
+    if (!pressedDelta.value)
+      return;
+    pressedDelta.value = void 0;
+    onEnd == null ? void 0 : onEnd(position.value, e);
+    handleEvent(e);
+  };
+  if (isClient) {
+    const config = { capture: (_b = options.capture) != null ? _b : true };
+    useEventListener(draggingHandle, "pointerdown", start, config);
+    useEventListener(draggingElement, "pointermove", move, config);
+    useEventListener(draggingElement, "pointerup", end, config);
+  }
+  return {
+    ...toRefs(position),
+    position,
+    isDragging: computed(() => !!pressedDelta.value),
+    style: computed(
+      () => `left:${position.value.x}px;top:${position.value.y}px;`
+    )
+  };
+}
+
+function useDropZone(target, options = {}) {
+  const isOverDropZone = ref(false);
+  const files = shallowRef(null);
+  let counter = 0;
+  let isDataTypeIncluded = true;
+  if (isClient) {
+    const _options = typeof options === "function" ? { onDrop: options } : options;
+    const getFiles = (event) => {
+      var _a, _b;
+      const list = Array.from((_b = (_a = event.dataTransfer) == null ? void 0 : _a.files) != null ? _b : []);
+      return files.value = list.length === 0 ? null : list;
+    };
+    useEventListener(target, "dragenter", (event) => {
+      var _a, _b;
+      const types = Array.from(((_a = event == null ? void 0 : event.dataTransfer) == null ? void 0 : _a.items) || []).map((i) => i.kind === "file" ? i.type : null).filter(notNullish);
+      if (_options.dataTypes && event.dataTransfer) {
+        const dataTypes = unref(_options.dataTypes);
+        isDataTypeIncluded = typeof dataTypes === "function" ? dataTypes(types) : dataTypes ? dataTypes.some((item) => types.includes(item)) : true;
+        if (!isDataTypeIncluded)
+          return;
+      }
+      event.preventDefault();
+      counter += 1;
+      isOverDropZone.value = true;
+      (_b = _options.onEnter) == null ? void 0 : _b.call(_options, getFiles(event), event);
+    });
+    useEventListener(target, "dragover", (event) => {
+      var _a;
+      if (!isDataTypeIncluded)
+        return;
+      event.preventDefault();
+      (_a = _options.onOver) == null ? void 0 : _a.call(_options, getFiles(event), event);
+    });
+    useEventListener(target, "dragleave", (event) => {
+      var _a;
+      if (!isDataTypeIncluded)
+        return;
+      event.preventDefault();
+      counter -= 1;
+      if (counter === 0)
+        isOverDropZone.value = false;
+      (_a = _options.onLeave) == null ? void 0 : _a.call(_options, getFiles(event), event);
+    });
+    useEventListener(target, "drop", (event) => {
+      var _a;
+      event.preventDefault();
+      counter = 0;
+      isOverDropZone.value = false;
+      (_a = _options.onDrop) == null ? void 0 : _a.call(_options, getFiles(event), event);
+    });
+  }
+  return {
+    files,
+    isOverDropZone
+  };
+}
+
+function useResizeObserver(target, callback, options = {}) {
+  const { window = defaultWindow, ...observerOptions } = options;
+  let observer;
+  const isSupported = useSupported(() => window && "ResizeObserver" in window);
+  const cleanup = () => {
+    if (observer) {
+      observer.disconnect();
+      observer = void 0;
+    }
+  };
+  const targets = computed(() => Array.isArray(target) ? target.map((el) => unrefElement(el)) : [unrefElement(target)]);
+  const stopWatch = watch(
+    targets,
+    (els) => {
+      cleanup();
+      if (isSupported.value && window) {
+        observer = new ResizeObserver(callback);
+        for (const _el of els)
+          _el && observer.observe(_el, observerOptions);
+      }
+    },
+    { immediate: true, flush: "post", deep: true }
+  );
+  const stop = () => {
+    cleanup();
+    stopWatch();
+  };
+  tryOnScopeDispose(stop);
+  return {
+    isSupported,
+    stop
+  };
+}
+
+function useElementBounding(target, options = {}) {
+  const {
+    reset = true,
+    windowResize = true,
+    windowScroll = true,
+    immediate = true
+  } = options;
+  const height = ref(0);
+  const bottom = ref(0);
+  const left = ref(0);
+  const right = ref(0);
+  const top = ref(0);
+  const width = ref(0);
+  const x = ref(0);
+  const y = ref(0);
+  function update() {
+    const el = unrefElement(target);
+    if (!el) {
+      if (reset) {
+        height.value = 0;
+        bottom.value = 0;
+        left.value = 0;
+        right.value = 0;
+        top.value = 0;
+        width.value = 0;
+        x.value = 0;
+        y.value = 0;
+      }
+      return;
+    }
+    const rect = el.getBoundingClientRect();
+    height.value = rect.height;
+    bottom.value = rect.bottom;
+    left.value = rect.left;
+    right.value = rect.right;
+    top.value = rect.top;
+    width.value = rect.width;
+    x.value = rect.x;
+    y.value = rect.y;
+  }
+  useResizeObserver(target, update);
+  watch(() => unrefElement(target), (ele) => !ele && update());
+  useMutationObserver(target, update, {
+    attributeFilter: ["style", "class"]
+  });
+  if (windowScroll)
+    useEventListener("scroll", update, { capture: true, passive: true });
+  if (windowResize)
+    useEventListener("resize", update, { passive: true });
+  tryOnMounted(() => {
+    if (immediate)
+      update();
+  });
+  return {
+    height,
+    bottom,
+    left,
+    right,
+    top,
+    width,
+    x,
+    y,
+    update
+  };
+}
+
+function useElementByPoint(options) {
+  const {
+    x,
+    y,
+    document = defaultDocument,
+    multiple,
+    interval = "requestAnimationFrame",
+    immediate = true
+  } = options;
+  const isSupported = useSupported(() => {
+    if (toValue(multiple))
+      return document && "elementsFromPoint" in document;
+    return document && "elementFromPoint" in document;
+  });
+  const element = ref(null);
+  const cb = () => {
+    var _a, _b;
+    element.value = toValue(multiple) ? (_a = document == null ? void 0 : document.elementsFromPoint(toValue(x), toValue(y))) != null ? _a : [] : (_b = document == null ? void 0 : document.elementFromPoint(toValue(x), toValue(y))) != null ? _b : null;
+  };
+  const controls = interval === "requestAnimationFrame" ? useRafFn(cb, { immediate }) : useIntervalFn(cb, interval, { immediate });
+  return {
+    isSupported,
+    element,
+    ...controls
+  };
+}
+
+function useElementHover(el, options = {}) {
+  const {
+    delayEnter = 0,
+    delayLeave = 0,
+    window = defaultWindow
+  } = options;
+  const isHovered = ref(false);
+  let timer;
+  const toggle = (entering) => {
+    const delay = entering ? delayEnter : delayLeave;
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    if (delay)
+      timer = setTimeout(() => isHovered.value = entering, delay);
+    else
+      isHovered.value = entering;
+  };
+  if (!window)
+    return isHovered;
+  useEventListener(el, "mouseenter", () => toggle(true), { passive: true });
+  useEventListener(el, "mouseleave", () => toggle(false), { passive: true });
+  return isHovered;
+}
+
+function useElementSize(target, initialSize = { width: 0, height: 0 }, options = {}) {
+  const { window = defaultWindow, box = "content-box" } = options;
+  const isSVG = computed(() => {
+    var _a, _b;
+    return (_b = (_a = unrefElement(target)) == null ? void 0 : _a.namespaceURI) == null ? void 0 : _b.includes("svg");
+  });
+  const width = ref(initialSize.width);
+  const height = ref(initialSize.height);
+  const { stop: stop1 } = useResizeObserver(
+    target,
+    ([entry]) => {
+      const boxSize = box === "border-box" ? entry.borderBoxSize : box === "content-box" ? entry.contentBoxSize : entry.devicePixelContentBoxSize;
+      if (window && isSVG.value) {
+        const $elem = unrefElement(target);
+        if ($elem) {
+          const styles = window.getComputedStyle($elem);
+          width.value = Number.parseFloat(styles.width);
+          height.value = Number.parseFloat(styles.height);
+        }
+      } else {
+        if (boxSize) {
+          const formatBoxSize = Array.isArray(boxSize) ? boxSize : [boxSize];
+          width.value = formatBoxSize.reduce((acc, { inlineSize }) => acc + inlineSize, 0);
+          height.value = formatBoxSize.reduce((acc, { blockSize }) => acc + blockSize, 0);
+        } else {
+          width.value = entry.contentRect.width;
+          height.value = entry.contentRect.height;
+        }
+      }
+    },
+    options
+  );
+  tryOnMounted(() => {
+    const ele = unrefElement(target);
+    if (ele) {
+      width.value = "offsetWidth" in ele ? ele.offsetWidth : initialSize.width;
+      height.value = "offsetHeight" in ele ? ele.offsetHeight : initialSize.height;
+    }
+  });
+  const stop2 = watch(
+    () => unrefElement(target),
+    (ele) => {
+      width.value = ele ? initialSize.width : 0;
+      height.value = ele ? initialSize.height : 0;
+    }
+  );
+  function stop() {
+    stop1();
+    stop2();
+  }
+  return {
+    width,
+    height,
+    stop
+  };
+}
+
+function useIntersectionObserver(target, callback, options = {}) {
+  const {
+    root,
+    rootMargin = "0px",
+    threshold = 0.1,
+    window = defaultWindow,
+    immediate = true
+  } = options;
+  const isSupported = useSupported(() => window && "IntersectionObserver" in window);
+  const targets = computed(() => {
+    const _target = toValue(target);
+    return (Array.isArray(_target) ? _target : [_target]).map(unrefElement).filter(notNullish);
+  });
+  let cleanup = noop;
+  const isActive = ref(immediate);
+  const stopWatch = isSupported.value ? watch(
+    () => [targets.value, unrefElement(root), isActive.value],
+    ([targets2, root2]) => {
+      cleanup();
+      if (!isActive.value)
+        return;
+      if (!targets2.length)
+        return;
+      const observer = new IntersectionObserver(
+        callback,
+        {
+          root: unrefElement(root2),
+          rootMargin,
+          threshold
+        }
+      );
+      targets2.forEach((el) => el && observer.observe(el));
+      cleanup = () => {
+        observer.disconnect();
+        cleanup = noop;
+      };
+    },
+    { immediate, flush: "post" }
+  ) : noop;
+  const stop = () => {
+    cleanup();
+    stopWatch();
+    isActive.value = false;
+  };
+  tryOnScopeDispose(stop);
+  return {
+    isSupported,
+    isActive,
+    pause() {
+      cleanup();
+      isActive.value = false;
+    },
+    resume() {
+      isActive.value = true;
+    },
+    stop
+  };
+}
+
+function useElementVisibility(element, options = {}) {
+  const { window = defaultWindow, scrollTarget } = options;
+  const elementIsVisible = ref(false);
+  useIntersectionObserver(
+    element,
+    (intersectionObserverEntries) => {
+      let isIntersecting = elementIsVisible.value;
+      let latestTime = 0;
+      for (const entry of intersectionObserverEntries) {
+        if (entry.time >= latestTime) {
+          latestTime = entry.time;
+          isIntersecting = entry.isIntersecting;
+        }
+      }
+      elementIsVisible.value = isIntersecting;
+    },
+    {
+      root: scrollTarget,
+      window,
+      threshold: 0
+    }
+  );
+  return elementIsVisible;
+}
+
+const events = /* @__PURE__ */ new Map();
+
+function useEventBus(key) {
+  const scope = getCurrentScope();
+  function on(listener) {
+    var _a;
+    const listeners = events.get(key) || /* @__PURE__ */ new Set();
+    listeners.add(listener);
+    events.set(key, listeners);
+    const _off = () => off(listener);
+    (_a = scope == null ? void 0 : scope.cleanups) == null ? void 0 : _a.push(_off);
+    return _off;
+  }
+  function once(listener) {
+    function _listener(...args) {
+      off(_listener);
+      listener(...args);
+    }
+    return on(_listener);
+  }
+  function off(listener) {
+    const listeners = events.get(key);
+    if (!listeners)
+      return;
+    listeners.delete(listener);
+    if (!listeners.size)
+      reset();
+  }
+  function reset() {
+    events.delete(key);
+  }
+  function emit(event, payload) {
+    var _a;
+    (_a = events.get(key)) == null ? void 0 : _a.forEach((v) => v(event, payload));
+  }
+  return { on, once, off, emit, reset };
+}
+
+function useEventSource(url, events = [], options = {}) {
+  const event = ref(null);
+  const data = ref(null);
+  const status = ref("CONNECTING");
+  const eventSource = ref(null);
+  const error = shallowRef(null);
+  const {
+    withCredentials = false
+  } = options;
+  const close = () => {
+    if (eventSource.value) {
+      eventSource.value.close();
+      eventSource.value = null;
+      status.value = "CLOSED";
+    }
+  };
+  const es = new EventSource(url, { withCredentials });
+  eventSource.value = es;
+  es.onopen = () => {
+    status.value = "OPEN";
+    error.value = null;
+  };
+  es.onerror = (e) => {
+    status.value = "CLOSED";
+    error.value = e;
+  };
+  es.onmessage = (e) => {
+    event.value = null;
+    data.value = e.data;
+  };
+  for (const event_name of events) {
+    useEventListener(es, event_name, (e) => {
+      event.value = event_name;
+      data.value = e.data || null;
+    });
+  }
+  tryOnScopeDispose(() => {
+    close();
+  });
+  return {
+    eventSource,
+    event,
+    data,
+    status,
+    error,
+    close
+  };
+}
+
+function useEyeDropper(options = {}) {
+  const { initialValue = "" } = options;
+  const isSupported = useSupported(() => typeof window !== "undefined" && "EyeDropper" in window);
+  const sRGBHex = ref(initialValue);
+  async function open(openOptions) {
+    if (!isSupported.value)
+      return;
+    const eyeDropper = new window.EyeDropper();
+    const result = await eyeDropper.open(openOptions);
+    sRGBHex.value = result.sRGBHex;
+    return result;
+  }
+  return { isSupported, sRGBHex, open };
+}
+
+function useFavicon(newIcon = null, options = {}) {
+  const {
+    baseUrl = "",
+    rel = "icon",
+    document = defaultDocument
+  } = options;
+  const favicon = toRef(newIcon);
+  const applyIcon = (icon) => {
+    const elements = document == null ? void 0 : document.head.querySelectorAll(`link[rel*="${rel}"]`);
+    if (!elements || elements.length === 0) {
+      const link = document == null ? void 0 : document.createElement("link");
+      if (link) {
+        link.rel = rel;
+        link.href = `${baseUrl}${icon}`;
+        link.type = `image/${icon.split(".").pop()}`;
+        document == null ? void 0 : document.head.append(link);
+      }
+      return;
+    }
+    elements == null ? void 0 : elements.forEach((el) => el.href = `${baseUrl}${icon}`);
+  };
+  watch(
+    favicon,
+    (i, o) => {
+      if (typeof i === "string" && i !== o)
+        applyIcon(i);
+    },
+    { immediate: true }
+  );
+  return favicon;
+}
+
+const payloadMapping = {
+  json: "application/json",
+  text: "text/plain"
+};
+function isFetchOptions(obj) {
+  return obj && containsProp(obj, "immediate", "refetch", "initialData", "timeout", "beforeFetch", "afterFetch", "onFetchError", "fetch", "updateDataOnError");
+}
+function isAbsoluteURL(url) {
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+}
+function headersToObject(headers) {
+  if (typeof Headers !== "undefined" && headers instanceof Headers)
+    return Object.fromEntries([...headers.entries()]);
+  return headers;
+}
+function combineCallbacks(combination, ...callbacks) {
+  if (combination === "overwrite") {
+    return async (ctx) => {
+      const callback = callbacks[callbacks.length - 1];
+      if (callback)
+        return { ...ctx, ...await callback(ctx) };
+      return ctx;
+    };
+  } else {
+    return async (ctx) => {
+      for (const callback of callbacks) {
+        if (callback)
+          ctx = { ...ctx, ...await callback(ctx) };
+      }
+      return ctx;
+    };
+  }
+}
+function createFetch(config = {}) {
+  const _combination = config.combination || "chain";
+  const _options = config.options || {};
+  const _fetchOptions = config.fetchOptions || {};
+  function useFactoryFetch(url, ...args) {
+    const computedUrl = computed(() => {
+      const baseUrl = toValue(config.baseUrl);
+      const targetUrl = toValue(url);
+      return baseUrl && !isAbsoluteURL(targetUrl) ? joinPaths(baseUrl, targetUrl) : targetUrl;
+    });
+    let options = _options;
+    let fetchOptions = _fetchOptions;
+    if (args.length > 0) {
+      if (isFetchOptions(args[0])) {
+        options = {
+          ...options,
+          ...args[0],
+          beforeFetch: combineCallbacks(_combination, _options.beforeFetch, args[0].beforeFetch),
+          afterFetch: combineCallbacks(_combination, _options.afterFetch, args[0].afterFetch),
+          onFetchError: combineCallbacks(_combination, _options.onFetchError, args[0].onFetchError)
+        };
+      } else {
+        fetchOptions = {
+          ...fetchOptions,
+          ...args[0],
+          headers: {
+            ...headersToObject(fetchOptions.headers) || {},
+            ...headersToObject(args[0].headers) || {}
+          }
+        };
+      }
+    }
+    if (args.length > 1 && isFetchOptions(args[1])) {
+      options = {
+        ...options,
+        ...args[1],
+        beforeFetch: combineCallbacks(_combination, _options.beforeFetch, args[1].beforeFetch),
+        afterFetch: combineCallbacks(_combination, _options.afterFetch, args[1].afterFetch),
+        onFetchError: combineCallbacks(_combination, _options.onFetchError, args[1].onFetchError)
+      };
+    }
+    return useFetch(computedUrl, fetchOptions, options);
+  }
+  return useFactoryFetch;
+}
+function useFetch(url, ...args) {
+  var _a;
+  const supportsAbort = typeof AbortController === "function";
+  let fetchOptions = {};
+  let options = {
+    immediate: true,
+    refetch: false,
+    timeout: 0,
+    updateDataOnError: false
+  };
+  const config = {
+    method: "GET",
+    type: "text",
+    payload: void 0
+  };
+  if (args.length > 0) {
+    if (isFetchOptions(args[0]))
+      options = { ...options, ...args[0] };
+    else
+      fetchOptions = args[0];
+  }
+  if (args.length > 1) {
+    if (isFetchOptions(args[1]))
+      options = { ...options, ...args[1] };
+  }
+  const {
+    fetch = (_a = defaultWindow) == null ? void 0 : _a.fetch,
+    initialData,
+    timeout
+  } = options;
+  const responseEvent = createEventHook();
+  const errorEvent = createEventHook();
+  const finallyEvent = createEventHook();
+  const isFinished = ref(false);
+  const isFetching = ref(false);
+  const aborted = ref(false);
+  const statusCode = ref(null);
+  const response = shallowRef(null);
+  const error = shallowRef(null);
+  const data = shallowRef(initialData || null);
+  const canAbort = computed(() => supportsAbort && isFetching.value);
+  let controller;
+  let timer;
+  const abort = () => {
+    if (supportsAbort) {
+      controller == null ? void 0 : controller.abort();
+      controller = new AbortController();
+      controller.signal.onabort = () => aborted.value = true;
+      fetchOptions = {
+        ...fetchOptions,
+        signal: controller.signal
+      };
+    }
+  };
+  const loading = (isLoading) => {
+    isFetching.value = isLoading;
+    isFinished.value = !isLoading;
+  };
+  if (timeout)
+    timer = useTimeoutFn(abort, timeout, { immediate: false });
+  let executeCounter = 0;
+  const execute = async (throwOnFailed = false) => {
+    var _a2, _b;
+    abort();
+    loading(true);
+    error.value = null;
+    statusCode.value = null;
+    aborted.value = false;
+    executeCounter += 1;
+    const currentExecuteCounter = executeCounter;
+    const defaultFetchOptions = {
+      method: config.method,
+      headers: {}
+    };
+    if (config.payload) {
+      const headers = headersToObject(defaultFetchOptions.headers);
+      const payload = toValue(config.payload);
+      if (!config.payloadType && payload && Object.getPrototypeOf(payload) === Object.prototype && !(payload instanceof FormData))
+        config.payloadType = "json";
+      if (config.payloadType)
+        headers["Content-Type"] = (_a2 = payloadMapping[config.payloadType]) != null ? _a2 : config.payloadType;
+      defaultFetchOptions.body = config.payloadType === "json" ? JSON.stringify(payload) : payload;
+    }
+    let isCanceled = false;
+    const context = {
+      url: toValue(url),
+      options: {
+        ...defaultFetchOptions,
+        ...fetchOptions
+      },
+      cancel: () => {
+        isCanceled = true;
+      }
+    };
+    if (options.beforeFetch)
+      Object.assign(context, await options.beforeFetch(context));
+    if (isCanceled || !fetch) {
+      loading(false);
+      return Promise.resolve(null);
+    }
+    let responseData = null;
+    if (timer)
+      timer.start();
+    return fetch(
+      context.url,
+      {
+        ...defaultFetchOptions,
+        ...context.options,
+        headers: {
+          ...headersToObject(defaultFetchOptions.headers),
+          ...headersToObject((_b = context.options) == null ? void 0 : _b.headers)
+        }
+      }
+    ).then(async (fetchResponse) => {
+      response.value = fetchResponse;
+      statusCode.value = fetchResponse.status;
+      responseData = await fetchResponse.clone()[config.type]();
+      if (!fetchResponse.ok) {
+        data.value = initialData || null;
+        throw new Error(fetchResponse.statusText);
+      }
+      if (options.afterFetch) {
+        ({ data: responseData } = await options.afterFetch({
+          data: responseData,
+          response: fetchResponse
+        }));
+      }
+      data.value = responseData;
+      responseEvent.trigger(fetchResponse);
+      return fetchResponse;
+    }).catch(async (fetchError) => {
+      let errorData = fetchError.message || fetchError.name;
+      if (options.onFetchError) {
+        ({ error: errorData, data: responseData } = await options.onFetchError({
+          data: responseData,
+          error: fetchError,
+          response: response.value
+        }));
+      }
+      error.value = errorData;
+      if (options.updateDataOnError)
+        data.value = responseData;
+      errorEvent.trigger(fetchError);
+      if (throwOnFailed)
+        throw fetchError;
+      return null;
+    }).finally(() => {
+      if (currentExecuteCounter === executeCounter)
+        loading(false);
+      if (timer)
+        timer.stop();
+      finallyEvent.trigger(null);
+    });
+  };
+  const refetch = toRef(options.refetch);
+  watch(
+    [
+      refetch,
+      toRef(url)
+    ],
+    ([refetch2]) => refetch2 && execute(),
+    { deep: true }
+  );
+  const shell = {
+    isFinished,
+    statusCode,
+    response,
+    error,
+    data,
+    isFetching,
+    canAbort,
+    aborted,
+    abort,
+    execute,
+    onFetchResponse: responseEvent.on,
+    onFetchError: errorEvent.on,
+    onFetchFinally: finallyEvent.on,
+    // method
+    get: setMethod("GET"),
+    put: setMethod("PUT"),
+    post: setMethod("POST"),
+    delete: setMethod("DELETE"),
+    patch: setMethod("PATCH"),
+    head: setMethod("HEAD"),
+    options: setMethod("OPTIONS"),
+    // type
+    json: setType("json"),
+    text: setType("text"),
+    blob: setType("blob"),
+    arrayBuffer: setType("arrayBuffer"),
+    formData: setType("formData")
+  };
+  function setMethod(method) {
+    return (payload, payloadType) => {
+      if (!isFetching.value) {
+        config.method = method;
+        config.payload = payload;
+        config.payloadType = payloadType;
+        if (isRef(config.payload)) {
+          watch(
+            [
+              refetch,
+              toRef(config.payload)
+            ],
+            ([refetch2]) => refetch2 && execute(),
+            { deep: true }
+          );
+        }
+        return {
+          ...shell,
+          then(onFulfilled, onRejected) {
+            return waitUntilFinished().then(onFulfilled, onRejected);
+          }
+        };
+      }
+      return void 0;
+    };
+  }
+  function waitUntilFinished() {
+    return new Promise((resolve, reject) => {
+      until(isFinished).toBe(true).then(() => resolve(shell)).catch((error2) => reject(error2));
+    });
+  }
+  function setType(type) {
+    return () => {
+      if (!isFetching.value) {
+        config.type = type;
+        return {
+          ...shell,
+          then(onFulfilled, onRejected) {
+            return waitUntilFinished().then(onFulfilled, onRejected);
+          }
+        };
+      }
+      return void 0;
+    };
+  }
+  if (options.immediate)
+    Promise.resolve().then(() => execute());
+  return {
+    ...shell,
+    then(onFulfilled, onRejected) {
+      return waitUntilFinished().then(onFulfilled, onRejected);
+    }
+  };
+}
+function joinPaths(start, end) {
+  if (!start.endsWith("/") && !end.startsWith("/"))
+    return `${start}/${end}`;
+  return `${start}${end}`;
+}
+
+const DEFAULT_OPTIONS = {
+  multiple: true,
+  accept: "*",
+  reset: false,
+  directory: false
+};
+function useFileDialog(options = {}) {
+  const {
+    document = defaultDocument
+  } = options;
+  const files = ref(null);
+  const { on: onChange, trigger } = createEventHook();
+  let input;
+  if (document) {
+    input = document.createElement("input");
+    input.type = "file";
+    input.onchange = (event) => {
+      const result = event.target;
+      files.value = result.files;
+      trigger(files.value);
+    };
+  }
+  const reset = () => {
+    files.value = null;
+    if (input) {
+      input.value = "";
+      trigger(null);
+    }
+  };
+  const open = (localOptions) => {
+    if (!input)
+      return;
+    const _options = {
+      ...DEFAULT_OPTIONS,
+      ...options,
+      ...localOptions
+    };
+    input.multiple = _options.multiple;
+    input.accept = _options.accept;
+    input.webkitdirectory = _options.directory;
+    if (hasOwn(_options, "capture"))
+      input.capture = _options.capture;
+    if (_options.reset)
+      reset();
+    input.click();
+  };
+  return {
+    files: readonly(files),
+    open,
+    reset,
+    onChange
+  };
+}
+
+function useFileSystemAccess(options = {}) {
+  const {
+    window: _window = defaultWindow,
+    dataType = "Text"
+  } = options;
+  const window = _window;
+  const isSupported = useSupported(() => window && "showSaveFilePicker" in window && "showOpenFilePicker" in window);
+  const fileHandle = ref();
+  const data = ref();
+  const file = ref();
+  const fileName = computed(() => {
+    var _a, _b;
+    return (_b = (_a = file.value) == null ? void 0 : _a.name) != null ? _b : "";
+  });
+  const fileMIME = computed(() => {
+    var _a, _b;
+    return (_b = (_a = file.value) == null ? void 0 : _a.type) != null ? _b : "";
+  });
+  const fileSize = computed(() => {
+    var _a, _b;
+    return (_b = (_a = file.value) == null ? void 0 : _a.size) != null ? _b : 0;
+  });
+  const fileLastModified = computed(() => {
+    var _a, _b;
+    return (_b = (_a = file.value) == null ? void 0 : _a.lastModified) != null ? _b : 0;
+  });
+  async function open(_options = {}) {
+    if (!isSupported.value)
+      return;
+    const [handle] = await window.showOpenFilePicker({ ...toValue(options), ..._options });
+    fileHandle.value = handle;
+    await updateFile();
+    await updateData();
+  }
+  async function create(_options = {}) {
+    if (!isSupported.value)
+      return;
+    fileHandle.value = await window.showSaveFilePicker({ ...options, ..._options });
+    data.value = void 0;
+    await updateFile();
+    await updateData();
+  }
+  async function save(_options = {}) {
+    if (!isSupported.value)
+      return;
+    if (!fileHandle.value)
+      return saveAs(_options);
+    if (data.value) {
+      const writableStream = await fileHandle.value.createWritable();
+      await writableStream.write(data.value);
+      await writableStream.close();
+    }
+    await updateFile();
+  }
+  async function saveAs(_options = {}) {
+    if (!isSupported.value)
+      return;
+    fileHandle.value = await window.showSaveFilePicker({ ...options, ..._options });
+    if (data.value) {
+      const writableStream = await fileHandle.value.createWritable();
+      await writableStream.write(data.value);
+      await writableStream.close();
+    }
+    await updateFile();
+  }
+  async function updateFile() {
+    var _a;
+    file.value = await ((_a = fileHandle.value) == null ? void 0 : _a.getFile());
+  }
+  async function updateData() {
+    var _a, _b;
+    const type = toValue(dataType);
+    if (type === "Text")
+      data.value = await ((_a = file.value) == null ? void 0 : _a.text());
+    else if (type === "ArrayBuffer")
+      data.value = await ((_b = file.value) == null ? void 0 : _b.arrayBuffer());
+    else if (type === "Blob")
+      data.value = file.value;
+  }
+  watch(() => toValue(dataType), updateData);
+  return {
+    isSupported,
+    data,
+    file,
+    fileName,
+    fileMIME,
+    fileSize,
+    fileLastModified,
+    open,
+    create,
+    save,
+    saveAs,
+    updateData
+  };
+}
+
+function useFocus(target, options = {}) {
+  const { initialValue = false, focusVisible = false } = options;
+  const innerFocused = ref(false);
+  const targetElement = computed(() => unrefElement(target));
+  useEventListener(targetElement, "focus", (event) => {
+    var _a, _b;
+    if (!focusVisible || ((_b = (_a = event.target).matches) == null ? void 0 : _b.call(_a, ":focus-visible")))
+      innerFocused.value = true;
+  });
+  useEventListener(targetElement, "blur", () => innerFocused.value = false);
+  const focused = computed({
+    get: () => innerFocused.value,
+    set(value) {
+      var _a, _b;
+      if (!value && innerFocused.value)
+        (_a = targetElement.value) == null ? void 0 : _a.blur();
+      else if (value && !innerFocused.value)
+        (_b = targetElement.value) == null ? void 0 : _b.focus();
+    }
+  });
+  watch(
+    targetElement,
+    () => {
+      focused.value = initialValue;
+    },
+    { immediate: true, flush: "post" }
+  );
+  return { focused };
+}
+
+function useFocusWithin(target, options = {}) {
+  const activeElement = useActiveElement(options);
+  const targetElement = computed(() => unrefElement(target));
+  const focused = computed(() => targetElement.value && activeElement.value ? targetElement.value.contains(activeElement.value) : false);
+  return { focused };
+}
+
+function useFps(options) {
+  var _a;
+  const fps = ref(0);
+  if (typeof performance === "undefined")
+    return fps;
+  const every = (_a = options == null ? void 0 : options.every) != null ? _a : 10;
+  let last = performance.now();
+  let ticks = 0;
+  useRafFn(() => {
+    ticks += 1;
+    if (ticks >= every) {
+      const now = performance.now();
+      const diff = now - last;
+      fps.value = Math.round(1e3 / (diff / ticks));
+      last = now;
+      ticks = 0;
+    }
+  });
+  return fps;
+}
+
+const eventHandlers = [
+  "fullscreenchange",
+  "webkitfullscreenchange",
+  "webkitendfullscreen",
+  "mozfullscreenchange",
+  "MSFullscreenChange"
+];
+function useFullscreen(target, options = {}) {
+  const {
+    document = defaultDocument,
+    autoExit = false
+  } = options;
+  const targetRef = computed(() => {
+    var _a;
+    return (_a = unrefElement(target)) != null ? _a : document == null ? void 0 : document.querySelector("html");
+  });
+  const isFullscreen = ref(false);
+  const requestMethod = computed(() => {
+    return [
+      "requestFullscreen",
+      "webkitRequestFullscreen",
+      "webkitEnterFullscreen",
+      "webkitEnterFullScreen",
+      "webkitRequestFullScreen",
+      "mozRequestFullScreen",
+      "msRequestFullscreen"
+    ].find((m) => document && m in document || targetRef.value && m in targetRef.value);
+  });
+  const exitMethod = computed(() => {
+    return [
+      "exitFullscreen",
+      "webkitExitFullscreen",
+      "webkitExitFullScreen",
+      "webkitCancelFullScreen",
+      "mozCancelFullScreen",
+      "msExitFullscreen"
+    ].find((m) => document && m in document || targetRef.value && m in targetRef.value);
+  });
+  const fullscreenEnabled = computed(() => {
+    return [
+      "fullScreen",
+      "webkitIsFullScreen",
+      "webkitDisplayingFullscreen",
+      "mozFullScreen",
+      "msFullscreenElement"
+    ].find((m) => document && m in document || targetRef.value && m in targetRef.value);
+  });
+  const fullscreenElementMethod = [
+    "fullscreenElement",
+    "webkitFullscreenElement",
+    "mozFullScreenElement",
+    "msFullscreenElement"
+  ].find((m) => document && m in document);
+  const isSupported = useSupported(() => targetRef.value && document && requestMethod.value !== void 0 && exitMethod.value !== void 0 && fullscreenEnabled.value !== void 0);
+  const isCurrentElementFullScreen = () => {
+    if (fullscreenElementMethod)
+      return (document == null ? void 0 : document[fullscreenElementMethod]) === targetRef.value;
+    return false;
+  };
+  const isElementFullScreen = () => {
+    if (fullscreenEnabled.value) {
+      if (document && document[fullscreenEnabled.value] != null) {
+        return document[fullscreenEnabled.value];
+      } else {
+        const target2 = targetRef.value;
+        if ((target2 == null ? void 0 : target2[fullscreenEnabled.value]) != null) {
+          return Boolean(target2[fullscreenEnabled.value]);
+        }
+      }
+    }
+    return false;
+  };
+  async function exit() {
+    if (!isSupported.value || !isFullscreen.value)
+      return;
+    if (exitMethod.value) {
+      if ((document == null ? void 0 : document[exitMethod.value]) != null) {
+        await document[exitMethod.value]();
+      } else {
+        const target2 = targetRef.value;
+        if ((target2 == null ? void 0 : target2[exitMethod.value]) != null)
+          await target2[exitMethod.value]();
+      }
+    }
+    isFullscreen.value = false;
+  }
+  async function enter() {
+    if (!isSupported.value || isFullscreen.value)
+      return;
+    if (isElementFullScreen())
+      await exit();
+    const target2 = targetRef.value;
+    if (requestMethod.value && (target2 == null ? void 0 : target2[requestMethod.value]) != null) {
+      await target2[requestMethod.value]();
+      isFullscreen.value = true;
+    }
+  }
+  async function toggle() {
+    await (isFullscreen.value ? exit() : enter());
+  }
+  const handlerCallback = () => {
+    const isElementFullScreenValue = isElementFullScreen();
+    if (!isElementFullScreenValue || isElementFullScreenValue && isCurrentElementFullScreen())
+      isFullscreen.value = isElementFullScreenValue;
+  };
+  useEventListener(document, eventHandlers, handlerCallback, false);
+  useEventListener(() => unrefElement(targetRef), eventHandlers, handlerCallback, false);
+  if (autoExit)
+    tryOnScopeDispose(exit);
+  return {
+    isSupported,
+    isFullscreen,
+    enter,
+    exit,
+    toggle
+  };
+}
+
+function mapGamepadToXbox360Controller(gamepad) {
+  return computed(() => {
+    if (gamepad.value) {
+      return {
+        buttons: {
+          a: gamepad.value.buttons[0],
+          b: gamepad.value.buttons[1],
+          x: gamepad.value.buttons[2],
+          y: gamepad.value.buttons[3]
+        },
+        bumper: {
+          left: gamepad.value.buttons[4],
+          right: gamepad.value.buttons[5]
+        },
+        triggers: {
+          left: gamepad.value.buttons[6],
+          right: gamepad.value.buttons[7]
+        },
+        stick: {
+          left: {
+            horizontal: gamepad.value.axes[0],
+            vertical: gamepad.value.axes[1],
+            button: gamepad.value.buttons[10]
+          },
+          right: {
+            horizontal: gamepad.value.axes[2],
+            vertical: gamepad.value.axes[3],
+            button: gamepad.value.buttons[11]
+          }
+        },
+        dpad: {
+          up: gamepad.value.buttons[12],
+          down: gamepad.value.buttons[13],
+          left: gamepad.value.buttons[14],
+          right: gamepad.value.buttons[15]
+        },
+        back: gamepad.value.buttons[8],
+        start: gamepad.value.buttons[9]
+      };
+    }
+    return null;
+  });
+}
+function useGamepad(options = {}) {
+  const {
+    navigator = defaultNavigator
+  } = options;
+  const isSupported = useSupported(() => navigator && "getGamepads" in navigator);
+  const gamepads = ref([]);
+  const onConnectedHook = createEventHook();
+  const onDisconnectedHook = createEventHook();
+  const stateFromGamepad = (gamepad) => {
+    const hapticActuators = [];
+    const vibrationActuator = "vibrationActuator" in gamepad ? gamepad.vibrationActuator : null;
+    if (vibrationActuator)
+      hapticActuators.push(vibrationActuator);
+    if (gamepad.hapticActuators)
+      hapticActuators.push(...gamepad.hapticActuators);
+    return {
+      ...gamepad,
+      id: gamepad.id,
+      hapticActuators,
+      axes: gamepad.axes.map((axes) => axes),
+      buttons: gamepad.buttons.map((button) => ({ pressed: button.pressed, touched: button.touched, value: button.value }))
+    };
+  };
+  const updateGamepadState = () => {
+    const _gamepads = (navigator == null ? void 0 : navigator.getGamepads()) || [];
+    for (let i = 0; i < _gamepads.length; ++i) {
+      const gamepad = _gamepads[i];
+      if (gamepad) {
+        const index = gamepads.value.findIndex(({ index: index2 }) => index2 === gamepad.index);
+        if (index > -1)
+          gamepads.value[index] = stateFromGamepad(gamepad);
+      }
+    }
+  };
+  const { isActive, pause, resume } = useRafFn(updateGamepadState);
+  const onGamepadConnected = (gamepad) => {
+    if (!gamepads.value.some(({ index }) => index === gamepad.index)) {
+      gamepads.value.push(stateFromGamepad(gamepad));
+      onConnectedHook.trigger(gamepad.index);
+    }
+    resume();
+  };
+  const onGamepadDisconnected = (gamepad) => {
+    gamepads.value = gamepads.value.filter((x) => x.index !== gamepad.index);
+    onDisconnectedHook.trigger(gamepad.index);
+  };
+  useEventListener("gamepadconnected", (e) => onGamepadConnected(e.gamepad));
+  useEventListener("gamepaddisconnected", (e) => onGamepadDisconnected(e.gamepad));
+  tryOnMounted(() => {
+    const _gamepads = (navigator == null ? void 0 : navigator.getGamepads()) || [];
+    if (_gamepads) {
+      for (let i = 0; i < _gamepads.length; ++i) {
+        const gamepad = _gamepads[i];
+        if (gamepad)
+          onGamepadConnected(gamepad);
+      }
+    }
+  });
+  pause();
+  return {
+    isSupported,
+    onConnected: onConnectedHook.on,
+    onDisconnected: onDisconnectedHook.on,
+    gamepads,
+    pause,
+    resume,
+    isActive
+  };
+}
+
+function useGeolocation(options = {}) {
+  const {
+    enableHighAccuracy = true,
+    maximumAge = 3e4,
+    timeout = 27e3,
+    navigator = defaultNavigator,
+    immediate = true
+  } = options;
+  const isSupported = useSupported(() => navigator && "geolocation" in navigator);
+  const locatedAt = ref(null);
+  const error = shallowRef(null);
+  const coords = ref({
+    accuracy: 0,
+    latitude: Number.POSITIVE_INFINITY,
+    longitude: Number.POSITIVE_INFINITY,
+    altitude: null,
+    altitudeAccuracy: null,
+    heading: null,
+    speed: null
+  });
+  function updatePosition(position) {
+    locatedAt.value = position.timestamp;
+    coords.value = position.coords;
+    error.value = null;
+  }
+  let watcher;
+  function resume() {
+    if (isSupported.value) {
+      watcher = navigator.geolocation.watchPosition(
+        updatePosition,
+        (err) => error.value = err,
+        {
+          enableHighAccuracy,
+          maximumAge,
+          timeout
+        }
+      );
+    }
+  }
+  if (immediate)
+    resume();
+  function pause() {
+    if (watcher && navigator)
+      navigator.geolocation.clearWatch(watcher);
+  }
+  tryOnScopeDispose(() => {
+    pause();
+  });
+  return {
+    isSupported,
+    coords,
+    locatedAt,
+    error,
+    resume,
+    pause
+  };
+}
+
+const defaultEvents$1 = ["mousemove", "mousedown", "resize", "keydown", "touchstart", "wheel"];
+const oneMinute = 6e4;
+function useIdle(timeout = oneMinute, options = {}) {
+  const {
+    initialState = false,
+    listenForVisibilityChange = true,
+    events = defaultEvents$1,
+    window = defaultWindow,
+    eventFilter = throttleFilter(50)
+  } = options;
+  const idle = ref(initialState);
+  const lastActive = ref(timestamp());
+  let timer;
+  const reset = () => {
+    idle.value = false;
+    clearTimeout(timer);
+    timer = setTimeout(() => idle.value = true, timeout);
+  };
+  const onEvent = createFilterWrapper(
+    eventFilter,
+    () => {
+      lastActive.value = timestamp();
+      reset();
+    }
+  );
+  if (window) {
+    const document = window.document;
+    for (const event of events)
+      useEventListener(window, event, onEvent, { passive: true });
+    if (listenForVisibilityChange) {
+      useEventListener(document, "visibilitychange", () => {
+        if (!document.hidden)
+          onEvent();
+      });
+    }
+    reset();
+  }
+  return {
+    idle,
+    lastActive,
+    reset
+  };
+}
+
+async function loadImage(options) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    const { src, srcset, sizes, class: clazz, loading, crossorigin, referrerPolicy } = options;
+    img.src = src;
+    if (srcset)
+      img.srcset = srcset;
+    if (sizes)
+      img.sizes = sizes;
+    if (clazz)
+      img.className = clazz;
+    if (loading)
+      img.loading = loading;
+    if (crossorigin)
+      img.crossOrigin = crossorigin;
+    if (referrerPolicy)
+      img.referrerPolicy = referrerPolicy;
+    img.onload = () => resolve(img);
+    img.onerror = reject;
+  });
+}
+function useImage(options, asyncStateOptions = {}) {
+  const state = useAsyncState(
+    () => loadImage(toValue(options)),
+    void 0,
+    {
+      resetOnExecute: true,
+      ...asyncStateOptions
+    }
+  );
+  watch(
+    () => toValue(options),
+    () => state.execute(asyncStateOptions.delay),
+    { deep: true }
+  );
+  return state;
+}
+
+const ARRIVED_STATE_THRESHOLD_PIXELS = 1;
+function useScroll(element, options = {}) {
+  const {
+    throttle = 0,
+    idle = 200,
+    onStop = noop,
+    onScroll = noop,
+    offset = {
+      left: 0,
+      right: 0,
+      top: 0,
+      bottom: 0
+    },
+    eventListenerOptions = {
+      capture: false,
+      passive: true
+    },
+    behavior = "auto",
+    window = defaultWindow
+  } = options;
+  const internalX = ref(0);
+  const internalY = ref(0);
+  const x = computed({
+    get() {
+      return internalX.value;
+    },
+    set(x2) {
+      scrollTo(x2, void 0);
+    }
+  });
+  const y = computed({
+    get() {
+      return internalY.value;
+    },
+    set(y2) {
+      scrollTo(void 0, y2);
+    }
+  });
+  function scrollTo(_x, _y) {
+    var _a, _b, _c;
+    if (!window)
+      return;
+    const _element = toValue(element);
+    if (!_element)
+      return;
+    (_c = _element instanceof Document ? window.document.body : _element) == null ? void 0 : _c.scrollTo({
+      top: (_a = toValue(_y)) != null ? _a : y.value,
+      left: (_b = toValue(_x)) != null ? _b : x.value,
+      behavior: toValue(behavior)
+    });
+  }
+  const isScrolling = ref(false);
+  const arrivedState = reactive({
+    left: true,
+    right: false,
+    top: true,
+    bottom: false
+  });
+  const directions = reactive({
+    left: false,
+    right: false,
+    top: false,
+    bottom: false
+  });
+  const onScrollEnd = (e) => {
+    if (!isScrolling.value)
+      return;
+    isScrolling.value = false;
+    directions.left = false;
+    directions.right = false;
+    directions.top = false;
+    directions.bottom = false;
+    onStop(e);
+  };
+  const onScrollEndDebounced = useDebounceFn(onScrollEnd, throttle + idle);
+  const setArrivedState = (target) => {
+    var _a;
+    if (!window)
+      return;
+    const el = target.document ? target.document.documentElement : (_a = target.documentElement) != null ? _a : target;
+    const { display, flexDirection } = getComputedStyle(el);
+    const scrollLeft = el.scrollLeft;
+    directions.left = scrollLeft < internalX.value;
+    directions.right = scrollLeft > internalX.value;
+    const left = Math.abs(scrollLeft) <= 0 + (offset.left || 0);
+    const right = Math.abs(scrollLeft) + el.clientWidth >= el.scrollWidth - (offset.right || 0) - ARRIVED_STATE_THRESHOLD_PIXELS;
+    if (display === "flex" && flexDirection === "row-reverse") {
+      arrivedState.left = right;
+      arrivedState.right = left;
+    } else {
+      arrivedState.left = left;
+      arrivedState.right = right;
+    }
+    internalX.value = scrollLeft;
+    let scrollTop = el.scrollTop;
+    if (target === window.document && !scrollTop)
+      scrollTop = window.document.body.scrollTop;
+    directions.top = scrollTop < internalY.value;
+    directions.bottom = scrollTop > internalY.value;
+    const top = Math.abs(scrollTop) <= 0 + (offset.top || 0);
+    const bottom = Math.abs(scrollTop) + el.clientHeight >= el.scrollHeight - (offset.bottom || 0) - ARRIVED_STATE_THRESHOLD_PIXELS;
+    if (display === "flex" && flexDirection === "column-reverse") {
+      arrivedState.top = bottom;
+      arrivedState.bottom = top;
+    } else {
+      arrivedState.top = top;
+      arrivedState.bottom = bottom;
+    }
+    internalY.value = scrollTop;
+  };
+  const onScrollHandler = (e) => {
+    var _a;
+    if (!window)
+      return;
+    const eventTarget = (_a = e.target.documentElement) != null ? _a : e.target;
+    setArrivedState(eventTarget);
+    isScrolling.value = true;
+    onScrollEndDebounced(e);
+    onScroll(e);
+  };
+  useEventListener(
+    element,
+    "scroll",
+    throttle ? useThrottleFn(onScrollHandler, throttle, true, false) : onScrollHandler,
+    eventListenerOptions
+  );
+  tryOnMounted(() => {
+    const _element = toValue(element);
+    if (!_element)
+      return;
+    setArrivedState(_element);
+  });
+  useEventListener(
+    element,
+    "scrollend",
+    onScrollEnd,
+    eventListenerOptions
+  );
+  return {
+    x,
+    y,
+    isScrolling,
+    arrivedState,
+    directions,
+    measure() {
+      const _element = toValue(element);
+      if (window && _element)
+        setArrivedState(_element);
+    }
+  };
+}
+
+function resolveElement(el) {
+  if (typeof Window !== "undefined" && el instanceof Window)
+    return el.document.documentElement;
+  if (typeof Document !== "undefined" && el instanceof Document)
+    return el.documentElement;
+  return el;
+}
+
+function useInfiniteScroll(element, onLoadMore, options = {}) {
+  var _a;
+  const {
+    direction = "bottom",
+    interval = 100,
+    canLoadMore = () => true
+  } = options;
+  const state = reactive(useScroll(
+    element,
+    {
+      ...options,
+      offset: {
+        [direction]: (_a = options.distance) != null ? _a : 0,
+        ...options.offset
+      }
+    }
+  ));
+  const promise = ref();
+  const isLoading = computed(() => !!promise.value);
+  const observedElement = computed(() => {
+    return resolveElement(toValue(element));
+  });
+  const isElementVisible = useElementVisibility(observedElement);
+  function checkAndLoad() {
+    state.measure();
+    if (!observedElement.value || !isElementVisible.value || !canLoadMore(observedElement.value))
+      return;
+    const { scrollHeight, clientHeight, scrollWidth, clientWidth } = observedElement.value;
+    const isNarrower = direction === "bottom" || direction === "top" ? scrollHeight <= clientHeight : scrollWidth <= clientWidth;
+    if (state.arrivedState[direction] || isNarrower) {
+      if (!promise.value) {
+        promise.value = Promise.all([
+          onLoadMore(state),
+          new Promise((resolve) => setTimeout(resolve, interval))
+        ]).finally(() => {
+          promise.value = null;
+          nextTick(() => checkAndLoad());
+        });
+      }
+    }
+  }
+  watch(
+    () => [state.arrivedState[direction], isElementVisible.value],
+    checkAndLoad,
+    { immediate: true }
+  );
+  return {
+    isLoading
+  };
+}
+
+const defaultEvents = ["mousedown", "mouseup", "keydown", "keyup"];
+function useKeyModifier(modifier, options = {}) {
+  const {
+    events = defaultEvents,
+    document = defaultDocument,
+    initial = null
+  } = options;
+  const state = ref(initial);
+  if (document) {
+    events.forEach((listenerEvent) => {
+      useEventListener(document, listenerEvent, (evt) => {
+        if (typeof evt.getModifierState === "function")
+          state.value = evt.getModifierState(modifier);
+      });
+    });
+  }
+  return state;
+}
+
+function useLocalStorage(key, initialValue, options = {}) {
+  const { window = defaultWindow } = options;
+  return useStorage(key, initialValue, window == null ? void 0 : window.localStorage, options);
+}
+
+const DefaultMagicKeysAliasMap = {
+  ctrl: "control",
+  command: "meta",
+  cmd: "meta",
+  option: "alt",
+  up: "arrowup",
+  down: "arrowdown",
+  left: "arrowleft",
+  right: "arrowright"
+};
+
+function useMagicKeys(options = {}) {
+  const {
+    reactive: useReactive = false,
+    target = defaultWindow,
+    aliasMap = DefaultMagicKeysAliasMap,
+    passive = true,
+    onEventFired = noop
+  } = options;
+  const current = reactive(/* @__PURE__ */ new Set());
+  const obj = {
+    toJSON() {
+      return {};
+    },
+    current
+  };
+  const refs = useReactive ? reactive(obj) : obj;
+  const metaDeps = /* @__PURE__ */ new Set();
+  const usedKeys = /* @__PURE__ */ new Set();
+  function setRefs(key, value) {
+    if (key in refs) {
+      if (useReactive)
+        refs[key] = value;
+      else
+        refs[key].value = value;
+    }
+  }
+  function reset() {
+    current.clear();
+    for (const key of usedKeys)
+      setRefs(key, false);
+  }
+  function updateRefs(e, value) {
+    var _a, _b;
+    const key = (_a = e.key) == null ? void 0 : _a.toLowerCase();
+    const code = (_b = e.code) == null ? void 0 : _b.toLowerCase();
+    const values = [code, key].filter(Boolean);
+    if (key) {
+      if (value)
+        current.add(key);
+      else
+        current.delete(key);
+    }
+    for (const key2 of values) {
+      usedKeys.add(key2);
+      setRefs(key2, value);
+    }
+    if (key === "meta" && !value) {
+      metaDeps.forEach((key2) => {
+        current.delete(key2);
+        setRefs(key2, false);
+      });
+      metaDeps.clear();
+    } else if (typeof e.getModifierState === "function" && e.getModifierState("Meta") && value) {
+      [...current, ...values].forEach((key2) => metaDeps.add(key2));
+    }
+  }
+  useEventListener(target, "keydown", (e) => {
+    updateRefs(e, true);
+    return onEventFired(e);
+  }, { passive });
+  useEventListener(target, "keyup", (e) => {
+    updateRefs(e, false);
+    return onEventFired(e);
+  }, { passive });
+  useEventListener("blur", reset, { passive: true });
+  useEventListener("focus", reset, { passive: true });
+  const proxy = new Proxy(
+    refs,
+    {
+      get(target2, prop, rec) {
+        if (typeof prop !== "string")
+          return Reflect.get(target2, prop, rec);
+        prop = prop.toLowerCase();
+        if (prop in aliasMap)
+          prop = aliasMap[prop];
+        if (!(prop in refs)) {
+          if (/[+_-]/.test(prop)) {
+            const keys = prop.split(/[+_-]/g).map((i) => i.trim());
+            refs[prop] = computed(() => keys.every((key) => toValue(proxy[key])));
+          } else {
+            refs[prop] = ref(false);
+          }
+        }
+        const r = Reflect.get(target2, prop, rec);
+        return useReactive ? toValue(r) : r;
+      }
+    }
+  );
+  return proxy;
+}
+
+function usingElRef(source, cb) {
+  if (toValue(source))
+    cb(toValue(source));
+}
+function timeRangeToArray(timeRanges) {
+  let ranges = [];
+  for (let i = 0; i < timeRanges.length; ++i)
+    ranges = [...ranges, [timeRanges.start(i), timeRanges.end(i)]];
+  return ranges;
+}
+function tracksToArray(tracks) {
+  return Array.from(tracks).map(({ label, kind, language, mode, activeCues, cues, inBandMetadataTrackDispatchType }, id) => ({ id, label, kind, language, mode, activeCues, cues, inBandMetadataTrackDispatchType }));
+}
+const defaultOptions = {
+  src: "",
+  tracks: []
+};
+function useMediaControls(target, options = {}) {
+  options = {
+    ...defaultOptions,
+    ...options
+  };
+  const {
+    document = defaultDocument
+  } = options;
+  const currentTime = ref(0);
+  const duration = ref(0);
+  const seeking = ref(false);
+  const volume = ref(1);
+  const waiting = ref(false);
+  const ended = ref(false);
+  const playing = ref(false);
+  const rate = ref(1);
+  const stalled = ref(false);
+  const buffered = ref([]);
+  const tracks = ref([]);
+  const selectedTrack = ref(-1);
+  const isPictureInPicture = ref(false);
+  const muted = ref(false);
+  const supportsPictureInPicture = document && "pictureInPictureEnabled" in document;
+  const sourceErrorEvent = createEventHook();
+  const disableTrack = (track) => {
+    usingElRef(target, (el) => {
+      if (track) {
+        const id = typeof track === "number" ? track : track.id;
+        el.textTracks[id].mode = "disabled";
+      } else {
+        for (let i = 0; i < el.textTracks.length; ++i)
+          el.textTracks[i].mode = "disabled";
+      }
+      selectedTrack.value = -1;
+    });
+  };
+  const enableTrack = (track, disableTracks = true) => {
+    usingElRef(target, (el) => {
+      const id = typeof track === "number" ? track : track.id;
+      if (disableTracks)
+        disableTrack();
+      el.textTracks[id].mode = "showing";
+      selectedTrack.value = id;
+    });
+  };
+  const togglePictureInPicture = () => {
+    return new Promise((resolve, reject) => {
+      usingElRef(target, async (el) => {
+        if (supportsPictureInPicture) {
+          if (!isPictureInPicture.value) {
+            el.requestPictureInPicture().then(resolve).catch(reject);
+          } else {
+            document.exitPictureInPicture().then(resolve).catch(reject);
+          }
+        }
+      });
+    });
+  };
+  watchEffect(() => {
+    if (!document)
+      return;
+    const el = toValue(target);
+    if (!el)
+      return;
+    const src = toValue(options.src);
+    let sources = [];
+    if (!src)
+      return;
+    if (typeof src === "string")
+      sources = [{ src }];
+    else if (Array.isArray(src))
+      sources = src;
+    else if (isObject(src))
+      sources = [src];
+    el.querySelectorAll("source").forEach((e) => {
+      e.removeEventListener("error", sourceErrorEvent.trigger);
+      e.remove();
+    });
+    sources.forEach(({ src: src2, type }) => {
+      const source = document.createElement("source");
+      source.setAttribute("src", src2);
+      source.setAttribute("type", type || "");
+      source.addEventListener("error", sourceErrorEvent.trigger);
+      el.appendChild(source);
+    });
+    el.load();
+  });
+  tryOnScopeDispose(() => {
+    const el = toValue(target);
+    if (!el)
+      return;
+    el.querySelectorAll("source").forEach((e) => e.removeEventListener("error", sourceErrorEvent.trigger));
+  });
+  watch([target, volume], () => {
+    const el = toValue(target);
+    if (!el)
+      return;
+    el.volume = volume.value;
+  });
+  watch([target, muted], () => {
+    const el = toValue(target);
+    if (!el)
+      return;
+    el.muted = muted.value;
+  });
+  watch([target, rate], () => {
+    const el = toValue(target);
+    if (!el)
+      return;
+    el.playbackRate = rate.value;
+  });
+  watchEffect(() => {
+    if (!document)
+      return;
+    const textTracks = toValue(options.tracks);
+    const el = toValue(target);
+    if (!textTracks || !textTracks.length || !el)
+      return;
+    el.querySelectorAll("track").forEach((e) => e.remove());
+    textTracks.forEach(({ default: isDefault, kind, label, src, srcLang }, i) => {
+      const track = document.createElement("track");
+      track.default = isDefault || false;
+      track.kind = kind;
+      track.label = label;
+      track.src = src;
+      track.srclang = srcLang;
+      if (track.default)
+        selectedTrack.value = i;
+      el.appendChild(track);
+    });
+  });
+  const { ignoreUpdates: ignoreCurrentTimeUpdates } = watchIgnorable(currentTime, (time) => {
+    const el = toValue(target);
+    if (!el)
+      return;
+    el.currentTime = time;
+  });
+  const { ignoreUpdates: ignorePlayingUpdates } = watchIgnorable(playing, (isPlaying) => {
+    const el = toValue(target);
+    if (!el)
+      return;
+    isPlaying ? el.play() : el.pause();
+  });
+  useEventListener(target, "timeupdate", () => ignoreCurrentTimeUpdates(() => currentTime.value = toValue(target).currentTime));
+  useEventListener(target, "durationchange", () => duration.value = toValue(target).duration);
+  useEventListener(target, "progress", () => buffered.value = timeRangeToArray(toValue(target).buffered));
+  useEventListener(target, "seeking", () => seeking.value = true);
+  useEventListener(target, "seeked", () => seeking.value = false);
+  useEventListener(target, ["waiting", "loadstart"], () => {
+    waiting.value = true;
+    ignorePlayingUpdates(() => playing.value = false);
+  });
+  useEventListener(target, "loadeddata", () => waiting.value = false);
+  useEventListener(target, "playing", () => {
+    waiting.value = false;
+    ended.value = false;
+    ignorePlayingUpdates(() => playing.value = true);
+  });
+  useEventListener(target, "ratechange", () => rate.value = toValue(target).playbackRate);
+  useEventListener(target, "stalled", () => stalled.value = true);
+  useEventListener(target, "ended", () => ended.value = true);
+  useEventListener(target, "pause", () => ignorePlayingUpdates(() => playing.value = false));
+  useEventListener(target, "play", () => ignorePlayingUpdates(() => playing.value = true));
+  useEventListener(target, "enterpictureinpicture", () => isPictureInPicture.value = true);
+  useEventListener(target, "leavepictureinpicture", () => isPictureInPicture.value = false);
+  useEventListener(target, "volumechange", () => {
+    const el = toValue(target);
+    if (!el)
+      return;
+    volume.value = el.volume;
+    muted.value = el.muted;
+  });
+  const listeners = [];
+  const stop = watch([target], () => {
+    const el = toValue(target);
+    if (!el)
+      return;
+    stop();
+    listeners[0] = useEventListener(el.textTracks, "addtrack", () => tracks.value = tracksToArray(el.textTracks));
+    listeners[1] = useEventListener(el.textTracks, "removetrack", () => tracks.value = tracksToArray(el.textTracks));
+    listeners[2] = useEventListener(el.textTracks, "change", () => tracks.value = tracksToArray(el.textTracks));
+  });
+  tryOnScopeDispose(() => listeners.forEach((listener) => listener()));
+  return {
+    currentTime,
+    duration,
+    waiting,
+    seeking,
+    ended,
+    stalled,
+    buffered,
+    playing,
+    rate,
+    // Volume
+    volume,
+    muted,
+    // Tracks
+    tracks,
+    selectedTrack,
+    enableTrack,
+    disableTrack,
+    // Picture in Picture
+    supportsPictureInPicture,
+    togglePictureInPicture,
+    isPictureInPicture,
+    // Events
+    onSourceError: sourceErrorEvent.on
+  };
+}
+
+function getMapVue2Compat() {
+  const data = shallowReactive({});
+  return {
+    get: (key) => data[key],
+    set: (key, value) => set(data, key, value),
+    has: (key) => hasOwn(data, key),
+    delete: (key) => del(data, key),
+    clear: () => {
+      Object.keys(data).forEach((key) => {
+        del(data, key);
+      });
+    }
+  };
+}
+function useMemoize(resolver, options) {
+  const initCache = () => {
+    if (options == null ? void 0 : options.cache)
+      return shallowReactive(options.cache);
+    if (isVue2)
+      return getMapVue2Compat();
+    return shallowReactive(/* @__PURE__ */ new Map());
+  };
+  const cache = initCache();
+  const generateKey = (...args) => (options == null ? void 0 : options.getKey) ? options.getKey(...args) : JSON.stringify(args);
+  const _loadData = (key, ...args) => {
+    cache.set(key, resolver(...args));
+    return cache.get(key);
+  };
+  const loadData = (...args) => _loadData(generateKey(...args), ...args);
+  const deleteData = (...args) => {
+    cache.delete(generateKey(...args));
+  };
+  const clearData = () => {
+    cache.clear();
+  };
+  const memoized = (...args) => {
+    const key = generateKey(...args);
+    if (cache.has(key))
+      return cache.get(key);
+    return _loadData(key, ...args);
+  };
+  memoized.load = loadData;
+  memoized.delete = deleteData;
+  memoized.clear = clearData;
+  memoized.generateKey = generateKey;
+  memoized.cache = cache;
+  return memoized;
+}
+
+function useMemory(options = {}) {
+  const memory = ref();
+  const isSupported = useSupported(() => typeof performance !== "undefined" && "memory" in performance);
+  if (isSupported.value) {
+    const { interval = 1e3 } = options;
+    useIntervalFn(() => {
+      memory.value = performance.memory;
+    }, interval, { immediate: options.immediate, immediateCallback: options.immediateCallback });
+  }
+  return { isSupported, memory };
+}
+
+const UseMouseBuiltinExtractors = {
+  page: (event) => [event.pageX, event.pageY],
+  client: (event) => [event.clientX, event.clientY],
+  screen: (event) => [event.screenX, event.screenY],
+  movement: (event) => event instanceof Touch ? null : [event.movementX, event.movementY]
+};
+function useMouse(options = {}) {
+  const {
+    type = "page",
+    touch = true,
+    resetOnTouchEnds = false,
+    initialValue = { x: 0, y: 0 },
+    window = defaultWindow,
+    target = window,
+    scroll = true,
+    eventFilter
+  } = options;
+  let _prevMouseEvent = null;
+  const x = ref(initialValue.x);
+  const y = ref(initialValue.y);
+  const sourceType = ref(null);
+  const extractor = typeof type === "function" ? type : UseMouseBuiltinExtractors[type];
+  const mouseHandler = (event) => {
+    const result = extractor(event);
+    _prevMouseEvent = event;
+    if (result) {
+      [x.value, y.value] = result;
+      sourceType.value = "mouse";
+    }
+  };
+  const touchHandler = (event) => {
+    if (event.touches.length > 0) {
+      const result = extractor(event.touches[0]);
+      if (result) {
+        [x.value, y.value] = result;
+        sourceType.value = "touch";
+      }
+    }
+  };
+  const scrollHandler = () => {
+    if (!_prevMouseEvent || !window)
+      return;
+    const pos = extractor(_prevMouseEvent);
+    if (_prevMouseEvent instanceof MouseEvent && pos) {
+      x.value = pos[0] + window.scrollX;
+      y.value = pos[1] + window.scrollY;
+    }
+  };
+  const reset = () => {
+    x.value = initialValue.x;
+    y.value = initialValue.y;
+  };
+  const mouseHandlerWrapper = eventFilter ? (event) => eventFilter(() => mouseHandler(event), {}) : (event) => mouseHandler(event);
+  const touchHandlerWrapper = eventFilter ? (event) => eventFilter(() => touchHandler(event), {}) : (event) => touchHandler(event);
+  const scrollHandlerWrapper = eventFilter ? () => eventFilter(() => scrollHandler(), {}) : () => scrollHandler();
+  if (target) {
+    const listenerOptions = { passive: true };
+    useEventListener(target, ["mousemove", "dragover"], mouseHandlerWrapper, listenerOptions);
+    if (touch && type !== "movement") {
+      useEventListener(target, ["touchstart", "touchmove"], touchHandlerWrapper, listenerOptions);
+      if (resetOnTouchEnds)
+        useEventListener(target, "touchend", reset, listenerOptions);
+    }
+    if (scroll && type === "page")
+      useEventListener(window, "scroll", scrollHandlerWrapper, { passive: true });
+  }
+  return {
+    x,
+    y,
+    sourceType
+  };
+}
+
+function useMouseInElement(target, options = {}) {
+  const {
+    handleOutside = true,
+    window = defaultWindow
+  } = options;
+  const type = options.type || "page";
+  const { x, y, sourceType } = useMouse(options);
+  const targetRef = ref(target != null ? target : window == null ? void 0 : window.document.body);
+  const elementX = ref(0);
+  const elementY = ref(0);
+  const elementPositionX = ref(0);
+  const elementPositionY = ref(0);
+  const elementHeight = ref(0);
+  const elementWidth = ref(0);
+  const isOutside = ref(true);
+  let stop = () => {
+  };
+  if (window) {
+    stop = watch(
+      [targetRef, x, y],
+      () => {
+        const el = unrefElement(targetRef);
+        if (!el)
+          return;
+        const {
+          left,
+          top,
+          width,
+          height
+        } = el.getBoundingClientRect();
+        elementPositionX.value = left + (type === "page" ? window.pageXOffset : 0);
+        elementPositionY.value = top + (type === "page" ? window.pageYOffset : 0);
+        elementHeight.value = height;
+        elementWidth.value = width;
+        const elX = x.value - elementPositionX.value;
+        const elY = y.value - elementPositionY.value;
+        isOutside.value = width === 0 || height === 0 || elX < 0 || elY < 0 || elX > width || elY > height;
+        if (handleOutside || !isOutside.value) {
+          elementX.value = elX;
+          elementY.value = elY;
+        }
+      },
+      { immediate: true }
+    );
+    useEventListener(document, "mouseleave", () => {
+      isOutside.value = true;
+    });
+  }
+  return {
+    x,
+    y,
+    sourceType,
+    elementX,
+    elementY,
+    elementPositionX,
+    elementPositionY,
+    elementHeight,
+    elementWidth,
+    isOutside,
+    stop
+  };
+}
+
+function useMousePressed(options = {}) {
+  const {
+    touch = true,
+    drag = true,
+    capture = false,
+    initialValue = false,
+    window = defaultWindow
+  } = options;
+  const pressed = ref(initialValue);
+  const sourceType = ref(null);
+  if (!window) {
+    return {
+      pressed,
+      sourceType
+    };
+  }
+  const onPressed = (srcType) => () => {
+    pressed.value = true;
+    sourceType.value = srcType;
+  };
+  const onReleased = () => {
+    pressed.value = false;
+    sourceType.value = null;
+  };
+  const target = computed(() => unrefElement(options.target) || window);
+  useEventListener(target, "mousedown", onPressed("mouse"), { passive: true, capture });
+  useEventListener(window, "mouseleave", onReleased, { passive: true, capture });
+  useEventListener(window, "mouseup", onReleased, { passive: true, capture });
+  if (drag) {
+    useEventListener(target, "dragstart", onPressed("mouse"), { passive: true, capture });
+    useEventListener(window, "drop", onReleased, { passive: true, capture });
+    useEventListener(window, "dragend", onReleased, { passive: true, capture });
+  }
+  if (touch) {
+    useEventListener(target, "touchstart", onPressed("touch"), { passive: true, capture });
+    useEventListener(window, "touchend", onReleased, { passive: true, capture });
+    useEventListener(window, "touchcancel", onReleased, { passive: true, capture });
+  }
+  return {
+    pressed,
+    sourceType
+  };
+}
+
+function useNavigatorLanguage(options = {}) {
+  const { window = defaultWindow } = options;
+  const navigator = window == null ? void 0 : window.navigator;
+  const isSupported = useSupported(() => navigator && "language" in navigator);
+  const language = ref(navigator == null ? void 0 : navigator.language);
+  useEventListener(window, "languagechange", () => {
+    if (navigator)
+      language.value = navigator.language;
+  });
+  return {
+    isSupported,
+    language
+  };
+}
+
+function useNetwork(options = {}) {
+  const { window = defaultWindow } = options;
+  const navigator = window == null ? void 0 : window.navigator;
+  const isSupported = useSupported(() => navigator && "connection" in navigator);
+  const isOnline = ref(true);
+  const saveData = ref(false);
+  const offlineAt = ref(void 0);
+  const onlineAt = ref(void 0);
+  const downlink = ref(void 0);
+  const downlinkMax = ref(void 0);
+  const rtt = ref(void 0);
+  const effectiveType = ref(void 0);
+  const type = ref("unknown");
+  const connection = isSupported.value && navigator.connection;
+  function updateNetworkInformation() {
+    if (!navigator)
+      return;
+    isOnline.value = navigator.onLine;
+    offlineAt.value = isOnline.value ? void 0 : Date.now();
+    onlineAt.value = isOnline.value ? Date.now() : void 0;
+    if (connection) {
+      downlink.value = connection.downlink;
+      downlinkMax.value = connection.downlinkMax;
+      effectiveType.value = connection.effectiveType;
+      rtt.value = connection.rtt;
+      saveData.value = connection.saveData;
+      type.value = connection.type;
+    }
+  }
+  if (window) {
+    useEventListener(window, "offline", () => {
+      isOnline.value = false;
+      offlineAt.value = Date.now();
+    });
+    useEventListener(window, "online", () => {
+      isOnline.value = true;
+      onlineAt.value = Date.now();
+    });
+  }
+  if (connection)
+    useEventListener(connection, "change", updateNetworkInformation, false);
+  updateNetworkInformation();
+  return {
+    isSupported,
+    isOnline,
+    saveData,
+    offlineAt,
+    onlineAt,
+    downlink,
+    downlinkMax,
+    effectiveType,
+    rtt,
+    type
+  };
+}
+
+function useNow(options = {}) {
+  const {
+    controls: exposeControls = false,
+    interval = "requestAnimationFrame"
+  } = options;
+  const now = ref(/* @__PURE__ */ new Date());
+  const update = () => now.value = /* @__PURE__ */ new Date();
+  const controls = interval === "requestAnimationFrame" ? useRafFn(update, { immediate: true }) : useIntervalFn(update, interval, { immediate: true });
+  if (exposeControls) {
+    return {
+      now,
+      ...controls
+    };
+  } else {
+    return now;
+  }
+}
+
+function useObjectUrl(object) {
+  const url = ref();
+  const release = () => {
+    if (url.value)
+      URL.revokeObjectURL(url.value);
+    url.value = void 0;
+  };
+  watch(
+    () => toValue(object),
+    (newObject) => {
+      release();
+      if (newObject)
+        url.value = URL.createObjectURL(newObject);
+    },
+    { immediate: true }
+  );
+  tryOnScopeDispose(release);
+  return readonly(url);
+}
+
+function useClamp(value, min, max) {
+  if (typeof value === "function" || isReadonly(value))
+    return computed(() => clamp(toValue(value), toValue(min), toValue(max)));
+  const _value = ref(value);
+  return computed({
+    get() {
+      return _value.value = clamp(_value.value, toValue(min), toValue(max));
+    },
+    set(value2) {
+      _value.value = clamp(value2, toValue(min), toValue(max));
+    }
+  });
+}
+
+function useOffsetPagination(options) {
+  const {
+    total = Number.POSITIVE_INFINITY,
+    pageSize = 10,
+    page = 1,
+    onPageChange = noop,
+    onPageSizeChange = noop,
+    onPageCountChange = noop
+  } = options;
+  const currentPageSize = useClamp(pageSize, 1, Number.POSITIVE_INFINITY);
+  const pageCount = computed(() => Math.max(
+    1,
+    Math.ceil(toValue(total) / toValue(currentPageSize))
+  ));
+  const currentPage = useClamp(page, 1, pageCount);
+  const isFirstPage = computed(() => currentPage.value === 1);
+  const isLastPage = computed(() => currentPage.value === pageCount.value);
+  if (isRef(page)) {
+    syncRef(page, currentPage, {
+      direction: isReadonly(page) ? "ltr" : "both"
+    });
+  }
+  if (isRef(pageSize)) {
+    syncRef(pageSize, currentPageSize, {
+      direction: isReadonly(pageSize) ? "ltr" : "both"
+    });
+  }
+  function prev() {
+    currentPage.value--;
+  }
+  function next() {
+    currentPage.value++;
+  }
+  const returnValue = {
+    currentPage,
+    currentPageSize,
+    pageCount,
+    isFirstPage,
+    isLastPage,
+    prev,
+    next
+  };
+  watch(currentPage, () => {
+    onPageChange(reactive(returnValue));
+  });
+  watch(currentPageSize, () => {
+    onPageSizeChange(reactive(returnValue));
+  });
+  watch(pageCount, () => {
+    onPageCountChange(reactive(returnValue));
+  });
+  return returnValue;
+}
+
+function useOnline(options = {}) {
+  const { isOnline } = useNetwork(options);
+  return isOnline;
+}
+
+function usePageLeave(options = {}) {
+  const { window = defaultWindow } = options;
+  const isLeft = ref(false);
+  const handler = (event) => {
+    if (!window)
+      return;
+    event = event || window.event;
+    const from = event.relatedTarget || event.toElement;
+    isLeft.value = !from;
+  };
+  if (window) {
+    useEventListener(window, "mouseout", handler, { passive: true });
+    useEventListener(window.document, "mouseleave", handler, { passive: true });
+    useEventListener(window.document, "mouseenter", handler, { passive: true });
+  }
+  return isLeft;
+}
+
+function useParallax(target, options = {}) {
+  const {
+    deviceOrientationTiltAdjust = (i) => i,
+    deviceOrientationRollAdjust = (i) => i,
+    mouseTiltAdjust = (i) => i,
+    mouseRollAdjust = (i) => i,
+    window = defaultWindow
+  } = options;
+  const orientation = reactive(useDeviceOrientation({ window }));
+  const {
+    elementX: x,
+    elementY: y,
+    elementWidth: width,
+    elementHeight: height
+  } = useMouseInElement(target, { handleOutside: false, window });
+  const source = computed(() => {
+    if (orientation.isSupported && (orientation.alpha != null && orientation.alpha !== 0 || orientation.gamma != null && orientation.gamma !== 0))
+      return "deviceOrientation";
+    return "mouse";
+  });
+  const roll = computed(() => {
+    if (source.value === "deviceOrientation") {
+      const value = -orientation.beta / 90;
+      return deviceOrientationRollAdjust(value);
+    } else {
+      const value = -(y.value - height.value / 2) / height.value;
+      return mouseRollAdjust(value);
+    }
+  });
+  const tilt = computed(() => {
+    if (source.value === "deviceOrientation") {
+      const value = orientation.gamma / 90;
+      return deviceOrientationTiltAdjust(value);
+    } else {
+      const value = (x.value - width.value / 2) / width.value;
+      return mouseTiltAdjust(value);
+    }
+  });
+  return { roll, tilt, source };
+}
+
+function useParentElement(element = useCurrentElement()) {
+  const parentElement = shallowRef();
+  const update = () => {
+    const el = unrefElement(element);
+    if (el)
+      parentElement.value = el.parentElement;
+  };
+  tryOnMounted(update);
+  watch(() => toValue(element), update);
+  return parentElement;
+}
+
+function usePerformanceObserver(options, callback) {
+  const {
+    window = defaultWindow,
+    immediate = true,
+    ...performanceOptions
+  } = options;
+  const isSupported = useSupported(() => window && "PerformanceObserver" in window);
+  let observer;
+  const stop = () => {
+    observer == null ? void 0 : observer.disconnect();
+  };
+  const start = () => {
+    if (isSupported.value) {
+      stop();
+      observer = new PerformanceObserver(callback);
+      observer.observe(performanceOptions);
+    }
+  };
+  tryOnScopeDispose(stop);
+  if (immediate)
+    start();
+  return {
+    isSupported,
+    start,
+    stop
+  };
+}
+
+const defaultState = {
+  x: 0,
+  y: 0,
+  pointerId: 0,
+  pressure: 0,
+  tiltX: 0,
+  tiltY: 0,
+  width: 0,
+  height: 0,
+  twist: 0,
+  pointerType: null
+};
+const keys = /* @__PURE__ */ Object.keys(defaultState);
+function usePointer(options = {}) {
+  const {
+    target = defaultWindow
+  } = options;
+  const isInside = ref(false);
+  const state = ref(options.initialValue || {});
+  Object.assign(state.value, defaultState, state.value);
+  const handler = (event) => {
+    isInside.value = true;
+    if (options.pointerTypes && !options.pointerTypes.includes(event.pointerType))
+      return;
+    state.value = objectPick(event, keys, false);
+  };
+  if (target) {
+    const listenerOptions = { passive: true };
+    useEventListener(target, ["pointerdown", "pointermove", "pointerup"], handler, listenerOptions);
+    useEventListener(target, "pointerleave", () => isInside.value = false, listenerOptions);
+  }
+  return {
+    ...toRefs(state),
+    isInside
+  };
+}
+
+function usePointerLock(target, options = {}) {
+  const { document = defaultDocument, pointerLockOptions } = options;
+  const isSupported = useSupported(() => document && "pointerLockElement" in document);
+  const element = ref();
+  const triggerElement = ref();
+  let targetElement;
+  if (isSupported.value) {
+    useEventListener(document, "pointerlockchange", () => {
+      var _a;
+      const currentElement = (_a = document.pointerLockElement) != null ? _a : element.value;
+      if (targetElement && currentElement === targetElement) {
+        element.value = document.pointerLockElement;
+        if (!element.value)
+          targetElement = triggerElement.value = null;
+      }
+    });
+    useEventListener(document, "pointerlockerror", () => {
+      var _a;
+      const currentElement = (_a = document.pointerLockElement) != null ? _a : element.value;
+      if (targetElement && currentElement === targetElement) {
+        const action = document.pointerLockElement ? "release" : "acquire";
+        throw new Error(`Failed to ${action} pointer lock.`);
+      }
+    });
+  }
+  async function lock(e, options2) {
+    var _a;
+    if (!isSupported.value)
+      throw new Error("Pointer Lock API is not supported by your browser.");
+    triggerElement.value = e instanceof Event ? e.currentTarget : null;
+    targetElement = e instanceof Event ? (_a = unrefElement(target)) != null ? _a : triggerElement.value : unrefElement(e);
+    if (!targetElement)
+      throw new Error("Target element undefined.");
+    targetElement.requestPointerLock(options2 != null ? options2 : pointerLockOptions);
+    return await until(element).toBe(targetElement);
+  }
+  async function unlock() {
+    if (!element.value)
+      return false;
+    document.exitPointerLock();
+    await until(element).toBeNull();
+    return true;
+  }
+  return {
+    isSupported,
+    element,
+    triggerElement,
+    lock,
+    unlock
+  };
+}
+
+function usePointerSwipe(target, options = {}) {
+  const targetRef = toRef(target);
+  const {
+    threshold = 50,
+    onSwipe,
+    onSwipeEnd,
+    onSwipeStart,
+    disableTextSelect = false
+  } = options;
+  const posStart = reactive({ x: 0, y: 0 });
+  const updatePosStart = (x, y) => {
+    posStart.x = x;
+    posStart.y = y;
+  };
+  const posEnd = reactive({ x: 0, y: 0 });
+  const updatePosEnd = (x, y) => {
+    posEnd.x = x;
+    posEnd.y = y;
+  };
+  const distanceX = computed(() => posStart.x - posEnd.x);
+  const distanceY = computed(() => posStart.y - posEnd.y);
+  const { max, abs } = Math;
+  const isThresholdExceeded = computed(() => max(abs(distanceX.value), abs(distanceY.value)) >= threshold);
+  const isSwiping = ref(false);
+  const isPointerDown = ref(false);
+  const direction = computed(() => {
+    if (!isThresholdExceeded.value)
+      return "none";
+    if (abs(distanceX.value) > abs(distanceY.value)) {
+      return distanceX.value > 0 ? "left" : "right";
+    } else {
+      return distanceY.value > 0 ? "up" : "down";
+    }
+  });
+  const eventIsAllowed = (e) => {
+    var _a, _b, _c;
+    const isReleasingButton = e.buttons === 0;
+    const isPrimaryButton = e.buttons === 1;
+    return (_c = (_b = (_a = options.pointerTypes) == null ? void 0 : _a.includes(e.pointerType)) != null ? _b : isReleasingButton || isPrimaryButton) != null ? _c : true;
+  };
+  const stops = [
+    useEventListener(target, "pointerdown", (e) => {
+      if (!eventIsAllowed(e))
+        return;
+      isPointerDown.value = true;
+      const eventTarget = e.target;
+      eventTarget == null ? void 0 : eventTarget.setPointerCapture(e.pointerId);
+      const { clientX: x, clientY: y } = e;
+      updatePosStart(x, y);
+      updatePosEnd(x, y);
+      onSwipeStart == null ? void 0 : onSwipeStart(e);
+    }),
+    useEventListener(target, "pointermove", (e) => {
+      if (!eventIsAllowed(e))
+        return;
+      if (!isPointerDown.value)
+        return;
+      const { clientX: x, clientY: y } = e;
+      updatePosEnd(x, y);
+      if (!isSwiping.value && isThresholdExceeded.value)
+        isSwiping.value = true;
+      if (isSwiping.value)
+        onSwipe == null ? void 0 : onSwipe(e);
+    }),
+    useEventListener(target, "pointerup", (e) => {
+      if (!eventIsAllowed(e))
+        return;
+      if (isSwiping.value)
+        onSwipeEnd == null ? void 0 : onSwipeEnd(e, direction.value);
+      isPointerDown.value = false;
+      isSwiping.value = false;
+    })
+  ];
+  tryOnMounted(() => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    (_b = (_a = targetRef.value) == null ? void 0 : _a.style) == null ? void 0 : _b.setProperty("touch-action", "none");
+    if (disableTextSelect) {
+      (_d = (_c = targetRef.value) == null ? void 0 : _c.style) == null ? void 0 : _d.setProperty("-webkit-user-select", "none");
+      (_f = (_e = targetRef.value) == null ? void 0 : _e.style) == null ? void 0 : _f.setProperty("-ms-user-select", "none");
+      (_h = (_g = targetRef.value) == null ? void 0 : _g.style) == null ? void 0 : _h.setProperty("user-select", "none");
+    }
+  });
+  const stop = () => stops.forEach((s) => s());
+  return {
+    isSwiping: readonly(isSwiping),
+    direction: readonly(direction),
+    posStart: readonly(posStart),
+    posEnd: readonly(posEnd),
+    distanceX,
+    distanceY,
+    stop
+  };
+}
+
+function usePreferredColorScheme(options) {
+  const isLight = useMediaQuery("(prefers-color-scheme: light)", options);
+  const isDark = useMediaQuery("(prefers-color-scheme: dark)", options);
+  return computed(() => {
+    if (isDark.value)
+      return "dark";
+    if (isLight.value)
+      return "light";
+    return "no-preference";
+  });
+}
+
+function usePreferredContrast(options) {
+  const isMore = useMediaQuery("(prefers-contrast: more)", options);
+  const isLess = useMediaQuery("(prefers-contrast: less)", options);
+  const isCustom = useMediaQuery("(prefers-contrast: custom)", options);
+  return computed(() => {
+    if (isMore.value)
+      return "more";
+    if (isLess.value)
+      return "less";
+    if (isCustom.value)
+      return "custom";
+    return "no-preference";
+  });
+}
+
+function usePreferredLanguages(options = {}) {
+  const { window = defaultWindow } = options;
+  if (!window)
+    return ref(["en"]);
+  const navigator = window.navigator;
+  const value = ref(navigator.languages);
+  useEventListener(window, "languagechange", () => {
+    value.value = navigator.languages;
+  });
+  return value;
+}
+
+function usePreferredReducedMotion(options) {
+  const isReduced = useMediaQuery("(prefers-reduced-motion: reduce)", options);
+  return computed(() => {
+    if (isReduced.value)
+      return "reduce";
+    return "no-preference";
+  });
+}
+
+function usePrevious(value, initialValue) {
+  const previous = shallowRef(initialValue);
+  watch(
+    toRef(value),
+    (_, oldValue) => {
+      previous.value = oldValue;
+    },
+    { flush: "sync" }
+  );
+  return readonly(previous);
+}
+
+function useScreenOrientation(options = {}) {
+  const {
+    window = defaultWindow
+  } = options;
+  const isSupported = useSupported(() => window && "screen" in window && "orientation" in window.screen);
+  const screenOrientation = isSupported.value ? window.screen.orientation : {};
+  const orientation = ref(screenOrientation.type);
+  const angle = ref(screenOrientation.angle || 0);
+  if (isSupported.value) {
+    useEventListener(window, "orientationchange", () => {
+      orientation.value = screenOrientation.type;
+      angle.value = screenOrientation.angle;
+    });
+  }
+  const lockOrientation = (type) => {
+    if (isSupported.value && typeof screenOrientation.lock === "function")
+      return screenOrientation.lock(type);
+    return Promise.reject(new Error("Not supported"));
+  };
+  const unlockOrientation = () => {
+    if (isSupported.value && typeof screenOrientation.unlock === "function")
+      screenOrientation.unlock();
+  };
+  return {
+    isSupported,
+    orientation,
+    angle,
+    lockOrientation,
+    unlockOrientation
+  };
+}
+
+const topVarName = "--vueuse-safe-area-top";
+const rightVarName = "--vueuse-safe-area-right";
+const bottomVarName = "--vueuse-safe-area-bottom";
+const leftVarName = "--vueuse-safe-area-left";
+function useScreenSafeArea() {
+  const top = ref("");
+  const right = ref("");
+  const bottom = ref("");
+  const left = ref("");
+  if (isClient) {
+    const topCssVar = useCssVar(topVarName);
+    const rightCssVar = useCssVar(rightVarName);
+    const bottomCssVar = useCssVar(bottomVarName);
+    const leftCssVar = useCssVar(leftVarName);
+    topCssVar.value = "env(safe-area-inset-top, 0px)";
+    rightCssVar.value = "env(safe-area-inset-right, 0px)";
+    bottomCssVar.value = "env(safe-area-inset-bottom, 0px)";
+    leftCssVar.value = "env(safe-area-inset-left, 0px)";
+    update();
+    useEventListener("resize", useDebounceFn(update));
+  }
+  function update() {
+    top.value = getValue(topVarName);
+    right.value = getValue(rightVarName);
+    bottom.value = getValue(bottomVarName);
+    left.value = getValue(leftVarName);
+  }
+  return {
+    top,
+    right,
+    bottom,
+    left,
+    update
+  };
+}
+function getValue(position) {
+  return getComputedStyle(document.documentElement).getPropertyValue(position);
+}
+
+function useScriptTag(src, onLoaded = noop, options = {}) {
+  const {
+    immediate = true,
+    manual = false,
+    type = "text/javascript",
+    async = true,
+    crossOrigin,
+    referrerPolicy,
+    noModule,
+    defer,
+    document = defaultDocument,
+    attrs = {}
+  } = options;
+  const scriptTag = ref(null);
+  let _promise = null;
+  const loadScript = (waitForScriptLoad) => new Promise((resolve, reject) => {
+    const resolveWithElement = (el2) => {
+      scriptTag.value = el2;
+      resolve(el2);
+      return el2;
+    };
+    if (!document) {
+      resolve(false);
+      return;
+    }
+    let shouldAppend = false;
+    let el = document.querySelector(`script[src="${toValue(src)}"]`);
+    if (!el) {
+      el = document.createElement("script");
+      el.type = type;
+      el.async = async;
+      el.src = toValue(src);
+      if (defer)
+        el.defer = defer;
+      if (crossOrigin)
+        el.crossOrigin = crossOrigin;
+      if (noModule)
+        el.noModule = noModule;
+      if (referrerPolicy)
+        el.referrerPolicy = referrerPolicy;
+      Object.entries(attrs).forEach(([name, value]) => el == null ? void 0 : el.setAttribute(name, value));
+      shouldAppend = true;
+    } else if (el.hasAttribute("data-loaded")) {
+      resolveWithElement(el);
+    }
+    el.addEventListener("error", (event) => reject(event));
+    el.addEventListener("abort", (event) => reject(event));
+    el.addEventListener("load", () => {
+      el.setAttribute("data-loaded", "true");
+      onLoaded(el);
+      resolveWithElement(el);
+    });
+    if (shouldAppend)
+      el = document.head.appendChild(el);
+    if (!waitForScriptLoad)
+      resolveWithElement(el);
+  });
+  const load = (waitForScriptLoad = true) => {
+    if (!_promise)
+      _promise = loadScript(waitForScriptLoad);
+    return _promise;
+  };
+  const unload = () => {
+    if (!document)
+      return;
+    _promise = null;
+    if (scriptTag.value)
+      scriptTag.value = null;
+    const el = document.querySelector(`script[src="${toValue(src)}"]`);
+    if (el)
+      document.head.removeChild(el);
+  };
+  if (immediate && !manual)
+    tryOnMounted(load);
+  if (!manual)
+    tryOnUnmounted(unload);
+  return { scriptTag, load, unload };
+}
+
+function checkOverflowScroll(ele) {
+  const style = window.getComputedStyle(ele);
+  if (style.overflowX === "scroll" || style.overflowY === "scroll" || style.overflowX === "auto" && ele.clientWidth < ele.scrollWidth || style.overflowY === "auto" && ele.clientHeight < ele.scrollHeight) {
+    return true;
+  } else {
+    const parent = ele.parentNode;
+    if (!parent || parent.tagName === "BODY")
+      return false;
+    return checkOverflowScroll(parent);
+  }
+}
+function preventDefault(rawEvent) {
+  const e = rawEvent || window.event;
+  const _target = e.target;
+  if (checkOverflowScroll(_target))
+    return false;
+  if (e.touches.length > 1)
+    return true;
+  if (e.preventDefault)
+    e.preventDefault();
+  return false;
+}
+const elInitialOverflow = /* @__PURE__ */ new WeakMap();
+function useScrollLock(element, initialState = false) {
+  const isLocked = ref(initialState);
+  let stopTouchMoveListener = null;
+  let initialOverflow;
+  watch(toRef(element), (el) => {
+    const target = resolveElement(toValue(el));
+    if (target) {
+      const ele = target;
+      if (!elInitialOverflow.get(ele))
+        elInitialOverflow.set(ele, initialOverflow);
+      if (isLocked.value)
+        ele.style.overflow = "hidden";
+    }
+  }, {
+    immediate: true
+  });
+  const lock = () => {
+    const el = resolveElement(toValue(element));
+    if (!el || isLocked.value)
+      return;
+    if (isIOS) {
+      stopTouchMoveListener = useEventListener(
+        el,
+        "touchmove",
+        (e) => {
+          preventDefault(e);
+        },
+        { passive: false }
+      );
+    }
+    el.style.overflow = "hidden";
+    isLocked.value = true;
+  };
+  const unlock = () => {
+    var _a;
+    const el = resolveElement(toValue(element));
+    if (!el || !isLocked.value)
+      return;
+    isIOS && (stopTouchMoveListener == null ? void 0 : stopTouchMoveListener());
+    el.style.overflow = (_a = elInitialOverflow.get(el)) != null ? _a : "";
+    elInitialOverflow.delete(el);
+    isLocked.value = false;
+  };
+  tryOnScopeDispose(unlock);
+  return computed({
+    get() {
+      return isLocked.value;
+    },
+    set(v) {
+      if (v)
+        lock();
+      else
+        unlock();
+    }
+  });
+}
+
+function useSessionStorage(key, initialValue, options = {}) {
+  const { window = defaultWindow } = options;
+  return useStorage(key, initialValue, window == null ? void 0 : window.sessionStorage, options);
+}
+
+function useShare(shareOptions = {}, options = {}) {
+  const { navigator = defaultNavigator } = options;
+  const _navigator = navigator;
+  const isSupported = useSupported(() => _navigator && "canShare" in _navigator);
+  const share = async (overrideOptions = {}) => {
+    if (isSupported.value) {
+      const data = {
+        ...toValue(shareOptions),
+        ...toValue(overrideOptions)
+      };
+      let granted = true;
+      if (data.files && _navigator.canShare)
+        granted = _navigator.canShare({ files: data.files });
+      if (granted)
+        return _navigator.share(data);
+    }
+  };
+  return {
+    isSupported,
+    share
+  };
+}
+
+const defaultSortFn = (source, compareFn) => source.sort(compareFn);
+const defaultCompare = (a, b) => a - b;
+function useSorted(...args) {
+  var _a, _b, _c, _d;
+  const [source] = args;
+  let compareFn = defaultCompare;
+  let options = {};
+  if (args.length === 2) {
+    if (typeof args[1] === "object") {
+      options = args[1];
+      compareFn = (_a = options.compareFn) != null ? _a : defaultCompare;
+    } else {
+      compareFn = (_b = args[1]) != null ? _b : defaultCompare;
+    }
+  } else if (args.length > 2) {
+    compareFn = (_c = args[1]) != null ? _c : defaultCompare;
+    options = (_d = args[2]) != null ? _d : {};
+  }
+  const {
+    dirty = false,
+    sortFn = defaultSortFn
+  } = options;
+  if (!dirty)
+    return computed(() => sortFn([...toValue(source)], compareFn));
+  watchEffect(() => {
+    const result = sortFn(toValue(source), compareFn);
+    if (isRef(source))
+      source.value = result;
+    else
+      source.splice(0, source.length, ...result);
+  });
+  return source;
+}
+
+function useSpeechRecognition(options = {}) {
+  const {
+    interimResults = true,
+    continuous = true,
+    window = defaultWindow
+  } = options;
+  const lang = toRef(options.lang || "en-US");
+  const isListening = ref(false);
+  const isFinal = ref(false);
+  const result = ref("");
+  const error = shallowRef(void 0);
+  const toggle = (value = !isListening.value) => {
+    isListening.value = value;
+  };
+  const start = () => {
+    isListening.value = true;
+  };
+  const stop = () => {
+    isListening.value = false;
+  };
+  const SpeechRecognition = window && (window.SpeechRecognition || window.webkitSpeechRecognition);
+  const isSupported = useSupported(() => SpeechRecognition);
+  let recognition;
+  if (isSupported.value) {
+    recognition = new SpeechRecognition();
+    recognition.continuous = continuous;
+    recognition.interimResults = interimResults;
+    recognition.lang = toValue(lang);
+    recognition.onstart = () => {
+      isFinal.value = false;
+    };
+    watch(lang, (lang2) => {
+      if (recognition && !isListening.value)
+        recognition.lang = lang2;
+    });
+    recognition.onresult = (event) => {
+      const transcript = Array.from(event.results).map((result2) => {
+        isFinal.value = result2.isFinal;
+        return result2[0];
+      }).map((result2) => result2.transcript).join("");
+      result.value = transcript;
+      error.value = void 0;
+    };
+    recognition.onerror = (event) => {
+      error.value = event;
+    };
+    recognition.onend = () => {
+      isListening.value = false;
+      recognition.lang = toValue(lang);
+    };
+    watch(isListening, () => {
+      if (isListening.value)
+        recognition.start();
+      else
+        recognition.stop();
+    });
+  }
+  tryOnScopeDispose(() => {
+    isListening.value = false;
+  });
+  return {
+    isSupported,
+    isListening,
+    isFinal,
+    recognition,
+    result,
+    error,
+    toggle,
+    start,
+    stop
+  };
+}
+
+function useSpeechSynthesis(text, options = {}) {
+  const {
+    pitch = 1,
+    rate = 1,
+    volume = 1,
+    window = defaultWindow
+  } = options;
+  const synth = window && window.speechSynthesis;
+  const isSupported = useSupported(() => synth);
+  const isPlaying = ref(false);
+  const status = ref("init");
+  const spokenText = toRef(text || "");
+  const lang = toRef(options.lang || "en-US");
+  const error = shallowRef(void 0);
+  const toggle = (value = !isPlaying.value) => {
+    isPlaying.value = value;
+  };
+  const bindEventsForUtterance = (utterance2) => {
+    utterance2.lang = toValue(lang);
+    utterance2.voice = toValue(options.voice) || null;
+    utterance2.pitch = toValue(pitch);
+    utterance2.rate = toValue(rate);
+    utterance2.volume = volume;
+    utterance2.onstart = () => {
+      isPlaying.value = true;
+      status.value = "play";
+    };
+    utterance2.onpause = () => {
+      isPlaying.value = false;
+      status.value = "pause";
+    };
+    utterance2.onresume = () => {
+      isPlaying.value = true;
+      status.value = "play";
+    };
+    utterance2.onend = () => {
+      isPlaying.value = false;
+      status.value = "end";
+    };
+    utterance2.onerror = (event) => {
+      error.value = event;
+    };
+  };
+  const utterance = computed(() => {
+    isPlaying.value = false;
+    status.value = "init";
+    const newUtterance = new SpeechSynthesisUtterance(spokenText.value);
+    bindEventsForUtterance(newUtterance);
+    return newUtterance;
+  });
+  const speak = () => {
+    synth.cancel();
+    utterance && synth.speak(utterance.value);
+  };
+  const stop = () => {
+    synth.cancel();
+    isPlaying.value = false;
+  };
+  if (isSupported.value) {
+    bindEventsForUtterance(utterance.value);
+    watch(lang, (lang2) => {
+      if (utterance.value && !isPlaying.value)
+        utterance.value.lang = lang2;
+    });
+    if (options.voice) {
+      watch(options.voice, () => {
+        synth.cancel();
+      });
+    }
+    watch(isPlaying, () => {
+      if (isPlaying.value)
+        synth.resume();
+      else
+        synth.pause();
+    });
+  }
+  tryOnScopeDispose(() => {
+    isPlaying.value = false;
+  });
+  return {
+    isSupported,
+    isPlaying,
+    status,
+    utterance,
+    error,
+    stop,
+    toggle,
+    speak
+  };
+}
+
+function useStepper(steps, initialStep) {
+  const stepsRef = ref(steps);
+  const stepNames = computed(() => Array.isArray(stepsRef.value) ? stepsRef.value : Object.keys(stepsRef.value));
+  const index = ref(stepNames.value.indexOf(initialStep != null ? initialStep : stepNames.value[0]));
+  const current = computed(() => at(index.value));
+  const isFirst = computed(() => index.value === 0);
+  const isLast = computed(() => index.value === stepNames.value.length - 1);
+  const next = computed(() => stepNames.value[index.value + 1]);
+  const previous = computed(() => stepNames.value[index.value - 1]);
+  function at(index2) {
+    if (Array.isArray(stepsRef.value))
+      return stepsRef.value[index2];
+    return stepsRef.value[stepNames.value[index2]];
+  }
+  function get(step) {
+    if (!stepNames.value.includes(step))
+      return;
+    return at(stepNames.value.indexOf(step));
+  }
+  function goTo(step) {
+    if (stepNames.value.includes(step))
+      index.value = stepNames.value.indexOf(step);
+  }
+  function goToNext() {
+    if (isLast.value)
+      return;
+    index.value++;
+  }
+  function goToPrevious() {
+    if (isFirst.value)
+      return;
+    index.value--;
+  }
+  function goBackTo(step) {
+    if (isAfter(step))
+      goTo(step);
+  }
+  function isNext(step) {
+    return stepNames.value.indexOf(step) === index.value + 1;
+  }
+  function isPrevious(step) {
+    return stepNames.value.indexOf(step) === index.value - 1;
+  }
+  function isCurrent(step) {
+    return stepNames.value.indexOf(step) === index.value;
+  }
+  function isBefore(step) {
+    return index.value < stepNames.value.indexOf(step);
+  }
+  function isAfter(step) {
+    return index.value > stepNames.value.indexOf(step);
+  }
+  return {
+    steps: stepsRef,
+    stepNames,
+    index,
+    current,
+    next,
+    previous,
+    isFirst,
+    isLast,
+    at,
+    get,
+    goTo,
+    goToNext,
+    goToPrevious,
+    goBackTo,
+    isNext,
+    isPrevious,
+    isCurrent,
+    isBefore,
+    isAfter
+  };
+}
+
+function useStorageAsync(key, initialValue, storage, options = {}) {
+  var _a;
+  const {
+    flush = "pre",
+    deep = true,
+    listenToStorageChanges = true,
+    writeDefaults = true,
+    mergeDefaults = false,
+    shallow,
+    window = defaultWindow,
+    eventFilter,
+    onError = (e) => {
+      console.error(e);
+    }
+  } = options;
+  const rawInit = toValue(initialValue);
+  const type = guessSerializerType(rawInit);
+  const data = (shallow ? shallowRef : ref)(initialValue);
+  const serializer = (_a = options.serializer) != null ? _a : StorageSerializers[type];
+  if (!storage) {
+    try {
+      storage = getSSRHandler("getDefaultStorageAsync", () => {
+        var _a2;
+        return (_a2 = defaultWindow) == null ? void 0 : _a2.localStorage;
+      })();
+    } catch (e) {
+      onError(e);
+    }
+  }
+  async function read(event) {
+    if (!storage || event && event.key !== key)
+      return;
+    try {
+      const rawValue = event ? event.newValue : await storage.getItem(key);
+      if (rawValue == null) {
+        data.value = rawInit;
+        if (writeDefaults && rawInit !== null)
+          await storage.setItem(key, await serializer.write(rawInit));
+      } else if (mergeDefaults) {
+        const value = await serializer.read(rawValue);
+        if (typeof mergeDefaults === "function")
+          data.value = mergeDefaults(value, rawInit);
+        else if (type === "object" && !Array.isArray(value))
+          data.value = { ...rawInit, ...value };
+        else
+          data.value = value;
+      } else {
+        data.value = await serializer.read(rawValue);
+      }
+    } catch (e) {
+      onError(e);
+    }
+  }
+  read();
+  if (window && listenToStorageChanges)
+    useEventListener(window, "storage", (e) => Promise.resolve().then(() => read(e)));
+  if (storage) {
+    watchWithFilter(
+      data,
+      async () => {
+        try {
+          if (data.value == null)
+            await storage.removeItem(key);
+          else
+            await storage.setItem(key, await serializer.write(data.value));
+        } catch (e) {
+          onError(e);
+        }
+      },
+      {
+        flush,
+        deep,
+        eventFilter
+      }
+    );
+  }
+  return data;
+}
+
+let _id = 0;
+function useStyleTag(css, options = {}) {
+  const isLoaded = ref(false);
+  const {
+    document = defaultDocument,
+    immediate = true,
+    manual = false,
+    id = `vueuse_styletag_${++_id}`
+  } = options;
+  const cssRef = ref(css);
+  let stop = () => {
+  };
+  const load = () => {
+    if (!document)
+      return;
+    const el = document.getElementById(id) || document.createElement("style");
+    if (!el.isConnected) {
+      el.id = id;
+      if (options.media)
+        el.media = options.media;
+      document.head.appendChild(el);
+    }
+    if (isLoaded.value)
+      return;
+    stop = watch(
+      cssRef,
+      (value) => {
+        el.textContent = value;
+      },
+      { immediate: true }
+    );
+    isLoaded.value = true;
+  };
+  const unload = () => {
+    if (!document || !isLoaded.value)
+      return;
+    stop();
+    document.head.removeChild(document.getElementById(id));
+    isLoaded.value = false;
+  };
+  if (immediate && !manual)
+    tryOnMounted(load);
+  if (!manual)
+    tryOnScopeDispose(unload);
+  return {
+    id,
+    css: cssRef,
+    unload,
+    load,
+    isLoaded: readonly(isLoaded)
+  };
+}
+
+function useSwipe(target, options = {}) {
+  const {
+    threshold = 50,
+    onSwipe,
+    onSwipeEnd,
+    onSwipeStart,
+    passive = true,
+    window = defaultWindow
+  } = options;
+  const coordsStart = reactive({ x: 0, y: 0 });
+  const coordsEnd = reactive({ x: 0, y: 0 });
+  const diffX = computed(() => coordsStart.x - coordsEnd.x);
+  const diffY = computed(() => coordsStart.y - coordsEnd.y);
+  const { max, abs } = Math;
+  const isThresholdExceeded = computed(() => max(abs(diffX.value), abs(diffY.value)) >= threshold);
+  const isSwiping = ref(false);
+  const direction = computed(() => {
+    if (!isThresholdExceeded.value)
+      return "none";
+    if (abs(diffX.value) > abs(diffY.value)) {
+      return diffX.value > 0 ? "left" : "right";
+    } else {
+      return diffY.value > 0 ? "up" : "down";
+    }
+  });
+  const getTouchEventCoords = (e) => [e.touches[0].clientX, e.touches[0].clientY];
+  const updateCoordsStart = (x, y) => {
+    coordsStart.x = x;
+    coordsStart.y = y;
+  };
+  const updateCoordsEnd = (x, y) => {
+    coordsEnd.x = x;
+    coordsEnd.y = y;
+  };
+  let listenerOptions;
+  const isPassiveEventSupported = checkPassiveEventSupport(window == null ? void 0 : window.document);
+  if (!passive)
+    listenerOptions = isPassiveEventSupported ? { passive: false, capture: true } : { capture: true };
+  else
+    listenerOptions = isPassiveEventSupported ? { passive: true } : { capture: false };
+  const onTouchEnd = (e) => {
+    if (isSwiping.value)
+      onSwipeEnd == null ? void 0 : onSwipeEnd(e, direction.value);
+    isSwiping.value = false;
+  };
+  const stops = [
+    useEventListener(target, "touchstart", (e) => {
+      if (e.touches.length !== 1)
+        return;
+      if (listenerOptions.capture && !listenerOptions.passive)
+        e.preventDefault();
+      const [x, y] = getTouchEventCoords(e);
+      updateCoordsStart(x, y);
+      updateCoordsEnd(x, y);
+      onSwipeStart == null ? void 0 : onSwipeStart(e);
+    }, listenerOptions),
+    useEventListener(target, "touchmove", (e) => {
+      if (e.touches.length !== 1)
+        return;
+      const [x, y] = getTouchEventCoords(e);
+      updateCoordsEnd(x, y);
+      if (!isSwiping.value && isThresholdExceeded.value)
+        isSwiping.value = true;
+      if (isSwiping.value)
+        onSwipe == null ? void 0 : onSwipe(e);
+    }, listenerOptions),
+    useEventListener(target, ["touchend", "touchcancel"], onTouchEnd, listenerOptions)
+  ];
+  const stop = () => stops.forEach((s) => s());
+  return {
+    isPassiveEventSupported,
+    isSwiping,
+    direction,
+    coordsStart,
+    coordsEnd,
+    lengthX: diffX,
+    lengthY: diffY,
+    stop
+  };
+}
+function checkPassiveEventSupport(document) {
+  if (!document)
+    return false;
+  let supportsPassive = false;
+  const optionsBlock = {
+    get passive() {
+      supportsPassive = true;
+      return false;
+    }
+  };
+  document.addEventListener("x", noop, optionsBlock);
+  document.removeEventListener("x", noop);
+  return supportsPassive;
+}
+
+function useTemplateRefsList() {
+  const refs = ref([]);
+  refs.value.set = (el) => {
+    if (el)
+      refs.value.push(el);
+  };
+  onBeforeUpdate(() => {
+    refs.value.length = 0;
+  });
+  return refs;
+}
+
+function useTextDirection(options = {}) {
+  const {
+    document = defaultDocument,
+    selector = "html",
+    observe = false,
+    initialValue = "ltr"
+  } = options;
+  function getValue() {
+    var _a, _b;
+    return (_b = (_a = document == null ? void 0 : document.querySelector(selector)) == null ? void 0 : _a.getAttribute("dir")) != null ? _b : initialValue;
+  }
+  const dir = ref(getValue());
+  tryOnMounted(() => dir.value = getValue());
+  if (observe && document) {
+    useMutationObserver(
+      document.querySelector(selector),
+      () => dir.value = getValue(),
+      { attributes: true }
+    );
+  }
+  return computed({
+    get() {
+      return dir.value;
+    },
+    set(v) {
+      var _a, _b;
+      dir.value = v;
+      if (!document)
+        return;
+      if (dir.value)
+        (_a = document.querySelector(selector)) == null ? void 0 : _a.setAttribute("dir", dir.value);
+      else
+        (_b = document.querySelector(selector)) == null ? void 0 : _b.removeAttribute("dir");
+    }
+  });
+}
+
+function getRangesFromSelection(selection) {
+  var _a;
+  const rangeCount = (_a = selection.rangeCount) != null ? _a : 0;
+  return Array.from({ length: rangeCount }, (_, i) => selection.getRangeAt(i));
+}
+function useTextSelection(options = {}) {
+  const {
+    window = defaultWindow
+  } = options;
+  const selection = ref(null);
+  const text = computed(() => {
+    var _a, _b;
+    return (_b = (_a = selection.value) == null ? void 0 : _a.toString()) != null ? _b : "";
+  });
+  const ranges = computed(() => selection.value ? getRangesFromSelection(selection.value) : []);
+  const rects = computed(() => ranges.value.map((range) => range.getBoundingClientRect()));
+  function onSelectionChange() {
+    selection.value = null;
+    if (window)
+      selection.value = window.getSelection();
+  }
+  if (window)
+    useEventListener(window.document, "selectionchange", onSelectionChange);
+  return {
+    text,
+    rects,
+    ranges,
+    selection
+  };
+}
+
+function useTextareaAutosize(options) {
+  const textarea = ref(options == null ? void 0 : options.element);
+  const input = ref(options == null ? void 0 : options.input);
+  const textareaScrollHeight = ref(1);
+  function triggerResize() {
+    var _a, _b;
+    if (!textarea.value)
+      return;
+    let height = "";
+    textarea.value.style.height = "1px";
+    textareaScrollHeight.value = (_a = textarea.value) == null ? void 0 : _a.scrollHeight;
+    if (options == null ? void 0 : options.styleTarget)
+      toValue(options.styleTarget).style.height = `${textareaScrollHeight.value}px`;
+    else
+      height = `${textareaScrollHeight.value}px`;
+    textarea.value.style.height = height;
+    (_b = options == null ? void 0 : options.onResize) == null ? void 0 : _b.call(options);
+  }
+  watch([input, textarea], () => nextTick(triggerResize), { immediate: true });
+  useResizeObserver(textarea, () => triggerResize());
+  if (options == null ? void 0 : options.watch)
+    watch(options.watch, triggerResize, { immediate: true, deep: true });
+  return {
+    textarea,
+    input,
+    triggerResize
+  };
+}
+
+function useThrottledRefHistory(source, options = {}) {
+  const { throttle = 200, trailing = true } = options;
+  const filter = throttleFilter(throttle, trailing);
+  const history = useRefHistory(source, { ...options, eventFilter: filter });
+  return {
+    ...history
+  };
+}
+
+const DEFAULT_UNITS = [
+  { max: 6e4, value: 1e3, name: "second" },
+  { max: 276e4, value: 6e4, name: "minute" },
+  { max: 72e6, value: 36e5, name: "hour" },
+  { max: 5184e5, value: 864e5, name: "day" },
+  { max: 24192e5, value: 6048e5, name: "week" },
+  { max: 28512e6, value: 2592e6, name: "month" },
+  { max: Number.POSITIVE_INFINITY, value: 31536e6, name: "year" }
+];
+const DEFAULT_MESSAGES = {
+  justNow: "just now",
+  past: (n) => n.match(/\d/) ? `${n} ago` : n,
+  future: (n) => n.match(/\d/) ? `in ${n}` : n,
+  month: (n, past) => n === 1 ? past ? "last month" : "next month" : `${n} month${n > 1 ? "s" : ""}`,
+  year: (n, past) => n === 1 ? past ? "last year" : "next year" : `${n} year${n > 1 ? "s" : ""}`,
+  day: (n, past) => n === 1 ? past ? "yesterday" : "tomorrow" : `${n} day${n > 1 ? "s" : ""}`,
+  week: (n, past) => n === 1 ? past ? "last week" : "next week" : `${n} week${n > 1 ? "s" : ""}`,
+  hour: (n) => `${n} hour${n > 1 ? "s" : ""}`,
+  minute: (n) => `${n} minute${n > 1 ? "s" : ""}`,
+  second: (n) => `${n} second${n > 1 ? "s" : ""}`,
+  invalid: ""
+};
+function DEFAULT_FORMATTER(date) {
+  return date.toISOString().slice(0, 10);
+}
+function useTimeAgo(time, options = {}) {
+  const {
+    controls: exposeControls = false,
+    updateInterval = 3e4
+  } = options;
+  const { now, ...controls } = useNow({ interval: updateInterval, controls: true });
+  const timeAgo = computed(() => formatTimeAgo(new Date(toValue(time)), options, toValue(now)));
+  if (exposeControls) {
+    return {
+      timeAgo,
+      ...controls
+    };
+  } else {
+    return timeAgo;
+  }
+}
+function formatTimeAgo(from, options = {}, now = Date.now()) {
+  var _a;
+  const {
+    max,
+    messages = DEFAULT_MESSAGES,
+    fullDateFormatter = DEFAULT_FORMATTER,
+    units = DEFAULT_UNITS,
+    showSecond = false,
+    rounding = "round"
+  } = options;
+  const roundFn = typeof rounding === "number" ? (n) => +n.toFixed(rounding) : Math[rounding];
+  const diff = +now - +from;
+  const absDiff = Math.abs(diff);
+  function getValue(diff2, unit) {
+    return roundFn(Math.abs(diff2) / unit.value);
+  }
+  function format(diff2, unit) {
+    const val = getValue(diff2, unit);
+    const past = diff2 > 0;
+    const str = applyFormat(unit.name, val, past);
+    return applyFormat(past ? "past" : "future", str, past);
+  }
+  function applyFormat(name, val, isPast) {
+    const formatter = messages[name];
+    if (typeof formatter === "function")
+      return formatter(val, isPast);
+    return formatter.replace("{0}", val.toString());
+  }
+  if (absDiff < 6e4 && !showSecond)
+    return messages.justNow;
+  if (typeof max === "number" && absDiff > max)
+    return fullDateFormatter(new Date(from));
+  if (typeof max === "string") {
+    const unitMax = (_a = units.find((i) => i.name === max)) == null ? void 0 : _a.max;
+    if (unitMax && absDiff > unitMax)
+      return fullDateFormatter(new Date(from));
+  }
+  for (const [idx, unit] of units.entries()) {
+    const val = getValue(diff, unit);
+    if (val <= 0 && units[idx - 1])
+      return format(diff, units[idx - 1]);
+    if (absDiff < unit.max)
+      return format(diff, unit);
+  }
+  return messages.invalid;
+}
+
+function useTimeoutPoll(fn, interval, timeoutPollOptions) {
+  const { start } = useTimeoutFn(loop, interval, { immediate: false });
+  const isActive = ref(false);
+  async function loop() {
+    if (!isActive.value)
+      return;
+    await fn();
+    start();
+  }
+  function resume() {
+    if (!isActive.value) {
+      isActive.value = true;
+      loop();
+    }
+  }
+  function pause() {
+    isActive.value = false;
+  }
+  if (timeoutPollOptions == null ? void 0 : timeoutPollOptions.immediate)
+    resume();
+  tryOnScopeDispose(pause);
+  return {
+    isActive,
+    pause,
+    resume
+  };
+}
+
+function useTimestamp(options = {}) {
+  const {
+    controls: exposeControls = false,
+    offset = 0,
+    immediate = true,
+    interval = "requestAnimationFrame",
+    callback
+  } = options;
+  const ts = ref(timestamp() + offset);
+  const update = () => ts.value = timestamp() + offset;
+  const cb = callback ? () => {
+    update();
+    callback(ts.value);
+  } : update;
+  const controls = interval === "requestAnimationFrame" ? useRafFn(cb, { immediate }) : useIntervalFn(cb, interval, { immediate });
+  if (exposeControls) {
+    return {
+      timestamp: ts,
+      ...controls
+    };
+  } else {
+    return ts;
+  }
+}
+
+function useTitle(newTitle = null, options = {}) {
+  var _a, _b, _c;
+  const {
+    document = defaultDocument,
+    restoreOnUnmount = (t) => t
+  } = options;
+  const originalTitle = (_a = document == null ? void 0 : document.title) != null ? _a : "";
+  const title = toRef((_b = newTitle != null ? newTitle : document == null ? void 0 : document.title) != null ? _b : null);
+  const isReadonly = newTitle && typeof newTitle === "function";
+  function format(t) {
+    if (!("titleTemplate" in options))
+      return t;
+    const template = options.titleTemplate || "%s";
+    return typeof template === "function" ? template(t) : toValue(template).replace(/%s/g, t);
+  }
+  watch(
+    title,
+    (t, o) => {
+      if (t !== o && document)
+        document.title = format(typeof t === "string" ? t : "");
+    },
+    { immediate: true }
+  );
+  if (options.observe && !options.titleTemplate && document && !isReadonly) {
+    useMutationObserver(
+      (_c = document.head) == null ? void 0 : _c.querySelector("title"),
+      () => {
+        if (document && document.title !== title.value)
+          title.value = format(document.title);
+      },
+      { childList: true }
+    );
+  }
+  tryOnBeforeUnmount(() => {
+    if (restoreOnUnmount) {
+      const restoredTitle = restoreOnUnmount(originalTitle, title.value || "");
+      if (restoredTitle != null && document)
+        document.title = restoredTitle;
+    }
+  });
+  return title;
+}
+
+const _TransitionPresets = {
+  easeInSine: [0.12, 0, 0.39, 0],
+  easeOutSine: [0.61, 1, 0.88, 1],
+  easeInOutSine: [0.37, 0, 0.63, 1],
+  easeInQuad: [0.11, 0, 0.5, 0],
+  easeOutQuad: [0.5, 1, 0.89, 1],
+  easeInOutQuad: [0.45, 0, 0.55, 1],
+  easeInCubic: [0.32, 0, 0.67, 0],
+  easeOutCubic: [0.33, 1, 0.68, 1],
+  easeInOutCubic: [0.65, 0, 0.35, 1],
+  easeInQuart: [0.5, 0, 0.75, 0],
+  easeOutQuart: [0.25, 1, 0.5, 1],
+  easeInOutQuart: [0.76, 0, 0.24, 1],
+  easeInQuint: [0.64, 0, 0.78, 0],
+  easeOutQuint: [0.22, 1, 0.36, 1],
+  easeInOutQuint: [0.83, 0, 0.17, 1],
+  easeInExpo: [0.7, 0, 0.84, 0],
+  easeOutExpo: [0.16, 1, 0.3, 1],
+  easeInOutExpo: [0.87, 0, 0.13, 1],
+  easeInCirc: [0.55, 0, 1, 0.45],
+  easeOutCirc: [0, 0.55, 0.45, 1],
+  easeInOutCirc: [0.85, 0, 0.15, 1],
+  easeInBack: [0.36, 0, 0.66, -0.56],
+  easeOutBack: [0.34, 1.56, 0.64, 1],
+  easeInOutBack: [0.68, -0.6, 0.32, 1.6]
+};
+const TransitionPresets = /* @__PURE__ */ Object.assign({}, { linear: identity }, _TransitionPresets);
+function createEasingFunction([p0, p1, p2, p3]) {
+  const a = (a1, a2) => 1 - 3 * a2 + 3 * a1;
+  const b = (a1, a2) => 3 * a2 - 6 * a1;
+  const c = (a1) => 3 * a1;
+  const calcBezier = (t, a1, a2) => ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;
+  const getSlope = (t, a1, a2) => 3 * a(a1, a2) * t * t + 2 * b(a1, a2) * t + c(a1);
+  const getTforX = (x) => {
+    let aGuessT = x;
+    for (let i = 0; i < 4; ++i) {
+      const currentSlope = getSlope(aGuessT, p0, p2);
+      if (currentSlope === 0)
+        return aGuessT;
+      const currentX = calcBezier(aGuessT, p0, p2) - x;
+      aGuessT -= currentX / currentSlope;
+    }
+    return aGuessT;
+  };
+  return (x) => p0 === p1 && p2 === p3 ? x : calcBezier(getTforX(x), p1, p3);
+}
+function lerp(a, b, alpha) {
+  return a + alpha * (b - a);
+}
+function toVec(t) {
+  return (typeof t === "number" ? [t] : t) || [];
+}
+function executeTransition(source, from, to, options = {}) {
+  var _a, _b;
+  const fromVal = toValue(from);
+  const toVal = toValue(to);
+  const v1 = toVec(fromVal);
+  const v2 = toVec(toVal);
+  const duration = (_a = toValue(options.duration)) != null ? _a : 1e3;
+  const startedAt = Date.now();
+  const endAt = Date.now() + duration;
+  const trans = typeof options.transition === "function" ? options.transition : (_b = toValue(options.transition)) != null ? _b : identity;
+  const ease = typeof trans === "function" ? trans : createEasingFunction(trans);
+  return new Promise((resolve) => {
+    source.value = fromVal;
+    const tick = () => {
+      var _a2;
+      if ((_a2 = options.abort) == null ? void 0 : _a2.call(options)) {
+        resolve();
+        return;
+      }
+      const now = Date.now();
+      const alpha = ease((now - startedAt) / duration);
+      const arr = toVec(source.value).map((n, i) => lerp(v1[i], v2[i], alpha));
+      if (Array.isArray(source.value))
+        source.value = arr.map((n, i) => {
+          var _a3, _b2;
+          return lerp((_a3 = v1[i]) != null ? _a3 : 0, (_b2 = v2[i]) != null ? _b2 : 0, alpha);
+        });
+      else if (typeof source.value === "number")
+        source.value = arr[0];
+      if (now < endAt) {
+        requestAnimationFrame(tick);
+      } else {
+        source.value = toVal;
+        resolve();
+      }
+    };
+    tick();
+  });
+}
+function useTransition(source, options = {}) {
+  let currentId = 0;
+  const sourceVal = () => {
+    const v = toValue(source);
+    return typeof v === "number" ? v : v.map(toValue);
+  };
+  const outputRef = ref(sourceVal());
+  watch(sourceVal, async (to) => {
+    var _a, _b;
+    if (toValue(options.disabled))
+      return;
+    const id = ++currentId;
+    if (options.delay)
+      await promiseTimeout(toValue(options.delay));
+    if (id !== currentId)
+      return;
+    const toVal = Array.isArray(to) ? to.map(toValue) : toValue(to);
+    (_a = options.onStarted) == null ? void 0 : _a.call(options);
+    await executeTransition(outputRef, outputRef.value, toVal, {
+      ...options,
+      abort: () => {
+        var _a2;
+        return id !== currentId || ((_a2 = options.abort) == null ? void 0 : _a2.call(options));
+      }
+    });
+    (_b = options.onFinished) == null ? void 0 : _b.call(options);
+  }, { deep: true });
+  watch(() => toValue(options.disabled), (disabled) => {
+    if (disabled) {
+      currentId++;
+      outputRef.value = sourceVal();
+    }
+  });
+  tryOnScopeDispose(() => {
+    currentId++;
+  });
+  return computed(() => toValue(options.disabled) ? sourceVal() : outputRef.value);
+}
+
+function useUrlSearchParams(mode = "history", options = {}) {
+  const {
+    initialValue = {},
+    removeNullishValues = true,
+    removeFalsyValues = false,
+    write: enableWrite = true,
+    window = defaultWindow
+  } = options;
+  if (!window)
+    return reactive(initialValue);
+  const state = reactive({});
+  function getRawParams() {
+    if (mode === "history") {
+      return window.location.search || "";
+    } else if (mode === "hash") {
+      const hash = window.location.hash || "";
+      const index = hash.indexOf("?");
+      return index > 0 ? hash.slice(index) : "";
+    } else {
+      return (window.location.hash || "").replace(/^#/, "");
+    }
+  }
+  function constructQuery(params) {
+    const stringified = params.toString();
+    if (mode === "history")
+      return `${stringified ? `?${stringified}` : ""}${window.location.hash || ""}`;
+    if (mode === "hash-params")
+      return `${window.location.search || ""}${stringified ? `#${stringified}` : ""}`;
+    const hash = window.location.hash || "#";
+    const index = hash.indexOf("?");
+    if (index > 0)
+      return `${hash.slice(0, index)}${stringified ? `?${stringified}` : ""}`;
+    return `${hash}${stringified ? `?${stringified}` : ""}`;
+  }
+  function read() {
+    return new URLSearchParams(getRawParams());
+  }
+  function updateState(params) {
+    const unusedKeys = new Set(Object.keys(state));
+    for (const key of params.keys()) {
+      const paramsForKey = params.getAll(key);
+      state[key] = paramsForKey.length > 1 ? paramsForKey : params.get(key) || "";
+      unusedKeys.delete(key);
+    }
+    Array.from(unusedKeys).forEach((key) => delete state[key]);
+  }
+  const { pause, resume } = pausableWatch(
+    state,
+    () => {
+      const params = new URLSearchParams("");
+      Object.keys(state).forEach((key) => {
+        const mapEntry = state[key];
+        if (Array.isArray(mapEntry))
+          mapEntry.forEach((value) => params.append(key, value));
+        else if (removeNullishValues && mapEntry == null)
+          params.delete(key);
+        else if (removeFalsyValues && !mapEntry)
+          params.delete(key);
+        else
+          params.set(key, mapEntry);
+      });
+      write(params);
+    },
+    { deep: true }
+  );
+  function write(params, shouldUpdate) {
+    pause();
+    if (shouldUpdate)
+      updateState(params);
+    window.history.replaceState(
+      window.history.state,
+      window.document.title,
+      window.location.pathname + constructQuery(params)
+    );
+    resume();
+  }
+  function onChanged() {
+    if (!enableWrite)
+      return;
+    write(read(), true);
+  }
+  useEventListener(window, "popstate", onChanged, false);
+  if (mode !== "history")
+    useEventListener(window, "hashchange", onChanged, false);
+  const initial = read();
+  if (initial.keys().next().value)
+    updateState(initial);
+  else
+    Object.assign(state, initialValue);
+  return state;
+}
+
+function useUserMedia(options = {}) {
+  var _a, _b;
+  const enabled = ref((_a = options.enabled) != null ? _a : false);
+  const autoSwitch = ref((_b = options.autoSwitch) != null ? _b : true);
+  const constraints = ref(options.constraints);
+  const { navigator = defaultNavigator } = options;
+  const isSupported = useSupported(() => {
+    var _a2;
+    return (_a2 = navigator == null ? void 0 : navigator.mediaDevices) == null ? void 0 : _a2.getUserMedia;
+  });
+  const stream = shallowRef();
+  function getDeviceOptions(type) {
+    switch (type) {
+      case "video": {
+        if (constraints.value)
+          return constraints.value.video || false;
+        break;
+      }
+      case "audio": {
+        if (constraints.value)
+          return constraints.value.audio || false;
+        break;
+      }
+    }
+  }
+  async function _start() {
+    if (!isSupported.value || stream.value)
+      return;
+    stream.value = await navigator.mediaDevices.getUserMedia({
+      video: getDeviceOptions("video"),
+      audio: getDeviceOptions("audio")
+    });
+    return stream.value;
+  }
+  function _stop() {
+    var _a2;
+    (_a2 = stream.value) == null ? void 0 : _a2.getTracks().forEach((t) => t.stop());
+    stream.value = void 0;
+  }
+  function stop() {
+    _stop();
+    enabled.value = false;
+  }
+  async function start() {
+    await _start();
+    if (stream.value)
+      enabled.value = true;
+    return stream.value;
+  }
+  async function restart() {
+    _stop();
+    return await start();
+  }
+  watch(
+    enabled,
+    (v) => {
+      if (v)
+        _start();
+      else
+        _stop();
+    },
+    { immediate: true }
+  );
+  watch(
+    constraints,
+    () => {
+      if (autoSwitch.value && stream.value)
+        restart();
+    },
+    { immediate: true }
+  );
+  return {
+    isSupported,
+    stream,
+    start,
+    stop,
+    restart,
+    constraints,
+    enabled,
+    autoSwitch
+  };
+}
+
+function useVModel(props, key, emit, options = {}) {
+  var _a, _b, _c, _d, _e;
+  const {
+    clone = false,
+    passive = false,
+    eventName,
+    deep = false,
+    defaultValue,
+    shouldEmit
+  } = options;
+  const vm = getCurrentInstance();
+  const _emit = emit || (vm == null ? void 0 : vm.emit) || ((_a = vm == null ? void 0 : vm.$emit) == null ? void 0 : _a.bind(vm)) || ((_c = (_b = vm == null ? void 0 : vm.proxy) == null ? void 0 : _b.$emit) == null ? void 0 : _c.bind(vm == null ? void 0 : vm.proxy));
+  let event = eventName;
+  if (!key) {
+    if (isVue2) {
+      const modelOptions = (_e = (_d = vm == null ? void 0 : vm.proxy) == null ? void 0 : _d.$options) == null ? void 0 : _e.model;
+      key = (modelOptions == null ? void 0 : modelOptions.value) || "value";
+      if (!eventName)
+        event = (modelOptions == null ? void 0 : modelOptions.event) || "input";
+    } else {
+      key = "modelValue";
+    }
+  }
+  event = event || `update:${key.toString()}`;
+  const cloneFn = (val) => !clone ? val : typeof clone === "function" ? clone(val) : cloneFnJSON(val);
+  const getValue = () => isDef(props[key]) ? cloneFn(props[key]) : defaultValue;
+  const triggerEmit = (value) => {
+    if (shouldEmit) {
+      if (shouldEmit(value))
+        _emit(event, value);
+    } else {
+      _emit(event, value);
+    }
+  };
+  if (passive) {
+    const initialValue = getValue();
+    const proxy = ref(initialValue);
+    let isUpdating = false;
+    watch(
+      () => props[key],
+      (v) => {
+        if (!isUpdating) {
+          isUpdating = true;
+          proxy.value = cloneFn(v);
+          nextTick(() => isUpdating = false);
+        }
+      }
+    );
+    watch(
+      proxy,
+      (v) => {
+        if (!isUpdating && (v !== props[key] || deep))
+          triggerEmit(v);
+      },
+      { deep }
+    );
+    return proxy;
+  } else {
+    return computed({
+      get() {
+        return getValue();
+      },
+      set(value) {
+        triggerEmit(value);
+      }
+    });
+  }
+}
+
+function useVModels(props, emit, options = {}) {
+  const ret = {};
+  for (const key in props) {
+    ret[key] = useVModel(
+      props,
+      key,
+      emit,
+      options
+    );
+  }
+  return ret;
+}
+
+function useVibrate(options) {
+  const {
+    pattern = [],
+    interval = 0,
+    navigator = defaultNavigator
+  } = options || {};
+  const isSupported = useSupported(() => typeof navigator !== "undefined" && "vibrate" in navigator);
+  const patternRef = toRef(pattern);
+  let intervalControls;
+  const vibrate = (pattern2 = patternRef.value) => {
+    if (isSupported.value)
+      navigator.vibrate(pattern2);
+  };
+  const stop = () => {
+    if (isSupported.value)
+      navigator.vibrate(0);
+    intervalControls == null ? void 0 : intervalControls.pause();
+  };
+  if (interval > 0) {
+    intervalControls = useIntervalFn(
+      vibrate,
+      interval,
+      {
+        immediate: false,
+        immediateCallback: false
+      }
+    );
+  }
+  return {
+    isSupported,
+    pattern,
+    intervalControls,
+    vibrate,
+    stop
+  };
+}
+
+function useVirtualList(list, options) {
+  const { containerStyle, wrapperProps, scrollTo, calculateRange, currentList, containerRef } = "itemHeight" in options ? useVerticalVirtualList(options, list) : useHorizontalVirtualList(options, list);
+  return {
+    list: currentList,
+    scrollTo,
+    containerProps: {
+      ref: containerRef,
+      onScroll: () => {
+        calculateRange();
+      },
+      style: containerStyle
+    },
+    wrapperProps
+  };
+}
+function useVirtualListResources(list) {
+  const containerRef = ref(null);
+  const size = useElementSize(containerRef);
+  const currentList = ref([]);
+  const source = shallowRef(list);
+  const state = ref({ start: 0, end: 10 });
+  return { state, source, currentList, size, containerRef };
+}
+function createGetViewCapacity(state, source, itemSize) {
+  return (containerSize) => {
+    if (typeof itemSize === "number")
+      return Math.ceil(containerSize / itemSize);
+    const { start = 0 } = state.value;
+    let sum = 0;
+    let capacity = 0;
+    for (let i = start; i < source.value.length; i++) {
+      const size = itemSize(i);
+      sum += size;
+      capacity = i;
+      if (sum > containerSize)
+        break;
+    }
+    return capacity - start;
+  };
+}
+function createGetOffset(source, itemSize) {
+  return (scrollDirection) => {
+    if (typeof itemSize === "number")
+      return Math.floor(scrollDirection / itemSize) + 1;
+    let sum = 0;
+    let offset = 0;
+    for (let i = 0; i < source.value.length; i++) {
+      const size = itemSize(i);
+      sum += size;
+      if (sum >= scrollDirection) {
+        offset = i;
+        break;
+      }
+    }
+    return offset + 1;
+  };
+}
+function createCalculateRange(type, overscan, getOffset, getViewCapacity, { containerRef, state, currentList, source }) {
+  return () => {
+    const element = containerRef.value;
+    if (element) {
+      const offset = getOffset(type === "vertical" ? element.scrollTop : element.scrollLeft);
+      const viewCapacity = getViewCapacity(type === "vertical" ? element.clientHeight : element.clientWidth);
+      const from = offset - overscan;
+      const to = offset + viewCapacity + overscan;
+      state.value = {
+        start: from < 0 ? 0 : from,
+        end: to > source.value.length ? source.value.length : to
+      };
+      currentList.value = source.value.slice(state.value.start, state.value.end).map((ele, index) => ({
+        data: ele,
+        index: index + state.value.start
+      }));
+    }
+  };
+}
+function createGetDistance(itemSize, source) {
+  return (index) => {
+    if (typeof itemSize === "number") {
+      const size2 = index * itemSize;
+      return size2;
+    }
+    const size = source.value.slice(0, index).reduce((sum, _, i) => sum + itemSize(i), 0);
+    return size;
+  };
+}
+function useWatchForSizes(size, list, calculateRange) {
+  watch([size.width, size.height, list], () => {
+    calculateRange();
+  });
+}
+function createComputedTotalSize(itemSize, source) {
+  return computed(() => {
+    if (typeof itemSize === "number")
+      return source.value.length * itemSize;
+    return source.value.reduce((sum, _, index) => sum + itemSize(index), 0);
+  });
+}
+const scrollToDictionaryForElementScrollKey = {
+  horizontal: "scrollLeft",
+  vertical: "scrollTop"
+};
+function createScrollTo(type, calculateRange, getDistance, containerRef) {
+  return (index) => {
+    if (containerRef.value) {
+      containerRef.value[scrollToDictionaryForElementScrollKey[type]] = getDistance(index);
+      calculateRange();
+    }
+  };
+}
+function useHorizontalVirtualList(options, list) {
+  const resources = useVirtualListResources(list);
+  const { state, source, currentList, size, containerRef } = resources;
+  const containerStyle = { overflowX: "auto" };
+  const { itemWidth, overscan = 5 } = options;
+  const getViewCapacity = createGetViewCapacity(state, source, itemWidth);
+  const getOffset = createGetOffset(source, itemWidth);
+  const calculateRange = createCalculateRange("horizontal", overscan, getOffset, getViewCapacity, resources);
+  const getDistanceLeft = createGetDistance(itemWidth, source);
+  const offsetLeft = computed(() => getDistanceLeft(state.value.start));
+  const totalWidth = createComputedTotalSize(itemWidth, source);
+  useWatchForSizes(size, list, calculateRange);
+  const scrollTo = createScrollTo("horizontal", calculateRange, getDistanceLeft, containerRef);
+  const wrapperProps = computed(() => {
+    return {
+      style: {
+        height: "100%",
+        width: `${totalWidth.value - offsetLeft.value}px`,
+        marginLeft: `${offsetLeft.value}px`,
+        display: "flex"
+      }
+    };
+  });
+  return {
+    scrollTo,
+    calculateRange,
+    wrapperProps,
+    containerStyle,
+    currentList,
+    containerRef
+  };
+}
+function useVerticalVirtualList(options, list) {
+  const resources = useVirtualListResources(list);
+  const { state, source, currentList, size, containerRef } = resources;
+  const containerStyle = { overflowY: "auto" };
+  const { itemHeight, overscan = 5 } = options;
+  const getViewCapacity = createGetViewCapacity(state, source, itemHeight);
+  const getOffset = createGetOffset(source, itemHeight);
+  const calculateRange = createCalculateRange("vertical", overscan, getOffset, getViewCapacity, resources);
+  const getDistanceTop = createGetDistance(itemHeight, source);
+  const offsetTop = computed(() => getDistanceTop(state.value.start));
+  const totalHeight = createComputedTotalSize(itemHeight, source);
+  useWatchForSizes(size, list, calculateRange);
+  const scrollTo = createScrollTo("vertical", calculateRange, getDistanceTop, containerRef);
+  const wrapperProps = computed(() => {
+    return {
+      style: {
+        width: "100%",
+        height: `${totalHeight.value - offsetTop.value}px`,
+        marginTop: `${offsetTop.value}px`
+      }
+    };
+  });
+  return {
+    calculateRange,
+    scrollTo,
+    containerStyle,
+    wrapperProps,
+    currentList,
+    containerRef
+  };
+}
+
+function useWakeLock(options = {}) {
+  const {
+    navigator = defaultNavigator,
+    document = defaultDocument
+  } = options;
+  let wakeLock;
+  const isSupported = useSupported(() => navigator && "wakeLock" in navigator);
+  const isActive = ref(false);
+  async function onVisibilityChange() {
+    if (!isSupported.value || !wakeLock)
+      return;
+    if (document && document.visibilityState === "visible")
+      wakeLock = await navigator.wakeLock.request("screen");
+    isActive.value = !wakeLock.released;
+  }
+  if (document)
+    useEventListener(document, "visibilitychange", onVisibilityChange, { passive: true });
+  async function request(type) {
+    if (!isSupported.value)
+      return;
+    wakeLock = await navigator.wakeLock.request(type);
+    isActive.value = !wakeLock.released;
+  }
+  async function release() {
+    if (!isSupported.value || !wakeLock)
+      return;
+    await wakeLock.release();
+    isActive.value = !wakeLock.released;
+    wakeLock = null;
+  }
+  return {
+    isSupported,
+    isActive,
+    request,
+    release
+  };
+}
+
+function useWebNotification(options = {}) {
+  const {
+    window = defaultWindow,
+    requestPermissions: _requestForPermissions = true
+  } = options;
+  const defaultWebNotificationOptions = options;
+  const isSupported = useSupported(() => !!window && "Notification" in window);
+  const permissionGranted = ref(isSupported.value && "permission" in Notification && Notification.permission === "granted");
+  const notification = ref(null);
+  const ensurePermissions = async () => {
+    if (!isSupported.value)
+      return;
+    if (!permissionGranted.value && Notification.permission !== "denied") {
+      const result = await Notification.requestPermission();
+      if (result === "granted")
+        permissionGranted.value = true;
+    }
+    return permissionGranted.value;
+  };
+  const { on: onClick, trigger: clickTrigger } = createEventHook();
+  const { on: onShow, trigger: showTrigger } = createEventHook();
+  const { on: onError, trigger: errorTrigger } = createEventHook();
+  const { on: onClose, trigger: closeTrigger } = createEventHook();
+  const show = async (overrides) => {
+    if (!isSupported.value || !permissionGranted.value)
+      return;
+    const options2 = Object.assign({}, defaultWebNotificationOptions, overrides);
+    notification.value = new Notification(options2.title || "", options2);
+    notification.value.onclick = clickTrigger;
+    notification.value.onshow = showTrigger;
+    notification.value.onerror = errorTrigger;
+    notification.value.onclose = closeTrigger;
+    return notification.value;
+  };
+  const close = () => {
+    if (notification.value)
+      notification.value.close();
+    notification.value = null;
+  };
+  if (_requestForPermissions)
+    tryOnMounted(ensurePermissions);
+  tryOnScopeDispose(close);
+  if (isSupported.value && window) {
+    const document = window.document;
+    useEventListener(document, "visibilitychange", (e) => {
+      e.preventDefault();
+      if (document.visibilityState === "visible") {
+        close();
+      }
+    });
+  }
+  return {
+    isSupported,
+    notification,
+    ensurePermissions,
+    permissionGranted,
+    show,
+    close,
+    onClick,
+    onShow,
+    onError,
+    onClose
+  };
+}
+
+const DEFAULT_PING_MESSAGE = "ping";
+function resolveNestedOptions(options) {
+  if (options === true)
+    return {};
+  return options;
+}
+function useWebSocket(url, options = {}) {
+  const {
+    onConnected,
+    onDisconnected,
+    onError,
+    onMessage,
+    immediate = true,
+    autoClose = true,
+    protocols = []
+  } = options;
+  const data = ref(null);
+  const status = ref("CLOSED");
+  const wsRef = ref();
+  const urlRef = toRef(url);
+  let heartbeatPause;
+  let heartbeatResume;
+  let explicitlyClosed = false;
+  let retried = 0;
+  let bufferedData = [];
+  let pongTimeoutWait;
+  const _sendBuffer = () => {
+    if (bufferedData.length && wsRef.value && status.value === "OPEN") {
+      for (const buffer of bufferedData)
+        wsRef.value.send(buffer);
+      bufferedData = [];
+    }
+  };
+  const resetHeartbeat = () => {
+    clearTimeout(pongTimeoutWait);
+    pongTimeoutWait = void 0;
+  };
+  const close = (code = 1e3, reason) => {
+    if (!isClient || !wsRef.value)
+      return;
+    explicitlyClosed = true;
+    resetHeartbeat();
+    heartbeatPause == null ? void 0 : heartbeatPause();
+    wsRef.value.close(code, reason);
+  };
+  const send = (data2, useBuffer = true) => {
+    if (!wsRef.value || status.value !== "OPEN") {
+      if (useBuffer)
+        bufferedData.push(data2);
+      return false;
+    }
+    _sendBuffer();
+    wsRef.value.send(data2);
+    return true;
+  };
+  const _init = () => {
+    if (explicitlyClosed || typeof urlRef.value === "undefined")
+      return;
+    const ws = new WebSocket(urlRef.value, protocols);
+    wsRef.value = ws;
+    status.value = "CONNECTING";
+    ws.onopen = () => {
+      status.value = "OPEN";
+      onConnected == null ? void 0 : onConnected(ws);
+      heartbeatResume == null ? void 0 : heartbeatResume();
+      _sendBuffer();
+    };
+    ws.onclose = (ev) => {
+      status.value = "CLOSED";
+      wsRef.value = void 0;
+      onDisconnected == null ? void 0 : onDisconnected(ws, ev);
+      if (!explicitlyClosed && options.autoReconnect) {
+        const {
+          retries = -1,
+          delay = 1e3,
+          onFailed
+        } = resolveNestedOptions(options.autoReconnect);
+        retried += 1;
+        if (typeof retries === "number" && (retries < 0 || retried < retries))
+          setTimeout(_init, delay);
+        else if (typeof retries === "function" && retries())
+          setTimeout(_init, delay);
+        else
+          onFailed == null ? void 0 : onFailed();
+      }
+    };
+    ws.onerror = (e) => {
+      onError == null ? void 0 : onError(ws, e);
+    };
+    ws.onmessage = (e) => {
+      if (options.heartbeat) {
+        resetHeartbeat();
+        const {
+          message = DEFAULT_PING_MESSAGE
+        } = resolveNestedOptions(options.heartbeat);
+        if (e.data === message)
+          return;
+      }
+      data.value = e.data;
+      onMessage == null ? void 0 : onMessage(ws, e);
+    };
+  };
+  if (options.heartbeat) {
+    const {
+      message = DEFAULT_PING_MESSAGE,
+      interval = 1e3,
+      pongTimeout = 1e3
+    } = resolveNestedOptions(options.heartbeat);
+    const { pause, resume } = useIntervalFn(
+      () => {
+        send(message, false);
+        if (pongTimeoutWait != null)
+          return;
+        pongTimeoutWait = setTimeout(() => {
+          close();
+          explicitlyClosed = false;
+        }, pongTimeout);
+      },
+      interval,
+      { immediate: false }
+    );
+    heartbeatPause = pause;
+    heartbeatResume = resume;
+  }
+  if (autoClose) {
+    if (isClient)
+      useEventListener("beforeunload", () => close());
+    tryOnScopeDispose(close);
+  }
+  const open = () => {
+    if (!isClient && !isWorker)
+      return;
+    close();
+    explicitlyClosed = false;
+    retried = 0;
+    _init();
+  };
+  if (immediate)
+    watch(urlRef, open, { immediate: true });
+  return {
+    data,
+    status,
+    close,
+    send,
+    open,
+    ws: wsRef
+  };
+}
+
+function useWebWorker(arg0, workerOptions, options) {
+  const {
+    window = defaultWindow
+  } = options != null ? options : {};
+  const data = ref(null);
+  const worker = shallowRef();
+  const post = (...args) => {
+    if (!worker.value)
+      return;
+    worker.value.postMessage(...args);
+  };
+  const terminate = function terminate2() {
+    if (!worker.value)
+      return;
+    worker.value.terminate();
+  };
+  if (window) {
+    if (typeof arg0 === "string")
+      worker.value = new Worker(arg0, workerOptions);
+    else if (typeof arg0 === "function")
+      worker.value = arg0();
+    else
+      worker.value = arg0;
+    worker.value.onmessage = (e) => {
+      data.value = e.data;
+    };
+    tryOnScopeDispose(() => {
+      if (worker.value)
+        worker.value.terminate();
+    });
+  }
+  return {
+    data,
+    post,
+    terminate,
+    worker
+  };
+}
+
+function jobRunner(userFunc) {
+  return (e) => {
+    const userFuncArgs = e.data[0];
+    return Promise.resolve(userFunc.apply(void 0, userFuncArgs)).then((result) => {
+      postMessage(["SUCCESS", result]);
+    }).catch((error) => {
+      postMessage(["ERROR", error]);
+    });
+  };
+}
+
+function depsParser(deps) {
+  if (deps.length === 0)
+    return "";
+  const depsString = deps.map((dep) => `'${dep}'`).toString();
+  return `importScripts(${depsString})`;
+}
+
+function createWorkerBlobUrl(fn, deps) {
+  const blobCode = `${depsParser(deps)}; onmessage=(${jobRunner})(${fn})`;
+  const blob = new Blob([blobCode], { type: "text/javascript" });
+  const url = URL.createObjectURL(blob);
+  return url;
+}
+
+function useWebWorkerFn(fn, options = {}) {
+  const {
+    dependencies = [],
+    timeout,
+    window = defaultWindow
+  } = options;
+  const worker = ref();
+  const workerStatus = ref("PENDING");
+  const promise = ref({});
+  const timeoutId = ref();
+  const workerTerminate = (status = "PENDING") => {
+    if (worker.value && worker.value._url && window) {
+      worker.value.terminate();
+      URL.revokeObjectURL(worker.value._url);
+      promise.value = {};
+      worker.value = void 0;
+      window.clearTimeout(timeoutId.value);
+      workerStatus.value = status;
+    }
+  };
+  workerTerminate();
+  tryOnScopeDispose(workerTerminate);
+  const generateWorker = () => {
+    const blobUrl = createWorkerBlobUrl(fn, dependencies);
+    const newWorker = new Worker(blobUrl);
+    newWorker._url = blobUrl;
+    newWorker.onmessage = (e) => {
+      const { resolve = () => {
+      }, reject = () => {
+      } } = promise.value;
+      const [status, result] = e.data;
+      switch (status) {
+        case "SUCCESS":
+          resolve(result);
+          workerTerminate(status);
+          break;
+        default:
+          reject(result);
+          workerTerminate("ERROR");
+          break;
+      }
+    };
+    newWorker.onerror = (e) => {
+      const { reject = () => {
+      } } = promise.value;
+      e.preventDefault();
+      reject(e);
+      workerTerminate("ERROR");
+    };
+    if (timeout) {
+      timeoutId.value = setTimeout(
+        () => workerTerminate("TIMEOUT_EXPIRED"),
+        timeout
+      );
+    }
+    return newWorker;
+  };
+  const callWorker = (...fnArgs) => new Promise((resolve, reject) => {
+    promise.value = {
+      resolve,
+      reject
+    };
+    worker.value && worker.value.postMessage([[...fnArgs]]);
+    workerStatus.value = "RUNNING";
+  });
+  const workerFn = (...fnArgs) => {
+    if (workerStatus.value === "RUNNING") {
+      console.error(
+        "[useWebWorkerFn] You can only run one instance of the worker at a time."
+      );
+      return Promise.reject();
+    }
+    worker.value = generateWorker();
+    return callWorker(...fnArgs);
+  };
+  return {
+    workerFn,
+    workerStatus,
+    workerTerminate
+  };
+}
+
+function useWindowFocus(options = {}) {
+  const { window = defaultWindow } = options;
+  if (!window)
+    return ref(false);
+  const focused = ref(window.document.hasFocus());
+  useEventListener(window, "blur", () => {
+    focused.value = false;
+  });
+  useEventListener(window, "focus", () => {
+    focused.value = true;
+  });
+  return focused;
+}
+
+function useWindowScroll(options = {}) {
+  const { window = defaultWindow, behavior = "auto" } = options;
+  if (!window) {
+    return {
+      x: ref(0),
+      y: ref(0)
+    };
+  }
+  const internalX = ref(window.scrollX);
+  const internalY = ref(window.scrollY);
+  const x = computed({
+    get() {
+      return internalX.value;
+    },
+    set(x2) {
+      scrollTo({ left: x2, behavior });
+    }
+  });
+  const y = computed({
+    get() {
+      return internalY.value;
+    },
+    set(y2) {
+      scrollTo({ top: y2, behavior });
+    }
+  });
+  useEventListener(
+    window,
+    "scroll",
+    () => {
+      internalX.value = window.scrollX;
+      internalY.value = window.scrollY;
+    },
+    {
+      capture: false,
+      passive: true
+    }
+  );
+  return { x, y };
+}
+
+function useWindowSize(options = {}) {
+  const {
+    window = defaultWindow,
+    initialWidth = Number.POSITIVE_INFINITY,
+    initialHeight = Number.POSITIVE_INFINITY,
+    listenOrientation = true,
+    includeScrollbar = true
+  } = options;
+  const width = ref(initialWidth);
+  const height = ref(initialHeight);
+  const update = () => {
+    if (window) {
+      if (includeScrollbar) {
+        width.value = window.innerWidth;
+        height.value = window.innerHeight;
+      } else {
+        width.value = window.document.documentElement.clientWidth;
+        height.value = window.document.documentElement.clientHeight;
+      }
+    }
+  };
+  update();
+  tryOnMounted(update);
+  useEventListener("resize", update, { passive: true });
+  if (listenOrientation) {
+    const matches = useMediaQuery("(orientation: portrait)");
+    watch(matches, () => update());
+  }
+  return { width, height };
+}
+
+export { DefaultMagicKeysAliasMap, StorageSerializers, TransitionPresets, computedAsync as asyncComputed, breakpointsAntDesign, breakpointsBootstrapV5, breakpointsMasterCss, breakpointsPrimeFlex, breakpointsQuasar, breakpointsSematic, breakpointsTailwind, breakpointsVuetify, cloneFnJSON, computedAsync, computedInject, createFetch, createReusableTemplate, createTemplatePromise, createUnrefFn, customStorageEventName, defaultDocument, defaultLocation, defaultNavigator, defaultWindow, executeTransition, formatTimeAgo, getSSRHandler, mapGamepadToXbox360Controller, onClickOutside, onKeyDown, onKeyPressed, onKeyStroke, onKeyUp, onLongPress, onStartTyping, setSSRHandler, templateRef, unrefElement, useActiveElement, useAnimate, useAsyncQueue, useAsyncState, useBase64, useBattery, useBluetooth, useBreakpoints, useBroadcastChannel, useBrowserLocation, useCached, useClipboard, useClipboardItems, useCloned, useColorMode, useConfirmDialog, useCssVar, useCurrentElement, useCycleList, useDark, useDebouncedRefHistory, useDeviceMotion, useDeviceOrientation, useDevicePixelRatio, useDevicesList, useDisplayMedia, useDocumentVisibility, useDraggable, useDropZone, useElementBounding, useElementByPoint, useElementHover, useElementSize, useElementVisibility, useEventBus, useEventListener, useEventSource, useEyeDropper, useFavicon, useFetch, useFileDialog, useFileSystemAccess, useFocus, useFocusWithin, useFps, useFullscreen, useGamepad, useGeolocation, useIdle, useImage, useInfiniteScroll, useIntersectionObserver, useKeyModifier, useLocalStorage, useMagicKeys, useManualRefHistory, useMediaControls, useMediaQuery, useMemoize, useMemory, useMounted, useMouse, useMouseInElement, useMousePressed, useMutationObserver, useNavigatorLanguage, useNetwork, useNow, useObjectUrl, useOffsetPagination, useOnline, usePageLeave, useParallax, useParentElement, usePerformanceObserver, usePermission, usePointer, usePointerLock, usePointerSwipe, usePreferredColorScheme, usePreferredContrast, usePreferredDark, usePreferredLanguages, usePreferredReducedMotion, usePrevious, useRafFn, useRefHistory, useResizeObserver, useScreenOrientation, useScreenSafeArea, useScriptTag, useScroll, useScrollLock, useSessionStorage, useShare, useSorted, useSpeechRecognition, useSpeechSynthesis, useStepper, useStorage, useStorageAsync, useStyleTag, useSupported, useSwipe, useTemplateRefsList, useTextDirection, useTextSelection, useTextareaAutosize, useThrottledRefHistory, useTimeAgo, useTimeoutPoll, useTimestamp, useTitle, useTransition, useUrlSearchParams, useUserMedia, useVModel, useVModels, useVibrate, useVirtualList, useWakeLock, useWebNotification, useWebSocket, useWebWorker, useWebWorkerFn, useWindowFocus, useWindowScroll, useWindowSize };
diff --git a/parent_dir/node_modules/vueuse/head/dist/index.mjs b/parent_dir/node_modules/vueuse/head/dist/index.mjs
new file mode 100644
index 0000000..2adbe39
--- /dev/null
+++ b/parent_dir/node_modules/vueuse/head/dist/index.mjs
@@ -0,0 +1,148 @@
+import { createHead as createHead$1, useHead, Vue2ProvideUnheadPlugin, injectHead } from '@unhead/vue';
+export { Vue2ProvideUnheadPlugin, VueHeadMixin, createHeadCore, injectHead, unheadVueComposablesImports, useBodyAttrs, useHead, useHeadSafe, useHtmlAttrs, useSeoMeta, useServerBodyAttrs, useServerHead, useServerHeadSafe, useServerHtmlAttrs, useServerSeoMeta, useServerTagBase, useServerTagLink, useServerTagMeta, useServerTagMetaFlat, useServerTagNoscript, useServerTagScript, useServerTagStyle, useServerTagTitle, useServerTitleTemplate, useTagBase, useTagLink, useTagMeta, useTagMetaFlat, useTagNoscript, useTagScript, useTagStyle, useTagTitle, useTitleTemplate } from '@unhead/vue';
+import { renderDOMHead, debouncedRenderDOMHead } from '@unhead/dom';
+import { version, defineComponent, ref, onBeforeUnmount, watchEffect } from 'vue';
+import { renderSSRHead } from '@unhead/ssr';
+
+function createHead(initHeadObject, options) {
+  const unhead = createHead$1(options || {});
+  const legacyHead = {
+    unhead,
+    install(app) {
+      if (version.startsWith("3")) {
+        app.config.globalProperties.$head = unhead;
+        app.provide("usehead", unhead);
+      }
+    },
+    use(plugin) {
+      unhead.use(plugin);
+    },
+    resolveTags() {
+      return unhead.resolveTags();
+    },
+    headEntries() {
+      return unhead.headEntries();
+    },
+    headTags() {
+      return unhead.resolveTags();
+    },
+    push(input, options2) {
+      return unhead.push(input, options2);
+    },
+    addEntry(input, options2) {
+      return unhead.push(input, options2);
+    },
+    addHeadObjs(input, options2) {
+      return unhead.push(input, options2);
+    },
+    addReactiveEntry(input, options2) {
+      const api = useHead(input, options2);
+      if (typeof api !== "undefined")
+        return api.dispose;
+      return () => {
+      };
+    },
+    removeHeadObjs() {
+    },
+    updateDOM(document, force) {
+      if (force)
+        renderDOMHead(unhead, { document });
+      else
+        debouncedRenderDOMHead(unhead, { delayFn: (fn) => setTimeout(() => fn(), 50), document });
+    },
+    internalHooks: unhead.hooks,
+    hooks: {
+      "before:dom": [],
+      "resolved:tags": [],
+      "resolved:entries": []
+    }
+  };
+  unhead.addHeadObjs = legacyHead.addHeadObjs;
+  unhead.updateDOM = legacyHead.updateDOM;
+  unhead.hooks.hook("dom:beforeRender", (ctx) => {
+    for (const hook of legacyHead.hooks["before:dom"]) {
+      if (hook() === false)
+        ctx.shouldRender = false;
+    }
+  });
+  if (initHeadObject)
+    legacyHead.addHeadObjs(initHeadObject);
+  return legacyHead;
+}
+
+const HeadVuePlugin = Vue2ProvideUnheadPlugin;
+const renderHeadToString = (head) => renderSSRHead(head.unhead);
+
+const Vue2 = version.startsWith("2.");
+const IsBrowser = typeof window !== "undefined";
+
+const addVNodeToHeadObj = (node, obj) => {
+  const nodeType = Vue2 ? node.tag : node.type;
+  const type = nodeType === "html" ? "htmlAttrs" : nodeType === "body" ? "bodyAttrs" : nodeType;
+  if (typeof type !== "string" || !(type in obj))
+    return;
+  const nodeData = Vue2 ? node.data : node;
+  const props = (Vue2 ? nodeData.attrs : node.props) || {};
+  if (Vue2) {
+    if (nodeData.staticClass)
+      props.class = nodeData.staticClass;
+    if (nodeData.staticStyle)
+      props.style = Object.entries(nodeData.staticStyle).map(([key, value]) => `${key}:${value}`).join(";");
+  }
+  if (node.children) {
+    const childrenAttr = Vue2 ? "text" : "children";
+    props.children = Array.isArray(node.children) ? node.children[0][childrenAttr] : node[childrenAttr];
+  }
+  if (Array.isArray(obj[type]))
+    obj[type].push(props);
+  else if (type === "title")
+    obj.title = props.children;
+  else
+    obj[type] = props;
+};
+const vnodesToHeadObj = (nodes) => {
+  const obj = {
+    title: void 0,
+    htmlAttrs: void 0,
+    bodyAttrs: void 0,
+    base: void 0,
+    meta: [],
+    link: [],
+    style: [],
+    script: [],
+    noscript: []
+  };
+  for (const node of nodes) {
+    if (typeof node.type === "symbol" && Array.isArray(node.children)) {
+      for (const childNode of node.children)
+        addVNodeToHeadObj(childNode, obj);
+    } else {
+      addVNodeToHeadObj(node, obj);
+    }
+  }
+  return obj;
+};
+const Head = /* @__PURE__ */ defineComponent({
+  // eslint-disable-next-line vue/no-reserved-component-names
+  name: "Head",
+  setup(_, { slots }) {
+    const head = injectHead();
+    const obj = ref({});
+    const entry = head.push(obj);
+    if (IsBrowser) {
+      onBeforeUnmount(() => {
+        entry.dispose();
+      });
+    }
+    return () => {
+      watchEffect(() => {
+        if (!slots.default)
+          return;
+        entry.patch(vnodesToHeadObj(slots.default()));
+      });
+      return null;
+    };
+  }
+});
+
+export { Head, HeadVuePlugin, createHead, renderHeadToString };
diff --git a/parent_dir/node_modules/vueuse/shared/index.mjs b/parent_dir/node_modules/vueuse/shared/index.mjs
new file mode 100644
index 0000000..4457171
--- /dev/null
+++ b/parent_dir/node_modules/vueuse/shared/index.mjs
@@ -0,0 +1,1559 @@
+import { shallowRef, watchEffect, readonly, ref, watch, customRef, getCurrentScope, onScopeDispose, effectScope, getCurrentInstance, provide, inject, isVue3, version, isRef, unref, computed, reactive, toRefs as toRefs$1, toRef as toRef$1, isVue2, set as set$1, onBeforeMount, nextTick, onBeforeUnmount, onMounted, onUnmounted, isReactive } from 'vue-demi';
+
+function computedEager(fn, options) {
+  var _a;
+  const result = shallowRef();
+  watchEffect(() => {
+    result.value = fn();
+  }, {
+    ...options,
+    flush: (_a = options == null ? void 0 : options.flush) != null ? _a : "sync"
+  });
+  return readonly(result);
+}
+
+function computedWithControl(source, fn) {
+  let v = void 0;
+  let track;
+  let trigger;
+  const dirty = ref(true);
+  const update = () => {
+    dirty.value = true;
+    trigger();
+  };
+  watch(source, update, { flush: "sync" });
+  const get = typeof fn === "function" ? fn : fn.get;
+  const set = typeof fn === "function" ? void 0 : fn.set;
+  const result = customRef((_track, _trigger) => {
+    track = _track;
+    trigger = _trigger;
+    return {
+      get() {
+        if (dirty.value) {
+          v = get();
+          dirty.value = false;
+        }
+        track();
+        return v;
+      },
+      set(v2) {
+        set == null ? void 0 : set(v2);
+      }
+    };
+  });
+  if (Object.isExtensible(result))
+    result.trigger = update;
+  return result;
+}
+
+function tryOnScopeDispose(fn) {
+  if (getCurrentScope()) {
+    onScopeDispose(fn);
+    return true;
+  }
+  return false;
+}
+
+function createEventHook() {
+  const fns = /* @__PURE__ */ new Set();
+  const off = (fn) => {
+    fns.delete(fn);
+  };
+  const on = (fn) => {
+    fns.add(fn);
+    const offFn = () => off(fn);
+    tryOnScopeDispose(offFn);
+    return {
+      off: offFn
+    };
+  };
+  const trigger = (...args) => {
+    return Promise.all(Array.from(fns).map((fn) => fn(...args)));
+  };
+  return {
+    on,
+    off,
+    trigger
+  };
+}
+
+function createGlobalState(stateFactory) {
+  let initialized = false;
+  let state;
+  const scope = effectScope(true);
+  return (...args) => {
+    if (!initialized) {
+      state = scope.run(() => stateFactory(...args));
+      initialized = true;
+    }
+    return state;
+  };
+}
+
+const localProvidedStateMap = /* @__PURE__ */ new WeakMap();
+
+const provideLocal = (key, value) => {
+  var _a;
+  const instance = (_a = getCurrentInstance()) == null ? void 0 : _a.proxy;
+  if (instance == null)
+    throw new Error("provideLocal must be called in setup");
+  if (!localProvidedStateMap.has(instance))
+    localProvidedStateMap.set(instance, /* @__PURE__ */ Object.create(null));
+  const localProvidedState = localProvidedStateMap.get(instance);
+  localProvidedState[key] = value;
+  provide(key, value);
+};
+
+const injectLocal = (...args) => {
+  var _a;
+  const key = args[0];
+  const instance = (_a = getCurrentInstance()) == null ? void 0 : _a.proxy;
+  if (instance == null)
+    throw new Error("injectLocal must be called in setup");
+  if (localProvidedStateMap.has(instance) && key in localProvidedStateMap.get(instance))
+    return localProvidedStateMap.get(instance)[key];
+  return inject(...args);
+};
+
+function createInjectionState(composable, options) {
+  const key = (options == null ? void 0 : options.injectionKey) || Symbol("InjectionState");
+  const useProvidingState = (...args) => {
+    const state = composable(...args);
+    provideLocal(key, state);
+    return state;
+  };
+  const useInjectedState = () => injectLocal(key);
+  return [useProvidingState, useInjectedState];
+}
+
+function createSharedComposable(composable) {
+  let subscribers = 0;
+  let state;
+  let scope;
+  const dispose = () => {
+    subscribers -= 1;
+    if (scope && subscribers <= 0) {
+      scope.stop();
+      state = void 0;
+      scope = void 0;
+    }
+  };
+  return (...args) => {
+    subscribers += 1;
+    if (!state) {
+      scope = effectScope(true);
+      state = scope.run(() => composable(...args));
+    }
+    tryOnScopeDispose(dispose);
+    return state;
+  };
+}
+
+function extendRef(ref, extend, { enumerable = false, unwrap = true } = {}) {
+  if (!isVue3 && !version.startsWith("2.7.")) {
+    if (process.env.NODE_ENV !== "production")
+      throw new Error("[VueUse] extendRef only works in Vue 2.7 or above.");
+    return;
+  }
+  for (const [key, value] of Object.entries(extend)) {
+    if (key === "value")
+      continue;
+    if (isRef(value) && unwrap) {
+      Object.defineProperty(ref, key, {
+        get() {
+          return value.value;
+        },
+        set(v) {
+          value.value = v;
+        },
+        enumerable
+      });
+    } else {
+      Object.defineProperty(ref, key, { value, enumerable });
+    }
+  }
+  return ref;
+}
+
+function get(obj, key) {
+  if (key == null)
+    return unref(obj);
+  return unref(obj)[key];
+}
+
+function isDefined(v) {
+  return unref(v) != null;
+}
+
+function makeDestructurable(obj, arr) {
+  if (typeof Symbol !== "undefined") {
+    const clone = { ...obj };
+    Object.defineProperty(clone, Symbol.iterator, {
+      enumerable: false,
+      value() {
+        let index = 0;
+        return {
+          next: () => ({
+            value: arr[index++],
+            done: index > arr.length
+          })
+        };
+      }
+    });
+    return clone;
+  } else {
+    return Object.assign([...arr], obj);
+  }
+}
+
+function toValue(r) {
+  return typeof r === "function" ? r() : unref(r);
+}
+const resolveUnref = toValue;
+
+function reactify(fn, options) {
+  const unrefFn = (options == null ? void 0 : options.computedGetter) === false ? unref : toValue;
+  return function(...args) {
+    return computed(() => fn.apply(this, args.map((i) => unrefFn(i))));
+  };
+}
+
+function reactifyObject(obj, optionsOrKeys = {}) {
+  let keys = [];
+  let options;
+  if (Array.isArray(optionsOrKeys)) {
+    keys = optionsOrKeys;
+  } else {
+    options = optionsOrKeys;
+    const { includeOwnProperties = true } = optionsOrKeys;
+    keys.push(...Object.keys(obj));
+    if (includeOwnProperties)
+      keys.push(...Object.getOwnPropertyNames(obj));
+  }
+  return Object.fromEntries(
+    keys.map((key) => {
+      const value = obj[key];
+      return [
+        key,
+        typeof value === "function" ? reactify(value.bind(obj), options) : value
+      ];
+    })
+  );
+}
+
+function toReactive(objectRef) {
+  if (!isRef(objectRef))
+    return reactive(objectRef);
+  const proxy = new Proxy({}, {
+    get(_, p, receiver) {
+      return unref(Reflect.get(objectRef.value, p, receiver));
+    },
+    set(_, p, value) {
+      if (isRef(objectRef.value[p]) && !isRef(value))
+        objectRef.value[p].value = value;
+      else
+        objectRef.value[p] = value;
+      return true;
+    },
+    deleteProperty(_, p) {
+      return Reflect.deleteProperty(objectRef.value, p);
+    },
+    has(_, p) {
+      return Reflect.has(objectRef.value, p);
+    },
+    ownKeys() {
+      return Object.keys(objectRef.value);
+    },
+    getOwnPropertyDescriptor() {
+      return {
+        enumerable: true,
+        configurable: true
+      };
+    }
+  });
+  return reactive(proxy);
+}
+
+function reactiveComputed(fn) {
+  return toReactive(computed(fn));
+}
+
+function reactiveOmit(obj, ...keys) {
+  const flatKeys = keys.flat();
+  const predicate = flatKeys[0];
+  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(toRefs$1(obj)).filter(([k, v]) => !predicate(toValue(v), k))) : Object.fromEntries(Object.entries(toRefs$1(obj)).filter((e) => !flatKeys.includes(e[0]))));
+}
+
+const isClient = typeof window !== "undefined" && typeof document !== "undefined";
+const isWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+const isDef = (val) => typeof val !== "undefined";
+const notNullish = (val) => val != null;
+const assert = (condition, ...infos) => {
+  if (!condition)
+    console.warn(...infos);
+};
+const toString = Object.prototype.toString;
+const isObject = (val) => toString.call(val) === "[object Object]";
+const now = () => Date.now();
+const timestamp = () => +Date.now();
+const clamp = (n, min, max) => Math.min(max, Math.max(min, n));
+const noop = () => {
+};
+const rand = (min, max) => {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+const hasOwn = (val, key) => Object.prototype.hasOwnProperty.call(val, key);
+const isIOS = /* @__PURE__ */ getIsIOS();
+function getIsIOS() {
+  var _a, _b;
+  return isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && (/iP(ad|hone|od)/.test(window.navigator.userAgent) || ((_b = window == null ? void 0 : window.navigator) == null ? void 0 : _b.maxTouchPoints) > 2 && /iPad|Macintosh/.test(window == null ? void 0 : window.navigator.userAgent));
+}
+
+function createFilterWrapper(filter, fn) {
+  function wrapper(...args) {
+    return new Promise((resolve, reject) => {
+      Promise.resolve(filter(() => fn.apply(this, args), { fn, thisArg: this, args })).then(resolve).catch(reject);
+    });
+  }
+  return wrapper;
+}
+const bypassFilter = (invoke) => {
+  return invoke();
+};
+function debounceFilter(ms, options = {}) {
+  let timer;
+  let maxTimer;
+  let lastRejector = noop;
+  const _clearTimeout = (timer2) => {
+    clearTimeout(timer2);
+    lastRejector();
+    lastRejector = noop;
+  };
+  const filter = (invoke) => {
+    const duration = toValue(ms);
+    const maxDuration = toValue(options.maxWait);
+    if (timer)
+      _clearTimeout(timer);
+    if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
+      if (maxTimer) {
+        _clearTimeout(maxTimer);
+        maxTimer = null;
+      }
+      return Promise.resolve(invoke());
+    }
+    return new Promise((resolve, reject) => {
+      lastRejector = options.rejectOnCancel ? reject : resolve;
+      if (maxDuration && !maxTimer) {
+        maxTimer = setTimeout(() => {
+          if (timer)
+            _clearTimeout(timer);
+          maxTimer = null;
+          resolve(invoke());
+        }, maxDuration);
+      }
+      timer = setTimeout(() => {
+        if (maxTimer)
+          _clearTimeout(maxTimer);
+        maxTimer = null;
+        resolve(invoke());
+      }, duration);
+    });
+  };
+  return filter;
+}
+function throttleFilter(ms, trailing = true, leading = true, rejectOnCancel = false) {
+  let lastExec = 0;
+  let timer;
+  let isLeading = true;
+  let lastRejector = noop;
+  let lastValue;
+  const clear = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+      lastRejector();
+      lastRejector = noop;
+    }
+  };
+  const filter = (_invoke) => {
+    const duration = toValue(ms);
+    const elapsed = Date.now() - lastExec;
+    const invoke = () => {
+      return lastValue = _invoke();
+    };
+    clear();
+    if (duration <= 0) {
+      lastExec = Date.now();
+      return invoke();
+    }
+    if (elapsed > duration && (leading || !isLeading)) {
+      lastExec = Date.now();
+      invoke();
+    } else if (trailing) {
+      lastValue = new Promise((resolve, reject) => {
+        lastRejector = rejectOnCancel ? reject : resolve;
+        timer = setTimeout(() => {
+          lastExec = Date.now();
+          isLeading = true;
+          resolve(invoke());
+          clear();
+        }, Math.max(0, duration - elapsed));
+      });
+    }
+    if (!leading && !timer)
+      timer = setTimeout(() => isLeading = true, duration);
+    isLeading = false;
+    return lastValue;
+  };
+  return filter;
+}
+function pausableFilter(extendFilter = bypassFilter) {
+  const isActive = ref(true);
+  function pause() {
+    isActive.value = false;
+  }
+  function resume() {
+    isActive.value = true;
+  }
+  const eventFilter = (...args) => {
+    if (isActive.value)
+      extendFilter(...args);
+  };
+  return { isActive: readonly(isActive), pause, resume, eventFilter };
+}
+
+const directiveHooks = {
+  mounted: isVue3 ? "mounted" : "inserted",
+  updated: isVue3 ? "updated" : "componentUpdated",
+  unmounted: isVue3 ? "unmounted" : "unbind"
+};
+
+function cacheStringFunction(fn) {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return (str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+}
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
+const camelizeRE = /-(\w)/g;
+const camelize = cacheStringFunction((str) => {
+  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+});
+
+function promiseTimeout(ms, throwOnTimeout = false, reason = "Timeout") {
+  return new Promise((resolve, reject) => {
+    if (throwOnTimeout)
+      setTimeout(() => reject(reason), ms);
+    else
+      setTimeout(resolve, ms);
+  });
+}
+function identity(arg) {
+  return arg;
+}
+function createSingletonPromise(fn) {
+  let _promise;
+  function wrapper() {
+    if (!_promise)
+      _promise = fn();
+    return _promise;
+  }
+  wrapper.reset = async () => {
+    const _prev = _promise;
+    _promise = void 0;
+    if (_prev)
+      await _prev;
+  };
+  return wrapper;
+}
+function invoke(fn) {
+  return fn();
+}
+function containsProp(obj, ...props) {
+  return props.some((k) => k in obj);
+}
+function increaseWithUnit(target, delta) {
+  var _a;
+  if (typeof target === "number")
+    return target + delta;
+  const value = ((_a = target.match(/^-?[0-9]+\.?[0-9]*/)) == null ? void 0 : _a[0]) || "";
+  const unit = target.slice(value.length);
+  const result = Number.parseFloat(value) + delta;
+  if (Number.isNaN(result))
+    return target;
+  return result + unit;
+}
+function objectPick(obj, keys, omitUndefined = false) {
+  return keys.reduce((n, k) => {
+    if (k in obj) {
+      if (!omitUndefined || obj[k] !== void 0)
+        n[k] = obj[k];
+    }
+    return n;
+  }, {});
+}
+function objectOmit(obj, keys, omitUndefined = false) {
+  return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
+    return (!omitUndefined || value !== void 0) && !keys.includes(key);
+  }));
+}
+function objectEntries(obj) {
+  return Object.entries(obj);
+}
+function getLifeCycleTarget(target) {
+  return target || getCurrentInstance();
+}
+
+function toRef(...args) {
+  if (args.length !== 1)
+    return toRef$1(...args);
+  const r = args[0];
+  return typeof r === "function" ? readonly(customRef(() => ({ get: r, set: noop }))) : ref(r);
+}
+const resolveRef = toRef;
+
+function reactivePick(obj, ...keys) {
+  const flatKeys = keys.flat();
+  const predicate = flatKeys[0];
+  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(toRefs$1(obj)).filter(([k, v]) => predicate(toValue(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, toRef(obj, k)])));
+}
+
+function refAutoReset(defaultValue, afterMs = 1e4) {
+  return customRef((track, trigger) => {
+    let value = toValue(defaultValue);
+    let timer;
+    const resetAfter = () => setTimeout(() => {
+      value = toValue(defaultValue);
+      trigger();
+    }, toValue(afterMs));
+    tryOnScopeDispose(() => {
+      clearTimeout(timer);
+    });
+    return {
+      get() {
+        track();
+        return value;
+      },
+      set(newValue) {
+        value = newValue;
+        trigger();
+        clearTimeout(timer);
+        timer = resetAfter();
+      }
+    };
+  });
+}
+
+function useDebounceFn(fn, ms = 200, options = {}) {
+  return createFilterWrapper(
+    debounceFilter(ms, options),
+    fn
+  );
+}
+
+function refDebounced(value, ms = 200, options = {}) {
+  const debounced = ref(value.value);
+  const updater = useDebounceFn(() => {
+    debounced.value = value.value;
+  }, ms, options);
+  watch(value, () => updater());
+  return debounced;
+}
+
+function refDefault(source, defaultValue) {
+  return computed({
+    get() {
+      var _a;
+      return (_a = source.value) != null ? _a : defaultValue;
+    },
+    set(value) {
+      source.value = value;
+    }
+  });
+}
+
+function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
+  return createFilterWrapper(
+    throttleFilter(ms, trailing, leading, rejectOnCancel),
+    fn
+  );
+}
+
+function refThrottled(value, delay = 200, trailing = true, leading = true) {
+  if (delay <= 0)
+    return value;
+  const throttled = ref(value.value);
+  const updater = useThrottleFn(() => {
+    throttled.value = value.value;
+  }, delay, trailing, leading);
+  watch(value, () => updater());
+  return throttled;
+}
+
+function refWithControl(initial, options = {}) {
+  let source = initial;
+  let track;
+  let trigger;
+  const ref = customRef((_track, _trigger) => {
+    track = _track;
+    trigger = _trigger;
+    return {
+      get() {
+        return get();
+      },
+      set(v) {
+        set(v);
+      }
+    };
+  });
+  function get(tracking = true) {
+    if (tracking)
+      track();
+    return source;
+  }
+  function set(value, triggering = true) {
+    var _a, _b;
+    if (value === source)
+      return;
+    const old = source;
+    if (((_a = options.onBeforeChange) == null ? void 0 : _a.call(options, value, old)) === false)
+      return;
+    source = value;
+    (_b = options.onChanged) == null ? void 0 : _b.call(options, value, old);
+    if (triggering)
+      trigger();
+  }
+  const untrackedGet = () => get(false);
+  const silentSet = (v) => set(v, false);
+  const peek = () => get(false);
+  const lay = (v) => set(v, false);
+  return extendRef(
+    ref,
+    {
+      get,
+      set,
+      untrackedGet,
+      silentSet,
+      peek,
+      lay
+    },
+    { enumerable: true }
+  );
+}
+const controlledRef = refWithControl;
+
+function set(...args) {
+  if (args.length === 2) {
+    const [ref, value] = args;
+    ref.value = value;
+  }
+  if (args.length === 3) {
+    if (isVue2) {
+      set$1(...args);
+    } else {
+      const [target, key, value] = args;
+      target[key] = value;
+    }
+  }
+}
+
+function watchWithFilter(source, cb, options = {}) {
+  const {
+    eventFilter = bypassFilter,
+    ...watchOptions
+  } = options;
+  return watch(
+    source,
+    createFilterWrapper(
+      eventFilter,
+      cb
+    ),
+    watchOptions
+  );
+}
+
+function watchPausable(source, cb, options = {}) {
+  const {
+    eventFilter: filter,
+    ...watchOptions
+  } = options;
+  const { eventFilter, pause, resume, isActive } = pausableFilter(filter);
+  const stop = watchWithFilter(
+    source,
+    cb,
+    {
+      ...watchOptions,
+      eventFilter
+    }
+  );
+  return { stop, pause, resume, isActive };
+}
+
+function syncRef(left, right, ...[options]) {
+  const {
+    flush = "sync",
+    deep = false,
+    immediate = true,
+    direction = "both",
+    transform = {}
+  } = options || {};
+  const watchers = [];
+  const transformLTR = "ltr" in transform && transform.ltr || ((v) => v);
+  const transformRTL = "rtl" in transform && transform.rtl || ((v) => v);
+  if (direction === "both" || direction === "ltr") {
+    watchers.push(watchPausable(
+      left,
+      (newValue) => {
+        watchers.forEach((w) => w.pause());
+        right.value = transformLTR(newValue);
+        watchers.forEach((w) => w.resume());
+      },
+      { flush, deep, immediate }
+    ));
+  }
+  if (direction === "both" || direction === "rtl") {
+    watchers.push(watchPausable(
+      right,
+      (newValue) => {
+        watchers.forEach((w) => w.pause());
+        left.value = transformRTL(newValue);
+        watchers.forEach((w) => w.resume());
+      },
+      { flush, deep, immediate }
+    ));
+  }
+  const stop = () => {
+    watchers.forEach((w) => w.stop());
+  };
+  return stop;
+}
+
+function syncRefs(source, targets, options = {}) {
+  const {
+    flush = "sync",
+    deep = false,
+    immediate = true
+  } = options;
+  if (!Array.isArray(targets))
+    targets = [targets];
+  return watch(
+    source,
+    (newValue) => targets.forEach((target) => target.value = newValue),
+    { flush, deep, immediate }
+  );
+}
+
+function toRefs(objectRef, options = {}) {
+  if (!isRef(objectRef))
+    return toRefs$1(objectRef);
+  const result = Array.isArray(objectRef.value) ? Array.from({ length: objectRef.value.length }) : {};
+  for (const key in objectRef.value) {
+    result[key] = customRef(() => ({
+      get() {
+        return objectRef.value[key];
+      },
+      set(v) {
+        var _a;
+        const replaceRef = (_a = toValue(options.replaceRef)) != null ? _a : true;
+        if (replaceRef) {
+          if (Array.isArray(objectRef.value)) {
+            const copy = [...objectRef.value];
+            copy[key] = v;
+            objectRef.value = copy;
+          } else {
+            const newObject = { ...objectRef.value, [key]: v };
+            Object.setPrototypeOf(newObject, Object.getPrototypeOf(objectRef.value));
+            objectRef.value = newObject;
+          }
+        } else {
+          objectRef.value[key] = v;
+        }
+      }
+    }));
+  }
+  return result;
+}
+
+function tryOnBeforeMount(fn, sync = true, target) {
+  const instance = getLifeCycleTarget(target);
+  if (instance)
+    onBeforeMount(fn, target);
+  else if (sync)
+    fn();
+  else
+    nextTick(fn);
+}
+
+function tryOnBeforeUnmount(fn, target) {
+  const instance = getLifeCycleTarget(target);
+  if (instance)
+    onBeforeUnmount(fn, target);
+}
+
+function tryOnMounted(fn, sync = true, target) {
+  const instance = getLifeCycleTarget();
+  if (instance)
+    onMounted(fn, target);
+  else if (sync)
+    fn();
+  else
+    nextTick(fn);
+}
+
+function tryOnUnmounted(fn, target) {
+  const instance = getLifeCycleTarget(target);
+  if (instance)
+    onUnmounted(fn, target);
+}
+
+function createUntil(r, isNot = false) {
+  function toMatch(condition, { flush = "sync", deep = false, timeout, throwOnTimeout } = {}) {
+    let stop = null;
+    const watcher = new Promise((resolve) => {
+      stop = watch(
+        r,
+        (v) => {
+          if (condition(v) !== isNot) {
+            stop == null ? void 0 : stop();
+            resolve(v);
+          }
+        },
+        {
+          flush,
+          deep,
+          immediate: true
+        }
+      );
+    });
+    const promises = [watcher];
+    if (timeout != null) {
+      promises.push(
+        promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => stop == null ? void 0 : stop())
+      );
+    }
+    return Promise.race(promises);
+  }
+  function toBe(value, options) {
+    if (!isRef(value))
+      return toMatch((v) => v === value, options);
+    const { flush = "sync", deep = false, timeout, throwOnTimeout } = options != null ? options : {};
+    let stop = null;
+    const watcher = new Promise((resolve) => {
+      stop = watch(
+        [r, value],
+        ([v1, v2]) => {
+          if (isNot !== (v1 === v2)) {
+            stop == null ? void 0 : stop();
+            resolve(v1);
+          }
+        },
+        {
+          flush,
+          deep,
+          immediate: true
+        }
+      );
+    });
+    const promises = [watcher];
+    if (timeout != null) {
+      promises.push(
+        promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => {
+          stop == null ? void 0 : stop();
+          return toValue(r);
+        })
+      );
+    }
+    return Promise.race(promises);
+  }
+  function toBeTruthy(options) {
+    return toMatch((v) => Boolean(v), options);
+  }
+  function toBeNull(options) {
+    return toBe(null, options);
+  }
+  function toBeUndefined(options) {
+    return toBe(void 0, options);
+  }
+  function toBeNaN(options) {
+    return toMatch(Number.isNaN, options);
+  }
+  function toContains(value, options) {
+    return toMatch((v) => {
+      const array = Array.from(v);
+      return array.includes(value) || array.includes(toValue(value));
+    }, options);
+  }
+  function changed(options) {
+    return changedTimes(1, options);
+  }
+  function changedTimes(n = 1, options) {
+    let count = -1;
+    return toMatch(() => {
+      count += 1;
+      return count >= n;
+    }, options);
+  }
+  if (Array.isArray(toValue(r))) {
+    const instance = {
+      toMatch,
+      toContains,
+      changed,
+      changedTimes,
+      get not() {
+        return createUntil(r, !isNot);
+      }
+    };
+    return instance;
+  } else {
+    const instance = {
+      toMatch,
+      toBe,
+      toBeTruthy,
+      toBeNull,
+      toBeNaN,
+      toBeUndefined,
+      changed,
+      changedTimes,
+      get not() {
+        return createUntil(r, !isNot);
+      }
+    };
+    return instance;
+  }
+}
+function until(r) {
+  return createUntil(r);
+}
+
+function defaultComparator(value, othVal) {
+  return value === othVal;
+}
+function useArrayDifference(...args) {
+  var _a;
+  const list = args[0];
+  const values = args[1];
+  let compareFn = (_a = args[2]) != null ? _a : defaultComparator;
+  if (typeof compareFn === "string") {
+    const key = compareFn;
+    compareFn = (value, othVal) => value[key] === othVal[key];
+  }
+  return computed(() => toValue(list).filter((x) => toValue(values).findIndex((y) => compareFn(x, y)) === -1));
+}
+
+function useArrayEvery(list, fn) {
+  return computed(() => toValue(list).every((element, index, array) => fn(toValue(element), index, array)));
+}
+
+function useArrayFilter(list, fn) {
+  return computed(() => toValue(list).map((i) => toValue(i)).filter(fn));
+}
+
+function useArrayFind(list, fn) {
+  return computed(() => toValue(
+    toValue(list).find((element, index, array) => fn(toValue(element), index, array))
+  ));
+}
+
+function useArrayFindIndex(list, fn) {
+  return computed(() => toValue(list).findIndex((element, index, array) => fn(toValue(element), index, array)));
+}
+
+function findLast(arr, cb) {
+  let index = arr.length;
+  while (index-- > 0) {
+    if (cb(arr[index], index, arr))
+      return arr[index];
+  }
+  return void 0;
+}
+function useArrayFindLast(list, fn) {
+  return computed(() => toValue(
+    !Array.prototype.findLast ? findLast(toValue(list), (element, index, array) => fn(toValue(element), index, array)) : toValue(list).findLast((element, index, array) => fn(toValue(element), index, array))
+  ));
+}
+
+function isArrayIncludesOptions(obj) {
+  return isObject(obj) && containsProp(obj, "formIndex", "comparator");
+}
+function useArrayIncludes(...args) {
+  var _a;
+  const list = args[0];
+  const value = args[1];
+  let comparator = args[2];
+  let formIndex = 0;
+  if (isArrayIncludesOptions(comparator)) {
+    formIndex = (_a = comparator.fromIndex) != null ? _a : 0;
+    comparator = comparator.comparator;
+  }
+  if (typeof comparator === "string") {
+    const key = comparator;
+    comparator = (element, value2) => element[key] === toValue(value2);
+  }
+  comparator = comparator != null ? comparator : (element, value2) => element === toValue(value2);
+  return computed(() => toValue(list).slice(formIndex).some((element, index, array) => comparator(
+    toValue(element),
+    toValue(value),
+    index,
+    toValue(array)
+  )));
+}
+
+function useArrayJoin(list, separator) {
+  return computed(() => toValue(list).map((i) => toValue(i)).join(toValue(separator)));
+}
+
+function useArrayMap(list, fn) {
+  return computed(() => toValue(list).map((i) => toValue(i)).map(fn));
+}
+
+function useArrayReduce(list, reducer, ...args) {
+  const reduceCallback = (sum, value, index) => reducer(toValue(sum), toValue(value), index);
+  return computed(() => {
+    const resolved = toValue(list);
+    return args.length ? resolved.reduce(reduceCallback, toValue(args[0])) : resolved.reduce(reduceCallback);
+  });
+}
+
+function useArraySome(list, fn) {
+  return computed(() => toValue(list).some((element, index, array) => fn(toValue(element), index, array)));
+}
+
+function uniq(array) {
+  return Array.from(new Set(array));
+}
+function uniqueElementsBy(array, fn) {
+  return array.reduce((acc, v) => {
+    if (!acc.some((x) => fn(v, x, array)))
+      acc.push(v);
+    return acc;
+  }, []);
+}
+function useArrayUnique(list, compareFn) {
+  return computed(() => {
+    const resolvedList = toValue(list).map((element) => toValue(element));
+    return compareFn ? uniqueElementsBy(resolvedList, compareFn) : uniq(resolvedList);
+  });
+}
+
+function useCounter(initialValue = 0, options = {}) {
+  let _initialValue = unref(initialValue);
+  const count = ref(initialValue);
+  const {
+    max = Number.POSITIVE_INFINITY,
+    min = Number.NEGATIVE_INFINITY
+  } = options;
+  const inc = (delta = 1) => count.value = Math.min(max, count.value + delta);
+  const dec = (delta = 1) => count.value = Math.max(min, count.value - delta);
+  const get = () => count.value;
+  const set = (val) => count.value = Math.max(min, Math.min(max, val));
+  const reset = (val = _initialValue) => {
+    _initialValue = val;
+    return set(val);
+  };
+  return { count, inc, dec, get, set, reset };
+}
+
+const REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/;
+const REGEX_FORMAT = /[YMDHhms]o|\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a{1,2}|A{1,2}|m{1,2}|s{1,2}|Z{1,2}|SSS/g;
+function defaultMeridiem(hours, minutes, isLowercase, hasPeriod) {
+  let m = hours < 12 ? "AM" : "PM";
+  if (hasPeriod)
+    m = m.split("").reduce((acc, curr) => acc += `${curr}.`, "");
+  return isLowercase ? m.toLowerCase() : m;
+}
+function formatOrdinal(num) {
+  const suffixes = ["th", "st", "nd", "rd"];
+  const v = num % 100;
+  return num + (suffixes[(v - 20) % 10] || suffixes[v] || suffixes[0]);
+}
+function formatDate(date, formatStr, options = {}) {
+  var _a;
+  const years = date.getFullYear();
+  const month = date.getMonth();
+  const days = date.getDate();
+  const hours = date.getHours();
+  const minutes = date.getMinutes();
+  const seconds = date.getSeconds();
+  const milliseconds = date.getMilliseconds();
+  const day = date.getDay();
+  const meridiem = (_a = options.customMeridiem) != null ? _a : defaultMeridiem;
+  const matches = {
+    Yo: () => formatOrdinal(years),
+    YY: () => String(years).slice(-2),
+    YYYY: () => years,
+    M: () => month + 1,
+    Mo: () => formatOrdinal(month + 1),
+    MM: () => `${month + 1}`.padStart(2, "0"),
+    MMM: () => date.toLocaleDateString(options.locales, { month: "short" }),
+    MMMM: () => date.toLocaleDateString(options.locales, { month: "long" }),
+    D: () => String(days),
+    Do: () => formatOrdinal(days),
+    DD: () => `${days}`.padStart(2, "0"),
+    H: () => String(hours),
+    Ho: () => formatOrdinal(hours),
+    HH: () => `${hours}`.padStart(2, "0"),
+    h: () => `${hours % 12 || 12}`.padStart(1, "0"),
+    ho: () => formatOrdinal(hours % 12 || 12),
+    hh: () => `${hours % 12 || 12}`.padStart(2, "0"),
+    m: () => String(minutes),
+    mo: () => formatOrdinal(minutes),
+    mm: () => `${minutes}`.padStart(2, "0"),
+    s: () => String(seconds),
+    so: () => formatOrdinal(seconds),
+    ss: () => `${seconds}`.padStart(2, "0"),
+    SSS: () => `${milliseconds}`.padStart(3, "0"),
+    d: () => day,
+    dd: () => date.toLocaleDateString(options.locales, { weekday: "narrow" }),
+    ddd: () => date.toLocaleDateString(options.locales, { weekday: "short" }),
+    dddd: () => date.toLocaleDateString(options.locales, { weekday: "long" }),
+    A: () => meridiem(hours, minutes),
+    AA: () => meridiem(hours, minutes, false, true),
+    a: () => meridiem(hours, minutes, true),
+    aa: () => meridiem(hours, minutes, true, true)
+  };
+  return formatStr.replace(REGEX_FORMAT, (match, $1) => {
+    var _a2, _b;
+    return (_b = $1 != null ? $1 : (_a2 = matches[match]) == null ? void 0 : _a2.call(matches)) != null ? _b : match;
+  });
+}
+function normalizeDate(date) {
+  if (date === null)
+    return new Date(Number.NaN);
+  if (date === void 0)
+    return /* @__PURE__ */ new Date();
+  if (date instanceof Date)
+    return new Date(date);
+  if (typeof date === "string" && !/Z$/i.test(date)) {
+    const d = date.match(REGEX_PARSE);
+    if (d) {
+      const m = d[2] - 1 || 0;
+      const ms = (d[7] || "0").substring(0, 3);
+      return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms);
+    }
+  }
+  return new Date(date);
+}
+function useDateFormat(date, formatStr = "HH:mm:ss", options = {}) {
+  return computed(() => formatDate(normalizeDate(toValue(date)), toValue(formatStr), options));
+}
+
+function useIntervalFn(cb, interval = 1e3, options = {}) {
+  const {
+    immediate = true,
+    immediateCallback = false
+  } = options;
+  let timer = null;
+  const isActive = ref(false);
+  function clean() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+  function pause() {
+    isActive.value = false;
+    clean();
+  }
+  function resume() {
+    const intervalValue = toValue(interval);
+    if (intervalValue <= 0)
+      return;
+    isActive.value = true;
+    if (immediateCallback)
+      cb();
+    clean();
+    timer = setInterval(cb, intervalValue);
+  }
+  if (immediate && isClient)
+    resume();
+  if (isRef(interval) || typeof interval === "function") {
+    const stopWatch = watch(interval, () => {
+      if (isActive.value && isClient)
+        resume();
+    });
+    tryOnScopeDispose(stopWatch);
+  }
+  tryOnScopeDispose(pause);
+  return {
+    isActive,
+    pause,
+    resume
+  };
+}
+
+function useInterval(interval = 1e3, options = {}) {
+  const {
+    controls: exposeControls = false,
+    immediate = true,
+    callback
+  } = options;
+  const counter = ref(0);
+  const update = () => counter.value += 1;
+  const reset = () => {
+    counter.value = 0;
+  };
+  const controls = useIntervalFn(
+    callback ? () => {
+      update();
+      callback(counter.value);
+    } : update,
+    interval,
+    { immediate }
+  );
+  if (exposeControls) {
+    return {
+      counter,
+      reset,
+      ...controls
+    };
+  } else {
+    return counter;
+  }
+}
+
+function useLastChanged(source, options = {}) {
+  var _a;
+  const ms = ref((_a = options.initialValue) != null ? _a : null);
+  watch(
+    source,
+    () => ms.value = timestamp(),
+    options
+  );
+  return ms;
+}
+
+function useTimeoutFn(cb, interval, options = {}) {
+  const {
+    immediate = true
+  } = options;
+  const isPending = ref(false);
+  let timer = null;
+  function clear() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  function stop() {
+    isPending.value = false;
+    clear();
+  }
+  function start(...args) {
+    clear();
+    isPending.value = true;
+    timer = setTimeout(() => {
+      isPending.value = false;
+      timer = null;
+      cb(...args);
+    }, toValue(interval));
+  }
+  if (immediate) {
+    isPending.value = true;
+    if (isClient)
+      start();
+  }
+  tryOnScopeDispose(stop);
+  return {
+    isPending: readonly(isPending),
+    start,
+    stop
+  };
+}
+
+function useTimeout(interval = 1e3, options = {}) {
+  const {
+    controls: exposeControls = false,
+    callback
+  } = options;
+  const controls = useTimeoutFn(
+    callback != null ? callback : noop,
+    interval,
+    options
+  );
+  const ready = computed(() => !controls.isPending.value);
+  if (exposeControls) {
+    return {
+      ready,
+      ...controls
+    };
+  } else {
+    return ready;
+  }
+}
+
+function useToNumber(value, options = {}) {
+  const {
+    method = "parseFloat",
+    radix,
+    nanToZero
+  } = options;
+  return computed(() => {
+    let resolved = toValue(value);
+    if (typeof resolved === "string")
+      resolved = Number[method](resolved, radix);
+    if (nanToZero && Number.isNaN(resolved))
+      resolved = 0;
+    return resolved;
+  });
+}
+
+function useToString(value) {
+  return computed(() => `${toValue(value)}`);
+}
+
+function useToggle(initialValue = false, options = {}) {
+  const {
+    truthyValue = true,
+    falsyValue = false
+  } = options;
+  const valueIsRef = isRef(initialValue);
+  const _value = ref(initialValue);
+  function toggle(value) {
+    if (arguments.length) {
+      _value.value = value;
+      return _value.value;
+    } else {
+      const truthy = toValue(truthyValue);
+      _value.value = _value.value === truthy ? toValue(falsyValue) : truthy;
+      return _value.value;
+    }
+  }
+  if (valueIsRef)
+    return toggle;
+  else
+    return [_value, toggle];
+}
+
+function watchArray(source, cb, options) {
+  let oldList = (options == null ? void 0 : options.immediate) ? [] : [...source instanceof Function ? source() : Array.isArray(source) ? source : toValue(source)];
+  return watch(source, (newList, _, onCleanup) => {
+    const oldListRemains = Array.from({ length: oldList.length });
+    const added = [];
+    for (const obj of newList) {
+      let found = false;
+      for (let i = 0; i < oldList.length; i++) {
+        if (!oldListRemains[i] && obj === oldList[i]) {
+          oldListRemains[i] = true;
+          found = true;
+          break;
+        }
+      }
+      if (!found)
+        added.push(obj);
+    }
+    const removed = oldList.filter((_2, i) => !oldListRemains[i]);
+    cb(newList, oldList, added, removed, onCleanup);
+    oldList = [...newList];
+  }, options);
+}
+
+function watchAtMost(source, cb, options) {
+  const {
+    count,
+    ...watchOptions
+  } = options;
+  const current = ref(0);
+  const stop = watchWithFilter(
+    source,
+    (...args) => {
+      current.value += 1;
+      if (current.value >= toValue(count))
+        nextTick(() => stop());
+      cb(...args);
+    },
+    watchOptions
+  );
+  return { count: current, stop };
+}
+
+function watchDebounced(source, cb, options = {}) {
+  const {
+    debounce = 0,
+    maxWait = void 0,
+    ...watchOptions
+  } = options;
+  return watchWithFilter(
+    source,
+    cb,
+    {
+      ...watchOptions,
+      eventFilter: debounceFilter(debounce, { maxWait })
+    }
+  );
+}
+
+function watchDeep(source, cb, options) {
+  return watch(
+    source,
+    cb,
+    {
+      ...options,
+      deep: true
+    }
+  );
+}
+
+function watchIgnorable(source, cb, options = {}) {
+  const {
+    eventFilter = bypassFilter,
+    ...watchOptions
+  } = options;
+  const filteredCb = createFilterWrapper(
+    eventFilter,
+    cb
+  );
+  let ignoreUpdates;
+  let ignorePrevAsyncUpdates;
+  let stop;
+  if (watchOptions.flush === "sync") {
+    const ignore = ref(false);
+    ignorePrevAsyncUpdates = () => {
+    };
+    ignoreUpdates = (updater) => {
+      ignore.value = true;
+      updater();
+      ignore.value = false;
+    };
+    stop = watch(
+      source,
+      (...args) => {
+        if (!ignore.value)
+          filteredCb(...args);
+      },
+      watchOptions
+    );
+  } else {
+    const disposables = [];
+    const ignoreCounter = ref(0);
+    const syncCounter = ref(0);
+    ignorePrevAsyncUpdates = () => {
+      ignoreCounter.value = syncCounter.value;
+    };
+    disposables.push(
+      watch(
+        source,
+        () => {
+          syncCounter.value++;
+        },
+        { ...watchOptions, flush: "sync" }
+      )
+    );
+    ignoreUpdates = (updater) => {
+      const syncCounterPrev = syncCounter.value;
+      updater();
+      ignoreCounter.value += syncCounter.value - syncCounterPrev;
+    };
+    disposables.push(
+      watch(
+        source,
+        (...args) => {
+          const ignore = ignoreCounter.value > 0 && ignoreCounter.value === syncCounter.value;
+          ignoreCounter.value = 0;
+          syncCounter.value = 0;
+          if (ignore)
+            return;
+          filteredCb(...args);
+        },
+        watchOptions
+      )
+    );
+    stop = () => {
+      disposables.forEach((fn) => fn());
+    };
+  }
+  return { stop, ignoreUpdates, ignorePrevAsyncUpdates };
+}
+
+function watchImmediate(source, cb, options) {
+  return watch(
+    source,
+    cb,
+    {
+      ...options,
+      immediate: true
+    }
+  );
+}
+
+function watchOnce(source, cb, options) {
+  const stop = watch(source, (...args) => {
+    nextTick(() => stop());
+    return cb(...args);
+  }, options);
+  return stop;
+}
+
+function watchThrottled(source, cb, options = {}) {
+  const {
+    throttle = 0,
+    trailing = true,
+    leading = true,
+    ...watchOptions
+  } = options;
+  return watchWithFilter(
+    source,
+    cb,
+    {
+      ...watchOptions,
+      eventFilter: throttleFilter(throttle, trailing, leading)
+    }
+  );
+}
+
+function watchTriggerable(source, cb, options = {}) {
+  let cleanupFn;
+  function onEffect() {
+    if (!cleanupFn)
+      return;
+    const fn = cleanupFn;
+    cleanupFn = void 0;
+    fn();
+  }
+  function onCleanup(callback) {
+    cleanupFn = callback;
+  }
+  const _cb = (value, oldValue) => {
+    onEffect();
+    return cb(value, oldValue, onCleanup);
+  };
+  const res = watchIgnorable(source, _cb, options);
+  const { ignoreUpdates } = res;
+  const trigger = () => {
+    let res2;
+    ignoreUpdates(() => {
+      res2 = _cb(getWatchSources(source), getOldValue(source));
+    });
+    return res2;
+  };
+  return {
+    ...res,
+    trigger
+  };
+}
+function getWatchSources(sources) {
+  if (isReactive(sources))
+    return sources;
+  if (Array.isArray(sources))
+    return sources.map((item) => toValue(item));
+  return toValue(sources);
+}
+function getOldValue(source) {
+  return Array.isArray(source) ? source.map(() => void 0) : void 0;
+}
+
+function whenever(source, cb, options) {
+  return watch(
+    source,
+    (v, ov, onInvalidate) => {
+      if (v)
+        cb(v, ov, onInvalidate);
+    },
+    options
+  );
+}
+
+export { assert, refAutoReset as autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, directiveHooks, computedEager as eagerComputed, extendRef, formatDate, get, getLifeCycleTarget, hasOwn, hyphenate, identity, watchIgnorable as ignorableWatch, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, watchPausable as pausableWatch, promiseTimeout, provideLocal, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refThrottled, refWithControl, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toReactive, toRef, toRefs, toValue, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };
diff --git a/parent_dir/node_modules/vuex-persist/dist/esm/index.js b/parent_dir/node_modules/vuex-persist/dist/esm/index.js
new file mode 100644
index 0000000..471c6dd
--- /dev/null
+++ b/parent_dir/node_modules/vuex-persist/dist/esm/index.js
@@ -0,0 +1,267 @@
+import deepmerge from 'deepmerge';
+
+/**
+ * Created by championswimmer on 22/07/17.
+ */
+let MockStorage;
+// @ts-ignore
+{
+    MockStorage = class {
+        get length() {
+            return Object.keys(this).length;
+        }
+        key(index) {
+            return Object.keys(this)[index];
+        }
+        setItem(key, data) {
+            this[key] = data.toString();
+        }
+        getItem(key) {
+            return this[key];
+        }
+        removeItem(key) {
+            delete this[key];
+        }
+        clear() {
+            for (let key of Object.keys(this)) {
+                delete this[key];
+            }
+        }
+    };
+}
+
+// tslint:disable: variable-name
+class SimplePromiseQueue {
+    constructor() {
+        this._queue = [];
+        this._flushing = false;
+    }
+    enqueue(promise) {
+        this._queue.push(promise);
+        if (!this._flushing) {
+            return this.flushQueue();
+        }
+        return Promise.resolve();
+    }
+    flushQueue() {
+        this._flushing = true;
+        const chain = () => {
+            const nextTask = this._queue.shift();
+            if (nextTask) {
+                return nextTask.then(chain);
+            }
+            else {
+                this._flushing = false;
+            }
+        };
+        return Promise.resolve(chain());
+    }
+}
+
+const options = {
+    replaceArrays: {
+        arrayMerge: (destinationArray, sourceArray, options) => sourceArray
+    },
+    concatArrays: {
+        arrayMerge: (target, source, options) => target.concat(...source)
+    }
+};
+function merge(into, from, mergeOption) {
+    return deepmerge(into, from, options[mergeOption]);
+}
+
+let FlattedJSON = JSON;
+/**
+ * A class that implements the vuex persistence.
+ * @type S type of the 'state' inside the store (default: any)
+ */
+class VuexPersistence {
+    /**
+     * Create a {@link VuexPersistence} object.
+     * Use the <code>plugin</code> function of this class as a
+     * Vuex plugin.
+     * @param {PersistOptions} options
+     */
+    constructor(options) {
+        // tslint:disable-next-line:variable-name
+        this._mutex = new SimplePromiseQueue();
+        /**
+         * Creates a subscriber on the store. automatically is used
+         * when this is used a vuex plugin. Not for manual usage.
+         * @param store
+         */
+        this.subscriber = (store) => (handler) => store.subscribe(handler);
+        if (typeof options === 'undefined')
+            options = {};
+        this.key = ((options.key != null) ? options.key : 'vuex');
+        this.subscribed = false;
+        this.supportCircular = options.supportCircular || false;
+        if (this.supportCircular) {
+            FlattedJSON = require('flatted');
+        }
+        this.mergeOption = options.mergeOption || 'replaceArrays';
+        let localStorageLitmus = true;
+        try {
+            window.localStorage.getItem('');
+        }
+        catch (err) {
+            localStorageLitmus = false;
+        }
+        /**
+         * 1. First, prefer storage sent in optinos
+         * 2. Otherwise, use window.localStorage if available
+         * 3. Finally, try to use MockStorage
+         * 4. None of above? Well we gotta fail.
+         */
+        if (options.storage) {
+            this.storage = options.storage;
+        }
+        else if (localStorageLitmus) {
+            this.storage = window.localStorage;
+        }
+        else if (MockStorage) {
+            this.storage = new MockStorage();
+        }
+        else {
+            throw new Error("Neither 'window' is defined, nor 'MockStorage' is available");
+        }
+        /**
+         * How this works is -
+         *  1. If there is options.reducer function, we use that, if not;
+         *  2. We check options.modules;
+         *    1. If there is no options.modules array, we use entire state in reducer
+         *    2. Otherwise, we create a reducer that merges all those state modules that are
+         *        defined in the options.modules[] array
+         * @type {((state: S) => {}) | ((state: S) => S) | ((state: any) => {})}
+         */
+        this.reducer = ((options.reducer != null)
+            ? options.reducer
+            : ((options.modules == null)
+                ? ((state) => state)
+                : ((state) => options.modules.reduce((a, i) => merge(a, { [i]: state[i] }, this.mergeOption), { /* start empty accumulator*/}))));
+        this.filter = options.filter || ((mutation) => true);
+        this.strictMode = options.strictMode || false;
+        this.RESTORE_MUTATION = function RESTORE_MUTATION(state, savedState) {
+            const mergedState = merge(state, savedState || {}, this.mergeOption);
+            for (const propertyName of Object.keys(mergedState)) {
+                this._vm.$set(state, propertyName, mergedState[propertyName]);
+            }
+        };
+        this.asyncStorage = options.asyncStorage || false;
+        if (this.asyncStorage) {
+            /**
+             * Async {@link #VuexPersistence.restoreState} implementation
+             * @type {((key: string, storage?: Storage) =>
+             *      (Promise<S> | S)) | ((key: string, storage: AsyncStorage) => Promise<any>)}
+             */
+            this.restoreState = ((options.restoreState != null)
+                ? options.restoreState
+                : ((key, storage) => (storage).getItem(key)
+                    .then((value) => typeof value === 'string' // If string, parse, or else, just return
+                    ? (this.supportCircular
+                        ? FlattedJSON.parse(value || '{}')
+                        : JSON.parse(value || '{}'))
+                    : (value || {}))));
+            /**
+             * Async {@link #VuexPersistence.saveState} implementation
+             * @type {((key: string, state: {}, storage?: Storage) =>
+             *    (Promise<void> | void)) | ((key: string, state: {}, storage?: Storage) => Promise<void>)}
+             */
+            this.saveState = ((options.saveState != null)
+                ? options.saveState
+                : ((key, state, storage) => (storage).setItem(key, // Second argument is state _object_ if asyc storage, stringified otherwise
+                // do not stringify the state if the storage type is async
+                (this.asyncStorage
+                    ? merge({}, state || {}, this.mergeOption)
+                    : (this.supportCircular
+                        ? FlattedJSON.stringify(state)
+                        : JSON.stringify(state))))));
+            /**
+             * Async version of plugin
+             * @param {Store<S>} store
+             */
+            this.plugin = (store) => {
+                /**
+                 * For async stores, we're capturing the Promise returned
+                 * by the `restoreState()` function in a `restored` property
+                 * on the store itself. This would allow app developers to
+                 * determine when and if the store's state has indeed been
+                 * refreshed. This approach was suggested by GitHub user @hotdogee.
+                 * See https://github.com/championswimmer/vuex-persist/pull/118#issuecomment-500914963
+                 * @since 2.1.0
+                 */
+                store.restored = (this.restoreState(this.key, this.storage)).then((savedState) => {
+                    /**
+                     * If in strict mode, do only via mutation
+                     */
+                    if (this.strictMode) {
+                        store.commit('RESTORE_MUTATION', savedState);
+                    }
+                    else {
+                        store.replaceState(merge(store.state, savedState || {}, this.mergeOption));
+                    }
+                    this.subscriber(store)((mutation, state) => {
+                        if (this.filter(mutation)) {
+                            this._mutex.enqueue(this.saveState(this.key, this.reducer(state), this.storage));
+                        }
+                    });
+                    this.subscribed = true;
+                });
+            };
+        }
+        else {
+            /**
+             * Sync {@link #VuexPersistence.restoreState} implementation
+             * @type {((key: string, storage?: Storage) =>
+             *    (Promise<S> | S)) | ((key: string, storage: Storage) => (any | string | {}))}
+             */
+            this.restoreState = ((options.restoreState != null)
+                ? options.restoreState
+                : ((key, storage) => {
+                    const value = (storage).getItem(key);
+                    if (typeof value === 'string') { // If string, parse, or else, just return
+                        return (this.supportCircular
+                            ? FlattedJSON.parse(value || '{}')
+                            : JSON.parse(value || '{}'));
+                    }
+                    else {
+                        return (value || {});
+                    }
+                }));
+            /**
+             * Sync {@link #VuexPersistence.saveState} implementation
+             * @type {((key: string, state: {}, storage?: Storage) =>
+             *     (Promise<void> | void)) | ((key: string, state: {}, storage?: Storage) => Promise<void>)}
+             */
+            this.saveState = ((options.saveState != null)
+                ? options.saveState
+                : ((key, state, storage) => (storage).setItem(key, // Second argument is state _object_ if localforage, stringified otherwise
+                (this.supportCircular
+                    ? FlattedJSON.stringify(state)
+                    : JSON.stringify(state)))));
+            /**
+             * Sync version of plugin
+             * @param {Store<S>} store
+             */
+            this.plugin = (store) => {
+                const savedState = this.restoreState(this.key, this.storage);
+                if (this.strictMode) {
+                    store.commit('RESTORE_MUTATION', savedState);
+                }
+                else {
+                    store.replaceState(merge(store.state, savedState || {}, this.mergeOption));
+                }
+                this.subscriber(store)((mutation, state) => {
+                    if (this.filter(mutation)) {
+                        this.saveState(this.key, this.reducer(state), this.storage);
+                    }
+                });
+                this.subscribed = true;
+            };
+        }
+    }
+}
+
+export default VuexPersistence;
+export { MockStorage, VuexPersistence };
+//# sourceMappingURL=index.js.map
diff --git a/parent_dir/node_modules/vuex/dist/vuex.esm-bundler.js b/parent_dir/node_modules/vuex/dist/vuex.esm-bundler.js
new file mode 100644
index 0000000..73c522a
--- /dev/null
+++ b/parent_dir/node_modules/vuex/dist/vuex.esm-bundler.js
@@ -0,0 +1,1485 @@
+/*!
+ * vuex v4.1.0
+ * (c) 2022 Evan You
+ * @license MIT
+ */
+import { inject, effectScope, reactive, watch, computed } from 'vue';
+import { setupDevtoolsPlugin } from '@vue/devtools-api';
+
+var storeKey = 'store';
+
+function useStore (key) {
+  if ( key === void 0 ) key = null;
+
+  return inject(key !== null ? key : storeKey)
+}
+
+/**
+ * Get the first item that pass the test
+ * by second argument function
+ *
+ * @param {Array} list
+ * @param {Function} f
+ * @return {*}
+ */
+function find (list, f) {
+  return list.filter(f)[0]
+}
+
+/**
+ * Deep copy the given object considering circular structure.
+ * This function caches all nested objects and its copies.
+ * If it detects circular structure, use cached copy to avoid infinite loop.
+ *
+ * @param {*} obj
+ * @param {Array<Object>} cache
+ * @return {*}
+ */
+function deepCopy (obj, cache) {
+  if ( cache === void 0 ) cache = [];
+
+  // just return if obj is immutable value
+  if (obj === null || typeof obj !== 'object') {
+    return obj
+  }
+
+  // if obj is hit, it is in circular structure
+  var hit = find(cache, function (c) { return c.original === obj; });
+  if (hit) {
+    return hit.copy
+  }
+
+  var copy = Array.isArray(obj) ? [] : {};
+  // put the copy into cache at first
+  // because we want to refer it in recursive deepCopy
+  cache.push({
+    original: obj,
+    copy: copy
+  });
+
+  Object.keys(obj).forEach(function (key) {
+    copy[key] = deepCopy(obj[key], cache);
+  });
+
+  return copy
+}
+
+/**
+ * forEach for object
+ */
+function forEachValue (obj, fn) {
+  Object.keys(obj).forEach(function (key) { return fn(obj[key], key); });
+}
+
+function isObject (obj) {
+  return obj !== null && typeof obj === 'object'
+}
+
+function isPromise (val) {
+  return val && typeof val.then === 'function'
+}
+
+function assert (condition, msg) {
+  if (!condition) { throw new Error(("[vuex] " + msg)) }
+}
+
+function partial (fn, arg) {
+  return function () {
+    return fn(arg)
+  }
+}
+
+function genericSubscribe (fn, subs, options) {
+  if (subs.indexOf(fn) < 0) {
+    options && options.prepend
+      ? subs.unshift(fn)
+      : subs.push(fn);
+  }
+  return function () {
+    var i = subs.indexOf(fn);
+    if (i > -1) {
+      subs.splice(i, 1);
+    }
+  }
+}
+
+function resetStore (store, hot) {
+  store._actions = Object.create(null);
+  store._mutations = Object.create(null);
+  store._wrappedGetters = Object.create(null);
+  store._modulesNamespaceMap = Object.create(null);
+  var state = store.state;
+  // init all modules
+  installModule(store, state, [], store._modules.root, true);
+  // reset state
+  resetStoreState(store, state, hot);
+}
+
+function resetStoreState (store, state, hot) {
+  var oldState = store._state;
+  var oldScope = store._scope;
+
+  // bind store public getters
+  store.getters = {};
+  // reset local getters cache
+  store._makeLocalGettersCache = Object.create(null);
+  var wrappedGetters = store._wrappedGetters;
+  var computedObj = {};
+  var computedCache = {};
+
+  // create a new effect scope and create computed object inside it to avoid
+  // getters (computed) getting destroyed on component unmount.
+  var scope = effectScope(true);
+
+  scope.run(function () {
+    forEachValue(wrappedGetters, function (fn, key) {
+      // use computed to leverage its lazy-caching mechanism
+      // direct inline function use will lead to closure preserving oldState.
+      // using partial to return function with only arguments preserved in closure environment.
+      computedObj[key] = partial(fn, store);
+      computedCache[key] = computed(function () { return computedObj[key](); });
+      Object.defineProperty(store.getters, key, {
+        get: function () { return computedCache[key].value; },
+        enumerable: true // for local getters
+      });
+    });
+  });
+
+  store._state = reactive({
+    data: state
+  });
+
+  // register the newly created effect scope to the store so that we can
+  // dispose the effects when this method runs again in the future.
+  store._scope = scope;
+
+  // enable strict mode for new state
+  if (store.strict) {
+    enableStrictMode(store);
+  }
+
+  if (oldState) {
+    if (hot) {
+      // dispatch changes in all subscribed watchers
+      // to force getter re-evaluation for hot reloading.
+      store._withCommit(function () {
+        oldState.data = null;
+      });
+    }
+  }
+
+  // dispose previously registered effect scope if there is one.
+  if (oldScope) {
+    oldScope.stop();
+  }
+}
+
+function installModule (store, rootState, path, module, hot) {
+  var isRoot = !path.length;
+  var namespace = store._modules.getNamespace(path);
+
+  // register in namespace map
+  if (module.namespaced) {
+    if (store._modulesNamespaceMap[namespace] && (process.env.NODE_ENV !== 'production')) {
+      console.error(("[vuex] duplicate namespace " + namespace + " for the namespaced module " + (path.join('/'))));
+    }
+    store._modulesNamespaceMap[namespace] = module;
+  }
+
+  // set state
+  if (!isRoot && !hot) {
+    var parentState = getNestedState(rootState, path.slice(0, -1));
+    var moduleName = path[path.length - 1];
+    store._withCommit(function () {
+      if ((process.env.NODE_ENV !== 'production')) {
+        if (moduleName in parentState) {
+          console.warn(
+            ("[vuex] state field \"" + moduleName + "\" was overridden by a module with the same name at \"" + (path.join('.')) + "\"")
+          );
+        }
+      }
+      parentState[moduleName] = module.state;
+    });
+  }
+
+  var local = module.context = makeLocalContext(store, namespace, path);
+
+  module.forEachMutation(function (mutation, key) {
+    var namespacedType = namespace + key;
+    registerMutation(store, namespacedType, mutation, local);
+  });
+
+  module.forEachAction(function (action, key) {
+    var type = action.root ? key : namespace + key;
+    var handler = action.handler || action;
+    registerAction(store, type, handler, local);
+  });
+
+  module.forEachGetter(function (getter, key) {
+    var namespacedType = namespace + key;
+    registerGetter(store, namespacedType, getter, local);
+  });
+
+  module.forEachChild(function (child, key) {
+    installModule(store, rootState, path.concat(key), child, hot);
+  });
+}
+
+/**
+ * make localized dispatch, commit, getters and state
+ * if there is no namespace, just use root ones
+ */
+function makeLocalContext (store, namespace, path) {
+  var noNamespace = namespace === '';
+
+  var local = {
+    dispatch: noNamespace ? store.dispatch : function (_type, _payload, _options) {
+      var args = unifyObjectStyle(_type, _payload, _options);
+      var payload = args.payload;
+      var options = args.options;
+      var type = args.type;
+
+      if (!options || !options.root) {
+        type = namespace + type;
+        if ((process.env.NODE_ENV !== 'production') && !store._actions[type]) {
+          console.error(("[vuex] unknown local action type: " + (args.type) + ", global type: " + type));
+          return
+        }
+      }
+
+      return store.dispatch(type, payload)
+    },
+
+    commit: noNamespace ? store.commit : function (_type, _payload, _options) {
+      var args = unifyObjectStyle(_type, _payload, _options);
+      var payload = args.payload;
+      var options = args.options;
+      var type = args.type;
+
+      if (!options || !options.root) {
+        type = namespace + type;
+        if ((process.env.NODE_ENV !== 'production') && !store._mutations[type]) {
+          console.error(("[vuex] unknown local mutation type: " + (args.type) + ", global type: " + type));
+          return
+        }
+      }
+
+      store.commit(type, payload, options);
+    }
+  };
+
+  // getters and state object must be gotten lazily
+  // because they will be changed by state update
+  Object.defineProperties(local, {
+    getters: {
+      get: noNamespace
+        ? function () { return store.getters; }
+        : function () { return makeLocalGetters(store, namespace); }
+    },
+    state: {
+      get: function () { return getNestedState(store.state, path); }
+    }
+  });
+
+  return local
+}
+
+function makeLocalGetters (store, namespace) {
+  if (!store._makeLocalGettersCache[namespace]) {
+    var gettersProxy = {};
+    var splitPos = namespace.length;
+    Object.keys(store.getters).forEach(function (type) {
+      // skip if the target getter is not match this namespace
+      if (type.slice(0, splitPos) !== namespace) { return }
+
+      // extract local getter type
+      var localType = type.slice(splitPos);
+
+      // Add a port to the getters proxy.
+      // Define as getter property because
+      // we do not want to evaluate the getters in this time.
+      Object.defineProperty(gettersProxy, localType, {
+        get: function () { return store.getters[type]; },
+        enumerable: true
+      });
+    });
+    store._makeLocalGettersCache[namespace] = gettersProxy;
+  }
+
+  return store._makeLocalGettersCache[namespace]
+}
+
+function registerMutation (store, type, handler, local) {
+  var entry = store._mutations[type] || (store._mutations[type] = []);
+  entry.push(function wrappedMutationHandler (payload) {
+    handler.call(store, local.state, payload);
+  });
+}
+
+function registerAction (store, type, handler, local) {
+  var entry = store._actions[type] || (store._actions[type] = []);
+  entry.push(function wrappedActionHandler (payload) {
+    var res = handler.call(store, {
+      dispatch: local.dispatch,
+      commit: local.commit,
+      getters: local.getters,
+      state: local.state,
+      rootGetters: store.getters,
+      rootState: store.state
+    }, payload);
+    if (!isPromise(res)) {
+      res = Promise.resolve(res);
+    }
+    if (store._devtoolHook) {
+      return res.catch(function (err) {
+        store._devtoolHook.emit('vuex:error', err);
+        throw err
+      })
+    } else {
+      return res
+    }
+  });
+}
+
+function registerGetter (store, type, rawGetter, local) {
+  if (store._wrappedGetters[type]) {
+    if ((process.env.NODE_ENV !== 'production')) {
+      console.error(("[vuex] duplicate getter key: " + type));
+    }
+    return
+  }
+  store._wrappedGetters[type] = function wrappedGetter (store) {
+    return rawGetter(
+      local.state, // local state
+      local.getters, // local getters
+      store.state, // root state
+      store.getters // root getters
+    )
+  };
+}
+
+function enableStrictMode (store) {
+  watch(function () { return store._state.data; }, function () {
+    if ((process.env.NODE_ENV !== 'production')) {
+      assert(store._committing, "do not mutate vuex store state outside mutation handlers.");
+    }
+  }, { deep: true, flush: 'sync' });
+}
+
+function getNestedState (state, path) {
+  return path.reduce(function (state, key) { return state[key]; }, state)
+}
+
+function unifyObjectStyle (type, payload, options) {
+  if (isObject(type) && type.type) {
+    options = payload;
+    payload = type;
+    type = type.type;
+  }
+
+  if ((process.env.NODE_ENV !== 'production')) {
+    assert(typeof type === 'string', ("expects string as the type, but found " + (typeof type) + "."));
+  }
+
+  return { type: type, payload: payload, options: options }
+}
+
+var LABEL_VUEX_BINDINGS = 'vuex bindings';
+var MUTATIONS_LAYER_ID = 'vuex:mutations';
+var ACTIONS_LAYER_ID = 'vuex:actions';
+var INSPECTOR_ID = 'vuex';
+
+var actionId = 0;
+
+function addDevtools (app, store) {
+  setupDevtoolsPlugin(
+    {
+      id: 'org.vuejs.vuex',
+      app: app,
+      label: 'Vuex',
+      homepage: 'https://next.vuex.vuejs.org/',
+      logo: 'https://vuejs.org/images/icons/favicon-96x96.png',
+      packageName: 'vuex',
+      componentStateTypes: [LABEL_VUEX_BINDINGS]
+    },
+    function (api) {
+      api.addTimelineLayer({
+        id: MUTATIONS_LAYER_ID,
+        label: 'Vuex Mutations',
+        color: COLOR_LIME_500
+      });
+
+      api.addTimelineLayer({
+        id: ACTIONS_LAYER_ID,
+        label: 'Vuex Actions',
+        color: COLOR_LIME_500
+      });
+
+      api.addInspector({
+        id: INSPECTOR_ID,
+        label: 'Vuex',
+        icon: 'storage',
+        treeFilterPlaceholder: 'Filter stores...'
+      });
+
+      api.on.getInspectorTree(function (payload) {
+        if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
+          if (payload.filter) {
+            var nodes = [];
+            flattenStoreForInspectorTree(nodes, store._modules.root, payload.filter, '');
+            payload.rootNodes = nodes;
+          } else {
+            payload.rootNodes = [
+              formatStoreForInspectorTree(store._modules.root, '')
+            ];
+          }
+        }
+      });
+
+      api.on.getInspectorState(function (payload) {
+        if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
+          var modulePath = payload.nodeId;
+          makeLocalGetters(store, modulePath);
+          payload.state = formatStoreForInspectorState(
+            getStoreModule(store._modules, modulePath),
+            modulePath === 'root' ? store.getters : store._makeLocalGettersCache,
+            modulePath
+          );
+        }
+      });
+
+      api.on.editInspectorState(function (payload) {
+        if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
+          var modulePath = payload.nodeId;
+          var path = payload.path;
+          if (modulePath !== 'root') {
+            path = modulePath.split('/').filter(Boolean).concat( path);
+          }
+          store._withCommit(function () {
+            payload.set(store._state.data, path, payload.state.value);
+          });
+        }
+      });
+
+      store.subscribe(function (mutation, state) {
+        var data = {};
+
+        if (mutation.payload) {
+          data.payload = mutation.payload;
+        }
+
+        data.state = state;
+
+        api.notifyComponentUpdate();
+        api.sendInspectorTree(INSPECTOR_ID);
+        api.sendInspectorState(INSPECTOR_ID);
+
+        api.addTimelineEvent({
+          layerId: MUTATIONS_LAYER_ID,
+          event: {
+            time: Date.now(),
+            title: mutation.type,
+            data: data
+          }
+        });
+      });
+
+      store.subscribeAction({
+        before: function (action, state) {
+          var data = {};
+          if (action.payload) {
+            data.payload = action.payload;
+          }
+          action._id = actionId++;
+          action._time = Date.now();
+          data.state = state;
+
+          api.addTimelineEvent({
+            layerId: ACTIONS_LAYER_ID,
+            event: {
+              time: action._time,
+              title: action.type,
+              groupId: action._id,
+              subtitle: 'start',
+              data: data
+            }
+          });
+        },
+        after: function (action, state) {
+          var data = {};
+          var duration = Date.now() - action._time;
+          data.duration = {
+            _custom: {
+              type: 'duration',
+              display: (duration + "ms"),
+              tooltip: 'Action duration',
+              value: duration
+            }
+          };
+          if (action.payload) {
+            data.payload = action.payload;
+          }
+          data.state = state;
+
+          api.addTimelineEvent({
+            layerId: ACTIONS_LAYER_ID,
+            event: {
+              time: Date.now(),
+              title: action.type,
+              groupId: action._id,
+              subtitle: 'end',
+              data: data
+            }
+          });
+        }
+      });
+    }
+  );
+}
+
+// extracted from tailwind palette
+var COLOR_LIME_500 = 0x84cc16;
+var COLOR_DARK = 0x666666;
+var COLOR_WHITE = 0xffffff;
+
+var TAG_NAMESPACED = {
+  label: 'namespaced',
+  textColor: COLOR_WHITE,
+  backgroundColor: COLOR_DARK
+};
+
+/**
+ * @param {string} path
+ */
+function extractNameFromPath (path) {
+  return path && path !== 'root' ? path.split('/').slice(-2, -1)[0] : 'Root'
+}
+
+/**
+ * @param {*} module
+ * @return {import('@vue/devtools-api').CustomInspectorNode}
+ */
+function formatStoreForInspectorTree (module, path) {
+  return {
+    id: path || 'root',
+    // all modules end with a `/`, we want the last segment only
+    // cart/ -> cart
+    // nested/cart/ -> cart
+    label: extractNameFromPath(path),
+    tags: module.namespaced ? [TAG_NAMESPACED] : [],
+    children: Object.keys(module._children).map(function (moduleName) { return formatStoreForInspectorTree(
+        module._children[moduleName],
+        path + moduleName + '/'
+      ); }
+    )
+  }
+}
+
+/**
+ * @param {import('@vue/devtools-api').CustomInspectorNode[]} result
+ * @param {*} module
+ * @param {string} filter
+ * @param {string} path
+ */
+function flattenStoreForInspectorTree (result, module, filter, path) {
+  if (path.includes(filter)) {
+    result.push({
+      id: path || 'root',
+      label: path.endsWith('/') ? path.slice(0, path.length - 1) : path || 'Root',
+      tags: module.namespaced ? [TAG_NAMESPACED] : []
+    });
+  }
+  Object.keys(module._children).forEach(function (moduleName) {
+    flattenStoreForInspectorTree(result, module._children[moduleName], filter, path + moduleName + '/');
+  });
+}
+
+/**
+ * @param {*} module
+ * @return {import('@vue/devtools-api').CustomInspectorState}
+ */
+function formatStoreForInspectorState (module, getters, path) {
+  getters = path === 'root' ? getters : getters[path];
+  var gettersKeys = Object.keys(getters);
+  var storeState = {
+    state: Object.keys(module.state).map(function (key) { return ({
+      key: key,
+      editable: true,
+      value: module.state[key]
+    }); })
+  };
+
+  if (gettersKeys.length) {
+    var tree = transformPathsToObjectTree(getters);
+    storeState.getters = Object.keys(tree).map(function (key) { return ({
+      key: key.endsWith('/') ? extractNameFromPath(key) : key,
+      editable: false,
+      value: canThrow(function () { return tree[key]; })
+    }); });
+  }
+
+  return storeState
+}
+
+function transformPathsToObjectTree (getters) {
+  var result = {};
+  Object.keys(getters).forEach(function (key) {
+    var path = key.split('/');
+    if (path.length > 1) {
+      var target = result;
+      var leafKey = path.pop();
+      path.forEach(function (p) {
+        if (!target[p]) {
+          target[p] = {
+            _custom: {
+              value: {},
+              display: p,
+              tooltip: 'Module',
+              abstract: true
+            }
+          };
+        }
+        target = target[p]._custom.value;
+      });
+      target[leafKey] = canThrow(function () { return getters[key]; });
+    } else {
+      result[key] = canThrow(function () { return getters[key]; });
+    }
+  });
+  return result
+}
+
+function getStoreModule (moduleMap, path) {
+  var names = path.split('/').filter(function (n) { return n; });
+  return names.reduce(
+    function (module, moduleName, i) {
+      var child = module[moduleName];
+      if (!child) {
+        throw new Error(("Missing module \"" + moduleName + "\" for path \"" + path + "\"."))
+      }
+      return i === names.length - 1 ? child : child._children
+    },
+    path === 'root' ? moduleMap : moduleMap.root._children
+  )
+}
+
+function canThrow (cb) {
+  try {
+    return cb()
+  } catch (e) {
+    return e
+  }
+}
+
+// Base data struct for store's module, package with some attribute and method
+var Module = function Module (rawModule, runtime) {
+  this.runtime = runtime;
+  // Store some children item
+  this._children = Object.create(null);
+  // Store the origin module object which passed by programmer
+  this._rawModule = rawModule;
+  var rawState = rawModule.state;
+
+  // Store the origin module's state
+  this.state = (typeof rawState === 'function' ? rawState() : rawState) || {};
+};
+
+var prototypeAccessors$1 = { namespaced: { configurable: true } };
+
+prototypeAccessors$1.namespaced.get = function () {
+  return !!this._rawModule.namespaced
+};
+
+Module.prototype.addChild = function addChild (key, module) {
+  this._children[key] = module;
+};
+
+Module.prototype.removeChild = function removeChild (key) {
+  delete this._children[key];
+};
+
+Module.prototype.getChild = function getChild (key) {
+  return this._children[key]
+};
+
+Module.prototype.hasChild = function hasChild (key) {
+  return key in this._children
+};
+
+Module.prototype.update = function update (rawModule) {
+  this._rawModule.namespaced = rawModule.namespaced;
+  if (rawModule.actions) {
+    this._rawModule.actions = rawModule.actions;
+  }
+  if (rawModule.mutations) {
+    this._rawModule.mutations = rawModule.mutations;
+  }
+  if (rawModule.getters) {
+    this._rawModule.getters = rawModule.getters;
+  }
+};
+
+Module.prototype.forEachChild = function forEachChild (fn) {
+  forEachValue(this._children, fn);
+};
+
+Module.prototype.forEachGetter = function forEachGetter (fn) {
+  if (this._rawModule.getters) {
+    forEachValue(this._rawModule.getters, fn);
+  }
+};
+
+Module.prototype.forEachAction = function forEachAction (fn) {
+  if (this._rawModule.actions) {
+    forEachValue(this._rawModule.actions, fn);
+  }
+};
+
+Module.prototype.forEachMutation = function forEachMutation (fn) {
+  if (this._rawModule.mutations) {
+    forEachValue(this._rawModule.mutations, fn);
+  }
+};
+
+Object.defineProperties( Module.prototype, prototypeAccessors$1 );
+
+var ModuleCollection = function ModuleCollection (rawRootModule) {
+  // register root module (Vuex.Store options)
+  this.register([], rawRootModule, false);
+};
+
+ModuleCollection.prototype.get = function get (path) {
+  return path.reduce(function (module, key) {
+    return module.getChild(key)
+  }, this.root)
+};
+
+ModuleCollection.prototype.getNamespace = function getNamespace (path) {
+  var module = this.root;
+  return path.reduce(function (namespace, key) {
+    module = module.getChild(key);
+    return namespace + (module.namespaced ? key + '/' : '')
+  }, '')
+};
+
+ModuleCollection.prototype.update = function update$1 (rawRootModule) {
+  update([], this.root, rawRootModule);
+};
+
+ModuleCollection.prototype.register = function register (path, rawModule, runtime) {
+    var this$1$1 = this;
+    if ( runtime === void 0 ) runtime = true;
+
+  if ((process.env.NODE_ENV !== 'production')) {
+    assertRawModule(path, rawModule);
+  }
+
+  var newModule = new Module(rawModule, runtime);
+  if (path.length === 0) {
+    this.root = newModule;
+  } else {
+    var parent = this.get(path.slice(0, -1));
+    parent.addChild(path[path.length - 1], newModule);
+  }
+
+  // register nested modules
+  if (rawModule.modules) {
+    forEachValue(rawModule.modules, function (rawChildModule, key) {
+      this$1$1.register(path.concat(key), rawChildModule, runtime);
+    });
+  }
+};
+
+ModuleCollection.prototype.unregister = function unregister (path) {
+  var parent = this.get(path.slice(0, -1));
+  var key = path[path.length - 1];
+  var child = parent.getChild(key);
+
+  if (!child) {
+    if ((process.env.NODE_ENV !== 'production')) {
+      console.warn(
+        "[vuex] trying to unregister module '" + key + "', which is " +
+        "not registered"
+      );
+    }
+    return
+  }
+
+  if (!child.runtime) {
+    return
+  }
+
+  parent.removeChild(key);
+};
+
+ModuleCollection.prototype.isRegistered = function isRegistered (path) {
+  var parent = this.get(path.slice(0, -1));
+  var key = path[path.length - 1];
+
+  if (parent) {
+    return parent.hasChild(key)
+  }
+
+  return false
+};
+
+function update (path, targetModule, newModule) {
+  if ((process.env.NODE_ENV !== 'production')) {
+    assertRawModule(path, newModule);
+  }
+
+  // update target module
+  targetModule.update(newModule);
+
+  // update nested modules
+  if (newModule.modules) {
+    for (var key in newModule.modules) {
+      if (!targetModule.getChild(key)) {
+        if ((process.env.NODE_ENV !== 'production')) {
+          console.warn(
+            "[vuex] trying to add a new module '" + key + "' on hot reloading, " +
+            'manual reload is needed'
+          );
+        }
+        return
+      }
+      update(
+        path.concat(key),
+        targetModule.getChild(key),
+        newModule.modules[key]
+      );
+    }
+  }
+}
+
+var functionAssert = {
+  assert: function (value) { return typeof value === 'function'; },
+  expected: 'function'
+};
+
+var objectAssert = {
+  assert: function (value) { return typeof value === 'function' ||
+    (typeof value === 'object' && typeof value.handler === 'function'); },
+  expected: 'function or object with "handler" function'
+};
+
+var assertTypes = {
+  getters: functionAssert,
+  mutations: functionAssert,
+  actions: objectAssert
+};
+
+function assertRawModule (path, rawModule) {
+  Object.keys(assertTypes).forEach(function (key) {
+    if (!rawModule[key]) { return }
+
+    var assertOptions = assertTypes[key];
+
+    forEachValue(rawModule[key], function (value, type) {
+      assert(
+        assertOptions.assert(value),
+        makeAssertionMessage(path, key, type, value, assertOptions.expected)
+      );
+    });
+  });
+}
+
+function makeAssertionMessage (path, key, type, value, expected) {
+  var buf = key + " should be " + expected + " but \"" + key + "." + type + "\"";
+  if (path.length > 0) {
+    buf += " in module \"" + (path.join('.')) + "\"";
+  }
+  buf += " is " + (JSON.stringify(value)) + ".";
+  return buf
+}
+
+function createStore (options) {
+  return new Store(options)
+}
+
+var Store = function Store (options) {
+  var this$1$1 = this;
+  if ( options === void 0 ) options = {};
+
+  if ((process.env.NODE_ENV !== 'production')) {
+    assert(typeof Promise !== 'undefined', "vuex requires a Promise polyfill in this browser.");
+    assert(this instanceof Store, "store must be called with the new operator.");
+  }
+
+  var plugins = options.plugins; if ( plugins === void 0 ) plugins = [];
+  var strict = options.strict; if ( strict === void 0 ) strict = false;
+  var devtools = options.devtools;
+
+  // store internal state
+  this._committing = false;
+  this._actions = Object.create(null);
+  this._actionSubscribers = [];
+  this._mutations = Object.create(null);
+  this._wrappedGetters = Object.create(null);
+  this._modules = new ModuleCollection(options);
+  this._modulesNamespaceMap = Object.create(null);
+  this._subscribers = [];
+  this._makeLocalGettersCache = Object.create(null);
+
+  // EffectScope instance. when registering new getters, we wrap them inside
+  // EffectScope so that getters (computed) would not be destroyed on
+  // component unmount.
+  this._scope = null;
+
+  this._devtools = devtools;
+
+  // bind commit and dispatch to self
+  var store = this;
+  var ref = this;
+  var dispatch = ref.dispatch;
+  var commit = ref.commit;
+  this.dispatch = function boundDispatch (type, payload) {
+    return dispatch.call(store, type, payload)
+  };
+  this.commit = function boundCommit (type, payload, options) {
+    return commit.call(store, type, payload, options)
+  };
+
+  // strict mode
+  this.strict = strict;
+
+  var state = this._modules.root.state;
+
+  // init root module.
+  // this also recursively registers all sub-modules
+  // and collects all module getters inside this._wrappedGetters
+  installModule(this, state, [], this._modules.root);
+
+  // initialize the store state, which is responsible for the reactivity
+  // (also registers _wrappedGetters as computed properties)
+  resetStoreState(this, state);
+
+  // apply plugins
+  plugins.forEach(function (plugin) { return plugin(this$1$1); });
+};
+
+var prototypeAccessors = { state: { configurable: true } };
+
+Store.prototype.install = function install (app, injectKey) {
+  app.provide(injectKey || storeKey, this);
+  app.config.globalProperties.$store = this;
+
+  var useDevtools = this._devtools !== undefined
+    ? this._devtools
+    : (process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__;
+
+  if (useDevtools) {
+    addDevtools(app, this);
+  }
+};
+
+prototypeAccessors.state.get = function () {
+  return this._state.data
+};
+
+prototypeAccessors.state.set = function (v) {
+  if ((process.env.NODE_ENV !== 'production')) {
+    assert(false, "use store.replaceState() to explicit replace store state.");
+  }
+};
+
+Store.prototype.commit = function commit (_type, _payload, _options) {
+    var this$1$1 = this;
+
+  // check object-style commit
+  var ref = unifyObjectStyle(_type, _payload, _options);
+    var type = ref.type;
+    var payload = ref.payload;
+    var options = ref.options;
+
+  var mutation = { type: type, payload: payload };
+  var entry = this._mutations[type];
+  if (!entry) {
+    if ((process.env.NODE_ENV !== 'production')) {
+      console.error(("[vuex] unknown mutation type: " + type));
+    }
+    return
+  }
+  this._withCommit(function () {
+    entry.forEach(function commitIterator (handler) {
+      handler(payload);
+    });
+  });
+
+  this._subscribers
+    .slice() // shallow copy to prevent iterator invalidation if subscriber synchronously calls unsubscribe
+    .forEach(function (sub) { return sub(mutation, this$1$1.state); });
+
+  if (
+    (process.env.NODE_ENV !== 'production') &&
+    options && options.silent
+  ) {
+    console.warn(
+      "[vuex] mutation type: " + type + ". Silent option has been removed. " +
+      'Use the filter functionality in the vue-devtools'
+    );
+  }
+};
+
+Store.prototype.dispatch = function dispatch (_type, _payload) {
+    var this$1$1 = this;
+
+  // check object-style dispatch
+  var ref = unifyObjectStyle(_type, _payload);
+    var type = ref.type;
+    var payload = ref.payload;
+
+  var action = { type: type, payload: payload };
+  var entry = this._actions[type];
+  if (!entry) {
+    if ((process.env.NODE_ENV !== 'production')) {
+      console.error(("[vuex] unknown action type: " + type));
+    }
+    return
+  }
+
+  try {
+    this._actionSubscribers
+      .slice() // shallow copy to prevent iterator invalidation if subscriber synchronously calls unsubscribe
+      .filter(function (sub) { return sub.before; })
+      .forEach(function (sub) { return sub.before(action, this$1$1.state); });
+  } catch (e) {
+    if ((process.env.NODE_ENV !== 'production')) {
+      console.warn("[vuex] error in before action subscribers: ");
+      console.error(e);
+    }
+  }
+
+  var result = entry.length > 1
+    ? Promise.all(entry.map(function (handler) { return handler(payload); }))
+    : entry[0](payload);
+
+  return new Promise(function (resolve, reject) {
+    result.then(function (res) {
+      try {
+        this$1$1._actionSubscribers
+          .filter(function (sub) { return sub.after; })
+          .forEach(function (sub) { return sub.after(action, this$1$1.state); });
+      } catch (e) {
+        if ((process.env.NODE_ENV !== 'production')) {
+          console.warn("[vuex] error in after action subscribers: ");
+          console.error(e);
+        }
+      }
+      resolve(res);
+    }, function (error) {
+      try {
+        this$1$1._actionSubscribers
+          .filter(function (sub) { return sub.error; })
+          .forEach(function (sub) { return sub.error(action, this$1$1.state, error); });
+      } catch (e) {
+        if ((process.env.NODE_ENV !== 'production')) {
+          console.warn("[vuex] error in error action subscribers: ");
+          console.error(e);
+        }
+      }
+      reject(error);
+    });
+  })
+};
+
+Store.prototype.subscribe = function subscribe (fn, options) {
+  return genericSubscribe(fn, this._subscribers, options)
+};
+
+Store.prototype.subscribeAction = function subscribeAction (fn, options) {
+  var subs = typeof fn === 'function' ? { before: fn } : fn;
+  return genericSubscribe(subs, this._actionSubscribers, options)
+};
+
+Store.prototype.watch = function watch$1 (getter, cb, options) {
+    var this$1$1 = this;
+
+  if ((process.env.NODE_ENV !== 'production')) {
+    assert(typeof getter === 'function', "store.watch only accepts a function.");
+  }
+  return watch(function () { return getter(this$1$1.state, this$1$1.getters); }, cb, Object.assign({}, options))
+};
+
+Store.prototype.replaceState = function replaceState (state) {
+    var this$1$1 = this;
+
+  this._withCommit(function () {
+    this$1$1._state.data = state;
+  });
+};
+
+Store.prototype.registerModule = function registerModule (path, rawModule, options) {
+    if ( options === void 0 ) options = {};
+
+  if (typeof path === 'string') { path = [path]; }
+
+  if ((process.env.NODE_ENV !== 'production')) {
+    assert(Array.isArray(path), "module path must be a string or an Array.");
+    assert(path.length > 0, 'cannot register the root module by using registerModule.');
+  }
+
+  this._modules.register(path, rawModule);
+  installModule(this, this.state, path, this._modules.get(path), options.preserveState);
+  // reset store to update getters...
+  resetStoreState(this, this.state);
+};
+
+Store.prototype.unregisterModule = function unregisterModule (path) {
+    var this$1$1 = this;
+
+  if (typeof path === 'string') { path = [path]; }
+
+  if ((process.env.NODE_ENV !== 'production')) {
+    assert(Array.isArray(path), "module path must be a string or an Array.");
+  }
+
+  this._modules.unregister(path);
+  this._withCommit(function () {
+    var parentState = getNestedState(this$1$1.state, path.slice(0, -1));
+    delete parentState[path[path.length - 1]];
+  });
+  resetStore(this);
+};
+
+Store.prototype.hasModule = function hasModule (path) {
+  if (typeof path === 'string') { path = [path]; }
+
+  if ((process.env.NODE_ENV !== 'production')) {
+    assert(Array.isArray(path), "module path must be a string or an Array.");
+  }
+
+  return this._modules.isRegistered(path)
+};
+
+Store.prototype.hotUpdate = function hotUpdate (newOptions) {
+  this._modules.update(newOptions);
+  resetStore(this, true);
+};
+
+Store.prototype._withCommit = function _withCommit (fn) {
+  var committing = this._committing;
+  this._committing = true;
+  fn();
+  this._committing = committing;
+};
+
+Object.defineProperties( Store.prototype, prototypeAccessors );
+
+/**
+ * Reduce the code which written in Vue.js for getting the state.
+ * @param {String} [namespace] - Module's namespace
+ * @param {Object|Array} states # Object's item can be a function which accept state and getters for param, you can do something for state and getters in it.
+ * @param {Object}
+ */
+var mapState = normalizeNamespace(function (namespace, states) {
+  var res = {};
+  if ((process.env.NODE_ENV !== 'production') && !isValidMap(states)) {
+    console.error('[vuex] mapState: mapper parameter must be either an Array or an Object');
+  }
+  normalizeMap(states).forEach(function (ref) {
+    var key = ref.key;
+    var val = ref.val;
+
+    res[key] = function mappedState () {
+      var state = this.$store.state;
+      var getters = this.$store.getters;
+      if (namespace) {
+        var module = getModuleByNamespace(this.$store, 'mapState', namespace);
+        if (!module) {
+          return
+        }
+        state = module.context.state;
+        getters = module.context.getters;
+      }
+      return typeof val === 'function'
+        ? val.call(this, state, getters)
+        : state[val]
+    };
+    // mark vuex getter for devtools
+    res[key].vuex = true;
+  });
+  return res
+});
+
+/**
+ * Reduce the code which written in Vue.js for committing the mutation
+ * @param {String} [namespace] - Module's namespace
+ * @param {Object|Array} mutations # Object's item can be a function which accept `commit` function as the first param, it can accept another params. You can commit mutation and do any other things in this function. specially, You need to pass anthor params from the mapped function.
+ * @return {Object}
+ */
+var mapMutations = normalizeNamespace(function (namespace, mutations) {
+  var res = {};
+  if ((process.env.NODE_ENV !== 'production') && !isValidMap(mutations)) {
+    console.error('[vuex] mapMutations: mapper parameter must be either an Array or an Object');
+  }
+  normalizeMap(mutations).forEach(function (ref) {
+    var key = ref.key;
+    var val = ref.val;
+
+    res[key] = function mappedMutation () {
+      var args = [], len = arguments.length;
+      while ( len-- ) args[ len ] = arguments[ len ];
+
+      // Get the commit method from store
+      var commit = this.$store.commit;
+      if (namespace) {
+        var module = getModuleByNamespace(this.$store, 'mapMutations', namespace);
+        if (!module) {
+          return
+        }
+        commit = module.context.commit;
+      }
+      return typeof val === 'function'
+        ? val.apply(this, [commit].concat(args))
+        : commit.apply(this.$store, [val].concat(args))
+    };
+  });
+  return res
+});
+
+/**
+ * Reduce the code which written in Vue.js for getting the getters
+ * @param {String} [namespace] - Module's namespace
+ * @param {Object|Array} getters
+ * @return {Object}
+ */
+var mapGetters = normalizeNamespace(function (namespace, getters) {
+  var res = {};
+  if ((process.env.NODE_ENV !== 'production') && !isValidMap(getters)) {
+    console.error('[vuex] mapGetters: mapper parameter must be either an Array or an Object');
+  }
+  normalizeMap(getters).forEach(function (ref) {
+    var key = ref.key;
+    var val = ref.val;
+
+    // The namespace has been mutated by normalizeNamespace
+    val = namespace + val;
+    res[key] = function mappedGetter () {
+      if (namespace && !getModuleByNamespace(this.$store, 'mapGetters', namespace)) {
+        return
+      }
+      if ((process.env.NODE_ENV !== 'production') && !(val in this.$store.getters)) {
+        console.error(("[vuex] unknown getter: " + val));
+        return
+      }
+      return this.$store.getters[val]
+    };
+    // mark vuex getter for devtools
+    res[key].vuex = true;
+  });
+  return res
+});
+
+/**
+ * Reduce the code which written in Vue.js for dispatch the action
+ * @param {String} [namespace] - Module's namespace
+ * @param {Object|Array} actions # Object's item can be a function which accept `dispatch` function as the first param, it can accept anthor params. You can dispatch action and do any other things in this function. specially, You need to pass anthor params from the mapped function.
+ * @return {Object}
+ */
+var mapActions = normalizeNamespace(function (namespace, actions) {
+  var res = {};
+  if ((process.env.NODE_ENV !== 'production') && !isValidMap(actions)) {
+    console.error('[vuex] mapActions: mapper parameter must be either an Array or an Object');
+  }
+  normalizeMap(actions).forEach(function (ref) {
+    var key = ref.key;
+    var val = ref.val;
+
+    res[key] = function mappedAction () {
+      var args = [], len = arguments.length;
+      while ( len-- ) args[ len ] = arguments[ len ];
+
+      // get dispatch function from store
+      var dispatch = this.$store.dispatch;
+      if (namespace) {
+        var module = getModuleByNamespace(this.$store, 'mapActions', namespace);
+        if (!module) {
+          return
+        }
+        dispatch = module.context.dispatch;
+      }
+      return typeof val === 'function'
+        ? val.apply(this, [dispatch].concat(args))
+        : dispatch.apply(this.$store, [val].concat(args))
+    };
+  });
+  return res
+});
+
+/**
+ * Rebinding namespace param for mapXXX function in special scoped, and return them by simple object
+ * @param {String} namespace
+ * @return {Object}
+ */
+var createNamespacedHelpers = function (namespace) { return ({
+  mapState: mapState.bind(null, namespace),
+  mapGetters: mapGetters.bind(null, namespace),
+  mapMutations: mapMutations.bind(null, namespace),
+  mapActions: mapActions.bind(null, namespace)
+}); };
+
+/**
+ * Normalize the map
+ * normalizeMap([1, 2, 3]) => [ { key: 1, val: 1 }, { key: 2, val: 2 }, { key: 3, val: 3 } ]
+ * normalizeMap({a: 1, b: 2, c: 3}) => [ { key: 'a', val: 1 }, { key: 'b', val: 2 }, { key: 'c', val: 3 } ]
+ * @param {Array|Object} map
+ * @return {Object}
+ */
+function normalizeMap (map) {
+  if (!isValidMap(map)) {
+    return []
+  }
+  return Array.isArray(map)
+    ? map.map(function (key) { return ({ key: key, val: key }); })
+    : Object.keys(map).map(function (key) { return ({ key: key, val: map[key] }); })
+}
+
+/**
+ * Validate whether given map is valid or not
+ * @param {*} map
+ * @return {Boolean}
+ */
+function isValidMap (map) {
+  return Array.isArray(map) || isObject(map)
+}
+
+/**
+ * Return a function expect two param contains namespace and map. it will normalize the namespace and then the param's function will handle the new namespace and the map.
+ * @param {Function} fn
+ * @return {Function}
+ */
+function normalizeNamespace (fn) {
+  return function (namespace, map) {
+    if (typeof namespace !== 'string') {
+      map = namespace;
+      namespace = '';
+    } else if (namespace.charAt(namespace.length - 1) !== '/') {
+      namespace += '/';
+    }
+    return fn(namespace, map)
+  }
+}
+
+/**
+ * Search a special module from store by namespace. if module not exist, print error message.
+ * @param {Object} store
+ * @param {String} helper
+ * @param {String} namespace
+ * @return {Object}
+ */
+function getModuleByNamespace (store, helper, namespace) {
+  var module = store._modulesNamespaceMap[namespace];
+  if ((process.env.NODE_ENV !== 'production') && !module) {
+    console.error(("[vuex] module namespace not found in " + helper + "(): " + namespace));
+  }
+  return module
+}
+
+// Credits: borrowed code from fcomb/redux-logger
+
+function createLogger (ref) {
+  if ( ref === void 0 ) ref = {};
+  var collapsed = ref.collapsed; if ( collapsed === void 0 ) collapsed = true;
+  var filter = ref.filter; if ( filter === void 0 ) filter = function (mutation, stateBefore, stateAfter) { return true; };
+  var transformer = ref.transformer; if ( transformer === void 0 ) transformer = function (state) { return state; };
+  var mutationTransformer = ref.mutationTransformer; if ( mutationTransformer === void 0 ) mutationTransformer = function (mut) { return mut; };
+  var actionFilter = ref.actionFilter; if ( actionFilter === void 0 ) actionFilter = function (action, state) { return true; };
+  var actionTransformer = ref.actionTransformer; if ( actionTransformer === void 0 ) actionTransformer = function (act) { return act; };
+  var logMutations = ref.logMutations; if ( logMutations === void 0 ) logMutations = true;
+  var logActions = ref.logActions; if ( logActions === void 0 ) logActions = true;
+  var logger = ref.logger; if ( logger === void 0 ) logger = console;
+
+  return function (store) {
+    var prevState = deepCopy(store.state);
+
+    if (typeof logger === 'undefined') {
+      return
+    }
+
+    if (logMutations) {
+      store.subscribe(function (mutation, state) {
+        var nextState = deepCopy(state);
+
+        if (filter(mutation, prevState, nextState)) {
+          var formattedTime = getFormattedTime();
+          var formattedMutation = mutationTransformer(mutation);
+          var message = "mutation " + (mutation.type) + formattedTime;
+
+          startMessage(logger, message, collapsed);
+          logger.log('%c prev state', 'color: #9E9E9E; font-weight: bold', transformer(prevState));
+          logger.log('%c mutation', 'color: #03A9F4; font-weight: bold', formattedMutation);
+          logger.log('%c next state', 'color: #4CAF50; font-weight: bold', transformer(nextState));
+          endMessage(logger);
+        }
+
+        prevState = nextState;
+      });
+    }
+
+    if (logActions) {
+      store.subscribeAction(function (action, state) {
+        if (actionFilter(action, state)) {
+          var formattedTime = getFormattedTime();
+          var formattedAction = actionTransformer(action);
+          var message = "action " + (action.type) + formattedTime;
+
+          startMessage(logger, message, collapsed);
+          logger.log('%c action', 'color: #03A9F4; font-weight: bold', formattedAction);
+          endMessage(logger);
+        }
+      });
+    }
+  }
+}
+
+function startMessage (logger, message, collapsed) {
+  var startMessage = collapsed
+    ? logger.groupCollapsed
+    : logger.group;
+
+  // render
+  try {
+    startMessage.call(logger, message);
+  } catch (e) {
+    logger.log(message);
+  }
+}
+
+function endMessage (logger) {
+  try {
+    logger.groupEnd();
+  } catch (e) {
+    logger.log('—— log end ——');
+  }
+}
+
+function getFormattedTime () {
+  var time = new Date();
+  return (" @ " + (pad(time.getHours(), 2)) + ":" + (pad(time.getMinutes(), 2)) + ":" + (pad(time.getSeconds(), 2)) + "." + (pad(time.getMilliseconds(), 3)))
+}
+
+function repeat (str, times) {
+  return (new Array(times + 1)).join(str)
+}
+
+function pad (num, maxLength) {
+  return repeat('0', maxLength - num.toString().length) + num
+}
+
+var index = {
+  version: '4.1.0',
+  Store: Store,
+  storeKey: storeKey,
+  createStore: createStore,
+  useStore: useStore,
+  mapState: mapState,
+  mapMutations: mapMutations,
+  mapGetters: mapGetters,
+  mapActions: mapActions,
+  createNamespacedHelpers: createNamespacedHelpers,
+  createLogger: createLogger
+};
+
+export default index;
+export { Store, createLogger, createNamespacedHelpers, createStore, mapActions, mapGetters, mapMutations, mapState, storeKey, useStore };
diff --git a/parent_dir/src/admin-components/ComponentNotFound.vue b/parent_dir/src/admin-components/ComponentNotFound.vue
new file mode 100644
index 0000000..234db4a
--- /dev/null
+++ b/parent_dir/src/admin-components/ComponentNotFound.vue
@@ -0,0 +1,22 @@
+<template>
+  <div class="component-not-found">
+    <h3>{{ $t('componentNotFound') }}</h3>
+  </div>
+</template>
+
+<script>
+export default {
+  name: 'ComponentNotFound',
+};
+</script>
+
+<style scoped lang="scss">
+.component-not-found {
+  text-align: center;
+  box-shadow: 0 0 15px rgba(0, 0, 0, 40%);
+  background-color: #fff;
+  margin-top: 20px;
+  margin-bottom: 20px;
+  padding: 32px 16px;
+}
+</style>
diff --git a/parent_dir/src/api-clients/base-api-client.ts b/parent_dir/src/api-clients/base-api-client.ts
new file mode 100644
index 0000000..3490080
--- /dev/null
+++ b/parent_dir/src/api-clients/base-api-client.ts
@@ -0,0 +1,90 @@
+import axios, { CreateAxiosDefaults, RawAxiosRequestHeaders } from 'axios';
+import https from 'https';
+import process from 'process';
+import { castEnv, getEnvUniversal } from '#root/src/utils/env-utils';
+
+class RestApi {
+  private readonly _apiHost;
+
+  private readonly _apiPrefix;
+
+  private readonly _axios;
+
+  constructor(apiHost: string, apiPrefix: string) {
+    if (!apiHost) {
+      throw new Error('"apiHost" {string} param is required.');
+    }
+
+    // eslint-disable-next-line no-restricted-globals
+    this._apiHost = apiHost || location?.origin;
+    this._apiPrefix = apiPrefix;
+
+    const axiosHeaders: RawAxiosRequestHeaders = {
+      Accept: 'application/json',
+    };
+
+    const axiosConfig: CreateAxiosDefaults = { headers: axiosHeaders };
+    // https - модуль ноды. Наверное можно как-то застаивть его работать на клиенте,
+    // но пока я не смог этого сделать, поэтому завернул в трай коч
+    try {
+      // Когда сейчас запускаю в проде все равно использжуем self-signed стерификат.
+      // TODO: вернуть проверку на прод
+      if (typeof window === 'undefined') {
+        axiosConfig.httpsAgent = new https.Agent({
+          rejectUnauthorized: false,
+        });
+      }
+    } catch (e) {
+      // cdekConsoleError(e)
+    }
+
+    this._axios = axios.create(axiosConfig);
+    this.setCache();
+  }
+
+  get apiHost() {
+    return this._apiHost;
+  }
+
+  get apiPrefix() {
+    return this._apiPrefix;
+  }
+
+  get axios() {
+    return this._axios;
+  }
+
+  async setCache() {
+    const checkCacheDisabled = castEnv(getEnvUniversal('VITE_REDIS_CACHE_DISABLED'), false);
+
+    if ((process as any).browser || checkCacheDisabled) {
+      return;
+    }
+
+    const { redisStorage } = await import('#root/src/utils/redis-storage/redis-storage');
+    const { setupCache } = await import('axios-cache-interceptor');
+
+    setupCache(this.axios, {
+      // У нас огромное количество разных запросов, я не уверен, что мы хотим кешировать вообще все
+      // поэтому пока делаем что то типа вайт листа. Там где хотим, чтобы запрос кешировался
+      // добавляем в конфиг запроса { cache: {methods: ['yourMethod'] },
+      methods: [],
+      storage: redisStorage,
+      ttl: (process.env.REDIS_TIMEOUT ? +process.env.REDIS_TIMEOUT : 600) * 1000,
+    });
+  }
+
+  unAuthAxios() {
+    return this.axios;
+  }
+
+  endpointUrl(endpoint?: string) {
+    if (!this.apiPrefix) {
+      return `${this.apiHost}${endpoint || ''}`;
+    }
+
+    return `${this.apiHost}/${this.apiPrefix}${endpoint || ''}`;
+  }
+}
+
+export default RestApi;
diff --git a/parent_dir/src/api-clients/cabinetApi/cabinet.ts b/parent_dir/src/api-clients/cabinetApi/cabinet.ts
new file mode 100644
index 0000000..6e44c05
--- /dev/null
+++ b/parent_dir/src/api-clients/cabinetApi/cabinet.ts
@@ -0,0 +1,559 @@
+// noinspection NpmUsedModulesInstalled
+import axios, { RawAxiosRequestHeaders } from 'axios';
+import sortBy from 'lodash/sortBy';
+import { cdekConsoleInfo } from '@/utils/console-wrapper';
+import { getMappedLocale } from '@/utils/map.locale.utils';
+import MainState from '@/types/store';
+import { Store } from 'vuex';
+import { CdekCity } from '@/types/dto/city';
+import { getWebsiteId } from '@/utils/international.utils';
+import { LkWebsiteId } from '@/env';
+import { AdvertAgreement } from '@/types/dto/advertAgreement';
+import { GetOrderNotifications } from '@/types/dto/cabinet';
+
+const USER_ME = '/user/me/';
+const USER_PROFILE_EMAIL = '/user/profile/email';
+const USER_PROFILE_EMAIL_CONFIRM = '/user/profile/email/confirm';
+const USER_ADVERT_AGREEMENT = '/user/advert-agreement';
+const REFRESH = '/refresh/';
+const HELLO = '/hello/';
+
+const TRACING_TRACK_INFO = '/tracing/trackInfo/';
+
+const ENDPOINT_CITIES_AUTOCOMPLETE = '/cities/autocomplete/';
+const ENDPOINT_PACKAGING_TYPES = '/packaging-types/';
+const ENDPOINT_ESTIMATE_V2 = '/estimateV2/';
+const ENDPOINT_GET_TARIFF_INFO = '/getTariffInfo/';
+const ENDPOINT_CURRENCIES = '/currencies/';
+const ENDPOINT_STREET_TIME_CITY = '/cities/time/';
+const ENDPOINT_LOYALTY_OFFERS = '/loyalty/offers/';
+const ENDPOINT_LOYALTY_POINTS = '/loyalty/points/';
+const ENDPOINT_COD_PAYMENT_STATUS = '/cashOnDelivery/paymentStatus/';
+const ENDPOINT_COD_PAYMENT_STATUS_BY_ORDER = '/cashOnDelivery/paymentStatus/{orderNumber}/';
+const ENDPOINT_COD_PAYMENT_INIT = '/cashOnDelivery/paymentInit/';
+const ENDPOINT_LOYALTY_ORDER_PRECHECK = '/loyalty/orderPrecheck/';
+const ENDPOINT_USER_ORDER_NOTIFICATIONS = '/user/order-notifications/';
+const ENDPOINT_GET_CITY_BY_ID = '/cities/{code}/';
+
+const ENDPOINT_RATING_PRODUCTS_REVIEWS_INFO = '/rating-products/reviews-info/';
+const ENDPOINT_RATING_PRODUCTS_SEND_POPUP_SHOWED = '/rating-products/send-popup-showed/';
+const ENDPOINT_RATING_PRODUCTS_REVIEW = '/rating-products/review/';
+
+const GIFTS_PRODUCTS = '/gifts/products/';
+const GIFTS_PRODUCTS_BURN = '/gifts/products/burn/';
+const GIFT_PRODUCTS_BY_UUID = '/gifts/products/{uuid}/';
+const GIFTS_ADD_TO_FAVORITE = '/gifts/favourites/{uuid}/';
+const GIFTS_REMOVE_FROM_FAVORITE = '/gifts/favourites/{uuid}/';
+const GIFTS_FAVORITES = '/gifts/favourites/';
+const GIFTS_PRECHECK = '/gifts/precheck/';
+const GIFTS_PURCHASE = '/gifts/purchase/';
+const GIFTS_ORDERS_DELETE = '/gifts/orders/{uuid}/';
+
+/**
+ * @param {CabinetApi} cls
+ * @param {string} endpoint
+ *
+ * @returns {string}
+ */
+function endpointUrl(cls: CabinetApi, endpoint: string): string {
+  return `${cls.apiHost}/${cls.apiPrefix}${endpoint}`;
+}
+
+/**
+ * @method {string} _apiHost
+ * @method {string} _apiPrefix
+ * @method {string|null} _accessToken
+ * @method {AxiosInstance} _axios
+ */
+class CabinetApi {
+  _apiHost;
+
+  _apiPrefix;
+
+  _store;
+
+  locale;
+
+  websiteId;
+
+  /**
+   * @param {string} apiHost
+   * @param {string} apiPrefix
+   * @param {object} store
+   *
+   * @constructor
+   */
+  constructor(apiHost: string, apiPrefix: string, store: Store<MainState>) {
+    if (!apiHost) {
+      throw new Error('"apiHost" {string} param is required.');
+    }
+
+    if (!apiPrefix) {
+      throw new Error('"apiPrefix" {string} param is required.');
+    }
+
+    if (!store) {
+      throw new Error('"store" {object} param is required.');
+    }
+
+    this._apiHost = apiHost;
+    this._apiPrefix = apiPrefix.replace(/\/+/, '');
+    this._store = store;
+
+    this.locale = getMappedLocale(this.store.getters?.currentLocaleISO) ?? 'ru/';
+    this.websiteId = getWebsiteId();
+  }
+
+  get apiHost() {
+    return this._apiHost;
+  }
+
+  get apiPrefix() {
+    return this._apiPrefix;
+  }
+
+  get store() {
+    return this._store;
+  }
+
+  setLocale(lang: Exclude<LkWebsiteId, 'by'>) {
+    this.locale = getMappedLocale(lang);
+  }
+
+  async accessToken() {
+    const impersonationAccessToken = this.impersonationAccessToken();
+
+    if (impersonationAccessToken) {
+      return [impersonationAccessToken, true];
+    }
+
+    const accessToken = this.store.getters['keycloak/accessToken'];
+    const refreshToken = this.store.getters['keycloak/refreshToken'];
+    const accessTokenExpiredAt = this.store.getters['keycloak/expiredAt'];
+    const refreshTokenExpiredAt = this.store.getters['keycloak/refreshExpiredAt'];
+    const nowTS = Math.round(new Date().getTime() / 1000);
+    let accessTokenExpiredAtTS = Math.round(new Date(accessTokenExpiredAt).getTime() / 1000);
+    let refreshTokenExpiredAtTS = Math.round(new Date(refreshTokenExpiredAt).getTime() / 1000);
+
+    if (accessTokenExpiredAtTS === 0) {
+      accessTokenExpiredAtTS = 2 ** 31;
+    }
+
+    if (refreshTokenExpiredAtTS === 0) {
+      refreshTokenExpiredAtTS = 2 ** 31;
+    }
+
+    const accessTokenReducedExpiredTS = accessTokenExpiredAtTS - 10;
+    const refreshTokenReducedExpiredTS = refreshTokenExpiredAtTS - 10;
+
+    if (accessToken && accessTokenReducedExpiredTS > nowTS) {
+      return [accessToken];
+    }
+
+    if (!refreshToken) {
+      throw new Error('REFRESH_TOKEN_EMPTY');
+    }
+
+    if (refreshTokenReducedExpiredTS < nowTS) {
+      throw new Error('REFRESH_TOKEN_EXPIRED');
+    }
+
+    cdekConsoleInfo('Access token is expired, refreshing...');
+
+    return this.refresh(refreshToken)
+      .then((response) => {
+        /**
+         * @type {KeycloakResponse}
+         */
+        const keycloakResponse = response.data;
+
+        this.store.commit('keycloak/setKeycloak', keycloakResponse);
+
+        return [this.store.getters['keycloak/accessToken']];
+      })
+      .catch(() => {
+        throw new Error('REFRESH_TOKEN_PENDING');
+      });
+  }
+
+  impersonationAccessToken() {
+    const obj = this.store.getters['auth/getImpersonation'];
+    const token = obj?._t;
+
+    if (!token) {
+      return null;
+    }
+
+    const isImpersonationTokenExpired = this.store.getters['auth/isImpersonationTokenExpired'];
+    if (isImpersonationTokenExpired()) {
+      throw new Error('TOKEN_EXPIRED');
+    }
+
+    return token;
+  }
+
+  /**
+   * Returns authenticated axios instance with auto refreshing access token.
+   *
+   * @returns {Promise<AxiosInstance>}
+   */
+  async authAxios() {
+    return this.accessToken()
+      .then(([accessToken, asUser = false]) => {
+        if (!accessToken) {
+          throw new Error('"accessToken" is required for auth requests.');
+        }
+
+        const headers: RawAxiosRequestHeaders = {
+          Accept: 'application/json',
+          Authorization: `Bearer ${accessToken}`,
+          'X-Site-Code': this.websiteId,
+          'X-User-Lang': this.locale,
+        };
+
+        if (asUser) {
+          headers['X-Auth-As-User'] = 'true/';
+        }
+
+        return axios.create({
+          headers,
+        });
+      })
+      .catch((error) => {
+        switch (error.message) {
+          case 'REFRESH_TOKEN_EMPTY':
+          case 'REFRESH_TOKEN_EXPIRED':
+            cdekConsoleInfo('Refresh token empty or expired.');
+
+            this.store.dispatch('auth/removeImpersonation', true);
+
+            break;
+
+          case 'REFRESH_TOKEN_PENDING':
+            cdekConsoleInfo('Refresh token not empty, but auth gateway is inaccessible.');
+
+            break;
+
+          case 'TOKEN_EXPIRED':
+            cdekConsoleInfo('Token empty or expired.');
+            this.store.dispatch('auth/removeImpersonation', true);
+            break;
+
+          default:
+            break;
+        }
+
+        return axios.create();
+      });
+  }
+
+  /**
+   * Returns unauthenticated axios instance.
+   *
+   * @returns {Promise<AxiosInstance>}
+   */
+  // eslint-disable-next-line class-methods-use-this
+  async unauthAxios() {
+    return axios.create({
+      headers: {
+        Accept: 'application/json',
+        'X-Site-Code': this.websiteId,
+        'X-User-Lang': this.locale,
+      },
+    });
+  }
+
+  /**
+   * @returns {Promise<AxiosResponse<any>>}
+   */
+  async hello() {
+    return (await this.unauthAxios()).get(endpointUrl(this, HELLO));
+  }
+
+  /**
+   * @returns {Promise<AxiosResponse<any>>}
+   */
+  async userMe() {
+    return (await this.authAxios()).get(endpointUrl(this, USER_ME));
+  }
+
+  async setEmail(email: string | null) {
+    return (await this.authAxios()).post(endpointUrl(this, USER_PROFILE_EMAIL), {
+      email,
+    });
+  }
+
+  async confirmEmail(email: string, token: string) {
+    return (await this.authAxios()).put(endpointUrl(this, USER_PROFILE_EMAIL_CONFIRM), {
+      email,
+      token,
+    });
+  }
+
+  async getUserAdvertAgreement(): Promise<AdvertAgreement> {
+    const {
+      data: { data },
+    } = await (await this.authAxios()).get(endpointUrl(this, USER_ADVERT_AGREEMENT));
+
+    return data;
+  }
+
+  async saveUserAdvertAgreement(agreed: boolean) {
+    return (await this.authAxios()).put(endpointUrl(this, USER_ADVERT_AGREEMENT), { agreed });
+  }
+
+  async getOrderNotifications(): Promise<GetOrderNotifications> {
+    const res = await (
+      await this.authAxios()
+    ).get(endpointUrl(this, ENDPOINT_USER_ORDER_NOTIFICATIONS));
+    return res.data.data;
+  }
+
+  async getPaymentInfo(order_numbers: unknown) {
+    const res = await (
+      await this.authAxios()
+    ).get(endpointUrl(this, ENDPOINT_COD_PAYMENT_STATUS), {
+      params: { order_numbers },
+    });
+    return res.data.data;
+  }
+
+  async getCashOnDeliveryInfo(orderNumber: string) {
+    const url = ENDPOINT_COD_PAYMENT_STATUS_BY_ORDER.replace('{orderNumber}', orderNumber);
+    const res = await (await this.unauthAxios()).get(endpointUrl(this, url));
+
+    return res.data;
+  }
+
+  /**
+   * @param {string} order_number
+   *
+   * @returns {Promise<AxiosResponse<any>>}
+   */
+  async paymentInit(order_number: string) {
+    const res = await (
+      await this.authAxios()
+    ).post(endpointUrl(this, ENDPOINT_COD_PAYMENT_INIT), {
+      order_number,
+    });
+
+    return res.data.data;
+  }
+
+  /**
+   * @param {number} orderNumber
+   *
+   * @returns {Promise<AxiosResponse<any>>}
+   */
+  async trackInfo(orderNumber: string) {
+    return (await this.authAxios()).get(`${endpointUrl(this, TRACING_TRACK_INFO)}${orderNumber}`);
+  }
+
+  async trackDetailInfo(orderNumber: string) {
+    return (await this.authAxios()).get(
+      `${endpointUrl(this, TRACING_TRACK_INFO)}${orderNumber}/details`,
+    );
+  }
+
+  async getLoyaltyPrecheckInfo(orderNumber: number, coupons: number, points: number) {
+    const { data } = await (
+      await this.unauthAxios()
+    ).post(endpointUrl(this, ENDPOINT_LOYALTY_ORDER_PRECHECK), { orderNumber, coupons, points });
+
+    return data;
+  }
+
+  async getLoyaltyOffers(isAuth = false) {
+    const axiosInstance = await (isAuth ? this.authAxios() : this.unauthAxios());
+
+    const res = await axiosInstance.get(endpointUrl(this, ENDPOINT_LOYALTY_OFFERS));
+    return res.data.data;
+  }
+
+  async getLoyaltyPoints() {
+    const { data } = await (await this.authAxios()).get(endpointUrl(this, ENDPOINT_LOYALTY_POINTS));
+
+    return data.data;
+  }
+
+  // order
+  /**
+   * @param str {string}
+   * @param limit {number}
+   * @returns {Promise<any>}
+   */
+  async citiesAutocomplete(str = '', limit = 10): Promise<CdekCity[]> {
+    const params = {
+      str,
+      limit,
+    };
+    const res = await (
+      await this.unauthAxios()
+    ).get(endpointUrl(this, ENDPOINT_CITIES_AUTOCOMPLETE), { params });
+
+    return res.data.data;
+  }
+
+  /**
+   * @returns {Promise<any>}
+   */
+  async getPackagingTypes() {
+    const res = await (await this.unauthAxios()).get(endpointUrl(this, ENDPOINT_PACKAGING_TYPES));
+    return res.data;
+  }
+
+  /**
+   * @param form {{currency: Object, origin: Object, destination: Object, parcels: Object[]}}
+   * @returns {Promise<void>}
+   */
+  async getOrderTariffV2(form: unknown) {
+    const res = await (
+      await this.unauthAxios()
+    ).post(endpointUrl(this, ENDPOINT_ESTIMATE_V2), form);
+    return sortBy(res.data.data, ['placing']);
+  }
+
+  /**
+   * @param {Boolean} isAuth
+   * @param {Object} form
+   * @param {Boolean} form.withoutAdditionalServices
+   * @param {String} form.payerType
+   * @param {String} form.currencyMark
+   * @param {String} form.senderCityId
+   * @param {String} form.receiverCityId
+   * @param {String} form.serviceId
+   * @param {String} form.mode
+   * @param {Object[]} form.packages
+   * @param {Object[]} form.additionalServices
+   * @returns {Promise<void>}
+   */
+  async getTariffInfo(isAuth: boolean, form: unknown) {
+    const axiosInstance = await (isAuth ? this.authAxios() : this.unauthAxios());
+    const res = await axiosInstance.post(endpointUrl(this, ENDPOINT_GET_TARIFF_INFO), form);
+    return res.data.data;
+  }
+
+  /**
+   * @param cityCode
+   * @returns {Promise<*>}
+   */
+  async getCurrenciesByCityCode(cityCode = 14) {
+    const params = { cityCode };
+    const res = await (
+      await this.unauthAxios()
+    ).get(endpointUrl(this, ENDPOINT_CURRENCIES), { params });
+    return res.data.data;
+  }
+
+  /**
+   * @param cityCode
+   * @returns {Promise<any>}
+   */
+  async getCurrentTimeCity(cityCode: string) {
+    const params = { cityCode };
+    const res = await (
+      await this.unauthAxios()
+    ).get(endpointUrl(this, ENDPOINT_STREET_TIME_CITY), { params });
+    return res.data;
+  }
+
+  /**
+   * @param {string} refreshToken
+   *
+   * @returns {Promise<AxiosResponse<any>>}
+   */
+  async refresh(refreshToken: string) {
+    return (await this.unauthAxios()).post(endpointUrl(this, REFRESH), {
+      token: refreshToken,
+    });
+  }
+
+  async getCityById(id: string) {
+    const url = ENDPOINT_GET_CITY_BY_ID.replace('{code}', id);
+    const res = await (await this.unauthAxios()).get(endpointUrl(this, url));
+    return res.data.data;
+  }
+
+  async ratingProductsReview(form: unknown) {
+    const res = await (
+      await this.authAxios()
+    ).post(endpointUrl(this, ENDPOINT_RATING_PRODUCTS_REVIEW), form);
+    return res.data.data;
+  }
+
+  async ratingProductsSendPopupShowed() {
+    const res = await (
+      await this.authAxios()
+    ).post(endpointUrl(this, ENDPOINT_RATING_PRODUCTS_SEND_POPUP_SHOWED));
+    return res.data.data;
+  }
+
+  /**
+   * @returns {Promise<{countPopup: String, availableProducts: Array, currentProductId: String}>}
+   */
+  async ratingProductsReviewsInfo() {
+    const res = await (
+      await this.authAxios()
+    ).get(endpointUrl(this, ENDPOINT_RATING_PRODUCTS_REVIEWS_INFO));
+    return res.data.data;
+  }
+
+  async giftsProducts() {
+    const url = `${GIFTS_PRODUCTS}?available=true`;
+
+    const res = await (await this.authAxios()).get(endpointUrl(this, url));
+    return res.data.data;
+  }
+
+  async giftsProductsBurn() {
+    const res = await (await this.authAxios()).get(endpointUrl(this, GIFTS_PRODUCTS_BURN));
+    return res.data.data;
+  }
+
+  async giftsProductsByUuid(uuid: string) {
+    const url = GIFT_PRODUCTS_BY_UUID.replace('{uuid}', uuid);
+
+    const res = await (await this.authAxios()).get(endpointUrl(this, url));
+    return res.data.data;
+  }
+
+  async giftsAddToFavorite(uuid: string) {
+    const url = GIFTS_ADD_TO_FAVORITE.replace('{uuid}', uuid);
+    const res = await (await this.authAxios()).put(endpointUrl(this, url));
+    return res.data.data;
+  }
+
+  async giftsRemoveFromFavorite(uuid: string) {
+    const url = GIFTS_REMOVE_FROM_FAVORITE.replace('{uuid}', uuid);
+    const res = await (await this.authAxios()).delete(endpointUrl(this, url));
+    return res.data.data;
+  }
+
+  async giftsFavorite() {
+    const res = await (await this.authAxios()).get(endpointUrl(this, GIFTS_FAVORITES));
+    return res.data.data;
+  }
+
+  async giftsPrecheck(productUuid: string) {
+    const res = await (
+      await this.authAxios()
+    ).post(endpointUrl(this, GIFTS_PRECHECK), { productUuid });
+    return res.data.data;
+  }
+
+  async giftsPurchase(productUuid: string) {
+    const res = await (
+      await this.authAxios()
+    ).post(endpointUrl(this, GIFTS_PURCHASE), { productUuid });
+    return res.data.data;
+  }
+
+  async giftsOrdersDelete(uuid: string) {
+    const url = GIFTS_ORDERS_DELETE.replace('{uuid}', uuid);
+
+    const res = await (await this.authAxios()).delete(endpointUrl(this, url));
+    return res.data.data;
+  }
+}
+
+export default CabinetApi;
diff --git a/parent_dir/src/api-clients/cabinetApi/client.ts b/parent_dir/src/api-clients/cabinetApi/client.ts
new file mode 100644
index 0000000..44371be
--- /dev/null
+++ b/parent_dir/src/api-clients/cabinetApi/client.ts
@@ -0,0 +1,6 @@
+import CabinetApi from '@/api-clients/cabinetApi/cabinet';
+import { CdekStore } from '@/types/store';
+
+export default (apiHost: string, apiPrefix: string, store: CdekStore) => ({
+  cabinet: new CabinetApi(apiHost, apiPrefix, store),
+});
diff --git a/parent_dir/src/api-clients/express-api.ts b/parent_dir/src/api-clients/express-api.ts
new file mode 100644
index 0000000..2c6feb0
--- /dev/null
+++ b/parent_dir/src/api-clients/express-api.ts
@@ -0,0 +1,35 @@
+import { Multitone, getInstanceFactory } from '@cdek-ui-kit/vue';
+
+import axios from 'axios';
+import https from 'https';
+import type { AxiosInstance, AxiosRequestConfig } from 'axios';
+
+import { getEnvUniversal } from '#root/src/utils/env-utils';
+
+const EXPRESS_URL = getEnvUniversal('VITE_DEV_EXPRESS_ENDPOINT', 'VITE_HTTP_ENDPOINT');
+
+export class ExpressApi extends Multitone {
+  private _axios: AxiosInstance;
+
+  constructor() {
+    super();
+
+    const config: AxiosRequestConfig = {
+      baseURL: EXPRESS_URL,
+    };
+
+    if (typeof window === 'undefined') {
+      config.httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+    }
+
+    this._axios = axios.create(config);
+  }
+
+  get(url: string) {
+    return this._axios.get(url);
+  }
+}
+
+export const getExpressApi = getInstanceFactory<ExpressApi>(ExpressApi);
diff --git a/parent_dir/src/api-clients/graphql-api-client.ts b/parent_dir/src/api-clients/graphql-api-client.ts
new file mode 100644
index 0000000..1a76c8a
--- /dev/null
+++ b/parent_dir/src/api-clients/graphql-api-client.ts
@@ -0,0 +1,361 @@
+import IPage from '#root/src/types/dto/page';
+import RestApi from '#root/src/api-clients/base-api-client';
+import { DefaultRequestData } from '#root/src/types/dto/defaultRequestData';
+import { InvestmentSendEmailData } from '#root/src/types/dto/investmentSendEmailData';
+import { RedisError } from '#root/src/utils/redis-storage/RedisError';
+import { CdekDefaultCity } from '@/types/dto/city';
+
+export default class GraphqlApiClient extends RestApi {
+  constructor(host: string, prefix = 'api-site/v1/graphql/') {
+    super(host, prefix);
+  }
+
+  // TODO: вынести в интерцепторы
+  async unAuthCachedPost(href: string, body: any, config: any = {}) {
+    try {
+      config.cache = { methods: ['post'] };
+      return (await this.unAuthAxios().post(href, body, config)).data;
+    } catch (e) {
+      if (e instanceof RedisError) {
+        config.cache = false;
+
+        return (await this.unAuthAxios().post(href, body, config)).data;
+      }
+
+      throw e;
+    }
+  }
+
+  async websiteOfficeMap(code: string, locale: string): Promise<unknown> {
+    const href = this.endpointUrl();
+    const { websiteOfficeMapGql } = await import('#root/src/gql/website-office-map.gql');
+    const body = {
+      query: websiteOfficeMapGql,
+      variables: {
+        code,
+        filter: {
+          locale,
+        },
+      },
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async websiteCountriesPaginated(locale: string): Promise<unknown> {
+    const href = this.endpointUrl();
+    const { websiteCountriesPaginatedGql } = await import(
+      '#root/src/gql/website-countries-paginated.gql'
+    );
+    const body = {
+      query: websiteCountriesPaginatedGql,
+      variables: {
+        filter: {
+          locale,
+        },
+      },
+    };
+
+    return this.unAuthCachedPost(href, body);
+  }
+
+  async websiteCitiesPaginated(
+    { locale }: DefaultRequestData,
+    name: string,
+    country_code: string,
+  ): Promise<{
+    date: {
+      websiteCitiesPaginated: {
+        items: CdekDefaultCity[];
+      };
+    };
+  }> {
+    const href = this.endpointUrl();
+    const { websiteCitiesPaginatedGql } = await import(
+      '#root/src/gql/website-cities-paginated.gql'
+    );
+    const body = {
+      query: websiteCitiesPaginatedGql,
+      variables: {
+        filter: {
+          locale,
+          name,
+          country_code,
+        },
+      },
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async websitePage(url: string, locale: string, cookieABTestMap?: string | null): Promise<IPage> {
+    const { websitePageTextQuery } = await import('#root/src/gql/website-page.gql');
+    const href = this.endpointUrl();
+
+    const body = {
+      query: websitePageTextQuery,
+      variables: {
+        url,
+        locale,
+      },
+    };
+
+    const postOptions: any = {};
+
+    if (cookieABTestMap) {
+      postOptions.headers = { Cookie: `ab_test_map=${cookieABTestMap}` };
+      postOptions.cache = cookieABTestMap.includes(url) ? false : { methods: ['post'] };
+    }
+
+    const res = await this.unAuthCachedPost(href, body, postOptions);
+
+    return res.data.page;
+  }
+
+  async websiteOfficesPaginated({ locale }: DefaultRequestData, cityCode: number) {
+    const href = this.endpointUrl();
+    const { websiteOfficesPaginatedGql } = await import(
+      '#root/src/gql/website-offices-paginated.gql'
+    );
+    const body = {
+      query: websiteOfficesPaginatedGql,
+      variables: {
+        limit: 1,
+        filter: {
+          locale,
+          cityCode,
+        },
+      },
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async websiteOfficesCoordsPaginated(variables: unknown) {
+    const href = this.endpointUrl();
+    const { websiteOfficesCoordsPaginatedGql } = await import(
+      '#root/src/gql/website-offices-coords-paginated.gql'
+    );
+    const body = {
+      query: websiteOfficesCoordsPaginatedGql,
+      variables,
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async websitePressNewsPaginated({ locale }: DefaultRequestData, limit: number, offset: number) {
+    const href = this.endpointUrl();
+    const { websitePressNewsPaginated } = await import(
+      '#root/src/gql/website-press-news-paginated'
+    );
+    const body = {
+      query: websitePressNewsPaginated,
+      variables: {
+        limit,
+        offset,
+        filter: {
+          locale,
+        },
+        sort: {
+          field: 'sorted',
+          dir: 'DESC',
+        },
+      },
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async websiteVideosPaginated(
+    { locale }: DefaultRequestData,
+    sort: {
+      field: string;
+      dir: string;
+    },
+    offset: number,
+    limit: number,
+  ) {
+    const href = this.endpointUrl();
+    const { websiteVideosPaginatedGql } = await import(
+      '#root/src/gql/website-videos-paginated.gql'
+    );
+    const body = {
+      query: websiteVideosPaginatedGql,
+      variables: {
+        filter: {
+          locale,
+        },
+        limit,
+        offset,
+        sort,
+      },
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async sendCallback(form: Record<string, string>) {
+    const href = this.endpointUrl();
+    const { sendCallbackGql } = await import('#root/src/gql/send-callback.gql');
+    const body = {
+      query: sendCallbackGql,
+      variables: {
+        input: {
+          ...form,
+        },
+      },
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async questionsAdd(input: unknown) {
+    const href = this.endpointUrl();
+    const { questionsAddGql } = await import('#root/src/gql/questions-add.gql');
+    const body = {
+      query: questionsAddGql,
+      variables: {
+        input,
+      },
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async notificationSenderSms(phone: string, message: string) {
+    const href = this.endpointUrl();
+    const { notificationSenderSmsGql } = await import('#root/src/gql/notification-sender-sms.gql');
+    const body = {
+      query: notificationSenderSmsGql,
+      variables: {
+        input: {
+          phone,
+          message,
+        },
+      },
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async sendEmail(variables: unknown) {
+    const href = this.endpointUrl();
+    const { sendEmailGql } = await import('#root/src/gql/send-email.gql');
+    const body = {
+      query: sendEmailGql,
+      variables,
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async getTrackingV2(variables: unknown) {
+    const href = this.endpointUrl();
+    const { getTrackingV2Gql } = await import('#root/src/gql/get-tracking-v2.gql');
+    const body = {
+      query: getTrackingV2Gql,
+      variables,
+      context: {
+        enabledGlobalError: false,
+      },
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async InvestmentCalculatorResult(
+    { locale }: DefaultRequestData,
+    pdate: string,
+    sdate: string,
+    size: string,
+  ) {
+    const href = this.endpointUrl();
+    const { investmentCalculatorResult } = await import(
+      '#root/src/gql/investment-calculator-result.gql'
+    );
+    const body = {
+      query: investmentCalculatorResult,
+      variables: {
+        locale,
+        pdate,
+        sdate,
+        size,
+      },
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async InvestmentSendEmail(input: InvestmentSendEmailData) {
+    const href = this.endpointUrl();
+    const { investmentSendEmail } = await import('#root/src/gql/investment-send-email.gql');
+    const body = {
+      query: investmentSendEmail,
+      variables: {
+        input,
+      },
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async getInfoPayment(variables: unknown) {
+    const href = this.endpointUrl();
+    const { getInfoPaymentGql } = await import('#root/src/gql/payment/get-info-payment.gql');
+    const body = {
+      query: getInfoPaymentGql,
+      variables,
+      context: {
+        enabledGlobalError: false,
+      },
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async getOrderInfo(variables: unknown) {
+    const href = this.endpointUrl();
+    const { getOrderInfoGql } = await import('#root/src/gql/payment/get-order-info.gql');
+    const body = {
+      query: getOrderInfoGql,
+      variables,
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async onlinePayment(input: unknown) {
+    const href = this.endpointUrl();
+    const { onlinePaymentGql } = await import('#root/src/gql/payment/online-payment.gql');
+    const body = {
+      query: onlinePaymentGql,
+      variables: {
+        input,
+      },
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async payment(variables: unknown) {
+    const href = this.endpointUrl();
+    const { paymentGql } = await import('#root/src/gql/payment/payment.gql');
+    const body = {
+      query: paymentGql,
+      variables,
+    };
+
+    return (await this.unAuthAxios().post(href, body)).data;
+  }
+
+  async websiteOfficeByCode(variables: unknown) {
+    const { websiteOfficeByCodeGql } = await import('#root/src/gql/website-office-by-code.gql');
+    const body = {
+      query: websiteOfficeByCodeGql,
+      variables,
+    };
+
+    return (await this.unAuthAxios().post(this.endpointUrl(), body)).data.data;
+  }
+}
diff --git a/parent_dir/src/api-clients/pms-api-client.ts b/parent_dir/src/api-clients/pms-api-client.ts
new file mode 100644
index 0000000..d8a7a2a
--- /dev/null
+++ b/parent_dir/src/api-clients/pms-api-client.ts
@@ -0,0 +1,54 @@
+import axios, { CreateAxiosDefaults } from 'axios';
+import https from 'https';
+import IPage from '@/types/dto/page';
+
+const GET_FAQ = '/website/faq';
+const ENDPOINT_WEBSITE_PAGE = '/website/page';
+
+interface IWebsitePageReqParams {
+  url: string;
+  websiteId: string;
+  locale: string;
+}
+class PmsApiClient {
+  _axiosAuthInstance;
+
+  constructor(apiHost: string) {
+    if (!apiHost) {
+      throw new Error('"apiHost" {string} param is required.');
+    }
+
+    const apiPrefix = '/api-pms';
+
+    const baseURL = `${apiHost}/${apiPrefix.replace(/\/+/, '')}`;
+
+    const axiosConfig: CreateAxiosDefaults = { baseURL };
+
+    if (typeof window === 'undefined') {
+      axiosConfig.httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+    }
+
+    this._axiosAuthInstance = axios.create(axiosConfig);
+  }
+
+  // Получение списка FAQ
+  async getFaq(category?: string, isoLocale?: string) {
+    const params = {
+      category,
+      isoLocale,
+    };
+    const res = await this._axiosAuthInstance.get(GET_FAQ, { params });
+
+    return res.data.data;
+  }
+
+  async websitePage(params: IWebsitePageReqParams): Promise<IPage> {
+    const res = await this._axiosAuthInstance.get(ENDPOINT_WEBSITE_PAGE, { params });
+
+    return res.data.data.page;
+  }
+}
+
+export default PmsApiClient;
diff --git a/parent_dir/src/api-clients/rest-api-client.ts b/parent_dir/src/api-clients/rest-api-client.ts
new file mode 100644
index 0000000..6b3ae2f
--- /dev/null
+++ b/parent_dir/src/api-clients/rest-api-client.ts
@@ -0,0 +1,617 @@
+import BaseApiClient from '#root/src/api-clients/base-api-client';
+import { DefaultRequestData } from '#root/src/types/dto/defaultRequestData';
+import { SiteParam } from '#root/src/types/dto/siteParams';
+import IMenuItem from '#root/src/types/dto/menuItem';
+import { FooterData, FooterRequestData } from '#root/src/types/store/footer';
+import { getOfficeUrl } from '#root/src/utils/offices.request.utils';
+import { CdekOfficeFilter, OfficeRequestData } from '#root/src/types/dto/cdek-office';
+import { News } from '#root/src/types/dto/news';
+import IntegrationQuestion from '#root/src/types/dto/integrationQuestions';
+import {
+  IntegrationModuleResponse,
+  IntegrationShortModule,
+} from '#root/src/types/dto/integrationModule';
+
+import {
+  BaseCreationRequest,
+  ConclusionRequest,
+  ContragentInformation,
+  ExistsCreationRequest,
+  FnsCard,
+  JoinCompanyRequest,
+  SelfcareResponse,
+} from '#root/src/types/dto/fns-card';
+import { CityAutocomplete } from '#root/src/types/dto/city-autocomplete';
+import { removeSideSlashes } from '#root/src/utils/string.utils';
+import { CdekCityRequest, CdekFullCity } from '@/types/dto/city';
+import {
+  RequestWebsiteComponentAlert,
+  ResponseWebsiteComponentAlert,
+  WebsiteAlert,
+} from '@/types/dto/alert';
+import { IWebsiteFaqData } from '@/types/dto/websiteFaq';
+import { IWebsitePageData } from '@/types/dto/restWebsitePage';
+import { IPaymentVerifyParams, IPaymentVerifyResponse } from '@/types/dto/paymentVerify';
+import { RedisError } from '#root/src/utils/redis-storage/RedisError';
+import type {
+  ICalculateRequest,
+  ICalculateResponse,
+  IServicesRequest,
+  IServicesResponse,
+} from '#root/src/types/dto/calculatorB2B';
+import { AutodetectCityResponse } from '@/types/dto/autodetect-city';
+import { OfficeMapDto } from '@/types/dto/office';
+
+const WEBSITE_COUNTRY = '/website/country/get/?locale={locale}';
+const WEBSITE_WORKLOAD = '/website/workload/?officeCode={officeCode}';
+const WEBSITE_MENU = '/website/menu/?locale={locale}';
+const WEBSITE_INTEGRATION_MODULE = '/website/integration/module/';
+const WEBSITE_INTEGRATION_MODULE_BY_ID = '/website/integration/module/{id}/';
+const WEBSITE_QUESTION_BY_GROUP_TAG = '/website/question/?groupTag={tag}';
+const WEBSITE_NOTIFICATION_SEND_JIRA = '/website/notification/send-jira/';
+const WEBSITE_NOTIFICATION_SEND_JIRA_OI = '/website/notification/send-jira-oi/';
+const WEBSITE_PARAM = '/website/param/';
+const WEBSITE_FOOTER = '/website/footer/';
+const WEBSITE_ALERT = '/website/alert/';
+const WEBSITE_COMPONENT_ALERT = '/website/component/alert/';
+const HEALTHCHECK_NETWORK = '/healthcheck/network/';
+const WEBSITE_HELP_WIDGET = '/website/help-widget/';
+const OTHER_CDEK_SHOPPING_FEATURED_PRODUCTS =
+  '/other/cdek-shopping/featured-products/?locale={locale}';
+const OTHER_CDEK_SHOPPING_FEATURED_PRODUCTS_CATEGORY =
+  '/other/cdek-shopping/featured-products-category/?locale={locale}';
+const WEBSITE_OFFICE_MAP = '/website/office/map/';
+const WEBSITE_OFFICE = '/website/office/';
+const WEBSITE_CITY_DETECT = '/website/city/detect/?locale={locale}';
+const WEBSITE_CITY_BY_COORDS =
+  '/website/city/by-coords/?locale={locale}&latitude={latitude}&longitude={longitude}';
+const WEBSITE_CITY = '/website/city/?locale={locale}';
+
+const WEBSITE_NEWS = '/website/news/?locale={locale}&sort={sort}&limit={limit}&page={page}';
+const WEBSITE_CITY_AUTOCOMPLETE = '/website/city/auto-complete/?name={name}&locale={locale}';
+const WEBSITE_VIDEO_STREAM_OFFICE = '/website/video-stream/office/?id={id}&locale={locale}';
+const WEBSITE_DOGOVOR_CREATE_INDIVIDUAL = '/website/dogovor/create-individual/';
+const WEBSITE_DOGOVOR_CREATE_BUSINESS = '/website/dogovor/create-business/';
+const WEBSITE_DOGOVOR_CREATE_IP = '/website/dogovor/create-ip/';
+const WEBSITE_DOGOVOR_BIK = '/website/dogovor/bik-info/?bik={bik}&locale={locale}';
+const WEBSITE_DOGOVOR_INN = '/website/dogovor/inn-info/?inn={inn}&locale={locale}';
+const WEBSITE_DOGOVOR_CREATE_BUSINESS_FORM = '/website/dogovor/create-business-form';
+const WEBSITE_IDENTITY_PARAMS = '/website/identity/params/';
+const WEBSITE_IDENTITY_PASSPORT =
+  '/website/identity/{citizenship}/passport/?operationId={operationId}';
+const WEBSITE_IDENTITY_ID_CARD =
+  '/website/identity/{citizenship}/identity-card/?operationId={operationId}';
+const WEBSITE_IDENTITY_OTHER_DOCUMENT =
+  '/website/identity/other/undefined/?operationId={operationId}';
+const WEBSITE_SITEMAP = `/website/sitemap/?locale={locale}`;
+const WEBSITE_FREEZED_LOYALTY_POINTS = '/payment/customer/freezed-points/?customerUuid={user_uuid}';
+const WEBSITE_RATING_PRODUCT_ADD = '/website/rating-product/add/';
+const WEBSITE_ORDER_CHECK = '/website/order/check/?order={order}';
+const WEBSITE_NOTIFICATION_PACKAGE_ORDER = '/website/notification/package-order/';
+const WEBSITE_IDENTITY_CDEK_ID =
+  '/website/identity/{citizenship}/cdek-id/?operationId={operationId}';
+
+const WEBSITE_AGREEMENT_ONLINE_FNS_CARD =
+  '/website/agreement-online/fns-card/?inn={inn}&locale={locale}';
+const WEBSITE_AGREEMENT_ONLINE_JOIN = '/website/agreement-online/join/?locale={locale}';
+const WEBSITE_AGREEMENT_ONLINE_CONCLUSION =
+  '/website/agreement-online/conclusion/?locale={locale}&inn={inn}&cityUuid={cityUuid}';
+const WEBSITE_AGREEMENT_ONLINE_SELFCARE =
+  '/website/agreement-online/selfcare-users/?locale={locale}';
+
+const WEBSITE_AGREEMENT_ONLINE_BY_REQUISTIES = `/website/agreement-online/by-requisites/?inn={inn}`;
+const WEBSITE_AGREEMENT_ONLINE_CREATE_NEW =
+  '/website/agreement-online/contract-for-new-contragent/?locale={locale}';
+const WEBSITE_AGREEMENT_ONLINE_CREATE_EXIST =
+  '/website/agreement-online/contract-for-exist-contragent/?locale={locale}';
+
+const WEBSITE_AGREEMENT_ONLINE_CONTRACT = '/website/agreement-online/contract/?locale={locale}';
+
+const WEBSITE_FAQ = '/website/faq/?locale={locale}&withFooter={withFooter}';
+const WEBSITE_PAGE = '/website/page/?url={url}&locale={locale}';
+
+const WEBSITE_PAYMENT_AUTH_CODE_VERIFY = '/payment/cash-on-delivery/auth-code-verify';
+const OTHER_YANDEX_GEO_SUGGEST = `/other/yandex-geo-suggest/?text={text}&locale={locale}`;
+
+const CALCULATOR_SERVICES = '/website/calculator/services/';
+const CALCULATOR_CALCULATE = '/website/calculator/calculate/';
+
+const CUSTOMER_GET_LINK = '/payment/customer/get-link/?locale={locale}&number={number}&id={id}';
+
+export default class RestApiClient extends BaseApiClient {
+  constructor(apiHost: string, prefix = 'api-site') {
+    super(apiHost, prefix);
+  }
+
+  async unAuthCachedGet(url: string, config: any = {}) {
+    try {
+      config.cache = {
+        methods: ['get'],
+      };
+      return await this.unAuthAxios().get(this.endpointUrl(url), config);
+    } catch (e) {
+      if (e instanceof RedisError) {
+        config.cache = false;
+
+        return await this.unAuthAxios().get(this.endpointUrl(url), config);
+      }
+
+      throw e;
+    }
+  }
+
+  async websiteMenu(locale = 'ru'): Promise<IMenuItem[]> {
+    const url = WEBSITE_MENU.replace('{locale}', locale);
+
+    const res = await this.unAuthCachedGet(url);
+    return res.data.data;
+  }
+
+  async websiteParam({ locale }: DefaultRequestData): Promise<SiteParam[]> {
+    const url = `${WEBSITE_PARAM}?locale=${locale}`;
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data.data;
+  }
+
+  async websiteAlert({ locale }: DefaultRequestData): Promise<WebsiteAlert[]> {
+    const url = `${WEBSITE_ALERT}?locale=${locale}`;
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data.data;
+  }
+
+  async websiteComponentAlert({
+    locale,
+    url,
+  }: RequestWebsiteComponentAlert): Promise<ResponseWebsiteComponentAlert> {
+    const urlRequest = `${WEBSITE_COMPONENT_ALERT}?url=${url}&locale=${locale}`;
+    const res = await this.unAuthAxios().get(this.endpointUrl(urlRequest));
+    return res.data.data;
+  }
+
+  async healthCheckNetwork(network: string) {
+    const url = `${HEALTHCHECK_NETWORK}${network}/`;
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data;
+  }
+
+  async websiteIntegrationQuestionByTag(tag: string): Promise<IntegrationQuestion[]> {
+    const url = WEBSITE_QUESTION_BY_GROUP_TAG.replace('{tag}', tag);
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data.data;
+  }
+
+  async websiteOfficeMap(
+    data: OfficeRequestData,
+    filter?: Partial<CdekOfficeFilter>,
+  ): Promise<OfficeMapDto[]> {
+    const url = getOfficeUrl(WEBSITE_OFFICE_MAP, data, filter);
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+
+    return res.data.data.data;
+  }
+
+  async websiteOffice(data: OfficeRequestData, filter: Partial<CdekOfficeFilter>) {
+    let url = getOfficeUrl(WEBSITE_OFFICE, data, filter);
+    url += '&limit=100';
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data.data.data;
+  }
+
+  async websiteIntegrationModule(): Promise<IntegrationShortModule[]> {
+    const res = await this.unAuthAxios().get(this.endpointUrl(WEBSITE_INTEGRATION_MODULE));
+    return res.data.data;
+  }
+
+  async websiteIntegrationModuleById(id: string): Promise<IntegrationModuleResponse> {
+    const url = WEBSITE_INTEGRATION_MODULE_BY_ID.replace('{id}', id);
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data.data;
+  }
+
+  async websiteFooter({ locale, cityId }: FooterRequestData): Promise<FooterData> {
+    let url = `${WEBSITE_FOOTER}?locale=${locale}`;
+
+    if (cityId) {
+      url += `&cityId=${cityId}`;
+    }
+
+    const res = await this.unAuthCachedGet(url);
+
+    return res.data.data;
+  }
+
+  async getCdekShoppingFeaturedProducts({ locale = 'ru', category, limit, sourceType }: any) {
+    let url = OTHER_CDEK_SHOPPING_FEATURED_PRODUCTS.replace('{locale}', locale);
+
+    if (category) {
+      url += `&category[]=${category}`;
+    }
+
+    if (limit) {
+      url += `&limit=${limit}`;
+    }
+
+    if (sourceType) {
+      url += `&sourceType=${sourceType}`;
+    }
+
+    const res = await this.unAuthAxios().get(this.endpointUrl(encodeURI(url)));
+    return res.data.data;
+  }
+
+  async getCdekShoppingFeaturedProductsCategory({ locale }: DefaultRequestData) {
+    const url = OTHER_CDEK_SHOPPING_FEATURED_PRODUCTS_CATEGORY.replace('{locale}', locale);
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data.data;
+  }
+
+  async autodetectCity({ locale }: DefaultRequestData): Promise<AutodetectCityResponse> {
+    const url = WEBSITE_CITY_DETECT.replace('{locale}', locale);
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data.data;
+  }
+
+  async websiteNews({ locale, sort, limit, page }: News) {
+    const url = WEBSITE_NEWS.replace('{locale}', locale)
+      .replace('{sort}', sort)
+      .replace('{limit}', limit)
+      .replace('{page}', page);
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data.data;
+  }
+
+  async helpWidget({ locale = 'ru' }: DefaultRequestData, path = null) {
+    const url = `${WEBSITE_HELP_WIDGET}?locale=${locale}&url=${path}`;
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data.data;
+  }
+
+  async cityAutocomplete(
+    name: string,
+    locale: string,
+    countryCode?: string,
+  ): Promise<CityAutocomplete[]> {
+    let url = WEBSITE_CITY_AUTOCOMPLETE.replace('{name}', name).replace('{locale}', locale);
+
+    if (countryCode) {
+      url += `&countryCode=${countryCode}`;
+    }
+
+    const res = await this.unAuthAxios().post(this.endpointUrl(url));
+    return res.data.data;
+  }
+
+  async websiteNotificationSendJira(feedback: unknown) {
+    return this.unAuthAxios().post(this.endpointUrl(WEBSITE_NOTIFICATION_SEND_JIRA), feedback);
+  }
+
+  async websiteNotificationSendJiraOI(feedback: unknown) {
+    return this.unAuthAxios().post(this.endpointUrl(WEBSITE_NOTIFICATION_SEND_JIRA_OI), feedback);
+  }
+
+  async getOfficeWorkload(officeCode: string) {
+    const url = WEBSITE_WORKLOAD.replace('{officeCode}', officeCode);
+    const res = await this.unAuthAxios().post(this.endpointUrl(url));
+    return res.data.data;
+  }
+
+  async getOfficeVideoStream(id: string, locale: string, device: string | null = null) {
+    let url = WEBSITE_VIDEO_STREAM_OFFICE.replace('{id}', id).replace('{locale}', locale);
+
+    if (device) {
+      url += `&device=${device}`;
+    }
+    const res = await this.unAuthAxios().post(this.endpointUrl(url));
+    return res.data.data;
+  }
+
+  async websiteDogovorCreateIndividual(data: unknown) {
+    return this.unAuthAxios().post(this.endpointUrl(WEBSITE_DOGOVOR_CREATE_INDIVIDUAL), data);
+  }
+
+  async websiteDogovorCreateBusiness(data: unknown) {
+    return this.unAuthAxios().post(this.endpointUrl(WEBSITE_DOGOVOR_CREATE_BUSINESS), data);
+  }
+
+  async websiteDogovorCreateIp(data: unknown) {
+    return this.unAuthAxios().post(this.endpointUrl(WEBSITE_DOGOVOR_CREATE_IP), data);
+  }
+
+  async websiteDogovorBik(bik: string, locale: string) {
+    const url = WEBSITE_DOGOVOR_BIK.replace('{bik}', bik).replace('{locale}', locale);
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data;
+  }
+
+  async websiteDogovorInn(inn: string, locale: string) {
+    const url = WEBSITE_DOGOVOR_INN.replace('{inn}', inn).replace('{locale}', locale);
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data;
+  }
+
+  async getCountries(locale: string) {
+    const url = WEBSITE_COUNTRY.replace('{locale}', locale);
+
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data.data;
+  }
+
+  async websiteIdentityParams(data: unknown) {
+    const res = await this.unAuthAxios().post(this.endpointUrl(WEBSITE_IDENTITY_PARAMS), data);
+    return res.data;
+  }
+
+  async uploadPassportFile(data: unknown) {
+    const res = await this.unAuthAxios().post(
+      `${import.meta.env.VITE_HTTP_ENDPOINT}/api-site/v1/upload/passport-file/`,
+      data,
+      {
+        headers: {
+          'Content-Type': 'multipart/form-data',
+        },
+      },
+    );
+    return res.data;
+  }
+
+  async sendPassportData({ citizenship, operationId, formData }: any) {
+    const url = WEBSITE_IDENTITY_PASSPORT.replace('{citizenship}', citizenship).replace(
+      '{operationId}',
+      operationId,
+    );
+    const res = await this.unAuthAxios().post(this.endpointUrl(url), formData);
+    return res.data;
+  }
+
+  async sendIdCardData({ citizenship, operationId, formData }: any) {
+    const url = WEBSITE_IDENTITY_ID_CARD.replace('{citizenship}', citizenship).replace(
+      '{operationId}',
+      operationId,
+    );
+    const res = await this.unAuthAxios().post(this.endpointUrl(url), formData);
+    return res.data;
+  }
+
+  async sendOtherDocumentData({ operationId, formData }: any) {
+    const url = WEBSITE_IDENTITY_OTHER_DOCUMENT.replace('{operationId}', operationId);
+    const res = await this.unAuthAxios().post(this.endpointUrl(url), formData);
+    return res.data;
+  }
+
+  async sendCdekIdData({
+    citizenship = 'ru',
+    operationId,
+    formData,
+  }: {
+    citizenship: string;
+    operationId: string;
+    formData: { personUuid: string; wantCdekId: boolean };
+  }): Promise<{ success: true; code: number; error: any; data: { created: boolean } | null }> {
+    const url = WEBSITE_IDENTITY_CDEK_ID.replace('{citizenship}', citizenship).replace(
+      '{operationId}',
+      operationId,
+    );
+    const res = await this.unAuthAxios().post(this.endpointUrl(url), formData);
+    return res.data;
+  }
+
+  async websiteSitemap(locale: string) {
+    const url = WEBSITE_SITEMAP.replace('{locale}', locale);
+
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data.data;
+  }
+
+  async sendPackageForm(data: unknown) {
+    const res = await this.unAuthAxios().post(
+      this.endpointUrl(WEBSITE_NOTIFICATION_PACKAGE_ORDER),
+      data,
+    );
+    return res.data;
+  }
+
+  async getFrozenLoyaltyPoints(user_uuid: string) {
+    const url = WEBSITE_FREEZED_LOYALTY_POINTS.replace('{user_uuid}', user_uuid);
+    const res = await this.unAuthAxios().post(this.endpointUrl(url));
+    return res.data;
+  }
+
+  async ratingProductAdd(
+    rating: number,
+    comment: string,
+    user_uuid: string | null,
+    phone: string | null,
+  ) {
+    const res = await this.unAuthAxios().post(this.endpointUrl(WEBSITE_RATING_PRODUCT_ADD), {
+      rating,
+      comment,
+      user_uuid,
+      phone,
+    });
+    return res.data;
+  }
+
+  async agreementOnlineFnsCard(inn: string, data: DefaultRequestData): Promise<FnsCard> {
+    const url = WEBSITE_AGREEMENT_ONLINE_FNS_CARD.replace('{inn}', inn).replace(
+      '{locale}',
+      data.locale,
+    );
+
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+
+    return res.data.data;
+  }
+
+  async websiteAgreementJoin(data: JoinCompanyRequest, { locale }: DefaultRequestData) {
+    const url = WEBSITE_AGREEMENT_ONLINE_JOIN.replace('{locale}', locale);
+
+    const res = await this.unAuthAxios().post(this.endpointUrl(url), data);
+
+    return res.data.data;
+  }
+
+  async websiteOrderCheck(order: number) {
+    const url = WEBSITE_ORDER_CHECK.replace('{order}', `${order}`);
+
+    return this.unAuthAxios().post(this.endpointUrl(url));
+  }
+
+  async websiteCityByCoords(
+    position: GeolocationCoordinates,
+    locale: string,
+  ): Promise<CityAutocomplete> {
+    const url = WEBSITE_CITY_BY_COORDS.replace('{locale}', locale)
+      .replace(`{latitude}`, `${position.latitude}`)
+      .replace(`{longitude}`, `${position.longitude}`);
+
+    return (await this.unAuthAxios().get(this.endpointUrl(url))).data.data;
+  }
+
+  async websiteAgreementConclusion(
+    data: ConclusionRequest,
+    { locale }: DefaultRequestData,
+  ): Promise<ContragentInformation> {
+    let url = WEBSITE_AGREEMENT_ONLINE_CONCLUSION.replace('{locale}', locale)
+      .replace('{inn}', data.inn)
+      .replace('{cityUuid}', data.cityUuid);
+
+    if (data.kpp) {
+      url = `${url}&kpp=${data.kpp}`;
+    }
+
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+
+    return res.data.data;
+  }
+
+  async websiteAgreementByRequisites(inn: string): Promise<{ contractUuid: string }> {
+    const url = WEBSITE_AGREEMENT_ONLINE_BY_REQUISTIES.replace('{inn}', inn);
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data.data;
+  }
+
+  async websiteAgreementContract(locale: string, body: unknown): Promise<{ contractUuid: string }> {
+    const url = WEBSITE_AGREEMENT_ONLINE_CONTRACT.replace('{locale}', locale);
+    const res = await this.unAuthAxios().post(this.endpointUrl(url), body);
+    return res.data.data;
+  }
+
+  async websiteAgreementSelfcare(
+    data: ContragentInformation,
+    { locale }: DefaultRequestData,
+  ): Promise<SelfcareResponse> {
+    let url = WEBSITE_AGREEMENT_ONLINE_SELFCARE.replace('{locale}', locale);
+
+    if (data.contractUuid) {
+      url = `${url}&contractUuid=${data.contractUuid}`;
+    }
+
+    if (data.contragentUuid) {
+      url = `${url}&contragentUuid=${data.contragentUuid}`;
+    }
+
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+
+    return res.data.data;
+  }
+
+  async websiteAgreementCreateNew(data: BaseCreationRequest, locales: DefaultRequestData) {
+    const url = WEBSITE_AGREEMENT_ONLINE_CREATE_NEW.replace('{locale}', locales.locale);
+
+    const res = await this.unAuthAxios().post(this.endpointUrl(url), data);
+
+    return res.data.data;
+  }
+
+  async websiteAgreementCreateExist(data: ExistsCreationRequest, { locale }: DefaultRequestData) {
+    const url = WEBSITE_AGREEMENT_ONLINE_CREATE_EXIST.replace('{locale}', locale);
+
+    const res = await this.unAuthAxios().post(this.endpointUrl(url), data);
+
+    return res.data.data;
+  }
+
+  async websiteCity(
+    data: CdekCityRequest,
+    { locale }: DefaultRequestData,
+  ): Promise<CdekFullCity[]> {
+    let url = WEBSITE_CITY.replace('{locale}', locale);
+
+    Object.entries(data).forEach(([key, value]) => {
+      url = `${url}&${key}=${value}`;
+    });
+
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+
+    return res.data.data.data;
+  }
+
+  async websiteFaq(locale: string, withFooter = false): Promise<IWebsiteFaqData> {
+    const url = WEBSITE_FAQ.replace('{locale}', locale).replace(`{withFooter}`, `${withFooter}`);
+
+    return (await this.unAuthAxios().get(this.endpointUrl(url))).data.data;
+  }
+
+  async websitePage(url: string, locale: string): Promise<IWebsitePageData> {
+    const requestUrl = WEBSITE_PAGE.replace('{locale}', locale).replace(
+      `{url}`,
+      `${removeSideSlashes(url)}/`,
+    );
+
+    const res = await this.unAuthCachedGet(requestUrl);
+
+    return res.data.data;
+  }
+
+  async websitePaymentAuthCodeVerify(
+    params: IPaymentVerifyParams,
+  ): Promise<IPaymentVerifyResponse> {
+    const res = await this.unAuthAxios().post(
+      this.endpointUrl(WEBSITE_PAYMENT_AUTH_CODE_VERIFY),
+      params,
+    );
+
+    return res.data.data;
+  }
+
+  async yandexGeoSuggest(text: string, locale = 'ru'): Promise<string[]> {
+    const url = OTHER_YANDEX_GEO_SUGGEST.replace('{text}', text).replace('{locale}', locale);
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+
+    return res.data.data;
+  }
+
+  async getServices(data: IServicesRequest): Promise<IServicesResponse> {
+    const res = await this.unAuthAxios().post(this.endpointUrl(CALCULATOR_SERVICES), data);
+
+    return res.data.data;
+  }
+
+  async calculate(data: ICalculateRequest): Promise<ICalculateResponse> {
+    const res = await this.unAuthAxios().post(this.endpointUrl(CALCULATOR_CALCULATE), data);
+
+    return res.data.data;
+  }
+
+  async createBusinessForm(data: FormData): Promise<any> {
+    const res = await this.unAuthAxios().post(
+      this.endpointUrl(WEBSITE_DOGOVOR_CREATE_BUSINESS_FORM),
+      data,
+      {
+        headers: {
+          'Content-Type': 'multipart/form-data',
+        },
+      },
+    );
+
+    return res.data.data;
+  }
+
+  async customerGetLink(number: string, id: string, locale = 'ru'): Promise<string> {
+    const url = CUSTOMER_GET_LINK.replace('{locale}', locale)
+      .replace('{number}', number)
+      .replace('{id}', id);
+    const res = await this.unAuthAxios().get(this.endpointUrl(url));
+    return res.data?.data || '';
+  }
+}
diff --git a/parent_dir/src/assets/img/close.svgurl b/parent_dir/src/assets/img/close.svgurl
new file mode 100644
index 0000000..5abf7c0
--- /dev/null
+++ b/parent_dir/src/assets/img/close.svgurl
@@ -0,0 +1 @@
+export default "__VITE_ASSET__aaabd9ba__"
\ No newline at end of file
diff --git a/parent_dir/src/components/Auth/CdekAuth.vue b/parent_dir/src/components/Auth/CdekAuth.vue
new file mode 100644
index 0000000..0efbe51
--- /dev/null
+++ b/parent_dir/src/components/Auth/CdekAuth.vue
@@ -0,0 +1,197 @@
+<template>
+  <div class="cdek-auth">
+    <div v-if="isLoading" class="cdek-auth__loader">
+      <base-loader big :old="false" />
+    </div>
+    <div v-show="!isLoading" id="__cdek-auth" />
+  </div>
+</template>
+
+<script>
+/* global CdekAuth */
+import { mapGetters, mapMutations } from 'vuex';
+import { reachGoal } from '@/utils/reach-goal';
+import BaseLoader from '@/components/BaseLoader.vue';
+import { castEnv } from '@/utils/env-utils';
+import { useRedirect } from '@/components/Login/use-redirect';
+import useSiteInfo from '@/composables/use-site-info';
+
+export default {
+  name: 'CdekAuth',
+  components: { BaseLoader },
+  props: {
+    notificationText: {
+      type: String,
+      default: '',
+    },
+    /**
+     * @param {string} title
+     * @param {string} url
+     * @param {string} target
+     */
+    alert: {
+      type: Object,
+      default: null,
+    },
+    allowLogin: {
+      type: Boolean,
+      default: true,
+    },
+    isRedirect: {
+      type: Boolean,
+      default: false,
+    },
+    legalOnly: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  emits: ['success'],
+  setup() {
+    const { currentLocale, isRuSite } = useSiteInfo();
+
+    return { currentLocale, handleCabinetRedirect: useRedirect(), isRuSite };
+  },
+  data() {
+    return {
+      isLoading: typeof CdekAuth === 'undefined',
+      captchaKey: import.meta.env.VITE_CAPTCHA_KEY_PUBLIC,
+      scriptUrl: import.meta.env.VITE_CDEK_AUTH_SCRIPT_URL,
+      httpEndpoint: import.meta.env.VITE_HTTP_ENDPOINT || window.location.origin,
+      isRedirectEnabled: castEnv(import.meta.env.VITE_CDEK_AUTH_REDIRECT_ENABLED, false),
+      testRedirect: import.meta.env.VITE_CDEK_AUTH_TEST_REDIRECT,
+      availableCodes: import.meta.env.VITE_CDEK_AUTH_AVAILABLE_CODES || ['ru', 'kz', 'by'],
+    };
+  },
+  computed: {
+    ...mapGetters({
+      websiteId: 'websiteId',
+    }),
+  },
+  mounted() {
+    this.init();
+  },
+  methods: {
+    ...mapMutations({
+      setKeycloak: 'keycloak/setKeycloak',
+    }),
+    loadScript() {
+      const params = {
+        async: true,
+        src: this.scriptUrl,
+        onload: () => {
+          this.init();
+        },
+      };
+      const script = Object.assign(document.createElement('script'), params);
+      document.body.appendChild(script);
+    },
+    init() {
+      if (typeof CdekAuth === 'undefined') {
+        this.loadScript();
+        return;
+      }
+
+      this.isLoading = false;
+
+      const o = CdekAuth({
+        id: '#__cdek-auth',
+        locale: this.currentLocale,
+        websiteId: this.websiteId,
+        urlLegalEntitiesLk: import.meta.env.VITE_LKUL_URL || 'https://lk.cdek.ru/',
+        httpEndpoint: this.httpEndpoint,
+        captchaKeyPublic: this.captchaKey,
+        allowLogin: this.allowLogin,
+        yandexMetrikaId: import.meta.env.VITE_YANDEX_METRIKA_ID || null,
+        allowLegalLogin: this.isRuSite,
+        legalOnly: this.legalOnly,
+      });
+
+      if (this.notificationText) {
+        o.setNotification(this.notificationText);
+      }
+
+      if (this.alert) {
+        o.setAlert(this.alert);
+      }
+
+      const urlParams = new URLSearchParams(window.location.search);
+      const phone = urlParams.get('phone');
+      const token = urlParams.get('token');
+
+      if (phone && phone.match(/^\+?([\d]{11,12})$/)) {
+        o.setPhone(phone, false, true);
+      }
+
+      if (token) {
+        o.setCodeToken(token);
+      }
+
+      if (this.isRedirectEnabled) {
+        o.onRedirect((data) => {
+          let redirectTo = data.redirectUrl;
+
+          // Дл� те�товых �ред
+          if (this.testRedirect === 'origin') {
+            redirectTo = window.location.origin;
+          } else if (this.testRedirect) {
+            redirectTo = this.testRedirect;
+          }
+
+          const url = new URL('/cabinet/auth', redirectTo);
+          url.searchParams.set('phone', data.phone);
+          url.searchParams.set('token', data.token);
+
+          window.location.replace(url);
+        }).stopIfRedirect();
+      }
+
+      if (this.availableCodes && o.setAvailableCountryCodes) {
+        o.setAvailableCountryCodes(this.availableCodes);
+      }
+
+      o.onAuth(this.onSuccess).mount();
+    },
+    async onSuccess(data, phone) {
+      const { mindbox } = window;
+
+      if (mindbox) {
+        //  Ку�ок кода из задачи
+        mindbox('async', {
+          operation: 'Website.AuthenticatedOnWebsite',
+          data: { customer: { mobilePhone: phone } },
+        });
+      }
+
+      await this.storeInitAuth(data, phone);
+      this.$emit('success');
+
+      reachGoal('vhod v lk phiz l');
+
+      if (this.isRedirect) {
+        setTimeout(() => this.handleCabinetRedirect(), 100);
+      }
+    },
+    /**
+     * @param {KeycloakResponse} data
+     *
+     * @returns {Promise}
+     */
+    storeInitAuth(data) {
+      return new Promise((resolve) => {
+        this.setKeycloak(data);
+
+        resolve();
+      });
+    },
+  },
+};
+</script>
+
+<style lang="scss" scoped>
+.cdek-auth {
+  &__loader {
+    text-align: center;
+  }
+}
+</style>
diff --git a/parent_dir/src/components/BaseComponents/BaseButton.vue b/parent_dir/src/components/BaseComponents/BaseButton.vue
new file mode 100644
index 0000000..e2d4243
--- /dev/null
+++ b/parent_dir/src/components/BaseComponents/BaseButton.vue
@@ -0,0 +1,181 @@
+<script>
+import { h, defineComponent, computed } from 'vue';
+import BaseLoader from '@/components/BaseComponents/BaseLoader.vue';
+import IconArrow from '@/components/icon-svg/IconArrow.vue';
+
+export default defineComponent({
+  name: 'BaseButton',
+  props: {
+    tag: {
+      type: String,
+      default() {
+        return 'button';
+      },
+    },
+    href: {
+      type: String,
+      default: '',
+    },
+    type: {
+      type: String,
+      default() {
+        return 'button';
+      },
+    },
+    level: {
+      type: [Number, String],
+      default() {
+        return 0;
+      },
+    },
+    primary: {
+      type: Boolean,
+      default: false,
+    },
+    secondary: {
+      type: Boolean,
+      default: false,
+    },
+    loading: {
+      type: Boolean,
+      default: false,
+    },
+    tertiary: {
+      type: Boolean,
+      default: false,
+    },
+    quaternary: {
+      type: Boolean,
+      default: false,
+    },
+    sm: {
+      type: Boolean,
+      default: false,
+    },
+    lg: {
+      type: Boolean,
+      default: false,
+    },
+    round: {
+      type: Boolean,
+      default: true,
+    },
+    roundCircle: {
+      type: Boolean,
+      default: false,
+    },
+    icon: {
+      type: Boolean,
+      default: false,
+    },
+    default: {
+      type: Boolean,
+      default: false,
+    },
+    outline: {
+      type: Boolean,
+      default: false,
+    },
+    grey: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  setup(props, { slots }) {
+    const level = computed(() => parseInt(props.level, 10));
+
+    const levels = computed(() => {
+      return {
+        primary: level.value === 1 || props.primary,
+        secondary: level.value === 2 || props.secondary,
+        tertiary: level.value === 3 || props.tertiary,
+        quaternary: level.value === 4 || props.quaternary,
+      };
+    });
+
+    const outline = computed(() => {
+      const res = {};
+      if (props.outline) {
+        for (const levelsKey in levels.value) {
+          if (levels.value[levelsKey]) {
+            res[`base-button--${levelsKey}-outline`] = true;
+          }
+        }
+      }
+
+      return res;
+    });
+
+    const classes = computed(() => {
+      return {
+        'base-button': true,
+        'base-button--loading': props.loading,
+        'base-button--sm': props.sm,
+        'base-button--lg': props.lg,
+        'base-button--primary': levels.value.primary,
+        'base-button--secondary': levels.value.secondary,
+        'base-button--tertiary': levels.value.tertiary,
+        'base-button--quaternary': levels.value.quaternary,
+        'base-button--round': props.round,
+        'base-button--round-circle': props.roundCircle,
+        'base-button--default': props.default,
+        'base-button--icon': props.icon,
+        'base-button--grey': props.grey,
+        ...outline.value,
+      };
+    });
+
+    const attrs = computed(() => {
+      const res = {
+        type: props.tag !== 'a' && props.type,
+        disabled: props.loading,
+      };
+      if (props.href) {
+        res.href = props.href;
+      }
+
+      return res;
+    });
+
+    const buttonLoader = h('div', { class: 'base-button__loader' }, [
+      h(BaseLoader, {
+        old: false,
+        primary: levels.value.primary,
+        secondary: levels.value.secondary || levels.value.tertiary || levels.value.quaternary,
+      }),
+    ]);
+    const transition = h('transition', { name: 'base-button__fade' }, [buttonLoader]);
+    const arrow = h('div', { class: 'base-button__icon' }, [
+      h(IconArrow, {
+        direction: 'right',
+        width: 6,
+        height: 10,
+      }),
+    ]);
+    const render = () => {
+      const children = slots?.default ? [slots.default()] : [];
+      if (props.loading) {
+        children.push(transition);
+      }
+
+      if (props.quaternary) {
+        children.push(arrow);
+      }
+      return h(
+        props.tag,
+        {
+          class: classes.value,
+          ...attrs.value,
+        },
+        children,
+      );
+    };
+
+    return { arrow, classes, transition, attrs, slots, render };
+  },
+
+  render() {
+    return this.render();
+  },
+});
+</script>
diff --git a/parent_dir/src/components/BaseComponents/BaseCdekModal.vue b/parent_dir/src/components/BaseComponents/BaseCdekModal.vue
new file mode 100644
index 0000000..6825b78
--- /dev/null
+++ b/parent_dir/src/components/BaseComponents/BaseCdekModal.vue
@@ -0,0 +1,86 @@
+<template>
+  <vue-final-modal class="base-cdek-modal" :name="name">
+    <div class="base-cdek-modal__container">
+      <mobile-close-line class="base-cdek-modal__mobile-controls" @swipe-down="close" />
+
+      <button type="button" class="base-cdek-modal__icon-close" @click="close">
+        <icon-close :stroke="'#ADAFB4'" />
+      </button>
+
+      <div class="base-cdek-modal__content">
+        <slot />
+      </div>
+    </div>
+  </vue-final-modal>
+</template>
+
+<script setup lang="ts">
+import MobileCloseLine from '@/components/MobileCloseLine/MobileCloseLine.vue';
+import IconClose from '@/components/icon-svg/IconCloseV2.vue';
+
+interface IBaseCdekModalProps {
+  name: string;
+}
+
+defineProps<IBaseCdekModalProps>();
+
+const emit = defineEmits<{
+  (e: 'close'): void;
+}>();
+
+const close = () => {
+  emit('close');
+};
+</script>
+
+<style scoped lang="scss">
+.base-cdek-modal {
+  &__container {
+    position: fixed;
+    bottom: 0;
+    background: $Peak;
+    left: 0;
+    right: 0;
+    border-radius: 10px 10px 0 0;
+
+    @include media-min-sm {
+      border-radius: 16px;
+      box-shadow: 0 20px 40px -5px rgba(0, 0, 0, 0.2);
+      top: 50%;
+      left: 50%;
+      bottom: unset;
+      transform: translate(-50%, -50%);
+      width: 384px;
+    }
+  }
+
+  &__mobile-controls {
+    height: 28px;
+
+    @include media-min-sm {
+      display: none;
+    }
+  }
+
+  &__content {
+    padding-left: 16px;
+    padding-right: 16px;
+    padding-bottom: 16px;
+
+    @include media-min-sm {
+      padding: 32px;
+    }
+  }
+
+  &__icon-close {
+    display: none;
+    position: absolute;
+    top: 15px;
+    right: 16px;
+
+    @include media-min-sm {
+      display: block;
+    }
+  }
+}
+</style>
diff --git a/parent_dir/src/components/BaseComponents/BaseContainer.vue b/parent_dir/src/components/BaseComponents/BaseContainer.vue
new file mode 100644
index 0000000..eae73ab
--- /dev/null
+++ b/parent_dir/src/components/BaseComponents/BaseContainer.vue
@@ -0,0 +1,70 @@
+<template>
+  <component
+    :is="tagToUse"
+    class="base-container"
+    :class="{
+      'base-container--without-padding': props.withoutPadding,
+      'base-container--fluid': props.fluid,
+    }"
+  >
+    <slot />
+  </component>
+</template>
+
+<script lang="ts" setup>
+import { computed } from 'vue';
+
+const props = defineProps({
+  tag: {
+    type: String,
+    default: 'div',
+  },
+  withoutPadding: {
+    type: Boolean,
+  },
+  fluid: {
+    type: Boolean,
+  },
+});
+
+const tagToUse = computed(() => {
+  return props.tag || 'div';
+});
+</script>
+
+<style lang="scss">
+.base-container {
+  padding: 0 10px;
+  transition: $primary-transition;
+
+  &.base-container--without-padding {
+    padding: 0;
+
+    @media (min-width: $tablet) {
+      padding: 0;
+    }
+  }
+
+  &.base-container--fluid {
+    max-width: 100%;
+
+    @media (min-width: $desktop) {
+      max-width: 100%;
+    }
+  }
+
+  @media (min-width: $tablet) {
+    padding: 0 20px;
+  }
+
+  @media (min-width: $desktop) {
+    max-width: 1200px;
+    margin-right: auto;
+    margin-left: auto;
+  }
+
+  @media (min-width: $desktop-l) {
+    padding: 0;
+  }
+}
+</style>
diff --git a/parent_dir/src/components/BaseComponents/BaseFlex.vue b/parent_dir/src/components/BaseComponents/BaseFlex.vue
new file mode 100644
index 0000000..0b8dcdd
--- /dev/null
+++ b/parent_dir/src/components/BaseComponents/BaseFlex.vue
@@ -0,0 +1,41 @@
+<template>
+  <component :is="tagToUse" class="base-flex" :class="classes"> <slot /></component>
+</template>
+<script setup lang="ts">
+import { computed } from 'vue';
+
+const props = defineProps({
+  tag: {
+    type: String,
+    default: 'div',
+  },
+  dFlex: {
+    type: Boolean,
+    default: false,
+  },
+});
+
+const tagToUse = computed(() => {
+  return props.tag || 'div';
+});
+
+const classes = computed(() => {
+  const classArray: string[] = [];
+
+  if (props.dFlex) {
+    classArray.push('base-d-flex');
+  }
+
+  return classArray;
+});
+</script>
+
+<style lang="scss">
+.base-flex {
+  flex: 1 1 auto;
+}
+
+.base-d-flex {
+  display: flex;
+}
+</style>
diff --git a/parent_dir/src/components/BaseComponents/BaseInput.vue b/parent_dir/src/components/BaseComponents/BaseInput.vue
new file mode 100644
index 0000000..cb259c3
--- /dev/null
+++ b/parent_dir/src/components/BaseComponents/BaseInput.vue
@@ -0,0 +1,528 @@
+<script>
+import {
+  unref,
+  h,
+  defineComponent,
+  ref,
+  onMounted,
+  onUnmounted,
+  computed,
+  nextTick,
+  toRefs,
+  watch,
+} from 'vue';
+import random from 'lodash/random';
+import IconClose from '@/components/icon-svg/IconClose.vue';
+import BaseLoader from '@/components/BaseComponents/BaseLoader.vue';
+import { isAppleDevice } from '@/utils/bowser';
+import useBaseField from '@/composables/use-base-field';
+import baseFieldMixin from './mixins/base-field.mixin';
+
+export default defineComponent({
+  name: 'BaseInput',
+  mixins: [baseFieldMixin],
+  props: {
+    light: {
+      type: Boolean,
+      default: false,
+    },
+    type: {
+      type: String,
+      default() {
+        return 'text';
+      },
+    },
+    role: {
+      type: String,
+      default() {
+        return 'none';
+      },
+    },
+    step: {
+      type: String,
+      default: '1',
+    },
+    autocomplete: { type: String, default: '' },
+    min: { type: String, default: '' },
+    max: { type: String, default: '' },
+    mask: {
+      type: [String, Object],
+      default: null,
+    },
+    fullHeight: {
+      type: Boolean,
+      default() {
+        return false;
+      },
+    },
+    errorMessageFixed: {
+      type: Boolean,
+      default() {
+        return false;
+      },
+    },
+    iconLeft: {
+      type: Boolean,
+      default: false,
+    },
+    iconRight: {
+      type: Boolean,
+      default: false,
+    },
+    loading: {
+      type: Boolean,
+      default: false,
+    },
+    decimal: {
+      type: Boolean,
+      default: false,
+    },
+    checked: {
+      type: Boolean,
+      default: false,
+    },
+    isDisabledTrim: {
+      type: Boolean,
+    },
+  },
+  emits: [
+    'focus',
+    'blur',
+    'change',
+    'input',
+    'keydownDown',
+    'keydownUp',
+    'keydownEnter',
+    'keydown',
+    'clear',
+    'update:modelValue',
+  ],
+  setup(props, { emit, attrs, slots }) {
+    const { modelValue } = toRefs(props);
+
+    const field = ref(null);
+
+    const {
+      baseClassName,
+      rootClasses,
+      fieldAttrs,
+      hasSlotIcon,
+      groutClasses,
+      getPlaceholder,
+      getError,
+      getAdditionalInfo,
+      focused,
+      isIOs,
+      focus,
+    } = useBaseField(props, { slots }, field);
+
+    const ellipsis = ref(true);
+    const inputMask = ref(null);
+    const inputMaskElement = ref(null);
+    const randomValue = ref(`form_random-${random(-1000, 1000)}-${random(-1000, 1000)}`);
+
+    const setEllipsis = (value) => {
+      if (!props.readonly) {
+        ellipsis.value = value;
+      }
+    };
+
+    const destroyMask = () => {
+      unref(inputMaskElement) && unref(inputMaskElement).remove();
+      inputMaskElement.value = null;
+    };
+
+    const initMask = () => {
+      if (unref(inputMask)) {
+        inputMaskElement.value = unref(inputMask).mask(field.value);
+      }
+    };
+
+    onMounted(() => {
+      if (props.mask) {
+        import('inputmask').then((Inputmask) => {
+          inputMask.value = new Inputmask.default(props.mask);
+          inputMask.value.opacity = {
+            onBeforePaste: (pastedValue) => {
+              const newTel = pastedValue.replace(/^(\+7|8)(.*?)$/g, '$2');
+              return newTel;
+            },
+            showMaskOnHover: false,
+          };
+
+          initMask();
+        });
+      }
+
+      isIOs.value = isAppleDevice();
+      ellipsis.value = !unref(isIOs);
+    });
+
+    onUnmounted(() => {
+      inputMask.value = null;
+      if (unref(inputMaskElement)) {
+        destroyMask();
+      }
+    });
+
+    const inputListeners = computed(() => {
+      return {
+        onFocus(event) {
+          initMask();
+          if (unref(isIOs)) {
+            setEllipsis(false);
+          }
+          focused.value = true;
+          emit('focus', event);
+        },
+        onBlur(event) {
+          // If mask plugin is applied and input.value is empty string, placeholder remains visible
+          // Force setting input.value to null resolves issue
+          if (props.mask && event.target.value.length === 0) {
+            event.target.value = null;
+          }
+          if (!unref(isIOs)) {
+            setEllipsis(true);
+          }
+          focused.value = false;
+          emit('blur', event);
+
+          // Почему-то библиотека inputMask не триггерит ивент onchange, колхоз
+          if (props.mask) {
+            emit('change', event.target.value, event);
+          }
+
+          destroyMask();
+        },
+        onInput(event) {
+          let value = event.target.value;
+
+          if (!props.isDisabledTrim) {
+            value = value.trim();
+          }
+
+          if (props.type === 'number') {
+            value = value.replace(/\+|-/gi, '');
+          }
+
+          emit('update:modelValue', value, event);
+          emit('input', value, event);
+        },
+        onKeydown(event) {
+          if (props.type === 'number') {
+            const { key } = event;
+
+            if (key === '+' || key === '-') {
+              event.preventDefault();
+            }
+
+            if (props.decimal && (key === '.' || key === ',')) {
+              event.preventDefault();
+            }
+          }
+
+          if (event.keyCode === 40) {
+            emit('keydownDown', event);
+          }
+          if (event.keyCode === 38) {
+            emit('keydownUp', event);
+          }
+          if (event.keyCode === 13) {
+            emit('keydownEnter', event);
+          }
+          if (event.keyCode === 27) {
+            emit('keydownEnter', event);
+          }
+          emit('keydown', event);
+        },
+        onChange(event) {
+          let value = event.target.value;
+
+          if (!props.isDisabledTrim) {
+            value = value.trim();
+          }
+
+          if (props.type === 'number') {
+            value = value.replace(/\+|-/gi, '');
+          }
+
+          emit('change', value);
+        },
+      };
+    });
+
+    const inputAttrs = computed(() => {
+      const attributs = {
+        type: props.type,
+        autocomplete: 'off',
+        autocorrect: 'off',
+        autocapitalize: 'off',
+        role: props.role,
+        ...attrs,
+      };
+
+      if (props.type === 'password') {
+        attributs.autocomplete = 'new-password';
+      }
+
+      if (
+        typeof window !== 'undefined' &&
+        typeof window.navigator !== 'undefined' &&
+        !attributs.autocomplete
+      ) {
+        const isChrome =
+          /Chrome/.test(window.navigator.userAgent) && /Google Inc/.test(window.navigator.vendor);
+        attributs.autocomplete = isChrome ? props.random : 'off';
+      }
+
+      if (props.type === 'number') {
+        attributs.step = props.step;
+
+        if (props.min) {
+          attributs.min = props.min;
+        }
+
+        if (props.max) {
+          attributs.max = props.max;
+        }
+      }
+
+      if (unref(ellipsis) && !props.old) {
+        attributs.readonly = props.readonly;
+      }
+
+      if (props.old) {
+        attributs.readonly = props.readonly;
+      }
+      return {
+        ...fieldAttrs.value,
+        ...attributs,
+      };
+    });
+
+    const containerGroutClasses = computed(() => {
+      let directionIcon = '';
+      let displayRightIcon = false;
+
+      if (unref(hasSlotIcon)) {
+        if (props.iconLeft && !props.iconRight) {
+          directionIcon = 'left';
+        } else if (
+          (!props.iconLeft && props.iconRight) ||
+          (props.iconLeft && props.iconRight) ||
+          (!props.iconLeft && !props.iconRight)
+        ) {
+          directionIcon = 'right';
+        }
+      }
+      if (directionIcon !== 'right' && props.clearButton) {
+        displayRightIcon = true;
+      }
+      return {
+        ...unref(groutClasses),
+        [`${unref(baseClassName)}__group--left-icon`]: directionIcon === 'left',
+        [`${unref(baseClassName)}__group--right-icon`]:
+          directionIcon === 'right' || displayRightIcon,
+      };
+    });
+
+    const rootConf = computed(() => {
+      let classes = {
+        ...unref(rootClasses),
+      };
+      if (!props.old) {
+        classes = {
+          ...classes,
+          [`${unref(baseClassName)}--readonly`]: props.readonly,
+          [`${unref(baseClassName)}--ios`]: unref(isIOs),
+        };
+      }
+      return {
+        class: classes,
+      };
+    });
+
+    const inputConf = computed(() => {
+      return {
+        ...unref(inputAttrs),
+        ...unref(inputListeners),
+        value: modelValue.value,
+        ref: 'field',
+        class: {
+          [`${unref(baseClassName)}__field`]: true,
+        },
+      };
+    });
+
+    // ...methods
+
+    const onClear = () => {
+      if (props.readonly || props.disabled) return;
+
+      setTimeout(() => {
+        emit('update:modelValue', '');
+        emit('clear', '');
+        emit('input', '');
+        emit('change');
+        destroyMask();
+      });
+    };
+
+    const getButtonIcon = () => {
+      const hasClearButton =
+        props.modelValue &&
+        props.clearButton &&
+        !props.loading &&
+        !props.disabled &&
+        (!unref(hasSlotIcon) || !props.iconRight || (!props.iconLeft && !props.iconRight));
+
+      const clearButton = hasClearButton
+        ? [
+            h(
+              'div',
+              {
+                class: {
+                  [`${unref(baseClassName)}__icon`]: true,
+                  [`${unref(baseClassName)}__icon--right`]: true,
+                },
+              },
+              [
+                h(
+                  'button',
+                  {
+                    class: {
+                      'base-icon-button': true,
+                    },
+                    type: 'button',
+                    tabIndex: -1,
+                    onClick: onClear,
+                  },
+                  [
+                    h(IconClose, {
+                      fill: props.hasError && !unref(focused) ? '#FA4747' : '#B0B0B0',
+                      height: 10,
+                      width: 10,
+                    }),
+                  ],
+                ),
+              ],
+            ),
+          ]
+        : [];
+
+      const loading = props.loading
+        ? [
+            h(
+              'div',
+              {
+                class: {
+                  [`${unref(baseClassName)}__icon`]: true,
+                  [`${unref(baseClassName)}__icon--right`]: true,
+                },
+              },
+              [
+                h(BaseLoader, {
+                  old: false,
+                }),
+              ],
+            ),
+          ]
+        : [];
+
+      return unref(hasSlotIcon) &&
+        ((props.iconRight && !props.loading) ||
+          props.iconLeft ||
+          (!props.iconRight && !props.iconLeft))
+        ? [
+            h(
+              'div',
+              {
+                class: {
+                  [`${unref(baseClassName)}__icon`]: true,
+                  [`${unref(baseClassName)}__icon--right`]: props.iconRight,
+                  [`${unref(baseClassName)}__icon--left`]: props.iconLeft,
+                },
+              },
+              [slots.icon()],
+            ),
+            ...clearButton,
+            ...loading,
+          ]
+        : [...clearButton, ...loading];
+    };
+    watch(
+      () => props.mask,
+      () => {
+        if (props.mask && !inputMask.value) {
+          import('inputmask').then((Inputmask) => {
+            inputMask.value = new Inputmask.default(props.mask, { showMaskOnHover: false });
+            initMask();
+          });
+        }
+      },
+    );
+    /**
+     * Публичный метод для ручного вызова фокуса на поле
+     */
+    const render = () => {
+      const inputElement = h('input', inputConf.value);
+      // Render еще не отработал, El еще не существет.
+      nextTick(() => {
+        field.value = inputElement.el;
+      });
+
+      const buttonElement = getButtonIcon();
+
+      const placeholderElement = getPlaceholder();
+      const containerGroutChildren = [inputElement]
+        .concat(buttonElement)
+        .concat(placeholderElement);
+
+      const containerGroutConfig = {
+        class: containerGroutClasses.value,
+      };
+      const containerGrout = h('div', containerGroutConfig, containerGroutChildren);
+
+      const errorElement = getError();
+
+      const additionalInfo = getAdditionalInfo();
+
+      return h('div', rootConf.value, [containerGrout].concat(errorElement).concat(additionalInfo));
+    };
+
+    return {
+      render,
+      isIOs,
+      ellipsis,
+      inputMask,
+      inputMaskElement,
+      randomValue,
+      inputListeners,
+      inputAttrs,
+      containerGroutClasses,
+      rootConf,
+      inputConf,
+      initMask,
+      destroyMask,
+      onClear,
+      getButtonIcon,
+      setEllipsis,
+      focus,
+    };
+  },
+  render() {
+    return this.render();
+  },
+});
+</script>
+
+<style lang="scss" scoped>
+input[type='tel']::placeholder {
+  opacity: 0;
+  transition: opacity 0.3s ease;
+
+  &:focus {
+    opacity: 1;
+  }
+}
+</style>
diff --git a/parent_dir/src/components/BaseComponents/BaseLink.vue b/parent_dir/src/components/BaseComponents/BaseLink.vue
new file mode 100644
index 0000000..1487c18
--- /dev/null
+++ b/parent_dir/src/components/BaseComponents/BaseLink.vue
@@ -0,0 +1,63 @@
+<script lang="ts">
+import { ComponentOptionsBase, h } from 'vue';
+import { setLocaleToLink } from '@/utils/set-locale-to-link';
+
+const BaseLink: ComponentOptionsBase<any, any, any, any, any, any, any, any> = {
+  name: 'BaseLink',
+  props: {
+    tag: {
+      type: String,
+      default: 'a',
+    },
+    img: { type: String, default: '' },
+    href: {
+      type: [String, Object],
+      default: undefined,
+    },
+    target: {
+      type: String,
+      default: '',
+    },
+  },
+  computed: {
+    isSite(): boolean {
+      return !!this.$store.getters.isSite;
+    },
+  },
+  render() {
+    let newProps = {};
+    let children: ReturnType<typeof h>[] = [];
+
+    if (this.img) {
+      children = [
+        h('img', {
+          class: {
+            'base-link__image': true,
+          },
+          src: this.img,
+        }),
+      ];
+    }
+
+    const { href } = this;
+
+    newProps = {
+      ...this.$attrs,
+      href: setLocaleToLink(href, this.$store.getters.currentLocaleISO, this.isSite),
+      target: this.target,
+    };
+    return h(h(this.tag || 'a', newProps), [...children, this.$slots.default()]);
+  },
+};
+
+export default BaseLink;
+</script>
+<style lang="scss">
+.base-link__image {
+  display: inline-block;
+  width: 20px;
+  height: 16px;
+  margin-right: 8px;
+  vertical-align: middle;
+}
+</style>
diff --git a/parent_dir/src/components/BaseComponents/BaseLoader.vue b/parent_dir/src/components/BaseComponents/BaseLoader.vue
new file mode 100644
index 0000000..c7768ab
--- /dev/null
+++ b/parent_dir/src/components/BaseComponents/BaseLoader.vue
@@ -0,0 +1,56 @@
+<template>
+  <span v-if="old" class="base-loader" />
+  <base-loader-progress v-else :big="big" :primary="primary" :secondary="secondary" />
+</template>
+
+<script>
+import BaseLoaderProgress from '#root/src/components/BaseComponents/BaseLoaderProgress.vue';
+
+export default {
+  components: { BaseLoaderProgress },
+  props: {
+    old: {
+      type: Boolean,
+      default() {
+        return true;
+      },
+    },
+    primary: {
+      type: Boolean,
+      default: false,
+    },
+    secondary: {
+      type: Boolean,
+      default: false,
+    },
+    big: {
+      type: Boolean,
+      default: false,
+    },
+  },
+};
+</script>
+
+<style lang="scss" scoped>
+.base-loader {
+  &::after {
+    content: ' ';
+    display: block;
+    width: 24px;
+    height: 24px;
+    background-image: url('@/assets/img/progress-circle.png');
+    background-size: cover;
+    animation: rotation 2s infinite linear;
+  }
+}
+
+@keyframes rotation {
+  from {
+    transform: rotate(0deg);
+  }
+
+  to {
+    transform: rotate(-359deg);
+  }
+}
+</style>
diff --git a/parent_dir/src/components/BaseComponents/BaseLoaderProgress.vue b/parent_dir/src/components/BaseComponents/BaseLoaderProgress.vue
new file mode 100644
index 0000000..7566d20
--- /dev/null
+++ b/parent_dir/src/components/BaseComponents/BaseLoaderProgress.vue
@@ -0,0 +1,129 @@
+<template>
+  <svg :width="width" :height="height" :class="{ 'icon-progress--big': big }">
+    <circle :cx="cx" :cy="cy" :r="r" :stroke="colors.progress" />
+  </svg>
+</template>
+
+<script>
+export default {
+  name: 'BaseLoaderProgress',
+  props: {
+    primary: {
+      type: Boolean,
+      default: false,
+    },
+    secondary: {
+      type: Boolean,
+      default: false,
+    },
+    big: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  computed: {
+    colors() {
+      if (this.primary) {
+        return {
+          stroke: 'transparent',
+          progress: '#FFFFFF',
+        };
+      }
+      if (this.secondary) {
+        return {
+          stroke: 'transparent',
+          progress: '#00A942',
+        };
+      }
+      return {
+        stroke: '#EDF0F3',
+        progress: '#00A942',
+      };
+    },
+    width() {
+      return this.big ? 86 : 20;
+    },
+    height() {
+      return this.big ? 86 : 20;
+    },
+    cx() {
+      return this.big ? 38 : 9;
+    },
+    cy() {
+      return this.big ? 38 : 9;
+    },
+    r() {
+      return this.big ? 38 : 8;
+    },
+  },
+};
+</script>
+
+<style scoped lang="scss">
+svg {
+  position: relative;
+  animation: rotate 0.6s linear infinite;
+}
+
+circle {
+  width: 100%;
+  height: 100%;
+  fill: none;
+  stroke-width: 2px;
+  stroke-linecap: round;
+  transform: translate(1px, 1px);
+  stroke-dasharray: 50;
+  stroke-dashoffset: 50;
+  animation: animate 2s linear infinite;
+}
+
+@keyframes rotate {
+  0% {
+    transform: rotate(0deg);
+  }
+
+  100% {
+    transform: rotate(360deg);
+  }
+}
+
+@keyframes animate {
+  0%,
+  100% {
+    stroke-dashoffset: 50;
+  }
+
+  50% {
+    stroke-dashoffset: 1;
+  }
+
+  50.1% {
+    stroke-dashoffset: 100;
+  }
+}
+
+.icon-progress--big {
+  circle {
+    stroke-dasharray: 250;
+    stroke-dashoffset: 250;
+    stroke-width: 4px;
+    transform: translate(5px, 5px);
+    animation: animate-big 2s linear infinite;
+  }
+}
+
+@keyframes animate-big {
+  0%,
+  100% {
+    stroke-dashoffset: 250;
+  }
+
+  50% {
+    stroke-dashoffset: 1;
+  }
+
+  50.1% {
+    stroke-dashoffset: 500;
+  }
+}
+</style>
diff --git a/parent_dir/src/components/BaseComponents/CdekCheckbox.vue b/parent_dir/src/components/BaseComponents/CdekCheckbox.vue
new file mode 100644
index 0000000..76ae0fa
--- /dev/null
+++ b/parent_dir/src/components/BaseComponents/CdekCheckbox.vue
@@ -0,0 +1,167 @@
+<template>
+  <label
+    class="cdek-checkbox-v2"
+    :class="{
+      'cdek-checkbox-v2--big': big,
+      'cdek-checkbox-v2--disabled': disabled,
+    }"
+  >
+    <input
+      class="cdek-checkbox-v2__input"
+      type="checkbox"
+      :checked="modelValue"
+      :disabled="disabled"
+      @change="onChange"
+    />
+
+    <span
+      class="cdek-checkbox-v2__checkmark"
+      :class="{ 'cdek-checkbox-v2__checkmark_error': validRes }"
+    />
+
+    <span class="cdek-checkbox-v2__text">
+      <slot />
+
+      <span v-if="$slots.tip" class="cdek-checkbox-v2__tip">
+        <slot name="tip" />
+      </span>
+    </span>
+  </label>
+</template>
+
+<script lang="ts" setup>
+withDefaults(
+  defineProps<{
+    disabled?: boolean;
+    big?: boolean;
+    modelValue?: boolean;
+    validRes?: boolean;
+  }>(),
+  {
+    disabled: false,
+    big: false,
+  },
+);
+
+const emit = defineEmits(['update:modelValue']);
+
+const onChange = (e: Event) => {
+  emit('update:modelValue', (e.target as HTMLInputElement).checked);
+};
+</script>
+
+<style lang="scss" scoped>
+.cdek-checkbox-v2 {
+  display: flex;
+  position: relative;
+  cursor: pointer;
+  gap: 16px;
+}
+
+.cdek-checkbox-v2__checkmark {
+  cursor: pointer;
+  position: relative;
+  width: 24px;
+  height: 24px;
+  background: $Primary_5;
+  border: 1px solid $Primary;
+  border-radius: 6px;
+  flex: 0 0 24px;
+
+  &_error {
+    background: $Error_20;
+    border-color: $Error;
+    border-width: 2px;
+  }
+
+  .cdek-checkbox-v2--big & {
+    width: 32px;
+    height: 32px;
+    border-radius: 8px;
+    flex: 0 0 32px;
+  }
+
+  .cdek-checkbox-v2:hover & {
+    background: $Primary_20;
+    border-color: $Primary;
+  }
+
+  .cdek-checkbox-v2--disabled &,
+  .cdek-checkbox-v2--disabled:hover & {
+    background: $Button_Disable;
+    border: 1px solid transparent;
+  }
+}
+
+.cdek-checkbox-v2__checkmark::after {
+  content: '';
+  position: absolute;
+  display: none;
+  left: 50%;
+  top: 50%;
+  transform: translate(-50%, -50%);
+  width: 13px;
+  height: 9px;
+  background-image: url('./icons/check.svg?url');
+  background-size: cover;
+
+  .cdek-checkbox-v2--big & {
+    width: 17px;
+    height: 12px;
+  }
+}
+
+.cdek-checkbox-v2__input {
+  position: absolute;
+  opacity: 0;
+  height: 0;
+  width: 0;
+
+  &:checked ~ .cdek-checkbox-v2__checkmark {
+    background: $Primary;
+    border: 1px solid transparent;
+
+    &::after {
+      display: block;
+    }
+
+    .cdek-checkbox-v2:hover & {
+      background: $Primary_70;
+      border: 1px solid transparent;
+    }
+
+    .cdek-checkbox-v2--disabled &,
+    .cdek-checkbox-v2--disabled:hover & {
+      background: $Button_Disable;
+      border: 1px solid transparent;
+    }
+  }
+}
+
+.cdek-checkbox-v2__text {
+  @include body-2;
+
+  margin-top: 2px;
+
+  .cdek-checkbox-v2--big & {
+    @include body-1;
+
+    margin-top: 4px;
+  }
+
+  display: block;
+
+  .cdek-checkbox-v2--disabled &,
+  .cdek-checkbox-v2--disabled:hover & {
+    color: $Bottom_60;
+  }
+}
+
+.cdek-checkbox-v2__tip {
+  @include caption-1;
+
+  display: block;
+  color: $Bottom_60;
+  margin-top: 2px;
+}
+</style>
diff --git a/parent_dir/src/components/BaseComponents/mixins/base-field.mixin.js b/parent_dir/src/components/BaseComponents/mixins/base-field.mixin.js
new file mode 100644
index 0000000..0f0b6e1
--- /dev/null
+++ b/parent_dir/src/components/BaseComponents/mixins/base-field.mixin.js
@@ -0,0 +1,23 @@
+import basePropsMixin from './base-props.mixin.js';
+
+export default {
+  name: 'base-field-mixin',
+  mixins: [basePropsMixin],
+  props: {
+    // deprecated
+    old: {
+      type: Boolean,
+      default: false,
+    },
+    checked: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  data() {
+    return {
+      focused: false,
+      idElement: null,
+    };
+  },
+};
diff --git a/parent_dir/src/components/BaseComponents/mixins/base-props.mixin.js b/parent_dir/src/components/BaseComponents/mixins/base-props.mixin.js
new file mode 100644
index 0000000..0f4571a
--- /dev/null
+++ b/parent_dir/src/components/BaseComponents/mixins/base-props.mixin.js
@@ -0,0 +1,54 @@
+export default {
+  name: 'base-props',
+  props: {
+    name: String,
+    placeholder: String,
+    modelValue: [String, Number, Object],
+    messageError: String,
+    id: [String, Number],
+    required: {
+      type: Boolean,
+      default() {
+        return false;
+      },
+    },
+    hasError: {
+      type: Boolean,
+      default: false,
+    },
+    displayError: {
+      type: Boolean,
+      default: false,
+    },
+    disabled: {
+      type: [String, Boolean],
+      default() {
+        return false;
+      },
+    },
+    additionalInfo: {
+      type: String,
+      default: '',
+    },
+    readonly: {
+      type: Boolean,
+      default: false,
+    },
+    old: {
+      type: Boolean,
+      default: false,
+    },
+    light: {
+      type: Boolean,
+      default: false,
+    },
+    order: {
+      type: Boolean,
+      default: false,
+    },
+    clearButton: {
+      type: Boolean,
+      default: true,
+    },
+  },
+};
diff --git a/parent_dir/src/components/BaseLoader.vue b/parent_dir/src/components/BaseLoader.vue
new file mode 100644
index 0000000..4b3c432
--- /dev/null
+++ b/parent_dir/src/components/BaseLoader.vue
@@ -0,0 +1,67 @@
+<template>
+  <span v-if="old" class="base-loader" />
+  <icon-progress v-else :big="big" :primary="primary" :secondary="secondary" />
+</template>
+
+<script>
+import IconProgress from '@/components/icon-svg/IconProgress.vue';
+
+export default {
+  components: { IconProgress },
+  props: {
+    old: {
+      type: Boolean,
+      default() {
+        return true;
+      },
+    },
+    primary: {
+      type: Boolean,
+      default: false,
+    },
+    secondary: {
+      type: Boolean,
+      default: false,
+    },
+    big: {
+      type: Boolean,
+      default: false,
+    },
+  },
+};
+</script>
+
+<style lang="scss" scoped>
+.rotate {
+  animation: rotation 2s infinite linear;
+}
+
+.rotate-progress {
+  display: block;
+  width: 24px;
+  height: 24px;
+  background-image: url('@/assets/img/progress-circle.png');
+  background-size: cover;
+
+  @extend .rotate;
+}
+
+@keyframes rotation {
+  from {
+    transform: rotate(0deg);
+  }
+
+  to {
+    transform: rotate(-359deg);
+  }
+}
+
+.base-loader {
+  &::after {
+    content: ' ';
+    display: inline-block;
+
+    @extend .rotate-progress;
+  }
+}
+</style>
diff --git a/parent_dir/src/components/ClientOnly.vue b/parent_dir/src/components/ClientOnly.vue
new file mode 100644
index 0000000..ebbe099
--- /dev/null
+++ b/parent_dir/src/components/ClientOnly.vue
@@ -0,0 +1,18 @@
+<template>
+  <template v-if="show">
+    <slot />
+  </template>
+  <template v-else>
+    <slot name="placeholder" />
+  </template>
+</template>
+
+<script lang="ts" setup>
+import { onMounted, ref } from 'vue';
+
+const show = ref(false);
+
+onMounted(() => {
+  show.value = true;
+});
+</script>
diff --git a/parent_dir/src/components/CookieAlert.vue b/parent_dir/src/components/CookieAlert.vue
new file mode 100644
index 0000000..5ff4250
--- /dev/null
+++ b/parent_dir/src/components/CookieAlert.vue
@@ -0,0 +1,126 @@
+<template>
+  <div class="cookie-alert">
+    <div class="cookie-alert__content">
+      <div class="cookie-alert__content__text">
+        <h3 class="cookie-alert__title" v-html="title"></h3>
+        <div class="cookie-alert__description" v-html="note" />
+      </div>
+      <div class="cookie-alert__button_wrapper">
+        <cdek-button @click="onClick">{{ button }}</cdek-button>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { useStore } from 'vuex';
+import { CdekButton } from '@cdek-ui-kit/vue';
+import useSettings from '@/composables/use-settings';
+import { computed, inject } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { VueCookies } from 'vue-cookies';
+
+const $cookies = inject<VueCookies>('$cookies');
+const store = useStore();
+const { getSettingsGroup } = useSettings();
+const { t } = useI18n();
+
+const cookiesSettings = getSettingsGroup('cookies');
+
+const title = computed(() => {
+  return cookiesSettings?.title || t('popupCookieMsg');
+});
+const note = computed(() => {
+  return cookiesSettings?.text || t('popupCookieAgreement');
+});
+const button = computed(() => {
+  return cookiesSettings?.btnText || t('toAccept');
+});
+
+const onClick = () => {
+  store.dispatch('cookie-alert/agreeToUseOfCookies');
+  $cookies?.set('consent-to-use-of-cookies', true, 60 * 60 * 24 * 7 * 356 * 30);
+};
+</script>
+
+<style lang="scss" scoped>
+.cookie-alert {
+  background-color: $Peak;
+  box-shadow: 0 -5px 18px 0 rgba(0, 0, 0, 0.05);
+  padding: 16px;
+  position: fixed;
+  width: 100%;
+  bottom: 0;
+  z-index: 999;
+
+  @include media-min-lg {
+    padding: 24px;
+  }
+
+  &__content {
+    display: flex;
+    flex-direction: column;
+    gap: 24px;
+
+    @include media-min-lg {
+      flex-direction: row;
+      justify-content: space-between;
+      max-width: 1200px;
+      margin-left: auto;
+      margin-right: auto;
+      align-items: center;
+    }
+
+    &__text {
+      display: flex;
+      flex-direction: column;
+      gap: 4px;
+    }
+  }
+
+  &__title {
+    font-family: Roboto, serif;
+    font-size: 14px;
+    font-style: normal;
+    font-weight: 500;
+    line-height: 20px; /* 142.857% */
+    color: $Bottom;
+
+    @include media-min-lg {
+      line-height: 24px; /* 150% */
+      font-size: 16px;
+    }
+  }
+
+  &__description {
+    color: $Bottom;
+    font-family: Roboto, serif;
+    font-size: 12px;
+    font-style: normal;
+    font-weight: 400;
+    line-height: 18px; /* 150% */
+
+    @include media-min-lg {
+      font-size: 14px;
+      font-style: normal;
+      line-height: 20px; /* 142.857% */
+    }
+  }
+
+  &__button_wrapper {
+    :deep(button) {
+      border-radius: 10px;
+      padding: 6px 12px;
+
+      @include media-min-lg {
+        padding: 12px 24px;
+        width: 173px;
+
+        &.cdek-button.small {
+          height: 48px;
+        }
+      }
+    }
+  }
+}
+</style>
diff --git a/parent_dir/src/components/FlomniChat/FlomniChat.vue b/parent_dir/src/components/FlomniChat/FlomniChat.vue
new file mode 100644
index 0000000..21ddccd
--- /dev/null
+++ b/parent_dir/src/components/FlomniChat/FlomniChat.vue
@@ -0,0 +1,106 @@
+<template>
+  <div id="flomni" :class="{ 'flomni-inline containerMF': inline, flomni: !inline }" />
+</template>
+
+<script>
+import { mapState } from 'vuex';
+import { onBeforeUnmount, onMounted } from 'vue';
+import useFlomni from '@/composables/use-flomni';
+import useSiteInfo from '@/composables/use-site-info';
+
+export default {
+  props: {
+    inline: Boolean,
+  },
+  setup() {
+    const { isLoggedInCabinet } = useSiteInfo();
+    const { displayChat, installFlomni } = useFlomni();
+
+    const destroy = () => {
+      if (window.$flomni) {
+        // Уничтожает инстанс компонента, но почему то фломни остается в состоянии загрузки
+        // поэтому ниже я еще контент селектора удаляю.
+        window.$flomni.chat && window.$flomni.chat.destroy();
+
+        const flomniEl = document.getElementById('flomni');
+
+        if (flomniEl) {
+          flomniEl.innerHTML = '';
+        }
+      }
+    };
+
+    const refresh = () => {
+      if (displayChat.value) {
+        if (window.$flomni) {
+          window.$flomni.chat.create();
+        } else {
+          this.installFlomni();
+        }
+      } else {
+        this.destroy();
+      }
+    };
+
+    onMounted(() => {
+      if (displayChat.value) {
+        installFlomni();
+      }
+    });
+
+    onBeforeUnmount(destroy);
+
+    return { installFlomni, destroy, refresh, displayChat, isLoggedInCabinet };
+  },
+  computed: {
+    ...mapState('flomni', ['isHelpCustomerLoaded']),
+  },
+  watch: {
+    displayChat() {
+      setTimeout(() => this.refresh(), 50);
+    },
+    inline(inline) {
+      if (inline !== undefined) {
+        this.destroy();
+        window.$flomni = undefined;
+        setTimeout(() => this.refresh(), 50);
+      }
+    },
+    isHelpCustomerLoaded() {
+      // flomni-mounted используется только для HelpCustomer, поэтому ожидаем что он загрузился
+      this.$emitter.emit('flomni-mounted');
+    },
+  },
+  mounted() {
+    // костыль для авторизованного (хф), потому что эмит почему не работает в вотчере
+    if (this.isHelpCustomerLoaded && this.isLoggedInCabinet) {
+      this.$emitter.emit('flomni-mounted');
+    }
+  },
+};
+</script>
+
+<style lang="scss" scoped>
+.flomni-inline {
+  position: relative;
+  z-index: 1;
+  width: 100%;
+
+  & iframe {
+    min-height: 500px !important;
+
+    @media (min-width: $tablet) {
+      min-height: 600px !important;
+    }
+
+    @media (min-width: $desktop) {
+      min-height: 800px !important;
+    }
+  }
+}
+
+.flomni {
+  position: relative;
+  z-index: 100;
+}
+</style>
diff --git a/parent_dir/src/components/Footer/FooterMain.vue b/parent_dir/src/components/Footer/FooterMain.vue
new file mode 100644
index 0000000..c3c5ff1
--- /dev/null
+++ b/parent_dir/src/components/Footer/FooterMain.vue
@@ -0,0 +1,123 @@
+<template>
+  <footer class="footer" :class="footerClass">
+    <base-container>
+      <base-layout column wrap>
+        <base-layout wrap>
+          <base-flex class="footer__menu lg4 md5 sm8 xs12 order-md2 order-xs2">
+            <footer-menu v-if="!loading" />
+          </base-flex>
+
+          <base-flex class="footer__additional lg4 md3 sm4 xs12 order-md2 order-xs3">
+            <footer-additional-links
+              v-if="!loading && additionalLinks.length"
+              :links="additionalLinks"
+            />
+          </base-flex>
+          <base-flex d-flex class="lg4 md4 sm12 xs12 order-md2 order-sm1 order-xs1">
+            <base-layout class="footer__search" :class="{ cn: isChine }">
+              <base-flex class="footer__search-box md12 sm6 xs12 order-md1 order-sm2 order-xs2">
+                <footer-search v-if="!loading" :placeholder="footer.search" />
+              </base-flex>
+
+              <base-flex
+                v-if="isChine"
+                class="md12 sm6 xs12 order-md2 order-xs2 order-sm2 qr-codes"
+              >
+                <img :src="qr1" alt="mini app QR" class="qr-codes-code" />
+                <img :src="qr2" alt="WeChat QR" class="qr-codes-code" />
+              </base-flex>
+              <base-flex v-if="!isChine" class="md12 sm6 xs12 order-md2 order-sm1 order-xs1">
+                <footer-feedback v-if="!loading" :feedback="footer.feedback" />
+              </base-flex>
+            </base-layout>
+          </base-flex>
+        </base-layout>
+        <footer-international
+          v-if="!loading && footer.links.international && footer.links.international.length"
+          :international="footer.links.international"
+        />
+        <base-layout wrap>
+          <base-flex v-if="!loading" class="md6 sm12 xs12">
+            <footer-social-group-links v-if="isShowSocialLinks" :social="footer.links.social" />
+          </base-flex>
+          <base-flex v-if="!loading" class="md6 sm12 xs12">
+            <footer-official
+              v-if="footer.links.official && footer.links.official.length"
+              :official="footer.links.official"
+            />
+          </base-flex>
+        </base-layout>
+        <base-flex>
+          <footer-copy />
+        </base-flex>
+      </base-layout>
+    </base-container>
+  </footer>
+</template>
+
+<script>
+import { mapGetters } from 'vuex';
+import { computed, defineAsyncComponent } from 'vue';
+
+import BaseContainer from '@/components/BaseContainer.vue';
+import BaseLayout from '@/components/BaseLayout.vue';
+import BaseFlex from '@/components/BaseComponents/BaseFlex.vue';
+import usePage from '@/composables/use-page';
+
+export default {
+  components: {
+    BaseFlex,
+    BaseLayout,
+    BaseContainer,
+    FooterMenu: defineAsyncComponent(() => import('./FooterMenu.vue')),
+    FooterAdditionalLinks: defineAsyncComponent(() => import('./FooterAdditionalLinks.vue')),
+    FooterSearch: defineAsyncComponent(() => import('./FooterSearch.vue')),
+    FooterFeedback: defineAsyncComponent(() => import('./FooterFeedback.vue')),
+    FooterSocialGroupLinks: defineAsyncComponent(() => import('./FooterSocialGroupLinks.vue')),
+    FooterInternational: defineAsyncComponent(() => import('./FooterInternational.vue')),
+    FooterOfficial: defineAsyncComponent(() => import('./FooterOfficial.vue')),
+    FooterCopy: defineAsyncComponent(() => import('./FooterCopy.vue')),
+  },
+  setup() {
+    const { isNewDesign, isSearchResultsPage } = usePage();
+
+    const footerClass = computed(() => {
+      return {
+        footer__enable_margin: isNewDesign.value || isSearchResultsPage.value,
+      };
+    });
+    return {
+      footerClass,
+    };
+  },
+  data: () => ({
+    qr1: '../../assets/img/qr_cn1.jpeg',
+    qr2: '../../assets/img/qr_cn2.jpg',
+  }),
+  computed: {
+    ...mapGetters({
+      footer: 'footer/footer',
+      loading: 'footer/loading',
+      isChine: 'isChineSite',
+    }),
+    additionalLinks() {
+      return this.footer.links.additional ?? [];
+    },
+    isShowSocialLinks() {
+      return this.footer.links.social && Object.keys(this.footer.links.social).length;
+    },
+  },
+};
+</script>
+
+<style lang="scss" src="./footer.scss"></style>
+
+<style lang="scss" scoped>
+.footer__enable_margin {
+  margin-top: 48px;
+
+  @include media-min-lg {
+    margin-top: 80px;
+  }
+}
+</style>
diff --git a/parent_dir/src/components/HelpCustomer/HelpCustomerContainer.vue b/parent_dir/src/components/HelpCustomer/HelpCustomerContainer.vue
new file mode 100644
index 0000000..201a441
--- /dev/null
+++ b/parent_dir/src/components/HelpCustomer/HelpCustomerContainer.vue
@@ -0,0 +1,259 @@
+<template>
+  <div
+    class="help-customer-container"
+    :class="{
+      'help-customer-container--open': open,
+      'help-customer-container--flomni': isFlomni,
+    }"
+  >
+    <div v-if="!loaded" class="help-customer-container__loading">
+      <base-loader />
+    </div>
+    <div v-if="loaded" class="help-customer-container__loaded">
+      <template v-if="(isRuSite || isAzSite) && firstScreen">
+        <div class="help-customer-container__screen1">
+          <help-customer-container-rating v-if="!isAzSite" :opened="open" />
+          <help-customer-container-messengers :opened="open" @close="$emit('close')" />
+          <help-customer-container-other v-if="!isAzSite" @click="otherClick" />
+        </div>
+      </template>
+      <template v-else>
+        <help-customer-container-list
+          v-if="!view && !isSystem"
+          :list="list"
+          :all-questions-link="allQuestionsLink"
+          :opened="open"
+          :widget="widget"
+          :is-short-faq="isShortFaq"
+          @select="onSelectView"
+        />
+        <help-customer-container-view v-if="view" :view="view" :opened="open" @back="onBack" />
+        <help-customer-container-view-contact
+          v-if="isSystem"
+          :opened="open"
+          :widget="widget"
+          @back="onBack"
+        />
+        <div v-if="!isSystem" class="help-customer-container__footer" @click="onOpenSystem()">
+          <button type="button" class="help-customer-container__all-questions">
+            {{ widget && widget.allQuestionTitleResult }}
+            <icon-arrow color="#000" direction="right" class="help-customer-container__icon" />
+          </button>
+        </div>
+      </template>
+    </div>
+  </div>
+</template>
+
+<script>
+import { mapGetters } from 'vuex';
+import BaseLoader from '@/components/BaseComponents/BaseLoader.vue';
+import { defineAsyncComponent } from 'vue';
+import { reachGoal } from '@/utils/reach-goal';
+import { navigate } from 'vite-plugin-ssr/client/router';
+import useSiteInfo from '@/composables/use-site-info';
+
+const SCREENS = 2;
+
+export default {
+  name: 'HelpCustomerContainer',
+  components: {
+    HelpCustomerContainerList: defineAsyncComponent(() =>
+      import('./HelpCustomerContainerList.vue'),
+    ),
+    HelpCustomerContainerView: defineAsyncComponent(() =>
+      import('./HelpCustomerContainerView.vue'),
+    ),
+    HelpCustomerContainerViewContact: defineAsyncComponent(() =>
+      import('./HelpCustomerContainerViewContact.vue'),
+    ),
+    HelpCustomerContainerRating: defineAsyncComponent(() =>
+      import('./HelpCustomerContainerRating.vue'),
+    ),
+    HelpCustomerContainerMessengers: defineAsyncComponent(() =>
+      import('./HelpCustomerContainerMessengersV2.vue'),
+    ),
+    HelpCustomerContainerOther: defineAsyncComponent(() =>
+      import('./HelpCustomerContainerOther.vue'),
+    ),
+    IconArrow: defineAsyncComponent(() => import('../icon-svg/IconArrow.vue')),
+    BaseLoader,
+  },
+  props: {
+    opened: Boolean,
+    loaded: Boolean,
+    widget: { type: Object, default: null },
+  },
+  emits: ['close'],
+  setup() {
+    const { currentLocale } = useSiteInfo();
+
+    const { isRuSite, isAzSite } = useSiteInfo();
+
+    const otherClick = () => {
+      navigate(`/${currentLocale.value}/faq`);
+      reachGoal('widget_FAQ');
+    };
+
+    return {
+      otherClick,
+      isRuSite,
+      isAzSite,
+    };
+  },
+  data() {
+    return {
+      open: false,
+      view: null,
+      isSystem: false,
+      screen: new Array(SCREENS).fill(false),
+      isShortFaq: import.meta.env.VITE_FAQ_STEP === 'short',
+    };
+  },
+  computed: {
+    ...mapGetters({
+      isFlomni: 'flomni/displayChat',
+    }),
+    list() {
+      return (this.widget && this.widget.questions) || [];
+    },
+    allQuestionsLink() {
+      return (this.widget && this.widget.allQuestionsLink) || '';
+    },
+    chatLink() {
+      return (this.widget && this.widget.chatLink) || '';
+    },
+    callLink() {
+      return (this.widget && this.widget.callLink) || '';
+    },
+    firstScreen() {
+      return this.screen[0];
+    },
+  },
+  watch: {
+    opened(opened) {
+      this.open = opened;
+      if (!opened) {
+        this.reset();
+      }
+    },
+  },
+  mounted() {
+    if (this.isShortFaq) {
+      this.screen[1] = true;
+      return;
+    }
+    this.screen[0] = true;
+  },
+  methods: {
+    onOpenSystem() {
+      reachGoal('widget_more');
+      if (window.$flomni && window.$flomni.chat) {
+        window.$flomni.chat.switchToggler(true);
+        return;
+      }
+
+      this.view = null;
+      this.isSystem = true;
+    },
+    onSelectView(item) {
+      if (!item.isSystem) {
+        this.view = item;
+      } else {
+        this.isSystem = true;
+      }
+    },
+    onBack() {
+      this.view = null;
+      this.isSystem = false;
+    },
+    reset() {
+      this.view = null;
+      this.setCurrentScreen(this.isShortFaq ? 1 : 0);
+    },
+    goto(url) {
+      this.$emit('close');
+      this.$router.push(url);
+    },
+    setCurrentScreen(screenNumber) {
+      for (let i = 0; i < SCREENS; i++) {
+        this.screen[i] = false;
+      }
+      this.screen[screenNumber] = true;
+    },
+  },
+};
+</script>
+
+<style scoped lang="scss">
+@import './variables';
+
+.help-customer-container {
+  position: relative;
+  overflow: hidden;
+  width: 0;
+  height: 0;
+  border-radius: 10px;
+  background-color: white;
+  box-shadow: 0 4px 15px rgba(0, 0, 0, 0.15);
+
+  &__screen1 {
+    padding: 0 15px;
+    height: 100%;
+    overflow: auto;
+  }
+
+  &--open {
+    width: 380px;
+    height: auto;
+  }
+
+  &__loaded {
+    height: 100%;
+    max-height: calc(100vh - 80px);
+    display: flex;
+    flex-direction: column;
+    overflow: auto;
+  }
+
+  &__loading {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+  }
+
+  &--flomni {
+    right: -68px;
+
+    @media (min-width: $tablet) {
+      right: 0;
+    }
+  }
+
+  &__footer {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 100%;
+    height: $heightFooter;
+    cursor: pointer;
+    padding: 16px 30px 14px;
+    border-top: 1px solid rgba(0, 0, 0, 0.1);
+  }
+
+  &__all-questions {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    width: 100%;
+    text-decoration: none;
+    color: $black-dark;
+    outline: none;
+  }
+
+  &__icon {
+    margin-bottom: -2px;
+  }
+}
+</style>
diff --git a/parent_dir/src/components/HelpCustomer/HelpCustomerTrigger.vue b/parent_dir/src/components/HelpCustomer/HelpCustomerTrigger.vue
new file mode 100644
index 0000000..5018f29
--- /dev/null
+++ b/parent_dir/src/components/HelpCustomer/HelpCustomerTrigger.vue
@@ -0,0 +1,112 @@
+<template>
+  <div
+    class="help-customer-trigger"
+    :class="{
+      'help-customer-trigger--closed': !open,
+      'help-customer-trigger--opened': open,
+    }"
+    @click="onTrigger"
+  >
+    <div v-if="open">
+      <icon-close :fill="'#fff'" />
+    </div>
+    <div v-if="!open" class="help-customer-trigger__default">
+      <div class="help-customer-trigger__default-text" v-html="buttonName" />
+      <icon-messages class="help-customer-trigger__message" />
+    </div>
+  </div>
+</template>
+
+<script>
+import { reachGoal } from '@/utils/reach-goal';
+import IconClose from '../icon-svg/IconClose.vue';
+import IconMessages from './icons/messages.svg';
+
+export default {
+  name: 'HelpCustomerTrigger',
+  components: {
+    IconClose,
+    IconMessages,
+  },
+  props: {
+    opened: Boolean,
+    widget: { type: Object, default: null },
+  },
+  emits: ['toggle'],
+  data() {
+    return {
+      open: false,
+    };
+  },
+  computed: {
+    buttonName() {
+      return (this.widget && this.widget.allQuestionTitle) || '';
+    },
+  },
+  watch: {
+    opened(opened) {
+      this.open = opened;
+    },
+  },
+  methods: {
+    onTrigger() {
+      this.open = !this.open;
+      if (this.open) {
+        reachGoal('widget_click');
+      }
+      this.$emit('toggle', this.open);
+    },
+  },
+};
+</script>
+
+<style scoped lang="scss">
+.help-customer-trigger {
+  background-color: #00bc4c;
+  border-radius: 25px;
+  color: white;
+  cursor: pointer;
+
+  &--closed {
+    padding: 8px 16px 8px 24px;
+    animation: shadow-pulse 1s infinite;
+  }
+
+  &--opened {
+    line-height: 0;
+    padding: 17px;
+  }
+
+  &__default {
+    display: flex;
+    align-items: center;
+    position: relative;
+  }
+
+  &__default-text {
+    margin-right: 8px;
+
+    @media (min-width: $tablet) {
+      margin-right: 12px;
+    }
+  }
+
+  &__message {
+    width: 28px;
+
+    @media (min-width: $tablet) {
+      width: 33px;
+    }
+  }
+}
+
+@keyframes shadow-pulse {
+  0% {
+    box-shadow: 0 0 0 0 rgba(0, 188, 76, 0.4);
+  }
+
+  100% {
+    box-shadow: 0 0 0 16px rgba(0, 188, 76, 0);
+  }
+}
+</style>
diff --git a/parent_dir/src/components/HelpCustomer/HelpCustomerWrapper.vue b/parent_dir/src/components/HelpCustomer/HelpCustomerWrapper.vue
new file mode 100644
index 0000000..6a350d9
--- /dev/null
+++ b/parent_dir/src/components/HelpCustomer/HelpCustomerWrapper.vue
@@ -0,0 +1,280 @@
+<template>
+  <div
+    v-if="isShowFlomni"
+    ref="helpCustomerWrapper"
+    class="help-customer-wrapper"
+    :class="{
+      'help-customer-wrapper--opened': open,
+      'help-customer-wrapper--flomni': isFlomni,
+      'help-customer-wrapper--loaded': loaded,
+    }"
+    :style="{ right }"
+  >
+    <help-customer-container
+      v-if="enableCustomerContainer"
+      class="help-customer-wrapper__container"
+      :opened="open"
+      :loaded="loaded"
+      :widget="widget"
+      @close="onClose"
+    />
+    <help-customer-trigger :opened="open" :widget="widget" @toggle="onToggle" />
+  </div>
+</template>
+
+<script>
+import { mapGetters, mapMutations, mapState } from 'vuex';
+import HelpCustomerTrigger from '@/components/HelpCustomer/HelpCustomerTrigger.vue';
+import HelpCustomerContainer from '@/components/HelpCustomer/HelpCustomerContainer.vue';
+import { cdekConsoleError } from '@/utils/console-wrapper';
+import { ref } from 'vue';
+import { getBodyElement } from '@/utils/dom.utils';
+import useFlomni from '@/composables/use-flomni';
+import useSettings from '@/composables/use-settings';
+
+export default {
+  name: 'HelpCustomerWrapper',
+  components: { HelpCustomerContainer, HelpCustomerTrigger },
+  setup() {
+    const { installFlomni, isFlomniScriptLoaded } = useFlomni();
+
+    const initRight = '4px';
+
+    const buttonRightInt = parseInt(initRight, 10) || 0;
+
+    const right = ref(initRight);
+
+    const body = getBodyElement();
+
+    const { getSettingsGroup } = useSettings();
+
+    const { displayChatOnly } = getSettingsGroup('all');
+
+    const observer = new MutationObserver((mutations) => {
+      mutations.forEach(() => {
+        const bodyPaddingRightInt = parseInt(body.style.paddingRight, 10) || 0;
+
+        right.value = `${buttonRightInt + bodyPaddingRightInt}px`;
+      });
+    });
+
+    observer.observe(body, { attributes: true, attributeFilter: ['style'] });
+
+    return {
+      right,
+      enableCustomerContainer: !displayChatOnly,
+      installFlomni,
+      isFlomniScriptLoaded,
+    };
+  },
+  data() {
+    return {
+      open: false,
+      widget: null,
+      loaded: false,
+      updated: false,
+    };
+  },
+  computed: {
+    ...mapState('flomni', ['isExternalOpened']),
+    ...mapGetters({
+      currentLocaleISO: 'currentLocaleISO',
+      isFlomni: 'flomni/displayChat',
+      stateFlomni: 'flomni/state',
+      isYaMapsBalloonOpened: 'flomni/isYaMapsBalloonOpened',
+      consentToUseOfCookies: 'cookie-alert/consentToUseOfCookies',
+    }),
+    isShowFlomni() {
+      return !this.isYaMapsBalloonOpened && this.isFlomniScriptLoaded;
+    },
+  },
+  watch: {
+    currentLocaleISO() {
+      this.loadContent();
+    },
+    stateFlomni(state) {
+      if (!this.enableCustomerContainer) {
+        if (state === 'closed') {
+          this.open = false;
+        }
+
+        return;
+      }
+
+      if (state === 'open') {
+        this.onClose();
+      }
+    },
+    $route() {
+      this.loadContent();
+    },
+    consentToUseOfCookies(val) {
+      if (val) {
+        this.$el?.style?.removeProperty('bottom');
+      }
+    },
+    /**
+     * Открытие виджета из любого места через стор
+     * flomni/setIsExternalOpened
+     * flomni/toggleIsExternalOpened
+     * @param {Boolean} val
+     */
+    isExternalOpened(val) {
+      this.onToggle(val);
+    },
+  },
+  mounted() {
+    this.$emitter.on('flomni-mounted', () => {
+      this.checkFlomniEl();
+      this.installFlomni();
+
+      if (!this.consentToUseOfCookies) {
+        this.handleBottomPlacement();
+
+        window.addEventListener('resize', this.handleBottomPlacement);
+      }
+    });
+
+    if (this.isFlomni) {
+      this.$store.commit('flomni/onInit', { displayChat: false });
+    }
+
+    this.setIsHelpCustomerLoaded(true);
+  },
+  created() {
+    this.loadContent();
+  },
+  beforeUnmount() {
+    window.removeEventListener('resize', this.handleBottomPlacement);
+  },
+  methods: {
+    ...mapMutations('flomni', ['setIsHelpCustomerLoaded', 'setIsExternalOpened']),
+    handleBottomPlacement() {
+      const cookieEl = document.querySelector('.cookie-alert');
+
+      if (!cookieEl?.clientHeight || !this.$el?.style?.bottom) {
+        return;
+      }
+
+      this.$el.style.bottom = `${cookieEl.clientHeight + 12}px`;
+    },
+    checkFlomniEl() {
+      const layout = document.getElementById('__layout');
+      const el = document.getElementById('flomni');
+
+      if (el) {
+        el.classList.add('hidden-flomni');
+        return;
+      }
+
+      const flomniEl = document.createElement('div');
+      flomniEl.setAttribute('id', 'flomni');
+      flomniEl.classList.add('hidden-flomni');
+      layout.appendChild(flomniEl);
+    },
+    handleUzToggle(open) {
+      if (open) {
+        this.open = true;
+      }
+
+      if (window.$flomni && window.$flomni.chat) {
+        window.$flomni.chat.switchToggler(open);
+      }
+    },
+    onToggle(open) {
+      if (!this.enableCustomerContainer) {
+        this.handleUzToggle(open);
+        return;
+      }
+
+      this.open = open;
+
+      if (open && window.$flomni && window.$flomni.chat && window.$flomni.chat.togglerState()) {
+        window.$flomni.chat.switchToggler(false);
+      }
+
+      if (open !== this.isExternalOpened) {
+        this.setIsExternalOpened(open);
+      }
+    },
+    onClose() {
+      this.open = false;
+      this.setIsExternalOpened(false);
+    },
+    loadContent() {
+      this.updated = true;
+
+      this.$restApi
+        .helpWidget(
+          {
+            locale: this.currentLocaleISO,
+          },
+          this.$route.$path,
+        )
+        .then((res) => {
+          let id = 0;
+          res.questions =
+            res.questions?.map((i) => ({
+              ...i,
+              // eslint-disable-next-line no-plusplus
+              id: id++,
+            })) || [];
+          this.widget = res;
+        })
+        .catch((e) => {
+          cdekConsoleError(e);
+        })
+        .finally(() => {
+          this.updated = false;
+          this.loaded = true;
+        });
+    },
+  },
+  destroy() {
+    if (window.$flomni) {
+      window.$flomni.chat && window.$flomni.chat.destroy();
+    }
+  },
+};
+</script>
+<style lang="scss">
+.hidden-flomni {
+  #flomni-preloading,
+  #flomni-toggler {
+    visibility: hidden;
+    pointer-events: none;
+  }
+}
+</style>
+<style scoped lang="scss">
+.help-customer-wrapper {
+  position: fixed;
+  z-index: 50;
+  bottom: 12px;
+  display: flex;
+  visibility: hidden;
+  align-items: flex-end;
+  flex-direction: column;
+  justify-content: flex-end;
+
+  &--opened {
+    z-index: 99;
+  }
+
+  &--flomni {
+    right: 68px;
+  }
+
+  &__container {
+    margin-bottom: 16px;
+  }
+
+  &--loaded {
+    visibility: visible;
+  }
+
+  @media (min-width: $tablet) {
+    bottom: 12px;
+  }
+}
+</style>
diff --git a/parent_dir/src/components/HelpCustomer/icons/messages.svg b/parent_dir/src/components/HelpCustomer/icons/messages.svg
new file mode 100644
index 0000000..8853ab7
--- /dev/null
+++ b/parent_dir/src/components/HelpCustomer/icons/messages.svg
@@ -0,0 +1,23 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "26",
+  height: "26",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createElementVNode("path", {
+  stroke: "#fff",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "2",
+  d: "M15.667 17v2.667A1.333 1.333 0 0 1 14.333 21H5l-4 4V11.667a1.333 1.333 0 0 1 1.333-1.334H5m20 5.334-4-4h-9.333a1.333 1.333 0 0 1-1.334-1.334v-8A1.333 1.333 0 0 1 11.667 1h12A1.333 1.333 0 0 1 25 2.333v13.334Z"
+}, null, -1)
+const _hoisted_3 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_3))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/components/IconsMenu/IconsMenu.vue b/parent_dir/src/components/IconsMenu/IconsMenu.vue
new file mode 100644
index 0000000..cf52aec
--- /dev/null
+++ b/parent_dir/src/components/IconsMenu/IconsMenu.vue
@@ -0,0 +1,68 @@
+<template>
+  <div class="icons-menu">
+    <icons-menu-item v-if="isRuSite" :href="sendAsLegalLink" @click="onClickSendAsLegalHandler">
+      <template #icon><trackIcon /></template>
+      {{ $t('menu.links.sendAsLegal') }}
+    </icons-menu-item>
+
+    <icons-menu-item :href="officesLink" @click="closeMenu">
+      <template #icon><mapPinIcon /></template>
+      {{ $t('menu.links.offices') }}
+    </icons-menu-item>
+
+    <icons-menu-item v-if="helpEnabled" :href="helpLink" @click="closeMenu">
+      <template #icon><helpIcon /></template>
+      {{ $t('menu.links.help') }}
+    </icons-menu-item>
+  </div>
+</template>
+<script setup lang="ts">
+import { computed } from 'vue';
+import IconsMenuItem from '@/components/IconsMenu/IconsMenuItem.vue';
+import { useMenuStore } from '@/store/pinia/menu/menu';
+import useSiteInfo from '@/composables/use-site-info';
+import { reachGoal } from '@/utils/reach-goal';
+import trackIcon from './icons/track.svg';
+import mapPinIcon from './icons/map-pin.svg';
+import helpIcon from './icons/help.svg';
+
+const menuStore = useMenuStore();
+
+const { isRuSite, currentLocaleISO } = useSiteInfo();
+
+const sendAsLegalLink = computed(() => {
+  return `/${currentLocaleISO.value}/B2C-B2B-FORM/`;
+});
+
+const officesLink = computed(() => {
+  return `/${currentLocaleISO.value}/offices/`;
+});
+
+const helpEnabled = computed(() => {
+  return isRuSite.value;
+});
+
+const helpLink = computed(() => {
+  return `/${currentLocaleISO.value}/faq`;
+});
+
+const closeMenu = () => {
+  menuStore.closeMobileMenu();
+};
+
+const onClickSendAsLegalHandler = () => {
+  reachGoal('send_as_business_header');
+  closeMenu();
+};
+</script>
+
+<style scoped lang="scss">
+.icons-menu {
+  display: flex;
+  flex-direction: column;
+
+  @include media-min-xl {
+    flex-direction: row-reverse;
+  }
+}
+</style>
diff --git a/parent_dir/src/components/IconsMenu/icons/help.svg b/parent_dir/src/components/IconsMenu/icons/help.svg
new file mode 100644
index 0000000..4a1f54a
--- /dev/null
+++ b/parent_dir/src/components/IconsMenu/icons/help.svg
@@ -0,0 +1,24 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "20",
+  height: "20",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createElementVNode("path", {
+  stroke: "#000",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-opacity": ".66",
+  "stroke-width": "1.5",
+  d: "M10 14.167v.008m0-2.925a1.25 1.25 0 0 1 .833-1.25 2.166 2.166 0 1 0-2.5-3.333M17.5 10a7.5 7.5 0 1 1-15 0 7.5 7.5 0 0 1 15 0Z"
+}, null, -1)
+const _hoisted_3 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_3))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/components/IconsMenu/icons/map-pin.svg b/parent_dir/src/components/IconsMenu/icons/map-pin.svg
new file mode 100644
index 0000000..5da0a20
--- /dev/null
+++ b/parent_dir/src/components/IconsMenu/icons/map-pin.svg
@@ -0,0 +1,33 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "20",
+  height: "20",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createElementVNode("path", {
+  stroke: "#000",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-opacity": ".66",
+  "stroke-width": "1.5",
+  d: "M10 11.667a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5Z"
+}, null, -1)
+const _hoisted_3 = /*#__PURE__*/_createElementVNode("path", {
+  stroke: "#000",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-opacity": ".66",
+  "stroke-width": "1.5",
+  d: "m14.714 13.88-3.536 3.537a1.667 1.667 0 0 1-2.355 0L5.286 13.88a6.666 6.666 0 1 1 9.428 0Z"
+}, null, -1)
+const _hoisted_4 = [
+  _hoisted_2,
+  _hoisted_3
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_4))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/components/IconsMenu/icons/track.svg b/parent_dir/src/components/IconsMenu/icons/track.svg
new file mode 100644
index 0000000..495f122
--- /dev/null
+++ b/parent_dir/src/components/IconsMenu/icons/track.svg
@@ -0,0 +1,24 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "20",
+  height: "20",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createElementVNode("path", {
+  stroke: "#000",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-opacity": ".66",
+  "stroke-width": "1.5",
+  d: "M7.5 14.167a1.667 1.667 0 1 1-3.333 0m3.333 0a1.667 1.667 0 0 0-3.333 0m3.333 0h5m-8.334 0H2.5v-3.334m13.333 3.334a1.667 1.667 0 1 1-3.333 0m3.333 0a1.667 1.667 0 0 0-3.333 0m3.333 0H17.5v-5m-15.834-5h9.167v10m6.667-5h-6.667m6.667 0L15 5h-4.167M2.5 7.5h3.333"
+}, null, -1)
+const _hoisted_3 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_3))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/components/Layout/LayoutHeader.vue b/parent_dir/src/components/Layout/LayoutHeader.vue
new file mode 100644
index 0000000..e9d818d
--- /dev/null
+++ b/parent_dir/src/components/Layout/LayoutHeader.vue
@@ -0,0 +1,423 @@
+<template>
+  <header
+    :class="{
+      'layout-header__sticky': isHelpPage,
+    }"
+  >
+    <div class="device-wrapper show-on-mobile">
+      <div class="top-line">
+        <base-container>
+          <div class="inner-wrapper">
+            <a class="logo" :href="rootWithLocale" @click="onClick(menu[0])">
+              <img v-if="logo?.src" :src="logo.src" alt="CDEK" />
+            </a>
+
+            <button class="mobile-toggle__button" @click="menuStore.openMobileMenu">
+              <span class="mobile-toggle" :class="{ 'order-notification': ordersHasUpdates }">
+                <mobile-drawer-icon />
+              </span>
+            </button>
+          </div>
+        </base-container>
+      </div>
+
+      <mobile-drawer :cabinet="cabinet" />
+    </div>
+
+    <div class="device-wrapper show-on-desktop">
+      <base-container class="top-level">
+        <div class="top-level__left">
+          <a
+            v-if="logo && logo.src"
+            :href="rootWithLocale"
+            class="top-level__logo"
+            @click="onClick(menu[0])"
+          >
+            <img :src="logo.src" alt="CDEK" />
+          </a>
+
+          <div v-if="menu.length > 0" ref="container" class="top-level__container">
+            <menu-item
+              v-for="item in menu"
+              :id="`top-menu-${item.id}`"
+              :key="item.id"
+              :ref="'menu' + item.id"
+              :menu="item"
+              class="top-level__link"
+              :href="item.url"
+              :class="{ active: activePath && activePath[0] && activePath[0].id === item.id }"
+            >
+              {{ item.title }}
+            </menu-item>
+
+            <div ref="underline" class="top-level__underline" />
+          </div>
+        </div>
+        <div class="top-level__right">
+          <icons-menu />
+        </div>
+      </base-container>
+
+      <div class="top-level__spacer" />
+
+      <base-container class="mid-level">
+        <menu-mid-line :menus="submenu" />
+        <div class="mid-level__extra">
+          <locale-switcher v-if="displaySwitcher" class="mid-level__switcher" />
+          <div v-if="isCabinet" id="header-cabinet-place"></div>
+          <div class="mid-level__extra__buttons">
+            <a v-if="isRuSite" :href="paymentLink">
+              <cdek-button theme="outline" small class="mobile-drawer-first-level__payment">
+                {{ $t('menu.links.payment') }}
+              </cdek-button>
+            </a>
+            <client-only>
+              <login v-if="enabledLK" />
+            </client-only>
+          </div>
+        </div>
+      </base-container>
+    </div>
+  </header>
+</template>
+
+<script>
+// TODO: переписать на composition API
+import { mapGetters } from 'vuex';
+import { storeToRefs } from 'pinia';
+import { computed, defineAsyncComponent } from 'vue';
+import MobileDrawer from '#root/src/components/MobileDrawer/MobileDrawer.vue';
+import BaseContainer from '#root/src/components/BaseComponents/BaseContainer.vue';
+import { CdekButton } from '@cdek-ui-kit/vue';
+import MenuMidLine from '@/components/Menu/MenuMidLine.vue';
+import MenuItem from '@/components/Menu/MenuItem.vue';
+import ClientOnly from '@/components/ClientOnly.vue';
+import LocaleSwitcher from '@/components/LocaleSwitcher.vue';
+import { useMenuStore } from '@/store/pinia/menu/menu';
+import IconsMenu from '@/components/IconsMenu/IconsMenu.vue';
+import useSiteInfo from '@/composables/use-site-info';
+import usePage from '@/composables/use-page';
+import useSettings from '@/composables/use-settings';
+import MobileDrawerIcon from './icons/profile-icon.svg';
+
+export default {
+  name: 'LayoutHeader',
+
+  components: {
+    CdekButton,
+    IconsMenu,
+    LocaleSwitcher,
+    ClientOnly,
+    MobileDrawerIcon,
+    MenuItem,
+    MenuMidLine,
+    MobileDrawer,
+    BaseContainer,
+    Login: defineAsyncComponent(() => import('@/components/Login/Login.vue')),
+  },
+  props: {
+    logo: {
+      type: Object,
+      required: true,
+    },
+    cabinet: {
+      type: Boolean,
+      default() {
+        return false;
+      },
+    },
+  },
+  setup() {
+    const menuStore = useMenuStore();
+
+    const { menu, activePath, activeMenu, individualsSubmenu } = storeToRefs(menuStore);
+
+    const { isRuSite, currentLocale } = useSiteInfo();
+
+    const { isHelpPage } = usePage();
+
+    const paymentLink = computed(() => {
+      return `/${currentLocale.value}/payment`;
+    });
+
+    const rootWithLocale = computed(() => {
+      return `/${currentLocale.value}/`;
+    });
+
+    const { getShowLangSwitcher } = useSettings();
+
+    const isShowLangSwitcher = getShowLangSwitcher();
+
+    return {
+      menu,
+      activePath,
+      activeMenu,
+      individualsSubmenu,
+      menuStore,
+      paymentLink,
+      isRuSite,
+      rootWithLocale,
+      isHelpPage,
+      isShowLangSwitcher,
+    };
+  },
+  computed: {
+    ...mapGetters({
+      screen: 'resize/screen',
+      isActiveCdekId: 'isActiveCdekId',
+      ordersHasUpdates: 'cabinet/ordersHasUpdates',
+      enabledLK: 'auth/enabledLK',
+    }),
+    activeFirstLevelMenu() {
+      return this.activePath[0] || null;
+    },
+    submenu() {
+      if (this.activeFirstLevelMenu?.children?.length) {
+        return this.activeFirstLevelMenu.children;
+      }
+
+      return this.individualsSubmenu;
+    },
+    menuContainer() {
+      return this.$refs.container;
+    },
+    underline() {
+      return this.$refs.underline;
+    },
+    isCabinet() {
+      return this.cabinet;
+    },
+    displaySwitcher() {
+      return !this.cabinet && this.isShowLangSwitcher;
+    },
+  },
+
+  watch: {
+    activeMenu: {
+      immediate: true,
+      handler() {
+        this.$nextTick(() => {
+          this.updateActiveUnderline();
+        });
+      },
+    },
+    screen: {
+      immediate: true,
+      handler(newVal, oldVal = {}) {
+        const { desktop: newDesktop } = newVal;
+        const { desktop: oldDesktop } = oldVal;
+
+        if (newDesktop === oldDesktop) {
+          return;
+        }
+
+        if (newDesktop) {
+          this.updateActiveUnderline();
+        }
+
+        this.menuStore.closeMobileMenu();
+      },
+    },
+  },
+
+  mounted() {
+    this.updateUnderlineOnResize();
+    window.addEventListener('resize', this.updateUnderlineOnResize);
+    this.loadCdekAuthScript();
+  },
+
+  beforeUnmount() {
+    window.removeEventListener('resize', this.updateUnderlineOnResize);
+  },
+
+  methods: {
+    updateActiveUnderline() {
+      if (!this.activeFirstLevelMenu || !this.screen.desktop) {
+        return;
+      }
+
+      const idx = this.activeFirstLevelMenu.id;
+      if (!this.$el) {
+        return;
+      }
+
+      const currentMenu = this.$el.querySelector(`#top-menu-${idx}`);
+
+      if (currentMenu) {
+        const { underline } = this.$refs;
+        if (!underline) {
+          return;
+        }
+
+        const el = currentMenu;
+
+        const rect = el.getBoundingClientRect();
+        const containerRect = this.menuContainer.getBoundingClientRect();
+
+        const translateX = rect.x - containerRect.x;
+
+        underline.style.transform = `translateX(${translateX}px)`;
+        underline.style.width = `${rect.width}px`;
+      } else {
+        setTimeout(this.updateActiveUnderline, 100);
+      }
+    },
+
+    onClick(menu) {
+      if (menu) {
+        this.menuStore.setActiveMenu(menu);
+      }
+    },
+
+    toggleMobileMenu() {
+      this.menuStore.openMobileMenu();
+    },
+
+    updateUnderlineOnResize() {
+      this.updateActiveUnderline();
+    },
+    loadCdekAuthScript() {
+      const url = import.meta.env.VITE_CDEK_AUTH_SCRIPT_URL;
+
+      if (this.isLoggedInCabinet) {
+        return;
+      }
+
+      const script = Object.assign(document.createElement('script'), {
+        async: true,
+        src: url,
+      });
+      document.body.appendChild(script);
+    },
+  },
+};
+</script>
+
+<style lang="scss" scoped>
+.mid-level,
+.top-level,
+.top-level__container {
+  display: flex;
+  align-items: center;
+}
+
+.top-level {
+  align-items: center;
+  justify-content: space-between;
+
+  &__underline {
+    position: absolute;
+    bottom: -1px;
+    transition: $primary-transition;
+    border-bottom: 2px solid $primary-base;
+  }
+
+  &__spacer {
+    height: 1px;
+    box-shadow: inset 0 -1px 0 $ui-gray;
+  }
+
+  &__link {
+    padding: 12px;
+    cursor: pointer;
+    text-decoration: none;
+    letter-spacing: 1px;
+    text-transform: uppercase;
+    color: $grey-transparent;
+    font-size: 12px;
+    font-weight: 400;
+    line-height: 20px;
+
+    &.active {
+      text-shadow: 0 0 1px rgba(0, 0, 0, 0.5);
+    }
+  }
+
+  &__logo {
+    display: inline-flex;
+    flex: 0 0 auto;
+    width: 72px;
+    height: 20px;
+    max-height: 28px;
+    margin: auto 24px auto 0;
+
+    & > img {
+      width: 100%;
+      height: auto;
+    }
+  }
+
+  &__left {
+    position: relative;
+    display: flex;
+    width: 100%;
+    height: 100%;
+    margin: auto;
+  }
+}
+
+.mid-level {
+  align-items: center;
+  flex-direction: row;
+  justify-content: space-between;
+  padding-top: 22px;
+  padding-bottom: 22px;
+
+  &__extra {
+    display: flex;
+    align-items: center;
+
+    &__buttons {
+      display: flex;
+      gap: 16px;
+
+      a {
+        &:deep(.cdek-button) {
+          @include button-1;
+
+          width: 164px;
+          padding: 6px 12px;
+          letter-spacing: 0.4px;
+        }
+      }
+    }
+  }
+
+  &__switcher {
+    margin: 0 12px;
+  }
+}
+
+.mobile-toggle__button {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 40px;
+  height: 40px;
+}
+
+.mobile-toggle.order-notification {
+  position: relative;
+
+  &::after {
+    position: absolute;
+    top: -6px;
+    right: -6px;
+    width: 12px;
+    height: 12px;
+    content: '';
+    border: 2px solid $WhiteColor;
+    border-radius: 12px;
+    background: $ui-orange-base;
+  }
+}
+
+.layout-wrapper {
+  .layout-header__sticky {
+    @include media-min-lg {
+      position: sticky;
+      top: 0;
+    }
+  }
+}
+</style>
diff --git a/parent_dir/src/components/Layout/icons/profile-icon.svg b/parent_dir/src/components/Layout/icons/profile-icon.svg
new file mode 100644
index 0000000..a119c98
--- /dev/null
+++ b/parent_dir/src/components/Layout/icons/profile-icon.svg
@@ -0,0 +1,42 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "22",
+  height: "14",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createElementVNode("rect", {
+  width: "21",
+  height: "2.561",
+  x: ".813",
+  y: "5.392",
+  fill: "#1AB248",
+  rx: "1.28"
+}, null, -1)
+const _hoisted_3 = /*#__PURE__*/_createElementVNode("rect", {
+  width: "21",
+  height: "2.561",
+  x: ".813",
+  y: "10.49",
+  fill: "#1AB248",
+  rx: "1.28"
+}, null, -1)
+const _hoisted_4 = /*#__PURE__*/_createElementVNode("rect", {
+  width: "21",
+  height: "2.561",
+  x: ".813",
+  y: ".294",
+  fill: "#1AB248",
+  rx: "1.28"
+}, null, -1)
+const _hoisted_5 = [
+  _hoisted_2,
+  _hoisted_3,
+  _hoisted_4
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_5))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/components/LocaleSwitcher.vue b/parent_dir/src/components/LocaleSwitcher.vue
new file mode 100644
index 0000000..89b7d64
--- /dev/null
+++ b/parent_dir/src/components/LocaleSwitcher.vue
@@ -0,0 +1,234 @@
+<template>
+  <div
+    v-cdek-click-outside="{
+      exclude: ['button'],
+      handler: closeDropdown,
+    }"
+    class="switch-locale"
+  >
+    <div class="switch-locale__content">
+      <button ref="button" type="button" class="switch-locale__toggle" @click="toggle">
+        <component :is="currentFlag" v-if="currentFlag" class="switch-locale__flag" />
+        <span class="switch-locale__lang">
+          {{ selectedLang }}
+        </span>
+        <span class="switch-locale__icon">
+          <icon-arrow
+            class="switch-locale__icon-arrow"
+            :color="colorArrow"
+            :direction="directionArrow"
+            :width="12"
+            :height="8"
+          />
+        </span>
+      </button>
+    </div>
+    <transition name="dropdown">
+      <div v-if="open" class="switch-locale__dropdown">
+        <a
+          v-for="(locale, index) of locales"
+          :key="index"
+          class="switch-locale__dropdown-item"
+          :class="{
+            'switch-locale__dropdown-item--active': locale.code === currentLocale,
+          }"
+          @click="onChangeLang(locale.code)"
+        >
+          <component
+            :is="getFlag(locale.code)"
+            v-if="getFlag(locale.code)"
+            class="switch-locale__flag"
+          />
+          {{ locale.name }}
+        </a>
+      </div>
+    </transition>
+  </div>
+</template>
+<script lang="ts" setup>
+import { useI18n } from 'vue-i18n';
+import { computed, onMounted, ref } from 'vue';
+import { usePageContext } from '#root/src/composables/use-page-context';
+
+import kz from '@/static/flags/flag_kz.svg';
+import am from '@/static/flags/flag_am.svg';
+import kg from '@/static/flags/flag_kg.svg';
+import by from '@/static/flags/flag_by.svg';
+import ru from '@/static/flags/flag_ru.svg';
+import ge from '@/static/flags/flag_ge.svg';
+import uz from '@/static/flags/flag_uz.svg';
+import az from '@/static/flags/flag_az.svg';
+import IconArrow from '@/components/icon-svg/IconArrow.vue';
+import { $uiBaseColor } from '@/constants/default-colors';
+
+import useSiteInfo from '@/composables/use-site-info';
+import useSettings from '@/composables/use-settings';
+
+const { locale } = useI18n({ useScope: 'global' });
+const flags = {
+  kz,
+  am,
+  kg,
+  by,
+  ru,
+  uz,
+  ge,
+  az,
+};
+const pageContext = usePageContext();
+
+const { isAmSite, isKzSite, currentLocale } = useSiteInfo();
+
+const open = ref(false);
+const closeDropdown = () => {
+  open.value = false;
+};
+const toggle = () => {
+  open.value = !open.value;
+};
+
+const onChangeLang = async (newLocale: string) => {
+  const { urlPathname } = pageContext;
+  const urlWithoutPrefix = urlPathname.replace(`/${locale.value}`, '');
+  window.location.href = `/${newLocale}${urlWithoutPrefix}`;
+};
+
+const { getSettingsGroup } = useSettings();
+
+const locales = getSettingsGroup('locales');
+
+const selectedLang = computed(() => {
+  return currentLocale.value === 'zh' ? '\u4e2d\u6587' : currentLocale.value;
+});
+
+const colorArrow = computed(() => {
+  return open.value ? $uiBaseColor.primaryColor : $uiBaseColor.darkGray;
+});
+const directionArrow = computed(() => {
+  return open.value ? 'top' : 'down';
+});
+
+const sendMindBoxData = () => {
+  if (isAmSite.value || isKzSite.value) {
+    const { mindbox } = window;
+
+    if (mindbox) {
+      const sitePrefix = isKzSite.value ? 'WebsiteKZ' : 'WebsiteAM';
+
+      mindbox('async', {
+        operation: `${sitePrefix}.LanguageCommunication`,
+        data: {
+          customer: {
+            customFields: {
+              languageCommunication: currentLocale.value,
+            },
+          },
+        },
+      });
+    }
+  }
+};
+
+onMounted(() => {
+  sendMindBoxData();
+});
+
+const currentFlag = computed(() => {
+  return flags[currentLocale.value as keyof typeof flags];
+});
+
+const getFlag = (code: string) => {
+  return flags[code as keyof typeof flags];
+};
+</script>
+
+<style lang="scss">
+.switch-locale {
+  display: flex;
+  position: relative;
+  align-items: center;
+
+  &__toggle {
+    display: flex;
+    align-items: center;
+    padding: 0 4px;
+    text-transform: capitalize;
+    outline: none;
+  }
+
+  &__icon {
+    margin-left: 2px;
+    width: 20px;
+    height: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+  }
+
+  &__icon-arrow {
+    width: 6px;
+    height: 10px;
+    transition: $primary-transition;
+  }
+
+  &__dropdown {
+    position: absolute;
+    top: 100%;
+    right: -30px;
+    padding: 8px 0;
+    border: 1px solid #e2e5ec;
+    border-radius: 5px;
+    background: #fff;
+    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+    z-index: 2;
+
+    @media (min-width: $desktop) {
+      right: -4px;
+    }
+  }
+
+  &__dropdown-item {
+    font-weight: 400;
+    font-size: 14px;
+    display: flex;
+    align-items: center;
+    width: 100%;
+    padding: 8px 16px;
+    cursor: pointer;
+    color: $base-color;
+
+    &--active {
+      color: $primary-base;
+    }
+  }
+
+  &__flag {
+    margin-top: -2px;
+    margin-right: 16px;
+    border-radius: 3px;
+
+    @media (min-width: $desktop) {
+      margin-right: 8px;
+    }
+  }
+
+  &__lang {
+    color: $black-dark;
+    font-size: 14px;
+    font-style: normal;
+    font-weight: 400;
+    line-height: 20px;
+    margin-right: 2px;
+  }
+}
+
+.dropdown-enter-active,
+.dropdown-leave-active {
+  transition: opacity $primary-transition, right $primary-transition;
+}
+
+.dropdown-enter-from,
+.dropdown-leave-to {
+  opacity: 0;
+}
+</style>
diff --git a/parent_dir/src/components/Login/LoginModal.vue b/parent_dir/src/components/Login/LoginModal.vue
new file mode 100644
index 0000000..7943d9a
--- /dev/null
+++ b/parent_dir/src/components/Login/LoginModal.vue
@@ -0,0 +1,95 @@
+<template>
+  <base-cdek-modal :name="modalName" @close="close">
+    <cdek-auth
+      :notification-text="notificationText"
+      :alert="alert"
+      :allow-login="allowLogin"
+      :is-redirect="isRedirect"
+      :legal-only="legalOnly"
+      @success="onSuccess"
+    />
+  </base-cdek-modal>
+</template>
+
+<script lang="ts" setup>
+import CdekAuth from '@/components/Auth/CdekAuth.vue';
+import useModal from '@/composables/use-modal';
+import useLoadUser from '@/components/Login/use-load-user';
+import { modalName } from '@/components/Login/consts';
+import BaseCdekModal from '@/components/BaseComponents/BaseCdekModal.vue';
+
+interface LoginAlert {
+  title: string;
+  url: string;
+  target: string;
+}
+
+interface IProps {
+  allowLogin?: boolean;
+  withLoadUser: boolean;
+  isRedirect: boolean;
+  notificationText: string;
+  alert?: LoginAlert;
+  legalOnly?: boolean;
+}
+
+const props = withDefaults(defineProps<IProps>(), { allowLogin: true });
+
+const modal = useModal();
+const userLoader = useLoadUser();
+
+const emit = defineEmits<{
+  (e: 'success'): void;
+}>();
+
+const close = () => {
+  modal.hide(modalName);
+};
+
+const onSuccess = async () => {
+  if (props.withLoadUser) {
+    await userLoader.load();
+  }
+
+  emit('success');
+  modal.hide(modalName);
+};
+</script>
+
+<style lang="scss" scoped>
+.login-modal {
+  display: flex;
+  align-items: center;
+
+  &__content {
+    position: relative;
+    margin: auto;
+    background: #fff;
+    padding: 32px;
+    border-radius: 10px;
+    box-shadow: 0 20px 60px -2px rgba(27, 33, 58, 0.4);
+    max-width: 400px;
+  }
+
+  &.v--modal {
+    padding: 32px 40px;
+    border-radius: 10px;
+  }
+
+  &__close {
+    padding: 22px 18px;
+    outline: none;
+    line-height: 0;
+  }
+
+  &__action {
+    position: absolute;
+    top: 0;
+    right: 0;
+  }
+
+  &__container {
+    max-width: 320px;
+  }
+}
+</style>
diff --git a/parent_dir/src/components/Login/consts.ts b/parent_dir/src/components/Login/consts.ts
new file mode 100644
index 0000000..7ee2216
--- /dev/null
+++ b/parent_dir/src/components/Login/consts.ts
@@ -0,0 +1 @@
+export const modalName = 'login-modal';
diff --git a/parent_dir/src/components/Login/use-advert-agreement.ts b/parent_dir/src/components/Login/use-advert-agreement.ts
new file mode 100644
index 0000000..3f08a36
--- /dev/null
+++ b/parent_dir/src/components/Login/use-advert-agreement.ts
@@ -0,0 +1,35 @@
+import { useStore } from 'vuex';
+import { AdvertAgreement } from '@/types/dto/advertAgreement';
+import useCabinetApi from '@/composables/use-cabinet-api';
+import { captureClientException } from '@/utils/handleErrors/handleErrors';
+
+export default function useAdvertAgreement() {
+  const api = useCabinetApi();
+  const store = useStore();
+
+  const loadStatus = async (): Promise<AdvertAgreement | undefined> => {
+    try {
+      const data: AdvertAgreement = await api.apiClient.getUserAdvertAgreement();
+      store.commit('cabinet/setAgreement', data);
+
+      return data;
+    } catch (error) {
+      captureClientException({ error, place: 'AdvertAgreement' });
+    }
+  };
+
+  const save = async (agreed: boolean) => {
+    store.commit('cabinet/setAgreement', { agreed });
+
+    try {
+      await api.apiClient.saveUserAdvertAgreement(agreed);
+    } catch (error) {
+      captureClientException({ error, place: 'AdvertAgreement' });
+    }
+  };
+
+  return {
+    loadStatus,
+    save,
+  };
+}
diff --git a/parent_dir/src/components/Login/use-confirm-email.ts b/parent_dir/src/components/Login/use-confirm-email.ts
new file mode 100644
index 0000000..a01859b
--- /dev/null
+++ b/parent_dir/src/components/Login/use-confirm-email.ts
@@ -0,0 +1,47 @@
+import { computed, ref } from 'vue';
+import { useStore } from 'vuex';
+import ConfirmCodeModal from '@/components/Modal/EmailConfirmCodeModal.vue';
+import { captureClientException } from '@/utils/handleErrors/handleErrors';
+import useCabinetApi from '@/composables/use-cabinet-api';
+import useModal from '@/composables/use-modal';
+
+export default function useConfirmEmail() {
+  const store = useStore();
+  const currentEmail = computed(() => store.getters['cabinet/getUserEmail']);
+  const modal = useModal();
+  const emailLoading = ref<boolean>(false);
+  const { apiClient } = useCabinetApi();
+
+  const showConfirmModal = (email?: string) => {
+    modal.show({
+      component: ConfirmCodeModal,
+      bind: {
+        email,
+      },
+    });
+  };
+
+  const send = async (email: string | null = null) => {
+    try {
+      emailLoading.value = true;
+      if (!email) {
+        email = currentEmail.value;
+      }
+
+      store.commit('cabinet/setUserEmail', email);
+      await apiClient.setEmail(email);
+
+      showConfirmModal();
+    } catch (error) {
+      captureClientException({ error, place: 'useConfirmEmail' });
+    } finally {
+      emailLoading.value = false;
+    }
+  };
+
+  return {
+    send,
+    emailLoading,
+    showConfirmModal,
+  };
+}
diff --git a/parent_dir/src/components/Login/use-email-on-login.ts b/parent_dir/src/components/Login/use-email-on-login.ts
new file mode 100644
index 0000000..48a1f15
--- /dev/null
+++ b/parent_dir/src/components/Login/use-email-on-login.ts
@@ -0,0 +1,41 @@
+import { computed } from 'vue';
+import { useStore } from 'vuex';
+import useModal from '@/composables/use-modal';
+import useSiteInfo from '@/composables/use-site-info';
+import { useLocalStorage } from '@vueuse/core';
+import EmailFillModal from '@/components/Modal/EmailFillModal.vue';
+import AdvertAgreementModal from '@/components/Modal/AdvertAgreementModal.vue';
+import useAdvertAgreement from './use-advert-agreement';
+
+const ADVERT_AGREEMENT_STORAGE_KEY = 'advert-agreement-status';
+const ADVERT_AGREEMENT_TIMEOUT_PERIOD = 12 * 3600 * 1000; // 12 ча�ов
+
+export default function useEmailOnLogin() {
+  const store = useStore();
+  const modal = useModal();
+  const { isRuSite } = useSiteInfo();
+  const advertAgreement = useAdvertAgreement();
+  const nextTimeAdvert = useLocalStorage<number>(ADVERT_AGREEMENT_STORAGE_KEY, 0);
+  const email = computed(() => store.getters['cabinet/getUserEmail']);
+
+  const check = async () => {
+    if (!email.value) {
+      modal.show({
+        component: EmailFillModal,
+      });
+    } else if (isRuSite.value && nextTimeAdvert.value < Date.now()) {
+      const data = await advertAgreement.loadStatus();
+      nextTimeAdvert.value = Date.now() + ADVERT_AGREEMENT_TIMEOUT_PERIOD;
+
+      if (data?.needRequestAgreement) {
+        modal.show({
+          component: AdvertAgreementModal,
+        });
+      }
+    }
+  };
+
+  return {
+    check,
+  };
+}
diff --git a/parent_dir/src/components/Login/use-load-user.ts b/parent_dir/src/components/Login/use-load-user.ts
new file mode 100644
index 0000000..9f5936b
--- /dev/null
+++ b/parent_dir/src/components/Login/use-load-user.ts
@@ -0,0 +1,65 @@
+import { IS_AUTH_COOKIE_TAG } from '@/constants/cookie-tag';
+import { useStore } from 'vuex';
+import useCabinetApi from '@/composables/use-cabinet-api';
+import { inject } from 'vue';
+import { VueCookies } from 'vue-cookies/types';
+import useTildaUser from '@/composables/use-tilda-user';
+import { sendUserParams } from '@/utils/reach-goal';
+import { captureClientException } from '@/utils/handleErrors/handleErrors';
+import useOrderNotification from './use-order-notification';
+import useEmailOnLogin from './use-email-on-login';
+
+interface LoadParams {
+  withOrderNotification?: boolean;
+}
+
+export default function useLoadUser() {
+  const cookies = inject<VueCookies>('$cookies');
+  const store = useStore();
+  const { apiClient } = useCabinetApi();
+  const tildaUser = useTildaUser();
+  const loadOrderNotification = useOrderNotification();
+  const emailOnLogin = useEmailOnLogin();
+
+  const load = async ({ withOrderNotification = false }: LoadParams = {}) => {
+    try {
+      const res = await apiClient.userMe();
+      const { data } = res.data;
+
+      store.commit('cabinet/setUserProfile', data.profile);
+      store.commit('cabinet/setLoginPhone', data.profile.phone);
+      store.commit('cabinet/setUserContragent', data.contragent);
+      store.commit('cabinet/setUserContragentUUID', data.contragent_uuid);
+      store.commit('cabinet/setCdekidStatus', data.cdekid_status);
+      store.commit('cabinet/setOrdersHasUpdates', data.ordersHasUpdates);
+      store.commit('cabinet/touchLastDateIfUserLoaded');
+
+      cookies?.set(
+        IS_AUTH_COOKIE_TAG,
+        true,
+        new Date(store.getters['keycloak/refreshExpiredAt']).toUTCString(),
+      );
+
+      emailOnLogin.check();
+
+      tildaUser.saveLS({
+        auth: true,
+        cdekId: data.contragent?.cdekId,
+      });
+
+      sendUserParams({ cdek_id: store.getters.isActiveCdekId });
+
+      if (withOrderNotification) {
+        loadOrderNotification();
+      }
+    } catch (error) {
+      cookies?.remove(IS_AUTH_COOKIE_TAG);
+      tildaUser.removeLS();
+      captureClientException({ place: 'login-load-use', error });
+    }
+  };
+
+  return {
+    load,
+  };
+}
diff --git a/parent_dir/src/components/Login/use-login.ts b/parent_dir/src/components/Login/use-login.ts
new file mode 100644
index 0000000..1bba175
--- /dev/null
+++ b/parent_dir/src/components/Login/use-login.ts
@@ -0,0 +1,117 @@
+import { computed, ref } from 'vue';
+import { cdekConsoleError } from '@/utils/console-wrapper';
+import { useStore } from 'vuex';
+import LoginModal from '@/components/Login/LoginModal.vue';
+import useModal from '@/composables/use-modal';
+import { useRestApi } from '@/composables/use-rest-api';
+
+type PrepareLoginCallback = (notificationText: string, alert: unknown, allowLogin: boolean) => void;
+
+interface IOnLogin {
+  defaultNotificationText?: string;
+  isRedirect?: boolean;
+  withLoadUser?: boolean;
+  onSuccess?: () => void;
+}
+
+/**
+ * Взял логику из components/Login/Login.mixin.ts и перевел в композбл
+ * Убавил if>if>if>if...
+ * gql -> rest
+ */
+export default function useLogin(legalOnly = false) {
+  const store = useStore();
+  const { restApi } = useRestApi();
+  const modal = useModal();
+
+  const isChineSite = computed<boolean>(() => store.getters.isChineSite);
+  const currentLocaleISO = computed<string>(() => store.getters.currentLocaleISO);
+  const isLoading = ref(false);
+
+  const prepareDataLogin = async (callback: PrepareLoginCallback, notificationText = '') => {
+    if (isChineSite.value) {
+      window.location.href = 'https://lnx.cdek-express.cn/';
+      return;
+    }
+
+    isLoading.value = true;
+    let alert = null;
+    let allowLogin = true;
+
+    try {
+      const { success } = await restApi.healthCheckNetwork('keycloak');
+
+      if (!success) {
+        notificationText =
+          'Ведутся технические работы, приносим свои извинения. Попробуйте авторизоваться позже.';
+        allowLogin = false;
+      }
+    } catch (e) {
+      cdekConsoleError(e);
+    }
+
+    if (notificationText) {
+      isLoading.value = false;
+      callback(notificationText, alert, allowLogin);
+      return;
+    }
+
+    try {
+      const res = await restApi.websiteComponentAlert({
+        locale: currentLocaleISO.value,
+        url: '/login-modal-alert/',
+      });
+
+      if (!res || !res.length) {
+        return;
+      }
+
+      const alerts = res[0];
+
+      if (!alerts || !alerts.params?.items || alerts.params?.items.length === 0) {
+        return;
+      }
+
+      alert = alerts.params.items[0];
+      const { title } = alert;
+      const newTitle = title.replace('{blocking}', '');
+      allowLogin = title === newTitle;
+      alert.title = newTitle;
+    } catch (e) {
+      cdekConsoleError(e);
+    } finally {
+      isLoading.value = false;
+      callback(notificationText, alert, allowLogin);
+    }
+  };
+
+  const onLogin = ({
+    defaultNotificationText = '',
+    isRedirect = true,
+    withLoadUser = false,
+    onSuccess = () => {},
+  }: IOnLogin = {}) => {
+    prepareDataLogin((notificationText, alert, allowLogin) => {
+      modal.show({
+        component: LoginModal,
+        bind: {
+          notificationText,
+          alert,
+          allowLogin,
+          isRedirect,
+          withLoadUser,
+          legalOnly,
+        },
+        on: {
+          success: onSuccess,
+        },
+      });
+    }, defaultNotificationText);
+  };
+
+  return {
+    prepareDataLogin,
+    isLoading,
+    onLogin,
+  };
+}
diff --git a/parent_dir/src/components/Login/use-order-notification.ts b/parent_dir/src/components/Login/use-order-notification.ts
new file mode 100644
index 0000000..e7e2788
--- /dev/null
+++ b/parent_dir/src/components/Login/use-order-notification.ts
@@ -0,0 +1,17 @@
+import { useStore } from 'vuex';
+import useCabinetApi from '@/composables/use-cabinet-api';
+import { captureClientException } from '@/utils/handleErrors/handleErrors';
+
+export default function useOrderNotification() {
+  const store = useStore();
+  const { apiClient } = useCabinetApi();
+
+  return async () => {
+    try {
+      const ordersHasUpdates = (await apiClient.getOrderNotifications()).ordersHasUpdates;
+      store.commit('cabinet/setOrdersHasUpdates', ordersHasUpdates);
+    } catch (error) {
+      captureClientException({ place: 'useOrderNotification', error });
+    }
+  };
+}
diff --git a/parent_dir/src/components/Login/use-redirect.ts b/parent_dir/src/components/Login/use-redirect.ts
new file mode 100644
index 0000000..6ccc970
--- /dev/null
+++ b/parent_dir/src/components/Login/use-redirect.ts
@@ -0,0 +1,95 @@
+import { useStore } from 'vuex';
+import useModal from '@/composables/use-modal';
+import { useMenuStore } from '@/store/pinia/menu/menu';
+import { navigate } from 'vite-plugin-ssr/client/router';
+import { modalName } from '@/components/Login/consts';
+
+interface RedirectMapItem {
+  from: string;
+  to: string;
+  withParams?: boolean;
+  isCalculate?: boolean;
+  isModal?: boolean;
+}
+
+const redirectMap: RedirectMapItem[] = [
+  {
+    from: 'gifts',
+    to: 'cabinet/gifts',
+  },
+  {
+    from: 'box',
+    to: 'cabinet/calculate',
+    isCalculate: true,
+  },
+  {
+    from: 'profi',
+    to: 'cabinet/calculate',
+    isCalculate: true,
+  },
+  {
+    from: 'tracking',
+    to: 'cabinet/tracking',
+    withParams: true,
+  },
+  {
+    from: 'payment',
+    to: 'payment',
+    isModal: true,
+  },
+];
+
+export function useRedirect() {
+  const store = useStore();
+  const modal = useModal();
+  const menuStore = useMenuStore();
+
+  const preparePathname = (url: string) => {
+    const endSlash = url.match(/\/$/) ? '' : '/';
+
+    return `/${store.getters.currentLocale}/${url}${endSlash}`;
+  };
+
+  const startsWith = (pathname: string) => {
+    return window.location.pathname.startsWith(preparePathname(pathname));
+  };
+
+  return () => {
+    const foundRedirect = redirectMap.find((item) => {
+      return startsWith(item.from) ? item : false;
+    });
+
+    if (foundRedirect) {
+      const params = foundRedirect.withParams ? window.location.search : '';
+
+      if (foundRedirect.isModal) {
+        modal.hide(modalName);
+        menuStore.updateMenuForAuthorized(store.getters.currentLocale);
+        navigate(preparePathname(foundRedirect.to));
+        return;
+      }
+
+      window.location.href = preparePathname(foundRedirect.to) + params;
+      return;
+    }
+
+    try {
+      const urlParams = new URLSearchParams(window.location.search);
+      const redirect = urlParams.get('redirect') ? atob(<string>urlParams.get('redirect')) : null;
+
+      // Делаем проверку, что редирект только внутри �айта – начинаете на /, но не // и не http
+      if (redirect && redirect.match(/^\/[a-z]/)) {
+        window.location.search = '';
+        window.location.href = redirect;
+        return;
+      }
+
+      // Чи�тим лишнее
+      window.history.replaceState(null, '', window.location.pathname);
+    } catch (e) {
+      /* empty */
+    }
+
+    window.location.pathname = preparePathname('cabinet');
+  };
+}
diff --git a/parent_dir/src/components/Login/use-username.ts b/parent_dir/src/components/Login/use-username.ts
new file mode 100644
index 0000000..481ba69
--- /dev/null
+++ b/parent_dir/src/components/Login/use-username.ts
@@ -0,0 +1,10 @@
+import { computed, ComputedRef } from 'vue';
+import { useStore } from 'vuex';
+
+export default function useUsername(): ComputedRef<string> {
+  const store = useStore();
+
+  return computed(() => {
+    return store.state.cabinet.user?.profile?.firstName || store.getters['cabinet/getLoginPhone'];
+  });
+}
diff --git a/parent_dir/src/components/Menu/MenuDropdownArrow.vue b/parent_dir/src/components/Menu/MenuDropdownArrow.vue
new file mode 100644
index 0000000..8cdc34e
--- /dev/null
+++ b/parent_dir/src/components/Menu/MenuDropdownArrow.vue
@@ -0,0 +1,49 @@
+<template>
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    width="16"
+    height="16"
+    viewBox="0 0 16 16"
+    fill="none"
+    class="icon"
+    :class="{ open: isOpen }"
+  >
+    <path
+      d="M4 6L8 10L12 6"
+      :stroke="color"
+      :stroke-opacity="isOpen ? 1 : 0.5"
+      stroke-width="1.5"
+      stroke-linecap="round"
+      stroke-linejoin="round"
+    />
+  </svg>
+</template>
+
+<script>
+export default {
+  name: 'MenuDropdownArrow',
+  props: {
+    isOpen: {
+      type: Boolean,
+      required: true,
+    },
+  },
+  computed: {
+    color() {
+      // Разные написания цветов - из фигмы
+      return this.isOpen ? '#158E3A' : 'black';
+    },
+  },
+};
+</script>
+
+<style scoped lang="scss">
+.icon {
+  transition: $primary-transition;
+  flex-shrink: 0;
+
+  &.open {
+    transform: rotate(180deg);
+  }
+}
+</style>
diff --git a/parent_dir/src/components/Menu/MenuItem.vue b/parent_dir/src/components/Menu/MenuItem.vue
new file mode 100644
index 0000000..adc9893
--- /dev/null
+++ b/parent_dir/src/components/Menu/MenuItem.vue
@@ -0,0 +1,192 @@
+<template>
+  <component
+    :is="component"
+    :to="menu.url"
+    :href="menu.url"
+    :target="target"
+    :prefetch="false"
+    :rel="rel"
+    @click="onClick"
+  >
+    <slot />
+  </component>
+</template>
+
+<script>
+/* global jQuery */
+
+import { mapGetters } from 'vuex';
+import BaseLink from '#root/src/components/BaseComponents/BaseLink.vue';
+import { storeToRefs } from 'pinia';
+import { reachGoal } from '@/utils/reach-goal';
+import { useMenuStore } from '@/store/pinia/menu/menu';
+
+export default {
+  name: 'MenuItem',
+  components: BaseLink,
+  props: {
+    menu: {
+      required: true,
+      type: Object,
+    },
+    tag: {
+      type: [String, Number],
+      required: false,
+      default: 'a',
+    },
+    goal: {
+      type: String,
+      default: '',
+    },
+  },
+  setup() {
+    const menuStore = useMenuStore();
+
+    const { isMobileMenuOpen, activePath } = storeToRefs(menuStore);
+
+    return { isMobileMenuOpen, menuStore, activePath };
+  },
+  computed: {
+    ...mapGetters({
+      isLoggedInCabinet: 'isLoggedInCabinet',
+      isChineSite: 'isChineSite',
+      isSite: 'isSite',
+    }),
+    isChinaTrigger() {
+      return this.isChineSite && this.menu.id === 105;
+    },
+    isExternalLink() {
+      return this.menu.url && this.menu.url.startsWith('http');
+    },
+    target() {
+      return this.isExternalLink ? '_blank' : '_self';
+    },
+    isCustomComponent() {
+      return this.component === 'nuxt-link' || this.component === 'router-link';
+    },
+    component() {
+      if (this.isChinaTrigger) {
+        return 'button';
+      }
+
+      if (this.tag && this.tag !== 'a') {
+        return this.isExternalLink ? 'a' : this.tag;
+      }
+
+      if (!this.isLoggedInCabinet) {
+        return this.isExternalLink ? 'a' : BaseLink;
+      }
+
+      if (this.isSite) {
+        return this.isExternalLink || this.menu.url.includes('/cabinet/') ? 'a' : BaseLink;
+      }
+
+      return [
+        '/orders',
+        '/cdekid',
+        '/receipts',
+        '/tickets',
+        '/returns',
+        '/offers',
+        '/calculate',
+      ].some((el) => this.menu.url.endsWith(el))
+        ? BaseLink
+        : 'a';
+    },
+    rel() {
+      if (this.menu?.isExternal) {
+        return 'external';
+      }
+
+      return this.menu?.url?.includes('/cabinet/') ? 'external' : null;
+    },
+  },
+
+  mounted() {
+    if (!this.isChinaTrigger) {
+      return;
+    }
+
+    this.loadJquery();
+  },
+
+  methods: {
+    toggleMobileMenu() {
+      if (this.menu.children && this.menu.children.length > 0) {
+        return;
+      }
+
+      this.closeMenu();
+    },
+    loadJquery() {
+      if (!document.getElementById('jquery')) {
+        const chartScript = document.createElement('script');
+        chartScript.src = 'https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js';
+        chartScript.id = 'jquery';
+        chartScript.async = true;
+        chartScript.referrerpolicy = 'no-referrer';
+        document.head.appendChild(chartScript);
+
+        chartScript.onload = () => {
+          this.loadFirstScript();
+        };
+      }
+    },
+    loadFirstScript() {
+      if (!document.getElementById('chinaFirst')) {
+        const chartScript = document.createElement('script');
+        chartScript.src =
+          'https://corp.cdek.ru/s/d41d8cd98f00b204e9800998ecf8427e-CDN/1w4yf8/810001/f726c0ccd5628076e8a005c87160ce33/2.2.4.7//download/batch/com.atlassian.plugins.jquery:jquery/com.atlassian.plugins.jquery:jquery.js?collectorId=ad987a27';
+        chartScript.id = 'chinaFirst';
+
+        chartScript.type = 'text/javascript';
+        chartScript.async = true;
+        chartScript.referrerpolicy = 'no-referrer';
+        document.head.appendChild(chartScript);
+
+        chartScript.onload = () => {
+          jQuery.ajax({
+            url: 'https://corp.cdek.ru/s/6485a1252ff75c0e3773a77535b72841-T/1w4yf8/810001/f726c0ccd5628076e8a005c87160ce33/4.0.1/_/download/batch/com.atlassian.jira.collector.plugin.jira-issue-collector-plugin:issuecollector-embededjs/com.atlassian.jira.collector.plugin.jira-issue-collector-plugin:issuecollector-embededjs.js?locale=ru-RU&collectorId=ad987a27',
+            type: 'get',
+            cache: true,
+            dataType: 'script',
+          });
+        };
+      }
+    },
+    async onClick() {
+      if (this.goal) {
+        reachGoal(this.goal);
+      }
+
+      if (this.tag !== 'button') {
+        if (this.target !== '_blank' && this.menu.id !== undefined) {
+          this.menuStore.setActiveMenu(this.menu);
+        }
+
+        if (this.isMobileMenuOpen) {
+          this.menuStore.closeMobileMenu();
+        }
+      }
+
+      if (!this.isChinaTrigger) {
+        return;
+      }
+
+      const trigger = document.getElementById('atlwdg-trigger');
+
+      if (!trigger) {
+        return;
+      }
+
+      trigger.click();
+    },
+  },
+};
+</script>
+
+<style lang="scss">
+a[id='atlwdg-trigger'] {
+  display: none;
+}
+</style>
diff --git a/parent_dir/src/components/Menu/MenuMidLine.vue b/parent_dir/src/components/Menu/MenuMidLine.vue
new file mode 100644
index 0000000..280ac80
--- /dev/null
+++ b/parent_dir/src/components/Menu/MenuMidLine.vue
@@ -0,0 +1,209 @@
+<template>
+  <div class="mid-level-menu">
+    <template v-if="menus.length > 0">
+      <div v-for="(menu, idx) in menus" :key="getKey(menu.id)" class="mid-level-menu__item">
+        <VDropdown
+          :distance="12"
+          placement="bottom-start"
+          popper-class="header-popover"
+          :delay="{ show: 100 }"
+          @apply-show="onPopoverOpen(menu.children, idx)"
+          @hide="onPopoverClose()"
+        >
+          <menu-item
+            :menu="menu"
+            :tag="menu.children && menu.children.length && 'button'"
+            class="mid-level-menu__button"
+            :class="{
+              active:
+                idx === popoverIdx || (activePath && activePath[1] && activePath[1].id === menu.id),
+            }"
+          >
+            {{ menu.title }}
+
+            <menu-new-label v-if="menu.isNew" class="mid-level-menu__label" />
+
+            <menu-dropdown-arrow
+              v-if="menu.children && menu.children.length"
+              class="mid-level-menu__arrow"
+              :is-open="idx === popoverIdx"
+            />
+          </menu-item>
+
+          <template v-if="selectedMenus.length > 0" #popper>
+            <div
+              class="popover-menu__container"
+              :class="{
+                'popover-menu__container__four': isFourLvl,
+                'popover-menu__container__icons': hasIcons,
+              }"
+            >
+              <menu-popover-item
+                v-for="ch in selectedMenus"
+                :key="ch.id"
+                v-close-popper
+                :menu="ch"
+                class="popover-menu__item"
+                :has-icons="hasIcons"
+              />
+            </div>
+          </template>
+        </VDropdown>
+      </div>
+    </template>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { useMenuStore } from '@/store/pinia/menu/menu';
+import { storeToRefs } from 'pinia';
+import { computed, nextTick, ref, watch } from 'vue';
+import IMenuItem from '@/types/dto/menuItem';
+import MenuItem from '@/components/Menu/MenuItem.vue';
+import MenuNewLabel from '@/components/Menu/MenuNewLabel.vue';
+import MenuDropdownArrow from '@/components/Menu/MenuDropdownArrow.vue';
+import MenuPopoverItem from '@/components/Menu/MenuPopoverItem.vue';
+import useSiteInfo from '@/composables/use-site-info';
+import { usePageContext } from '@/composables/use-page-context';
+
+interface IMenuMidLine {
+  menus: IMenuItem[];
+}
+
+defineProps<IMenuMidLine>();
+
+const menuStore = useMenuStore();
+const { activePath } = storeToRefs(menuStore);
+
+const popoverIdx = ref<number | null>(null);
+const selectedMenus = ref<IMenuItem[]>([]);
+const isFourLvl = ref(false);
+
+const { isAuthorizedUser } = usePageContext();
+
+const { isLoggedInCabinet } = useSiteInfo();
+
+const onPopoverOpen = async (menus: IMenuItem[], idx: number) => {
+  await nextTick();
+  selectedMenus.value = menus;
+  popoverIdx.value = idx;
+};
+
+const onPopoverClose = () => {
+  popoverIdx.value = null;
+};
+
+const hasIcons = computed(() => {
+  return selectedMenus.value.some((el) => !!el.icon);
+});
+
+watch(
+  selectedMenus,
+  () => {
+    isFourLvl.value = selectedMenus.value.some((menu) => {
+      return menu.children.length > 0;
+    });
+  },
+  { deep: true },
+);
+
+const getKey = (id: number) => {
+  if (isLoggedInCabinet.value || isAuthorizedUser) {
+    return `isAuthorized-${id}`;
+  }
+
+  return id;
+};
+</script>
+
+<style scoped lang="scss">
+.mid-level-menu {
+  display: flex;
+  align-items: center;
+  height: 36px;
+  gap: 20px;
+
+  &__item {
+    display: flex;
+  }
+
+  &__button {
+    display: flex;
+    align-items: center;
+    cursor: pointer;
+    transition: $primary-transition;
+    text-decoration: none;
+    color: $base-color;
+    font-size: 14px;
+    font-weight: 500;
+    line-height: 20px;
+
+    &:hover,
+    &.active {
+      color: $Primary_Active;
+
+      :deep(path) {
+        stroke: $Primary_Active;
+        stroke-opacity: 1;
+      }
+    }
+  }
+
+  &__arrow {
+    margin-left: 4px;
+  }
+
+  &__label {
+    margin: 0 0 0 8px;
+  }
+}
+
+.popover-menu {
+  &__container {
+    display: inline-flex;
+    align-items: flex-start;
+    padding: 8px;
+    flex-wrap: wrap;
+    column-gap: 16px;
+    max-width: 100%;
+    width: 100%;
+
+    &__four {
+      gap: 16px;
+    }
+
+    &__icons {
+      width: 744px;
+    }
+  }
+}
+</style>
+
+<style lang="scss">
+.header-popover.v-popper--theme-dropdown {
+  .v-popper__arrow-container {
+    display: none;
+  }
+
+  .v-popper__inner {
+    display: none;
+    border: none;
+    padding: 0;
+    border-radius: 8px;
+    box-shadow: 0 4px 12px 0 rgba(0, 0, 0, 0.04);
+    background: $Peak;
+    min-width: 584px;
+    max-width: 744px;
+    width: min-content;
+
+    // Не знаю как иначе добраться до этого элемента, в доке тултипа не нашел для него класса
+    & > div {
+      display: flex;
+    }
+
+    @include media-min-xl {
+      display: block;
+    }
+  }
+}
+</style>
diff --git a/parent_dir/src/components/Menu/MenuNewLabel.vue b/parent_dir/src/components/Menu/MenuNewLabel.vue
new file mode 100644
index 0000000..c239661
--- /dev/null
+++ b/parent_dir/src/components/Menu/MenuNewLabel.vue
@@ -0,0 +1,20 @@
+<template>
+  <span class="new-label"> new </span>
+</template>
+
+<script setup lang="ts"></script>
+
+<style scoped lang="scss">
+.new-label {
+  padding: 2px 8px;
+  text-decoration: none;
+  color: $WhiteColor;
+  border-radius: 4px;
+  background: $Attention;
+  font-size: 12px;
+  font-weight: 500;
+  line-height: 14px;
+  max-height: 18px;
+  text-transform: uppercase;
+}
+</style>
diff --git a/parent_dir/src/components/Menu/MenuPopoverItem.vue b/parent_dir/src/components/Menu/MenuPopoverItem.vue
new file mode 100644
index 0000000..42cb262
--- /dev/null
+++ b/parent_dir/src/components/Menu/MenuPopoverItem.vue
@@ -0,0 +1,116 @@
+<template>
+  <menu-popover-item-children v-if="menu.children?.length > 0" :menu="menu" />
+  <menu-item
+    v-else
+    :menu="menu"
+    :goal="menu.url.includes('inter') ? 'inter_header' : ''"
+    class="menu-popover-item"
+    :class="{ active: isActive, 'menu-popover-item__children': hasChildren }"
+  >
+    <div class="menu-popover-item__container">
+      <div
+        class="menu-popover-item__title"
+        :class="{ 'menu-popover-item__title__children': hasChildren }"
+      >
+        <div v-html="menu.title" />
+
+        <menu-new-label v-if="menu.isNew" class="menu-popover-item__label" />
+      </div>
+      <div v-if="menu.text" class="menu-popover-item__description" v-html="menu.text" />
+    </div>
+
+    <template v-if="hasIcons">
+      <img v-if="menu.icon" :src="menu.icon" alt="" />
+      <menu-placeholder-icon v-else alt="" class="menu-popover-item__icon" />
+    </template>
+  </menu-item>
+</template>
+<script setup lang="ts">
+import MenuPlaceholderIcon from '#root/src/components/MobileDrawer/icons/mobile-drawer-placeholder-icon.svg';
+import { storeToRefs } from 'pinia';
+import { computed } from 'vue';
+import { useMenuStore } from '@/store/pinia/menu/menu';
+import MenuNewLabel from '@/components/Menu/MenuNewLabel.vue';
+import MenuItem from '@/components/Menu/MenuItem.vue';
+import MenuPopoverItemChildren from '@/components/Menu/MenuPopoverItemChildren.vue';
+import IMenuItem from '@/types/dto/menuItem';
+
+interface IMenuPopoverItemProps {
+  menu: IMenuItem;
+  hasIcons: boolean;
+}
+
+const props = defineProps<IMenuPopoverItemProps>();
+
+const menuStore = useMenuStore();
+
+const { activePath } = storeToRefs(menuStore);
+
+const isActive = computed(() => {
+  return activePath.value[2]?.id === props.menu?.id || activePath.value[3]?.id === props.menu?.id;
+});
+
+const hasChildren = computed(() => {
+  return props.menu.children.length > 0;
+});
+</script>
+
+<style scoped lang="scss">
+.menu-popover-item {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  padding: 8px;
+  transition: $primary-transition;
+  text-decoration: none;
+  border-radius: 8px;
+  gap: 24px;
+
+  img {
+    width: 56px;
+    height: 56px;
+  }
+
+  &__icon {
+    max-width: 56px;
+  }
+
+  &__container {
+    display: flex;
+    flex-direction: column;
+    width: 260px;
+  }
+
+  &__title {
+    display: flex;
+    gap: 8px;
+
+    > div {
+      color: #232323;
+      font-family: Roboto, serif;
+      font-size: 14px;
+      font-style: normal;
+      font-weight: 500;
+      line-height: 20px; /* 142.857% */
+    }
+
+    .menu-popover-item__label {
+      max-height: 18px;
+      margin-right: 4px;
+    }
+  }
+
+  &__description {
+    width: 260px;
+    color: $grey-transparent;
+    font-size: 12px;
+    font-weight: 400;
+    line-height: 16px;
+  }
+
+  &:hover:not(&__children),
+  &.active:not(&__children) {
+    background: $Primary_10;
+  }
+}
+</style>
diff --git a/parent_dir/src/components/MobileCloseLine/MobileCloseLine.vue b/parent_dir/src/components/MobileCloseLine/MobileCloseLine.vue
new file mode 100644
index 0000000..0bd5f20
--- /dev/null
+++ b/parent_dir/src/components/MobileCloseLine/MobileCloseLine.vue
@@ -0,0 +1,56 @@
+<template>
+  <div :id="id" class="mobile-close-line">
+    <div class="mobile-close-line__trigger" />
+  </div>
+</template>
+
+<script>
+export default {
+  name: 'MobileCloseLine',
+  emits: ['swipe-up', 'swipe-down'],
+  data() {
+    return {
+      // В пределах одной �траницы может быть не�колько таких линий.
+      id: `tocuh-${Math.floor(Math.random() * 10000)}`,
+    };
+  },
+  mounted() {
+    const touchEl = document.querySelector(`#${this.id}`);
+
+    if (touchEl) {
+      import('hammerjs').then(({ default: Hammer }) => {
+        const hammer = new Hammer(touchEl);
+        hammer.get('swipe').set({ direction: Hammer.DIRECTION_VERTICAL });
+
+        hammer.on('swipe', (e) => {
+          const isSwipeDown = e.deltaY > 0;
+          isSwipeDown ? this.$emit('swipe-down') : this.$emit('swipe-up');
+        });
+      });
+    }
+  },
+};
+</script>
+
+<style scoped lang="scss">
+.mobile-close-line {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: 20px;
+
+  @media (min-width: $desktop) {
+    display: none;
+  }
+
+  &__trigger {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 56px;
+    height: 4px;
+    border-radius: 100px;
+    background-color: rgba(29, 29, 27, 0.3);
+  }
+}
+</style>
diff --git a/parent_dir/src/components/MobileDrawer/MobileDrawer.vue b/parent_dir/src/components/MobileDrawer/MobileDrawer.vue
new file mode 100644
index 0000000..2b9dfd8
--- /dev/null
+++ b/parent_dir/src/components/MobileDrawer/MobileDrawer.vue
@@ -0,0 +1,54 @@
+<template>
+  <div>
+    <mobile-drawer-first-level :cabinet="cabinet" @second-level-expanded="onExpanded($event)" />
+    <mobile-drawer-second-level
+      :selected-menu="selectedSubmenu"
+      @second-level-closed="selectedSubmenu = null"
+    />
+  </div>
+</template>
+
+<script>
+import MobileDrawerFirstLevel from '#root/src/components/MobileDrawer/MobileDrawerFirstLevel.vue';
+import MobileDrawerSecondLevel from '#root/src/components/MobileDrawer/MobileDrawerSecondLevel.vue';
+import { storeToRefs } from 'pinia';
+import { useMenuStore } from '@/store/pinia/menu/menu';
+
+export default {
+  name: 'MobileDrawer',
+  components: {
+    MobileDrawerSecondLevel,
+    MobileDrawerFirstLevel,
+  },
+  props: {
+    cabinet: Boolean,
+    mobileMenu: Boolean,
+  },
+  setup() {
+    const menuStore = useMenuStore();
+
+    const { menus, isMobileMenuOpen } = storeToRefs(menuStore);
+
+    return { menus, isMobileMenuOpen };
+  },
+  data() {
+    return { selectedSubmenu: null };
+  },
+  watch: {
+    isMobileMenuOpen(val) {
+      if (val) {
+        document.documentElement.classList.add('mobile-menu-opened');
+        return;
+      }
+
+      document.documentElement.classList.remove('mobile-menu-opened');
+      this.selectedSubmenu = null;
+    },
+  },
+  methods: {
+    onExpanded(menus) {
+      this.selectedSubmenu = menus;
+    },
+  },
+};
+</script>
diff --git a/parent_dir/src/components/MobileDrawer/MobileDrawerFirstLevel.vue b/parent_dir/src/components/MobileDrawer/MobileDrawerFirstLevel.vue
new file mode 100644
index 0000000..7ab50c9
--- /dev/null
+++ b/parent_dir/src/components/MobileDrawer/MobileDrawerFirstLevel.vue
@@ -0,0 +1,135 @@
+<template>
+  <slide-left-transition>
+    <div v-if="isMobileMenuOpen" class="mobile-drawer-first-level">
+      <mobile-drawer-header>
+        <locale-switcher v-if="isShowLangSwitcher" />
+      </mobile-drawer-header>
+
+      <div class="mobile-drawer-first-level__buttons">
+        <mobile-drawer-user :cabinet="cabinet" />
+
+        <div v-if="isRuSite" class="mobile-drawer-first-level__payment_wrapper">
+          <a :href="paymentLink" @click="closeMenu">
+            <cdek-button theme="outline" small class="mobile-drawer-first-level__payment">
+              {{ $t('menu.links.payment') }}
+            </cdek-button>
+          </a>
+        </div>
+      </div>
+
+      <icons-menu />
+
+      <div class="mobile-drawer__menu">
+        <mobile-drawer-menu-item
+          v-for="(rootMenu, index) in menus"
+          :key="index"
+          :root-menu="rootMenu"
+          class="mobile-drawer__menu-item"
+          @expanded="onExpanded"
+        />
+      </div>
+    </div>
+  </slide-left-transition>
+</template>
+
+<script setup lang="ts">
+import MobileDrawerHeader from '#root/src/components/MobileDrawer/MobileDrawerHeader.vue';
+import SlideLeftTransition from '#root/src/components/Transitions/SlideLeftTransition.vue';
+import MobileDrawerMenuItem from '#root/src/components/MobileDrawer/MobileDrawerMenuItem.vue';
+import { storeToRefs } from 'pinia';
+import { computed } from 'vue';
+import { CdekButton } from '@cdek-ui-kit/vue';
+import LocaleSwitcher from '@/components/LocaleSwitcher.vue';
+import { useMenuStore } from '@/store/pinia/menu/menu';
+import type IMenuItem from '@/types/dto/menuItem';
+import IconsMenu from '@/components/IconsMenu/IconsMenu.vue';
+import useSiteInfo from '@/composables/use-site-info';
+import useSettings from '@/composables/use-settings';
+import MobileDrawerUser from './MobileDrawerUser.vue';
+
+interface IMobileDrawerFirstLevel {
+  cabinet: boolean;
+}
+
+defineProps<IMobileDrawerFirstLevel>();
+
+const emit = defineEmits<{
+  (e: 'second-level-expanded', submenu: IMenuItem): void;
+}>();
+
+const menuStore = useMenuStore();
+
+const { menus, isMobileMenuOpen } = storeToRefs(menuStore);
+
+const { getShowLangSwitcher } = useSettings();
+
+const isShowLangSwitcher = getShowLangSwitcher();
+
+const { isRuSite, currentLocaleISO } = useSiteInfo();
+
+const paymentLink = computed(() => {
+  return `/${currentLocaleISO.value}/payment`;
+});
+
+const closeMenu = () => {
+  menuStore.closeMobileMenu();
+};
+
+const onExpanded = (submenu: IMenuItem) => {
+  emit('second-level-expanded', submenu);
+};
+</script>
+<style scoped lang="scss">
+.mobile-drawer__menu {
+  margin-top: 24px;
+}
+
+.mobile-drawer-first-level {
+  &__payment_wrapper {
+    padding-left: 16px;
+    padding-right: 16px;
+    margin-bottom: 24px;
+
+    @include media-min-sm {
+      max-width: 320px;
+    }
+  }
+}
+
+.mobile-drawer-first-level__dogovor {
+  margin: 12px 16px;
+  display: flex;
+  justify-content: center;
+}
+</style>
+<style lang="scss">
+.mobile-drawer-first-level {
+  position: fixed;
+  z-index: 10;
+  top: 0;
+  right: 0;
+  overflow-y: auto;
+  width: 100%;
+  height: 100%;
+  transform: translate3d(0, 0, 0);
+  background-color: #fff;
+
+  .menu-city-title {
+    text-align: right;
+    color: #a5a5a5;
+    font-size: 16px;
+    line-height: 19px;
+  }
+
+  .menu-city-value {
+    display: inline-block;
+    font-size: 16px;
+  }
+
+  .menu-city {
+    width: auto;
+    margin: 24px 16px;
+    padding-left: 0;
+  }
+}
+</style>
diff --git a/parent_dir/src/components/MobileDrawer/MobileDrawerHeader.vue b/parent_dir/src/components/MobileDrawer/MobileDrawerHeader.vue
new file mode 100644
index 0000000..1abae0f
--- /dev/null
+++ b/parent_dir/src/components/MobileDrawer/MobileDrawerHeader.vue
@@ -0,0 +1,56 @@
+<template>
+  <div class="mobile-drawer-header">
+    <slot>
+      <img class="mobile-drawer-header__logo" :src="siteLogo.src" alt="logo" />
+    </slot>
+    <button class="mobile-drawer-header__close" @click="closeMenu">
+      <mobile-drawer-close />
+    </button>
+  </div>
+</template>
+<script setup>
+import { useMenuStore } from '@/store/pinia/menu/menu';
+import useSettings from '@/composables/use-settings';
+import MobileDrawerClose from './icons/mobile-drawer-close-icon.svg';
+
+const menuStore = useMenuStore();
+
+const { getSettingsGroup } = useSettings();
+
+const siteLogo = getSettingsGroup('logo');
+const closeMenu = () => {
+  menuStore.closeMobileMenu();
+};
+</script>
+
+<style scoped lang="scss">
+.mobile-drawer-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 16px;
+  box-shadow: 0 4px 4px 0 rgba(0, 0, 0, 0.05);
+  position: relative;
+
+  .mobile-drawer-header__cap {
+    width: 31px;
+    height: 31px;
+    position: absolute;
+    top: 2px;
+    left: 4px;
+    transform: rotate(-30deg);
+  }
+
+  &__logo {
+    height: 20px;
+  }
+
+  &__close {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 24px;
+    height: 24px;
+  }
+}
+</style>
diff --git a/parent_dir/src/components/MobileDrawer/MobileDrawerMenuItem.vue b/parent_dir/src/components/MobileDrawer/MobileDrawerMenuItem.vue
new file mode 100644
index 0000000..831797e
--- /dev/null
+++ b/parent_dir/src/components/MobileDrawer/MobileDrawerMenuItem.vue
@@ -0,0 +1,130 @@
+<template>
+  <div class="mobile-drawer-menu-item">
+    <menu-item
+      :menu="rootMenu"
+      class="mobile-drawer-menu-item__link mobile-drawer-menu-item__link--root"
+    >
+      <div class="mobile-drawer-menu-item__root_wrapper">
+        {{ rootMenu.title }}
+        <menu-dropdown-arrow :is-open="false" class="mobile-drawer-menu-item__arrow" />
+      </div>
+    </menu-item>
+
+    <ul class="mobile-drawer-menu-item-submenu">
+      <li
+        v-for="(submenu, index) in rootMenu.children"
+        :key="index"
+        class="mobile-drawer-menu-item-submenu__item"
+      >
+        <menu-item
+          :menu="submenu"
+          :tag="submenu.children && submenu.children.length && 'button'"
+          class="mobile-drawer-menu-item__link"
+          @click="showChildList(submenu)"
+        >
+          <span>
+            {{ submenu.title }}
+            <menu-new-label v-if="submenu.isNew" class="mobile-drawer-menu-item__label" />
+          </span>
+
+          <menu-dropdown-arrow
+            v-if="submenu.children && submenu.children.length"
+            :is-open="false"
+            class="mobile-drawer-menu-item__arrow"
+          />
+        </menu-item>
+      </li>
+    </ul>
+  </div>
+</template>
+
+<script>
+import MenuNewLabel from '@/components/Menu/MenuNewLabel.vue';
+import MenuDropdownArrow from '@/components/Menu/MenuDropdownArrow.vue';
+import MenuItem from '@/components/Menu/MenuItem.vue';
+
+export default {
+  name: 'MobileDrawerMenuItem',
+
+  components: {
+    MenuDropdownArrow,
+    MenuNewLabel,
+    MenuItem,
+  },
+  props: {
+    rootMenu: {
+      type: Object,
+      required: true,
+    },
+  },
+  emits: ['expanded'],
+
+  methods: {
+    showChildList(submenu) {
+      this.$emit('expanded', submenu);
+    },
+  },
+};
+</script>
+
+<style scoped lang="scss">
+.mobile-drawer-menu-item {
+  &__link {
+    display: flex;
+    justify-content: space-between;
+    width: 100%;
+    text-decoration: none;
+    color: $base-color;
+    font-size: 14px;
+    font-weight: 500;
+    line-height: 20px;
+
+    &--active {
+      color: $primary-base;
+    }
+
+    &--root {
+      width: 100%;
+      padding: 10px 16px;
+      background: $Tertiary_10;
+      margin-bottom: 8px;
+      box-sizing: border-box;
+    }
+  }
+
+  &__root_wrapper {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    width: 100%;
+  }
+
+  &__arrow {
+    transform: rotate(-90deg);
+  }
+
+  &__label {
+    margin-left: 8px;
+    text-decoration: none;
+  }
+
+  &-submenu {
+    &__item {
+      display: flex;
+      align-items: center;
+      justify-content: flex-start;
+      padding: 10px 16px;
+      color: #232323;
+      font-family: Roboto, serif;
+      font-size: 14px;
+      font-style: normal;
+      font-weight: 500;
+      line-height: 20px; /* 142.857% */
+
+      &:last-child {
+        margin-bottom: 16px;
+      }
+    }
+  }
+}
+</style>
diff --git a/parent_dir/src/components/MobileDrawer/MobileDrawerSecondLevel.vue b/parent_dir/src/components/MobileDrawer/MobileDrawerSecondLevel.vue
new file mode 100644
index 0000000..7124a03
--- /dev/null
+++ b/parent_dir/src/components/MobileDrawer/MobileDrawerSecondLevel.vue
@@ -0,0 +1,89 @@
+<template>
+  <slide-left-transition>
+    <div v-if="selectedMenu" class="mobile-drawer-second-level">
+      <mobile-drawer-header>
+        <button class="mobile-drawer-second-level__header" @click="$emit('second-level-closed')">
+          <mobile-drawer-back-icon class="mobile-drawer-second-level__back" />
+
+          {{ selectedMenu.title }}
+        </button>
+      </mobile-drawer-header>
+
+      <ul class="mobile-drawer-second-level-menu">
+        <li
+          v-for="(menu, index) in selectedMenu.children"
+          :key="index"
+          class="mobile-drawer-second-level-menu__item"
+        >
+          <deep-menu-item :menu="menu" :has-icons="hasIcons" />
+        </li>
+      </ul>
+    </div>
+  </slide-left-transition>
+</template>
+<script setup></script>
+<script>
+import MobileDrawerHeader from '#root/src/components/MobileDrawer/MobileDrawerHeader.vue';
+import SlideLeftTransition from '#root/src/components/Transitions/SlideLeftTransition.vue';
+import DeepMenuItem from '#root/src/components/MobileDrawer/MobileDrawerDeepMenuItem.vue';
+import MobileDrawerBackIcon from './icons/mobile-drawer-back-icon.svg';
+
+export default {
+  name: 'MobileDrawerSecondLevel',
+  components: {
+    DeepMenuItem,
+    SlideLeftTransition,
+    MobileDrawerHeader,
+    MobileDrawerBackIcon,
+  },
+  props: {
+    selectedMenu: {
+      type: Object,
+      default: null,
+    },
+  },
+  emits: ['second-level-closed'],
+  computed: {
+    hasIcons() {
+      return !!this.selectedMenu.children.find((el) => !!el.icon);
+    },
+  },
+};
+</script>
+
+<style lang="scss">
+.mobile-drawer-second-level {
+  position: fixed;
+  z-index: 11;
+  top: 0;
+  right: 0;
+  overflow-y: auto;
+  width: 100%;
+  height: 100%;
+  background-color: #fff;
+
+  &__header {
+    display: flex;
+    align-items: center;
+    color: $Bottom;
+    font-family: Roboto, serif;
+    font-size: 14px;
+    font-style: normal;
+    font-weight: 500;
+    line-height: 20px; /* 142.857% */
+  }
+
+  &__back {
+    margin-right: 12px;
+  }
+
+  &-menu {
+    margin-top: 16px;
+
+    &__item {
+      list-style: none;
+      margin: 0;
+    }
+  }
+}
+</style>
diff --git a/parent_dir/src/components/MobileDrawer/MobileDrawerUser.vue b/parent_dir/src/components/MobileDrawer/MobileDrawerUser.vue
new file mode 100644
index 0000000..fcf1a7c
--- /dev/null
+++ b/parent_dir/src/components/MobileDrawer/MobileDrawerUser.vue
@@ -0,0 +1,150 @@
+<template>
+  <div v-if="enabledLK" class="mobile-user">
+    <div v-if="cabinet" id="header-cabinet-place-mobile" />
+
+    <template v-if="isLoggedInCabinet">
+      <a :href="`/${locale}/cabinet/`" class="mobile-user__item" @click.stop="closeMenu">
+        <span class="mobile-user__item-icon"><icon-user /></span>
+        <span class="mobile-user__item-text">{{ userName }}</span>
+      </a>
+      <button class="mobile-user__item" @click="logOut">
+        <span class="mobile-user__item-icon"><icon-logout /></span>
+        <span class="mobile-user__item-text">{{ $t('lk.menu.logOut') }}</span>
+      </button>
+    </template>
+    <template v-else-if="enabledLoginBtn">
+      <div class="mobile-user__item">
+        <span v-if="isLoading" class="mobile-user__item-loader">
+          <base-loader :old="false" />
+        </span>
+        <cdek-button v-test-id="'auth-login-btn'" small @click="login">
+          {{ $t('lk.menu.logIn') }}</cdek-button
+        >
+      </div>
+    </template>
+  </div>
+</template>
+
+<script>
+import { mapGetters } from 'vuex';
+import BaseLoader from '@/components/BaseComponents/BaseLoader.vue';
+import useUsername from '@/components/Login/use-username';
+import useLogin from '@/components/Login/use-login';
+import { useMenuStore } from '@/store/pinia/menu/menu';
+import { storeToRefs } from 'pinia';
+import { CdekButton } from '@cdek-ui-kit/vue';
+import useLogout from '@/composables/use-logout';
+import { onMounted, onUnmounted } from 'vue';
+import IconUser from './icons/mobile-drawer-user.svg';
+import IconLogout from './icons/mobile-drawer-logout.svg';
+
+export default {
+  name: 'MobileDrawerUser',
+  components: {
+    CdekButton,
+    BaseLoader,
+    IconUser,
+    IconLogout,
+  },
+  props: {
+    cabinet: {
+      type: Boolean,
+    },
+  },
+  setup() {
+    const userName = useUsername();
+    const { isLoading, onLogin } = useLogin();
+    const { logOut } = useLogout();
+    const menuStore = useMenuStore();
+
+    const { enabledLoginBtn } = storeToRefs(menuStore);
+
+    onMounted(() => {
+      // Этот костыль обязателен для кабинета
+      menuStore.setUserMenuOpen(true);
+    });
+
+    onUnmounted(() => {
+      // Этот костыль обязателен для кабинета
+      menuStore.setUserMenuOpen(false);
+    });
+
+    return {
+      onLogin,
+      isLoading,
+      userName,
+      enabledLoginBtn,
+      menuStore,
+      logOut,
+    };
+  },
+  computed: {
+    ...mapGetters({
+      isLoggedInCabinet: 'isLoggedInCabinet',
+      enabledLK: 'auth/enabledLK',
+      locale: 'currentLocaleISO',
+    }),
+  },
+  methods: {
+    login() {
+      this.menuStore.closeMobileMenu();
+      this.onLogin();
+    },
+  },
+};
+</script>
+
+<style scoped lang="scss">
+.mobile-user {
+  margin-bottom: 12px;
+
+  &__item {
+    cursor: pointer;
+    margin-top: 24px;
+    padding: 0 16px;
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    width: 100%;
+    text-decoration: none;
+    text-align: left;
+
+    :deep(.cdek-button) {
+      width: 100%;
+
+      @include media-min-sm {
+        max-width: 288px;
+      }
+    }
+
+    &-loader,
+    &-icon {
+      width: 24px;
+      height: 24px;
+      flex-basis: 24px;
+      margin-right: 16px;
+    }
+
+    &-text {
+      flex: 1;
+      width: 100%;
+      color: #000;
+      font-size: 14px;
+      font-weight: 400;
+      line-height: 20px;
+      max-width: 100%;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+
+    &:hover {
+      text-decoration: none;
+
+      .mobile-user__item-text {
+        color: rgba(21, 142, 58, 1);
+      }
+    }
+  }
+}
+</style>
diff --git a/parent_dir/src/components/MobileDrawer/icons/mobile-drawer-back-icon.svg b/parent_dir/src/components/MobileDrawer/icons/mobile-drawer-back-icon.svg
new file mode 100644
index 0000000..6ca9989
--- /dev/null
+++ b/parent_dir/src/components/MobileDrawer/icons/mobile-drawer-back-icon.svg
@@ -0,0 +1,24 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "24",
+  height: "24",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createElementVNode("path", {
+  stroke: "#1BB249",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-miterlimit": "10",
+  "stroke-width": "1.5",
+  d: "M9.57 5.93 3.5 12l6.07 6.07M20.5 12H3.67"
+}, null, -1)
+const _hoisted_3 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_3))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/components/MobileDrawer/icons/mobile-drawer-close-icon.svg b/parent_dir/src/components/MobileDrawer/icons/mobile-drawer-close-icon.svg
new file mode 100644
index 0000000..ab7f714
--- /dev/null
+++ b/parent_dir/src/components/MobileDrawer/icons/mobile-drawer-close-icon.svg
@@ -0,0 +1,35 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "17",
+  height: "17",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createElementVNode("rect", {
+  width: "21",
+  height: "2.561",
+  x: "15.189",
+  y: "16.803",
+  fill: "#1AB248",
+  rx: "1.28",
+  transform: "rotate(-135 15.19 16.803)"
+}, null, -1)
+const _hoisted_3 = /*#__PURE__*/_createElementVNode("rect", {
+  width: "21",
+  height: "2.561",
+  x: ".34",
+  y: "14.992",
+  fill: "#1AB248",
+  rx: "1.28",
+  transform: "rotate(-45 .34 14.992)"
+}, null, -1)
+const _hoisted_4 = [
+  _hoisted_2,
+  _hoisted_3
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_4))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/components/MobileDrawer/icons/mobile-drawer-logout.svg b/parent_dir/src/components/MobileDrawer/icons/mobile-drawer-logout.svg
new file mode 100644
index 0000000..9807cf2
--- /dev/null
+++ b/parent_dir/src/components/MobileDrawer/icons/mobile-drawer-logout.svg
@@ -0,0 +1,22 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  viewBox: "0 0 24 24"
+}
+const _hoisted_2 = /*#__PURE__*/_createElementVNode("path", {
+  stroke: "#1AB248",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "2",
+  d: "M14 8V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h7a2 2 0 0 0 2-2v-2m-7-4h14m0 0-3-3m3 3-3 3"
+}, null, -1)
+const _hoisted_3 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_3))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/components/MobileDrawer/icons/mobile-drawer-placeholder-icon.svg b/parent_dir/src/components/MobileDrawer/icons/mobile-drawer-placeholder-icon.svg
new file mode 100644
index 0000000..4558d3d
--- /dev/null
+++ b/parent_dir/src/components/MobileDrawer/icons/mobile-drawer-placeholder-icon.svg
@@ -0,0 +1,17 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock, createStaticVNode as _createStaticVNode } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "56",
+  height: "56",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createStaticVNode("<mask id=\"a\" width=\"56\" height=\"56\" x=\"0\" y=\"0\" maskUnits=\"userSpaceOnUse\" style=\"mask-type:alpha;\"><path fill=\"#C4C4C4\" d=\"M0 0h56v56H0z\"></path></mask><g mask=\"url(#a)\"><rect width=\"56\" height=\"56\" fill=\"#F5F5F5\" rx=\"4\"></rect></g><path stroke=\"#1D1D1B\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-opacity=\".3\" stroke-width=\"2\" d=\"m19 19 18 18m-6-13h.01M24 20h9a3 3 0 0 1 3 3v9m-16-1 4-4c.928-.893 2.072-.893 3 0l5 5m.32-3.66c.577-.06 1.162.162 1.68.66l2 2m-.879 4.122A3 3 0 0 1 33 36H23a3 3 0 0 1-3-3V23c0-.833.34-1.587.888-2.131l14.233 14.253Z\"></path>", 3)
+const _hoisted_5 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_5))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/components/MobileDrawer/icons/mobile-drawer-user.svg b/parent_dir/src/components/MobileDrawer/icons/mobile-drawer-user.svg
new file mode 100644
index 0000000..2579f3c
--- /dev/null
+++ b/parent_dir/src/components/MobileDrawer/icons/mobile-drawer-user.svg
@@ -0,0 +1,22 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  viewBox: "0 0 24 24"
+}
+const _hoisted_2 = /*#__PURE__*/_createElementVNode("path", {
+  stroke: "#1AB248",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "2",
+  d: "M6.168 18.849A4 4 0 0 1 10 16h4a4 4 0 0 1 3.834 2.855M21 12a9 9 0 1 1-18 0 9 9 0 0 1 18 0Zm-6-2a3 3 0 1 1-6 0 3 3 0 0 1 6 0Z"
+}, null, -1)
+const _hoisted_3 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_3))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/components/Modal/AdvertAgreementModal.vue b/parent_dir/src/components/Modal/AdvertAgreementModal.vue
new file mode 100644
index 0000000..5fd9d12
--- /dev/null
+++ b/parent_dir/src/components/Modal/AdvertAgreementModal.vue
@@ -0,0 +1,132 @@
+<template>
+  <vue-final-modal
+    content-class="cabinet-modal advert-agreement-modal"
+    :name="name"
+    :click-to-close="false"
+    :classes="['cabinet-modal-container']"
+  >
+    <modal-close-btn :name="name" @close="answer(false)" />
+    <div class="wrap">
+      <div class="title">
+        {{ t('advertAgreement.title') }}
+      </div>
+      <div class="description">
+        {{ t('advertAgreement.description') }}
+      </div>
+      <div class="actions">
+        <cdek-button class="btn" @click="answer(true)">{{ t('subscribe') }}</cdek-button>
+        <cdek-button class="btn" theme="outline" @click="answer(false)">{{
+          t('advertAgreement.cancel')
+        }}</cdek-button>
+      </div>
+      <div class="note">
+        <i18n-t keypath="advertAgreement.note.text">
+          <template #link>
+            <a
+              href="https://www.cdek.ru/storage/source/docs/agreement_pd_ad_info_msg.pdf"
+              target="_blank"
+              class="note__link"
+            >
+              {{ t('advertAgreement.note.link') }}
+            </a>
+          </template>
+        </i18n-t>
+      </div>
+    </div>
+  </vue-final-modal>
+</template>
+
+<script setup lang="ts">
+import { CdekButton } from '@cdek-ui-kit/vue';
+import { useI18n } from 'vue-i18n';
+import useModal from '@/composables/use-modal';
+import useAdvertAgreement from '@/components/Login/use-advert-agreement';
+import { reachGoal } from '@/utils/reach-goal';
+import { ADVERT_AGREEMENT } from '@/constants/metrics';
+import ModalCloseBtn from './CloseBtn.vue';
+
+const name = 'advert-agreement-modal';
+
+const { t } = useI18n();
+const modal = useModal();
+const { save } = useAdvertAgreement();
+
+const answer = (agreed: boolean) => {
+  save(agreed);
+  modal.hide(name);
+};
+
+reachGoal(ADVERT_AGREEMENT.LK_AD);
+</script>
+
+<style lang="scss">
+.cabinet-modal.advert-agreement-modal {
+  @include media-min-md {
+    width: 100%;
+    max-width: 588px;
+    padding: 32px;
+    background-image: url('./assets/balloon.png');
+    background-size: 310px 310px;
+    background-repeat: no-repeat;
+    background-position: bottom -68px right -110px;
+  }
+}
+</style>
+
+<style scoped lang="scss">
+.wrap {
+  @include media-min-md {
+    max-width: 408px;
+  }
+}
+
+.title {
+  @include headline-5;
+
+  margin-bottom: 8px;
+
+  @include media-min-md {
+    @include headline-4;
+  }
+}
+
+.description {
+  @include body-1;
+}
+
+.btn {
+  @include media-min-md {
+    max-width: 160px;
+  }
+}
+
+.actions {
+  margin-top: 32px;
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+
+  @include media-min-md {
+    flex-direction: row;
+    gap: 12px;
+  }
+}
+
+.note {
+  @include caption-1;
+
+  line-height: 18px;
+  color: $Bottom_60;
+  margin-top: 24px;
+  text-align: center;
+
+  @include media-min-md {
+    margin-top: 16px;
+    text-align: left;
+  }
+
+  .note__link {
+    color: $Bottom_60;
+  }
+}
+</style>
diff --git a/parent_dir/src/components/Modal/CloseBtn.vue b/parent_dir/src/components/Modal/CloseBtn.vue
new file mode 100644
index 0000000..3d15b84
--- /dev/null
+++ b/parent_dir/src/components/Modal/CloseBtn.vue
@@ -0,0 +1,92 @@
+<template>
+  <div class="close-btn-wrap">
+    <button class="btn" @click="close"><icon-close /></button>
+    <div ref="lineRef" class="line">
+      <div class="trigger" />
+    </div>
+  </div>
+</template>
+
+<script lang="ts" setup>
+import useModal from '@/composables/use-modal';
+import { onBeforeUnmount, onMounted, ref } from 'vue';
+import IconClose from './assets/close-green.svg';
+
+const props = defineProps<{ name: string }>();
+const emit = defineEmits<{
+  (e: 'close'): void;
+}>();
+
+const modal = useModal();
+
+const lineRef = ref<HTMLElement>(null as unknown as HTMLElement);
+let hammer: any;
+
+const close = () => {
+  emit('close');
+  modal.hide(props.name);
+};
+
+onMounted(() => {
+  import('hammerjs').then(({ default: Hammer }) => {
+    hammer = new Hammer(lineRef.value);
+    hammer.get('swipe').set({ direction: Hammer.DIRECTION_VERTICAL });
+
+    hammer.on('swipe', (e: { deltaY: number }) => {
+      if (e.deltaY > 0) {
+        close();
+      }
+    });
+  });
+});
+
+onBeforeUnmount(() => {
+  hammer.destroy();
+});
+</script>
+
+<style lang="scss" scoped>
+.close-btn-wrap {
+  width: 100%;
+  position: relative;
+  margin-top: -16px;
+  margin-bottom: 16px;
+
+  @include media-min-md {
+    margin: 0;
+    height: 0;
+    line-height: 0;
+  }
+}
+
+.btn {
+  position: absolute;
+  top: -8px;
+  right: -8px;
+  height: 24px;
+  width: 24px;
+  display: none;
+
+  @include media-min-md {
+    display: block;
+  }
+}
+
+.line {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: 28px;
+
+  @include media-min-md {
+    display: none;
+  }
+}
+
+.trigger {
+  width: 64px;
+  height: 4px;
+  border-radius: 100px;
+  background-color: $Bottom_20;
+}
+</style>
diff --git a/parent_dir/src/components/Modal/EmailConfirmCodeModal.vue b/parent_dir/src/components/Modal/EmailConfirmCodeModal.vue
new file mode 100644
index 0000000..bc72dda
--- /dev/null
+++ b/parent_dir/src/components/Modal/EmailConfirmCodeModal.vue
@@ -0,0 +1,438 @@
+<template>
+  <vue-final-modal
+    content-class="confirm-code-email-modal base-modal--confirm-code-email"
+    :name="name"
+    :classes="['vfm-modal-container']"
+  >
+    <div class="v-modal-confirm-code-email-modal">
+      <div class="width-wrapper">
+        <template v-if="!confirmSuccess">
+          <base-loader v-if="confirmLoading" class="confirm-code-email-modal__loader" />
+          <icon-close class="confirm-code-email-modal__close" @click="close" />
+          <h2 class="confirm-code-email-modal__title">
+            {{ $t('confirmEmailModal.emailConfirm') }}
+          </h2>
+          <p class="confirm-code-email-modal__text">{{ $t('confirmEmailModal.emailCode') }}</p>
+          <div class="confirm-code-email-modal__field-code">
+            <div v-if="confirmError" class="confirm-code-email-modal__field-code-error">
+              {{ $t('confirmEmailModal.emailCodeError') }}
+            </div>
+            <base-input
+              ref="numb1"
+              v-model="form.numb1"
+              v-test-id="'email-confirm-code1'"
+              inputmode="numeric"
+              class="confirm-code-email-modal__field-code-input"
+              :old="false"
+              :clear-button="false"
+              :disabled="confirmLoading"
+              :has-error="confirmError"
+              @input="(e) => onChangeCode(e, 'numb1')"
+              @keydown="(e) => onKeyDown(e, 'numb1')"
+            />
+            <base-input
+              ref="numb2"
+              v-model="form.numb2"
+              v-test-id="'email-confirm-code2'"
+              inputmode="numeric"
+              class="confirm-code-email-modal__field-code-input"
+              :old="false"
+              :clear-button="false"
+              :disabled="confirmLoading"
+              :has-error="confirmError"
+              @input="(e) => onChangeCode(e, 'numb2')"
+              @keydown="(e) => onKeyDown(e, 'numb2')"
+            />
+            <base-input
+              ref="numb3"
+              v-model="form.numb3"
+              v-test-id="'email-confirm-code3'"
+              inputmode="numeric"
+              class="confirm-code-email-modal__field-code-input"
+              :old="false"
+              :clear-button="false"
+              :disabled="confirmLoading"
+              :has-error="confirmError"
+              @input="(e) => onChangeCode(e, 'numb3')"
+              @keydown="(e) => onKeyDown(e, 'numb3')"
+            />
+            <base-input
+              ref="numb4"
+              v-model="form.numb4"
+              v-test-id="'email-confirm-code4'"
+              inputmode="numeric"
+              class="confirm-code-email-modal__field-code-input"
+              :old="false"
+              :clear-button="false"
+              :disabled="confirmLoading"
+              :has-error="confirmError"
+              @input="(e) => onChangeCode(e, 'numb4')"
+              @keydown="(e) => onKeyDown(e, 'numb4')"
+            />
+          </div>
+          <div class="confirm-code-email-modal__actions">
+            <base-button
+              v-test-id="'email-confirm-code-btn'"
+              :loading="sendCodeLoading"
+              :disabled="disabledButtonResetCode"
+              primary
+              class="base-button--block"
+              @click="onResetCode"
+            >
+              <template v-if="disabledButtonResetCode">
+                <i18n-t keypath="confirmEmailModal.sendEmailAgain">
+                  <template #time>
+                    <timer
+                      v-if="disabledButtonResetCode"
+                      :current="currentTime"
+                      :deadline="deadlineTime"
+                      @stop-timer="stopTimer"
+                    />
+                  </template>
+                </i18n-t>
+              </template>
+              <template v-else> {{ $t('confirmEmailModal.sendEmailAgainBtn') }} </template>
+            </base-button>
+          </div>
+        </template>
+      </div>
+    </div>
+  </vue-final-modal>
+</template>
+
+<script>
+import { mapGetters, mapMutations } from 'vuex';
+import moment from 'moment';
+import { useToast } from '@cdek-ui-kit/vue';
+import { cdekConsoleError } from '@/utils/console-wrapper';
+import useCabinetApi from '@/composables/use-cabinet-api';
+import Timer from '@/components/Timer.vue';
+import IconClose from './assets/close-green.svg';
+import BaseLoader from '../BaseComponents/BaseLoader.vue';
+import BaseButton from '../BaseComponents/BaseButton.vue';
+import BaseInput from '../BaseComponents/BaseInput.vue';
+
+export default {
+  name: 'EmailConfirmCodeModal',
+
+  components: {
+    BaseLoader,
+    BaseButton,
+    BaseInput,
+    IconClose,
+    Timer,
+  },
+
+  props: {
+    email: {
+      type: String,
+      default: '',
+    },
+  },
+
+  setup() {
+    const { apiClient: api } = useCabinetApi();
+
+    return {
+      toast: useToast(),
+      api,
+    };
+  },
+
+  data() {
+    const currentTime = new Date();
+    return {
+      name: 'confirm-code-email-modal',
+      form: {
+        numb1: '',
+        numb2: '',
+        numb3: '',
+        numb4: '',
+      },
+      currentTime,
+      deadlineTime: moment(currentTime).add(1, 'minutes').format(),
+      disabledButtonResetCode: true,
+      confirmLoading: false,
+      confirmSuccess: false,
+      confirmError: false,
+      sendCodeLoading: false,
+      isCodeValid: false,
+    };
+  },
+
+  computed: {
+    ...mapGetters({
+      userEmail: 'cabinet/getUserEmail',
+    }),
+    code() {
+      return [this.form.numb1, this.form.numb2, this.form.numb3, this.form.numb4].join('');
+    },
+    isCodeFull() {
+      return this.code.length === 4;
+    },
+  },
+
+  methods: {
+    ...mapMutations({
+      setUserEmailConfirmed: 'cabinet/setUserEmailConfirmed',
+      setUserEmail: 'cabinet/setUserEmail',
+    }),
+    async sendCodeToEmail() {
+      const email = this.userEmail;
+
+      try {
+        this.sendCodeLoading = true;
+        await this.api.setEmail(email);
+      } catch (e) {
+        cdekConsoleError(e.message);
+      } finally {
+        this.sendCodeLoading = false;
+      }
+    },
+    onFocus() {
+      if (!this.form.numb1) {
+        this.$refs.numb1.$refs.field.focus();
+      } else if (!this.form.numb2) {
+        this.$refs.numb2.$refs.field.focus();
+      } else if (!this.form.numb3) {
+        this.$refs.numb3.$refs.field.focus();
+      } else if (!this.form.numb4) {
+        this.$refs.numb4.$refs.field.focus();
+      }
+    },
+    onFocusByNumb(numb) {
+      this.$refs[numb].$refs.field.focus();
+    },
+    onBlur() {
+      this.$refs.numb1.$refs.field.blur();
+      this.$refs.numb2.$refs.field.blur();
+      this.$refs.numb3.$refs.field.blur();
+      this.$refs.numb4.$refs.field.blur();
+    },
+    stopTimer() {
+      this.disabledButtonResetCode = false;
+    },
+    runTimer() {
+      this.currentTime = new Date();
+      this.deadlineTime = moment(this.currentTime).add(1, 'minutes').format();
+    },
+    onResetCode() {
+      this.sendCodeToEmail();
+      this.runTimer();
+      this.disabledButtonResetCode = true;
+      this.onBlur();
+    },
+    onChangeCode(value = '', field = '') {
+      const onlyNumb = value.replace(/^[a-zA-Z!@#$%^&*)(+=._-]+$/g, '').trim();
+      if (onlyNumb.length > 1) {
+        this.form[field] = onlyNumb[onlyNumb.length - 1];
+      } else {
+        this.form[field] = onlyNumb;
+      }
+      const nextField = parseFloat(field.replace('numb', '')) + 1;
+      if (nextField < 5) {
+        this.onFocusByNumb(`numb${nextField}`);
+      }
+      this.checkCode();
+    },
+    onKeyDown(event, field) {
+      if (event.keyCode === 8) {
+        event.preventDefault();
+        const prevField = parseFloat(field.replace('numb', '')) - 1;
+        this.form[field] = '';
+        this.form[`numb${prevField}`] = '';
+        if (prevField > 0) {
+          this.onFocusByNumb(`numb${prevField}`);
+        }
+      }
+    },
+    checkCode() {
+      setTimeout(() => {
+        if (this.isCodeFull) {
+          this.confirmEmail(this.code);
+        }
+      });
+    },
+    async confirmEmail(code) {
+      try {
+        this.confirmError = false;
+        this.confirmLoading = true;
+        const email = this.email || this.userEmail;
+        await this.api.confirmEmail(email, code);
+        this.setUserEmail(email);
+        this.setUserEmailConfirmed(true);
+
+        this.confirmSuccess = true;
+
+        const isMobile = window?.matchMedia('(max-width: 768px)');
+        this.toast.success(
+          {
+            title: this.$t('confirmEmailModal.emailConfirmSuccess'),
+          },
+          {
+            position: isMobile.matches ? 'top-center' : 'top-right',
+          },
+        );
+        this.close();
+      } catch (e) {
+        this.confirmError = true;
+        this.clearCode();
+        cdekConsoleError(e);
+      } finally {
+        this.confirmLoading = false;
+      }
+    },
+    clearCode() {
+      this.form.numb1 = '';
+      this.form.numb2 = '';
+      this.form.numb3 = '';
+      this.form.numb4 = '';
+      this.onBlur();
+    },
+    close() {
+      this.$modal.hide(this.name);
+    },
+  },
+};
+</script>
+
+<style lang="scss">
+.confirm-code-email-modal {
+  position: relative;
+
+  &__loader {
+    position: absolute;
+    z-index: 10;
+    bottom: calc(50% - 52px);
+    left: calc(50% - 10px);
+  }
+
+  &__title {
+    margin-bottom: 4px;
+    font-size: 24px;
+    font-style: normal;
+    font-weight: 500;
+    line-height: 32px;
+  }
+
+  &__text {
+    margin-bottom: 16px;
+    font-size: 16px;
+    font-style: normal;
+    font-weight: 400;
+    line-height: 24px;
+  }
+
+  &__actions {
+    button {
+      margin-bottom: 10px;
+
+      &:last-child {
+        margin-bottom: 0;
+      }
+    }
+  }
+
+  &__success {
+    display: flex;
+    align-items: center;
+    flex-direction: column;
+    justify-content: center;
+
+    svg {
+      margin-bottom: 20px;
+    }
+  }
+
+  &__field-code {
+    position: relative;
+    display: flex;
+    margin-bottom: 40px;
+    gap: 16px;
+    justify-content: space-between;
+
+    &:last-child {
+      margin-right: 0;
+    }
+
+    &-input {
+      .base-control__field {
+        width: 66px;
+        height: 66px;
+        text-align: center;
+        border-width: 2px;
+        font-size: 40px;
+        font-style: normal;
+        font-weight: 300;
+        line-height: 50px;
+        padding: 18px;
+        border-radius: 8px;
+        border: 2px solid var(--bottom-bottom-20, rgba(0, 0, 0, 0.2));
+
+        @include media-min-sm {
+          min-width: 84px;
+          min-height: 84px;
+        }
+      }
+    }
+
+    &-error {
+      position: absolute;
+      right: 0;
+      bottom: -17px;
+      left: 0;
+      flex: 1 1 100%;
+      color: $ui-red-base;
+      font-size: 12px;
+      line-height: 14px;
+    }
+  }
+
+  &__close {
+    position: absolute;
+    right: 16px;
+    top: 16px;
+    cursor: pointer;
+    width: 24px;
+    height: 24px;
+  }
+}
+
+.v-modal-confirm-code-email-modal {
+  padding: 24px;
+}
+
+.base-modal--confirm-code-email {
+  border-radius: 16px;
+  background: $Peak;
+  box-shadow: 0 20px 40px -5px rgba(0, 0, 0, 0.2);
+  padding: 0;
+  width: 100%;
+
+  @include media-min-sm {
+    width: 432px;
+  }
+}
+</style>
+
+<style lang="scss" scoped>
+.base-button--primary {
+  font-size: 14px;
+  font-style: normal;
+  font-weight: 500;
+  line-height: 24px;
+  letter-spacing: 0.4px;
+  text-transform: uppercase;
+  padding: 12px;
+  cursor: pointer;
+}
+
+.base-button--primary:disabled:not(.base-button--loading) {
+  color: $Peak;
+  background-color: $Button_Disable;
+}
+
+.base-control {
+  width: auto;
+}
+</style>
diff --git a/parent_dir/src/components/Modal/EmailFillModal.vue b/parent_dir/src/components/Modal/EmailFillModal.vue
new file mode 100644
index 0000000..65becdb
--- /dev/null
+++ b/parent_dir/src/components/Modal/EmailFillModal.vue
@@ -0,0 +1,181 @@
+<template>
+  <vue-final-modal
+    content-class="cabinet-modal require-email-modal"
+    :name="name"
+    :click-to-close="false"
+    :classes="['cabinet-modal-container']"
+  >
+    <modal-close-btn :name="name" />
+    <div class="title">
+      {{ t('fillEmailModal.title') }}
+    </div>
+    <div class="description">
+      {{ t('fillEmailModal.description') }}
+    </div>
+
+    <cdek-form class="form" @submit="setEmail">
+      <div class="form-control">
+        <cdek-form-control
+          v-test-id="'email-confirm-input'"
+          label="Email"
+          name="email"
+          :rules="!activatedRules ? 'required' : 'required|email'"
+          @blur="activateRules"
+        />
+      </div>
+      <cdek-checkbox v-if="isRuSite" v-model="agree" class="checkbox">
+        <i18n-t keypath="advertAgreement.checkbox.text">
+          <template #link>
+            <a
+              href="https://www.cdek.ru/storage/source/docs/agreement_pd_ad_info_msg.pdf"
+              target="_blank"
+            >
+              {{ t('advertAgreement.checkbox.link') }}
+            </a>
+          </template>
+        </i18n-t>
+      </cdek-checkbox>
+      <cdek-button
+        v-test-id="'email-confirm-btn'"
+        class="step-actions__btn"
+        type="submit"
+        :loading="isLoading"
+      >
+        {{ t('confirm') }}
+      </cdek-button>
+    </cdek-form>
+  </vue-final-modal>
+</template>
+
+<script setup lang="ts">
+import { useStore } from 'vuex';
+import { reachGoal } from '@/utils/reach-goal';
+import { CdekButton, CdekForm, CdekFormControl, useToast, formSettings } from '@cdek-ui-kit/vue';
+import { computed, ref } from 'vue';
+import useModal from '@/composables/use-modal';
+import { useI18n } from 'vue-i18n';
+import CdekCheckbox from '@/components/BaseComponents/CdekCheckbox.vue';
+import useAdvertAgreement from '@/components/Login/use-advert-agreement';
+import useConfirmEmail from '@/components/Login/use-confirm-email';
+import { ShowError } from '@/types/error';
+import { ADVERT_AGREEMENT } from '@/constants/metrics';
+import useCabinetApi from '@/composables/use-cabinet-api';
+import useSiteInfo from '@/composables/use-site-info';
+import { captureClientException } from '@/utils/handleErrors/handleErrors';
+import ModalCloseBtn from './CloseBtn.vue';
+
+const name = 'require-email-modal';
+
+const activatedRules = ref(false);
+const isLoading = ref(false);
+const { apiClient } = useCabinetApi();
+const store = useStore();
+const confirm = useConfirmEmail();
+const modal = useModal();
+const toast = useToast();
+const advertAgreement = useAdvertAgreement();
+const { t } = useI18n();
+const { isRuSite } = useSiteInfo();
+
+const locale = computed(() => store.getters.currentLocale);
+
+const uiKitAddMessages = (rule: string, message: string) => {
+  formSettings.addMessages(rule, {
+    [locale.value]: message,
+  });
+};
+
+const isMobile = window?.matchMedia('(max-width: 768px)');
+const toastSettings = {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  position: isMobile.matches ? 'top-center' : 'top-right',
+};
+const agree = ref(false);
+
+const activateRules = () => {
+  activatedRules.value = true;
+};
+
+const setEmail = async (values: { email: string }) => {
+  isLoading.value = true;
+
+  try {
+    await apiClient.setEmail(values.email);
+    store.commit('cabinet/setUserEmail', values.email);
+
+    if (isRuSite.value) {
+      advertAgreement.save(agree.value);
+
+      if (agree.value) reachGoal(ADVERT_AGREEMENT.LK_MAIL_AD_CONFIRM);
+    }
+
+    modal.hide(name);
+    confirm.showConfirmModal();
+  } catch (e) {
+    const errors = (e as ShowError).response?.data?.errors || [];
+
+    toast.error(
+      {
+        title: t('error'),
+        text: errors[0] || '',
+      },
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      toastSettings,
+    );
+
+    captureClientException({ error: e, place: 'FillEmailModal' });
+  } finally {
+    isLoading.value = false;
+  }
+};
+
+if (isRuSite.value) reachGoal(ADVERT_AGREEMENT.LK_MAIL);
+
+uiKitAddMessages('email', t('validEmail'));
+uiKitAddMessages('required', t('requiredField'));
+</script>
+
+<style lang="scss">
+.require-email-modal {
+  @include media-min-md {
+    max-width: 432px;
+  }
+}
+</style>
+
+<style scoped lang="scss">
+.title {
+  @include headline-5;
+
+  margin-bottom: 8px;
+
+  @include media-min-md {
+    @include headline-4;
+
+    margin-bottom: 4px;
+  }
+}
+
+.description {
+  @include body-1;
+}
+
+.form {
+  margin-top: 16px;
+}
+
+.form-control {
+  // �а �ам cdek-form-control кла�� вешает�� без scoped (баго-фича) по�тому враппер
+  margin-bottom: 16px;
+
+  :deep(.cdek-input__tip:empty) {
+    display: none;
+  }
+}
+
+.checkbox {
+  margin-bottom: 40px;
+}
+</style>
diff --git a/parent_dir/src/components/Modal/SelectCountryModal/ConfirmCountryModal.vue b/parent_dir/src/components/Modal/SelectCountryModal/ConfirmCountryModal.vue
new file mode 100644
index 0000000..016eb5c
--- /dev/null
+++ b/parent_dir/src/components/Modal/SelectCountryModal/ConfirmCountryModal.vue
@@ -0,0 +1,182 @@
+<template>
+  <vue-final-modal
+    ref="modal"
+    :classes="['confirm-country']"
+    content-class="confirm-country__content"
+    :name="name"
+  >
+    <mobile-close-line class="confirm-country__mobile-controls" @swipe-down="onSwipeDown" />
+
+    <div class="confirm-country__title">
+      {{ $t('selectCountry.confirmCountry.title') }}&nbsp;<b>{{ countryName }}</b
+      >{{ $t('selectCountry.confirmCountry.sign') }}
+    </div>
+    <div class="confirm-country__buttons">
+      <base-button primary sm class="confirm-country__button" @click="onConfirm">{{
+        $t('selectCountry.confirmCountry.yes')
+      }}</base-button>
+      <base-button secondary sm class="confirm-country__button" @click="onSelect">{{
+        $t('selectCountry.confirmCountry.no')
+      }}</base-button>
+    </div>
+  </vue-final-modal>
+</template>
+
+<script>
+import stopScrollOpenModal from '@/components/Modal/stop-scroll-open-modal-mixin';
+import MobileCloseLine from '@/components/MobileCloseLine/MobileCloseLine.vue';
+import BaseButton from '@/components/BaseComponents/BaseButton.vue';
+import { COOKIE_CONFIRM_COUNTRY } from '@/constants/cookie-tag';
+import SelectCountryModal from '@/components/Modal/SelectCountryModal/SelectCountryModal.vue';
+
+export default {
+  name: 'ConfirmCountryModal',
+  components: {
+    BaseButton,
+    MobileCloseLine,
+  },
+  mixins: [stopScrollOpenModal],
+  data() {
+    return {
+      name: 'confirm-country-modal',
+    };
+  },
+  computed: {
+    countryName() {
+      return this.$t(`selectCountry.${this.$store.getters.websiteId}`);
+    },
+  },
+  methods: {
+    onClose() {
+      this.$modal.hide(this.name);
+    },
+    onSwipeDown() {
+      this.onClose();
+    },
+    onConfirm() {
+      this.$cookies.set(COOKIE_CONFIRM_COUNTRY, 1, {
+        maxAge: 60 * 60 * 24 * 30, // 30 дней
+      });
+      this.onClose();
+    },
+    onSelect() {
+      this.onClose();
+      this.$modal.show({ component: SelectCountryModal });
+    },
+  },
+};
+</script>
+<style lang="scss">
+.confirm-country {
+  display: flex;
+  align-items: flex-end;
+
+  &__content {
+    width: 100%;
+    padding: 16px;
+    transition: $primary-transition;
+    background-color: #fff;
+    position: relative;
+    top: 0;
+    right: 0;
+    border-top-left-radius: 8px;
+    border-top-right-radius: 8px;
+  }
+
+  @include media-min-lg {
+    align-items: center;
+
+    &__content {
+      width: auto;
+      margin: auto;
+      height: auto;
+      padding: 20px;
+      border-radius: 8px;
+      box-shadow: 0 4px 15px rgba(0, 0, 0, 0.15);
+      position: absolute;
+      top: 132px;
+      right: 88px;
+    }
+  }
+}
+</style>
+
+<style scoped lang="scss">
+.confirm-country {
+  position: fixed;
+  z-index: 100;
+  bottom: 0;
+  left: 0;
+  width: 100%;
+  transition: $primary-transition;
+  background-color: #fff;
+
+  &__close {
+    position: absolute;
+    top: 12px;
+    right: 12px;
+    outline: none;
+
+    @include media-min-lg {
+      top: 18px;
+      right: 13px;
+    }
+  }
+
+  &__mobile-controls {
+    position: absolute;
+    top: 0;
+    right: 0;
+    left: 0;
+  }
+
+  &__title {
+    font-style: normal;
+    font-weight: 400;
+    font-size: 16px;
+    line-height: 24px;
+    text-align: center;
+    color: #000;
+    padding: 40px 0;
+
+    @include media-min-lg {
+      text-align: left;
+      padding: 0;
+    }
+  }
+
+  &__buttons {
+    display: flex;
+    flex-direction: column;
+    margin-top: 0;
+
+    @include media-min-lg {
+      flex-direction: row;
+      margin-top: 16px;
+    }
+  }
+
+  &__buttons > :first-child {
+    margin-bottom: 8px;
+
+    @include media-min-lg {
+      margin-bottom: 0;
+    }
+  }
+
+  &__button {
+    text-transform: uppercase;
+    margin-right: 0;
+    font-style: normal;
+    font-weight: 500;
+    font-size: 14px;
+    line-height: 24px;
+    letter-spacing: 0.4px;
+
+    @include media-min-lg {
+      margin-right: 12px;
+      line-height: 12px;
+    }
+  }
+}
+</style>
diff --git a/parent_dir/src/components/Modal/SelectCountryModal/SelectCountryModal.vue b/parent_dir/src/components/Modal/SelectCountryModal/SelectCountryModal.vue
new file mode 100644
index 0000000..5afef02
--- /dev/null
+++ b/parent_dir/src/components/Modal/SelectCountryModal/SelectCountryModal.vue
@@ -0,0 +1,168 @@
+<template>
+  <vue-final-modal
+    ref="modal"
+    :classes="['select-country']"
+    content-class="select-country__content"
+    :name="name"
+  >
+    <mobile-close-line class="select-country__mobile-controls" @swipe-down="onSwipeDown" />
+
+    <button type="button" class="select-country__close" @click="onClose">
+      <img :src="closeIcon" alt="" />
+    </button>
+
+    <div class="select-country__title">
+      {{ $t('selectCountry.title') }}
+    </div>
+    <div class="select-country__items">
+      <div v-for="country in $options.COUNTRIES" :key="country.code" class="select-country__item">
+        <base-link class="select-country__item-link" :href="country.url">
+          {{ $t(`selectCountry.${country.code}`) }}
+        </base-link>
+      </div>
+    </div>
+  </vue-final-modal>
+</template>
+
+<script>
+import stopScrollOpenModal from '@/components/Modal/stop-scroll-open-modal-mixin';
+import MobileCloseLine from '@/components/MobileCloseLine/MobileCloseLine.vue';
+import BaseLink from '@/components/BaseComponents/BaseLink.vue';
+import { COUNTRIES } from '@/constants/select-countries';
+import closeIcon from '@/assets/img/close.svg?url';
+
+export default {
+  name: 'SelectCountryModal',
+  components: {
+    BaseLink,
+    MobileCloseLine,
+  },
+  mixins: [stopScrollOpenModal],
+  COUNTRIES,
+  data() {
+    return {
+      closeIcon,
+      name: 'select-country-modal',
+    };
+  },
+  methods: {
+    onClose() {
+      this.$modal.hide(this.name);
+    },
+    onSwipeDown() {
+      this.onClose();
+    },
+  },
+};
+</script>
+<style lang="scss">
+.select-country {
+  display: flex;
+  align-items: flex-start;
+
+  &__content {
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    height: 100%;
+    padding: 0;
+    transition: $primary-transition;
+    background-color: #fff;
+    position: relative;
+  }
+
+  @include media-min-lg {
+    align-items: center;
+
+    &__content {
+      width: auto;
+      margin: auto;
+      height: auto;
+      padding: 32px;
+      border-radius: 8px;
+      box-shadow: 0 4px 15px rgba(0, 0, 0, 0.15);
+    }
+  }
+}
+</style>
+
+<style scoped lang="scss">
+.select-country {
+  position: fixed;
+  z-index: 100;
+  bottom: 0;
+  left: 0;
+  width: 100%;
+  transition: $primary-transition;
+  background-color: #fff;
+
+  &__close {
+    position: absolute;
+    top: 12px;
+    right: 12px;
+    outline: none;
+
+    @include media-min-lg {
+      top: 18px;
+      right: 13px;
+    }
+  }
+
+  &__mobile-controls {
+    position: absolute;
+    top: 0;
+    right: 0;
+    left: 0;
+  }
+
+  &__title {
+    font-style: normal;
+    font-weight: 500;
+    font-size: 16px;
+    line-height: 24px;
+    color: #000;
+    box-shadow: 0 4px 4px 0 rgba(0, 0, 0, 0.05);
+    padding: 16px;
+
+    @include media-min-lg {
+      font-size: 24px;
+      line-height: 32px;
+      box-shadow: none;
+      padding: 0;
+    }
+  }
+
+  &__items {
+    display: flex;
+    flex-direction: column;
+    margin-top: 16px;
+
+    @include media-min-lg {
+      flex-direction: row;
+      margin-top: 24px;
+    }
+  }
+
+  &__item {
+    padding: 12px 0 12px 16px;
+    font-style: normal;
+    font-weight: 400;
+    font-size: 16px;
+    line-height: 24px;
+    color: #000;
+
+    @include media-min-lg {
+      padding: 0 16px 0 0;
+    }
+  }
+
+  &__item-link {
+    text-decoration: none;
+    color: #000;
+  }
+
+  &__item-link:hover {
+    color: #158e3a;
+  }
+}
+</style>
diff --git a/parent_dir/src/components/Modal/assets/close-green.svg b/parent_dir/src/components/Modal/assets/close-green.svg
new file mode 100644
index 0000000..3d8ac58
--- /dev/null
+++ b/parent_dir/src/components/Modal/assets/close-green.svg
@@ -0,0 +1,22 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  viewBox: "0 0 24 24"
+}
+const _hoisted_2 = /*#__PURE__*/_createElementVNode("path", {
+  stroke: "#1AB248",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  "stroke-width": "2",
+  d: "M18 6 6 18M6 6l12 12"
+}, null, -1)
+const _hoisted_3 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_3))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/components/Modal/stop-scroll-open-modal-mixin.ts b/parent_dir/src/components/Modal/stop-scroll-open-modal-mixin.ts
new file mode 100644
index 0000000..eef4169
--- /dev/null
+++ b/parent_dir/src/components/Modal/stop-scroll-open-modal-mixin.ts
@@ -0,0 +1,30 @@
+import { ComponentOptionsMixin } from 'vue';
+
+const stopScrollModal: ComponentOptionsMixin = {
+  name: 'stop-scroll-open-modal',
+  props: {
+    enabledScroll: {
+      type: Boolean,
+      default() {
+        return false;
+      },
+    },
+  },
+  data() {
+    return {
+      root: null,
+    };
+  },
+  mounted() {
+    if (this.enabledScroll) return;
+    this.root = document.documentElement;
+    this.root.classList.add('overflow-y-hidden');
+  },
+  unmounted() {
+    if (this.enabledScroll) return;
+    this.root.classList.remove('overflow-y-hidden');
+    this.root = null;
+  },
+};
+
+export default stopScrollModal;
diff --git a/parent_dir/src/components/NewOrder/constants.ts b/parent_dir/src/components/NewOrder/constants.ts
new file mode 100644
index 0000000..2c7a86f
--- /dev/null
+++ b/parent_dir/src/components/NewOrder/constants.ts
@@ -0,0 +1,157 @@
+import { LkWebsiteId } from '@/env';
+
+export const CABINET_CALCULATE = '/cabinet/calculate';
+
+export const DELIVERY_TYPES = Object.freeze({
+  OFFICE: 'OFFICE',
+  HOME: 'HOME',
+  POSTAMAT: 'POSTAMAT',
+});
+
+export const PARCEL_TARIFF_ID = 333;
+// потому что неизве�тно какие будут айди дл� других �ред (тут указыны айди дл� препрода)
+export const PROFI_TARIFF_OFFICE_OFFICE_ID = import.meta.env.VITE_PROFI_TARIFF_OFFICE_OFFICE_ID
+  ? Number(import.meta.env.VITE_PROFI_TARIFF_OFFICE_OFFICE_ID)
+  : 2245;
+export const PROFI_TARIFF_OFFICE_POSTAMAT_ID = import.meta.env.VITE_PROFI_TARIFF_OFFICE_POSTAMAT_ID
+  ? Number(import.meta.env.VITE_PROFI_TARIFF_OFFICE_POSTAMAT_ID)
+  : 2248;
+
+export const DEFAULT_RUB_VALUE = {
+  id: 1,
+  name: 'Ро��ий�кий рубль',
+  shortName: 'RUB',
+  sign: '₽',
+  default: true,
+};
+
+export const DEFAULT_KZT_VALUE = {
+  id: 2,
+  name: 'Теңге',
+  shortName: 'KZT',
+  sign: '₸',
+  default: true,
+};
+
+export const DEFAULT_BYN_VALUE = {
+  id: 7,
+  name: 'Белору��кий рубль',
+  shortName: 'BYN',
+  sign: 'Br',
+  default: false,
+};
+
+export const DEFAULT_USD_VALUE = {
+  id: 3,
+  name: 'Доллар СШ�',
+  shortName: 'USD',
+  sign: '$',
+  default: false,
+};
+
+export const DEFAULT_AM_VALUE = {
+  id: 10,
+  name: '�рм�н�кий драм',
+  shortName: 'AMD',
+  sign: 'Ö�',
+  default: false,
+};
+
+export const DEFAULT_KG_VALUE = {
+  id: 9,
+  name: 'Киргиз�кий �ом',
+  shortName: 'KGS',
+  sign: '�',
+  default: false,
+};
+
+export const DEFAULT_GE_VALUE = {
+  id: 19,
+  name: 'Лари',
+  shortName: 'GEL',
+  sign: '₾',
+  default: false,
+};
+
+export const DEFAULT_UZ_VALUE = {
+  id: 15,
+  name: 'Сум',
+  shortName: 'UZS',
+  sign: 'Soʻm',
+  default: false,
+};
+
+export const DEFAULT_AZ_VALUE = {
+  id: 18,
+  name: 'Манат',
+  shortName: 'AZN',
+  sign: '₼',
+  default: false,
+};
+
+export const DEFAULT_CURRENCY_BY_WEBSITE_ID: Record<LkWebsiteId | 'us', typeof DEFAULT_RUB_VALUE> =
+  {
+    ru: DEFAULT_RUB_VALUE,
+    kz: DEFAULT_KZT_VALUE,
+    by: DEFAULT_BYN_VALUE,
+    us: DEFAULT_USD_VALUE,
+    kg: DEFAULT_KG_VALUE,
+    am: DEFAULT_AM_VALUE,
+    ge: DEFAULT_GE_VALUE,
+    uz: DEFAULT_UZ_VALUE,
+    az: DEFAULT_AZ_VALUE,
+  };
+
+export const POSTAMAT = 'postomat';
+
+export const COUNTRIES: Readonly<Record<Uppercase<LkWebsiteId>, number>> = Object.freeze({
+  RU: 1,
+  KZ: 48,
+  AM: 41,
+  KG: 15,
+  BY: 42,
+  GE: 58,
+  UZ: 46,
+  AZ: 40,
+});
+
+export const COUNTRIES_ALIASES: Readonly<{ [key: number]: LkWebsiteId }> = {
+  [COUNTRIES.RU]: 'ru',
+  [COUNTRIES.KZ]: 'kz',
+  [COUNTRIES.AM]: 'am',
+  [COUNTRIES.KG]: 'kg',
+  [COUNTRIES.BY]: 'by',
+  [COUNTRIES.GE]: 'ge',
+  [COUNTRIES.UZ]: 'uz',
+  [COUNTRIES.AZ]: 'az',
+};
+
+export const COUNTRIES_TO: number[] = [
+  COUNTRIES.RU,
+  COUNTRIES.KZ,
+  COUNTRIES.AM,
+  COUNTRIES.KG,
+  COUNTRIES.BY,
+  COUNTRIES.UZ,
+  COUNTRIES.GE,
+  COUNTRIES.AZ,
+];
+
+export const COUNTRIES_FROM: number[] = [
+  COUNTRIES.RU,
+  COUNTRIES.KZ,
+  COUNTRIES.AM,
+  COUNTRIES.KG,
+  COUNTRIES.BY,
+  COUNTRIES.UZ,
+  COUNTRIES.GE,
+  COUNTRIES.AZ,
+];
+
+export const BOX_AVAILABLE_SIZES = ['XS', 'S', 'L', 'M'];
+
+// перече�ление id разрешенных от по�тамата у�луг, перечень вот зде�ь https://docs.google.com/spreadsheets/d/1cNdxuy0q6wJWqGesBcWJdaZxLRoFZ7t4wXlTtKzGHvA/edit#gid=628202538
+export const SUPER_EXPRESS_TARIFF_IDS = [3, 57, 58, 59, 60, 61];
+
+export const CLIENT_TYPE_SENDER = 'sender';
+export const CLIENT_TYPE_RECEIVER = 'receiver';
diff --git a/parent_dir/src/components/NewOrder/utils.ts b/parent_dir/src/components/NewOrder/utils.ts
new file mode 100644
index 0000000..acf7a12
--- /dev/null
+++ b/parent_dir/src/components/NewOrder/utils.ts
@@ -0,0 +1,302 @@
+import pluralize from '@/utils/pluralize.utils';
+import { WebsiteId } from '@/env';
+import { CreateOrderTab, CreateOrderTariff } from '@/types/store/createOrder';
+import { CdekOffice } from '@/types/dto/cdek-office';
+import {
+  DEFAULT_CURRENCY_BY_WEBSITE_ID,
+  DELIVERY_TYPES,
+  PARCEL_TARIFF_ID,
+  POSTAMAT,
+  PROFI_TARIFF_OFFICE_OFFICE_ID,
+  PROFI_TARIFF_OFFICE_POSTAMAT_ID,
+} from './constants';
+
+interface IgetTariffParams {
+  tariffs: CreateOrderTariff[];
+  form: { payer?: string; recipientType: string; senderType: string };
+  senderOffice?: CdekOffice | null;
+  receiverOffice?: CdekOffice | null;
+  tariffProfiEnabled?: boolean;
+  preferredTariff?: number | null;
+}
+
+// сортировка по стоимости тарифа
+export const compare = (a: CreateOrderTariff, b: CreateOrderTariff) => {
+  if (a.price < b.price) {
+    return -1;
+  }
+  if (a.price > b.price) {
+    return 1;
+  }
+  return 0;
+};
+
+export function getTariff({
+  tariffs = [],
+  form = {
+    senderType: '',
+    recipientType: '',
+  },
+  senderOffice = null,
+  receiverOffice = null,
+  tariffProfiEnabled = false,
+  preferredTariff = null,
+}: IgetTariffParams): CreateOrderTariff | undefined {
+  let modeFrom = form.senderType;
+  let modeTo = form.recipientType;
+
+  if (modeFrom === DELIVERY_TYPES.OFFICE && senderOffice && senderOffice.type === POSTAMAT) {
+    modeFrom = DELIVERY_TYPES.POSTAMAT;
+  }
+
+  if (modeTo === DELIVERY_TYPES.OFFICE && receiverOffice && receiverOffice.type === POSTAMAT) {
+    modeTo = DELIVERY_TYPES.POSTAMAT;
+  }
+
+  const type = `${modeFrom}-${modeTo}`;
+
+  const isTariffParcelAvailable = tariffs.some((tariff) => tariff.ec4Id === PARCEL_TARIFF_ID);
+
+  // если пользователь выбрал режим "профи", а выбрать его пользователь может только если тариф профи пришел с бека,
+  // см.геттеры isTariffProfiAvailable и isTariffProfiToPostamatAvailable
+  if (tariffProfiEnabled) {
+    if (modeTo === DELIVERY_TYPES.POSTAMAT) {
+      return tariffs.filter((tariff) => tariff.ec4Id === PROFI_TARIFF_OFFICE_POSTAMAT_ID)?.at(0);
+    }
+
+    return tariffs.filter((tariff) => tariff.ec4Id === PROFI_TARIFF_OFFICE_OFFICE_ID)?.at(0);
+  }
+
+  const foundPreferredTariff =
+    preferredTariff &&
+    tariffs.find((tariff) => {
+      return tariff.ec4Id === preferredTariff && tariff.mode === type;
+    });
+
+  const preparedTariffs = tariffs
+    .filter((tariff) => {
+      if (foundPreferredTariff) {
+        return tariff.ec4Id === preferredTariff;
+      }
+
+      // если нет посылочки и не выбран режим профи, но тариф профи есть и он дешевле всех тарифов - то выбираем тариф профи
+      if (isTariffParcelAvailable) {
+        return (
+          tariff.ec4Id !== PROFI_TARIFF_OFFICE_OFFICE_ID &&
+          tariff.ec4Id !== PROFI_TARIFF_OFFICE_POSTAMAT_ID
+        );
+      }
+
+      return true;
+    })
+    .filter((tariff) => tariff.mode === type)
+    .sort(compare);
+
+  return preparedTariffs[0];
+}
+
+/**
+ * @param tariffs {{id: number, mode: string, shortName: string}[]}
+ * @param form {{payer: string, recipientType: string,  senderType: string}}
+ * @param senderOffice {{type: string}|null}
+ * @param receiverOffice {{type: string}|null}
+ * @returns {{currentTariff: null|Object, recipientType: string, senderType: string}}
+ */
+export function findTariffOtherModes(
+  tariffs: CreateOrderTariff[],
+  form: Record<string, string>,
+  senderOffice: CdekOffice | null = null,
+  receiverOffice: CdekOffice | null = null,
+) {
+  const findModes = [
+    ['HOME', 'OFFICE'],
+    ['OFFICE', 'HOME'],
+    ['HOME', 'HOME'],
+  ];
+
+  let currentTariff = null;
+  let senderType = null;
+  let recipientType = null;
+  for (let i = 0; i < findModes.length; ++i) {
+    const item = findModes[i];
+    senderType = item[0];
+    recipientType = item[1];
+    currentTariff = getTariff({
+      tariffs,
+      form: { ...form, ...{ senderType, recipientType } },
+      senderOffice,
+      receiverOffice,
+    });
+
+    if (currentTariff) {
+      break;
+    }
+  }
+
+  return {
+    senderType,
+    recipientType,
+    currentTariff,
+  };
+}
+
+/**
+ * Мне нужно найти таб у которого есть тарифф из заранее определенного списка
+ * Массивы небольшие. Что-то типа 3 таба в каждом по 4 массива
+ * @param tabs
+ * @param availableIds
+ * @returns {{tab: *, tariffId: number}}
+ */
+export function findTabWithTariff(tabs: CreateOrderTab[], availableIds: number[]) {
+  let tariffId = 0;
+
+  const tab = tabs.find(({ tariffs }) => {
+    // Проверяю на id и ec4id, потому что у нас где-то старый калькулятор где-то новый
+    // в одном месте так поле называется в другом иначе
+    return tariffs.some(({ ec4Id }) => {
+      if (availableIds.includes(ec4Id)) {
+        tariffId = ec4Id;
+        return true;
+      }
+
+      return false;
+    });
+  });
+
+  return {
+    tab,
+    tariffId,
+  };
+}
+
+/**
+ * @param {Array} tabs
+ * @returns {{recipientType: String, tab: Object, tariff: Object, senderType: String}|null}
+ */
+export function findCourierTariffWithTab(tabs: CreateOrderTab[]) {
+  const tabsPlacing = [2, 3];
+  const modes = [
+    ['HOME', 'HOME'],
+    ['HOME', 'OFFICE'],
+  ];
+
+  let findTab: CreateOrderTab | undefined;
+  let findTariff: CreateOrderTariff | undefined;
+  let senderType: string | undefined;
+  let recipientType: string | undefined;
+
+  tabsPlacing.some((placing) => {
+    findTab = tabs.find((tab) => tab.placing === placing);
+
+    if (!findTab) {
+      return false;
+    }
+
+    return modes.some((mode) => {
+      senderType = mode[0];
+      recipientType = mode[1];
+      findTariff = getTariff({
+        tariffs: findTab?.tariffs || [],
+        form: { senderType, recipientType },
+      });
+
+      return !!findTariff;
+    });
+  });
+
+  if (findTariff && findTab) {
+    return {
+      tab: findTab,
+      tariff: findTariff,
+      senderType,
+      recipientType,
+    };
+  }
+
+  return null;
+}
+
+export function isFirstTab(tab: CreateOrderTab) {
+  return tab?.placing === 1;
+}
+
+export function isThirdTab(tab: CreateOrderTab) {
+  return tab?.placing === 3;
+}
+
+interface IVM {
+  $notify: (o: Record<string, string | undefined>) => void;
+}
+
+export function notify(vm: IVM, text: string | undefined) {
+  vm.$notify({
+    group: 'notification-error',
+    type: 'notification-error',
+    title: 'Ошибка',
+    text,
+  });
+}
+
+interface ITextError {
+  isAxiosError: boolean;
+  response: { data: { message?: string; errors?: string[] } };
+}
+
+export function displayError(vm: IVM, e: ITextError) {
+  if (!e || !e.isAxiosError) {
+    return;
+  }
+  const { response } = e;
+  let text = response.data.message;
+
+  if (!text && response.data.errors) {
+    text = response.data.errors[0];
+  }
+
+  notify(vm, text);
+}
+
+type ObjectType = Record<string, object | string | number | boolean>;
+
+export function removeEmpty(obj: ObjectType) {
+  const finalObj: ObjectType = {};
+  Object.keys(obj).forEach((key) => {
+    if (obj[key] && typeof obj[key] === 'object') {
+      const nestedObj = removeEmpty(obj[key] as ObjectType);
+      if (Object.keys(nestedObj).length) {
+        finalObj[key] = nestedObj;
+      }
+    } else if (obj[key] !== '' && obj[key] !== undefined && obj[key] !== null) {
+      finalObj[key] = obj[key];
+    }
+  });
+  return finalObj;
+}
+
+export function getDayTitle(
+  minDays: number,
+  maxDays: number,
+  texts: {
+    one: string;
+    two: string;
+    five: string;
+    interval: { one: string; two: string; five: string };
+  },
+) {
+  if (minDays === maxDays) {
+    return `${minDays}\xa0${pluralize(minDays, texts.one, texts.two, texts.five)}`;
+  }
+
+  return `${minDays}—${maxDays}\xa0${pluralize(
+    minDays,
+    texts.interval.one,
+    texts.interval.two,
+    texts.interval.five,
+  )}`;
+}
+
+export function getDefaultCurrencyByWebsiteId(id: WebsiteId) {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  return DEFAULT_CURRENCY_BY_WEBSITE_ID[id];
+}
diff --git a/parent_dir/src/components/Offices/coordsUtils.ts b/parent_dir/src/components/Offices/coordsUtils.ts
new file mode 100644
index 0000000..2b941fd
--- /dev/null
+++ b/parent_dir/src/components/Offices/coordsUtils.ts
@@ -0,0 +1,42 @@
+/**
+ * Calculate the center/average of multiple GeoLocation coordinates
+ * Expects an array of objects with .latitude and .longitude properties
+ *
+ * @url http://stackoverflow.com/a/14231286/538646
+ * @url https://gist.github.com/tlhunter/0ea604b77775b3e7d7d25ea0f70a23eb
+ */
+interface GeolocationData {
+  geoLatitude: string;
+  geoLongitude: string;
+}
+
+export function averageGeolocation(offices: GeolocationData[]): [number, number] {
+  if (offices.length === 1) {
+    return [+offices[0].geoLatitude, +offices[0].geoLongitude];
+  }
+
+  let x = 0.0;
+  let y = 0.0;
+  let z = 0.0;
+
+  for (const coord of offices) {
+    const latitude = (+coord.geoLatitude * Math.PI) / 180;
+    const longitude = (+coord.geoLongitude * Math.PI) / 180;
+
+    x += Math.cos(latitude) * Math.cos(longitude);
+    y += Math.cos(latitude) * Math.sin(longitude);
+    z += Math.sin(latitude);
+  }
+
+  const total = offices.length;
+
+  x /= total;
+  y /= total;
+  z /= total;
+
+  const centralLongitude = Math.atan2(y, x);
+  const centralSquareRoot = Math.sqrt(x * x + y * y);
+  const centralLatitude = Math.atan2(z, centralSquareRoot);
+
+  return [(centralLatitude * 180) / Math.PI, (centralLongitude * 180) / Math.PI];
+}
diff --git a/parent_dir/src/components/ProgressBar.ts b/parent_dir/src/components/ProgressBar.ts
new file mode 100644
index 0000000..c655e9c
--- /dev/null
+++ b/parent_dir/src/components/ProgressBar.ts
@@ -0,0 +1,131 @@
+// Прогресс бар из nuxt
+import { computed, defineComponent, h, onBeforeUnmount, ref, watch } from 'vue';
+import { useStore } from 'vuex';
+
+function useLoadingIndicator(opts: { duration: number; throttle: number }) {
+  const progress = ref(0);
+  const isLoading = ref(false);
+  const step = computed(() => 10000 / opts.duration);
+
+  let timer: NodeJS.Timeout | null = null;
+  let throttle: NodeJS.Timeout | null = null;
+
+  function clear() {
+    timer !== null && clearInterval(timer);
+    throttle !== null && clearTimeout(throttle);
+    timer = null;
+    throttle = null;
+  }
+
+  function hide() {
+    clear();
+    setTimeout(() => {
+      isLoading.value = false;
+      setTimeout(() => {
+        progress.value = 0;
+      }, 400);
+    });
+  }
+
+  function increase(num: number) {
+    progress.value = Math.min(100, progress.value + num);
+  }
+  function startTimer() {
+    timer = setInterval(() => {
+      increase(step.value);
+    }, 100);
+  }
+
+  function start() {
+    clear();
+    progress.value = 0;
+    if (opts.throttle) {
+      throttle = setTimeout(() => {
+        isLoading.value = true;
+        startTimer();
+      }, opts.throttle);
+    } else {
+      isLoading.value = true;
+      startTimer();
+    }
+  }
+
+  function finish() {
+    progress.value = 100;
+    hide();
+  }
+
+  return {
+    progress,
+    isLoading,
+    start,
+    finish,
+    clear,
+  };
+}
+
+export default defineComponent({
+  name: 'ProgressBar',
+  props: {
+    throttle: {
+      type: Number,
+      default: 200,
+    },
+    duration: {
+      type: Number,
+      default: 2000,
+    },
+    height: {
+      type: Number,
+      default: 3,
+    },
+    color: {
+      type: [String, Boolean],
+      default: 'repeating-linear-gradient(to right,#00dc82 0%,#34cdfe 50%,#0047e1 100%)',
+    },
+  },
+  setup(props, { slots }) {
+    const indicator = useLoadingIndicator({
+      duration: props.duration,
+      throttle: props.throttle,
+    });
+
+    const store = useStore();
+    const isPageLoading = computed(() => {
+      return store.getters['loader/isPageLoading'];
+    });
+
+    watch(isPageLoading, () => {
+      if (isPageLoading.value) {
+        indicator.start();
+      } else {
+        indicator.finish();
+      }
+    });
+
+    onBeforeUnmount(() => indicator.clear);
+
+    return () =>
+      h(
+        'div',
+        {
+          class: 'nuxt-loading-indicator',
+          style: {
+            position: 'fixed',
+            top: 0,
+            right: 0,
+            left: 0,
+            pointerEvents: 'none',
+            width: `${indicator.progress.value}%`,
+            height: `${props.height}px`,
+            opacity: indicator.isLoading.value ? 1 : 0,
+            background: props.color || undefined,
+            backgroundSize: `${(100 / indicator.progress.value) * 100}% auto`,
+            transition: 'width 0.1s, height 0.4s, opacity 0.4s',
+            zIndex: 999999,
+          },
+        },
+        slots,
+      );
+  },
+});
diff --git a/parent_dir/src/components/RenderComponent.vue b/parent_dir/src/components/RenderComponent.vue
new file mode 100644
index 0000000..47b5e35
--- /dev/null
+++ b/parent_dir/src/components/RenderComponent.vue
@@ -0,0 +1,60 @@
+<script>
+import { h } from 'vue';
+import _global from '#root/src/components/_global';
+import {
+  findComponentByPlace,
+  getComponentParams,
+  regexpOnlyBrTemplate,
+  regexpTemplate,
+} from '@/utils/parsePage.utils';
+import BaseContainer from '@/components/BaseContainer.vue';
+import RenderHtml from '@/components/RenderHtml.vue';
+import ComponentNotFound from '@/admin-components/ComponentNotFound.vue';
+
+export default {
+  props: {
+    /**
+     * @param {string} content
+     * @param {Array} components
+     */
+    page: {
+      type: Object,
+      required: true,
+    },
+  },
+  render(props) {
+    const globalComponent = _global;
+    const content = props.page.content || '';
+    const components = props.page.components || [];
+    let splitContent =
+      content.replace(/\r\n/gi, '').replace('&nbsp;', '').split(regexpTemplate) || [];
+
+    splitContent = splitContent.filter((str) => str !== '');
+    splitContent = splitContent.filter((str) => !regexpOnlyBrTemplate.test(str));
+    splitContent = splitContent.map((str) => {
+      if (regexpTemplate.test(str)) {
+        const component = findComponentByPlace(str, components);
+
+        if (component && globalComponent[component.name]) {
+          const params = getComponentParams(component);
+
+          return h(globalComponent[component.name], {
+            key: component.uuid,
+            params,
+          });
+        }
+
+        return h(ComponentNotFound);
+      }
+      const isFlomni = /id="(flomni|flomni-inline)"/.test(str);
+      if (isFlomni) {
+        return null;
+      }
+
+      return h(BaseContainer, {}, () => h(RenderHtml, { html: str }));
+    });
+
+    return h('div', this.$attrs, splitContent);
+  },
+};
+</script>
diff --git a/parent_dir/src/components/RenderHtml.vue b/parent_dir/src/components/RenderHtml.vue
new file mode 100644
index 0000000..7702c0f
--- /dev/null
+++ b/parent_dir/src/components/RenderHtml.vue
@@ -0,0 +1,15 @@
+<template>
+  <div v-html="html" />
+</template>
+
+<script>
+export default {
+  name: 'RenderHtml',
+  props: {
+    html: {
+      type: String,
+      default: '',
+    },
+  },
+};
+</script>
diff --git a/parent_dir/src/components/Timer.vue b/parent_dir/src/components/Timer.vue
new file mode 100644
index 0000000..71c4ae8
--- /dev/null
+++ b/parent_dir/src/components/Timer.vue
@@ -0,0 +1,74 @@
+<template>
+  <span>{{ timeLeft }}</span>
+</template>
+
+<script>
+import { getCurrentTime } from '@/utils/time';
+
+export default {
+  name: 'Timer',
+  props: {
+    current: {
+      type: [Date, String],
+      default() {
+        return new Date();
+      },
+    },
+    deadline: {
+      type: String,
+      required: true,
+    },
+    speed: {
+      type: Number,
+      default: 1000,
+    },
+  },
+  emits: ['increaseCurrentTime', 'stopTimer'],
+  data() {
+    return {
+      currentTime: null,
+      clearTimer: null,
+      currentToMs: 0,
+    };
+  },
+  computed: {
+    timeLeft() {
+      if (this.currentTime) {
+        const h = `0${this.currentTime.hours}`.slice(-2);
+        const m = `0${this.currentTime.minutes}`.slice(-2);
+        const s = `0${this.currentTime.seconds}`.slice(-2);
+        if (this.currentTime.hours) {
+          return `${h}:${m}:${s}`;
+        }
+        return `${m}:${s}`;
+      }
+      return '';
+    },
+  },
+  mounted() {
+    this.currentToMs = Date.parse(this.current);
+    setTimeout(() => this.countdown(), 1);
+  },
+  beforeUnmount() {
+    if (this.clearTimer) {
+      clearTimeout(this.clearTimer);
+    }
+  },
+  methods: {
+    countdown() {
+      const current = getCurrentTime(this.deadline, this.currentToMs);
+      if (current && current.total > 0) {
+        this.currentTime = current;
+        this.clearTimer = setTimeout(() => {
+          this.currentToMs += this.speed;
+          this.$emit('increaseCurrentTime', this.currentToMs);
+          this.countdown();
+        }, this.speed);
+      } else {
+        this.currentTime = null;
+        this.$emit('stopTimer');
+      }
+    },
+  },
+};
+</script>
diff --git a/parent_dir/src/components/Transitions/SlideLeftTransition.vue b/parent_dir/src/components/Transitions/SlideLeftTransition.vue
new file mode 100644
index 0000000..d9b01ad
--- /dev/null
+++ b/parent_dir/src/components/Transitions/SlideLeftTransition.vue
@@ -0,0 +1,42 @@
+<template>
+  <transition
+    name="slide-left-transition"
+    @before-enter="addDisableScrollClass"
+    @after-enter="removeDisableScrollClass"
+    @before-leave="addDisableScrollClass"
+    @after-leave="removeDisableScrollClass"
+  >
+    <slot />
+  </transition>
+</template>
+
+<script>
+export default {
+  name: 'SlideLeftTransition',
+  methods: {
+    addDisableScrollClass() {
+      document.documentElement.classList.add('slide-left-overflow-scroll');
+    },
+    removeDisableScrollClass() {
+      document.documentElement.classList.remove('slide-left-overflow-scroll');
+    },
+  },
+};
+</script>
+<style>
+.slide-left-overflow-scroll {
+  overflow-x: hidden;
+}
+</style>
+<style scoped>
+.slide-left-transition-enter-active,
+.slide-left-transition-leave-active {
+  transition: transform 0.2s ease;
+}
+
+.slide-left-transition-enter-from,
+.slide-left-transition-leave-to {
+  transform: translateX(100%);
+  transition: all 0.2s ease-in 0s;
+}
+</style>
diff --git a/parent_dir/src/components/_global.ts b/parent_dir/src/components/_global.ts
new file mode 100644
index 0000000..e42d5c4
--- /dev/null
+++ b/parent_dir/src/components/_global.ts
@@ -0,0 +1,427 @@
+import { defineAsyncComponent } from 'vue';
+import { CdekComponentNames } from '@/types/dto/cdekComponent';
+
+const Alerts = defineAsyncComponent({
+  loader: () => import('@/admin-components/Alerts/Alerts.vue'),
+  delay: 0,
+});
+
+const Digits = defineAsyncComponent({
+  loader: () => import('./Digits/Digits.vue'),
+  delay: 0,
+});
+
+const BannerStatic = defineAsyncComponent({
+  loader: () => import('./Banner/BannerStatic.vue'),
+  delay: 0,
+});
+
+const OfficeMap = defineAsyncComponent({
+  loader: () => import('./Offices/OfficeMap.vue'),
+  delay: 0,
+});
+
+const TrackingV2 = defineAsyncComponent({
+  loader: () => import('./TrackingNew/Tracking.vue'),
+  delay: 0,
+});
+const ComponentNotFound = defineAsyncComponent({
+  loader: () => import('@/admin-components/ComponentNotFound.vue'),
+  delay: 0,
+});
+const MobileApplications = defineAsyncComponent({
+  loader: () => import('./MobileApplications/MobileApplications.vue'),
+  delay: 0,
+});
+const Questions = defineAsyncComponent({
+  loader: () => import('@/components/Questions/Questions.vue'),
+  delay: 0,
+});
+const ClientQuestions = defineAsyncComponent({
+  loader: () => import('./ClientQuestion/ClientQuestions.vue'),
+  delay: 0,
+});
+const UnmarkedList = defineAsyncComponent({
+  loader: () => import('./UnmarkedList/UnmarkedList.vue'),
+  delay: 0,
+});
+
+const Tiles = defineAsyncComponent({
+  loader: () => import('@/admin-components/Tiles/Tiles.vue'),
+  delay: 0,
+});
+
+const Documents = defineAsyncComponent({
+  loader: () => import('./Documents/Documents.vue'),
+  delay: 0,
+});
+
+const NewBlock = defineAsyncComponent({
+  loader: () => import('./NewBlock/NewBlock.vue'),
+  delay: 0,
+});
+
+const Tariffs = defineAsyncComponent({
+  loader: () => import('./Tariffs.vue'),
+  delay: 0,
+});
+
+const BannerMobile = defineAsyncComponent({
+  loader: () => import('./BannerMobile.vue'),
+  delay: 0,
+});
+
+const BannerCarousel = defineAsyncComponent({
+  loader: () => import('./BannerCarousel/BannerCarousel.vue'),
+  delay: 0,
+});
+
+const BaseLoader = defineAsyncComponent({
+  loader: () => import('./BaseLoader.vue'),
+  delay: 0,
+});
+
+const BanerShoppingTop = defineAsyncComponent({
+  loader: () => import('./Shopping/CdekShopping.vue'),
+  delay: 0,
+});
+const Banner = defineAsyncComponent({
+  loader: () => import('./Banner/Banner.vue'),
+  delay: 0,
+});
+const Cover = defineAsyncComponent({
+  loader: () => import('./Cover/Cover.vue'),
+  delay: 0,
+});
+const TextBlock = defineAsyncComponent({
+  loader: () => import('./TextBlock/TextBlock.vue'),
+  delay: 0,
+});
+
+const BaseInput = defineAsyncComponent({
+  loader: () => import('./BaseComponents/BaseInput.vue'),
+  delay: 0,
+});
+
+const PressNewList = defineAsyncComponent({
+  loader: () => import('./PressNewList/PressNewList.vue'),
+  delay: 0,
+});
+
+const Intro = defineAsyncComponent({
+  loader: () => import('./Intro.vue'),
+  delay: 0,
+});
+
+const CoverNew = defineAsyncComponent({
+  loader: () => import('./Cover/CoverNew.vue'),
+  delay: 0,
+});
+
+const CdekServices = defineAsyncComponent({
+  loader: () => import('@/admin-components/CdekServices/CdekServices.vue'),
+  delay: 0,
+});
+
+const FeedbackBlock = defineAsyncComponent({
+  loader: () => import('./FeedbackBlock/FeedbackBlock.vue'),
+  delay: 0,
+});
+const Unsubscribe = defineAsyncComponent({
+  loader: () => import('./Unsubscribe/Unsubscribe.vue'),
+  delay: 0,
+});
+
+const Tabs = defineAsyncComponent({
+  loader: () => import('./Tabs/Tabs.vue'),
+  delay: 0,
+});
+
+const OfficeHeader = defineAsyncComponent({
+  loader: () => import('./Offices/OfficeHeader.vue'),
+  delay: 0,
+});
+
+const Payment = defineAsyncComponent({
+  loader: () => import('./Payment/PaymentV2/PaymentV2.vue'),
+  delay: 0,
+});
+const Top = defineAsyncComponent({
+  loader: () => import('./Top/Top.vue'),
+  delay: 0,
+});
+
+const PackageHeader = defineAsyncComponent({
+  loader: () => import('./Package/PackageHeader.vue'),
+  delay: 0,
+});
+
+const PackageBoxCard = defineAsyncComponent({
+  loader: () => import('./Package/PackageBoxCard.vue'),
+  delay: 0,
+});
+
+const PackageCard = defineAsyncComponent({
+  loader: () => import('./Package/PackageCard.vue'),
+  delay: 0,
+});
+
+const NewList = defineAsyncComponent({
+  loader: () => import('./NewList/NewList.vue'),
+  delay: 0,
+});
+
+const NewsVideoList = defineAsyncComponent({
+  loader: () => import('./NewList/NewsVideoList.vue'),
+  delay: 0,
+});
+
+const Email = defineAsyncComponent({
+  loader: () => import('./Email/Email.vue'),
+  delay: 0,
+});
+
+const Office = defineAsyncComponent({
+  loader: () => import('./Offices/Office.vue'),
+  delay: 0,
+});
+
+const SingleButtonBlock = defineAsyncComponent({
+  loader: () => import('./SingleButtonBlock.vue'),
+  delay: 0,
+});
+
+const Contacts = defineAsyncComponent({
+  loader: () => import('./Contacts/Contacts.vue'),
+  delay: 0,
+});
+
+const Partners = defineAsyncComponent({
+  loader: () => import('./Partners.vue'),
+  delay: 0,
+});
+
+const NewItem = defineAsyncComponent({
+  loader: () => import('./SingleNews/SingleNews.vue'),
+  delay: 0,
+});
+
+const History = defineAsyncComponent({
+  loader: () => import('./History/History.vue'),
+  delay: 0,
+});
+
+const FeedbackList = defineAsyncComponent({
+  loader: () => import('./FeedbackList/FeedbackList.vue'),
+  delay: 0,
+});
+
+const NumberBlocks = defineAsyncComponent({
+  loader: () => import('./NumberBlocks/NumberBlocks.vue'),
+  delay: 0,
+});
+
+const TrackingQuestions = defineAsyncComponent({
+  loader: () => import('./TrackingNew/TrackingDocuments.vue'),
+  delay: 0,
+});
+const Dogovor = defineAsyncComponent({
+  loader: () => import('./Dogovor/Dogovor.vue'),
+  delay: 0,
+});
+const DogovorKZ = defineAsyncComponent({
+  loader: () => import('./DogovorKZ/Dogovor.vue'),
+  delay: 0,
+});
+const DogovorUZ = defineAsyncComponent({
+  loader: () => import('./DogovorUZ/Dogovor.vue'),
+  delay: 0,
+});
+const DogovorKG = defineAsyncComponent({
+  loader: () => import('./DogovorKG/Dogovor.vue'),
+  delay: 0,
+});
+const DogovorAM = defineAsyncComponent({
+  loader: () => import('./DogovorAM/Dogovor.vue'),
+  delay: 0,
+});
+const CalculatorNew = defineAsyncComponent({
+  loader: () => import('./NewOrder/CalculatorNew.vue'),
+  delay: 0,
+});
+const TrackingInfo = defineAsyncComponent({
+  loader: () => import('./TrackingInfo/TrackingInfo.vue'),
+  delay: 0,
+});
+
+const TrackingApplications = defineAsyncComponent({
+  loader: () => import('./TrackingNew/TrackingApplications.vue'),
+  delay: 0,
+});
+
+const TwoColumns = defineAsyncComponent({
+  loader: () => import('@/admin-components/TwoColumns/TwoColumns.vue'),
+  delay: 0,
+});
+
+const LandingCover = defineAsyncComponent({
+  loader: () => import('./LandingCover.vue'),
+  delay: 0,
+});
+
+const PopularProducts = defineAsyncComponent({
+  loader: () => import('@/admin-components/PopularProducts/PopularProducts.vue'),
+  delay: 0,
+});
+
+const ActionsCarousel = defineAsyncComponent({
+  loader: () => import('@/admin-components/ActionsCarousel/ActionsCarousel.vue'),
+  delay: 0,
+});
+
+const LinkBlock = defineAsyncComponent({
+  loader: () => import('@/admin-components/LinkBlock/LinkBlock.vue'),
+  delay: 0,
+});
+
+// Компонент удалю отдлельной задачей после успешного релиза
+// Это самый первый компонент на главной, пусть лучше пока побудет, чем пользователи
+// вдруг увидят "компонент не найден"
+const Banners = defineAsyncComponent({
+  loader: () => import('@/admin-components/Banners/Banners.vue'),
+  delay: 0,
+});
+
+const CoverTabs = defineAsyncComponent({
+  loader: () => import('./Cover/CoverTabs.vue'),
+  delay: 0,
+});
+
+const LandingIllustration = defineAsyncComponent({
+  loader: () => import('./LandingIllustration/LandingIllustration.vue'),
+  delay: 0,
+});
+
+const Messengers = defineAsyncComponent({
+  loader: () => import('./Messengers.vue'),
+  delay: 0,
+});
+
+const PackageForm = defineAsyncComponent({
+  loader: () => import('./Package/PackageForm.vue'),
+  delay: 0,
+});
+
+const SocialLinks = defineAsyncComponent({
+  loader: () => import('./SocialLinks/SocialLinks.vue'),
+  delay: 0,
+});
+
+const TableWithTitle = defineAsyncComponent({
+  loader: () => import('./TableWithTitle/TableWithTitle.vue'),
+  delay: 0,
+});
+
+const TextBlockLogo = defineAsyncComponent({
+  loader: () => import('./TextBlock/TextBlockLogo.vue'),
+  delay: 0,
+});
+
+const YouTubeSlider = defineAsyncComponent({
+  loader: () => import('./YouTubeSlider/YouTubeSlider.vue'),
+  delay: 0,
+});
+
+const Universal = defineAsyncComponent({
+  loader: () => import('@/admin-components/UniversalComponent.vue'),
+  delay: 0,
+});
+
+const PictureGallery = defineAsyncComponent({
+  loader: () => import('./PictureGallery/PictureGallery.vue'),
+  delay: 0,
+});
+
+const FaqHtmlBlock = defineAsyncComponent({
+  loader: () => import('@/components/FaqHtmlBlock/FaqHtmlBlock.vue'),
+  delay: 0,
+});
+
+const globalComponents: Record<CdekComponentNames, any> = {
+  FaqHtmlBlock,
+  PictureGallery,
+  Universal,
+  LandingCover,
+  Unsubscribe,
+  TwoColumns,
+  TrackingApplications,
+  TrackingInfo,
+  CalculatorNew,
+  Dogovor,
+  DogovorKZ,
+  DogovorUZ,
+  DogovorKG,
+  DogovorAM,
+  Office,
+  OfficeHeader,
+  CdekServices,
+  PressNewList,
+  Tabs,
+  Email,
+  NewsTabs: Tabs,
+  TrackingV2,
+  Alerts,
+  NewBlock,
+  ComponentNotFound,
+  OfficeMap,
+  CoverNew,
+  Tiles,
+  BannerCarousel,
+  BannerStatic,
+  MobileApplications,
+  Questions,
+  BanerShoppingTop,
+  BaseLoader,
+  Tariffs,
+  BaseInput,
+  UnmarkedList,
+  Digits,
+  FeedbackBlock,
+  Intro,
+  ClientQuestions,
+  Payment,
+  Banner,
+  TextBlock,
+  Documents,
+  Top,
+  PackageHeader,
+  PackageBoxCard,
+  PackageCard,
+  NewList,
+  Videos: NewsVideoList,
+  BannerMobile,
+  Cover,
+  SingleButtonBlock,
+  Contacts,
+  Partners,
+  NewItem,
+  PressNewItem: NewItem,
+  History,
+  FeedbackList,
+  NumberBlocks,
+  TrackingQuestions,
+  ActionsCarousel,
+  PopularProducts,
+  LinkBlock,
+  Banners,
+  CoverTabs,
+  LandingIllustration,
+  Messengers,
+  PackageForm,
+  SocialLinks,
+  TableWithTitle,
+  TextBlockLogo,
+  YouTubeSlider,
+};
+
+export default globalComponents;
diff --git a/parent_dir/src/components/icon-svg/IconArrow.vue b/parent_dir/src/components/icon-svg/IconArrow.vue
new file mode 100644
index 0000000..38d9096
--- /dev/null
+++ b/parent_dir/src/components/icon-svg/IconArrow.vue
@@ -0,0 +1,66 @@
+<template>
+  <svg
+    :width="width"
+    :height="height"
+    viewBox="0 0 9 16"
+    fill="none"
+    xmlns="http://www.w3.org/2000/svg"
+    class="icon-arrow"
+    :class="{
+      'icon-arrow--left': direction === 'left',
+      'icon-arrow--right': direction === 'right',
+      'icon-arrow--top': direction === 'top',
+      'icon-arrow--down': direction === 'down',
+    }"
+  >
+    <path
+      d="M8 15L1 8L8 1"
+      :stroke="color"
+      stroke-width="2"
+      stroke-linecap="round"
+      stroke-linejoin="round"
+    />
+  </svg>
+</template>
+
+<script>
+export default {
+  name: 'IconArrow',
+  props: {
+    color: {
+      type: String,
+      default: '#232323',
+    },
+    direction: {
+      type: String,
+      default: 'left',
+    },
+    height: {
+      type: [String, Number],
+      default: '16',
+    },
+    width: {
+      type: [String, Number],
+      default: '9',
+    },
+  },
+};
+</script>
+
+<style scoped lang="scss">
+.icon-arrow {
+  transition: $primary-transition;
+
+  &--right {
+    transform: rotate(180deg);
+  }
+
+  &--top {
+    transform: rotate(90deg);
+  }
+
+  &--down {
+    transform: rotate(270deg);
+  }
+}
+</style>
diff --git a/parent_dir/src/components/icon-svg/IconClose.vue b/parent_dir/src/components/icon-svg/IconClose.vue
new file mode 100644
index 0000000..b5884a9
--- /dev/null
+++ b/parent_dir/src/components/icon-svg/IconClose.vue
@@ -0,0 +1,38 @@
+<template>
+  <svg
+    :width="width"
+    :height="height"
+    viewBox="0 0 15 15"
+    xmlns="http://www.w3.org/2000/svg"
+    :fill="fill"
+  >
+    <path
+      d="M6.78241 7.5023L0.143027 14.1883C-0.0414258 14.3741 -0.0414258 14.675 0.143027 14.8607C0.235137 14.9537 0.356074 15 0.476778 15C0.597715 15 0.718418 14.9537 0.810528 14.8607L7.49983 8.12445L14.1891 14.8607C14.2815 14.9537 14.4022 15 14.5229 15C14.6436 15 14.7645 14.9537 14.8566 14.8607C15.0411 14.675 15.0411 14.3741 14.8566 14.1883L8.21748 7.5023L14.8611 0.81156C15.0455 0.625811 15.0455 0.324884 14.8611 0.139135C14.6766 -0.0463783 14.3778 -0.0463783 14.1936 0.139135L7.50006 6.88015L0.80584 0.139371C0.621387 -0.0461422 0.322793 -0.0461422 0.13834 0.139371C-0.0461133 0.32512 -0.0461133 0.626047 0.13834 0.811796L6.78241 7.5023Z"
+    />
+  </svg>
+</template>
+
+<script>
+export default {
+  props: {
+    width: {
+      type: Number,
+      default() {
+        return 15;
+      },
+    },
+    height: {
+      type: Number,
+      default() {
+        return 15;
+      },
+    },
+    fill: {
+      type: String,
+      default() {
+        return '#232323';
+      },
+    },
+  },
+};
+</script>
diff --git a/parent_dir/src/components/icon-svg/IconCloseV2.vue b/parent_dir/src/components/icon-svg/IconCloseV2.vue
new file mode 100644
index 0000000..6130f79
--- /dev/null
+++ b/parent_dir/src/components/icon-svg/IconCloseV2.vue
@@ -0,0 +1,49 @@
+<template>
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    :width="width"
+    :height="height"
+    viewBox="0 0 12 12"
+    fill="none"
+  >
+    <path
+      d="M11 1L1 11M1 1L11 11"
+      :stroke="stroke"
+      :stroke-width="strokeWidth"
+      :stroke-opacity="strokeOpacity"
+      stroke-linecap="round"
+      stroke-linejoin="round"
+    />
+  </svg>
+</template>
+
+<script>
+export default {
+  props: {
+    width: {
+      type: Number,
+      default() {
+        return 12;
+      },
+    },
+    height: {
+      type: Number,
+      default() {
+        return 12;
+      },
+    },
+    stroke: {
+      type: String,
+      default: '#1AB248',
+    },
+    strokeWidth: {
+      type: Number,
+      default: 2,
+    },
+    strokeOpacity: {
+      type: Number,
+      default: 1,
+    },
+  },
+};
+</script>
diff --git a/parent_dir/src/components/icon-svg/IconProgress.vue b/parent_dir/src/components/icon-svg/IconProgress.vue
new file mode 100644
index 0000000..398f873
--- /dev/null
+++ b/parent_dir/src/components/icon-svg/IconProgress.vue
@@ -0,0 +1,129 @@
+<template>
+  <svg :width="width" :height="height" :class="{ 'icon-progress--big': big }">
+    <circle :cx="cx" :cy="cy" :r="r" :stroke="colors.progress" />
+  </svg>
+</template>
+
+<script>
+export default {
+  name: 'IconProgress',
+  props: {
+    primary: {
+      type: Boolean,
+      default: false,
+    },
+    secondary: {
+      type: Boolean,
+      default: false,
+    },
+    big: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  computed: {
+    colors() {
+      if (this.primary) {
+        return {
+          stroke: 'transparent',
+          progress: '#FFFFFF',
+        };
+      }
+      if (this.secondary) {
+        return {
+          stroke: 'transparent',
+          progress: '#00A942',
+        };
+      }
+      return {
+        stroke: '#EDF0F3',
+        progress: '#00A942',
+      };
+    },
+    width() {
+      return this.big ? 86 : 20;
+    },
+    height() {
+      return this.big ? 86 : 20;
+    },
+    cx() {
+      return this.big ? 38 : 9;
+    },
+    cy() {
+      return this.big ? 38 : 9;
+    },
+    r() {
+      return this.big ? 38 : 8;
+    },
+  },
+};
+</script>
+
+<style scoped lang="scss">
+svg {
+  position: relative;
+  animation: rotate 0.6s linear infinite;
+}
+
+circle {
+  width: 100%;
+  height: 100%;
+  fill: none;
+  stroke-width: 2px;
+  stroke-linecap: round;
+  transform: translate(1px, 1px);
+  stroke-dasharray: 50;
+  stroke-dashoffset: 50;
+  animation: animate 2s linear infinite;
+}
+
+@keyframes rotate {
+  0% {
+    transform: rotate(0deg);
+  }
+
+  100% {
+    transform: rotate(360deg);
+  }
+}
+
+@keyframes animate {
+  0%,
+  100% {
+    stroke-dashoffset: 50;
+  }
+
+  50% {
+    stroke-dashoffset: 1;
+  }
+
+  50.1% {
+    stroke-dashoffset: 100;
+  }
+}
+
+.icon-progress--big {
+  circle {
+    stroke-dasharray: 250;
+    stroke-dashoffset: 250;
+    stroke-width: 4px;
+    transform: translate(5px, 5px);
+    animation: animate-big 2s linear infinite;
+  }
+}
+
+@keyframes animate-big {
+  0%,
+  100% {
+    stroke-dashoffset: 250;
+  }
+
+  50% {
+    stroke-dashoffset: 1;
+  }
+
+  50.1% {
+    stroke-dashoffset: 500;
+  }
+}
+</style>
diff --git a/parent_dir/src/composables/use-autodetect-city.ts b/parent_dir/src/composables/use-autodetect-city.ts
new file mode 100644
index 0000000..a47447a
--- /dev/null
+++ b/parent_dir/src/composables/use-autodetect-city.ts
@@ -0,0 +1,46 @@
+import { COOKIE_CITY_ID_TAG } from '@/constants/cookie-tag';
+import { cdekConsoleError } from '@/utils/console-wrapper';
+import { SET_SHOW_CONFIRM_CITY } from '@/middleware/mutation-types';
+import { inject } from 'vue';
+import { VueCookies } from 'vue-cookies';
+import { useRestApi } from '@/composables/use-rest-api';
+import useSiteInfo from '@/composables/use-site-info';
+import { useSelectedCity } from '@/composables/use-selected-city';
+import { useStore } from 'vuex';
+import { CdekDefaultCity } from '@/types/dto/city';
+
+export const useAutodetectCity = () => {
+  const $cookies = inject<VueCookies>('$cookies');
+  const autodetectCity = async () => {
+    const cityId = $cookies?.get(COOKIE_CITY_ID_TAG);
+    const { restApi } = useRestApi();
+    const { currentLocaleISO } = useSiteInfo();
+    const { selectGlobalCity } = useSelectedCity();
+    const store = useStore();
+
+    if (!cityId) {
+      try {
+        const { detected, default: defaultCity } = await restApi.autodetectCity({
+          locale: currentLocaleISO.value,
+        });
+        const city = detected || defaultCity;
+
+        if (city) {
+          selectGlobalCity(city as unknown as CdekDefaultCity);
+        }
+
+        if (!detected) {
+          return;
+        }
+      } catch (e) {
+        cdekConsoleError(e);
+      } finally {
+        store.dispatch(SET_SHOW_CONFIRM_CITY, true);
+      }
+    }
+  };
+
+  return {
+    autodetectCity,
+  };
+};
diff --git a/parent_dir/src/composables/use-base-field.ts b/parent_dir/src/composables/use-base-field.ts
new file mode 100644
index 0000000..942e145
--- /dev/null
+++ b/parent_dir/src/composables/use-base-field.ts
@@ -0,0 +1,155 @@
+import { computed, h, onMounted, ref, unref, ComputedRef, SetupContext, VNode } from 'vue';
+import { isAppleDevice } from '@/utils/bowser';
+
+// Был миксин, чтобы не дублировать код вынес в композабле
+export default function useBaseField(
+  props: any,
+  { slots }: SetupContext,
+  inputField: ComputedRef<HTMLElement | null>,
+) {
+  const isIOs = ref(false);
+  const focused = ref(false);
+  const idElement = ref(0);
+
+  const baseClassName = computed(() => {
+    return props.old ? 'base-control-old' : 'base-control';
+  });
+
+  const groutClasses = computed(() => {
+    return {
+      [`${baseClassName.value}__group`]: true,
+    };
+  });
+
+  const rootClasses = computed(() => {
+    const rawClassName = baseClassName.value;
+
+    let classes = {
+      [rawClassName]: true,
+      [`${rawClassName}--disabled`]: props.disabled,
+      [`${rawClassName}--ios`]: isIOs.value,
+      'base--error': (props.hasError && !focused.value) || (props.hasError && props.displayError),
+    };
+
+    if (props.old) {
+      classes = {
+        ...classes,
+        [`${rawClassName}--light`]: props.light,
+        [`${rawClassName}--order`]: props.order,
+        [`${rawClassName}--full-height`]: props.fullHeight,
+        [`${rawClassName}--fixed-error`]: props.errorMessageFixed,
+      };
+    } else {
+      classes = {
+        ...classes,
+        [`${rawClassName}--focused`]: focused.value,
+        [`${rawClassName}--empty`]: !props.modelValue,
+        [`${rawClassName}--checked`]: props.checked,
+      };
+    }
+    return classes;
+  });
+
+  const fieldAttrs = computed(() => {
+    const attributs: Record<string, unknown> = {};
+    if (props.name) {
+      attributs.name = props.name;
+    }
+    if (props.placeholder && props.old) {
+      attributs.placeholder = props.placeholder;
+    }
+    if (props.id) {
+      attributs.id = props.id;
+    }
+    if (props.disabled) {
+      attributs.disabled = props.disabled;
+    }
+    return attributs;
+  });
+
+  const hasSlotIcon = computed(() => {
+    return Boolean(slots.icon);
+  });
+
+  const onClickLabel = () => {
+    if (!inputField.value) {
+      return;
+    }
+
+    inputField.value.focus();
+  };
+  const getPlaceholder = () => {
+    const rawClassName = baseClassName.value;
+
+    return props.placeholder && !props.old
+      ? [
+          h(
+            'label',
+            {
+              class: [
+                `${rawClassName}__placeholder`,
+                props.required ? `${rawClassName}__placeholder-required` : '',
+              ].join(' '),
+              tabIndex: '-1',
+              for: unref(idElement),
+              onClick: onClickLabel,
+            },
+            [props.placeholder],
+          ),
+        ]
+      : [];
+  };
+
+  const getError = () => {
+    let message: VNode | string = '';
+    if (slots.message) {
+      message = slots.message()[0];
+    } else if (props.messageError) {
+      message = props.messageError;
+    }
+
+    return props.hasError && (Boolean(slots.message) || Boolean(props.messageError))
+      ? [h('div', { class: `${baseClassName.value}__error-message` }, [message])]
+      : [];
+  };
+
+  const getAdditionalInfo = () => {
+    const has = Boolean(props.additionalInfo) || Boolean(slots.additionalInfo);
+    const getContext = () =>
+      props.additionalInfo || (slots.additionalInfo && slots.additionalInfo());
+    return has && !props.old
+      ? [h('div', { class: `${baseClassName.value}__additional-info` }, [getContext()])]
+      : [];
+  };
+  /**
+   * Публичный метод для ручного вызова фокуса на поле
+   */
+  const focus = () => {
+    if (!inputField.value) {
+      return;
+    }
+
+    inputField.value.focus();
+  };
+
+  onMounted(() => {
+    isIOs.value = isAppleDevice();
+    idElement.value = props.id;
+  });
+
+  return {
+    baseClassName,
+    groutClasses,
+    rootClasses,
+    fieldAttrs,
+    hasSlotIcon,
+    getPlaceholder,
+    getError,
+    getAdditionalInfo,
+    onClickLabel,
+    focus,
+    focused,
+    isIOs,
+    idElement,
+  };
+}
diff --git a/parent_dir/src/composables/use-cabinet-api.ts b/parent_dir/src/composables/use-cabinet-api.ts
new file mode 100644
index 0000000..229e505
--- /dev/null
+++ b/parent_dir/src/composables/use-cabinet-api.ts
@@ -0,0 +1,12 @@
+import { inject } from 'vue';
+import CabinetApi from '@/api-clients/cabinetApi/cabinet';
+
+export default function useCabinetApi() {
+  const apiClient = inject<{ cabinet: CabinetApi }>('apiClient');
+
+  return {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    apiClient: apiClient.cabinet,
+  };
+}
diff --git a/parent_dir/src/composables/use-cabinet-data.ts b/parent_dir/src/composables/use-cabinet-data.ts
new file mode 100644
index 0000000..914b94d
--- /dev/null
+++ b/parent_dir/src/composables/use-cabinet-data.ts
@@ -0,0 +1,14 @@
+import { useStore } from 'vuex';
+import { computed } from 'vue';
+
+const useCabinetData = () => {
+  const store = useStore();
+
+  const fullName = computed(() => store.getters['cabinet/fullName']);
+
+  const getLoginPhone = computed(() => store.getters['cabinet/getLoginPhone']);
+
+  return { fullName, getLoginPhone };
+};
+
+export default useCabinetData;
diff --git a/parent_dir/src/composables/use-countries.ts b/parent_dir/src/composables/use-countries.ts
new file mode 100644
index 0000000..1d1adba
--- /dev/null
+++ b/parent_dir/src/composables/use-countries.ts
@@ -0,0 +1,37 @@
+import type { ICountry } from '#root/src/types/dto/country';
+import { inject } from 'vue';
+import { cdekConsoleError } from '@/utils/console-wrapper';
+import useSiteInfo from '@/composables/use-site-info';
+import type RestApiClient from '@/api-clients/rest-api-client';
+
+let defaultCountries: ICountry[] = [];
+const useCountries = () => {
+  const restApi = inject<RestApiClient>('restApi');
+
+  const { currentLocaleISO } = useSiteInfo();
+
+  const setDefaultCountries = (data: ICountry[]) => {
+    defaultCountries = data;
+  };
+
+  const getDefaultCountries = () => {
+    return defaultCountries;
+  };
+
+  const getCountriesByLocale = async () => {
+    try {
+      return await restApi?.getCountries(currentLocaleISO.value);
+    } catch (e) {
+      cdekConsoleError(e);
+      return getDefaultCountries();
+    }
+  };
+
+  return {
+    setDefaultCountries,
+    getDefaultCountries,
+    getCountriesByLocale,
+  };
+};
+
+export default useCountries;
diff --git a/parent_dir/src/composables/use-flomni.ts b/parent_dir/src/composables/use-flomni.ts
new file mode 100644
index 0000000..bafc8e0
--- /dev/null
+++ b/parent_dir/src/composables/use-flomni.ts
@@ -0,0 +1,235 @@
+import { useStore } from 'vuex';
+import useSiteInfo from '@/composables/use-site-info';
+import useCabinetData from '@/composables/use-cabinet-data';
+import { computed, onMounted, Ref, ref } from 'vue';
+import axios from 'axios';
+import { IButtonData } from '@/components/HelpCustomer/types';
+
+import messenger from '@/static/messengers/messenger.svg?url';
+import vk from '@/static/messengers/vk.svg?url';
+import tg from '@/static/messengers/tg.svg?url';
+import vb from '@/static/messengers/vb.svg?url';
+import wa from '@/static/messengers/wa.svg?url';
+import wa_az from '@/static/messengers/wa_az.svg?url';
+import { isAppleDevice } from '@/utils/bowser';
+import useSettings from '@/composables/use-settings';
+
+export const openFlomni = () => {
+  if (window?.$flomni?.chat) {
+    window.$flomni.chat.toggle(true);
+  }
+};
+
+export const openFlomniByClick = (event: MouseEvent) => {
+  event?.preventDefault();
+  openFlomni();
+};
+
+const showFlomniComponent = () => {
+  const store = useStore();
+  store.commit('flomni/setIsExternalOpened', true);
+};
+
+export const showFlomniComponentByClick = (event: MouseEvent) => {
+  event?.preventDefault();
+  showFlomniComponent();
+};
+
+const useFlomni = () => {
+  let flomniLinks: NodeListOf<HTMLElement>;
+
+  const store = useStore();
+
+  const { getSettingsGroup } = useSettings();
+
+  const { returnToMessengers, flomniConfig } = getSettingsGroup('all');
+  const { isAzSite } = useSiteInfo();
+
+  const isFlomniScriptLoaded = ref(false);
+
+  const { isLoggedInCabinet } = useSiteInfo();
+  const { fullName, getLoginPhone } = useCabinetData();
+  const displayChat = computed(() => store.getters['flomni/displayChat']);
+
+  const messengerButtons: Ref<any> = ref([]);
+
+  const isIOS = ref(false);
+
+  const showFlomniComponent = () => {
+    store.commit('flomni/setIsExternalOpened', true);
+  };
+
+  const showFlomniComponentByClick = (event: MouseEvent) => {
+    event?.preventDefault();
+    showFlomniComponent();
+  };
+
+  const updateState = (state: string) => {
+    store.commit('flomni/onUpdateState', { state });
+  };
+
+  const getFlomniConfig = () => {
+    return flomniConfig;
+  };
+  const getFlomniClientKey = () => {
+    const config = getFlomniConfig();
+    return config?.clientKey ?? import.meta.env.VITE_FLOMNI_KEY;
+  };
+
+  const clientKey = computed(() => getFlomniClientKey());
+
+  const installFlomni = () => {
+    const onToggle = (state: string) => {
+      if (window.$flomni && state === 'open') {
+        window.$flomni.chat.switchToggler(true);
+      }
+
+      updateState(state);
+    };
+
+    const src = 'https://i.v2.flomni.com/chat.corner.js';
+
+    const defaultConfig = {
+      clientKey: clientKey.value,
+      onlyApiWay: false,
+      rootClasses: 'non_authed',
+      onToggle,
+    };
+
+    const config = { ...defaultConfig, ...flomniConfig };
+
+    if (isLoggedInCabinet.value) {
+      delete config.rootClasses;
+      config.visitorAttributes = {
+        login: getLoginPhone.value,
+      };
+
+      const userName = fullName.value?.trim();
+      if (userName) {
+        config.visitorAttributes.userName = userName;
+      }
+    }
+
+    window.flomniConfig = config;
+
+    const params: any = {
+      type: 'text/javascript',
+      charset: 'utf-8',
+      id: 'flomniChat',
+      async: true,
+      onload: () => {
+        isFlomniScriptLoaded.value = true;
+      },
+    };
+
+    params.src = src;
+    const script = Object.assign(document.createElement('script'), params);
+    document.body.appendChild(script);
+  };
+
+  const messengerList = () => {
+    if (isAzSite.value) {
+      messengerButtons.value = [
+        {
+          icon: wa,
+          name: 'WhatsApp',
+          link: 'https://api.whatsapp.com/send?phone=994512321881',
+          messenger: 'waba',
+          qr: {
+            url: wa_az,
+          },
+        },
+      ];
+      return;
+    }
+
+    const url = `https://link.v2.flomni.com/widget/v2/settings/${
+      import.meta.env.VITE_FLOMNI_KEY
+    }?type=linker.standalone`;
+    axios.get(url).then((res) => {
+      const visibleButtons = res.data.messengers.filter((m: IButtonData) => {
+        if (m.messenger === 'abc' && !isIOS.value && returnToMessengers) {
+          return false;
+        }
+
+        return m.visible;
+      });
+
+      messengerButtons.value = visibleButtons.map((b: IButtonData) => {
+        let icon;
+        let name = '';
+
+        switch (b.messenger) {
+          case 'abc':
+            icon = messenger;
+            name = returnToMessengers ? 'Messages' : 'Чат';
+            break;
+          case 'fb':
+            icon = messenger;
+            name = 'Facebook';
+            break;
+          case 'vk':
+            icon = vk;
+            name = 'VK';
+            break;
+          case 'tlgr':
+            icon = tg;
+            name = 'Telegram';
+            break;
+          case 'vbr':
+            icon = vb;
+            name = 'Viber';
+            break;
+          case 'waba':
+            icon = wa;
+            name = 'WhatsApp';
+            break;
+          default:
+            icon = messenger;
+            name = 'Messages';
+        }
+        return {
+          ...b,
+          icon,
+          name,
+        };
+      });
+    });
+  };
+
+  onMounted(() => {
+    isIOS.value = isAppleDevice();
+  });
+
+  const addListenersToLinks = () => {
+    flomniLinks = document.querySelectorAll("a[href='#flomni']");
+
+    for (const link of flomniLinks) {
+      link.addEventListener('click', showFlomniComponentByClick);
+    }
+  };
+
+  const removeListenersFromLinks = () => {
+    for (const link of flomniLinks) {
+      link.removeEventListener('click', showFlomniComponentByClick);
+    }
+  };
+
+  return {
+    showFlomniComponent,
+    showFlomniComponentByClick,
+    addListenersToLinks,
+    removeListenersFromLinks,
+    installFlomni,
+    displayChat,
+    getFlomniConfig,
+    getFlomniClientKey,
+    clientKey,
+    messengerButtons,
+    messengerList,
+    returnToMessengers,
+    isFlomniScriptLoaded,
+  };
+};
+
+export default useFlomni;
diff --git a/parent_dir/src/composables/use-logout.ts b/parent_dir/src/composables/use-logout.ts
new file mode 100644
index 0000000..19da423
--- /dev/null
+++ b/parent_dir/src/composables/use-logout.ts
@@ -0,0 +1,26 @@
+import { inject } from 'vue';
+import { IS_AUTH_COOKIE_TAG } from '@/constants/cookie-tag';
+import { VueCookies } from 'vue-cookies';
+import useTildaUser from '@/composables/use-tilda-user';
+import { useStore } from 'vuex';
+
+export default function useLogout() {
+  const cookies = inject<VueCookies>('$cookies');
+  const store = useStore();
+  const tildaUser = useTildaUser();
+
+  const logOut = async () => {
+    if (cookies) {
+      cookies.remove(IS_AUTH_COOKIE_TAG);
+    }
+
+    tildaUser.removeLS();
+    await store.dispatch('cabinet/logoutFromCabinet');
+    window.history.pushState('', document.title, window.location.pathname);
+    window.location.pathname = `/${store.getters.currentLocaleISO}/`;
+  };
+
+  return {
+    logOut,
+  };
+}
diff --git a/parent_dir/src/composables/use-modal.ts b/parent_dir/src/composables/use-modal.ts
new file mode 100644
index 0000000..b6db1b0
--- /dev/null
+++ b/parent_dir/src/composables/use-modal.ts
@@ -0,0 +1,6 @@
+import { inject } from 'vue';
+import { VueFinalModalProperty } from 'vue-final-modal';
+
+export default function useModal(): VueFinalModalProperty {
+  return <VueFinalModalProperty>inject('$modal');
+}
diff --git a/parent_dir/src/composables/use-page-context.ts b/parent_dir/src/composables/use-page-context.ts
new file mode 100644
index 0000000..a3aaea8
--- /dev/null
+++ b/parent_dir/src/composables/use-page-context.ts
@@ -0,0 +1,28 @@
+// `usePageContext` allows us to access `pageContext` in any Vue component.
+// See https://vite-plugin-ssr.com/pageContext-anywhere
+
+import { inject, UnwrapNestedRefs } from 'vue';
+import type { App, InjectionKey } from 'vue';
+import { PageContext } from '#root/src/renderer/types';
+
+let key: InjectionKey<PageContext> = Symbol('pageContext');
+
+export const pageContextKey = key;
+
+function usePageContext() {
+  const pageContext = inject(key);
+  if (!pageContext) throw new Error('setPageContext() not called in parent');
+  return pageContext;
+}
+
+function setPageContext(app: App, pageContext: UnwrapNestedRefs<PageContext>) {
+  app.provide(key, pageContext);
+}
+
+export function updatePageContextKeyForTest(k: string) {
+  key = Symbol(k);
+  return key;
+}
+
+export { usePageContext };
+export { setPageContext };
diff --git a/parent_dir/src/composables/use-page.ts b/parent_dir/src/composables/use-page.ts
new file mode 100644
index 0000000..c349d06
--- /dev/null
+++ b/parent_dir/src/composables/use-page.ts
@@ -0,0 +1,85 @@
+import { computed } from 'vue';
+import { cdekHomePage } from '@/constants/global-variables';
+import useSiteInfo from '@/composables/use-site-info';
+import { usePageContext } from '@/composables/use-page-context';
+
+const usePage = () => {
+  const pageContext = usePageContext();
+
+  const { currentLocale } = useSiteInfo();
+
+  const isCityPage = computed(() => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return !!pageContext.pageProps?.page?.city?.id;
+  });
+
+  const checkIsHomePage = (path: string) => {
+    return (
+      path === `/${currentLocale.value}` ||
+      path === `/${currentLocale.value}/` ||
+      path === `/${currentLocale.value}${cdekHomePage}`
+    );
+  };
+
+  const isHomePage = computed(() => {
+    if (pageContext?.urlPathname) {
+      return checkIsHomePage(pageContext.urlPathname);
+    }
+
+    return false;
+  });
+
+  const isSearchResultsPage = computed(() => {
+    return pageContext?.urlPathname?.startsWith(`/${currentLocale.value}/search`);
+  });
+
+  const isTrackingPage = computed(() => {
+    return pageContext.urlOriginal.endsWith(`/tracking/`);
+  });
+
+  const isNewDesign = computed(() => {
+    if (isCityPage.value) {
+      return true;
+    }
+
+    return isHomePage.value;
+  });
+
+  const isHelpPage = computed(() => {
+    return (
+      !!pageContext?.routeParams?.['*'] &&
+      pageContext.urlOriginal.startsWith(`/${currentLocale.value}/faq`)
+    );
+  });
+
+  const isDarkPage = computed(() => {
+    return (
+      pageContext.urlOriginal.startsWith(`/${currentLocale.value}/payment-success`) ||
+      pageContext.urlOriginal.startsWith(`/${currentLocale.value}/calculator_B2B`) ||
+      pageContext.urlOriginal.startsWith(`/${currentLocale.value}/customs_duty`)
+    );
+  });
+
+  const isBusinessPage = computed(() => {
+    return pageContext.urlOriginal.startsWith(`/${currentLocale.value}/business`);
+  });
+
+  const isOfficesPage = computed(() => {
+    return pageContext.urlOriginal.endsWith(`/offices/`);
+  });
+
+  return {
+    isDarkPage,
+    isCityPage,
+    isHomePage,
+    isNewDesign,
+    isSearchResultsPage,
+    isHelpPage,
+    isTrackingPage,
+    isOfficesPage,
+    isBusinessPage,
+  };
+};
+
+export default usePage;
diff --git a/parent_dir/src/composables/use-rest-api.ts b/parent_dir/src/composables/use-rest-api.ts
new file mode 100644
index 0000000..0c54a9a
--- /dev/null
+++ b/parent_dir/src/composables/use-rest-api.ts
@@ -0,0 +1,9 @@
+import { inject } from 'vue';
+import RestApiClient from '@/api-clients/rest-api-client';
+
+export function useRestApi() {
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const restApi = inject<RestApiClient>('restApi')!;
+
+  return { restApi };
+}
diff --git a/parent_dir/src/composables/use-selected-city.ts b/parent_dir/src/composables/use-selected-city.ts
new file mode 100644
index 0000000..7f7f833
--- /dev/null
+++ b/parent_dir/src/composables/use-selected-city.ts
@@ -0,0 +1,28 @@
+import { useStore } from 'vuex';
+import MainState from '@/types/store';
+import { computed, inject } from 'vue';
+import { CdekDefaultCity } from '@/types/dto/city';
+import { COOKIE_CITY_ID_TAG } from '@/constants/cookie-tag';
+import { VueCookies } from 'vue-cookies';
+import { useOfficeDataService } from '@/services/OfficeDataService';
+
+export const useSelectedCity = () => {
+  const officeService = useOfficeDataService();
+
+  const $cookies = inject<VueCookies>('$cookies');
+
+  const store = useStore<MainState>();
+
+  const globalCity = computed(() => store.state.city);
+
+  const selectGlobalCity = (city: CdekDefaultCity) => {
+    store.dispatch('SELECT_CITY', city);
+    $cookies?.set(COOKIE_CITY_ID_TAG, city.cdek_id);
+    officeService.city = city;
+  };
+
+  return {
+    globalCity,
+    selectGlobalCity,
+  };
+};
diff --git a/parent_dir/src/composables/use-settings.ts b/parent_dir/src/composables/use-settings.ts
new file mode 100644
index 0000000..8d9f73f
--- /dev/null
+++ b/parent_dir/src/composables/use-settings.ts
@@ -0,0 +1,110 @@
+import { ExtendedLocale, getI18nLocales, getLocaleMapFromEnv } from '@/utils/env-utils';
+import groupBy from 'lodash/groupBy';
+import { SettingsGroup, SiteParam } from '@/types/dto/siteParams';
+import type {
+  ISettingsCookies,
+  ISettingsLogo,
+  ISettingsAll,
+  SettingsState,
+  PhoneParam,
+} from '@/types/store/settings';
+
+const FLOMNI_CONFIG_FLAGS = ['displayHelpCustomer', 'returnToMessengers', 'displayChatOnly'];
+
+const settings: SettingsState = {
+  cookies: {
+    btnText: '',
+    text: '',
+    title: '',
+  },
+  locales: getI18nLocales(getLocaleMapFromEnv(import.meta.env.VITE_LOCALE_CODE_NAME_MAP)),
+  logo: {
+    src: '/logo.svg',
+  },
+  all: {
+    appLinkIos: null,
+    appLinkAndroid: null,
+    displayHelpCustomer: false,
+    displayChatOnly: false,
+    flomniConfig: null,
+    returnToMessengers: false,
+    enableMindbox: false,
+  },
+  phoneParams: [],
+};
+
+const convertArrayToObject = (array: { name: string; value: string }[]) => {
+  return array.reduce((acc: Record<string, string>, { name, value }) => {
+    acc[name] = value;
+
+    return acc;
+  }, {});
+};
+
+const getParsedFlomniConfig = (settings: string) => {
+  try {
+    return JSON.parse(settings);
+  } catch {
+    return null;
+  }
+};
+
+const prepareSetting = (value?: string) => {
+  return Boolean(Number(value));
+};
+
+const getFlomniConfig = (config: Record<string, string>) => {
+  return {
+    ...FLOMNI_CONFIG_FLAGS.reduce((acc: Record<string, boolean>, key) => {
+      acc[key] = prepareSetting(config?.[key]);
+      return acc;
+    }, {}),
+    flomniConfig: getParsedFlomniConfig(config.flomniConfig),
+    flomniSettingsLC: null,
+  };
+};
+
+const useSettings = () => {
+  const init = (items: SiteParam[]) => {
+    const groups = groupBy(items, 'group');
+
+    (Object.keys(groups) as SettingsGroup[]).forEach((key) => {
+      const converted = convertArrayToObject(groups[key]);
+
+      if (key === 'phoneParams') {
+        settings.phoneParams = JSON.parse(converted.phoneParams);
+      } else if (key === 'all') {
+        settings.all = {
+          ...(converted as unknown as ISettingsAll),
+          enableMindbox: prepareSetting(converted.enableMindbox),
+          ...getFlomniConfig(converted),
+        };
+      } else {
+        // TODO: написать типы нормально, сейчас не очень ПАМАГИТЕ
+        settings[key] = converted as unknown as ISettingsCookies & ISettingsLogo;
+      }
+    });
+  };
+
+  function getSettingsGroup(key: 'all'): ISettingsAll;
+  function getSettingsGroup(key: 'phoneParams'): PhoneParam[];
+  function getSettingsGroup(key: 'logo'): ISettingsLogo;
+  function getSettingsGroup(key: 'cookies'): ISettingsCookies;
+  function getSettingsGroup(key: 'locales'): ExtendedLocale[];
+
+  function getSettingsGroup(key: SettingsGroup | 'locales') {
+    return settings[key];
+  }
+
+  const getShowLangSwitcher = () => {
+    return getSettingsGroup('locales').length > 1;
+  };
+
+  return {
+    init,
+    getShowLangSwitcher,
+    getSettingsGroup,
+  };
+};
+
+export default useSettings;
diff --git a/parent_dir/src/composables/use-site-info.ts b/parent_dir/src/composables/use-site-info.ts
new file mode 100644
index 0000000..dcfae8a
--- /dev/null
+++ b/parent_dir/src/composables/use-site-info.ts
@@ -0,0 +1,81 @@
+import { computed } from 'vue';
+import { useStore } from 'vuex';
+import { removeSideSlashes } from '@/utils/string.utils';
+
+// TODO: после мержа задачи 6158 подумать над переименованием хука (например, useCommonn и т.п.),
+//  так как хочется вынести сюда не только геттеры, но и всякие общие функции с использованием стора )
+const useSiteInfo = () => {
+  const store = useStore();
+
+  const websiteId = computed(() => {
+    return store.getters.websiteId;
+  });
+
+  const isRuSite = computed<boolean>(() => {
+    return store.getters.isRuSite;
+  });
+
+  const isAmSite = computed<boolean>(() => {
+    return store.getters.isAmSite;
+  });
+
+  const isKzSite = computed<boolean>(() => {
+    return store.getters.isKzSite;
+  });
+
+  const isUzSite = computed<boolean>(() => {
+    return store.getters.isUzSite;
+  });
+
+  const isKgSite = computed<boolean>(() => {
+    return store.getters.isKgSite;
+  });
+
+  const isAzSite = computed<boolean>(() => {
+    return store.getters.isAzSite;
+  });
+
+  const isBySite = computed<boolean>(() => {
+    return store.getters.isBySite;
+  });
+
+  const isGeSite = computed<boolean>(() => {
+    return store.getters.isGeSite;
+  });
+
+  const currentLocaleISO = computed<string>(() => {
+    return store.getters.currentLocaleISO;
+  });
+
+  const currentLocale = computed<string>(() => {
+    return store.getters.currentLocale;
+  });
+
+  const isLoggedInCabinet = computed<boolean>(() => {
+    return store.getters.isLoggedInCabinet;
+  });
+
+  const getLinkWithLocale = (link: string) => {
+    const removedSlashLink = removeSideSlashes(link);
+
+    return `/${currentLocale.value}/${removedSlashLink}/`;
+  };
+
+  return {
+    websiteId,
+    isRuSite,
+    isKzSite,
+    isAmSite,
+    isUzSite,
+    isKgSite,
+    isAzSite,
+    isBySite,
+    isGeSite,
+    currentLocaleISO,
+    currentLocale,
+    getLinkWithLocale,
+    isLoggedInCabinet,
+  };
+};
+
+export default useSiteInfo;
diff --git a/parent_dir/src/composables/use-tilda-user.ts b/parent_dir/src/composables/use-tilda-user.ts
new file mode 100644
index 0000000..2f7b481
--- /dev/null
+++ b/parent_dir/src/composables/use-tilda-user.ts
@@ -0,0 +1,18 @@
+import { TildaLS } from '@/types/dto/tilda';
+
+const LS_TILDA_KEY = 'cdek-tilda';
+
+export default function useTildaUser() {
+  const saveLS = (payload: TildaLS) => {
+    localStorage?.setItem(LS_TILDA_KEY, JSON.stringify(payload));
+  };
+
+  const removeLS = () => {
+    localStorage?.removeItem(LS_TILDA_KEY);
+  };
+
+  return {
+    removeLS,
+    saveLS,
+  };
+}
diff --git a/parent_dir/src/constants/cookie-tag.ts b/parent_dir/src/constants/cookie-tag.ts
new file mode 100644
index 0000000..a2c27e7
--- /dev/null
+++ b/parent_dir/src/constants/cookie-tag.ts
@@ -0,0 +1,3 @@
+export const COOKIE_CITY_ID_TAG = 'cityid';
+export const COOKIE_CONFIRM_COUNTRY = 'confirmCountry';
+export const IS_AUTH_COOKIE_TAG = 'isAuthorizedUser';
diff --git a/parent_dir/src/constants/default-cities.ts b/parent_dir/src/constants/default-cities.ts
new file mode 100644
index 0000000..be02764
--- /dev/null
+++ b/parent_dir/src/constants/default-cities.ts
@@ -0,0 +1,185 @@
+// Сначала ищем websiteID, потом локаль
+import { WebsiteId } from '@/env';
+import { CdekDefaultCity } from '@/types/dto/city';
+
+// ЭТО ДЕФОЛТНЫЙ ГОРОД ДЛЯ ОТОБРАЖЕНИЯ НА СТРАНИЦЫ ОФИСОВ
+export const DEFAULT_CITIES: Record<WebsiteId, Record<string, CdekDefaultCity>> = {
+  ru: {
+    ru: {
+      country: 'Россия',
+      country_code: 'ru',
+      locale: 'ru',
+      id: 14895,
+      cdek_id: 44,
+      name: 'Москва',
+      fullname: 'Москва, Москва, Россия',
+      url: 'moscow',
+    },
+  },
+  kz: {
+    ru: {
+      country: 'Казахстан',
+      country_code: 'kz',
+      locale: 'ru',
+      id: 14974,
+      cdek_id: 4961,
+      name: 'Нур-Султан (Астана)',
+      fullname: 'Нур-Султан (Астана), Акмолинская обл., Казахстан',
+      url: 'nur-sultan-astana',
+    },
+    kz: {
+      country: 'Казахстан',
+      country_code: 'kz',
+      locale: 'kz',
+      id: 9372500,
+      cdek_id: 4961,
+      name: 'Nur-Sultan (Astana)',
+      fullname: 'Nur-Sultan (Astana), Akmolinskaya obl., Kazakhstan',
+      url: 'nur-sultan-astana',
+    },
+  },
+  cn: {
+    zh: {
+      country: 'Китай (КНР)',
+      country_code: 'cn',
+      locale: 'zh',
+      id: 15919,
+      cdek_id: 10150,
+      name: '北京市',
+      fullname: '北京市, 北京, 中国',
+      url: 'beijing',
+    },
+    ru: {
+      country: 'Китай (КНР)',
+      country_code: 'cn',
+      locale: 'ru',
+      id: 15373,
+      cdek_id: 10150,
+      name: 'Пекин',
+      fullname: 'Пекин, Пекин, Китай (КНР)',
+      url: 'beijing',
+    },
+  },
+  by: {
+    ru: {
+      country: 'Белоруссия (Беларусь)',
+      country_code: 'by',
+      locale: 'ru',
+      id: 14940,
+      cdek_id: 9220,
+      name: 'Минск',
+      fullname: 'Минск, Минская обл., Белоруссия (Беларусь)',
+      url: 'minsk',
+    },
+  },
+  ge: {
+    ru: {
+      country: 'Грузия',
+      country_code: 'ge',
+      locale: 'ru',
+      id: 16316987,
+      cdek_id: 11564,
+      name: 'Тбилиси',
+      fullname: 'Грузия, Тбилиси',
+      url: 'tbilisi',
+    },
+    ge: {
+      country: 'Georgia',
+      country_code: 'ge',
+      locale: 'ge',
+      id: 20407617,
+      cdek_id: 11564,
+      name: 'Tbilisi',
+      fullname: 'Georgia, Tbilisi',
+      url: 'tbilisi',
+    },
+  },
+  uz: {
+    ru: {
+      country: 'Узбекистан',
+      country_code: 'uz',
+      locale: 'ru',
+      id: 15305,
+      cdek_id: 11562,
+      name: 'Ташкент',
+      fullname: 'Узбекистан, Ташкент',
+      url: 'tashkent',
+    },
+    uz: {
+      country: 'Uzbekistan',
+      country_code: 'uz',
+      locale: 'uz',
+      id: 20414041,
+      cdek_id: 11562,
+      name: 'Tashkent',
+      fullname: 'Uzbekistan, Tashkent',
+      url: 'tashkent',
+    },
+  },
+  kg: {
+    ru: {
+      country: 'Кыргызстан',
+      country_code: 'kg',
+      locale: 'ru',
+      id: 14926,
+      cdek_id: 5444,
+      name: 'Бишкек',
+      fullname: 'Киргызстан, город Бишкек, Бишкек',
+      url: 'bishkek',
+    },
+    kg: {
+      country: 'Kyrgyzstan',
+      country_code: 'kg',
+      locale: 'kg',
+      id: 16390970,
+      cdek_id: 5444,
+      name: 'Bishkek',
+      fullname: 'Bishkek, Chui region, Kyrgyzstan',
+      url: 'bishkek',
+    },
+  },
+  am: {
+    ru: {
+      country: 'Армения',
+      country_code: 'am',
+      locale: 'ru',
+      id: 15308,
+      cdek_id: 7114,
+      name: 'Ереван',
+      fullname: 'Ереван',
+      url: 'erevan',
+    },
+    am: {
+      country: 'Armenia',
+      country_code: 'am',
+      locale: 'am',
+      id: 16396240,
+      cdek_id: 7114,
+      name: 'Erevan',
+      fullname: 'Erevan',
+      url: 'erevan',
+    },
+  },
+  az: {
+    ru: {
+      id: 8066219,
+      cdek_id: 5090,
+      name: 'Баку',
+      fullname: 'Азербайджан, Баку, Баку',
+      locale: 'ru',
+      country_code: 'az',
+      country: 'Азербайджан',
+      url: 'baku',
+    },
+    az: {
+      id: 8066219,
+      cdek_id: 5090,
+      name: 'Baku',
+      fullname: 'Baku',
+      locale: 'az',
+      country_code: 'az',
+      country: 'Azerbaijan',
+      url: 'baku',
+    },
+  },
+};
diff --git a/parent_dir/src/constants/default-colors.ts b/parent_dir/src/constants/default-colors.ts
new file mode 100644
index 0000000..4b9a540
--- /dev/null
+++ b/parent_dir/src/constants/default-colors.ts
@@ -0,0 +1,28 @@
+/**
+ * $ui-base =        #00A942
+ * $ui-red-base =    #FA4747
+ * $ui-orange-base = #FF6B00
+ * $ui-yellow-base = #FFCB07
+ * $ui-black =       #434C5D
+ * $ui-dark-gray =   #ADAFB4
+ * $ui-gray =        #E0E0E0
+ * $ui-gray-1 =      #B0B0B0
+ * $ui-light-gray =  #F2F2F2
+ * $ui-light-blue =  #F6F7F9
+ * $ui-white =       #FFFFFF
+ */
+
+export const $uiBaseColor = {
+  base: '#00A942',
+  redBase: '#FA4747',
+  orangeBase: '#FF6B00',
+  yellowBase: '#FFCB07',
+  black: '#434C5D',
+  darkGray: '#ADAFB4',
+  gray: '#E0E0E0',
+  gray1: '#B0B0B0',
+  lightGray: '#F2F2F2',
+  lightBlue: '#F6F7F9',
+  white: '#FFFFFF',
+  primaryColor: '#1AB248',
+};
diff --git a/parent_dir/src/constants/default-coords.ts b/parent_dir/src/constants/default-coords.ts
new file mode 100644
index 0000000..dd12f73
--- /dev/null
+++ b/parent_dir/src/constants/default-coords.ts
@@ -0,0 +1,13 @@
+export const MoscowCenterCoords: [number, number] = [55.8203756, 37.4431069];
+
+export const moscowCity = {
+  cdek_id: 44,
+  country: 'Россия',
+  country_code: 'ru',
+  fullname: 'Москва, Москва, Россия',
+  id: 14895,
+  locale: 'ru-RU',
+  metro: false,
+  name: 'Москва',
+  url: 'moscow',
+};
diff --git a/parent_dir/src/constants/default-meta-data.ts b/parent_dir/src/constants/default-meta-data.ts
new file mode 100644
index 0000000..c2d5eec
--- /dev/null
+++ b/parent_dir/src/constants/default-meta-data.ts
@@ -0,0 +1,143 @@
+import { VueI18nTranslation } from 'vue-i18n';
+
+const appStoreId = '1384376966';
+const googlePlayId = 'com.logistic.sdek';
+
+export function getDefaultMetaData(t: VueI18nTranslation) {
+  return {
+    title: t('defaultCdekTitle'),
+    meta: [
+      { charset: 'utf-8' },
+      {
+        name: 'viewport',
+        content: 'width=device-width, initial-scale=1, maximum-scale=5, minimal-ui',
+      },
+      { name: 'msapplication-TileColor', content: '#da532c' },
+      { name: 'theme-color', content: '#ffffff' },
+      { name: 'format-detection', content: 'telephone=no' },
+      {
+        hid: 'description',
+        name: 'description',
+        content: t('defaultCdekDescription'),
+      },
+      {
+        name: 'yandex-verification',
+        content: import.meta.env.VITE_YANDEX_VERIFICATION,
+      },
+      {
+        name: 'apple-itunes-app',
+        content: `app-id=${appStoreId}`,
+      },
+      {
+        name: 'google-play-app',
+        content: `app-id=${googlePlayId}`,
+      },
+      {
+        name: 'facebook-domain-verification',
+        content: import.meta.env.VITE_FACEBOOK_DOMAIN_VERIFICATION,
+      },
+      {
+        name: 'color-scheme',
+        content: 'light',
+      },
+      {
+        name: 'msapplication-navbutton-color',
+        content: '#d9f5ff',
+      },
+      {
+        name: 'msapplication-TileImage',
+        content: '/favicons/android-chrome-192x192.png',
+      },
+      {
+        name: 'apple-mobile-web-app-status-bar-style',
+        content: '#3d6eff',
+      },
+      {
+        name: 'application-name',
+        content: 'CDEK',
+      },
+      {
+        name: 'apple-mobile-web-app-title',
+        content: 'CDEK',
+      },
+    ],
+    link: [
+      {
+        href: '/favicons/favicon.svg',
+        rel: 'icon',
+        type: 'image/svg+xml',
+      },
+      {
+        rel: 'icon',
+        type: 'image/png',
+        sizes: '16x16',
+        href: '/favicons/favicon-16x16.png',
+      },
+      {
+        rel: 'icon',
+        type: 'image/png',
+        sizes: '32x32',
+        href: '/favicons/favicon-32x32.png',
+      },
+      {
+        rel: 'icon',
+        type: 'image/png',
+        sizes: '38x38',
+        href: '/favicons/favicon-38x38.png',
+      },
+      {
+        rel: 'icon',
+        type: 'image/png',
+        sizes: '72x72',
+        href: '/favicons/favicon-72x72.png',
+      },
+      {
+        rel: 'icon',
+        type: 'image/png',
+        sizes: '128x128',
+        href: '/favicons/favicon-128x128.png',
+      },
+      {
+        rel: 'icon',
+        type: 'image/png',
+        sizes: '152x152',
+        href: '/favicons/favicon-152x152.png',
+      },
+      {
+        rel: 'icon',
+        type: 'image/png',
+        sizes: '192x192',
+        href: '/favicons/favicon-192x192.png',
+      },
+      {
+        rel: 'icon',
+        type: 'image/png',
+        sizes: '512x512',
+        href: '/favicons/favicon-512x512.png',
+      },
+      { rel: 'manifest', href: '/site.webmanifest' },
+      {
+        rel: 'mask-icon',
+        color: '#5bbad5',
+        href: '/favicons/safari-pinned-tab.svg',
+      },
+      { rel: 'icon', type: 'image/x-icon', href: '/favicons/favicon.ico' },
+      { rel: 'apple-touch-icon', href: '/smartbanner/apple-touch-icon.png' },
+      { rel: 'android-touch-icon', href: '/smartbanner/android-icon.png' },
+    ],
+    script: [
+      {
+        innerHTML: 'window.suggestmeyes_loaded = true;',
+        type: 'text/javascript',
+        charset: 'utf-8',
+      },
+      {
+        // На страницах тильды есть скрипты прямо в верстке которые используют функцию t_onReady.
+        // Скрипты в которых создается t_onReady загружаются позже чем бразуер в первый раз вызывает скрипты из верстки
+        // Чтобы на этом этапе ничего не разваливалось, добавляю эту пустую функцию.
+        innerHTML: 'window.t_onReady = function() {}',
+        type: 'text/javascript',
+      },
+    ],
+  };
+}
diff --git a/parent_dir/src/constants/global-variables.ts b/parent_dir/src/constants/global-variables.ts
new file mode 100644
index 0000000..725361c
--- /dev/null
+++ b/parent_dir/src/constants/global-variables.ts
@@ -0,0 +1,2 @@
+export const cdekHomePage = '/individuals/';
+export const cdekTitle = 'СДЭК - курьерская служба: доставка грузов и документов по всему миру';
diff --git a/parent_dir/src/constants/metrics.ts b/parent_dir/src/constants/metrics.ts
new file mode 100644
index 0000000..88820fc
--- /dev/null
+++ b/parent_dir/src/constants/metrics.ts
@@ -0,0 +1,21 @@
+export const RETURNS = {
+  CLIENT_RETURN_TRACING_SITE: 'client_return_tracing_site',
+} as const;
+
+export const ADVERT_AGREEMENT = {
+  LK_MAIL: 'lk_mail',
+  LK_MAIL_AD_CONFIRM: 'lk_mail_ad_confirm',
+  LK_AD: 'lk_ad',
+  LK_AD_CONFIRM: 'lk_ad_confirm',
+} as const;
+
+export const GIFT = {
+  GIFTS_CLICK: 'gifts_click',
+} as const;
+
+export const enum CdekIdGoal {
+  TINKOFF = 'cdekid_tinkoff',
+  ALFA_SITE = 'cdekid_alfa_site',
+  MOBILEID_SITE = 'cdekid_mobileid_site',
+  FORM_SITE = 'cdekid_form_site',
+}
diff --git a/parent_dir/src/constants/passport-v2.ts b/parent_dir/src/constants/passport-v2.ts
new file mode 100644
index 0000000..04f7509
--- /dev/null
+++ b/parent_dir/src/constants/passport-v2.ts
@@ -0,0 +1,107 @@
+export const PASSPORT_PAGE_STEPS = {
+  CODE: 'CODE',
+  DOCUMENT_TYPE_CHOICE: 'DOCUMENT_TYPE_CHOICE',
+  FORM_FILL_DATA: 'FORM_FILL_DATA',
+  FORM_UPLOAD_FILES: 'FORM_UPLOAD_FILES',
+  FORM_OFFER_CDEK_ID: 'FORM_OFFER_CDEK_ID',
+  FORM_SEND_FILES: 'FORM_SEND_FILES',
+  FORM_SEND_FORM: 'FORM_SEND_FORM',
+};
+
+export const DOCUMENTS_TYPES = {
+  PASSPORT: 'PASSPORT',
+  ID_CARD: 'ID_CARD',
+  OTHER: 'OTHER',
+};
+
+export const CITIZENSHIP_ID_MAP = {
+  RU: 'RU',
+  KZ: 'KZ',
+  KG: 'KG',
+  BY: 'BY',
+  UZ: 'UZ',
+  AM: 'AM',
+  GE: 'GE',
+  AZ: 'AZ',
+  IL: 'IL',
+  OTHER: 'OTHER',
+};
+
+export const PASSPORT_LOADING_STATUSES = {
+  LOADING: 'LOADING',
+  SUCCESS: 'SUCCESS',
+  ERROR: 'ERROR',
+  INCORRECT: 'INCORRECT',
+  SUCCESS_CDEK_ID: 'SUCCESS_CDEK_ID',
+  ERROR_CDEK_ID: 'ERROR_CDEK_ID',
+};
+
+export const ERRORS_MAP = {
+  err_identity_document_scan_required: 'Скан паспорта обязателен',
+  err_internal: 'Внутренняя ошибка. Скоро починим!',
+  err_idx_unknown: 'Что-то сломалось. Уже выясняем',
+  err_idx_parse: 'Не удалось распознать скан. Введите данные вручную',
+  err_idx_validate_name_date: 'Некорректные ФИО и дата рождения. Пожалуйста, перепроверьте данные.',
+  err_idx_validate_name_date_number:
+    'Некорректные ФИО, дата рождения и номер паспорта. Пожалуйста, перепроверьте данные',
+  err_idx_validate_non_correct:
+    'Не можем проверить паспортные данные. Пожалуйста, перепроверьте данные.',
+  err_idx_validate_issue_date_verified:
+    'Дата выдачи паспорта не подтверждена. Пожалуйста, перепроверьте данные.',
+  err_save_identity_document: 'Не удалось сохранить паспортные данные.',
+  err_can_not_get_file: 'Ошибка чтения файла.',
+  err_fns_connect: 'Ошибка запроса ИНН',
+  err_fns_validate_tin: 'Ошибка проверки паспортных данных.',
+  err_fns_validate_tin_mismatch: 'Указанный ИНН не соотвествует паспортным данным.',
+  err_invalid_phone: 'Невозможно обработать уведомление. Отсутствует номер телефона.',
+  err_invalid_order_number: 'Невозможно обработать уведомление. Отсутствует номер заказа.',
+  err_validation_failed: 'Ошибка валидации документа.',
+  err_name_is_mandatory: 'Имя обязательно к заполнению.',
+  err_invalid_name: 'Ошибка в имени.',
+  err_surname_is_mandatory: 'Фамилия обязательна к заполнению.',
+  err_invalid_surname: 'Ошибка в фамилии.',
+  err_invalid_patronymic: 'Ошибка в отчестве.',
+  err_invalid_nationality: 'Ошибка в национальности.',
+  err_passport_number_is_mandatory: 'Номер паспорта обязателен к заполнению.',
+  err_invalid_passport_number: 'Ошибка в номере паспорта.',
+  err_invalid_place_of_birth: 'Ошибка в месте рождения.',
+  err_date_of_birth_is_mandatory: 'Дата рождения обязательна к заполнению.',
+  err_invalid_date_of_birth: 'Ошибка в дате рождения.',
+  err_date_of_issue_is_mandatory: 'Дата выдачи обязательна к заполнению.',
+  err_invalid_date_of_issue: 'Ошибка в дате выдачи документа.',
+  err_authority_is_mandatory: 'Необходимо укзать место выдачи документа.',
+  err_invalid_authority: 'Ошибка в месте выдачи документа.',
+  err_invalid_date_of_expiry: 'Ошибка срока действия документа.',
+  err_iin_is_mandatory: 'Индивидуальный идентификационный номер обязателен к заполнению.',
+  err_invalid_iin: 'Ошибка в индивидуальном идентификационном номере.',
+  err_card_number_is_mandatory: 'Номер карты обязателен к заполнению.',
+  err_invalid_card_number: 'Ошибка в номере карты.',
+  err_pin_is_mandatory: 'Персональный идентификационный номер обязателен к заполнению.',
+  err_invalid_pin: 'Ошибка в персональном идентификационном номере.',
+  err_document_number_is_mandatory: 'Номер документа обазятелен к заполнению.',
+  err_invalid_document_number: 'Ошибка в номере документа.',
+  err_invalid_document: 'Ошибка в документе.',
+  err_collector_not_found: 'Процесс сбора документов не найден.',
+  err_collector_is_cancelled: 'Процесс сбора документов отменен.',
+  err_collector_is_stopped: 'Процесс сбора документов остановлен.',
+  err_collector_is_completed: 'Процесс сбора документов завершен.',
+  err_person_not_found: 'Персона не найдена.',
+  err_order_client_not_found: 'Клиент заказа не найден.',
+  err_invalid_tin: 'Неверный ИНН. Пожалуйста, перепроверьте паспортные данные и повторите.',
+  file_error:
+    'Скан удостоверения личности является обязательным при не совпадении страны получения с гражданством.',
+  err_passport_serial_is_mandatory: 'Серия паспорта обязательна к заполнению.',
+  err_invalid_passport_serial: 'Ошибка в серии паспорта.',
+  err_cant_overwrite_document:
+    'Ваши данные уже были переданы ранее. Повторная отправка возможна через 24 часа.',
+  err_date_of_expiry_is_mandatory: 'Необходимо указать дату окончания срока действия документа.',
+  err_card_serial_is_mandatory: 'Серия карты обязательна к заполнению.',
+  err_invalid_card_serial: 'Ошибка в серии карты.',
+  err_citizenship_is_mandatory: 'Необходимо указать страну выдачи документа.',
+  err_invalid_citizenship: 'Ошибка в стране гражданства документа.',
+  err_tin_is_mandatory: 'Идентификационный номер налогоплательщика обязателен к заполнению.',
+  err_identification_number_is_mandatory: 'Идентификационный номер обязателен к заполнению.',
+  err_invalid_identification_number: 'Ошибка в идентификационном номере.',
+  err_invalid_country_iso3: 'Ошибка в ISO3166.1-alpha3 коде страны.',
+  err_contract_not_found: 'Договор не найден.',
+};
diff --git a/parent_dir/src/constants/select-countries.ts b/parent_dir/src/constants/select-countries.ts
new file mode 100644
index 0000000..ecb6f92
--- /dev/null
+++ b/parent_dir/src/constants/select-countries.ts
@@ -0,0 +1,26 @@
+export const COUNTRIES = [
+  {
+    url: 'https://cdek.ru',
+    code: 'ru',
+  },
+  {
+    url: 'https://cdek.by',
+    code: 'by',
+  },
+  {
+    url: 'https://cdek.kz',
+    code: 'kz',
+  },
+  {
+    url: 'https://cdek-express.cn',
+    code: 'cn',
+  },
+  {
+    url: 'https://cdek-am.com',
+    code: 'am',
+  },
+  {
+    url: 'https://cdek.kg',
+    code: 'kg',
+  },
+];
diff --git a/parent_dir/src/directives/appear.directive.ts b/parent_dir/src/directives/appear.directive.ts
new file mode 100644
index 0000000..d5df9be
--- /dev/null
+++ b/parent_dir/src/directives/appear.directive.ts
@@ -0,0 +1,72 @@
+import throttle from 'lodash.throttle';
+import { DirectiveBinding } from 'vue';
+
+const OFFSET = 0.2;
+const MAIN_CLASS = 'appear-animation';
+const PASSIVE_CLASS = MAIN_CLASS.concat('_hidden');
+const INSIDE_PATTERNS = ['bebe', 'beeb', 'ebeb', 'ebbe'];
+
+interface VAppearHtmlElement extends HTMLElement {
+  $destroyScroll: () => void;
+}
+
+function scrollHandler(elem: VAppearHtmlElement) {
+  const viewportHeight = window.innerHeight;
+  const top = OFFSET * viewportHeight;
+  const bottom = (1 - OFFSET) * viewportHeight;
+
+  function recalculateLocation(element: VAppearHtmlElement) {
+    const rect = element.getBoundingClientRect();
+    const adaptiveTop = rect.height < top ? 0 : top;
+    const adaptiveBottom = rect.height < viewportHeight - bottom ? viewportHeight : bottom;
+
+    const patternList: [string, number][] = [
+      ['b', adaptiveTop],
+      ['b', adaptiveBottom],
+      ['e', rect.top],
+      ['e', rect.bottom],
+    ];
+
+    patternList.sort((a, b) => a[1] - b[1]);
+    const pattern = patternList.map((e) => e[0]).join('');
+
+    if (INSIDE_PATTERNS.includes(pattern)) {
+      element.classList.remove(PASSIVE_CLASS);
+    }
+  }
+  recalculateLocation(elem);
+}
+
+function subscribeScroll(func: ReturnType<typeof throttle>) {
+  window.addEventListener('scroll', func);
+  return () => {
+    window.removeEventListener('scroll', func);
+  };
+}
+
+function isValue(binding: DirectiveBinding) {
+  return binding.value !== undefined && typeof binding.value === 'boolean';
+}
+
+export const appearDirective = {
+  beforeMount(el: VAppearHtmlElement, binding: DirectiveBinding) {
+    const active = isValue(binding) ? binding.value : true;
+    if (!active) return;
+    el.classList.add(PASSIVE_CLASS);
+    el.classList.add(MAIN_CLASS);
+  },
+  mounted(el: VAppearHtmlElement, binding: DirectiveBinding) {
+    const active = isValue(binding) ? binding.value : true;
+    if (!active) return;
+    const func = throttle(scrollHandler.bind(null, el), 300);
+    const unsubscribe = subscribeScroll(func);
+    setTimeout(() => {
+      scrollHandler(el);
+    }, 1000);
+    el.$destroyScroll = () => unsubscribe();
+  },
+  unmounted(el: VAppearHtmlElement) {
+    el.classList.remove(MAIN_CLASS, PASSIVE_CLASS);
+    el.$destroyScroll && el.$destroyScroll();
+  },
+};
diff --git a/parent_dir/src/directives/append-to-body.directive.ts b/parent_dir/src/directives/append-to-body.directive.ts
new file mode 100644
index 0000000..0ff73f3
--- /dev/null
+++ b/parent_dir/src/directives/append-to-body.directive.ts
@@ -0,0 +1,59 @@
+import { cdekConsoleLog } from '@/utils/console-wrapper';
+import { DirectiveBinding, ComponentPublicInstance } from 'vue';
+
+type CalculatePositionCoords = { width: string; top: string; left: string };
+interface AppendToBodyHTMLElement extends HTMLElement {
+  unbindPosition: unknown;
+}
+
+type AppendToBodyInstance = ComponentPublicInstance<{
+  appendToBody: unknown;
+  calculatePosition: (el: unknown, context: unknown, coords: CalculatePositionCoords) => unknown;
+}>;
+
+export const appendToBodyDirective = {
+  mounted(el: AppendToBodyHTMLElement, bindings: DirectiveBinding) {
+    const context = bindings.instance as AppendToBodyInstance;
+
+    if (context && context.appendToBody) {
+      let config = {
+        ref: context.$refs.toggle || null,
+        active: true,
+      };
+
+      if (bindings.value) {
+        config = Object.assign(config, bindings.value);
+      }
+
+      if (!config.active) return;
+      const element = config.ref;
+
+      if (element) {
+        const { height, top, left } = (element as HTMLElement).getBoundingClientRect();
+
+        el.unbindPosition = context.calculatePosition(el, context, {
+          width: 'auto',
+          top: `${window.scrollY + top + height}px`,
+          left: `${window.scrollX + left}px`,
+        });
+
+        document.body.appendChild(el);
+      } else {
+        cdekConsoleLog('The element from which you need to make calculations is not installed');
+      }
+    }
+  },
+
+  unmounted(el: AppendToBodyHTMLElement, bindings: DirectiveBinding) {
+    const context = bindings.instance as AppendToBodyInstance;
+
+    if (context?.appendToBody) {
+      if (el.unbindPosition && typeof el.unbindPosition === 'function') {
+        el.unbindPosition();
+      }
+      if (el.parentNode) {
+        el.parentNode.removeChild(el);
+      }
+    }
+  },
+};
diff --git a/parent_dir/src/directives/cdek-click-outside.directive.ts b/parent_dir/src/directives/cdek-click-outside.directive.ts
new file mode 100644
index 0000000..44f7ccc
--- /dev/null
+++ b/parent_dir/src/directives/cdek-click-outside.directive.ts
@@ -0,0 +1,41 @@
+import { DirectiveBinding, VNode } from 'vue';
+
+let handleClickOutside: (e: Event) => void;
+
+export const clickOutsideDirective = {
+  $element: null,
+  beforeMount(el: HTMLElement, binding: DirectiveBinding, vnode: VNode) {
+    handleClickOutside = (e) => {
+      e.stopPropagation();
+      const { handler, exclude } = binding.value;
+      let clickedOnExcludedEl = false;
+
+      // Gives you the ability to exclude certain elements if you want, pass as array of strings to exclude
+      if (exclude) {
+        exclude.forEach((refName: string) => {
+          if (!clickedOnExcludedEl) {
+            if (!binding.instance) {
+              return;
+            }
+
+            const excludedEl = binding.instance.$refs[refName];
+            if (excludedEl)
+              clickedOnExcludedEl = (excludedEl as HTMLElement).contains(
+                e.target as HTMLButtonElement,
+              );
+          }
+        });
+      }
+      if (vnode.el && !vnode.el.contains(e.target) && !clickedOnExcludedEl) {
+        handler(e);
+      }
+    };
+    document.addEventListener('click', handleClickOutside);
+    document.addEventListener('touchstart', handleClickOutside);
+  },
+
+  unmounted() {
+    document.removeEventListener('click', handleClickOutside);
+    document.removeEventListener('touchstart', handleClickOutside);
+  },
+};
diff --git a/parent_dir/src/directives/test-id.directive.ts b/parent_dir/src/directives/test-id.directive.ts
new file mode 100644
index 0000000..ebc4d2b
--- /dev/null
+++ b/parent_dir/src/directives/test-id.directive.ts
@@ -0,0 +1,14 @@
+import { DirectiveBinding } from 'vue';
+
+const testIdDirective = {
+  beforeMount(el: HTMLElement, binding: DirectiveBinding) {
+    const environment =
+      import.meta.env.VITE_ENVIRONMENT || (import.meta.env.DEV ? 'development' : 'production');
+
+    if (environment !== 'production') {
+      el.setAttribute('data-test', binding.value);
+    }
+  },
+};
+
+export default testIdDirective;
diff --git a/parent_dir/src/layouts/DefaultLayout.vue b/parent_dir/src/layouts/DefaultLayout.vue
new file mode 100644
index 0000000..f80d48a
--- /dev/null
+++ b/parent_dir/src/layouts/DefaultLayout.vue
@@ -0,0 +1,162 @@
+<template>
+  <div class="layout-wrapper public-site">
+    <progress-bar />
+    <layout-header v-bind="headerSettings" />
+    <client-only>
+      <Notifications
+        group="notification-error"
+        position="top right"
+        :max="3"
+        classes="notification"
+        width="100%"
+      />
+    </client-only>
+    <main
+      id="work-area"
+      class="work-area"
+      :class="{
+        'layout-wrapper__work-area_help': isHelpPage,
+        'work-area--dark': isDarkPage,
+      }"
+    >
+      <slot />
+    </main>
+
+    <footer-main />
+
+    <client-only>
+      <flomni-chat v-if="!isLoggedInCabinet || loginPhone" :inline="inlineFlomni" />
+    </client-only>
+
+    <client-only v-if="hasConsetToUseOfCookie">
+      <cookie-alert />
+    </client-only>
+
+    <client-only>
+      <help-customer-wrapper v-if="settingsAll.displayHelpCustomer" />
+    </client-only>
+
+    <div
+      class="mobile-menu-overlay"
+      :class="{ 'mobile-menu-overlay--showed': isMobileMenuOpen }"
+      @click="clickModalOverlay"
+    />
+
+    <client-only> <modals-container /> </client-only>
+  </div>
+</template>
+
+<script>
+import ProgressBar from '#root/src/components/ProgressBar';
+import LayoutHeader from '#root/src/components/Layout/LayoutHeader.vue';
+import layoutMixin from '#root/src/mixins/layout.mixin';
+import { mapGetters } from 'vuex';
+import { inject, defineComponent } from 'vue';
+import { storeToRefs } from 'pinia';
+import layoutHeaderMixin from '@/mixins/layout-header.mixin';
+import FooterMain from '@/components/Footer/FooterMain.vue';
+import ClientOnly from '@/components/ClientOnly.vue';
+import CookieAlert from '@/components/CookieAlert.vue';
+import HelpCustomerWrapper from '@/components/HelpCustomer/HelpCustomerWrapper.vue';
+import FlomniChat from '@/components/FlomniChat/FlomniChat.vue';
+import ConfirmCountryModal from '@/components/Modal/SelectCountryModal/ConfirmCountryModal.vue';
+import { COOKIE_CONFIRM_COUNTRY, IS_AUTH_COOKIE_TAG } from '@/constants/cookie-tag';
+import { castEnv } from '@/utils/env-utils';
+import { COUNTRIES } from '@/constants/select-countries';
+import { getLocalCity } from '@/utils/menus.utils';
+import { useMenuStore } from '@/store/pinia/menu/menu';
+import usePage from '@/composables/use-page';
+import useLoadUser from '@/components/Login/use-load-user';
+import useSiteInfo from '@/composables/use-site-info';
+import { sendParams } from '@/utils/reach-goal';
+
+export default defineComponent({
+  name: 'DefaultLayout',
+  components: {
+    FlomniChat,
+    HelpCustomerWrapper,
+    CookieAlert,
+    ProgressBar,
+    LayoutHeader,
+    FooterMain,
+    ClientOnly,
+  },
+  mixins: [layoutMixin, layoutHeaderMixin],
+  setup() {
+    const pageContent = inject('pageContent', '');
+    const { isHelpPage, isDarkPage } = usePage();
+    const { load: loadUser } = useLoadUser();
+    const menuStore = useMenuStore();
+
+    const { isMobileMenuOpen } = storeToRefs(menuStore);
+    const { currentLocale, isLoggedInCabinet } = useSiteInfo();
+    return {
+      isDarkPage,
+      pageContent,
+      isMobileMenuOpen,
+      menuStore,
+      isHelpPage,
+      loadUser,
+      currentLocale,
+      isLoggedInCabinet,
+    };
+  },
+  computed: {
+    ...mapGetters({
+      inlineFlomni: 'flomni/inline',
+      loginPhone: 'cabinet/getLoginPhone',
+    }),
+  },
+  beforeMount() {
+    // Нужно вызвать максимально первым
+    sendParams({ user_auth: this.isLoggedInCabinet });
+  },
+  mounted() {
+    if (!this.settingsAll.displayHelpCustomer) {
+      // TODO: разобрарться нужно ли это, так как pageContent провайдится ниже, и в данным момент pageContent всегда пустая строка
+      if (/id="(flomni|flomni-inline)"/.test(this.pageContent)) {
+        this.$store.commit('flomni/onInit', {
+          displayChat: true,
+          inline: /id="flomni-inline"/.test(this.pageContent),
+        });
+      } else {
+        this.$store.commit('flomni/onInit', { displayChat: false });
+      }
+    }
+
+    this.$apiClient.cabinet.setLocale(this.currentLocale);
+
+    if (this.isLoggedInCabinet) {
+      this.loadUser({ withOrderNotification: true });
+    } else {
+      // Удаляем на всякий случай, для неавторизованного, так как возможно где-то не удалилась
+      this.$cookies.remove(IS_AUTH_COOKIE_TAG);
+    }
+
+    const countryCode = getLocalCity()?.country_code || this.$store.getters.websiteId;
+    const isShow = castEnv(import.meta.env.VITE_SHOW_SELECT_COUNTRY);
+    if (
+      isShow &&
+      !this.$cookies.isKey(COOKIE_CONFIRM_COUNTRY) &&
+      countryCode !== this.$store.getters.websiteId &&
+      COUNTRIES.find((el) => el.code === countryCode)
+    ) {
+      this.$modal.show({
+        component: ConfirmCountryModal,
+      });
+    }
+  },
+});
+</script>
+
+<style lang="scss" scoped>
+.layout-wrapper {
+  .layout-wrapper__work-area_help {
+    padding-top: 60px;
+
+    @include media-min-lg {
+      padding-top: 0;
+    }
+  }
+}
+</style>
diff --git a/parent_dir/src/locales/i18n-config.ts b/parent_dir/src/locales/i18n-config.ts
new file mode 100644
index 0000000..b6ae9c6
--- /dev/null
+++ b/parent_dir/src/locales/i18n-config.ts
@@ -0,0 +1,74 @@
+import { createI18n, I18n } from 'vue-i18n';
+import { nextTick } from 'vue';
+import { getExpressApi } from '#root/src/api-clients/express-api';
+import { getEnvUniversal, castEnv } from '#root/src/utils/env-utils';
+
+const expressApi = getExpressApi();
+
+function ruPluralRules(choice: number, choicesLength: number) {
+  if (choice === 0) {
+    return 0;
+  }
+
+  const teen = choice > 10 && choice < 20;
+  const endsWithOne = choice % 10 === 1;
+
+  if (choicesLength < 4) {
+    return !teen && endsWithOne ? 1 : 2;
+  }
+
+  if (!teen && endsWithOne) {
+    return 1;
+  }
+
+  if (!teen && choice % 10 >= 2 && choice % 10 <= 4) {
+    return 2;
+  }
+
+  return choicesLength < 4 ? 2 : 3;
+}
+
+const VITE_LOCALES_FROM_JSON = castEnv(getEnvUniversal('VITE_LOCALES_FROM_JSON'));
+
+// Русский всегда дефолтный язык, если добавляются ключи
+// не забудем добавить и в остальные языки
+export async function loadLocaleMessages(i18n: I18n, locale: string) {
+  if (VITE_LOCALES_FROM_JSON) {
+    const messages = await expressApi.get(`/messages/${locale}`);
+    i18n.global.setLocaleMessage(locale, messages.data);
+  } else {
+    const messages = await import(
+      /* webpackChunkName: "locale-[request]" */ `./messages/${locale}.js`
+    );
+    i18n.global.setLocaleMessage(locale, messages.default);
+  }
+
+  return nextTick();
+}
+
+export default async function i18nConfig(locale: string) {
+  const DEFAULT_LOCALE = 'ru';
+
+  const i18n = createI18n<any, 'ru' | 'kz'>({
+    legacy: false, // you must set `false`, to use Composition API
+    locale,
+    fallbackLocale: DEFAULT_LOCALE,
+    warnHtmlMessage: false, // disable warning HTML in message
+    pluralRules: {
+      ru: ruPluralRules,
+    },
+  });
+
+  const localesPromises: Promise<void>[] = [];
+
+  if (locale !== DEFAULT_LOCALE) {
+    // Дефолтная локаль должна быть всегда
+    localesPromises.push(loadLocaleMessages(i18n, DEFAULT_LOCALE));
+  }
+
+  localesPromises.push(loadLocaleMessages(i18n, locale));
+
+  await Promise.all(localesPromises);
+
+  return i18n;
+}
diff --git a/parent_dir/src/middleware/mutation-types.ts b/parent_dir/src/middleware/mutation-types.ts
new file mode 100644
index 0000000..f6f14e3
--- /dev/null
+++ b/parent_dir/src/middleware/mutation-types.ts
@@ -0,0 +1,24 @@
+export const SET_SHOW_CONFIRM_CITY = 'SET_SHOW_CONFIRM_CITY';
+
+export const FOOTER_TYPE = {
+  SET_FOOTER: 'SET_FOOTER',
+  LOADING_FOOTER: 'LOADING_FOOTER',
+  START_LOADING_FOOTER: 'START_LOADING_FOOTER',
+  STOP_LOADING_FOOTER: 'STOP_LOADING_FOOTER',
+};
+
+export const CLIENT_QUESTION_TYPE = {
+  SET_HASH: 'SET_HASH',
+};
+
+export const CONTRACT_TYPE = {
+  UPDATE_FORM: 'UPDATE_FORM',
+};
+
+export const LOYALTY_TYPE = {
+  SET_AVAILABLE_BONUSES: 'SET_AVAILABLE_BONUSES',
+  SET_TEXTS: 'SET_TEXTS',
+  SET_BURNING_BONUSES: 'SET_BURNING_BONUSES',
+  GET_BONUSES: 'GET_BONUSES',
+  SET_SMS_SUBSCRIPTION: 'SET_SMS_SUBSCRIPTION',
+};
diff --git a/parent_dir/src/mixins/layout-header.mixin.ts b/parent_dir/src/mixins/layout-header.mixin.ts
new file mode 100644
index 0000000..ba4dbe1
--- /dev/null
+++ b/parent_dir/src/mixins/layout-header.mixin.ts
@@ -0,0 +1,60 @@
+import { ComponentOptionsMixin } from 'vue';
+import { useMenuStore } from '@/store/pinia/menu/menu';
+
+const layoutHeaderMixin: ComponentOptionsMixin = {
+  name: 'layout-header-mixin',
+  setup() {
+    const menuStore = useMenuStore();
+
+    return {
+      menuStore,
+    };
+  },
+  data() {
+    return {
+      isMobileMenuOpened: false,
+    };
+  },
+  methods: {
+    clickModalOverlay() {
+      this.$emitter.emit('mobile-menu-closed');
+      this.menuStore.closeMobileMenu();
+    },
+  },
+  mounted() {
+    this.$emitter.on('mobile-menu-opened', () => {
+      this.isMobileMenuOpened = true;
+    });
+
+    this.$emitter.on('mobile-menu-closed', () => {
+      this.isMobileMenuOpened = false;
+    });
+
+    this.$emitter.on('mobile-menu-toggle', () => {
+      this.isMobileMenuOpened = !this.isMobileMenuOpened;
+    });
+  },
+  watch: {
+    isMobileMenuOpened(value) {
+      document.documentElement.classList.add(value ? 'mobile-menu-opening' : 'mobile-menu-closing');
+
+      setTimeout(() => {
+        document.documentElement.classList.remove(
+          value ? 'mobile-menu-opening' : 'mobile-menu-closing',
+        );
+
+        if (value) {
+          document.documentElement.classList.add('mobile-menu-opened');
+        } else {
+          // Я пока не придумал как это лучше типизировать
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          this.$emitter.emit('header-mobile-menu-closed');
+          document.documentElement.classList.remove('mobile-menu-opened');
+        }
+      }, 250);
+    },
+  },
+};
+
+export default layoutHeaderMixin;
diff --git a/parent_dir/src/mixins/layout.mixin.ts b/parent_dir/src/mixins/layout.mixin.ts
new file mode 100644
index 0000000..90acd03
--- /dev/null
+++ b/parent_dir/src/mixins/layout.mixin.ts
@@ -0,0 +1,150 @@
+import { mapActions, mapGetters, mapMutations } from 'vuex';
+import { ComponentOptionsMixin } from 'vue';
+import { cdekConsoleError } from '@/utils/console-wrapper';
+import { FOOTER_TYPE } from '@/middleware/mutation-types';
+import sbjs from 'sourcebuster';
+import { sendDataToADV } from '@/plugins/ADV-plugin';
+import usePage from '@/composables/use-page';
+import useSettings from '@/composables/use-settings';
+
+const { getSettingsGroup } = useSettings();
+
+const layoutMixin: ComponentOptionsMixin = {
+  name: 'layout-mixin',
+  computed: {
+    ...mapGetters({
+      websiteId: 'websiteId',
+      currentLocale: 'currentLocale',
+      consentToUseOfCookies: 'cookie-alert/consentToUseOfCookies',
+      currentLocaleISO: 'currentLocaleISO',
+      screen: 'resize/screen',
+      browser: 'browser/browser',
+      currentPage: 'page/currentPage',
+    }),
+    selectedCity() {
+      return this.$store.getters.city;
+    },
+    hasConsetToUseOfCookie() {
+      return !this.consentToUseOfCookies;
+    },
+    headerSettings() {
+      return {
+        logo: this.siteLogo,
+        cabinet: false,
+      };
+    },
+    settingsAll() {
+      return getSettingsGroup('all');
+    },
+    siteLogo() {
+      return getSettingsGroup('logo');
+    },
+  },
+
+  methods: {
+    ...mapMutations({
+      updateYaMapsBalloonOpened: 'flomni/updateYaMapsBalloonOpened',
+      setIsSite: 'setIsSite',
+    }),
+    ...mapActions({
+      setWidth: 'resize/setWidth',
+      setScreenByType: 'resize/setScreenByType',
+      initCookie: 'cookie-alert/init',
+      updateShowPageData: 'page/updateShowPageData',
+    }),
+    getWindowWidth() {
+      const { clientWidth } = document.documentElement;
+      this.setWidth({ clientWidth });
+    },
+    async initSmartBanner() {
+      await this.$store.dispatch('browser/update', { userAgent: navigator.userAgent });
+
+      if (this.browser && this.browser.parsedResult.platform.type === 'mobile') {
+        import('smart-app-banner').then((SmartBanner: any) => {
+          // eslint-disable-next-line no-new
+          new SmartBanner.default({
+            daysHidden: 15, // days to hide banner after close button is clicked (defaults to 15)
+            daysReminder: 90, // days to hide banner after "VIEW" button is clicked (defaults to 90)
+            title: 'СДЭК: грузоперевозки, экспресс доставка грузов',
+            author: 'CDEK Mobile',
+            button: this.$t('open'),
+          });
+        });
+      }
+    },
+    async updateFooterInfo(cityId?: string) {
+      const variables = {
+        locale: this.currentLocaleISO,
+        cityId,
+      };
+
+      this.$store.dispatch(`footer/${FOOTER_TYPE.START_LOADING_FOOTER}`);
+
+      try {
+        const footer = await this.$restApi.websiteFooter(variables);
+        this.$store.dispatch(`footer/${FOOTER_TYPE.SET_FOOTER}`, {
+          footer,
+        });
+      } catch (e) {
+        cdekConsoleError(e);
+      } finally {
+        this.$store.dispatch(`footer/${FOOTER_TYPE.STOP_LOADING_FOOTER}`);
+      }
+    },
+  },
+  watch: {
+    selectedCity(city) {
+      (this as any).updateFooterInfo(city && city.cdek_id);
+    },
+  },
+  mounted() {
+    const { isHomePage } = usePage();
+
+    sendDataToADV(isHomePage.value ? 1 : 2);
+
+    this.initSmartBanner();
+    this.initCookie(this.$cookies.get('consent-to-use-of-cookies'));
+
+    if (window.location.href.includes('cabinet')) {
+      this.setIsSite(false);
+    }
+
+    this.$nextTick(() => {
+      window.addEventListener('resize', this.getWindowWidth);
+      this.getWindowWidth();
+    });
+
+    if (!window.sbjs) {
+      window.sbjs = sbjs;
+
+      window.sbjs.init({
+        lifetime: 6,
+        session_length: 30,
+        domain: {
+          host: document.domain,
+          isolate: false,
+        },
+        timezone_offset: 0,
+        // Set `utm_source` & `utm_medium` values for `typein` traffic
+        // Defaults are `(direct)` & `(none)`
+        typein_attributes: {
+          source: '(direct)',
+          medium: '(none)',
+        },
+      });
+    }
+  },
+  created() {
+    if (this.browser && this.browser.parsedResult) {
+      this.setScreenByType(this.browser.parsedResult.platform.type);
+    }
+
+    // сбрасываем флаг открыт ли балун на карте, из vuex-persist может подтягиваться не актуальное значение
+    this.updateYaMapsBalloonOpened(false);
+  },
+  beforeUnmount() {
+    window.removeEventListener('resize', this.getWindowWidth);
+  },
+};
+
+export default layoutMixin;
diff --git a/parent_dir/src/pages/B2C-B2B-FORM/B2C-B2B-FORM.page.route.ts b/parent_dir/src/pages/B2C-B2B-FORM/B2C-B2B-FORM.page.route.ts
new file mode 100644
index 0000000..4905ae2
--- /dev/null
+++ b/parent_dir/src/pages/B2C-B2B-FORM/B2C-B2B-FORM.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/B2C-B2B-FORM';
diff --git a/parent_dir/src/pages/all-other/all-other.page.route.ts b/parent_dir/src/pages/all-other/all-other.page.route.ts
new file mode 100644
index 0000000..b2c38be
--- /dev/null
+++ b/parent_dir/src/pages/all-other/all-other.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/*';
diff --git a/parent_dir/src/pages/all-other/all-other.page.vue b/parent_dir/src/pages/all-other/all-other.page.vue
new file mode 100644
index 0000000..5494368
--- /dev/null
+++ b/parent_dir/src/pages/all-other/all-other.page.vue
@@ -0,0 +1,157 @@
+<template>
+  <div class="base-render-page" :class="pageClass">
+    <!--   TODO:  Нашел использование custom-meta-tags ровно в одно месте. Проверить когда понадобится -->
+    <keep-alive>
+      <render-component :page="page" :custom-meta-tags="[]" class="base-render-page" />
+    </keep-alive>
+  </div>
+</template>
+
+<script lang="ts" setup>
+import { computed, inject, onBeforeUnmount, onMounted, provide, ref, watch } from 'vue';
+import { VueCookies } from 'vue-cookies';
+import RenderComponent from '@/components/RenderComponent.vue';
+import IPage from '@/types/dto/page';
+import { sendParams } from '@/utils/reach-goal';
+import { usePageContext } from '@/composables/use-page-context';
+import useFlomni from '@/composables/use-flomni';
+import { createScriptElement, getHeadElement } from '@/utils/dom.utils';
+import { handleTildaYm, removeTildaYm } from '@/utils/handle-tilda-ym';
+
+const props = withDefaults(defineProps<{ page: IPage; metaData: unknown; isTilda?: boolean }>(), {
+  isTilda: false,
+});
+
+const pageContext = usePageContext();
+
+const { addListenersToLinks, removeListenersFromLinks } = useFlomni();
+
+provide('pageContent', props.page.content);
+
+const loadedScripts = ref(0);
+const $cookies = inject<VueCookies>('$cookies');
+
+// При навигации по сайту, head захламляется скриптами которые
+// запихиваем на страницах тильды, перед тем как покидаем страницу
+// желательно подчищать за собой
+
+const pageClass = computed(() => {
+  const customClass =
+    `page-${pageContext?.urlPathname?.replace(/^\/[\w\d]+\//, '')?.replace('/', '')}` || '';
+
+  return {
+    'base-render-page--tilda': props.isTilda,
+    [customClass]: true,
+  };
+});
+
+const scriptIds = ref<string[]>([]);
+
+const appendScriptToHead = (src: string, idx: number) => {
+  const head = getHeadElement();
+
+  const script = createScriptElement();
+  const id = `cdek_backend_tilda_script_${idx}`;
+
+  script.src = src;
+  script.defer = true;
+  script.id = id;
+
+  scriptIds.value.push(id);
+
+  head.appendChild(script);
+  // С бекенда нам приходит набор скриптов this.scriptsJS и верстка страницы тильды.
+  // Верстка содержит в себе блоки <script /> в которых происходит вызов функций определяемых в скриптах из this.scriptsJS.
+  // В файле nuxt.config.js я замокал функцию t_onReady чтобы при первичной отрисовке страница не ломалась.
+  script.onload = () => {
+    loadedScripts.value += 1;
+
+    // После того как все скрипты загружены можем по новой попытаться сделать тильду интерактивной
+    // выполнив то что приходило к нам в верстке
+    if (loadedScripts.value === props.page.js.length) {
+      const tildaContainer = document.getElementById('allrecords');
+      if (!tildaContainer) {
+        return;
+      }
+
+      const scripts = [...tildaContainer.getElementsByTagName('script')];
+
+      scripts.forEach((el, innerIdx) => {
+        const newScript = document.createElement('script');
+        const innerId = `cdek_tilda_script_${innerIdx}`;
+        scriptIds.value.push(innerId);
+
+        newScript.type = 'text/javascript';
+        newScript.innerHTML = el.innerHTML;
+        newScript.id = innerId;
+
+        head.appendChild(newScript);
+      });
+
+      handleTildaYm();
+    }
+  };
+};
+
+const handleTildaPage = () => {
+  if (props.page.isTilda) {
+    const pageLayout = document.getElementById('work-area');
+    if (pageLayout) pageLayout.style.zIndex = '1';
+  }
+
+  // Изначально эти скрипты запихивались просто в head. Была проблема с тем что непонятно когда что выполняется
+  // Судя по всему скрипты отрабатывали до получения верстки, и страница не становилась интерактивной
+  // Поэтому вынес добавление скриптов в хеад только после маунта. Чтобы ожидать одинакового поведения для сср и спа
+  props.page?.js?.forEach((src, idx) => {
+    appendScriptToHead(src, idx);
+  });
+};
+
+const removeTildaPage = () => {
+  removeTildaYm();
+
+  scriptIds.value.forEach((id) => {
+    const scriptToRemove = document.getElementById(id);
+
+    if (scriptToRemove) {
+      scriptToRemove.remove();
+    }
+  });
+  loadedScripts.value = 0;
+  scriptIds.value = [];
+  const pageLayout = document.getElementById('work-area');
+  if (pageLayout) pageLayout.style.zIndex = '';
+};
+watch(
+  () => props.page,
+  () => {
+    removeTildaPage();
+    handleTildaPage();
+  },
+);
+
+onMounted(() => {
+  handleTildaPage();
+
+  addListenersToLinks();
+
+  if (!$cookies) {
+    return;
+  }
+
+  if ($cookies.get('ab_test_map')) {
+    sendParams({
+      ab_test_map: $cookies.get('ab_test_map'),
+    });
+  }
+});
+onBeforeUnmount(() => {
+  removeListenersFromLinks();
+
+  removeTildaPage();
+});
+</script>
+
+<script lang="ts">
+export { default as Layout } from '#root/src/layouts/DefaultLayout.vue';
+</script>
diff --git a/parent_dir/src/pages/box/index.page.route.ts b/parent_dir/src/pages/box/index.page.route.ts
new file mode 100644
index 0000000..9b73bb2
--- /dev/null
+++ b/parent_dir/src/pages/box/index.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/box';
diff --git a/parent_dir/src/pages/calculator_B2B/calculator_B2B.page.route.ts b/parent_dir/src/pages/calculator_B2B/calculator_B2B.page.route.ts
new file mode 100644
index 0000000..ab47479
--- /dev/null
+++ b/parent_dir/src/pages/calculator_B2B/calculator_B2B.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/calculator_B2B';
diff --git a/parent_dir/src/pages/cdekid.page.route.ts b/parent_dir/src/pages/cdekid.page.route.ts
new file mode 100644
index 0000000..e377536
--- /dev/null
+++ b/parent_dir/src/pages/cdekid.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/cdekid';
diff --git a/parent_dir/src/pages/cod-card-success/cod-card-success.page.route.ts b/parent_dir/src/pages/cod-card-success/cod-card-success.page.route.ts
new file mode 100644
index 0000000..559702f
--- /dev/null
+++ b/parent_dir/src/pages/cod-card-success/cod-card-success.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/cod-card-success';
diff --git a/parent_dir/src/pages/economic-parcel/economic-parcel.page.route.ts b/parent_dir/src/pages/economic-parcel/economic-parcel.page.route.ts
new file mode 100644
index 0000000..e18658c
--- /dev/null
+++ b/parent_dir/src/pages/economic-parcel/economic-parcel.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/economic-parcel';
diff --git a/parent_dir/src/pages/faq/faq.page.route.ts b/parent_dir/src/pages/faq/faq.page.route.ts
new file mode 100644
index 0000000..d02c940
--- /dev/null
+++ b/parent_dir/src/pages/faq/faq.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/faq';
diff --git a/parent_dir/src/pages/faq/id/index.page.route.ts b/parent_dir/src/pages/faq/id/index.page.route.ts
new file mode 100644
index 0000000..7283ab7
--- /dev/null
+++ b/parent_dir/src/pages/faq/id/index.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/faq/*';
diff --git a/parent_dir/src/pages/gifts/gifts.page.route.ts b/parent_dir/src/pages/gifts/gifts.page.route.ts
new file mode 100644
index 0000000..69d8f38
--- /dev/null
+++ b/parent_dir/src/pages/gifts/gifts.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/gifts';
diff --git a/parent_dir/src/pages/integration-old.page.route.ts b/parent_dir/src/pages/integration-old.page.route.ts
new file mode 100644
index 0000000..d6c4843
--- /dev/null
+++ b/parent_dir/src/pages/integration-old.page.route.ts
@@ -0,0 +1 @@
+export default '/@param/integration-old';
diff --git a/parent_dir/src/pages/integration/api/api.page.route.ts b/parent_dir/src/pages/integration/api/api.page.route.ts
new file mode 100644
index 0000000..dc006da
--- /dev/null
+++ b/parent_dir/src/pages/integration/api/api.page.route.ts
@@ -0,0 +1 @@
+export default '/@param/integration/api';
diff --git a/parent_dir/src/pages/integration/faq/faq.page.route.ts b/parent_dir/src/pages/integration/faq/faq.page.route.ts
new file mode 100644
index 0000000..48b31b1
--- /dev/null
+++ b/parent_dir/src/pages/integration/faq/faq.page.route.ts
@@ -0,0 +1 @@
+export default '/@param/integration/faq';
diff --git a/parent_dir/src/pages/integration/index.page.route.ts b/parent_dir/src/pages/integration/index.page.route.ts
new file mode 100644
index 0000000..942be40
--- /dev/null
+++ b/parent_dir/src/pages/integration/index.page.route.ts
@@ -0,0 +1 @@
+export default '/@param/integration';
diff --git a/parent_dir/src/pages/integration/modules/index.page.route.ts b/parent_dir/src/pages/integration/modules/index.page.route.ts
new file mode 100644
index 0000000..8c6a885
--- /dev/null
+++ b/parent_dir/src/pages/integration/modules/index.page.route.ts
@@ -0,0 +1 @@
+export default '/@param/integration/modules';
diff --git a/parent_dir/src/pages/integration/modules/name/index.page.route.ts b/parent_dir/src/pages/integration/modules/name/index.page.route.ts
new file mode 100644
index 0000000..1a117fd
--- /dev/null
+++ b/parent_dir/src/pages/integration/modules/name/index.page.route.ts
@@ -0,0 +1 @@
+export default '/@param/integration/modules/@name';
diff --git a/parent_dir/src/pages/invest.page.route.ts b/parent_dir/src/pages/invest.page.route.ts
new file mode 100644
index 0000000..24ec557
--- /dev/null
+++ b/parent_dir/src/pages/invest.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/invest';
diff --git a/parent_dir/src/pages/login/login.page.route.ts b/parent_dir/src/pages/login/login.page.route.ts
new file mode 100644
index 0000000..736f953
--- /dev/null
+++ b/parent_dir/src/pages/login/login.page.route.ts
@@ -0,0 +1 @@
+export default '/@param/login';
diff --git a/parent_dir/src/pages/o/code/index.page.route.ts b/parent_dir/src/pages/o/code/index.page.route.ts
new file mode 100644
index 0000000..fa979d9
--- /dev/null
+++ b/parent_dir/src/pages/o/code/index.page.route.ts
@@ -0,0 +1 @@
+export default '/@param/o/@code';
diff --git a/parent_dir/src/pages/passport/index.page.route.ts b/parent_dir/src/pages/passport/index.page.route.ts
new file mode 100644
index 0000000..42f0f1a
--- /dev/null
+++ b/parent_dir/src/pages/passport/index.page.route.ts
@@ -0,0 +1 @@
+export default '/@param/passport';
diff --git a/parent_dir/src/pages/payment-fail.page.route.ts b/parent_dir/src/pages/payment-fail.page.route.ts
new file mode 100644
index 0000000..b5d5806
--- /dev/null
+++ b/parent_dir/src/pages/payment-fail.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/payment-fail';
diff --git a/parent_dir/src/pages/payment-success/payment-success.page.route.ts b/parent_dir/src/pages/payment-success/payment-success.page.route.ts
new file mode 100644
index 0000000..b85c409
--- /dev/null
+++ b/parent_dir/src/pages/payment-success/payment-success.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/payment-success';
diff --git a/parent_dir/src/pages/search/search.page.route.ts b/parent_dir/src/pages/search/search.page.route.ts
new file mode 100644
index 0000000..b148ab9
--- /dev/null
+++ b/parent_dir/src/pages/search/search.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/search/*';
diff --git a/parent_dir/src/pages/sitemap/sitemap.page.route.ts b/parent_dir/src/pages/sitemap/sitemap.page.route.ts
new file mode 100644
index 0000000..7311997
--- /dev/null
+++ b/parent_dir/src/pages/sitemap/sitemap.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/sitemap';
diff --git a/parent_dir/src/pages/tenders/tenders.page.route.ts b/parent_dir/src/pages/tenders/tenders.page.route.ts
new file mode 100644
index 0000000..ae3be5e
--- /dev/null
+++ b/parent_dir/src/pages/tenders/tenders.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/tenders';
diff --git a/parent_dir/src/pages/webview/cabinet.page.route.ts b/parent_dir/src/pages/webview/cabinet.page.route.ts
new file mode 100644
index 0000000..95d388e
--- /dev/null
+++ b/parent_dir/src/pages/webview/cabinet.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/webview/cabinet';
diff --git a/parent_dir/src/pages/webview/loyalty.page.route.ts b/parent_dir/src/pages/webview/loyalty.page.route.ts
new file mode 100644
index 0000000..15d8239
--- /dev/null
+++ b/parent_dir/src/pages/webview/loyalty.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/webview/loyalty';
diff --git a/parent_dir/src/pages/webview/offers.page.route.ts b/parent_dir/src/pages/webview/offers.page.route.ts
new file mode 100644
index 0000000..3a4dcca
--- /dev/null
+++ b/parent_dir/src/pages/webview/offers.page.route.ts
@@ -0,0 +1 @@
+export default '/@locale/webview/offers';
diff --git a/parent_dir/src/plugins/ADV-plugin.ts b/parent_dir/src/plugins/ADV-plugin.ts
new file mode 100644
index 0000000..bce3fd8
--- /dev/null
+++ b/parent_dir/src/plugins/ADV-plugin.ts
@@ -0,0 +1,32 @@
+import { createScriptElement, getHeadElement } from '@/utils/dom.utils';
+
+export const installADV = (src = import.meta.env.VITE_ADV_SRC) => {
+  if (!src) {
+    return;
+  }
+
+  const script = createScriptElement();
+
+  script.id = 'advcakeAsync';
+
+  script.text = `
+  (function(a) {
+        var b = a.createElement("script");
+        b.async = 1;
+        b.src = "${src}";
+        a = a.getElementsByTagName("script")[0];
+        a.parentNode.insertBefore(b, a)
+    })(document);
+  `;
+
+  const head = getHeadElement();
+
+  head.appendChild(script);
+};
+
+export const sendDataToADV = (pageType = 2) => {
+  window.advcake_data = window.advcake_data || [];
+  window.advcake_data.push({
+    pageType,
+  });
+};
diff --git a/parent_dir/src/plugins/api-client-plugin.ts b/parent_dir/src/plugins/api-client-plugin.ts
new file mode 100644
index 0000000..1b732ac
--- /dev/null
+++ b/parent_dir/src/plugins/api-client-plugin.ts
@@ -0,0 +1,16 @@
+import client from '@/api-clients/cabinetApi/client';
+import { App } from 'vue';
+import { CdekStore } from '@/types/store';
+
+export default {
+  install(app: App, store: CdekStore, url = import.meta.env.VITE_HTTP_ENDPOINT) {
+    // Пока не понимаю разницу между этими двумя значениеям
+    // Но в сср у нас нет доступа к виндов
+    // const apiHost = `${window.location.protocol}//${window.location.host}`;
+    const apiPrefix = '/api-lkfl';
+    const apiClient = client(url, apiPrefix, store);
+    app.config.globalProperties.$apiClient = apiClient;
+    store.$apiClient = apiClient;
+    app.provide('apiClient', apiClient);
+  },
+};
diff --git a/parent_dir/src/plugins/default-colors.ts b/parent_dir/src/plugins/default-colors.ts
new file mode 100644
index 0000000..6958bf2
--- /dev/null
+++ b/parent_dir/src/plugins/default-colors.ts
@@ -0,0 +1,10 @@
+import type { App } from 'vue';
+
+import { $uiBaseColor } from '@/constants/default-colors';
+
+export default {
+  install: (app: App) => {
+    app.config.globalProperties.$uiBaseColor = $uiBaseColor;
+    app.provide('uiBaseColor', $uiBaseColor);
+  },
+};
diff --git a/parent_dir/src/plugins/emitter-plugin.ts b/parent_dir/src/plugins/emitter-plugin.ts
new file mode 100644
index 0000000..b88feb7
--- /dev/null
+++ b/parent_dir/src/plugins/emitter-plugin.ts
@@ -0,0 +1,12 @@
+import mitt from 'mitt';
+import type { App } from 'vue';
+
+export default {
+  install: (app: App) => {
+    const emitter = mitt();
+
+    app.config.globalProperties.$emitter = emitter;
+
+    app.provide('emitter', emitter);
+  },
+};
diff --git a/parent_dir/src/plugins/graphql-api-client-plugin.ts b/parent_dir/src/plugins/graphql-api-client-plugin.ts
new file mode 100644
index 0000000..3b90222
--- /dev/null
+++ b/parent_dir/src/plugins/graphql-api-client-plugin.ts
@@ -0,0 +1,28 @@
+import type { App } from 'vue';
+import GraphqlApiClient from '#root/src/api-clients/graphql-api-client';
+
+export default {
+  install: (app: App, runsOnClient = false, url = import.meta.env.VITE_HTTP_ENDPOINT) => {
+    let client: GraphqlApiClient;
+
+    if (!runsOnClient) {
+      if (global.cdekGraphqlApiClient) {
+        client = global.cdekGraphqlApiClient;
+      } else {
+        client = new GraphqlApiClient(url);
+        global.cdekGraphqlApiClient = client;
+      }
+    } else {
+      client = new GraphqlApiClient(url);
+    }
+
+    // У нас большая часть компонентов будет на options api и там где есть аксиос
+    // мы будем использовать его как  this.$restApi.
+    app.config.globalProperties.$graphqlApi = client;
+
+    // Что-то новое будем писать и использованием composition api
+    // при таком подходе мы не имеем доступа к this.
+    // Чтобы использовать там клиент, будем делать inject('restApi')
+    app.provide('graphqlApi', client);
+  },
+};
diff --git a/parent_dir/src/plugins/gtm-plugin.ts b/parent_dir/src/plugins/gtm-plugin.ts
new file mode 100644
index 0000000..75ca108
--- /dev/null
+++ b/parent_dir/src/plugins/gtm-plugin.ts
@@ -0,0 +1,44 @@
+export function initDefaultGtmPlugin(id: string) {
+  const script = document.createElement('script');
+  script.text = `
+        (function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
+        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
+        j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
+        'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
+        })(window,document,'script','dataLayer','${id}');
+     `;
+
+  document.head.appendChild(script);
+}
+
+export function initSecondGtm(id: string) {
+  const firstScript = document.createElement('script');
+  firstScript.async = true;
+  firstScript.src = `https://www.googletagmanager.com/gtag/js?id=${id}`;
+
+  document.head.appendChild(firstScript);
+
+  const secondScript = document.createElement('script');
+
+  secondScript.text = `
+    window.dataLayer = window.dataLayer || [];
+    function gtag(){dataLayer.push(arguments);}
+    gtag('js', new Date());
+    gtag('config', '${id}');
+  `;
+  document.head.appendChild(secondScript);
+}
+
+export function initGtmPlugin() {
+  const gtmId = import.meta.env.VITE_GTM_ID;
+
+  if (gtmId) {
+    initDefaultGtmPlugin(gtmId);
+  }
+
+  const gtmIdSecond = import.meta.env.VITE_GTM_ID_SECOND;
+
+  if (gtmIdSecond) {
+    initSecondGtm(gtmIdSecond);
+  }
+}
diff --git a/parent_dir/src/plugins/libphonenumber-plugin.ts b/parent_dir/src/plugins/libphonenumber-plugin.ts
new file mode 100644
index 0000000..ecb0aa1
--- /dev/null
+++ b/parent_dir/src/plugins/libphonenumber-plugin.ts
@@ -0,0 +1,9 @@
+import { App } from 'vue';
+import libphonenumber from 'libphonenumber-js/max';
+
+export default {
+  install: (app: App) => {
+    app.config.globalProperties.$libphonenumber = libphonenumber;
+    app.provide('libphonenumber', libphonenumber);
+  },
+};
diff --git a/parent_dir/src/plugins/mindbox.ts b/parent_dir/src/plugins/mindbox.ts
new file mode 100644
index 0000000..b929ec7
--- /dev/null
+++ b/parent_dir/src/plugins/mindbox.ts
@@ -0,0 +1,21 @@
+export default function initMindbox(enabled = false) {
+  if ('mindbox' in window || !enabled) {
+    return;
+  }
+
+  const script = document.createElement('script') as HTMLScriptElement;
+  script.text = `
+          mindbox = window.mindbox || function() { mindbox.queue.push(arguments); };
+          mindbox.queue = mindbox.queue || []; mindbox('create', {
+          endpointId: 'cdek-website-loyalty' });
+      `;
+
+  const head = document.getElementsByTagName('head')[0] as HTMLHeadElement;
+  head.appendChild(script);
+
+  const mindboxSript = document.createElement('script') as HTMLScriptElement;
+  mindboxSript.setAttribute('src', 'https://api.mindbox.ru/scripts/v1/tracker.js');
+  mindboxSript.async = true;
+
+  head.appendChild(mindboxSript);
+}
diff --git a/parent_dir/src/plugins/pms-api-client-plugin.ts b/parent_dir/src/plugins/pms-api-client-plugin.ts
new file mode 100644
index 0000000..ae910d1
--- /dev/null
+++ b/parent_dir/src/plugins/pms-api-client-plugin.ts
@@ -0,0 +1,10 @@
+import type { App } from 'vue';
+import PmsApiClient from '@/api-clients/pms-api-client';
+
+export default {
+  install: (app: App, host = import.meta.env.VITE_HTTP_ENDPOINT || '') => {
+    const client = new PmsApiClient(host);
+    app.config.globalProperties.$pmsApi = client;
+    app.provide('pmsApi', client);
+  },
+};
diff --git a/parent_dir/src/plugins/rest-api-client-plugin.ts b/parent_dir/src/plugins/rest-api-client-plugin.ts
new file mode 100644
index 0000000..bc8b769
--- /dev/null
+++ b/parent_dir/src/plugins/rest-api-client-plugin.ts
@@ -0,0 +1,28 @@
+import type { App } from 'vue';
+import RestApiClient from '#root/src/api-clients/rest-api-client';
+
+export default {
+  install: (app: App, runsOnClient = false, url = import.meta.env.VITE_HTTP_ENDPOINT) => {
+    let client: RestApiClient;
+
+    if (!runsOnClient) {
+      if (global.cdekRestApiClient) {
+        client = global.cdekRestApiClient;
+      } else {
+        client = new RestApiClient(url);
+        global.cdekRestApiClient = client;
+      }
+    } else {
+      client = new RestApiClient(url);
+    }
+
+    // У нас большая часть компонентов будет на options api и там где есть аксиос
+    // мы будем использовать его как  this.$restApi.
+    app.config.globalProperties.$restApi = client;
+
+    // Что-то новое будем писать и использованием composition api
+    // при таком подходе мы не имеем доступа к this.
+    // Чтобы использовать там клиент, будем делать inject('restApi')
+    app.provide('restApi', client);
+  },
+};
diff --git a/parent_dir/src/plugins/router-push-plugin.ts b/parent_dir/src/plugins/router-push-plugin.ts
new file mode 100644
index 0000000..33a5faf
--- /dev/null
+++ b/parent_dir/src/plugins/router-push-plugin.ts
@@ -0,0 +1,73 @@
+import type { App } from 'vue';
+import { navigate } from 'vite-plugin-ssr/client/router';
+import { reactive, UnwrapNestedRefs } from 'vue';
+import { PageContext } from '@/renderer/types';
+import { setLocaleToLink } from '@/utils/set-locale-to-link';
+import { getCabinetUrl } from '@/utils/getCabinetUrl';
+
+export default {
+  install: (app: App, pageContext: UnwrapNestedRefs<PageContext>, runsOnClient: boolean) => {
+    const route = reactive({
+      path: pageContext.urlPathname,
+    });
+
+    app.provide('route', route);
+    app.provide('changeRoute', (path: string) => {
+      route.path = path;
+    });
+
+    app.config.globalProperties.$route = route;
+
+    const push = async (url: string | { path: string; query?: Record<string, string> }) => {
+      let resultPath = '';
+
+      if (typeof url === 'string') {
+        resultPath = url;
+      } else {
+        resultPath = url.path;
+
+        if (url.query) {
+          const queryString = Object.keys(url.query)
+            .map((el) => `${el}=${url.query && url.query[el]}`)
+            .join('&');
+
+          if (queryString) {
+            resultPath += `?${queryString}`;
+          }
+        }
+      }
+
+      const store = app.config.globalProperties?.$store;
+
+      const isLoggedInCabinet = store?.getters?.isLoggedInCabinet;
+
+      if (isLoggedInCabinet) {
+        const parsedUrl = new URL(resultPath, window.location.origin);
+
+        const { search, pathname } = parsedUrl;
+
+        const cabinetUrl = getCabinetUrl(pathname, search, pageContext.locale);
+
+        if (cabinetUrl) {
+          window.location.href = cabinetUrl;
+          return;
+        }
+      }
+
+      // Я подсовываю тут локаль, потому что у нас не везде ссылки указаны правильно
+      // Если нет локали, то мы ожидаем что попадем на текущую локаль
+      resultPath = setLocaleToLink(resultPath, pageContext.locale, true);
+
+      await navigate(resultPath);
+      app.config.globalProperties.$route.path = pageContext.urlPathname;
+    };
+
+    app.config.globalProperties.$router = {
+      push,
+    };
+
+    if (runsOnClient) {
+      window.clientNavigate = push;
+    }
+  },
+};
diff --git a/parent_dir/src/plugins/sentry-plugin.ts b/parent_dir/src/plugins/sentry-plugin.ts
new file mode 100644
index 0000000..14bbbc3
--- /dev/null
+++ b/parent_dir/src/plugins/sentry-plugin.ts
@@ -0,0 +1,49 @@
+import { App } from 'vue';
+import * as Sentry from '@sentry/vue';
+import { castEnv } from '@/utils/env-utils';
+
+export default {
+  install(app: App) {
+    const environment =
+      import.meta.env.VITE_ENVIRONMENT || (import.meta.env.DEV ? 'development' : 'production');
+
+    const release = import.meta.env.VITE_BUILD_RELEASE || '';
+
+    const sampleRate = import.meta.env.VITE_SITE_SENTRY_SAMPLE_RATE
+      ? parseFloat(import.meta.env.VITE_SITE_SENTRY_SAMPLE_RATE)
+      : 0.1;
+
+    Sentry.init({
+      app,
+      environment,
+      dsn: import.meta.env.VITE_SITE_SENTRY_DSN,
+      tracesSampleRate: sampleRate,
+      enabled: !castEnv(import.meta.env.VITE_SITE_SENTRY_DISABLED),
+      trackComponents: true,
+      attachStacktrace: true,
+      replaysSessionSampleRate: sampleRate,
+      integrations: [new Sentry.Replay(), new Sentry.BrowserTracing()],
+      release,
+      ignoreErrors: [/Network Error/i],
+      beforeSend(event, hint) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const errorMessage = hint.originalException?.message;
+
+        if (errorMessage && errorMessage.includes('Importing a module script failed')) {
+          return null;
+        }
+
+        if (errorMessage && errorMessage.includes('Failed to fetch dynamically imported module')) {
+          return null;
+        }
+
+        return event;
+      },
+      denyUrls: [/i\.v2\.flomni\.com/i, /mindbox\.ru/i, /yastatic\.net/i],
+    });
+
+    app.config.globalProperties.$sentry = Sentry;
+    app.provide('sentry', Sentry);
+  },
+};
diff --git a/parent_dir/src/plugins/vk-ads-plugin.ts b/parent_dir/src/plugins/vk-ads-plugin.ts
new file mode 100644
index 0000000..632765b
--- /dev/null
+++ b/parent_dir/src/plugins/vk-ads-plugin.ts
@@ -0,0 +1,25 @@
+import { createScriptElement, getHeadElement } from '@/utils/dom.utils';
+
+export const initVKAdsPlugin = (enabled = true) => {
+  if (!enabled) {
+    return;
+  }
+
+  const script = createScriptElement();
+
+  script.text = `
+    var _tmr = window._tmr || (window._tmr = []);
+    _tmr.push({id: "3488288", type: "pageView", start: (new Date()).getTime(), pid: "USER_ID"});
+    (function (d, w, id) {
+      if (d.getElementById(id)) return;
+      var ts = d.createElement("script"); ts.type = "text/javascript"; ts.async = true; ts.id = id;
+      ts.src = "https://top-fwz1.mail.ru/js/code.js";
+      var f = function () {var s = d.getElementsByTagName("script")[0]; s.parentNode.insertBefore(ts, s);};
+      if (w.opera == "[object Opera]") { d.addEventListener("DOMContentLoaded", f, false); } else { f(); }
+    })(document, window, "tmr-code");
+     `;
+
+  const head = getHeadElement();
+
+  head.appendChild(script);
+};
diff --git a/parent_dir/src/plugins/ym-plugin.js b/parent_dir/src/plugins/ym-plugin.js
new file mode 100644
index 0000000..dd8511b
--- /dev/null
+++ b/parent_dir/src/plugins/ym-plugin.js
@@ -0,0 +1,43 @@
+export function hitYm(urlPathname) {
+  window.ym && window.ym(import.meta.env.VITE_YANDEX_METRIKA_ID, 'hit', urlPathname);
+}
+export function initYmPlugin() {
+  const id = import.meta.env.VITE_YANDEX_METRIKA_ID;
+
+  if (!id) return;
+
+  /* eslint-disable */
+  (function (m, e, t, r, i, k, a) {
+    m[i] =
+      m[i] ||
+      function () {
+        (m[i].a = m[i].a || []).push(arguments);
+      };
+    m[i].l = 1 * new Date();
+
+    for (let j = 0; j < document.scripts.length; j++) {
+      if (document.scripts[j].src === r) {
+        return;
+      }
+    }
+
+    (k = e.createElement(t)),
+      (a = e.getElementsByTagName(t)[0]),
+      (k.async = 1),
+      (k.src = r),
+      a.parentNode.insertBefore(k, a);
+  })(window, document, 'script', 'https://mc.yandex.ru/metrika/tag.js', 'ym');
+  /* eslint-enable */
+
+  // Сказали только на ру включить, остальное как есть
+  const webvisor = import.meta.env.VITE_WEBSITE_ID === 'ru';
+
+  // Параметры из админки яндекc метрики
+  window.ym(id, 'init', {
+    clickmap: true,
+    trackLinks: true,
+    accurateTrackBounce: true,
+    webvisor,
+    ecommerce: 'dataLayer',
+  });
+}
diff --git a/parent_dir/src/renderer/_default.page.client.ts b/parent_dir/src/renderer/_default.page.client.ts
new file mode 100644
index 0000000..4d62673
--- /dev/null
+++ b/parent_dir/src/renderer/_default.page.client.ts
@@ -0,0 +1,78 @@
+import { getCabinetUrl } from '@/utils/getCabinetUrl';
+import { getRedirectPageContextData } from './getRedirectTo';
+import { createPageApp } from './app';
+import type { PageContextClient } from './types';
+// Эта функция отвечает за то как будет рендериться наша страница на клиенте.
+// Для каждой странице можно написать свой рендерер в зависимости от потребностей.
+// На текущем этапе мне нужно чтобы приложение работало в режиме SSR.
+// То есть, чтобы html мы получали только при первом запросе, и вся остальная навигация
+// происходила на клиенте
+
+// https://vite-plugin-ssr.com/server-routing-vs-client-routing
+// Если тру, роутинг происходит на клиенте. Клиент не запрашивает каждый раз новый html.
+// Если фолз, на каждый переход внутри сайта запрашивается новый html
+export const clientRouting = true;
+// https://vite-plugin-ssr.com/clientRouting#link-prefetching
+// Как мы хотим подгружать ресурсы из отрисованых ссылок
+// { when: HOVER } - при наведении мышки
+// { when: VIEWPORT } - при попадании ссылки во вьюпорте
+// false - не хотим
+// export const prefetchStaticAssets = { when: 'HOVER' };
+export const prefetchStaticAssets = false;
+
+let app: Awaited<ReturnType<typeof createPageApp>>;
+
+// pageContext - объект плагина, в котором хранятся все данные о текущей странице.
+async function render(pageContext: PageContextClient) {
+  if (!app) {
+    // Если внутри html который пришел с бека нет контента, считаем что это клинет онли страница
+    app = await createPageApp(
+      pageContext,
+      document.getElementById('page')?.innerHTML === '',
+      pageContext.initialSiteData,
+      true,
+    );
+    app.mount('#app');
+  } else {
+    const store = app.config.globalProperties?.$store;
+
+    const locale = store?.getters?.currentLocale;
+
+    const isLoggedInCabinet = store?.getters?.isLoggedInCabinet;
+
+    const { redirectTo } = getRedirectPageContextData(pageContext, locale);
+
+    const {
+      urlParsed: { pathname, searchOriginal },
+    } = pageContext;
+
+    const cabinetUrl = isLoggedInCabinet
+      ? getCabinetUrl(pathname, searchOriginal ?? '', locale)
+      : '';
+
+    if (redirectTo) {
+      app.config.globalProperties.$router.push(redirectTo);
+      return;
+    }
+
+    if (cabinetUrl) {
+      window.location.href = cabinetUrl;
+      return;
+    }
+
+    app.changePage(pageContext);
+  }
+}
+// Вызывается при первом клике по ссылке
+function onPageTransitionStart() {
+  app && app.startLoading();
+}
+
+// Вызывается когда все данные пришли и надо перерисовать страницу
+function onPageTransitionEnd() {
+  app && app.stopLoading();
+}
+
+export { render };
+export { onPageTransitionStart };
+export { onPageTransitionEnd };
diff --git a/parent_dir/src/renderer/app.ts b/parent_dir/src/renderer/app.ts
new file mode 100644
index 0000000..652e6ac
--- /dev/null
+++ b/parent_dir/src/renderer/app.ts
@@ -0,0 +1,293 @@
+import {
+  createSSRApp,
+  defineComponent,
+  h,
+  markRaw,
+  reactive,
+  createApp,
+  ComponentPublicInstance,
+} from 'vue';
+import FloatingVue from 'floating-vue';
+import { ActiveHeadEntry, createHead } from '@vueuse/head';
+import { getActiveHead } from 'unhead';
+import { Head } from '@unhead/schema';
+import 'floating-vue/dist/style.css';
+import '@cdek-ui-kit/vue/style.css';
+import { appearDirective } from '#root/src/directives/appear.directive';
+import restApiClientPlugin from '#root/src/plugins/rest-api-client-plugin';
+import pmsApiClientPlugin from '#root/src/plugins/pms-api-client-plugin';
+import graphqlApiClientPlugin from '#root/src/plugins/graphql-api-client-plugin';
+import defaultColors from '#root/src/plugins/default-colors';
+import emitterPlugin from '#root/src/plugins/emitter-plugin';
+
+import { rewriteServerMetaData, updateHead } from '#root/src/utils/metaDataHelpers';
+import DefaultLayout from '#root/src/layouts/DefaultLayout.vue';
+import VueLazyLoad from 'vue3-lazyload';
+import VueCookies from 'vue-cookies';
+import { createVuexStore } from '@/store/vuex-store';
+// es2015 module
+
+// default options config: { expires: '1d', path: '/', domain: '', secure: '', sameSite: 'Lax' }
+import '../assets/style/app.scss';
+import '../assets/font.css';
+import '../assets/main.css';
+import { InitialSiteData } from '@/types/dto/initialSiteData';
+import { clickOutsideDirective } from '@/directives/cdek-click-outside.directive';
+import { appendToBodyDirective } from '@/directives/append-to-body.directive';
+import testIdDirective from '@/directives/test-id.directive';
+import apiClientPlugin from '@/plugins/api-client-plugin';
+import { CdekStore } from '@/types/store';
+import libphonenumberPlugin from '@/plugins/libphonenumber-plugin';
+import sentryPlugin from '@/plugins/sentry-plugin';
+import EmptyLayout from '@/layouts/EmptyLayout.vue';
+import { initYmPlugin, hitYm } from '@/plugins/ym-plugin';
+import { initGtmPlugin } from '@/plugins/gtm-plugin';
+import routerPushPlugin from '@/plugins/router-push-plugin';
+import { registerToastification } from '@cdek-ui-kit/vue';
+import { setPageContext } from '@/composables/use-page-context';
+import { globalVueErrorsHandler } from '#root/src/utils/handleErrors/handleErrors';
+import { createPinia } from 'pinia';
+import { cdekConsoleError } from '@/utils/console-wrapper';
+import initMindbox from '@/plugins/mindbox';
+import { useI18nHelpers } from '@/composables/use-i18n-helpers';
+import { initVKAdsPlugin } from '@/plugins/vk-ads-plugin';
+import { installADV } from '@/plugins/ADV-plugin';
+import useCountries from '@/composables/use-countries';
+import { useAutodetectCity } from '@/composables/use-autodetect-city';
+import useSettings from '@/composables/use-settings';
+import i18n from '../locales/i18n-config';
+import type { PageContext } from './types';
+
+// Функция, которую я нашел в репозитории с примерами.
+// Обычный Object.assign, но с типами
+function objectAssign<Obj extends object, ObjAddendum>(
+  obj: Obj,
+  objAddendum: ObjAddendum,
+): asserts obj is Obj & ObjAddendum {
+  Object.assign(obj, objAddendum);
+}
+
+function getPageLayout(pageContext: PageContext) {
+  const { isWebView, routeParams, urlOriginal } = pageContext;
+
+  const locale = routeParams?.locale || '';
+
+  if (
+    isWebView ||
+    urlOriginal.includes(`/profi`) ||
+    (locale && urlOriginal.startsWith(`/${locale}/cod-card-success`)) ||
+    pageContext.pageProps?.layout === 'info-order'
+  ) {
+    return EmptyLayout;
+  }
+
+  if (pageContext.exports.Layout) {
+    return pageContext.exports.Layout;
+  }
+
+  return DefaultLayout;
+}
+
+async function createPageApp(
+  pageContext: PageContext,
+  clientOnly: boolean,
+  siteData: InitialSiteData,
+  runsOnClient = false,
+) {
+  const { Page } = pageContext;
+
+  let rootComponent: any;
+
+  const PageWithLayout = defineComponent({
+    inject: ['changeRoute'],
+    setup() {
+      const { autodetectCity } = useAutodetectCity();
+      return { autodetectCity };
+    },
+    data: () => ({
+      Page: markRaw(Page),
+      pageProps: markRaw(pageContext.pageProps || {}),
+      Layout: markRaw(getPageLayout(pageContext)),
+    }),
+    created() {
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      rootComponent = this;
+    },
+    mounted() {
+      try {
+        const tokenObj = JSON.stringify({ token: import.meta.env.VITE_CPSS_TOKEN });
+        this.$cookies.set('cpss', btoa(tokenObj));
+        this.autodetectCity();
+      } catch (e) {
+        cdekConsoleError(e);
+      }
+    },
+    render() {
+      return h(
+        this.Layout,
+        {},
+        {
+          default: () => {
+            return h(this.Page, this.pageProps);
+          },
+        },
+      );
+    },
+  });
+
+  const app = clientOnly ? createApp(PageWithLayout) : createSSRApp(PageWithLayout);
+
+  const pinia = createPinia();
+  app.use(pinia);
+
+  const store = createVuexStore(runsOnClient);
+  app.use(store);
+
+  const i18nPlugin = await i18n(pageContext.locale);
+  useI18nHelpers(i18nPlugin);
+  app.use(i18nPlugin);
+
+  app.use(restApiClientPlugin, runsOnClient);
+  app.use(graphqlApiClientPlugin, runsOnClient);
+  app.use(apiClientPlugin, store as CdekStore);
+  app.use(pmsApiClientPlugin);
+
+  app.use(FloatingVue);
+  app.directive('appear', appearDirective);
+  app.directive('cdek-click-outside', clickOutsideDirective);
+  app.directive('append-to-body', appendToBodyDirective);
+  app.directive('test-id', testIdDirective);
+
+  app.use(defaultColors);
+  app.use(createHead());
+  app.use(VueLazyLoad, {});
+  app.use(emitterPlugin);
+  app.use(VueCookies);
+
+  const { init, getSettingsGroup } = useSettings();
+
+  if (siteData) {
+    const { urlPathname, locale, authorization, isWebView } = pageContext;
+
+    const { countries, settings } = siteData;
+
+    if (countries) {
+      const { setDefaultCountries } = useCountries();
+
+      setDefaultCountries(countries);
+    }
+
+    if (settings) {
+      init(settings);
+    }
+
+    store.dispatch('UPDATE_SITE_DATA', { siteData, urlPathname, locale });
+
+    if (isWebView && authorization) {
+      store.commit('keycloak/setKeycloak', { access_token: authorization.replace('Bearer ', '') });
+    }
+  }
+
+  const pageContextReactive = reactive(pageContext);
+  app.use(routerPushPlugin, pageContextReactive, runsOnClient);
+
+  const activeHead = getActiveHead();
+  let activeEntry: ActiveHeadEntry<Head> | undefined;
+
+  // Все управление метаданными хотим переложить на библиотеку.
+  // ССР и ССГ страницы приходят с подготовленной метой. Чтобы либа нормально следила
+  // За своими мета данными, нужно удалить серверные данные и с помощью либы подставить новые
+  if (runsOnClient) {
+    rewriteServerMetaData(
+      i18nPlugin.global.t,
+      activeHead,
+      activeEntry,
+      pageContext.pageProps?.metaData,
+    );
+    const { vfmPlugin } = await import('vue-final-modal');
+
+    app.use(
+      vfmPlugin({
+        key: '$modal',
+        dynamicContainerName: 'modals-container',
+        componentName: 'VueFinalModal',
+      }),
+    );
+    const Notifications = await import('@kyvg/vue3-notification');
+    (store as CdekStore).$notify = Notifications.notify;
+    app.use(Notifications.default);
+    const { default: initAdmitad } = await import('@/utils/initAdmitad');
+    initAdmitad();
+
+    const { default: identityPersonApiPlugin } = await import(
+      '@/plugins/indentity-person-api-client'
+    );
+    app.use(identityPersonApiPlugin, store as CdekStore);
+    app.use(libphonenumberPlugin);
+
+    installADV();
+    initYmPlugin();
+    initGtmPlugin();
+    // пока не выносим в энвик или сеттинги, потому что только на кз (если появится другая страна, то рассмотреть перенос)
+    initVKAdsPlugin(store.getters.isKzSite);
+
+    registerToastification(app);
+
+    initMindbox(getSettingsGroup('all')?.enableMindbox);
+
+    app.use(sentryPlugin);
+  } else {
+    // Уведомления и модалки используются только на клиенте
+    // На беке из-за этого падают ворнинги о неизвестных компонентах
+    // Чтобы бек работал нормально, регистрирую компоненты, на клиенте они перетруся
+    app.component('Notifications', { template: '<div/>' });
+    app.component('ModalsContainer', { template: '<div/>' });
+    app.provide('$modal', {});
+    app.provide('$sentry', {
+      withScope: () => {},
+      setTag: () => {},
+      captureException: () => {},
+    });
+  }
+
+  const changePage = (pc: PageContext) => {
+    rootComponent.changeRoute(pc.urlPathname);
+
+    Object.assign(pageContextReactive, pc);
+
+    rootComponent.Page = markRaw(pc.Page);
+    rootComponent.pageProps = markRaw(pc.pageProps || {});
+
+    rootComponent.Layout = markRaw(getPageLayout(pc));
+
+    activeEntry = updateHead(i18nPlugin.global.t, activeHead, activeEntry, pc.pageProps?.metaData);
+    hitYm(pc.urlPathname);
+  };
+
+  const startLoading = () => {
+    store.commit('loader/setIsPageLoading', true);
+  };
+  const stopLoading = () => {
+    store.commit('loader/setIsPageLoading', false);
+  };
+
+  objectAssign(app, { changePage, startLoading, stopLoading });
+
+  setPageContext(app, pageContextReactive);
+
+  app.config.errorHandler = (
+    err: unknown,
+    instance: ComponentPublicInstance | null,
+    info: string,
+  ) => {
+    if (import.meta.env.DEV) {
+      cdekConsoleError(err, { dontSendSentry: true });
+    }
+
+    globalVueErrorsHandler(err, instance, info);
+  };
+
+  return app;
+}
+
+export { createPageApp };
diff --git a/parent_dir/src/renderer/getRedirectTo.ts b/parent_dir/src/renderer/getRedirectTo.ts
new file mode 100644
index 0000000..043b62e
--- /dev/null
+++ b/parent_dir/src/renderer/getRedirectTo.ts
@@ -0,0 +1,44 @@
+import getLocaleKeys from '#root/src/utils/getLocaleKeys';
+import { WebsiteId } from '#root/src/env';
+import { PageContextClient, PageContextServer } from './types';
+
+// /ru, /ru/, /ru/test - не нужен редирект
+// /test, /rutest, / - нужен
+const testLocalePrefix = (str: string, locale: string) =>
+  new RegExp(`^/${locale}/(.)*|^/${locale}$`).test(str);
+
+const getCurrentLocale = (localeKeys: WebsiteId[], locale: WebsiteId) => {
+  if (localeKeys.includes(locale)) {
+    return locale;
+  }
+
+  return localeKeys[0] || 'ru';
+};
+
+export const getRedirectPageContextData = (
+  pageContext: PageContextClient | PageContextServer,
+  locale?: string,
+) => {
+  const { urlOriginal, redirectTo } = pageContext;
+
+  const localeKeys = getLocaleKeys();
+
+  let currentLocale = getCurrentLocale(localeKeys, locale as WebsiteId);
+
+  let updatedRedirectTo = redirectTo;
+
+  if (!redirectTo) {
+    const needRedirect = urlOriginal && !localeKeys.some((el) => testLocalePrefix(urlOriginal, el));
+
+    if (!needRedirect) {
+      currentLocale = localeKeys.find((el) => testLocalePrefix(urlOriginal, el)) || 'ru';
+    }
+
+    updatedRedirectTo = needRedirect ? `/${currentLocale}${urlOriginal}` : '';
+  }
+
+  return {
+    redirectTo: updatedRedirectTo,
+    currentLocale,
+  };
+};
diff --git a/parent_dir/src/services/OfficeDataService.ts b/parent_dir/src/services/OfficeDataService.ts
new file mode 100644
index 0000000..fd66847
--- /dev/null
+++ b/parent_dir/src/services/OfficeDataService.ts
@@ -0,0 +1,102 @@
+import { destroyFactory, getInstanceFactory, Multitone, useServiceFactory } from '@cdek-ui-kit/vue';
+import { markRaw } from 'vue';
+
+import { useRestApi } from '@/composables/use-rest-api';
+import { useStore } from 'vuex';
+import { cdekConsoleError } from '@/utils/console-wrapper';
+import { OfficeMapDto } from '@/types/dto/office';
+import { CdekDefaultCity } from '@/types/dto/city';
+import { CdekOfficeFilter } from '@/types/dto/cdek-office';
+import debounce from 'lodash/debounce';
+import merge from 'lodash/merge';
+import { MoscowCenterCoords } from '@/constants/default-coords';
+import { averageGeolocation } from '@/components/Offices/coordsUtils';
+
+class OfficeData extends Multitone {
+  private readonly restApi = markRaw(useRestApi().restApi);
+
+  private readonly store = markRaw(useStore());
+
+  private get locale() {
+    return this.store.state.locale;
+  }
+
+  totalOfficesInCurrentCity = 0;
+
+  offices: OfficeMapDto[] = [];
+
+  officesLoading = false;
+
+  centerCoords = MoscowCenterCoords;
+
+  private _city = { ...this.store.getters.city };
+
+  private _filters: Partial<CdekOfficeFilter> = {};
+
+  private _extraFilters = {};
+
+  public get city() {
+    return this._city;
+  }
+
+  public set city(city) {
+    this._city = city;
+    this.updateDisplayedData(city);
+  }
+
+  public get filters() {
+    return this._filters;
+  }
+
+  public set filters(filters) {
+    this._filters = filters;
+    this.updateOffices();
+  }
+
+  public get extraFilters() {
+    return this._extraFilters;
+  }
+
+  public set extraFilters(extraFilters) {
+    this._extraFilters = extraFilters;
+    this.updateOffices();
+  }
+
+  private updateDisplayedData(city?: CdekDefaultCity) {
+    const cityToSearch = city || this.city;
+
+    const officesInSelectedCity = this.offices.filter(
+      (office) => +office.cityCode === cityToSearch.cdek_id,
+    );
+
+    this.totalOfficesInCurrentCity = officesInSelectedCity.length;
+
+    this.centerCoords = officesInSelectedCity.length
+      ? averageGeolocation(officesInSelectedCity)
+      : MoscowCenterCoords;
+  }
+
+  // Я не понял почему оно не работает с эрроу функцией
+  updateOffices = debounce(async function (this: OfficeData, city?: CdekDefaultCity) {
+    this.officesLoading = true;
+
+    try {
+      this.offices = await this.restApi.websiteOfficeMap(
+        { locale: this.locale },
+        merge({}, this.filters, this.extraFilters),
+      );
+
+      this.updateDisplayedData(city);
+    } catch (e) {
+      cdekConsoleError(e);
+    } finally {
+      this.officesLoading = false;
+    }
+  }, 100);
+}
+
+export const getOfficeDataService = getInstanceFactory<OfficeData>(OfficeData);
+
+export const destroyOfficeDataService = destroyFactory(OfficeData);
+
+export const useOfficeDataService = useServiceFactory<OfficeData>(getOfficeDataService, OfficeData);
diff --git a/parent_dir/src/static/flags/flag_am.svg b/parent_dir/src/static/flags/flag_am.svg
new file mode 100644
index 0000000..4ad968f
--- /dev/null
+++ b/parent_dir/src/static/flags/flag_am.svg
@@ -0,0 +1,17 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock, createStaticVNode as _createStaticVNode } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "20",
+  height: "15",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createStaticVNode("<mask id=\"a\" width=\"20\" height=\"15\" x=\"0\" y=\"0\" maskUnits=\"userSpaceOnUse\" style=\"mask-type:luminance;\"><path fill=\"#fff\" d=\"M0 0h20v15H0z\"></path></mask><g mask=\"url(#a)\"><path fill=\"#2E42A5\" fill-rule=\"evenodd\" d=\"M0 0v15h20V0H0Z\" clip-rule=\"evenodd\"></path><mask id=\"b\" width=\"20\" height=\"15\" x=\"0\" y=\"0\" maskUnits=\"userSpaceOnUse\" style=\"mask-type:luminance;\"><path fill=\"#fff\" fill-rule=\"evenodd\" d=\"M0 0v15h20V0H0Z\" clip-rule=\"evenodd\"></path></mask><g fill-rule=\"evenodd\" clip-rule=\"evenodd\" mask=\"url(#b)\"><path fill=\"#E31D1C\" d=\"M0 0v5h20V0H0Z\"></path><path fill=\"#FECA00\" d=\"M0 10v5h20v-5H0Z\"></path></g></g>", 2)
+const _hoisted_4 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_4))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/static/flags/flag_az.svg b/parent_dir/src/static/flags/flag_az.svg
new file mode 100644
index 0000000..f07aa31
--- /dev/null
+++ b/parent_dir/src/static/flags/flag_az.svg
@@ -0,0 +1,17 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock, createStaticVNode as _createStaticVNode } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "20",
+  height: "15",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createStaticVNode("<mask id=\"a\" width=\"20\" height=\"15\" x=\"0\" y=\"0\" maskUnits=\"userSpaceOnUse\" style=\"mask-type:luminance;\"><path fill=\"#fff\" d=\"M0 0h20v15H0z\"></path></mask><g mask=\"url(#a)\"><path fill=\"#AF0100\" fill-rule=\"evenodd\" d=\"M0 0v15h20V0H0Z\" clip-rule=\"evenodd\"></path><mask id=\"b\" width=\"20\" height=\"15\" x=\"0\" y=\"0\" maskUnits=\"userSpaceOnUse\" style=\"mask-type:luminance;\"><path fill=\"#fff\" fill-rule=\"evenodd\" d=\"M0 0v15h20V0H0Z\" clip-rule=\"evenodd\"></path></mask><g fill-rule=\"evenodd\" clip-rule=\"evenodd\" mask=\"url(#b)\"><path fill=\"#3CA5D9\" d=\"M0 0v5h20V0H0Z\"></path><path fill=\"#73BE4A\" d=\"M0 10v5h20v-5H0Z\"></path><path fill=\"#F7FCFF\" d=\"M10.726 9.317c-.842-.194-1.5-.856-1.492-1.828.008-.909.595-1.678 1.52-1.887.927-.209 1.741.232 1.741.232-.255-.567-1.143-.965-1.872-.963-1.357.003-2.804 1.039-2.818 2.62-.015 1.64 1.546 2.571 2.919 2.568 1.1-.003 1.624-.712 1.732-1.013 0 0-.888.465-1.73.27Zm.535-.93.735-.51.735.51-.26-.856.714-.54-.895-.019-.294-.845-.294.845-.895.018.713.541-.259.857Z\"></path></g></g>", 2)
+const _hoisted_4 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_4))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/static/flags/flag_by.svg b/parent_dir/src/static/flags/flag_by.svg
new file mode 100644
index 0000000..9734fec
--- /dev/null
+++ b/parent_dir/src/static/flags/flag_by.svg
@@ -0,0 +1,17 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock, createStaticVNode as _createStaticVNode } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "20",
+  height: "15",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createStaticVNode("<mask id=\"a\" width=\"20\" height=\"15\" x=\"0\" y=\"0\" maskUnits=\"userSpaceOnUse\" style=\"mask-type:luminance;\"><path fill=\"#fff\" d=\"M0 0h20v15H0z\"></path></mask><g mask=\"url(#a)\"><path fill=\"#73BE4A\" fill-rule=\"evenodd\" d=\"M0 0h20v15H0V0Z\" clip-rule=\"evenodd\"></path><path fill=\"#AF0100\" fill-rule=\"evenodd\" d=\"M0 0v10h20V0H0Z\" clip-rule=\"evenodd\"></path><path fill=\"#F7FCFF\" d=\"M0 0h3.75v15H0z\"></path><path fill=\"#D0181A\" fill-rule=\"evenodd\" d=\"M.625 0a.625.625 0 1 1 0 1.25.625.625 0 0 1 0-1.25Zm2.5 0a.625.625 0 1 1 0 1.25.625.625 0 0 1 0-1.25ZM1.25 3.125a.625.625 0 1 0-1.25 0 .625.625 0 0 0 1.25 0ZM3.125 2.5a.625.625 0 1 1 0 1.25.625.625 0 0 1 0-1.25Zm0 8.75a.625.625 0 1 1 0 1.25.625.625 0 0 1 0-1.25Zm-1.875.625a.625.625 0 1 0-1.25 0 .625.625 0 0 0 1.25 0ZM.625 13.75a.625.625 0 1 1 0 1.25.625.625 0 0 1 0-1.25Zm3.125.625a.625.625 0 1 0-1.25 0 .625.625 0 0 0 1.25 0ZM1.875 12.5a.625.625 0 1 1 0 1.25.625.625 0 0 1 0-1.25ZM2.5 1.875a.625.625 0 1 0-1.25 0 .625.625 0 0 0 1.25 0Zm.069 5.65L3.75 8.75V10l.027.058-1.845-1.847L.274 10H0V8.75l1.24-1.232L0 6.278V5h.136l1.779 1.846 1.787-1.778L3.75 5v1.25L2.569 7.524ZM1.875 3.75a.625.625 0 1 1 0 1.25.625.625 0 0 1 0-1.25Zm.625 6.875a.625.625 0 1 0-1.25 0 .625.625 0 0 0 1.25 0Z\" clip-rule=\"evenodd\"></path><path fill=\"#8F181A\" fill-rule=\"evenodd\" d=\"M0 0h1.25v1.25H0V0Zm1.25 2.5H0v1.25h1.25V2.5ZM0 5h1.25v1.25H0V5Zm1.25 3.75H0V10h1.25V8.75ZM0 11.25h1.25v1.25H0v-1.25Zm1.25 2.5H0V15h1.25v-1.25Zm2.5 0H2.5V15h1.25v-1.25ZM3.75 0H2.5v1.25h1.25V0Z\" clip-rule=\"evenodd\" opacity=\".4\"></path></g>", 2)
+const _hoisted_4 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_4))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/static/flags/flag_ge.svg b/parent_dir/src/static/flags/flag_ge.svg
new file mode 100644
index 0000000..9674384
--- /dev/null
+++ b/parent_dir/src/static/flags/flag_ge.svg
@@ -0,0 +1,17 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock, createStaticVNode as _createStaticVNode } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "20",
+  height: "15",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createStaticVNode("<mask id=\"a\" width=\"20\" height=\"15\" x=\"0\" y=\"0\" maskUnits=\"userSpaceOnUse\" style=\"mask-type:luminance;\"><path fill=\"#fff\" d=\"M0 0h20v15H0z\"></path></mask><g mask=\"url(#a)\"><path fill=\"#F7FCFF\" fill-rule=\"evenodd\" d=\"M0 0v15h20V0H0Z\" clip-rule=\"evenodd\"></path><mask id=\"b\" width=\"20\" height=\"15\" x=\"0\" y=\"0\" maskUnits=\"userSpaceOnUse\" style=\"mask-type:luminance;\"><path fill=\"#fff\" fill-rule=\"evenodd\" d=\"M0 0v15h20V0H0Z\" clip-rule=\"evenodd\"></path></mask><g fill=\"#E31D1C\" fill-rule=\"evenodd\" clip-rule=\"evenodd\" mask=\"url(#b)\"><path d=\"M8.75 0h2.5v6.25H20v2.5h-8.75V15h-2.5V8.75H0v-2.5h8.75V0Z\"></path><path d=\"m6.25 10.764 1.375-.139v1.25s-1.376-.086-1.376-.061c0 .025.126 1.311.126 1.311h-1.25l.1-1.25h-1.35v-1.25l1.35.139-.1-1.389h1.25l-.126 1.389ZM6.25 3.264l1.375-.139v1.25s-1.376-.086-1.376-.061c0 .025.126 1.311.126 1.311h-1.25l.1-1.25h-1.35v-1.25l1.35.139-.1-1.389h1.25l-.126 1.389ZM15 3.264l1.375-.139v1.25s-1.376-.086-1.376-.061c0 .025.126 1.311.126 1.311h-1.25l.1-1.25h-1.35v-1.25l1.35.139-.1-1.389h1.25l-.126 1.389ZM15 10.764l1.375-.139v1.25s-1.376-.086-1.376-.061c0 .025.126 1.311.126 1.311h-1.25l.1-1.25h-1.35v-1.25l1.35.139-.1-1.389h1.25l-.126 1.389Z\"></path></g></g>", 2)
+const _hoisted_4 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_4))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/static/flags/flag_kg.svg b/parent_dir/src/static/flags/flag_kg.svg
new file mode 100644
index 0000000..ed00bba
--- /dev/null
+++ b/parent_dir/src/static/flags/flag_kg.svg
@@ -0,0 +1,17 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock, createStaticVNode as _createStaticVNode } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "20",
+  height: "15",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createStaticVNode("<mask id=\"a\" width=\"20\" height=\"15\" x=\"0\" y=\"0\" maskUnits=\"userSpaceOnUse\" style=\"mask-type:luminance;\"><path fill=\"#fff\" d=\"M0 0h20v15H0z\"></path></mask><g mask=\"url(#a)\"><path fill=\"#C51918\" fill-rule=\"evenodd\" d=\"M0 0v15h20V0H0Z\" clip-rule=\"evenodd\"></path><mask id=\"b\" width=\"20\" height=\"15\" x=\"0\" y=\"0\" maskUnits=\"userSpaceOnUse\" style=\"mask-type:luminance;\"><path fill=\"#fff\" fill-rule=\"evenodd\" d=\"M0 0v15h20V0H0Z\" clip-rule=\"evenodd\"></path></mask><g mask=\"url(#b)\"><path fill=\"#FFDC17\" fill-rule=\"evenodd\" d=\"M9.989 11.167c.067 0 .133-.002.2-.005l.385 1.23.09-1.285c.129-.024.255-.054.38-.09l.66 1.109-.212-1.271c.12-.053.236-.11.349-.175l.902.929-.503-1.19c.104-.078.204-.16.298-.248l1.094.697-.765-1.043c.083-.099.16-.202.233-.31l1.226.429-.986-.84c.057-.114.11-.233.155-.354l1.291.136-1.154-.59a3.68 3.68 0 0 0 .068-.382l1.288-.163-1.26-.31c-.001-.131-.009-.26-.022-.387l1.214-.453-1.296-.014a3.644 3.644 0 0 0-.112-.372l1.075-.718-1.264.283a3.68 3.68 0 0 0-.195-.337l.878-.944-1.163.564a3.743 3.743 0 0 0-.269-.283l.635-1.119-1 .814a3.744 3.744 0 0 0-.328-.215l.358-1.232-.782 1.019a3.73 3.73 0 0 0-.371-.135l.061-1.278-.524 1.17a3.777 3.777 0 0 0-.392-.046L9.993 2.5l-.237 1.257a3.779 3.779 0 0 0-.394.045L8.84 2.634l.062 1.276a3.73 3.73 0 0 0-.373.134l-.78-1.016.356 1.227a3.747 3.747 0 0 0-.332.216l-.995-.81.632 1.113c-.095.09-.186.186-.272.286L5.98 4.5l.874.937c-.072.11-.139.224-.2.341L5.4 5.497l1.068.713a3.655 3.655 0 0 0-.113.377l-1.288.014 1.206.45c-.014.129-.021.26-.022.392l-1.251.308 1.279.162c.016.131.039.26.069.386L5.2 8.886l1.283-.135c.046.123.099.243.157.36l-.98.833 1.22-.426c.072.109.151.213.235.313l-.76 1.037 1.088-.694c.096.089.196.172.301.25l-.5 1.185.899-.925c.113.064.23.122.35.174l-.21 1.268.659-1.107c.124.036.252.066.381.09l.09 1.282.385-1.229c.063.003.127.005.19.005Zm2.812-3.72c0 1.553-1.269 2.812-2.835 2.812-1.565 0-2.835-1.259-2.835-2.812s1.27-2.812 2.835-2.812c1.566 0 2.835 1.26 2.835 2.812Zm-.857.916a2.136 2.136 0 0 0 .008-1.722c-.49.035-.904.164-1.24.329.746.326 1.084.864 1.232 1.393Zm-.241.411c-.061.082-.128.16-.2.232-.04-.738-.355-1.3-.922-1.908.701.336 1.097 1.138 1.122 1.676Zm-.537.507a2.14 2.14 0 0 1-.121.075c-.168-.829-.487-1.483-.93-2.006l.107-.081.044-.032c.567.652.925 1.212.9 2.044Zm-1.181.355c.251 0 .492-.043.717-.123-.163-.789-.447-1.523-.858-2.053a3.062 3.062 0 0 0-.75 1.983c.272.124.573.193.89.193Zm-.413-2.43.049.04c-.523.594-.809 1.265-.858 2.009a2.152 2.152 0 0 1-.184-.144c.197-.787.523-1.436.993-1.905Zm-1.56-.55c.49.055.878.174 1.169.313-.74.314-1.033.822-1.18 1.339a2.137 2.137 0 0 1 .01-1.652Zm.268 2.137a2.164 2.164 0 0 1-.048-.066c.037-.543.383-1.314 1.081-1.632A3.74 3.74 0 0 0 8.28 8.793Zm.159-2.784c.39-.407.938-.66 1.546-.66.598 0 1.139.246 1.527.64-.612.072-1.13.225-1.552.464-.375-.216-.883-.361-1.521-.444Z\" clip-rule=\"evenodd\"></path></g></g>", 2)
+const _hoisted_4 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_4))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/static/flags/flag_kz.svg b/parent_dir/src/static/flags/flag_kz.svg
new file mode 100644
index 0000000..f707505
--- /dev/null
+++ b/parent_dir/src/static/flags/flag_kz.svg
@@ -0,0 +1,17 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock, createStaticVNode as _createStaticVNode } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "20",
+  height: "15",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createStaticVNode("<mask id=\"a\" width=\"20\" height=\"15\" x=\"0\" y=\"0\" maskUnits=\"userSpaceOnUse\" style=\"mask-type:luminance;\"><path fill=\"#fff\" d=\"M0 0h20v15H0z\"></path></mask><g mask=\"url(#a)\"><path fill=\"#4EC7EE\" fill-rule=\"evenodd\" d=\"M0 0v15h20V0H0Z\" clip-rule=\"evenodd\"></path><mask id=\"b\" width=\"20\" height=\"15\" x=\"0\" y=\"0\" maskUnits=\"userSpaceOnUse\" style=\"mask-type:luminance;\"><path fill=\"#fff\" fill-rule=\"evenodd\" d=\"M0 0v15h20V0H0Z\" clip-rule=\"evenodd\"></path></mask><g mask=\"url(#b)\"><path fill=\"#FFE402\" d=\"M2.556 14.523c-.04.294.149.503.464.638.425.18.853.011 1.247-.425l-.51-.46c-.176.193-.302.268-.4.267.191-.137.436-.305.734-.506l.144-.207c.115-.493-.243-.76-.788-.76-.321 0-.578.063-.74.2-.268.224-.223.582.059.769a.735.735 0 0 0 .068.04c-.158.133-.254.27-.278.444Z\"></path><path stroke=\"#FFE402\" stroke-width=\".688\" d=\"M2.853 14.06s.078-.173.039-.263\"></path><path fill=\"#FFE402\" d=\"M5.356 14.523c.04.294-.149.503-.464.638-.425.18-.853.011-1.247-.425l.51-.46c.176.193.302.268.4.267a32.006 32.006 0 0 0-.734-.506l-.143-.207c-.115-.493.242-.76.787-.76.321 0 .578.063.74.2.268.224.223.582-.059.769a.735.735 0 0 1-.068.04c.158.133.254.27.278.444Z\"></path><path fill=\"#FFE402\" d=\"m5.372 13.918-.626.283c-.088-.195-.115-.372-.041-.54l.63.273c.022-.05.021-.051.037-.016ZM2.556.477c-.04-.294.149-.503.464-.638.425-.18.853-.011 1.247.425l-.51.46c-.176-.193-.302-.268-.4-.267.191.137.436.306.734.506l.144.207c.115.493-.243.76-.788.76-.321 0-.578-.063-.74-.2-.268-.224-.223-.582.059-.769a.728.728 0 0 1 .068-.04C2.676.789 2.58.652 2.556.478Z\"></path><path fill=\"#FFE402\" d=\"M5.356.477c.04-.294-.149-.503-.464-.638-.425-.18-.853-.011-1.247.425l.51.46c.176-.193.302-.268.4-.267-.191.137-.436.306-.734.506l-.143.207c-.115.493.242.76.787.76.321 0 .578-.063.74-.2.268-.224.223-.582-.059-.769a.728.728 0 0 0-.068-.04c.158-.133.254-.27.278-.444Z\"></path><path fill=\"#FFE402\" fill-rule=\"evenodd\" d=\"M3.184 12.54c-.395.01-.64.092-.64.472 0 .42.407.55.84.55.393 0 .835-.243.835-.68 0-.265-.337-.8-1.187-1.961-.03-.028-.046-.042-.059-.042a.548.548 0 0 1 .262-.062c.042 0 .096.02.15.048v.455h.9v-.344c0-.388-.575-.847-1.05-.847-.414 0-.747.198-.916.481-.166.28-.039.55.2.764.356.491.633.897.806 1.165h-.141Zm.042.316a.566.566 0 0 1-.036-.009c.009.01.041.048.041.165 0 .064-.003.109-.007.14a.33.33 0 0 1-.063-.418l.002-.003-.013-.026a.107.107 0 0 0 .005-.002c.02-.01.036-.02.008.028l.063.125Zm-.036-.009-.012-.003c.002 0 .003 0 .005.002l.007.001Zm.342.036c0-.012-.004-.019-.011-.023l.004.005c.004.01.007.015.007.018Z\" clip-rule=\"evenodd\"></path><path fill=\"#FFE402\" fill-rule=\"evenodd\" d=\"M4.728 12.54c.395.01.64.092.64.472 0 .42-.407.55-.84.55-.393 0-.835-.243-.835-.68 0-.265.337-.8 1.187-1.961.03-.028.046-.042.059-.042a.548.548 0 0 0-.262-.062.374.374 0 0 0-.15.048v.455h-.899v-.344c0-.388.574-.847 1.049-.847.414 0 .747.198.916.481.166.28.039.55-.2.764-.356.491-.633.897-.806 1.165h.141Zm-.042.316a.566.566 0 0 0 .036-.009c-.008.01-.041.048-.041.165 0 .064.003.109.007.14a.33.33 0 0 0 .063-.418l-.002-.003.013-.026a.107.107 0 0 1-.005-.002c-.02-.01-.036-.02-.008.028l-.063.125Zm.036-.009.012-.003a.024.024 0 0 0-.005.002l-.007.001Zm-.342.036c0-.012.004-.019.011-.023l-.004.005a.061.061 0 0 0-.007.018Z\" clip-rule=\"evenodd\"></path><path fill=\"#FFE402\" fill-rule=\"evenodd\" d=\"M3.184 8.347c-.395-.012-.64-.093-.64-.473 0-.42.407-.55.84-.55.393 0 .835.243.835.68 0 .265-.337.8-1.187 1.961-.03.028-.046.042-.059.042a.547.547 0 0 0 .262.062.374.374 0 0 0 .15-.048v-.455h.9v.344c0 .388-.575.847-1.05.847-.414 0-.747-.197-.916-.481-.166-.28-.039-.55.2-.764.356-.49.633-.897.806-1.165a3.5 3.5 0 0 1-.141 0Zm.042-.317a.58.58 0 0 0-.036.009c.009-.009.041-.048.041-.165 0-.064-.003-.109-.007-.14a.33.33 0 0 0-.063.418l.002.003-.013.026.005.002c.02.01.036.02.008-.028l.063-.125Zm-.036.009-.012.003a.022.022 0 0 0 .005-.002l.007-.001Zm.342-.036c0 .012-.004.02-.011.023l.004-.005a.061.061 0 0 0 .007-.018Z\" clip-rule=\"evenodd\"></path><path fill=\"#FFE402\" fill-rule=\"evenodd\" d=\"M4.728 8.347c.395-.012.64-.093.64-.473 0-.42-.407-.55-.84-.55-.393 0-.835.243-.835.68 0 .265.337.8 1.187 1.961.03.028.046.042.059.042a.547.547 0 0 1-.262.062.374.374 0 0 1-.15-.048v-.455h-.899v.344c0 .388.574.847 1.049.847.414 0 .747-.197.916-.481.166-.28.039-.55-.2-.764a28.69 28.69 0 0 1-.806-1.165h.141Zm-.042-.317a.58.58 0 0 1 .036.009c-.008-.009-.041-.048-.041-.165 0-.064.003-.109.007-.14a.33.33 0 0 1 .063.418l-.002.003.013.026-.005.002c-.02.01-.036.02-.008-.028l-.063-.125Zm.036.009.012.003a.022.022 0 0 1-.005-.002l-.007-.001Zm-.342-.036c0 .012.004.02.011.023l-.004-.005a.061.061 0 0 1-.007-.018Z\" clip-rule=\"evenodd\"></path><path fill=\"#FFE402\" fill-rule=\"evenodd\" d=\"M3.184 6.653c-.395.012-.64.093-.64.473 0 .42.407.55.84.55.393 0 .835-.243.835-.68 0-.265-.337-.8-1.187-1.961-.03-.028-.046-.042-.059-.042a.547.547 0 0 1 .262-.062c.042 0 .096.02.15.048v.455h.9V5.09c0-.388-.575-.847-1.05-.847-.414 0-.747.197-.916.481-.166.28-.039.55.2.764.356.491.633.897.806 1.165h-.141Zm.042.317a.581.581 0 0 1-.036-.009c.009.009.041.048.041.165 0 .064-.003.109-.007.14a.33.33 0 0 1-.063-.418l.002-.003-.013-.026a.49.49 0 0 0 .005-.002c.02-.01.036-.02.008.028l.063.125Zm-.036-.009-.012-.003c.002 0 .003 0 .005.002l.007.001Zm.342.036c0-.012-.004-.02-.011-.023l.004.005c.004.009.007.015.007.018Z\" clip-rule=\"evenodd\"></path><path fill=\"#FFE402\" fill-rule=\"evenodd\" d=\"M4.728 6.653c.395.012.64.093.64.473 0 .42-.407.55-.84.55-.393 0-.835-.243-.835-.68 0-.265.337-.8 1.187-1.961.03-.028.046-.042.059-.042a.547.547 0 0 0-.262-.062.373.373 0 0 0-.15.048v.455h-.899V5.09c0-.388.574-.847 1.049-.847.414 0 .747.197.916.481.166.28.039.55-.2.764-.356.491-.633.897-.806 1.165h.141Zm-.042.317a.581.581 0 0 0 .036-.009c-.008.009-.041.048-.041.165 0 .064.003.109.007.14a.33.33 0 0 0 .063-.418l-.002-.003.013-.026a.49.49 0 0 1-.005-.002c-.02-.01-.036-.02-.008.028l-.063.125Zm.036-.009.012-.003a.022.022 0 0 0-.005.002l-.007.001Zm-.342.036c0-.012.004-.02.011-.023l-.004.005a.061.061 0 0 0-.007.018Z\" clip-rule=\"evenodd\"></path><path fill=\"#FFE402\" fill-rule=\"evenodd\" d=\"M3.184 2.46c-.395-.01-.64-.092-.64-.472 0-.42.407-.55.84-.55.393 0 .835.243.835.68 0 .265-.337.8-1.187 1.961-.03.028-.046.042-.059.042a.547.547 0 0 0 .262.062.373.373 0 0 0 .15-.048V3.68h.9v.344c0 .388-.575.847-1.05.847-.414 0-.747-.198-.916-.481-.166-.28-.039-.55.2-.764.356-.491.633-.898.806-1.165h-.141Zm.042-.316a.58.58 0 0 0-.036.009c.009-.01.041-.048.041-.165 0-.064-.003-.109-.007-.14a.33.33 0 0 0-.063.418l.002.003-.013.026a.81.81 0 0 1 .005.002c.02.01.036.02.008-.028l.063-.125Zm-.036.009-.012.003a.022.022 0 0 0 .005-.002l.007-.001Zm.342-.036c0 .012-.004.019-.011.023l.004-.005a.061.061 0 0 0 .007-.018Z\" clip-rule=\"evenodd\"></path><path fill=\"#FFE402\" fill-rule=\"evenodd\" d=\"M4.728 2.46c.395-.01.64-.092.64-.472 0-.42-.407-.55-.84-.55-.393 0-.835.243-.835.68 0 .265.337.8 1.187 1.961.03.028.046.042.059.042a.547.547 0 0 1-.262.062.373.373 0 0 1-.15-.048V3.68h-.899v.344c0 .388.574.847 1.049.847.414 0 .747-.198.916-.481.166-.28.039-.55-.2-.764a28.69 28.69 0 0 1-.806-1.165h.141Zm-.042-.316a.58.58 0 0 1 .036.009c-.008-.01-.041-.048-.041-.165 0-.064.003-.109.007-.14a.33.33 0 0 1 .063.418l-.002.003.013.026a.81.81 0 0 0-.005.002c-.02.01-.036.02-.008-.028l-.063-.125Zm.036.009.012.003a.022.022 0 0 1-.005-.002l-.007-.001Zm-.342-.036c0 .012.004.019.011.023l-.004-.005a.061.061 0 0 1-.007-.018ZM11.867 1.74l.256.955s.003.217-.242.217a.238.238 0 0 1-.258-.217l.244-.954Zm2.164 3.647c0 1.243-.948 2.25-2.118 2.25S9.794 6.63 9.794 5.387c0-1.242.948-2.25 2.119-2.25 1.17 0 2.118 1.008 2.118 2.25Zm-1.168-2.5.035-.987-.512.842s-.052.21.182.283c.235.071.295-.137.295-.137Zm.975-.52-.322.935s-.119.182-.322.045-.092-.324-.092-.324l.736-.655Zm.185 1.535.58-.8-.894.412s-.161.146-.007.337c.154.19.321.051.321.051Zm1.109.146-.8.582s-.201.08-.29-.149a.238.238 0 0 1 .111-.318l.979-.115Zm-.702 1.378.934-.321-.969-.177s-.215.028-.198.272c.017.245.233.226.233.226Zm.858.759-.988.035s-.212-.046-.157-.285c.055-.239.27-.202.27-.202l.875.452Zm-1.334.753.954.256-.705-.688s-.194-.098-.316.114a.219.219 0 0 0 .067.318Zm.306 1.104-.838-.523s-.15-.157.029-.324c.18-.167.336-.017.336-.017l.473.864Zm-1.508-.133.648.746-.2-.965s-.105-.19-.326-.082c-.22.107-.122.3-.122.3Zm-.347 1.068-.402-.903s-.037-.214.205-.252a.238.238 0 0 1 .288.174l-.09.98Zm-1.156-.981.104.983.39-.905s.021-.217-.22-.255c-.243-.038-.274.177-.274.177Zm-.893.664.189-.97s.092-.197.313-.09c.22.108.136.309.136.309l-.637.751ZM9.96 7.178l-.464.873.829-.532s.139-.168-.04-.335c-.18-.167-.325-.006-.325-.006Zm-1.116.027.7-.7s.186-.11.308.102c.123.212-.059.331-.059.331l-.949.267Zm.49-1.472-.872.464.985.023s.208-.061.153-.3c-.055-.239-.266-.187-.266-.187Zm-.953-.616.97-.189s.217.012.2.257c-.017.244-.234.241-.234.241l-.936-.31Zm1.213-.954-.984-.103.805.57s.207.066.294-.163c.088-.229-.115-.304-.115-.304Zm-.459-1.05.903.401s.17.134.016.325c-.154.19-.33.063-.33.063l-.589-.79Zm1.51-.09-.746-.648.332.927s.131.173.334.036c.204-.137.08-.315.08-.315Zm.192-1.12.524.839s.066.206-.168.278c-.234.072-.31-.132-.31-.132l-.046-.984Z\" clip-rule=\"evenodd\"></path><path fill=\"#FFE402\" fill-rule=\"evenodd\" d=\"M7.638 6.67a3.156 3.156 0 0 1-.023-.096l.043.088-.02.008Zm.06.206a4.035 4.035 0 0 1-.06-.206l-.268.107.04.1H7.38l-.011.005a1.206 1.206 0 0 1-.024-.233v-.617l.269.542a1.827 1.827 0 0 1-.052-.398v-.77l.312.78-.296.092.116.371H7.69l-.032.013.11.222.107.34c-.1-.183-.15-.304-.15-.348h-.027Zm.342.867a8.263 8.263 0 0 1-.342-.867H7.41l.293.734-.109-.116a2.465 2.465 0 0 1-.224-.612L7.132 7l-.048-.05v.074l-.01.005.01.022v.084a.858.858 0 0 1-.047-.259V5.412l.309.62v-1.17l.217.545v-1.48l.87 2.777-.061.02c-.081-.241-.121-.425-.121-.548h-.344l-.032.01.247.62-.06.019a.665.665 0 0 1-.029-.176h-.338l.074.235.383.772-.015.007a7.666 7.666 0 0 1-.262-.44l.15.482.112-.042.015.024-.112.056Zm.12-.045-.12.045-.144.072-.193-.205.092.23a.33.33 0 0 1-.021-.019 5.236 5.236 0 0 1-.18-.327L7.132 7l-.048.024v.027l.381.768h-.037l-.003.002a3.444 3.444 0 0 1-.34-.686v.502l-1.366-.973 1.739 2.07a5.523 5.523 0 0 0 2.05 1.523l-1.575-.034 1.6.452-.827.61 1.43-.44.39.11c.525.148.817.296.836.342l.074.174.186.03c.409.069 1.163-.037 2.134-.252.33-.074.661-.155.917-.224a5.5 5.5 0 0 0 .24-.069l.017-.006.027-.01.01-.005a.645.645 0 0 0 .042-.021c.032-.005.055-.008.07-.02.043-.035.027-.142-.032-.544-.27-.073-.308-.083-.319-.07l-.003.007c-.093.02-.238.018-.43-.007 1.615-.795 2.677-1.591 3.185-2.41l.93-1.5-.563.412.203-.653-.803.516a1.88 1.88 0 0 0 .24-.41l.605-1.462-.955.89.518-1.706-1.229 1.646-5.03 3.702-.08-.018C10.079 9 9.209 8.125 8.692 6.62l-.258.084.003.01-.06.02-.004-.01-.25.081.004.01-.06.02-.004-.01-.025.008c.084.271.175.526.274.763l-.159.06.012.025-.012.006.007.011Zm.01-.004-.01.004.024.038-.247.124-.041-.045-.081.04a.645.645 0 0 1-.02-.015l.008.022.012-.006.054.038-.04.02a6.91 6.91 0 0 1-.055-.093l-.002-.002h-.307l.07.14-.045-.033a9.24 9.24 0 0 1-.065-.105l-.035.034-.306-.218v.182c0 .325.229.571.622.773l-.185.2 2.057 1.466-.07-.001c.067.029.136.057.205.085l.178.07-.357.263.602.17.48-.148 1.708.673-.55-.392c.067 0 .132-.002.195-.003a.686.686 0 0 0-.102-.14.992.992 0 0 1-.132-.011l-.019.113-.576-.41c.22-.076.435-.156.642-.24.853-.008 1.364-.054 1.44-.11l.131-.098.159.041c.153.04.293.072.422.098l.109.183c.085-.04.169-.08.251-.121a3.878 3.878 0 0 1-.063-.009l3.16-2.305-.264-.246c.334-.172.552-.398.643-.689l.077-.249-.34.248-.066-.101-.328-.102c-.03.097-.129.195-.304.285.175-.157.322-.312.438-.467l-.496.32.653-.61-.408-.282c.036-.08.065-.16.089-.238l.052-.171-.23.214-.342-.173.158-.32-.297.218-.703.942-.24-.2c-.642 1.303-1.798 2.338-3.48 3.101l-.608-.14-.174.127.018-.155c-1.146 0-1.991-.85-2.545-2.648l-.258.085.246.784-.246.094-.015-.039.246-.093a8.17 8.17 0 0 1-.292-.727l-.249.082.295.738-.021.008.016-.008c-.183-.298-.299-.54-.35-.719l-.025.008c.09.263.19.51.302.74l-.032.013.004.01-.15.075.006.013Zm.157-.06-.156.06.02.039-.007.003.023.036-.229.131-.04-.043-.069.034.06.037-.24.138-.154-.11.077.154.078-.044.036.025-.094.054a12.62 12.62 0 0 1-.142-.222l-.1-.071-.213.199.441.47.25-.235.036-.068 1.12.798.414.442a4.793 4.793 0 0 1-1.454-1.17l-.278.301.007.004 1.753.895-.028-.03c.169.089.344.169.527.24l-.303.559-.084-.002.061.044.023-.042.423.009-.194.143.725.285.025-.007c.17-.053.336-.107.5-.163l-.125-.089.202-.15c.202.002.39.002.564 0 .254-.102.499-.21.734-.322h1.267l.15.252.085.017.08.133.133-.097a5.057 5.057 0 0 1-.213-.036l-.16-.27h.386l-.448-.103-.048-.082c1.33-.632 2.27-1.252 2.82-1.848.212-.06.398-.13.559-.212l-.115-.106.615-.396-.12-.188-1.038.757-.13-.302c.175-.126.332-.25.47-.373-.098.05-.22.097-.368.141l.31-.289-.94.605c.585-.541.982-1.037 1.185-1.496l-.041-.03.077-.102-.125-.063-.791.738.449-.91-.138-.07c-.084.277-.293.603-.628.972l-.076-.063-.424.568.106.095-3.128 2.302-.273-.064c-.262.119-.536.231-.823.337l.04-.35-.526.387C9.686 9.46 8.91 8.728 8.372 7.642l.07-.035-.006-.014-.075.028-.015-.032.054-.027-.057.022.003.005-.031.016.012.03Zm.01.025-.147.074.037.074-.22.127-.029-.03-.048.027.04.023-.244.14.178.127.121-.238a2.05 2.05 0 0 1-.054-.029l.036-.02 1.017 1.085 1.402 1-.34.25.478.01.18.359.272-.2-.217-.154.42.005.439-.323h.858c.184-.09.363-.181.535-.277l.659.153.073.124h.075l-.062-.104-.086-.02-.018-.029 2.426-1.77.305-.073c.05-.012.098-.025.145-.038a3.66 3.66 0 0 0 .069-.077l.375-.241-.116-.107c-.071.115-.158.23-.26.348l-.108.07-.059-.138-.351.257-1.245.302c.139-.139.27-.282.395-.429l.399-.256.136.178a9 9 0 0 0 .536-.354l-.041-.098.143-.134a3.71 3.71 0 0 1-.18.048l.037.086-.44.41-.133-.173.082-.053.003-.002-.003.002-.162-.147.036-.052.169.152 1.105-1.48-.103-.072c-.112.27-.407.586-.887.934.047-.085.092-.17.135-.258l.016-.032-.146.136-.171-.144a7.34 7.34 0 0 1-.458.458l.116.104-.052.038.039.035-.056.052.18.237c-.094.132-.194.26-.3.385l-.832.535.437-.106a8.168 8.168 0 0 1-1.822 1.343l-.774-.18-.62.457h-.418c-.162 0-.32-.013-.472-.038l.126-.043c.088.027.177.05.268.072l.02-.174c-.095.035-.19.069-.288.102a4.106 4.106 0 0 1-.198-.065l-.1.074c-.968-.226-1.722-.983-2.257-2.235Zm0 0 .035-.017-.01-.02-.035.012.01.025Zm2.107 2.372-.018-.013.17-.124c.056.013.113.024.17.034-.105.035-.213.07-.322.103Zm5.166-2.557.035-.05-.195-.175.056-.035.175.158a6.2 6.2 0 0 0 .284-.466c-.137.1-.29.203-.459.308L15.49 7.2l.278-.26.227-.167-.025-.02-.202.187-.311.23.033.03-.046.043.006.006-.007.005.167.22Zm0 0 .115.15-.058.037-.098-.129.041-.058Zm-5.166 2.557.355.253-.172-.004-.063-.001-.125-.247.005-.001Zm1.272.906-.007.041h.064l-.057-.041Zm1.915-.208-.1-.135-.149.032-.041.16.118.03a.658.658 0 0 0 .172-.087Z\" clip-rule=\"evenodd\"></path></g></g>", 2)
+const _hoisted_4 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_4))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/static/flags/flag_ru.svg b/parent_dir/src/static/flags/flag_ru.svg
new file mode 100644
index 0000000..2616e98
--- /dev/null
+++ b/parent_dir/src/static/flags/flag_ru.svg
@@ -0,0 +1,17 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock, createStaticVNode as _createStaticVNode } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "20",
+  height: "15",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createStaticVNode("<mask id=\"a\" width=\"20\" height=\"15\" x=\"0\" y=\"0\" maskUnits=\"userSpaceOnUse\" style=\"mask-type:luminance;\"><path fill=\"#fff\" d=\"M0 0h20v15H0z\"></path></mask><g mask=\"url(#a)\"><mask id=\"b\" width=\"20\" height=\"15\" x=\"0\" y=\"0\" maskUnits=\"userSpaceOnUse\" style=\"mask-type:luminance;\"><path fill=\"#fff\" fill-rule=\"evenodd\" d=\"M0 0v15h20V0H0Z\" clip-rule=\"evenodd\"></path></mask><g mask=\"url(#b)\"><path fill=\"#3D58DB\" d=\"M0 5h20v5H0z\"></path><path fill=\"#F7FCFF\" fill-rule=\"evenodd\" d=\"M0 0v5h20V0H0Z\" clip-rule=\"evenodd\"></path><path fill=\"#C51918\" fill-rule=\"evenodd\" d=\"M0 10v5h20v-5H0Z\" clip-rule=\"evenodd\"></path></g></g>", 2)
+const _hoisted_4 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_4))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/static/flags/flag_uz.svg b/parent_dir/src/static/flags/flag_uz.svg
new file mode 100644
index 0000000..bde24ca
--- /dev/null
+++ b/parent_dir/src/static/flags/flag_uz.svg
@@ -0,0 +1,17 @@
+import { createElementVNode as _createElementVNode, openBlock as _openBlock, createElementBlock as _createElementBlock, createStaticVNode as _createStaticVNode } from "vue"
+
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "20",
+  height: "15",
+  fill: "none"
+}
+const _hoisted_2 = /*#__PURE__*/_createStaticVNode("<mask id=\"a\" width=\"20\" height=\"15\" x=\"0\" y=\"0\" maskUnits=\"userSpaceOnUse\" style=\"mask-type:luminance;\"><path fill=\"#fff\" d=\"M0 0h20v15H0z\"></path></mask><g mask=\"url(#a)\"><path fill=\"#14DC5A\" fill-rule=\"evenodd\" d=\"M0 10h20v5H0v-5Z\" clip-rule=\"evenodd\"></path><path fill=\"#0099B5\" fill-rule=\"evenodd\" d=\"M0 0h20v6.25H0V0Z\" clip-rule=\"evenodd\"></path><path fill=\"#F7FCFF\" stroke=\"#C51918\" stroke-width=\".938\" d=\"M-1.25 5.781h-.469V10.47H21.72V5.78H-1.25Z\"></path><path fill=\"#F7FCFF\" fill-rule=\"evenodd\" d=\"m10.455 1.5-.615.349.176-.708-.589-.52h.769l.258-.67.302.67h.655l-.515.52.248.708-.69-.348ZM7.306 3.423l.614-.348.69.348-.248-.708.514-.52h-.655l-.302-.67-.258.67h-.768l.588.52-.175.708ZM5.61 4.721l-.614.348.176-.708-.589-.52h.769l.257-.67.303.67h.655l-.515.52.247.708-.689-.348Zm2.346.002-.615.349.176-.708-.589-.52h.769l.258-.67.302.67h.655l-.515.52.248.708-.69-.349Zm2.5 0-.615.349.176-.708-.589-.52h.769l.258-.67.302.67h.655l-.515.52.248.708-.69-.349Zm-.65-1.3.614-.35.69.35-.248-.71.514-.52h-.655l-.302-.67-.258.67h-.768l.588.52-.175.71Zm2.535 1.649.615-.349.689.349-.248-.708.515-.52h-.655l-.302-.67-.258.67h-.769l.589.52-.176.708Zm.58-1.998-.615.348.175-.708-.588-.52h.768l.258-.67.302.67h.655l-.514.52.247.708-.689-.348Zm-.58-1.225.614-.348.689.348-.248-.708.515-.52h-.655l-.302-.67-.258.67h-.768l.588.52-.176.708Zm3.115 2.874-.615.349.176-.708-.589-.52h.769l.258-.67.302.67h.655l-.515.52.248.708-.69-.349Zm-.65-1.3.614-.35.69.35-.248-.71.514-.52h-.655l-.302-.67-.258.67h-.768l.588.52-.175.71Zm.649-1.922-.615.348.176-.708-.588-.52h.768l.258-.67.302.67h.655l-.515.52.248.708-.69-.348ZM3.678 5.15s-1.51-.41-1.481-1.925C2.225 1.712 3.75 1.318 3.75 1.318c-.623-.236-2.466.08-2.5 1.893-.034 1.812 1.847 2.169 2.428 1.94Z\" clip-rule=\"evenodd\"></path></g>", 2)
+const _hoisted_4 = [
+  _hoisted_2
+]
+
+export function render(_ctx, _cache) {
+  return (_openBlock(), _createElementBlock("svg", _hoisted_1, _hoisted_4))
+}
+export default { render: render }
\ No newline at end of file
diff --git a/parent_dir/src/static/messengers/messenger.svgurl b/parent_dir/src/static/messengers/messenger.svgurl
new file mode 100644
index 0000000..b826dbf
--- /dev/null
+++ b/parent_dir/src/static/messengers/messenger.svgurl
@@ -0,0 +1 @@
+export default "__VITE_ASSET__e3c7fd44__"
\ No newline at end of file
diff --git a/parent_dir/src/static/messengers/tg.svgurl b/parent_dir/src/static/messengers/tg.svgurl
new file mode 100644
index 0000000..9d36043
--- /dev/null
+++ b/parent_dir/src/static/messengers/tg.svgurl
@@ -0,0 +1 @@
+export default "__VITE_ASSET__b98466ac__"
\ No newline at end of file
diff --git a/parent_dir/src/static/messengers/vb.svgurl b/parent_dir/src/static/messengers/vb.svgurl
new file mode 100644
index 0000000..c68a3b8
--- /dev/null
+++ b/parent_dir/src/static/messengers/vb.svgurl
@@ -0,0 +1 @@
+export default "__VITE_ASSET__c3a4b9ce__"
\ No newline at end of file
diff --git a/parent_dir/src/static/messengers/vk.svgurl b/parent_dir/src/static/messengers/vk.svgurl
new file mode 100644
index 0000000..9c3b1e7
--- /dev/null
+++ b/parent_dir/src/static/messengers/vk.svgurl
@@ -0,0 +1 @@
+export default "__VITE_ASSET__d0129f82__"
\ No newline at end of file
diff --git a/parent_dir/src/static/messengers/wa.svgurl b/parent_dir/src/static/messengers/wa.svgurl
new file mode 100644
index 0000000..0df1bcb
--- /dev/null
+++ b/parent_dir/src/static/messengers/wa.svgurl
@@ -0,0 +1 @@
+export default "__VITE_ASSET__4c33807f__"
\ No newline at end of file
diff --git a/parent_dir/src/static/messengers/wa_az.svgurl b/parent_dir/src/static/messengers/wa_az.svgurl
new file mode 100644
index 0000000..b187631
--- /dev/null
+++ b/parent_dir/src/static/messengers/wa_az.svgurl
@@ -0,0 +1 @@
+export default "__VITE_ASSET__ac8cbc01__"
\ No newline at end of file
diff --git a/parent_dir/src/store/browser.js b/parent_dir/src/store/browser.js
new file mode 100644
index 0000000..96ebebf
--- /dev/null
+++ b/parent_dir/src/store/browser.js
@@ -0,0 +1,37 @@
+import { cdekConsoleError } from '#root/src/utils/console-wrapper';
+
+export const state = () => ({
+  browser: null,
+});
+
+export const mutations = {
+  update(store, payload) {
+    store.browser = payload.browser;
+  },
+};
+
+export const actions = {
+  async update({ commit }, { userAgent }) {
+    try {
+      const module = await import('bowser');
+
+      commit('update', {
+        browser: module.default.getParser(userAgent),
+      });
+    } catch (err) {
+      cdekConsoleError(err);
+    }
+  },
+};
+
+export const getters = {
+  browser: ({ browser }) => browser,
+};
+
+export const browserModule = {
+  namespaced: true,
+  state,
+  mutations,
+  actions,
+  getters,
+};
diff --git a/parent_dir/src/store/contract.js b/parent_dir/src/store/contract.js
new file mode 100644
index 0000000..34892df
--- /dev/null
+++ b/parent_dir/src/store/contract.js
@@ -0,0 +1,41 @@
+import { CONTRACT_TYPE } from '../middleware/mutation-types';
+
+export const state = () => ({
+  contract: {
+    corporate: {},
+    private: {},
+    ip: {},
+  },
+});
+
+export const mutations = {
+  [CONTRACT_TYPE.UPDATE_FORM](store, { form, type }) {
+    store.contract[type] = { ...form };
+  },
+};
+
+export const actions = {
+  async [CONTRACT_TYPE.UPDATE_FORM]({ commit }, { form, type }) {
+    commit(CONTRACT_TYPE.UPDATE_FORM, { form, type });
+  },
+};
+
+export const getters = {
+  corporateForm({ contract }) {
+    return contract.corporate;
+  },
+  privateForm({ contract }) {
+    return contract.private;
+  },
+  ip({ contract }) {
+    return contract.ip;
+  },
+};
+
+export const contractModule = {
+  namespaced: true,
+  actions,
+  getters,
+  mutations,
+  state,
+};
diff --git a/parent_dir/src/store/cookie-alert.js b/parent_dir/src/store/cookie-alert.js
new file mode 100644
index 0000000..34508c8
--- /dev/null
+++ b/parent_dir/src/store/cookie-alert.js
@@ -0,0 +1,38 @@
+export const state = () => ({
+  consentToUseOfCookies: true,
+});
+
+export const mutations = {
+  onUpdateState(store, payload) {
+    store.consentToUseOfCookies = payload.consentToUseOfCookies;
+  },
+};
+
+export const actions = {
+  init({ commit }, cookiesVal = false) {
+    commit('onUpdateState', {
+      consentToUseOfCookies: cookiesVal,
+    });
+  },
+  agreeToUseOfCookies({ commit }) {
+    commit('onUpdateState', {
+      consentToUseOfCookies: true,
+    });
+  },
+};
+
+export const getters = {
+  consentToUseOfCookies({ consentToUseOfCookies }) {
+    return consentToUseOfCookies;
+  },
+};
+
+const cookieAlertModule = {
+  namespaced: true,
+  state,
+  actions,
+  mutations,
+  getters,
+};
+
+export default cookieAlertModule;
diff --git a/parent_dir/src/store/order-create.js b/parent_dir/src/store/order-create.js
new file mode 100644
index 0000000..b3ae2cf
--- /dev/null
+++ b/parent_dir/src/store/order-create.js
@@ -0,0 +1,14 @@
+import mutations from './order-create/mutations';
+import actions from './order-create/actions';
+import getters from './order-create/getters';
+import state from './order-create/state';
+
+const OrderCreate = {
+  namespaced: true,
+  state,
+  mutations,
+  actions,
+  getters,
+};
+
+export default OrderCreate;
diff --git a/parent_dir/src/store/order-create/actions.js b/parent_dir/src/store/order-create/actions.js
new file mode 100644
index 0000000..091ef66
--- /dev/null
+++ b/parent_dir/src/store/order-create/actions.js
@@ -0,0 +1,376 @@
+import { DELIVERY_TYPES } from '@/components/NewOrder/constants';
+import {
+  getTariff,
+  isFirstTab,
+  isThirdTab,
+  displayError,
+  findTariffOtherModes,
+  findCourierTariffWithTab,
+} from '@/components/NewOrder/utils';
+import { clientAxiosErrorsHandler } from '@/utils/handleErrors/handleErrors';
+
+export default {
+  resetFull({ commit }) {
+    commit('setDefaultState');
+  },
+  async loadSizeOptions({ commit }) {
+    const result = await this.$apiClient.cabinet.getPackagingTypes();
+    commit('setSizeOptions', result.data);
+  },
+  async updateCurrencies({ commit, state, getters, rootGetters }) {
+    if (!state.direction.from) return;
+
+    try {
+      const currencies = await this.$apiClient.cabinet.getCurrenciesByCityCode(
+        state.direction.from.id,
+      );
+
+      const defaultCurrency = currencies.find(
+        // для не рф сайта устанавливаем дефолтную валюту данного сайта не смотря на валюту города отправителя.
+        // для каждого города своя валюта (привязка к стране).
+        // чтобы дать возможность пользователю сделать расчет в валюте его страны вне зависимоти от выбранных направлений.
+        (currency) =>
+          rootGetters.isRuSite
+            ? currency.default
+            : currency.shortName === getters.websiteDefaultCurrency.shortName,
+      );
+
+      commit('setCurrencies', currencies);
+      commit('setActiveCurrency', defaultCurrency);
+    } catch (e) {
+      clientAxiosErrorsHandler({ error: e, place: 'NewOrder' });
+    }
+  },
+  async estimate(
+    { dispatch, commit, state, getters },
+    { isUpdateTariff = false, withoutInsurance = false } = {},
+  ) {
+    commit('setIsRequestDirection', true);
+    commit('setIsDirectionError', false);
+
+    let senderCityId = state.direction.from.uuid;
+    let receiverCityId = state.direction.to.uuid;
+
+    try {
+      if (!senderCityId) {
+        const senderCity = await this.$apiClient.cabinet.getCityById(state.direction.from.id);
+        commit('setFrom', { ...state.direction.from, uuid: senderCity.uuid });
+        senderCityId = senderCity.uuid;
+      }
+
+      if (!receiverCityId) {
+        const receiverCity = await this.$apiClient.cabinet.getCityById(state.direction.to.id);
+        commit('setTo', { ...state.direction.to, uuid: receiverCity.uuid });
+        receiverCityId = receiverCity.uuid;
+      }
+    } catch (e) {
+      clientAxiosErrorsHandler({ error: e, place: 'NewOrder' });
+      displayError(this, e);
+      commit('setIsRequestDirection', false);
+      return;
+    }
+
+    const size = state.direction.size;
+
+    const form = {
+      payerType: state.tabForm.payer,
+      currencyMark: getters.currency.shortName,
+      senderCityId,
+      receiverCityId,
+      packages: [
+        {
+          height: size.dimension.height,
+          length: size.dimension.length,
+          width: size.dimension.width,
+          weight: size.maxWeight,
+        },
+      ],
+    };
+    try {
+      const tabs = await this.$apiClient.cabinet.getOrderTariffV2(form);
+
+      if (tabs && tabs.length > 0) {
+        commit('setTabs', tabs);
+        if (tabs.length && !isUpdateTariff) {
+          // По умолчанию таб выбран первый
+          commit('setCurrentTab', tabs[0]);
+        }
+
+        if (isUpdateTariff) {
+          await dispatch('reInitTariff', { withoutInsurance });
+        } else {
+          await dispatch('initTariff');
+        }
+      } else {
+        commit('setIsDirectionError', true);
+      }
+    } catch (e) {
+      clientAxiosErrorsHandler({ error: e, place: 'NewOrder' });
+      displayError(this, e);
+    } finally {
+      commit('setIsRequestDirection', false);
+    }
+  },
+  async initTariff({ dispatch }) {
+    await dispatch('setDefaultTariff');
+    await dispatch('loadTariffInfo');
+  },
+  reInitTariff({ dispatch }, { withoutInsurance = false } = {}) {
+    dispatch('loadTariffInfo', { withoutInsurance });
+  },
+  async loadTariffInfo(
+    { state, getters, commit, dispatch, rootGetters },
+    { withUpdateTariff = true } = {},
+  ) {
+    if (withUpdateTariff) {
+      await dispatch('updateTariff');
+    }
+
+    if (!state.currentTariff) {
+      return;
+    }
+
+    commit('setErrorAlerts', []);
+    commit('setIsRequestTariff', true);
+    const size = state.direction.size;
+
+    const form = {
+      withoutAdditionalServices: 0,
+      serviceId: state.currentTariff.serviceId,
+      mode: state.currentTariff.mode,
+      payerType: state.tabForm.payer,
+      currencyMark: getters.currency.shortName,
+      senderCityId: state.direction.from.uuid,
+      receiverCityId: state.direction.to.uuid,
+      packages: [
+        {
+          height: size.dimension.height,
+          length: size.dimension.length,
+          width: size.dimension.width,
+          weight: size.maxWeight,
+        },
+      ],
+      additionalServices: [],
+    };
+
+    try {
+      const tariffInfo = await this.$apiClient.cabinet.getTariffInfo(
+        rootGetters.isLoggedInCabinet,
+        form,
+      );
+
+      commit('setCost', {
+        totalCost: tariffInfo.totalCost,
+        deliveryPrice: tariffInfo.deliveryPrice,
+      });
+      commit('setLoyalty', tariffInfo.loyalty);
+      commit('setIsLoadTariffInfoError', false);
+    } catch (e) {
+      commit('setIsLoadTariffInfoError', true);
+
+      let isShowDisplayError = true;
+      if (e.response?.data?.alerts) {
+        commit('setErrorAlerts', e.response.data.alerts);
+
+        // Скрываем показ уведомления для ОС, так как оно выводится рядом с полем ввода
+        isShowDisplayError = !e.response.data.alerts.some((item) =>
+          item.code?.includes('insurance'),
+        );
+      }
+
+      if (isShowDisplayError) {
+        displayError(this, e);
+      }
+
+      clientAxiosErrorsHandler({ error: e, place: 'NewOrder' });
+    } finally {
+      commit('setIsRequestTariff', false);
+    }
+  },
+  setDefaultTariff({ commit, state }) {
+    const { currentTab, senderOffice, receiverOffice, tariffProfiEnabled } = state;
+    if (!currentTab) {
+      return;
+    }
+
+    const tabForm = { ...state.tabForm };
+    let tariff = null;
+
+    if (isFirstTab(currentTab)) {
+      tabForm.recipientType = DELIVERY_TYPES.OFFICE;
+      tabForm.senderType = DELIVERY_TYPES.OFFICE;
+      tabForm.optionValue = null;
+
+      tariff = getTariff({
+        tariffs: currentTab.tariffs,
+        form: tabForm,
+        senderOffice,
+        receiverOffice,
+        tariffProfiEnabled,
+      });
+      if (!tariff) {
+        // Ищем любой подходящий
+        const result = findTariffOtherModes(
+          currentTab.tariffs,
+          tabForm,
+          senderOffice,
+          receiverOffice,
+        );
+        tariff = result.currentTariff;
+        tabForm.senderType = result.senderType;
+        tabForm.recipientType = result.recipientType;
+      }
+    } else if (isThirdTab(currentTab)) {
+      tariff = getTariff({
+        tariffs: currentTab.tariffs,
+        form: tabForm,
+        senderOffice,
+        receiverOffice,
+        tariffProfiEnabled,
+      });
+
+      if (!tariff) {
+        // Ищем любой подходящий
+        const result = findTariffOtherModes(
+          currentTab.tariffs,
+          tabForm,
+          senderOffice,
+          receiverOffice,
+        );
+        tariff = result.currentTariff;
+        tabForm.senderType = result.senderType;
+        tabForm.recipientType = result.recipientType;
+      }
+
+      tabForm.optionValue = tariff?.ec4Id;
+    } else {
+      tabForm.optionValue = null;
+      tariff = getTariff({
+        tariffs: currentTab.tariffs,
+        form: tabForm,
+        senderOffice,
+        receiverOffice,
+        tariffProfiEnabled,
+      });
+      if (!tariff && tabForm.senderType === 'OFFICE' && tabForm.recipientType === 'OFFICE') {
+        // Ищем любой подходящий
+        const result = findTariffOtherModes(
+          currentTab.tariffs,
+          tabForm,
+          senderOffice,
+          receiverOffice,
+        );
+        tariff = result.currentTariff;
+        tabForm.senderType = result.senderType;
+        tabForm.recipientType = result.recipientType;
+      }
+    }
+
+    commit('setCurrentTariff', tariff);
+    commit('setTabForm', tabForm);
+  },
+  updateTariff({ state, commit, getters, dispatch }) {
+    const { currentTab, senderOffice, receiverOffice, preferredTariff } = state;
+
+    if (!currentTab) {
+      return;
+    }
+
+    if (!isFirstTab(currentTab)) {
+      if (isThirdTab(currentTab) && state.tabForm.optionValue) {
+        const currentTariff = currentTab.tariffs.find(
+          (tariff) => tariff.ec4Id === state.tabForm.optionValue,
+        );
+        commit('setCurrentTariff', currentTariff);
+      } else {
+        const tariff = getTariff({
+          tariffs: currentTab.tariffs,
+          form: state.tabForm,
+          senderOffice,
+          receiverOffice,
+          preferredTariff,
+        });
+        commit('setCurrentTariff', tariff);
+
+        if (isThirdTab(currentTab)) {
+          dispatch('updateTabForm', { optionValue: tariff.ec4Id });
+        }
+      }
+
+      return;
+    }
+
+    const tabForm = { ...state.tabForm };
+
+    if (isFirstTab(currentTab)) {
+      // Важно
+      // Для первого таба, курьерская доставка является условной
+      // Это значит, что выглядит как OFFICE-OFFICE, но появляются доп услуги:
+      // 1) Забор в городе отправителя
+      // 2) Доставка в городе получателя
+      // 3) Чистим офисы иначе столкнемся с проблемой постоматов
+      if (tabForm.recipientType === DELIVERY_TYPES.HOME && getters.isDeliveryOfCargo) {
+        tabForm.recipientType = DELIVERY_TYPES.OFFICE;
+      }
+
+      if (tabForm.senderType === DELIVERY_TYPES.HOME && getters.isPickingUpCargo) {
+        tabForm.senderType = DELIVERY_TYPES.OFFICE;
+      }
+    }
+
+    if (getters.isTariffProfiAvailable) {
+      commit(
+        'setCurrentTariff',
+        getTariff({
+          tariffs: currentTab.tariffs,
+          form: tabForm,
+          senderOffice,
+          receiverOffice,
+          tariffProfiEnabled: state.tariffProfiEnabled,
+        }),
+      );
+    } else {
+      commit(
+        'setCurrentTariff',
+        getTariff({
+          tariffs: currentTab.tariffs,
+          form: tabForm,
+          senderOffice,
+          receiverOffice,
+          preferredTariff,
+        }),
+      );
+    }
+  },
+  async initCourierTariff({ commit, dispatch, state }) {
+    if (!state.tabs || !state.tabs.length) {
+      return;
+    }
+
+    const result = findCourierTariffWithTab(state.tabs);
+
+    commit('updateIsTabClicked', true);
+
+    if (!result) {
+      // Когда не нашли нужный тариф, просто выбираем второй таб
+      const secondTab = state.tabs.find((item) => item.placing === 2);
+      if (secondTab) {
+        dispatch('initTab', secondTab);
+      }
+
+      return;
+    }
+
+    // Обновляем данные для найденного тарифа
+    commit('setCurrentTab', result.tab);
+    commit('setCurrentTariff', result.tariff);
+
+    const form = { senderType: result.senderType, recipientType: result.recipientType };
+    if (isThirdTab(result.tab)) {
+      form.optionValue = result.tariff.ec4Id;
+    }
+
+    dispatch('updateTabForm', form);
+    await dispatch('loadTariffInfo');
+  },
+};
diff --git a/parent_dir/src/store/order-create/getters.ts b/parent_dir/src/store/order-create/getters.ts
new file mode 100644
index 0000000..bbd3f2b
--- /dev/null
+++ b/parent_dir/src/store/order-create/getters.ts
@@ -0,0 +1,90 @@
+import {
+  COUNTRIES_TO,
+  COUNTRIES_FROM,
+  SUPER_EXPRESS_TARIFF_IDS,
+  PARCEL_TARIFF_ID,
+  PROFI_TARIFF_OFFICE_OFFICE_ID,
+  PROFI_TARIFF_OFFICE_POSTAMAT_ID,
+} from '@/components/NewOrder/constants';
+import { getDefaultCurrencyByWebsiteId, isFirstTab } from '@/components/NewOrder/utils';
+import { GetterTree } from 'vuex';
+import MainState from '@/types/store';
+import { CreateOrderState } from '@/types/store/createOrder';
+
+const createOrderGetters: GetterTree<CreateOrderState, MainState> = {
+  isSizeValid({ direction }) {
+    return !!direction.size;
+  },
+  isDirectionValid({ direction }, getters) {
+    return direction.from && direction.to && direction.size && getters.isSizeValid;
+  },
+  currency({ activeCurrency }, getters) {
+    return activeCurrency ?? getters.websiteDefaultCurrency;
+  },
+  websiteDefaultCurrency(state, getters, rootState, rootGetters) {
+    const currency = getDefaultCurrencyByWebsiteId(rootGetters.websiteId);
+
+    return currency ?? getters.currency;
+  },
+  isLiteOrder(state, getters) {
+    return !getters.isFullOrder;
+  },
+  isFullOrder() {
+    // на данный момент используется на всех сайтах
+    // в будущем будем добавлять исключение !rootGetters.isEnSite
+    return true;
+  },
+  isAuthOrder(state, getters, rootState, rootGetters) {
+    // Оставляем данный геттер, чтобы в коде понимать, что заказ идет в авторизованную зону
+    return rootGetters['auth/enabledLK'];
+  },
+  payersCurrency({ payerCurrencies }, getters) {
+    return payerCurrencies.find((currency) => currency.default) || getters.websiteDefaultCurrency;
+  },
+  isCurrencyRub(state, getters) {
+    return getters.currency && getters.currency.shortName === 'RUB';
+  },
+  isPayersCurrencyRub(state, getters) {
+    return getters.payersCurrency && getters.payersCurrency.shortName === 'RUB';
+  },
+  isOrderInsideRussia({ direction }) {
+    const { from, to } = direction;
+    if (from && to) {
+      return from.countryCode === 1 && to.countryCode === 1;
+    }
+
+    return false;
+  },
+
+  isGlobalLoading({ isRequestCalculate, isRequestDirection }) {
+    return isRequestCalculate || isRequestDirection;
+  },
+  isDifferentCountries({ direction }) {
+    return (
+      !COUNTRIES_FROM.includes(direction.from?.countryCode as number) ||
+      !COUNTRIES_TO.includes(direction.to?.countryCode as number)
+    );
+  },
+  isCurrentTariffParcel({ currentTariff }) {
+    return currentTariff && currentTariff.ec4Id === PARCEL_TARIFF_ID;
+  },
+  isSuperExpress({ currentTariff }) {
+    return currentTariff && SUPER_EXPRESS_TARIFF_IDS.includes(currentTariff.ec4Id);
+  },
+  isTariffProfiAvailable: (state) => {
+    return (
+      state.currentTab &&
+      isFirstTab(state.currentTab) &&
+      state.currentTab.tariffs.some((tariff) => tariff.ec4Id === PROFI_TARIFF_OFFICE_OFFICE_ID)
+    );
+  },
+  isTariffProfiToPostamatAvailable: (state) => {
+    return (
+      state.currentTab &&
+      isFirstTab(state.currentTab) &&
+      state.currentTab.tariffs.some((tariff) => tariff.ec4Id === PROFI_TARIFF_OFFICE_POSTAMAT_ID)
+    );
+  },
+};
+
+export default createOrderGetters;
diff --git a/parent_dir/src/store/order-create/mutations.ts b/parent_dir/src/store/order-create/mutations.ts
new file mode 100644
index 0000000..332b31f
--- /dev/null
+++ b/parent_dir/src/store/order-create/mutations.ts
@@ -0,0 +1,89 @@
+import { MutationTree } from 'vuex';
+import { CreateOrderErrorAlerts, CreateOrderState } from '@/types/store/createOrder';
+import initialState from './state';
+
+const createOrderMutations: MutationTree<CreateOrderState> = {
+  setDefaultState(state) {
+    const newState = initialState();
+    Object.keys(newState).forEach((k) => {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      state[k] = newState[k];
+    });
+  },
+  setIsRequestDirection(state, payload) {
+    state.isRequestDirection = !!payload;
+  },
+  setIsRequestTariff(state, payload) {
+    state.isRequestTariff = !!payload;
+  },
+  setFrom(state, payload) {
+    state.direction.from = 'fullName' in (payload ?? {}) ? payload : null;
+  },
+  setTo(state, payload) {
+    state.direction.to = 'fullName' in (payload ?? {}) ? payload : null;
+  },
+  setSize(state, payload) {
+    if (payload) {
+      payload.dimension.height = Number(payload.dimension.height);
+      payload.dimension.width = Number(payload.dimension.width);
+      payload.dimension.length = Number(payload.dimension.length);
+      payload.maxWeight = Number(payload.maxWeight);
+      state.direction.size = payload;
+    } else {
+      state.direction.size = null;
+    }
+  },
+  setSizeOptions(state, payload) {
+    state.sizeOptions = payload;
+  },
+  setCurrencies(state, payload) {
+    state.currencies = payload;
+  },
+  setPayerCurrencies(state, payload) {
+    state.payerCurrencies = payload;
+  },
+  setActiveCurrency(state, payload) {
+    state.activeCurrency = payload;
+  },
+  setTabs(state, payload) {
+    state.tabs = payload;
+  },
+  setCurrentTab(state, payload) {
+    state.currentTab = payload;
+  },
+  setCurrentTariff(state, payload) {
+    state.currentTariff = payload;
+  },
+  setTabForm(state, payload) {
+    state.tabForm = payload;
+  },
+  setCost(state, { totalCost, deliveryPrice }) {
+    state.totalCost = totalCost;
+
+    if (deliveryPrice) {
+      state.deliveryPrice = deliveryPrice;
+    }
+  },
+  setLoyalty(state, payload) {
+    state.loyalty = payload;
+  },
+  replaceState(state, newState) {
+    Object.keys(newState).forEach((k) => {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      state[k] = newState[k];
+    });
+  },
+  setIsLoadTariffInfoError(state, payload = true) {
+    state.isLoadTariffInfoError = payload;
+  },
+  setIsDirectionError(state, payload = true) {
+    state.isDirectionError = payload;
+  },
+  setErrorAlerts(state, payload: CreateOrderErrorAlerts[]) {
+    state.errorAlerts = payload;
+  },
+};
+
+export default createOrderMutations;
diff --git a/parent_dir/src/store/order-create/state.ts b/parent_dir/src/store/order-create/state.ts
new file mode 100644
index 0000000..b061460
--- /dev/null
+++ b/parent_dir/src/store/order-create/state.ts
@@ -0,0 +1,39 @@
+import { CLIENT_TYPE_SENDER, DELIVERY_TYPES } from '@/components/NewOrder/constants';
+import { CreateOrderState } from '@/types/store/createOrder';
+
+const initialState = (): CreateOrderState => ({
+  isRequestDirection: false,
+  isRequestCalculate: false,
+  isRequestTariff: false,
+  sizeOptions: [],
+  direction: {
+    from: null,
+    to: null,
+    size: null,
+  },
+  currencies: [],
+  payerCurrencies: [],
+  activeCurrency: null,
+  tabs: [],
+  currentTab: null,
+  currentTariff: null,
+  errorAlerts: [],
+  tabForm: {
+    payer: CLIENT_TYPE_SENDER,
+    recipientType: DELIVERY_TYPES.OFFICE,
+    senderType: DELIVERY_TYPES.OFFICE,
+    optionValue: null,
+  },
+  loyalty: {
+    totalPrice: null,
+    willBeEarnedPoints: null,
+    availableForCurrentOrderPoints: null,
+  },
+  totalCost: null,
+  deliveryPrice: null,
+  isLoadTariffInfoError: false,
+  isDirectionError: false,
+  isTabClicked: false,
+});
+
+export default initialState;
diff --git a/parent_dir/src/store/passport-form.js b/parent_dir/src/store/passport-form.js
new file mode 100644
index 0000000..dd201e6
--- /dev/null
+++ b/parent_dir/src/store/passport-form.js
@@ -0,0 +1,181 @@
+import {
+  CITIZENSHIP_ID_MAP,
+  DOCUMENTS_TYPES,
+  PASSPORT_LOADING_STATUSES,
+  PASSPORT_PAGE_STEPS,
+} from '@/constants/passport-v2';
+
+const defaultState = () => ({
+  pageStep: PASSPORT_PAGE_STEPS.CODE,
+  // по linkCode будет определяться флоу, если он есть
+  // то значит мы на странице с гет-параметром, если его нет
+  // то мы используем токены
+  linkCode: '',
+  // серьезность проверки, 1 раз проверяем строго, последующие слабо
+  severity: false,
+  citizenship: null,
+  otherCitizenshipIsoCode: null,
+  formData: {},
+  documentType: DOCUMENTS_TYPES.PASSPORT,
+  destinationCountryCode: null,
+  operationId: null,
+  orderNumber: null,
+  scanRequired: null,
+  files: [],
+  sendFilesStatus: '',
+  sendFormStatus: '',
+  sendFilesErrors: [],
+  sendFormErrors: [],
+  personUuid: '',
+});
+
+export const state = () => defaultState();
+
+export const mutations = {
+  setLinkCode(state, code) {
+    state.linkCode = code;
+  },
+  turnOffSeverity(state) {
+    state.severity = true;
+  },
+  setPageStep(state, payload) {
+    state.pageStep = payload;
+  },
+  setDocumentType(state, payload) {
+    state.documentType = payload;
+  },
+  setCitizenship(state, payload) {
+    state.citizenship = payload;
+  },
+  setOtherCitizenshipIsoCode(state, code) {
+    state.otherCitizenshipIsoCode = code;
+  },
+  updateFormData(state, payload) {
+    state.formData = { ...state.formData, ...payload };
+  },
+  putFile(state, payload) {
+    state.files[payload.fileNumber] = payload.file;
+  },
+  removeFile(state, id) {
+    state.files = state.files.map((f) => {
+      if (f.id === id) {
+        return {};
+      }
+      return f;
+    });
+  },
+  clearFiles(state) {
+    state.files = [];
+  },
+  setOperationId(state, id) {
+    state.operationId = id;
+  },
+  setDestinationCountryCode(state, code) {
+    state.destinationCountryCode = code;
+  },
+  updateSendFilesStatus(state, status) {
+    state.sendFilesStatus = status;
+  },
+  updateSendFilesErrors(state, errors) {
+    state.sendFilesErrors = errors;
+  },
+  updateSendFormStatus(state, status) {
+    state.sendFormStatus = status;
+  },
+  updateSendFormErrors(state, errors) {
+    state.sendFormErrors = errors;
+  },
+  resetFormState(state) {
+    const newState = defaultState();
+    state.pageStep = newState.pageStep;
+    state.linkCode = newState.linkCode;
+    state.citizenship = newState.citizenship;
+    state.otherCitizenshipIsoCode = newState.otherCitizenshipIsoCode;
+    state.formData = newState.formData;
+    state.documentType = newState.documentType;
+    state.destinationCountryCode = newState.destinationCountryCode;
+    state.operationId = newState.operationId;
+    state.orderNumber = newState.orderNumber;
+    state.scanRequired = newState.scanRequired;
+    state.files = newState.files;
+    state.sendFilesStatus = newState.sendFilesStatus;
+    state.sendFormStatus = newState.sendFormStatus;
+    state.sendFormErrors = newState.sendFormErrors;
+    state.personUuid = newState.personUuid;
+  },
+  resetFormData(state) {
+    const newState = defaultState();
+    state.citizenship = newState.citizenship;
+    state.otherCitizenshipIsoCode = newState.otherCitizenshipIsoCode;
+    state.formData = newState.formData;
+    state.documentType = newState.documentType;
+    state.files = newState.files;
+    state.sendFilesStatus = newState.sendFilesStatus;
+    state.sendFormStatus = newState.sendFormStatus;
+    state.sendFormErrors = newState.sendFormErrors;
+    state.personUuid = newState.personUuid;
+  },
+  setPersonUuid(state, payload) {
+    state.personUuid = payload;
+  },
+};
+
+export const actions = {
+  setLinkCode({ commit, state }, code) {
+    if (state.linkCode !== code) {
+      commit('resetFormState');
+    }
+    commit('setLinkCode', code);
+  },
+  updateSendFilesStatus({ commit }, status) {
+    if (status === PASSPORT_LOADING_STATUSES.SUCCESS) {
+      commit('setPageStep', PASSPORT_PAGE_STEPS.FORM_UPLOAD_FILES);
+    } else {
+      commit('setPageStep', PASSPORT_PAGE_STEPS.FORM_SEND_FILES);
+    }
+    commit('updateSendFilesStatus', status);
+  },
+  updateSendFormStatus({ commit }, status) {
+    commit('setPageStep', PASSPORT_PAGE_STEPS.FORM_SEND_FORM);
+    commit('updateSendFormStatus', status);
+  },
+};
+
+export const getters = {
+  pageStep: ({ pageStep }) => pageStep,
+  documentType: ({ documentType }) => documentType,
+  citizenship: ({ citizenship }) => citizenship,
+  otherCitizenshipIsoCode: ({ otherCitizenshipIsoCode }) => otherCitizenshipIsoCode,
+  destinationCountryCode: ({ destinationCountryCode }) => destinationCountryCode,
+  formData: ({ formData }) => formData,
+  files: ({ files }) => files,
+  operationId: ({ operationId }) => operationId,
+  sendFilesStatus: ({ sendFilesStatus }) => sendFilesStatus,
+  sendFormStatus: ({ sendFormStatus }) => sendFormStatus,
+  sendFilesErrors: ({ sendFilesErrors }) => sendFilesErrors,
+  sendFormErrors: ({ sendFormErrors }) => sendFormErrors,
+  isPassport: ({ documentType }) => documentType === DOCUMENTS_TYPES.PASSPORT,
+  isIdCard: ({ documentType }) => documentType === DOCUMENTS_TYPES.ID_CARD,
+  isOtherDocument: ({ documentType }) => documentType === DOCUMENTS_TYPES.OTHER,
+  isRuCitizenship: ({ citizenship }) => citizenship === CITIZENSHIP_ID_MAP.RU,
+  isKzCitizenship: ({ citizenship }) => citizenship === CITIZENSHIP_ID_MAP.KZ,
+  isKgCitizenship: ({ citizenship }) => citizenship === CITIZENSHIP_ID_MAP.KG,
+  isByCitizenship: ({ citizenship }) => citizenship === CITIZENSHIP_ID_MAP.BY,
+  isUzCitizenship: ({ citizenship }) => citizenship === CITIZENSHIP_ID_MAP.UZ,
+  isAMCitizenship: ({ citizenship }) => citizenship === CITIZENSHIP_ID_MAP.AM,
+  isGECitizenship: ({ citizenship }) => citizenship === CITIZENSHIP_ID_MAP.GE,
+  isAZCitizenship: ({ citizenship }) => citizenship === CITIZENSHIP_ID_MAP.AZ,
+  isILCitizenship: ({ citizenship }) => citizenship === CITIZENSHIP_ID_MAP.IL,
+  isOtherCitizenship: ({ citizenship }) => citizenship === CITIZENSHIP_ID_MAP.OTHER,
+  linkCode: ({ linkCode }) => linkCode,
+  severity: ({ severity }) => severity,
+  personUuid: ({ personUuid }) => personUuid,
+};
+
+export const passportFormModule = {
+  namespaced: true,
+  actions,
+  getters,
+  mutations,
+  state,
+};
diff --git a/parent_dir/src/store/pinia/menu/helpers.ts b/parent_dir/src/store/pinia/menu/helpers.ts
new file mode 100644
index 0000000..25c94fb
--- /dev/null
+++ b/parent_dir/src/store/pinia/menu/helpers.ts
@@ -0,0 +1,24 @@
+import IMenuItem from '@/types/dto/menuItem';
+import { CABINET_CALCULATE } from '@/components/NewOrder/constants';
+
+export const changeSiteUrls = (node: IMenuItem, locale = 'ru') => {
+  const newNode = { ...node };
+
+  if (newNode.url.endsWith('tracking/')) {
+    newNode.url = `/${locale}/cabinet/orders`;
+    newNode.isExternal = true;
+  } else if (newNode.url.endsWith('cdekid/') || newNode.title === 'CDEK ID') {
+    newNode.url = `/${locale}/cabinet/cdekid`;
+    newNode.isExternal = true;
+  } else if (newNode.url.endsWith(`calculate/`) || newNode.url.endsWith('courier/')) {
+    newNode.url = `/${locale}${CABINET_CALCULATE}`;
+    newNode.isExternal = true;
+  }
+
+  if (!(newNode.children && newNode.children.length)) {
+    return newNode;
+  }
+
+  newNode.children = newNode.children.map((el) => changeSiteUrls(el));
+  return newNode;
+};
diff --git a/parent_dir/src/store/pinia/menu/menu.ts b/parent_dir/src/store/pinia/menu/menu.ts
new file mode 100644
index 0000000..124bd13
--- /dev/null
+++ b/parent_dir/src/store/pinia/menu/menu.ts
@@ -0,0 +1,118 @@
+import { defineStore } from 'pinia';
+import IMenuItem from '@/types/dto/menuItem';
+import { changeSiteUrls } from '@/store/pinia/menu/helpers';
+
+interface IMenuStore {
+  isMobileMenuOpen: boolean;
+  enabledLoginBtn: boolean;
+  menu: IMenuItem[];
+  activeMenu?: IMenuItem | null;
+  isUserMenuOpen: boolean;
+  stateMenuParcel: string;
+  showPanelToMenu: boolean;
+}
+
+export const useMenuStore = defineStore('menu', {
+  state: (): IMenuStore => {
+    return {
+      isMobileMenuOpen: false,
+      menu: [],
+      activeMenu: null,
+      enabledLoginBtn: true,
+      isUserMenuOpen: false,
+      stateMenuParcel: 'SHOW',
+      showPanelToMenu: false,
+    };
+  },
+  getters: {
+    menus({ menu }) {
+      return menu;
+    },
+    individualsSubmenu({ menu }) {
+      return (menu && menu[0] && menu[0].children) || [];
+    },
+    activePath({ menu, activeMenu }) {
+      if (!activeMenu) {
+        return [];
+      }
+
+      const findActivePath = (o: IMenuItem) => {
+        if (o.id === activeMenu?.id) return [o];
+
+        if (!o.children) return [];
+
+        let curEl: IMenuItem[] | undefined;
+        o.children.find((x) => (curEl = findActivePath(x)));
+
+        if (curEl && curEl.length) {
+          return [o, ...curEl];
+        }
+
+        return undefined;
+      };
+
+      return menu.map((el) => findActivePath(el)).find((el) => !!el) || [];
+    },
+  },
+  actions: {
+    setMenu(payload: IMenuItem[]) {
+      this.menu = payload;
+    },
+    setMobileMenu(payload: boolean) {
+      this.isMobileMenuOpen = payload;
+    },
+    setActiveMenu(payload: IMenuItem) {
+      this.activeMenu = { ...payload };
+    },
+    setStatusLoginBtn(payload: boolean) {
+      this.enabledLoginBtn = payload;
+    },
+    updateStateMenu(payload: { state: string }) {
+      this.stateMenuParcel = payload.state;
+    },
+    updateStateShowPanelToMenu(payload: { showPanelToMenu: boolean }) {
+      this.showPanelToMenu = payload.showPanelToMenu;
+    },
+    setUserMenuOpen(payload: boolean) {
+      this.isUserMenuOpen = payload;
+    },
+    updateActiveMenuByUrl(url: string) {
+      const localeRegex = /^(\/\w\w\/|\/)/;
+      const urlToFindWithoutLocale = url.replace(localeRegex, '');
+
+      const findMenuItemByUrl = (o: IMenuItem): IMenuItem | undefined => {
+        if (!o.url) {
+          return;
+        }
+
+        const currentUrlWithoutLocale = o.url.replace(localeRegex, '');
+
+        if (urlToFindWithoutLocale === currentUrlWithoutLocale) return o;
+
+        if (!o.children) return;
+
+        return o.children.find((x) => findMenuItemByUrl(x));
+      };
+
+      const menuItemsByUrl = this.menu.map((el: IMenuItem) => findMenuItemByUrl(el));
+
+      const active = menuItemsByUrl?.find((el) => !!el);
+
+      if (active) {
+        this.setActiveMenu(active);
+      } else {
+        this.setActiveMenu(this.menu[0]);
+      }
+    },
+    openMobileMenu() {
+      this.setMobileMenu(true);
+    },
+    closeMobileMenu() {
+      this.setMobileMenu(false);
+    },
+    updateMenuForAuthorized(locale: string) {
+      const newMenu = this.menu.map((item) => changeSiteUrls(item, locale));
+      this.setMenu(newMenu);
+    },
+  },
+});
diff --git a/parent_dir/src/store/vuex-store/index.ts b/parent_dir/src/store/vuex-store/index.ts
new file mode 100644
index 0000000..fff454c
--- /dev/null
+++ b/parent_dir/src/store/vuex-store/index.ts
@@ -0,0 +1,70 @@
+import { createStore, StoreOptions } from 'vuex';
+import { resizeModule } from '#root/src/store/vuex-store/modules/resizeModule';
+import {
+  indexActions,
+  indexGetters,
+  indexMutations,
+  indexState,
+} from '#root/src/store/vuex-store/modules/indexModule';
+import VuexPersistence from 'vuex-persist';
+import { cabinetModule } from '@/store/vuex-store/modules/cabinetModule';
+import { footerModule } from '@/store/vuex-store/modules/footerModule';
+import { keycloakModule } from '@/store/vuex-store/modules/keycloakModule';
+import OrderCreate from '@/store/order-create';
+import { browserModule } from '@/store/browser';
+import { contractModule } from '@/store/contract';
+import { passportFormModule } from '@/store/passport-form';
+import { loyaltyModule } from '@/store/vuex-store/modules/loyaltyModule';
+import { trackingModule } from './modules/trackingModule';
+import MainState from '../../types/store';
+import { loaderModule } from './modules/loaderModule';
+import { flomniModule } from './modules/flomniModule';
+import cookieAlertModule from '../cookie-alert';
+import { authModule } from './modules/authModule';
+
+function createVuexStore(runsOnClient: boolean) {
+  if (!runsOnClient && global.cdekStore) {
+    return global.cdekStore;
+  }
+
+  const defaultStoreData: StoreOptions<MainState> = {
+    state: indexState,
+    actions: indexActions,
+    mutations: indexMutations,
+    getters: indexGetters,
+    modules: {
+      loader: loaderModule,
+      resize: resizeModule,
+      cabinet: cabinetModule,
+      footer: footerModule,
+      flomni: flomniModule,
+      keycloak: keycloakModule,
+      'order-create': OrderCreate,
+      'cookie-alert': cookieAlertModule,
+      tracking: trackingModule,
+      browser: browserModule,
+      contract: contractModule,
+      'passport-form': passportFormModule,
+      loyalty: loyaltyModule,
+      auth: authModule,
+    },
+  };
+
+  if (runsOnClient) {
+    const vuexLocal = new VuexPersistence<MainState>({
+      storage: window.localStorage,
+      modules: ['keycloak'],
+    });
+
+    defaultStoreData.plugins = [vuexLocal.plugin];
+  }
+  const vuexStore = createStore<MainState>(defaultStoreData);
+
+  if (!runsOnClient) {
+    global.cdekStore = vuexStore;
+  }
+
+  return vuexStore;
+}
+
+export { createVuexStore };
diff --git a/parent_dir/src/store/vuex-store/modules/authModule.ts b/parent_dir/src/store/vuex-store/modules/authModule.ts
new file mode 100644
index 0000000..2a68101
--- /dev/null
+++ b/parent_dir/src/store/vuex-store/modules/authModule.ts
@@ -0,0 +1,76 @@
+import { ActionTree, GetterTree, Module, MutationTree } from 'vuex';
+import MainState from '@/types/store';
+import { AuthState } from '@/types/store/auth';
+
+const initialKeycloak = (): AuthState => ({
+  impersonation: null,
+});
+
+const state = (): AuthState => initialKeycloak();
+const mutations: MutationTree<AuthState> = {
+  setImpersonation(state, payload) {
+    state.impersonation = payload;
+  },
+};
+
+const actions: ActionTree<AuthState, MainState> = {
+  removeImpersonation({ dispatch, commit, rootGetters }, alsoLogoutFromCabinet = false) {
+    commit('setImpersonation', null);
+
+    if (alsoLogoutFromCabinet) {
+      dispatch('cabinet/logoutFromCabinet', null, { root: true }).then(() => {
+        if (window.location.pathname.match(/^\/[a-z]{2}\/cabinet\//)) {
+          // Редирект на страницу авторизации (/ru/login)
+          let redirect = window.location.pathname + window.location.search + window.location.hash;
+          // в base64 чтобы нормальная строка была в гет параметре
+          redirect = btoa(redirect);
+
+          const url = new URL(window.location.origin);
+          url.pathname = `/${rootGetters.currentLocaleISO}/cabinet/auth`;
+          url.searchParams.set('redirect', redirect);
+
+          window.location.replace(url.href);
+          return;
+        }
+
+        window.location.pathname = `/${rootGetters.currentLocaleISO}/`;
+      });
+    }
+  },
+};
+
+const getters: GetterTree<AuthState, MainState> = {
+  getImpersonation(state) {
+    return state.impersonation;
+  },
+  getImpersonationToken(state) {
+    return state.impersonation?._t;
+  },
+  isImpersonationTokenExpired(state) {
+    return () => {
+      const et = state.impersonation?._et;
+      if (!et) {
+        return true;
+      }
+
+      const nowTS = Math.round(new Date().getTime() / 1000);
+      // TODO: fix type et
+      const accessTokenExpiredAtTS = Math.round(new Date(`${et}`).getTime() / 1000) - 10;
+
+      return accessTokenExpiredAtTS < nowTS;
+    };
+  },
+  enabledLK() {
+    // на данный момент используется на всех сайтах
+    // в будущем будем добавлять исключение !rootGetters.isEnSite
+    return true;
+  },
+};
+
+export const authModule: Module<AuthState, MainState> = {
+  namespaced: true,
+  getters,
+  state,
+  mutations,
+  actions,
+};
diff --git a/parent_dir/src/store/vuex-store/modules/cabinetModule/cabinetModuleActions.ts b/parent_dir/src/store/vuex-store/modules/cabinetModule/cabinetModuleActions.ts
new file mode 100644
index 0000000..10cbe76
--- /dev/null
+++ b/parent_dir/src/store/vuex-store/modules/cabinetModule/cabinetModuleActions.ts
@@ -0,0 +1,68 @@
+import { ActionTree } from 'vuex';
+import { CabinetState } from '@/types/store/cabinet';
+import MainState from '@/types/store';
+import { initialCabinet } from '@/store/vuex-store/modules/cabinetModule/cabinetModuleState';
+import { setItemLS } from '@/utils/local-storage.utils';
+
+const cabinetModuleActions: ActionTree<CabinetState, MainState> = {
+  removeMetrics({ commit }) {
+    commit('setStartCreateOrderAtBox', false);
+    commit('setStartCreateOrderAtSite', false);
+  },
+  logoutFromCabinet(store) {
+    store.commit('setIsStateLogout');
+
+    store.commit('keycloak/resetKeycloak', {}, { root: true });
+    store.commit('resetState');
+    store.commit('setLoginPhone', null);
+    store.commit('resetTracking');
+    store.commit('setOrdersHasUpdates', false);
+    store.commit('setUser', { ...initialCabinet().user });
+    // Удалил ручную чистку, так как весь стор хранится в ls и можно очистить его
+    // После логаута страницу всегда перезагружаем
+    setTimeout(() => {
+      // Если не в следующем макростаске, то стор перезапишется
+      localStorage.clear();
+    });
+  },
+  setTracking({ commit }, payload) {
+    commit('recordTrackingData', payload);
+  },
+  setStartCreateOrderAtSite({ commit }, payload) {
+    commit('setStartCreateOrderAtSite', payload);
+  },
+  updateOrderAfterCheckPhone({ commit }, payload) {
+    commit('updateAvailableTime', {
+      orderNumber: payload.orderNumber,
+      availableTimeForDelivery: payload.availableTimeForDelivery,
+    });
+    commit('updateReceiverAddress', {
+      orderNumber: payload.orderNumber,
+      receiverAddress: payload.receiverAddress,
+    });
+  },
+  setIsRedirectedFromSite({ commit }, payload) {
+    commit('setIsRedirectedFromSite', payload);
+  },
+  setIsChangeOrder({ commit }, payload) {
+    commit('setIsChangeOrder', payload);
+  },
+  tabVisibilityChange({ dispatch, rootGetters }) {
+    if (
+      rootGetters['auth/getImpersonationToken'] &&
+      rootGetters['auth/isImpersonationTokenExpired']()
+    ) {
+      dispatch('auth/removeImpersonation', true, { root: true });
+    }
+  },
+  setIsHideOrderCreditBtn({ commit }, payload) {
+    if (payload) {
+      setItemLS('is-hide-order-credit-btn', 'true');
+    } else {
+      setItemLS('is-hide-order-credit-btn', 'false');
+    }
+
+    commit('setIsHideOrderCreditBtn', payload);
+  },
+};
+export default cabinetModuleActions;
diff --git a/parent_dir/src/store/vuex-store/modules/cabinetModule/cabinetModuleGetters.ts b/parent_dir/src/store/vuex-store/modules/cabinetModule/cabinetModuleGetters.ts
new file mode 100644
index 0000000..b0e168a
--- /dev/null
+++ b/parent_dir/src/store/vuex-store/modules/cabinetModule/cabinetModuleGetters.ts
@@ -0,0 +1,91 @@
+import { GetterTree } from 'vuex';
+import { CabinetState } from '@/types/store/cabinet';
+import MainState from '@/types/store';
+import { initialCabinet } from '@/store/vuex-store/modules/cabinetModule/cabinetModuleState';
+
+const cabinetModuleGetters: GetterTree<CabinetState, MainState> = {
+  ordersHasUpdates: (state) => state.ordersHasUpdates,
+  fullName(state) {
+    if (state.user?.profile && (state.user.profile.firstName || state.user.profile.surName)) {
+      const { firstName, surName } = state.user.profile;
+      return [firstName, surName].filter(Boolean).join(' ');
+    }
+
+    return '';
+  },
+  isActiveCdekId(state) {
+    return state.user.contragent?.cdekId;
+  },
+  getLoginPhone(state) {
+    return state.login_phone;
+  },
+  getLoginPhoneLastDigits(state) {
+    if (!state.login_phone) {
+      return '';
+    }
+
+    return state.login_phone.substr(8);
+  },
+  trackId({ tracking }) {
+    return tracking.trackId;
+  },
+  tracking({ tracking }) {
+    return tracking.trackInfo;
+  },
+  getUser(state) {
+    return state.user;
+  },
+  getUserProfile(state) {
+    if (!state.user) {
+      return initialCabinet().user.profile;
+    }
+
+    return state.user.profile;
+  },
+  getUserInn(state) {
+    return state.user.profile.inn;
+  },
+  getUserEmail(state) {
+    return state.user.profile?.email;
+  },
+  isUserEmailConfirmed(state) {
+    return state.user.profile?.is_email_confirmed;
+  },
+  getLastDateUserLoaded: ({ lastDateUserLoaded }) => lastDateUserLoaded,
+  getStartCreateOrderAtSite(state) {
+    return state.startCreateOrderAtSite;
+  },
+
+  getStartCreateOrderAtBox: (state) => state.startCreateOrderAtBox,
+  // order
+
+  getTrackingHistory({ tracking }) {
+    return tracking.trackingHistory;
+  },
+  getOrderFromTrackingHistory(state, orderNumber) {
+    if (!state.tracking.trackingHistory) {
+      return [];
+    }
+    return state.tracking.trackingHistory.filter((o) => o.orderNumber === orderNumber);
+  },
+  getLoadingTrackingHistory({ tracking }) {
+    return tracking.loadingTrackingHistory;
+  },
+  getIsRedirectedFromSite({ isRedirectedFromSiteOrderCreate }) {
+    return isRedirectedFromSiteOrderCreate;
+  },
+
+  // cdekid
+
+  getRedirectedFromSiteCdekid({ redirectedFromSiteCdekid }) {
+    return redirectedFromSiteCdekid;
+  },
+  hiddenAlerts({ hiddenAlerts }) {
+    return hiddenAlerts;
+  },
+  isChangeOrder: ({ isChangeOrder }) => isChangeOrder,
+  isHideOrderCreditBtn: ({ isHideOrderCreditBtn }) => isHideOrderCreditBtn,
+  isStateLogout: ({ isStateLogout }) => isStateLogout,
+  isStateLoginProcessing: ({ isStateLoginProcessing }) => isStateLoginProcessing,
+};
+export default cabinetModuleGetters;
diff --git a/parent_dir/src/store/vuex-store/modules/cabinetModule/cabinetModuleMutations.ts b/parent_dir/src/store/vuex-store/modules/cabinetModule/cabinetModuleMutations.ts
new file mode 100644
index 0000000..7d4c26f
--- /dev/null
+++ b/parent_dir/src/store/vuex-store/modules/cabinetModule/cabinetModuleMutations.ts
@@ -0,0 +1,211 @@
+import { MutationTree } from 'vuex';
+import { CabinetState } from '@/types/store/cabinet';
+import {
+  getEmptyTracking,
+  initialCabinet,
+} from '@/store/vuex-store/modules/cabinetModule/cabinetModuleState';
+
+const cabinetModuleMutations: MutationTree<CabinetState> = {
+  /**
+   * @param {Object} state
+   * @param {String} payload
+   */
+  setLoginPhone(state, payload) {
+    state.login_phone = payload;
+  },
+
+  updateRedirectedFromSiteCdekid(state, payload) {
+    state.redirectedFromSiteCdekid = payload;
+  },
+
+  updateTrackId(state, payload) {
+    state.tracking.trackId = payload.trackId;
+  },
+
+  recordTrackingData(state, payload) {
+    state.tracking.trackInfo = payload;
+  },
+
+  resetState(state) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    state = { ...initialCabinet(), ...{ isStateLogout: true } };
+  },
+
+  setUser(state, value) {
+    state.user = value;
+  },
+
+  touchLastDateIfUserLoaded(state) {
+    state.lastDateUserLoaded = new Date();
+  },
+  setUserProfile(state, value) {
+    state.user = { ...state.user, profile: value };
+  },
+
+  setUserContragent(state, value) {
+    state.user = { ...state.user, contragent: value };
+  },
+
+  setUserContragentUUID(state, value) {
+    state.user = { ...state.user, contragent_uuid: value };
+  },
+  updateUserInn(state, value) {
+    state.user.profile.inn = value;
+  },
+  setUserEmail(state, payload: string) {
+    state.user.profile.email = payload;
+    state.user.profile.is_email_confirmed = false;
+  },
+  setUserEmailConfirmed(state, payload = true) {
+    state.user.profile.is_email_confirmed = payload;
+  },
+  setTrackingHistory(state, payload) {
+    // TODO: SET TYPE INSTEAD OF ANY.
+    state.tracking.trackingHistory = payload.map((o: any) => {
+      o.cashOnDeliveryIndividual = o.cash_on_delivery_individual
+        ? o.cash_on_delivery_individual.cost
+        : 0;
+
+      return o;
+    });
+  },
+  addOrderCashOnDeliveryStatus(state, payload) {
+    if (!state.tracking.trackingHistory) {
+      return;
+    }
+
+    state.tracking.trackingHistory = state.tracking.trackingHistory.map((o) => {
+      if (o.orderNumber === payload.orderNumber) {
+        return { ...o, cashOnDeliveryStatus: { ...payload } };
+      }
+      return o;
+    });
+  },
+  addOrderDetails(state, payload) {
+    if (!state.tracking.trackingHistory) {
+      return;
+    }
+    state.tracking.trackingHistory = state.tracking.trackingHistory.map((o) => {
+      if (o.orderNumber === payload.orderNumber) {
+        return { ...payload.order, detailsState: o.detailsState };
+      }
+      return o;
+    });
+  },
+  updateOrderDetails(state, payload) {
+    if (!state.tracking.trackingHistory) {
+      return;
+    }
+
+    state.tracking.trackingHistory = state.tracking.trackingHistory.map((t) => {
+      if (t.orderNumber === payload.orderNumber) {
+        return { ...payload.order };
+      }
+      return t;
+    });
+  },
+  showFullOrderInfo(state, { orderNumber, fullOrderDetails = null }) {
+    if (!state.tracking.trackingHistory) {
+      return;
+    }
+
+    state.tracking.trackingHistory = state.tracking.trackingHistory.map((t) => {
+      if (t.orderNumber === orderNumber) {
+        return { ...t, fullOrderDetails, showFullDetails: !t.showFullDetails };
+      }
+      return t;
+    });
+  },
+  changeOrderDetailsState(state, payload) {
+    if (!state.tracking.trackingHistory) {
+      return;
+    }
+
+    state.tracking.trackingHistory = state.tracking.trackingHistory.map((t) => {
+      if (t.orderNumber === payload.orderNumber) {
+        return { ...t, detailsState: payload.detailsState };
+      }
+      return t;
+    });
+  },
+  updateAvailableTime(state, payload) {
+    if (!state.tracking.trackingHistory) {
+      return;
+    }
+
+    state.tracking.trackingHistory = state.tracking.trackingHistory.map((t) => {
+      if (t.orderNumber === payload.orderNumber) {
+        return {
+          ...t,
+          availableTimeForDelivery: payload.availableTimeForDelivery,
+        };
+      }
+      return t;
+    });
+  },
+  updateReceiverAddress(state, payload) {
+    if (!state.tracking.trackingHistory) {
+      return;
+    }
+
+    state.tracking.trackingHistory = state.tracking.trackingHistory.map((t) => {
+      if (t.orderNumber === payload.orderNumber) {
+        return { ...t, receiverAddress: payload.receiverAddress };
+      }
+      return t;
+    });
+  },
+  updateCanBeChanged(state, payload) {
+    if (!state.tracking.trackingHistory) {
+      return;
+    }
+
+    state.tracking.trackingHistory = state.tracking.trackingHistory.map((t) => {
+      if (t.orderNumber === payload.orderNumber) {
+        return { ...t, canBeChanged: payload.canBeChanged };
+      }
+      return t;
+    });
+  },
+  resetTracking(state) {
+    state.tracking = getEmptyTracking();
+  },
+  setCdekidStatus(state, value) {
+    state.user = { ...state.user, cdekid_status: value };
+  },
+  setStartCreateOrderAtSite(state, value) {
+    state.startCreateOrderAtSite = value;
+  },
+  setStartCreateOrderAtBox(state, value) {
+    state.startCreateOrderAtBox = value;
+  },
+  setIsRedirectedFromSite(state, payload) {
+    state.isRedirectedFromSiteOrderCreate = payload;
+  },
+  setOrdersHasUpdates(state, payload) {
+    state.ordersHasUpdates = payload;
+  },
+  updateHiddenAlerts(state, payload) {
+    const newValue = [...state.hiddenAlerts, payload];
+    state.hiddenAlerts = [...new Set(newValue)];
+  },
+  setIsChangeOrder(state, payload) {
+    state.isChangeOrder = payload;
+  },
+  setIsHideOrderCreditBtn(state, payload) {
+    state.isHideOrderCreditBtn = payload;
+  },
+  setWebviewToken(state, payload) {
+    state.webviewToken = payload;
+  },
+  setIsStateLogout(state, payload = true) {
+    state.isStateLogout = payload;
+  },
+  setIsStateLoginProcessing(state, payload = false) {
+    state.isStateLoginProcessing = payload;
+  },
+  setAgreement(state, payload) {
+    state.agreement = { ...state.agreement, ...payload };
+  },
+};
+export default cabinetModuleMutations;
diff --git a/parent_dir/src/store/vuex-store/modules/cabinetModule/cabinetModuleState.ts b/parent_dir/src/store/vuex-store/modules/cabinetModule/cabinetModuleState.ts
new file mode 100644
index 0000000..c070f13
--- /dev/null
+++ b/parent_dir/src/store/vuex-store/modules/cabinetModule/cabinetModuleState.ts
@@ -0,0 +1,58 @@
+import { CabinetState, TrackingState } from '@/types/store/cabinet';
+
+export const store = {
+  login_phone: null,
+};
+export const getEmptyTracking = (): TrackingState => ({
+  trackId: '',
+  trackInfo: null,
+  loadingTrackingHistory: false,
+  trackingHistory: null,
+});
+
+export const initialCabinet = (): CabinetState => ({
+  login_phone: null,
+  email: null,
+  tracking: getEmptyTracking(),
+  isStateLogout: false,
+  isStateLoginProcessing: true,
+  user: {
+    contragent_uuid: null,
+
+    contragent: {},
+    cdekid_status: null,
+    profile: {
+      firstName: null,
+      lastName: null,
+      fatherName: null,
+      phone: null,
+      email: null,
+      inn: null,
+      gender: null,
+      passportSeries: null,
+      passportNumber: null,
+      dateBirth: null,
+      passportIssuedBy: null,
+      passportIssueDate: null,
+      surName: null,
+      addressFact: {},
+      addressReal: {},
+      is_email_confirmed: false,
+    },
+  },
+  ordersHasUpdates: false,
+  redirectedFromSiteCdekid: false,
+  startCreateOrderAtSite: false,
+  startCreateOrderAtBox: false,
+  isRedirectedFromSiteOrderCreate: false,
+  hiddenAlerts: [],
+  isChangeOrder: false,
+  lastDateUserLoaded: null,
+  isHideOrderCreditBtn: false,
+  webviewToken: null,
+});
+const state = () => ({
+  ...initialCabinet(),
+});
+
+export default state;
diff --git a/parent_dir/src/store/vuex-store/modules/cabinetModule/index.ts b/parent_dir/src/store/vuex-store/modules/cabinetModule/index.ts
new file mode 100644
index 0000000..6fccae8
--- /dev/null
+++ b/parent_dir/src/store/vuex-store/modules/cabinetModule/index.ts
@@ -0,0 +1,15 @@
+import { Module } from 'vuex';
+import { CabinetState } from '@/types/store/cabinet';
+import MainState from '@/types/store';
+import cabinetModuleActions from './cabinetModuleActions';
+import cabinetModuleState from './cabinetModuleState';
+import cabinetModuleMutations from './cabinetModuleMutations';
+import cabinetModuleGetters from './cabinetModuleGetters';
+
+export const cabinetModule: Module<CabinetState, MainState> = {
+  namespaced: true,
+  actions: cabinetModuleActions,
+  state: cabinetModuleState,
+  getters: cabinetModuleGetters,
+  mutations: cabinetModuleMutations,
+};
diff --git a/parent_dir/src/store/vuex-store/modules/flomniModule.ts b/parent_dir/src/store/vuex-store/modules/flomniModule.ts
new file mode 100644
index 0000000..7f6defb
--- /dev/null
+++ b/parent_dir/src/store/vuex-store/modules/flomniModule.ts
@@ -0,0 +1,59 @@
+import { FlomniState } from '@/types/store/flomni';
+import { GetterTree, Module, MutationTree } from 'vuex';
+import MainState from '@/types/store';
+
+const state = (): FlomniState => ({
+  displayChat: false,
+  state: 'close',
+  inline: false,
+  isYaMapsBalloonOpened: false,
+  isHelpCustomerLoaded: false,
+  isExternalOpened: false,
+});
+
+const mutations: MutationTree<FlomniState> = {
+  onInit(store, payload) {
+    store.displayChat = payload.displayChat;
+    store.inline = payload.inline;
+  },
+  onUpdateState(store, payload) {
+    store.state = payload.state;
+  },
+  updateYaMapsBalloonOpened(store, payload) {
+    store.isYaMapsBalloonOpened = payload;
+  },
+  setIsHelpCustomerLoaded(state, payload = true) {
+    state.isHelpCustomerLoaded = payload;
+  },
+  setIsExternalOpened(state, payload = true) {
+    state.isExternalOpened = payload;
+  },
+  toggleIsExternalOpened(state) {
+    state.isExternalOpened = !state.isExternalOpened;
+  },
+};
+
+const actions = {};
+
+const getters: GetterTree<FlomniState, MainState> = {
+  displayChat({ displayChat }) {
+    return displayChat;
+  },
+  state({ state }) {
+    return state;
+  },
+  inline({ inline }) {
+    return inline;
+  },
+  isYaMapsBalloonOpened({ isYaMapsBalloonOpened }) {
+    return isYaMapsBalloonOpened;
+  },
+};
+
+export const flomniModule: Module<FlomniState, MainState> = {
+  namespaced: true,
+  actions,
+  getters,
+  mutations,
+  state,
+};
diff --git a/parent_dir/src/store/vuex-store/modules/footerModule.ts b/parent_dir/src/store/vuex-store/modules/footerModule.ts
new file mode 100644
index 0000000..4092a94
--- /dev/null
+++ b/parent_dir/src/store/vuex-store/modules/footerModule.ts
@@ -0,0 +1,72 @@
+import { FooterData, FooterState } from '@/types/store/footer';
+import { ActionTree, GetterTree, Module, MutationTree } from 'vuex';
+import MainState from '@/types/store';
+
+export enum FooterType {
+  SET_FOOTER = 'SET_FOOTER',
+  LOADING_FOOTER = 'LOADING_FOOTER',
+  START_LOADING_FOOTER = 'START_LOADING_FOOTER',
+  STOP_LOADING_FOOTER = 'STOP_LOADING_FOOTER',
+}
+
+const defaultFooter: FooterData = {
+  color: null,
+  feedback: {
+    phone: null,
+  },
+  links: {
+    additional: [],
+    international: [],
+    locale: null,
+    official: [],
+    websiteId: null,
+    feedback: null,
+    social: null,
+  },
+  locale: null,
+  search: null,
+  websiteId: null,
+};
+
+export const getDefaultFooterState = (): FooterState => ({
+  footer: { ...defaultFooter },
+  loading: false,
+});
+
+const mutations: MutationTree<FooterState> = {
+  [FooterType.SET_FOOTER](state, { footer }) {
+    state.footer = { ...footer };
+  },
+  [FooterType.LOADING_FOOTER](state, loading) {
+    state.loading = loading;
+  },
+};
+
+const actions: ActionTree<FooterState, MainState> = {
+  [FooterType.SET_FOOTER]({ commit }, payload) {
+    commit(FooterType.SET_FOOTER, payload);
+  },
+  [FooterType.START_LOADING_FOOTER]({ commit }) {
+    commit(FooterType.LOADING_FOOTER, true);
+  },
+  [FooterType.STOP_LOADING_FOOTER]({ commit }) {
+    commit(FooterType.LOADING_FOOTER, false);
+  },
+};
+
+const getters: GetterTree<FooterState, MainState> = {
+  footer({ footer }) {
+    return footer;
+  },
+  loading({ loading }) {
+    return loading;
+  },
+};
+
+export const footerModule: Module<FooterState, MainState> = {
+  namespaced: true,
+  actions,
+  getters,
+  state: getDefaultFooterState,
+  mutations,
+};
diff --git a/parent_dir/src/store/vuex-store/modules/indexModule.ts b/parent_dir/src/store/vuex-store/modules/indexModule.ts
new file mode 100644
index 0000000..64f9998
--- /dev/null
+++ b/parent_dir/src/store/vuex-store/modules/indexModule.ts
@@ -0,0 +1,209 @@
+import { ActionTree, GetterTree, Module, MutationTree } from 'vuex';
+import {
+  ExtendedLocale,
+  getDefaultLocaleFromMap,
+  getI18nLocales,
+  getLocaleMapFromEnv,
+} from '#root/src/utils/env-utils';
+import { getLocalCity, saveLocalCity } from '#root/src/utils/menu-utils';
+import MainState from '#root/src/types/store';
+import { DEFAULT_CITIES } from '#root/src/constants/default-cities';
+import { WebsiteId } from '#root/src/env';
+import { InitialSiteData } from '@/types/dto/initialSiteData';
+import { FooterType } from '@/store/vuex-store/modules/footerModule';
+import { getLocaleCodeNameMap, getWebsiteId } from '@/utils/international.utils';
+import { useMenuStore } from '@/store/pinia/menu/menu';
+
+export const SET_LOCALE = 'SET_LOCALE';
+export const SET_LOCALES = 'SET_LOCALES';
+export const SET_LOCALES_MAP = 'SET_LOCALES_MAP';
+export const LOCAL_STORAGE_ENABLE = 'LOCAL_STORAGE_ENABLE';
+export const SET_SHOW_CONFIRM_CITY = 'SET_SHOW_CONFIRM_CITY';
+function getLocaleCodes(locales: ExtendedLocale[]): string[] {
+  return locales.map((locale) => locale.code);
+}
+
+function getLocalesMap(locales: ExtendedLocale[]) {
+  const map: Record<string, string> = {};
+  for (const row of locales) {
+    map[row.code] = row.iso;
+  }
+  return map;
+}
+
+const localeMap = getLocaleMapFromEnv(getLocaleCodeNameMap());
+const defLocale = getDefaultLocaleFromMap(localeMap);
+
+const initState = (): MainState => {
+  const websiteId: WebsiteId = getWebsiteId();
+
+  return {
+    localesMap: getLocalesMap(getI18nLocales(localeMap)),
+    locales: getLocaleCodes(getI18nLocales(localeMap)),
+    fullLocales: getI18nLocales(localeMap),
+    locale: defLocale,
+    defaultLocale: defLocale,
+    websiteId,
+    city: getLocalCity() ?? DEFAULT_CITIES[websiteId].ru,
+    isNewMenu: false,
+    showConfirmCityModal: false,
+    // Используем вместо !!$nuxt. Накста больше нет....
+    isSite: true,
+  };
+};
+
+export const indexState = (): MainState => ({
+  ...initState(),
+});
+
+export const indexMutations: MutationTree<MainState> = {
+  setIsSite(state, payload) {
+    state.isSite = payload.isSite;
+  },
+  [SET_LOCALE](state, locale) {
+    if (state.locales.indexOf(locale) !== -1) {
+      state.locale = locale;
+    }
+  },
+  [SET_LOCALES](state, payload) {
+    state.locales = payload.locales;
+  },
+  SET_DEFAULT_LOCALE(state, payload) {
+    state.defaultLocale = payload.defaultLocale;
+  },
+  [SET_LOCALES_MAP](state, payload) {
+    state.localesMap = payload.localesMap;
+  },
+  SET_WEBSITE_ID(state, payload) {
+    state.websiteId = payload.websiteId;
+  },
+  SELECT_CITY(state, payload) {
+    state.city = payload;
+  },
+  SET_NEW_MENU(state, payload) {
+    state.isNewMenu = payload;
+  },
+  SET_SHOW_CONFIRM_CITY(state, payload) {
+    state.showConfirmCityModal = payload;
+  },
+};
+
+export const indexActions: ActionTree<MainState, MainState> = {
+  UPDATE_SITE_DATA: (
+    { dispatch },
+    {
+      siteData,
+      urlPathname,
+      locale,
+    }: {
+      siteData: InitialSiteData;
+      urlPathname: string;
+      locale: string;
+    },
+  ) => {
+    const menuStore = useMenuStore();
+
+    menuStore.setMenu(siteData.menu);
+
+    menuStore.updateActiveMenuByUrl(urlPathname);
+
+    dispatch(`footer/${FooterType.SET_FOOTER}`, {
+      footer: siteData.footer,
+    });
+    dispatch('SET_LOCALE', locale);
+  },
+  SET_LOCALE(context, locale) {
+    context.commit(SET_LOCALE, locale);
+  },
+  SET_LOCALES(context, locales) {
+    context.commit(SET_LOCALES, { locales: getLocaleCodes(locales) });
+    context.commit(SET_LOCALES_MAP, { localesMap: getLocalesMap(locales) });
+  },
+  SET_DEFAULT_LOCALE(context, defaultLocale) {
+    context.commit('SET_DEFAULT_LOCALE', { defaultLocale });
+  },
+  SET_WEBSITE_ID(context, websiteId) {
+    context.commit('SET_WEBSITE_ID', { websiteId });
+  },
+  SELECT_CITY({ commit }, city) {
+    if (city && city.cdek_id) {
+      saveLocalCity(city);
+      commit('SELECT_CITY', { ...city });
+    }
+  },
+  SET_SHOW_CONFIRM_CITY({ commit }, payload) {
+    commit(SET_SHOW_CONFIRM_CITY, payload);
+  },
+  // TODO: check do we really need it
+  // LOCAL_STORAGE_ENABLE({ commit }) {
+  //   const localCity = getLocalCity();
+  //   if (localCity) {
+  //     commit(Menu.SELECT_CITY, localCity);
+  //   }
+  // },
+};
+
+export const indexGetters: GetterTree<MainState, MainState> = {
+  isLoggedInCabinet(state, getters, rootState, rootGetters) {
+    const accessToken = rootGetters['keycloak/accessToken'];
+    const impersonationToken = rootGetters['auth/getImpersonationToken'];
+
+    return !!(accessToken || impersonationToken);
+  },
+  isActiveCdekId(state, getters, rootState, rootGetters) {
+    const user = rootGetters['cabinet/getUser'];
+    return user && user.contragent?.uuid !== null && user.contragent?.cdekId === true;
+  },
+  currentLocale({ locale }) {
+    return locale;
+  },
+  websiteId({ websiteId }) {
+    return websiteId;
+  },
+  currentLocaleISO({ localesMap, locale }) {
+    return localesMap[locale];
+  },
+  isRuSite({ websiteId }) {
+    return websiteId === 'ru';
+  },
+  isKzSite({ websiteId }) {
+    return websiteId === 'kz';
+  },
+  isKgSite({ websiteId }) {
+    return websiteId === 'kg';
+  },
+  isAmSite({ websiteId }) {
+    return websiteId === 'am';
+  },
+  isUzSite({ websiteId }) {
+    return websiteId === 'uz';
+  },
+  isGeSite({ websiteId }) {
+    return websiteId === 'ge';
+  },
+  isBySite({ websiteId }) {
+    return websiteId === 'by';
+  },
+  isChineSite({ websiteId }) {
+    return websiteId === 'cn';
+  },
+  isAzSite({ websiteId }) {
+    return websiteId === 'az';
+  },
+  city({ city }) {
+    return city;
+  },
+  isNewMenu({ isNewMenu }) {
+    return isNewMenu;
+  },
+  showConfirmCityModal: ({ showConfirmCityModal }) => showConfirmCityModal,
+  isSite: ({ isSite }) => isSite,
+};
+
+export const indexModule: Module<MainState, MainState> = {
+  namespaced: false,
+  getters: indexGetters,
+  actions: indexActions,
+  state: indexState,
+  mutations: indexMutations,
+};
diff --git a/parent_dir/src/store/vuex-store/modules/keycloakModule.ts b/parent_dir/src/store/vuex-store/modules/keycloakModule.ts
new file mode 100644
index 0000000..a74f9c1
--- /dev/null
+++ b/parent_dir/src/store/vuex-store/modules/keycloakModule.ts
@@ -0,0 +1,79 @@
+import KeycloakState, { KeycloakData } from '@/types/store/keycloak';
+import { GetterTree, Module, MutationTree } from 'vuex';
+import MainState from '@/types/store';
+
+const initialKeycloak = (): KeycloakData => ({
+  access_token: null,
+  expires_in: null,
+  expired_at: null,
+  id_token: null,
+  'not-before-policy': null,
+  refresh_token: null,
+  refresh_expires_in: null,
+  refresh_expired_at: null,
+  scope: null,
+  session_state: null,
+  token_type: null,
+});
+
+const state = (): KeycloakState => ({
+  keycloak: initialKeycloak(),
+});
+const mutations: MutationTree<KeycloakState> = {
+  /**
+   * @param {Object} state
+   * @param {KeycloakResponse<Object>} payload
+   */
+  setKeycloak(state, payload) {
+    const date = new Date();
+    const accessTokenExpiredSecs = parseInt(payload.expires_in, 10);
+    const accessTokenExpiredMsecs = accessTokenExpiredSecs * 1000;
+    const accessTokenExpiredDate = new Date(
+      accessTokenExpiredMsecs ? date.getTime() + accessTokenExpiredMsecs : 2 ** 31 * 1000,
+    );
+    const refreshTokenExpiredSecs = parseInt(payload.refresh_expires_in, 10);
+    const refreshTokenExpiredMsecs = refreshTokenExpiredSecs * 1000;
+    const refreshTokenExpiredDate = new Date(
+      refreshTokenExpiredMsecs ? date.getTime() + refreshTokenExpiredMsecs : 2 ** 31 * 1000,
+    );
+
+    state.keycloak = {
+      ...payload,
+
+      expired_at: accessTokenExpiredDate,
+      refresh_expired_at: refreshTokenExpiredDate,
+    };
+  },
+  resetKeycloak(state) {
+    state.keycloak = initialKeycloak();
+  },
+};
+
+const getters: GetterTree<KeycloakState, MainState> = {
+  keycloak(state) {
+    return state.keycloak;
+  },
+
+  accessToken(state) {
+    return state.keycloak.access_token;
+  },
+
+  refreshToken(state) {
+    return state.keycloak.refresh_token;
+  },
+
+  expiredAt(state) {
+    return state.keycloak.expired_at;
+  },
+
+  refreshExpiredAt(state) {
+    return state.keycloak.refresh_expired_at;
+  },
+};
+
+export const keycloakModule: Module<KeycloakState, MainState> = {
+  namespaced: true,
+  getters,
+  state,
+  mutations,
+};
diff --git a/parent_dir/src/store/vuex-store/modules/loaderModule.ts b/parent_dir/src/store/vuex-store/modules/loaderModule.ts
new file mode 100644
index 0000000..7506fae
--- /dev/null
+++ b/parent_dir/src/store/vuex-store/modules/loaderModule.ts
@@ -0,0 +1,24 @@
+import { GetterTree, Module, MutationTree } from 'vuex';
+import { LoaderState } from '#root/src/types/store/loader';
+import MainState from '#root/src/types/store';
+
+const defaultState: LoaderState = {
+  isPageLoading: false,
+};
+
+const mutations: MutationTree<LoaderState> = {
+  setIsPageLoading(state, payload) {
+    state.isPageLoading = payload;
+  },
+};
+
+const getters: GetterTree<LoaderState, MainState> = {
+  isPageLoading: ({ isPageLoading }) => isPageLoading,
+};
+
+export const loaderModule: Module<LoaderState, MainState> = {
+  namespaced: true,
+  getters,
+  mutations,
+  state: defaultState,
+};
diff --git a/parent_dir/src/store/vuex-store/modules/loyaltyModule.ts b/parent_dir/src/store/vuex-store/modules/loyaltyModule.ts
new file mode 100644
index 0000000..53efbab
--- /dev/null
+++ b/parent_dir/src/store/vuex-store/modules/loyaltyModule.ts
@@ -0,0 +1,99 @@
+import { LOYALTY_TYPE } from '@/middleware/mutation-types';
+import MainState from '@/types/store';
+import { ActionTree, GetterTree, Module, MutationTree } from 'vuex';
+import { LoyaltyState } from '@/types/store/loyalty';
+
+export const initialLoyalty = (): LoyaltyState => ({
+  availableBonuses: 0,
+  burningBonuses: 0,
+  texts: {
+    burningRules: '',
+    loyaltyDetailRules: '',
+    loyaltyShortRules: '',
+  },
+  showcaseParams: null,
+  smsNotificationsEnabled: false,
+  isLoading: false,
+  canUseRefCode: true,
+  referralCard: {
+    code: '',
+    title: '',
+    subtitle: '',
+    invite: '',
+    description: '',
+    referrersNumber: '',
+    buttonText: '',
+    buttonClickedText: '',
+  },
+  giftStoreLinkText: '',
+});
+
+const state = (): LoyaltyState => ({
+  ...initialLoyalty(),
+});
+
+const actions: ActionTree<LoyaltyState, MainState> = {
+  addBonuses({ commit, state }, bonuses) {
+    const newAmount = state.availableBonuses + bonuses;
+    commit(LOYALTY_TYPE.SET_AVAILABLE_BONUSES, newAmount);
+  },
+};
+const mutations: MutationTree<LoyaltyState> = {
+  [LOYALTY_TYPE.SET_BURNING_BONUSES](store, payload) {
+    store.burningBonuses = payload;
+  },
+  [LOYALTY_TYPE.SET_AVAILABLE_BONUSES](store, payload) {
+    store.availableBonuses = payload;
+  },
+  [LOYALTY_TYPE.SET_TEXTS](store, payload) {
+    store.texts = { ...payload };
+  },
+  [LOYALTY_TYPE.SET_SMS_SUBSCRIPTION](store, payload) {
+    store.smsNotificationsEnabled = payload;
+  },
+  init(
+    state,
+    {
+      burningPoints,
+      availablePoints,
+      smsNotificationsEnabled,
+      referral,
+      showcaseParams,
+      giftStoreLinkText,
+    },
+  ) {
+    state.burningBonuses = burningPoints;
+    state.availableBonuses = availablePoints;
+    state.smsNotificationsEnabled = smsNotificationsEnabled;
+    state.showcaseParams = showcaseParams;
+    state.giftStoreLinkText = giftStoreLinkText;
+
+    if (referral) {
+      state.canUseRefCode = referral.canUseRefCode;
+      state.referralCard = referral.card;
+    } else {
+      state.canUseRefCode = true;
+      state.referralCard = null;
+    }
+  },
+  setIsLoading(state, payload = true) {
+    state.isLoading = !!payload;
+  },
+};
+
+const getters: GetterTree<LoyaltyState, MainState> = {
+  availableBonuses: ({ availableBonuses }) => availableBonuses,
+  burningBonuses: ({ burningBonuses }) => burningBonuses,
+  burningRules: ({ texts }) => texts.burningRules,
+  loyaltyDetailRules: ({ texts }) => texts.loyaltyDetailRules,
+  loyaltyShortRules: ({ texts }) => texts.loyaltyShortRules,
+  smsNotificationsEnabled: ({ smsNotificationsEnabled }) => smsNotificationsEnabled,
+};
+
+export const loyaltyModule: Module<LoyaltyState, MainState> = {
+  namespaced: true,
+  getters,
+  actions,
+  mutations,
+  state,
+};
diff --git a/parent_dir/src/store/vuex-store/modules/resizeModule.ts b/parent_dir/src/store/vuex-store/modules/resizeModule.ts
new file mode 100644
index 0000000..38289f0
--- /dev/null
+++ b/parent_dir/src/store/vuex-store/modules/resizeModule.ts
@@ -0,0 +1,69 @@
+import { ResizeState } from '#root/src/types/store/resize';
+import { ActionTree, GetterTree, Module, MutationTree } from 'vuex';
+import MainState from '#root/src/types/store';
+
+const TABLE = 640;
+const DESKTOP = 1000;
+const DESKTOP_LARGE = 1280;
+
+const defaultState = (): ResizeState => ({
+  width: 0,
+  height: 0,
+  screen: {
+    mobile: false, // 320px
+    table: false, // >=640
+    desktop: false, // >=1000
+    desktopLarge: false, // >=1280
+  },
+});
+
+export const mutations: MutationTree<ResizeState> = {
+  setWidth(store, payload) {
+    store.width = payload.width;
+  },
+  setScreen(store, payload) {
+    store.screen = payload.screen;
+  },
+};
+
+const actions: ActionTree<ResizeState, MainState> = {
+  setWidth({ commit }, { clientWidth }) {
+    commit('setWidth', {
+      width: clientWidth,
+    });
+    const screen = {
+      mobile: clientWidth <= TABLE, // <= 640px
+      table: clientWidth > TABLE && clientWidth <= DESKTOP, // >640 && <=1000
+      desktop: clientWidth >= DESKTOP, // >1000
+      desktopLarge: clientWidth >= DESKTOP_LARGE, // >1280
+    };
+    commit('setScreen', {
+      screen,
+    });
+  },
+  setScreenByType({ commit }, type) {
+    const screen = {
+      mobile: type === 'mobile', // <= 640px
+      table: type === 'tablet', // >640 && <=1000
+      desktop: type === 'desktop', // >1000
+      desktopLarge: type === 'desktopLarge', // >1280
+    };
+
+    commit('setScreen', {
+      screen,
+    });
+  },
+};
+
+const getters: GetterTree<ResizeState, MainState> = {
+  screen: ({ screen }) => screen,
+  isDesktop: ({ screen }) => screen.desktop,
+};
+
+export const resizeModule: Module<ResizeState, MainState> = {
+  namespaced: true,
+  getters,
+  mutations,
+  state: defaultState,
+  actions,
+};
diff --git a/parent_dir/src/store/vuex-store/modules/trackingModule.ts b/parent_dir/src/store/vuex-store/modules/trackingModule.ts
new file mode 100644
index 0000000..aa7528e
--- /dev/null
+++ b/parent_dir/src/store/vuex-store/modules/trackingModule.ts
@@ -0,0 +1,126 @@
+import { TrackingState } from '@/types/store/tracking';
+import { ActionTree, GetterTree, Module, MutationTree } from 'vuex';
+import MainState from '@/types/store';
+
+const initialTracking = (): TrackingState => ({
+  autoSubmit: false,
+  trackId: null,
+  phone: null,
+  tracking: null,
+  token: null,
+  loading: false,
+  displayCaptchaSearch: false,
+  displayCaptchaChange: false,
+  displayCaptchaPhone: false,
+});
+
+export const state = (): TrackingState => ({
+  ...initialTracking(),
+});
+
+export const mutations: MutationTree<TrackingState> = {
+  updateTrackId(state, payload) {
+    state.trackId = payload.trackId;
+  },
+  updateToken(state, payload) {
+    state.token = payload.token;
+  },
+  updateDisplayCaptchaSearch(state, payload) {
+    state.displayCaptchaSearch = payload.displayCaptchaSearch;
+  },
+  updateDisplayCaptchaChange(state, payload) {
+    state.displayCaptchaChange = payload.displayCaptchaChange;
+  },
+  updateDisplayCaptchaPhone(state, payload) {
+    state.displayCaptchaPhone = payload.displayCaptchaPhone;
+  },
+  updateAutoSubmit(state, payload) {
+    state.autoSubmit = payload.autoSubmit;
+  },
+  updatePhone(state, payload) {
+    state.phone = payload.phone;
+  },
+  updateLoading(state, payload) {
+    state.loading = payload.loading;
+  },
+  recordTrackingData(state, payload) {
+    state.tracking = payload.tracking;
+  },
+  clear(state, payload: TrackingState) {
+    for (const property in payload) {
+      if (payload.hasOwnProperty(property)) {
+        (state as any)[property] = payload[property as keyof TrackingState];
+      }
+    }
+  },
+  reset(state, payload) {
+    state.phone = payload.phone;
+    state.tracking = payload.tracking;
+    state.loading = payload.loading;
+  },
+};
+
+export const actions: ActionTree<TrackingState, MainState> = {
+  clearTracking({ commit }) {
+    commit('clear', {
+      ...initialTracking(),
+    });
+  },
+  reset({ commit }) {
+    commit('reset', {
+      phone: null,
+      tracking: null,
+      loading: false,
+    });
+  },
+  setTracking({ commit }, payload) {
+    commit('recordTrackingData', payload);
+    commit('updateLoading', { loading: true });
+  },
+  setTrackIdAndSubmit({ commit }, payload) {
+    commit('updateTrackId', {
+      trackId: payload.trackId,
+    });
+    commit('updateAutoSubmit', {
+      autoSubmit: payload.autoSubmit,
+    });
+  },
+};
+
+export const getters: GetterTree<TrackingState, MainState> = {
+  trackId({ trackId }) {
+    return trackId;
+  },
+  autoSubmit({ autoSubmit }) {
+    return autoSubmit;
+  },
+  phone({ phone }) {
+    return phone;
+  },
+  tracking({ tracking }) {
+    return tracking;
+  },
+  loading({ loading }) {
+    return loading;
+  },
+  token({ token }) {
+    return token;
+  },
+  displayCaptchaSearch({ displayCaptchaSearch }) {
+    return displayCaptchaSearch;
+  },
+  displayCaptchaChange({ displayCaptchaChange }) {
+    return displayCaptchaChange;
+  },
+  displayCaptchaPhone({ displayCaptchaPhone }) {
+    return displayCaptchaPhone;
+  },
+};
+
+export const trackingModule: Module<TrackingState, MainState> = {
+  namespaced: true,
+  getters,
+  actions,
+  state,
+  mutations,
+};
diff --git a/parent_dir/src/utils/bowser.ts b/parent_dir/src/utils/bowser.ts
new file mode 100644
index 0000000..4d250b9
--- /dev/null
+++ b/parent_dir/src/utils/bowser.ts
@@ -0,0 +1,43 @@
+import Bowser from 'bowser';
+
+const OS = {
+  iOS: 'iOS',
+  // https://github.com/lancedikson/bowser/issues/329
+  macOS: 'macOS',
+  android: 'Android',
+};
+
+export function getParser() {
+  return Bowser.getParser(window.navigator.userAgent);
+}
+
+export function isAppleDevice() {
+  const parse = getParser();
+  const os = parse.getOS();
+  const { name } = os;
+  const { iOS, macOS } = OS;
+  const isTs = 'ontouchstart' in window;
+
+  return name === iOS || (name === macOS && isTs);
+}
+
+export function isAndroidDevice() {
+  const parse = getParser();
+  const os = parse.getOS();
+  const { name } = os;
+  const { android } = OS;
+
+  return name === android;
+}
+
+export function isDevice() {
+  const parse = getParser();
+  const platform = parse.getPlatform();
+  return platform.type === 'mobile' || platform.type === 'tablet';
+}
+
+export function isMobile() {
+  const parse = getParser();
+  const platform = parse.getPlatform();
+  return platform.type === 'mobile';
+}
diff --git a/parent_dir/src/utils/console-wrapper.ts b/parent_dir/src/utils/console-wrapper.ts
new file mode 100644
index 0000000..cbd4ced
--- /dev/null
+++ b/parent_dir/src/utils/console-wrapper.ts
@@ -0,0 +1,18 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-console */
+import { globalVueErrorsHandler } from '#root/src/utils/handleErrors/handleErrors';
+
+export const cdekConsoleLog = (...args: any) => console.log(...args);
+export const cdekConsoleError = (...args: any) => {
+  console.error(...args);
+
+  for (const arg of args) {
+    if (arg?.dontSendSentry) {
+      return;
+    }
+  }
+
+  globalVueErrorsHandler(args[0]);
+};
+export const cdekConsoleWarn = (...args: any) => console.warn(...args);
+export const cdekConsoleInfo = (...args: any) => console.info(...args);
diff --git a/parent_dir/src/utils/dom.utils.ts b/parent_dir/src/utils/dom.utils.ts
new file mode 100644
index 0000000..9ef5709
--- /dev/null
+++ b/parent_dir/src/utils/dom.utils.ts
@@ -0,0 +1,11 @@
+export const getHeadElement = () => {
+  return document.getElementsByTagName('head')[0];
+};
+
+export const createScriptElement = () => {
+  return document.createElement('script');
+};
+
+export const getBodyElement = () => {
+  return document.querySelector('body');
+};
diff --git a/parent_dir/src/utils/env-utils.ts b/parent_dir/src/utils/env-utils.ts
new file mode 100644
index 0000000..9e24d0b
--- /dev/null
+++ b/parent_dir/src/utils/env-utils.ts
@@ -0,0 +1,94 @@
+export interface ExtendedLocale {
+  code: string;
+  iso: string;
+  file: string;
+  name: string;
+}
+export function castEnv(value: string, defaultValue: unknown = null) {
+  if (typeof value === 'undefined' || value === null) {
+    return defaultValue;
+  }
+
+  if (!value) {
+    return defaultValue;
+  }
+
+  switch (true) {
+    case value.toLowerCase() === 'null': {
+      return null;
+    }
+
+    case value.toLowerCase() === 'true': {
+      return true;
+    }
+
+    case value.toLowerCase() === 'false': {
+      return false;
+    }
+
+    case String(value).length > 1 && String(value).startsWith('0'): {
+      return String(value);
+    }
+
+    case !Number.isNaN(value): {
+      return parseFloat(value);
+    }
+
+    default: {
+      return String(value);
+    }
+  }
+}
+
+export function getLocaleMapFromEnv(envMap = import.meta.env.VITE_LOCALE_CODE_NAME_MAP) {
+  const fallbackMap = 'ru:Русский';
+
+  if (!envMap) {
+    return fallbackMap;
+  }
+
+  const split = envMap.split(';').filter((el: string) => {
+    const innerSplit = el.split(':');
+
+    return innerSplit.length === 2 && innerSplit.every((part) => part.length > 0);
+  });
+
+  return split ? split.join(';') : fallbackMap;
+}
+
+export function getI18nLocales(localeMap: string): ExtendedLocale[] {
+  const split = localeMap.split(';');
+
+  return split.map((el) => {
+    const innerSplit = el.split(':');
+
+    const code = innerSplit[0];
+    const name = innerSplit[1];
+
+    return {
+      code,
+      iso: code,
+      file: `${code}.js`,
+      name,
+    };
+  });
+}
+
+export function getDefaultLocaleFromMap(localeMap: string): string {
+  const split = localeMap.split(';');
+  const fallbackLocale = 'ru';
+
+  return split[0] ? split[0].split(':')[0] : fallbackLocale;
+}
+
+export function getEnvUniversal(...keys: string[]): string {
+  for (const key of keys) {
+    const value: string | undefined = import.meta.env ? import.meta.env[key] : process.env[key];
+
+    if (value) {
+      return value;
+    }
+  }
+
+  return '';
+}
diff --git a/parent_dir/src/utils/getCabinetUrl.ts b/parent_dir/src/utils/getCabinetUrl.ts
new file mode 100644
index 0000000..e666de7
--- /dev/null
+++ b/parent_dir/src/utils/getCabinetUrl.ts
@@ -0,0 +1,29 @@
+export const getCabinetUrl = (pathname: string, searchOriginal = '', currentLocale = 'ru') => {
+  let newUrl;
+
+  if (pathname.includes('/tracking')) {
+    newUrl = `/${currentLocale}/cabinet/orders`;
+  }
+
+  if (pathname.includes('/calculate')) {
+    newUrl = `/${currentLocale}/cabinet/calculate`;
+  }
+
+  if (newUrl) {
+    if (searchOriginal) {
+      newUrl += searchOriginal;
+    }
+
+    return newUrl;
+  }
+
+  if (pathname.includes('/cdekid')) {
+    return `/${currentLocale}/cabinet/cdekid`;
+  }
+
+  if (pathname.includes('/gifts')) {
+    return `/${currentLocale}/cabinet/gifts`;
+  }
+
+  return '';
+};
diff --git a/parent_dir/src/utils/getLocaleKeys.ts b/parent_dir/src/utils/getLocaleKeys.ts
new file mode 100644
index 0000000..ae0e767
--- /dev/null
+++ b/parent_dir/src/utils/getLocaleKeys.ts
@@ -0,0 +1,5 @@
+import { WebsiteId } from '#root/src/env';
+
+export default function getLocaleKeys(): WebsiteId[] {
+  return import.meta.env.VITE_LOCALE_CODE_NAME_MAP.split(';').map((el: string) => el.split(':')[0]);
+}
diff --git a/parent_dir/src/utils/handle-tilda-ym.ts b/parent_dir/src/utils/handle-tilda-ym.ts
new file mode 100644
index 0000000..22534b4
--- /dev/null
+++ b/parent_dir/src/utils/handle-tilda-ym.ts
@@ -0,0 +1,83 @@
+import { reachGoal } from '@/utils/reach-goal';
+
+const tildaTriggers = [
+  {
+    // Страница онлайн магазинам, казхский сайт, кз/ру локаль (этот айдишник одинаковый), заключить договор на баннере
+    query: '[data-lid="1660034890102"]',
+    handler: () => reachGoal('im_dogovor'),
+  },
+
+  {
+    // Страница онлайн магазинам, казхский сайт, кз локаль, заключить договор под таблицей
+    query: '[data-tilda-event-name="/tilda/click/rec546735897/button1475077923649"]',
+    handler: () => reachGoal('im_dogovor'),
+  },
+  {
+    // Страница онлайн магазинам, казхский сайт, кз локаль, заключить договор последняя
+    query: '[data-tilda-event-name="/tilda/click/rec546735900/button1475077923649"]',
+    handler: () => reachGoal('im_dogovor'),
+  },
+
+  {
+    // Страница онлайн магазинам, казхский сайт, ру локаль, заключить договор под таблицей
+    query: '[data-tilda-event-name="/tilda/click/rec551400770/button1475077923649"]',
+    handler: () => reachGoal('im_dogovor'),
+  },
+  {
+    // Страница онлайн магазинам, казхский сайт, ру локаль, заключить договор последняя
+    query: '[data-tilda-event-name="/tilda/click/rec551400773/button1475077923649"]',
+    handler: () => reachGoal('im_dogovor'),
+  },
+
+  {
+    // Страница contract, казхский сайт, ру локаль, перейти к анкете в карточке
+    query: '[data-elem-id="1663599749578"] a',
+    handler: () => reachGoal('contract_redirect'),
+  },
+  {
+    // Страница contract, казхский сайт, ру/кз локаль, заполнить анкету в синей карточке
+    query: '[data-elem-id="1663766563082"] a',
+    handler: () => reachGoal('contract_redirect'),
+  },
+  {
+    // Страница contract, казхский сайт, ру локаль, ссылка в частозадаваемых вопросах
+    query: '#accordion3_551401254 a',
+    handler: () => reachGoal('contract_redirect'),
+  },
+  {
+    // Страница contract, казхский сайт, ру/кз локаль, заполнить анкету в банере
+    query: '[data-elem-id="1663597949993"] a',
+    handler: () => reachGoal('contract_redirect'),
+  },
+
+  {
+    // Страница contract, казхский сайт, кз локаль, перейти к анкете в карточке
+    query: '[data-elem-id="1676312728049"] a',
+    handler: () => reachGoal('contract_redirect'),
+  },
+  {
+    // Страница contract, казхский сайт, кз локаль, ссылка в частозадаваемых вопросах
+    query: '#accordion3_546736178 a',
+    handler: () => reachGoal('contract_redirect'),
+  },
+];
+
+export const handleTildaYm = (): void => {
+  tildaTriggers.forEach((el) => {
+    const button = document.querySelector(el.query);
+
+    if (button) {
+      button.addEventListener('click', el.handler);
+    }
+  });
+};
+
+export const removeTildaYm = (): void => {
+  tildaTriggers.forEach((el) => {
+    const button = document.querySelector(el.query);
+
+    if (button) {
+      button.removeEventListener('click', el.handler);
+    }
+  });
+};
diff --git a/parent_dir/src/utils/handleErrors/components.ts b/parent_dir/src/utils/handleErrors/components.ts
new file mode 100644
index 0000000..1b2ef43
--- /dev/null
+++ b/parent_dir/src/utils/handleErrors/components.ts
@@ -0,0 +1,87 @@
+import { ComponentPublicInstance } from 'vue';
+
+const classifyRE = /(?:^|[-_])(\w)/g;
+const classify = (str: string) =>
+  str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+
+const ROOT_COMPONENT_NAME = '<Root>';
+const ANONYMOUS_COMPONENT_NAME = '<Anonymous>';
+
+const repeat = (str: string, n: number) => {
+  // string.repeat() is not supported by IE11, we fall back to just using the string in that case
+  return str.repeat ? str.repeat(n) : str;
+};
+
+export const formatComponentName = (vm?: ComponentPublicInstance | null, includeFile = false) => {
+  if (!vm) {
+    return ANONYMOUS_COMPONENT_NAME;
+  }
+
+  if (vm.$root === vm) {
+    return ROOT_COMPONENT_NAME;
+  }
+
+  // https://github.com/getsentry/sentry-javascript/issues/5204 $options can be undefined
+  if (!vm.$options) {
+    return ANONYMOUS_COMPONENT_NAME;
+  }
+
+  const options = vm.$options;
+
+  let name = options.name || options._componentTag;
+  const file = options.__file;
+  if (!name && file) {
+    const match = file.match(/([^/\\]+)\.vue$/);
+    if (match) {
+      name = match[1];
+    }
+  }
+
+  return (
+    (name ? `<${classify(name)}>` : ANONYMOUS_COMPONENT_NAME) +
+    (file && includeFile ? ` at ${file}` : '')
+  );
+};
+
+export const generateComponentTrace = (vm: ComponentPublicInstance | null) => {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  if (vm && (vm._isVue || vm.__isVue) && vm.$parent) {
+    const tree = [];
+    let currentRecursiveSequence = 0;
+    while (vm) {
+      if (tree.length > 0) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const last: any = tree[tree.length - 1];
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        if (last.constructor === vm.constructor) {
+          // eslint-disable-next-line no-plusplus
+          currentRecursiveSequence++;
+          vm = vm.$parent; // eslint-disable-line no-param-reassign
+          continue;
+        } else if (currentRecursiveSequence > 0) {
+          tree[tree.length - 1] = [last, currentRecursiveSequence];
+          currentRecursiveSequence = 0;
+        }
+      }
+      tree.push(vm);
+      vm = vm.$parent; // eslint-disable-line no-param-reassign
+    }
+
+    const formattedTree = tree
+      .map(
+        (vm, i) =>
+          `${
+            (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) +
+            (Array.isArray(vm)
+              ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+              : formatComponentName(vm))
+          }`,
+      )
+      .join('\n');
+
+    return `\n\nfound in\n\n${formattedTree}`;
+  }
+
+  return `\n\n(found in ${formatComponentName(vm)})`;
+};
diff --git a/parent_dir/src/utils/handleErrors/handleErrors.ts b/parent_dir/src/utils/handleErrors/handleErrors.ts
new file mode 100644
index 0000000..9f91ba0
--- /dev/null
+++ b/parent_dir/src/utils/handleErrors/handleErrors.ts
@@ -0,0 +1,160 @@
+import * as Sentry from '@sentry/vue';
+import { ComponentPublicInstance } from 'vue';
+import {
+  formatComponentName,
+  generateComponentTrace,
+} from '#root/src/utils/handleErrors/components';
+import { addExceptionMechanism } from '@sentry/utils';
+
+interface IClientAxiosErrorsHandlerParams {
+  error: any;
+  place?: string;
+  metadata?: IMetadata;
+}
+
+interface ICaptureExceptionParams {
+  error: any;
+  level?: 'info';
+  url?: string;
+  status?: number;
+  place?: string;
+  isAxios?: boolean;
+  metadata?: IMetadata;
+}
+
+type IMetadata = Record<string, string>;
+
+const setIsAxiosTag = (scope: Sentry.Scope, isAxios: boolean) => {
+  if (isAxios) {
+    scope.setTag('isAxios', true);
+  }
+};
+
+export const setInfoTag = (scope: Sentry.Scope, lifecycleHook?: string) => {
+  if (lifecycleHook) {
+    scope.setTag('lifecycleHook', lifecycleHook);
+  }
+};
+
+const setRequestUrlTag = (scope: Sentry.Scope, url?: string) => {
+  if (url) {
+    scope.setTag('requestUrl', url);
+  }
+};
+
+const setAxiosStatusTag = (scope: Sentry.Scope, status?: number) => {
+  if (status) {
+    scope.setTag('axiosStatus', status);
+  }
+};
+
+const setComponentNameTag = (scope: Sentry.Scope, name?: string) => {
+  if (name) {
+    scope.setTag('componentName', name);
+  }
+};
+
+export const setPlaceTag = (scope: Sentry.Scope, place?: string) => {
+  if (place) {
+    scope.setTag('place', place);
+  }
+};
+
+const setLevel = (scope: Sentry.Scope, level?: Sentry.SeverityLevel) => {
+  if (level) {
+    scope.setLevel(level);
+  }
+};
+
+const setMetadata = (scope: Sentry.Scope, metadata?: IMetadata) => {
+  if (metadata) {
+    scope.setContext('vue', metadata);
+  }
+};
+
+export const captureClientException = ({
+  error,
+  level,
+  url,
+  status,
+  place,
+  isAxios = false,
+  metadata,
+}: ICaptureExceptionParams) => {
+  // Capture exception in the next event loop, to make sure that all breadcrumbs are recorded in time.
+  setTimeout(() => {
+    Sentry?.withScope((scope: Sentry.Scope) => {
+      setLevel(scope, level);
+      setMetadata(scope, metadata);
+
+      setIsAxiosTag(scope, isAxios);
+      setInfoTag(scope, metadata?.lifecycleHook);
+      setRequestUrlTag(scope, url);
+      setAxiosStatusTag(scope, status);
+      setComponentNameTag(scope, metadata?.componentName);
+      setPlaceTag(scope, place);
+
+      scope.addEventProcessor((event) => {
+        addExceptionMechanism(event, {
+          handled: false,
+        });
+        return event;
+      });
+
+      Sentry?.captureException(error);
+    });
+  });
+};
+
+export const clientAxiosErrorsHandler = ({
+  error,
+  place,
+  metadata,
+}: IClientAxiosErrorsHandlerParams) => {
+  const captureParams: ICaptureExceptionParams = {
+    error,
+    isAxios: true,
+    place,
+    metadata,
+  };
+
+  if (error.response) {
+    captureParams.url = error.response.config.url;
+
+    captureParams.status = error?.response?.status;
+
+    if (captureParams.status && captureParams.status < 500) {
+      captureParams.level = 'info';
+    }
+  }
+
+  captureClientException(captureParams);
+  return true;
+};
+
+export const globalVueErrorsHandler = (
+  error: any,
+  vm?: ComponentPublicInstance | null,
+  lifecycleHook = '',
+) => {
+  if (!import.meta.env.SSR) {
+    const componentName = formatComponentName(vm);
+
+    const trace = vm ? generateComponentTrace(vm) : '';
+    const metadata: IMetadata = {
+      componentName,
+      lifecycleHook,
+      trace,
+    };
+
+    if (error?.name && error.name === 'AxiosError') {
+      clientAxiosErrorsHandler({ error, metadata });
+      return true;
+    }
+
+    captureClientException({
+      error,
+      metadata,
+    });
+  }
+};
diff --git a/parent_dir/src/utils/international.utils.js b/parent_dir/src/utils/international.utils.js
new file mode 100644
index 0000000..bc44ca7
--- /dev/null
+++ b/parent_dir/src/utils/international.utils.js
@@ -0,0 +1,91 @@
+// TODO: Как добавиться Азербайджанский нужно добавить для него urlLegalEntitiesLk: https://lk.cdek-az.com/
+const domainSettings = [
+    {
+        domains: ['www.cdek.kz', 'cdek.kz', 'website-kz.cdek.local'],
+        websiteId: 'kz',
+        localeCodeNameMap: 'ru:Русский;kz:Қазақ',
+        urlLegalEntitiesLk: 'https://lk.cdek.kz/user/login',
+    },
+    {
+        domains: ['www.cdek.by', 'cdek.by', 'website-by.cdek.local'],
+        websiteId: 'by',
+        localeCodeNameMap: 'ru:Русский;',
+        urlLegalEntitiesLk: 'https://lk.cdek.by/user/login',
+    },
+    {
+        domains: ['www.cdek-am.com', 'cdek-am.com', 'website-am.cdek.local'],
+        websiteId: 'am',
+        localeCodeNameMap: 'ru:Русский;am:հայերեն',
+        urlLegalEntitiesLk: 'https://lk.cdek-am.com/user/login',
+    },
+    {
+        domains: ['www.cdek.kg', 'cdek.kg', 'website-kg.cdek.local'],
+        websiteId: 'kg',
+        localeCodeNameMap: 'ru:Русский;kg:Киргизский',
+        urlLegalEntitiesLk: 'https://lk.cdek.kg/user/login',
+    },
+    {
+        domains: ['www.cdek.ge', 'cdek.ge', 'new.cdek.ge', 'website-ge.cdek.local'],
+        websiteId: 'ge',
+        localeCodeNameMap: 'ru:Русский;ge:Грузинский',
+        urlLegalEntitiesLk: 'https://lk.cdek.ge/user/login',
+    },
+    {
+        domains: ['www.cdek-express.uz', 'cdek-express.uz', 'website-uz.cdek.local'],
+        websiteId: 'uz',
+        localeCodeNameMap: 'ru:Русский;uz:Узбекский',
+        urlLegalEntitiesLk: 'https://lk.cdek-express.uz/user/login',
+    },
+    {
+        domains: ['website.cdek.local'],
+        websiteId: 'ru',
+        localeCodeNameMap: 'ru:Русский;kz:Қазақ;am:հայերեն',
+        urlLegalEntitiesLk: 'https://lk.cdek.ru/user/login',
+    },
+];
+export function getSettings() {
+    const hostname = window.location.hostname;
+    return domainSettings.find((item) => item.domains.includes(hostname));
+}
+export function getWebsiteId() {
+    const envWebsiteId = import.meta.env.VITE_WEBSITE_ID;
+    if (envWebsiteId) {
+        return envWebsiteId;
+    }
+    const settings = getSettings();
+    return settings?.websiteId || 'ru';
+}
+export function getLocaleCodeNameMap() {
+    const envLocaleMap = import.meta.env.VITE_LOCALE_CODE_NAME_MAP;
+    if (envLocaleMap) {
+        return envLocaleMap;
+    }
+    const settings = getSettings();
+    return settings?.localeCodeNameMap || 'ru:Русский';
+}
+export function getYandexMetrikaId() {
+    const envWebsiteId = import.meta.env.VITE_WEBSITE_ID;
+    if (envWebsiteId) {
+        // Когда в конфигах указан WEBSITE_ID значит метрику берем из конфигов, не думая
+        // Это особенно касается сайта
+        return import.meta.env.VITE_YANDEX_METRIKA_ID;
+    }
+    // Для ЛК получаем данные в зависимости от домена
+    const websiteId = getWebsiteId();
+    switch (websiteId) {
+        case 'kz':
+            return import.meta.env.VITE_YANDEX_METRIKA_ID_KZ;
+        case 'by':
+            return import.meta.env.VITE_YANDEX_METRIKA_ID_BY;
+        case 'am':
+            return import.meta.env.VITE_YANDEX_METRIKA_ID_AM;
+        case 'kg':
+            return import.meta.env.VITE_YANDEX_METRIKA_ID_KG;
+        case 'uz':
+            return import.meta.env.VITE_YANDEX_METRIKA_ID_UZ;
+        case 'ge':
+            return import.meta.env.VITE_YANDEX_METRIKA_ID_GE;
+        default:
+            return import.meta.env.VITE_YANDEX_METRIKA_ID;
+    }
+}
diff --git a/parent_dir/src/utils/local-storage.utils.js b/parent_dir/src/utils/local-storage.utils.js
new file mode 100644
index 0000000..109faa7
--- /dev/null
+++ b/parent_dir/src/utils/local-storage.utils.js
@@ -0,0 +1,17 @@
+export const setItemLS = (key, value) => {
+  if (typeof window !== 'undefined') {
+    localStorage?.setItem(key, value);
+  }
+};
+
+export const getItemLS = (key) => {
+  if (typeof window !== 'undefined') {
+    return localStorage?.getItem(key);
+  }
+};
+
+export const removeItemLS = (key) => {
+  if (typeof window !== 'undefined') {
+    localStorage?.removeItem(key);
+  }
+};
diff --git a/parent_dir/src/utils/map.locale.utils.ts b/parent_dir/src/utils/map.locale.utils.ts
new file mode 100644
index 0000000..2e42709
--- /dev/null
+++ b/parent_dir/src/utils/map.locale.utils.ts
@@ -0,0 +1,18 @@
+import { LkWebsiteId } from '@/env';
+import { Lang } from '@/types/locales';
+
+// Я не знаю почему тут нет беларуси, но оно же сейчас работает
+// А если добавим может чета отвалиться
+const localesMap: Record<Exclude<LkWebsiteId, 'by'>, string> = {
+  kz: 'kaz',
+  ru: 'rus',
+  am: 'hye',
+  kg: 'kir',
+  ge: 'kat',
+  uz: 'uzb',
+  az: 'aze',
+};
+
+export const getMappedLocale = (lang: Lang) => {
+  return localesMap[lang];
+};
diff --git a/parent_dir/src/utils/menu-utils.ts b/parent_dir/src/utils/menu-utils.ts
new file mode 100644
index 0000000..f3cf107
--- /dev/null
+++ b/parent_dir/src/utils/menu-utils.ts
@@ -0,0 +1,23 @@
+import { cdekConsoleError } from '#root/src/utils/console-wrapper';
+import { getItemLS, setItemLS } from '@/utils/local-storage.utils';
+
+const CITY_KEY = 'localstorage:city_key';
+
+export function getLocalCity() {
+  try {
+    const cityString = getItemLS(CITY_KEY) || null;
+
+    return cityString ? JSON.parse(cityString) : null;
+  } catch (error) {
+    cdekConsoleError(error);
+    return null;
+  }
+}
+
+export function saveLocalCity(city: unknown) {
+  try {
+    setItemLS(CITY_KEY, JSON.stringify(city));
+  } catch (error) {
+    cdekConsoleError(error);
+  }
+}
diff --git a/parent_dir/src/utils/menus.utils.js b/parent_dir/src/utils/menus.utils.js
new file mode 100644
index 0000000..1c7e269
--- /dev/null
+++ b/parent_dir/src/utils/menus.utils.js
@@ -0,0 +1,127 @@
+import { cdekConsoleError } from '@/utils/console-wrapper.ts';
+import { getItemLS, setItemLS } from '@/utils/local-storage.utils.js';
+
+export function addSlash(url) {
+  if (url.startsWith('http')) {
+    return url;
+  }
+  return url.charAt(0) !== '/' ? `/${url}` : url;
+}
+
+export function mappingMenusForBuild(menu, mappingMenu, currentMenu, depth, currentPath) {
+  return {
+    ...menu,
+    active: currentMenu.depth === depth ? currentPath === menu.url : menu.url === mappingMenu.url,
+  };
+}
+
+export function getMenuBuilt(currentMenu, rootMenus, reverseMapping) {
+  let submenus = [];
+  let menus = [];
+  if (currentMenu) {
+    let { depth } = currentMenu;
+    let mappingMenu = { ...currentMenu };
+    while (depth >= 0) {
+      if (depth > 0) {
+        submenus.unshift([
+          // eslint-disable-next-line no-loop-func,@typescript-eslint/no-loop-func
+          ...mappingMenu.menus.map((m) =>
+            mappingMenusForBuild(m, mappingMenu, currentMenu, depth, currentMenu.url),
+          ),
+        ]);
+      } else {
+        menus = [
+          ...mappingMenu.menus.map(
+            // eslint-disable-next-line no-loop-func,@typescript-eslint/no-loop-func
+            (m) => mappingMenusForBuild(m, mappingMenu, currentMenu, -1, currentMenu.url),
+          ),
+        ];
+        if (mappingMenu.menuChildren && mappingMenu.menuChildren.length && !submenus.length) {
+          submenus.push(mappingMenu.menuChildren);
+        }
+      }
+      if (mappingMenu.parentId) {
+        mappingMenu = { ...reverseMapping[mappingMenu.parentId] };
+      }
+      depth -= 1;
+    }
+  } else if (rootMenus.length) {
+    menus = [...rootMenus];
+    submenus = [menus[0].children];
+  }
+  if (submenus.length === 0 && rootMenus.length) {
+    submenus = [rootMenus[0].children];
+  }
+
+  return {
+    menus,
+    submenus,
+  };
+}
+
+export function removeLastPath(path) {
+  const splitPath = path.split('/');
+  splitPath.pop();
+  return splitPath.join('/');
+}
+
+export function trimPath(path) {
+  if (path.charAt(0) === '/') {
+    path = path.substr(1, path.length - 1);
+  }
+  if (path.charAt(path.length - 1) === '/') {
+    path = path.substr(0, path.length - 2);
+  }
+  return path;
+}
+
+export function getReverseMapping(menus, mapping, depth, parentId) {
+  mapping = mapping || {};
+  depth = typeof depth === 'number' ? depth + 1 : 0;
+  for (let i = 0; i < menus.length; i++) {
+    const menu = menus[i];
+    mapping[menu.id] = {
+      depth,
+      parentId,
+      url: menu.url,
+      menus: [...menus],
+      icon: menu.icon,
+      menuChildren: menu.children,
+    };
+    if (menu.children && menu.children.length) {
+      mapping = getReverseMapping(menu.children, mapping, depth, menu.id);
+    }
+  }
+  return mapping;
+}
+
+export function updateUrlMenu(menus) {
+  for (const menu of menus) {
+    menu.url = addSlash(menu.url);
+    if (menu.children && menu.children) {
+      menu.children = updateUrlMenu(menu.children);
+    }
+  }
+  return menus;
+}
+
+const CITY_KEY = 'localstorage:city_key';
+
+export function getLocalCity() {
+  try {
+    const cityString = getItemLS(CITY_KEY);
+
+    return cityString ? JSON.parse(cityString) : null;
+  } catch (error) {
+    cdekConsoleError(error);
+    return null;
+  }
+}
+
+export function saveLocalCity(city) {
+  try {
+    setItemLS(CITY_KEY, JSON.stringify(city));
+  } catch (error) {
+    cdekConsoleError(error);
+  }
+}
diff --git a/parent_dir/src/utils/metaDataHelpers.ts b/parent_dir/src/utils/metaDataHelpers.ts
new file mode 100644
index 0000000..6dbaf7a
--- /dev/null
+++ b/parent_dir/src/utils/metaDataHelpers.ts
@@ -0,0 +1,126 @@
+import { ActiveHeadEntry, Head, Unhead } from '@unhead/schema';
+import IPage from '#root/src/types/dto/page';
+import { getDefaultMetaData } from '#root/src/constants/default-meta-data';
+import { VueI18nTranslation } from 'vue-i18n';
+import cloneDeep from 'lodash/cloneDeep';
+
+interface MetaAsObj extends Head {
+  index: number;
+}
+
+export function prepareAdminPageMeta({ title, metaTags, scripts }: IPage) {
+  const result: Head = {};
+
+  if (title) {
+    result.title = title;
+  }
+
+  if (metaTags && metaTags.items && Array.isArray(metaTags.items)) {
+    result.meta = metaTags.items.map(({ name, value }) => {
+      return {
+        name,
+        content: value,
+      };
+    });
+  }
+
+  if (metaTags && !metaTags.items && Object.keys(metaTags).length > 0) {
+    result.meta = Object.keys(metaTags).map((name) => {
+      return {
+        name,
+        content: (metaTags as Record<string, string>)[name],
+      };
+    });
+  }
+
+  if (scripts && scripts.length && Array.isArray(scripts)) {
+    result.script = scripts.map(({ type, text }) => {
+      return {
+        type,
+        innerHTML: JSON.parse(text),
+        hid: 'ldjson',
+      };
+    });
+  }
+
+  return result;
+}
+
+export function prepareAllMeta(newMetaData: Head, defaultMeta: Head) {
+  try {
+    const result = cloneDeep(defaultMeta);
+
+    const { title: newTitle, meta: newMeta } = cloneDeep(newMetaData);
+
+    if (newTitle) {
+      result.title = newTitle;
+    }
+
+    const defaultMetaAsObj = result?.meta?.reduce((obj: Record<string, MetaAsObj>, curr, i) => {
+      const name = curr?.name;
+      if (name) {
+        obj[name as string] = { ...curr, index: i };
+      }
+
+      return obj;
+    }, {});
+
+    if (newMeta && defaultMetaAsObj) {
+      newMeta.forEach((el) => {
+        const newEl = { ...el, 'data-n-head': 'ssr' };
+
+        if ((newEl.name as string).startsWith('og:')) {
+          newEl.property = newEl.name;
+          delete newEl.name;
+        }
+
+        const name = el.name as string;
+
+        if (name && defaultMetaAsObj[name] && result.meta) {
+          result.meta[defaultMetaAsObj[name].index] = newEl;
+          return;
+        }
+
+        result?.meta?.push(newEl);
+      });
+    }
+    return result;
+  } catch (e) {
+    return defaultMeta;
+  }
+}
+export function updateHead(
+  t: VueI18nTranslation,
+  activeHead?: Unhead,
+  activeEntry?: ActiveHeadEntry<Head>,
+  metaData?: Head,
+): ActiveHeadEntry<Head> | undefined {
+  if (!activeHead) {
+    return;
+  }
+
+  if (activeEntry) {
+    activeEntry.dispose();
+  }
+
+  let newMetaData: Head = getDefaultMetaData(t);
+
+  if (metaData) {
+    newMetaData = prepareAllMeta(metaData, newMetaData) as Head;
+  }
+
+  return activeHead.push(newMetaData);
+}
+
+export function rewriteServerMetaData(
+  t: VueI18nTranslation,
+  activeHead?: Unhead,
+  activeEntry?: ActiveHeadEntry<Head>,
+  metaData?: Head,
+) {
+  const defaultMeta = document.querySelectorAll('[data-n-head="ssr"]');
+  const arrMeta = [...defaultMeta];
+  arrMeta.forEach((n) => n.remove());
+
+  return updateHead(t, activeHead, activeEntry, metaData);
+}
diff --git a/parent_dir/src/utils/offices.request.utils.ts b/parent_dir/src/utils/offices.request.utils.ts
new file mode 100644
index 0000000..f487408
--- /dev/null
+++ b/parent_dir/src/utils/offices.request.utils.ts
@@ -0,0 +1,61 @@
+import { CdekOfficeFilter, OfficeCoords, OfficeRequestData } from '@/types/dto/cdek-office';
+
+export function getOfficeUrl(
+  baseUrl: string,
+  data: Partial<OfficeRequestData>,
+  filter?: Partial<CdekOfficeFilter>,
+) {
+  const { locale } = data;
+
+  let url = `${baseUrl}?locale=${locale}`;
+
+  if (data && data.cityCode) {
+    url += `&cityCode=${data.cityCode}`;
+  }
+
+  if (data && data.coords) {
+    const keys = Object.keys(data.coords) as (keyof OfficeCoords)[];
+
+    keys.forEach((key) => {
+      url += `&${encodeURI(`coords[${key}]=${data.coords![key]}`)}`;
+    });
+  }
+
+  if (filter?.hasDressingRoom) {
+    url += `&hasDressingRoom=${filter.hasDressingRoom}`;
+  }
+
+  if (filter?.pvzType) {
+    url += `&type=${filter.pvzType}`;
+  }
+
+  if (filter?.maxWeight) {
+    url += `&maxWeight=${filter.maxWeight}`;
+  }
+
+  if (filter?.maxHeight) {
+    url += `&maxHeight=${filter.maxHeight}`;
+  }
+
+  if (filter?.maxDepth) {
+    url += `&maxDepth=${filter.maxDepth}`;
+  }
+
+  if (filter?.maxWidth) {
+    url += `&maxWidth=${filter.maxWidth}`;
+  }
+
+  if (filter?.isWorksOnWeekend) {
+    url += `&isWorksOnWeekend=true`;
+  }
+
+  if (filter?.isMoreThanMaxWeight) {
+    url += '&isMoreThanMaxWeight=true';
+  }
+
+  if (filter?.isLtl) {
+    url += `&isLtl=true`;
+  }
+
+  return url;
+}
diff --git a/parent_dir/src/utils/parsePage.utils.js b/parent_dir/src/utils/parsePage.utils.js
new file mode 100644
index 0000000..349d1cb
--- /dev/null
+++ b/parent_dir/src/utils/parsePage.utils.js
@@ -0,0 +1,177 @@
+import find from 'lodash/find';
+import { prepareAdminPageMeta } from '@/utils/metaDataHelpers';
+
+export const regexpTemplate = /(\{{.*?}})/;
+export const regexpOnlyBrTemplate = /^<br ?\/>\r\n$/;
+
+export function findComponentByPlace(templatePlace, components) {
+  const place = parseFloat(templatePlace.replace('{{', '').replace('}}', ''));
+  return find(components, { place });
+}
+
+export function convertPageArrayToObject(params) {
+  if (params && params.length) {
+    let object = {};
+    for (const {
+      name,
+      // label,
+      value,
+      paginated,
+      city,
+      cities,
+      item,
+      file,
+      items,
+      complex,
+      array,
+      link,
+      slides,
+      image,
+      columnLeft,
+      columnRight,
+      boolean,
+      list,
+      screens,
+      errors,
+      filesScreens,
+      sizes,
+      images,
+      inputs,
+      // values,
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      __typename,
+    } of params) {
+      try {
+        switch (__typename) {
+          case 'WebsitePageComponentParamString':
+            object[name] = value;
+            break;
+          case 'WebsitePageComponentParamCity':
+            object[name] = city;
+            break;
+          case 'WebsitePageComponentParamFile':
+            object[name] = file;
+            break;
+          case 'WebsitePageComponentParamOfficeOne':
+          case 'WebsitePageComponentParamNewItem':
+          case 'WebsitePageComponentParamPressNewItem':
+            object[name] = item;
+            break;
+          case 'WebsitePageComponentParamArrayString':
+            object[name] = array;
+            break;
+          case 'WebsitePageComponentParamFeedback':
+          case 'WebsitePageComponentParamDocument':
+          case 'WebsitePageComponentParamQuestion':
+          case 'WebsitePageComponentParamContact':
+          case 'WebsitePageComponentParamOffice':
+          case 'WebsitePageComponentParamNew':
+          case 'WebsitePageComponentParamPressNew':
+          case 'WebsitePageComponentParamGroupTariff':
+          case 'WebsitePageComponentParamPartner':
+          case 'WebsitePageComponentParamService':
+          case 'WebsitePageComponentParamVideos':
+          case 'WebsitePageComponentParamTile':
+          case 'WebsitePageComponentParamHistory':
+          case 'WebsitePageComponentParamGroupTop':
+          case 'WebsitePageComponentParamAlert':
+          case 'WebsitePageComponentParamPartnerOffer':
+          case 'WebsitePageComponentParamPartnerCarousel':
+          case 'WebsitePageComponentParamSocialLink':
+            object[name] = paginated;
+            break;
+          case 'WebsitePageComponentParamComplex':
+            object[name] = complex;
+            break;
+          case 'WebsitePageComponentParamQuestionsCategory':
+          case 'WebsitePageComponentParamAccreditationCategory':
+          case 'WebsitePageComponentParamTabs':
+          case 'WebsitePageComponentParamLinkBlock':
+          case 'WebsitePageComponentParamBanners':
+          case 'WebsitePageComponentParamActionsCarousel':
+            object[name] = items;
+            break;
+          case 'WebsitePageComponentParamLink':
+            object[name] = link;
+            break;
+          case 'WebsitePageComponentParamImage':
+            object[name] = image;
+            break;
+          case 'WebsitePageComponentParamSlides':
+            object[name] = slides;
+            break;
+          case 'WebsitePageComponentParamTwoColumnsBackground':
+            object = {
+              columnLeft,
+              columnRight,
+            };
+            break;
+          case 'WebsitePageComponentParamCities':
+            object[name] = cities;
+            break;
+          case 'WebsitePageComponentParamBoolean':
+            object[name] = boolean;
+            break;
+          case 'WebsitePageComponentParamList':
+          case 'WebsitePageComponentParamPopularProduct':
+            object[name] = list;
+            break;
+          case 'WebsitePageComponentParamScreenColumn':
+            object[name] = screens;
+            break;
+          case 'WebsitePageComponentParamError':
+            object[name] = errors;
+            break;
+          case 'WebsitePageComponentParamFilesForScreens':
+            object[name] = filesScreens;
+            break;
+          case 'WebsitePageComponentParamSizes':
+            object[name] = sizes;
+            break;
+          case 'WebsitePageComponentParamImagesGroup':
+            object[name] = images;
+            break;
+          case 'WebsitePageComponentParamPackageFormInputs':
+            object[name] = inputs;
+            break;
+          default:
+            throw new Error(`Error: RenderComponent __typename: ${__typename} not determined`);
+        }
+      } catch (error) {
+        // Error
+      }
+    }
+    return object;
+  }
+  return null;
+}
+
+export const getComponentParams = (component) => {
+  const { params } = component;
+
+  if (component.__typename === 'rest') {
+    return params;
+  }
+
+  return convertPageArrayToObject(params);
+};
+
+export const getPageData = (res) => {
+  return {
+    page: {
+      content: res?.content,
+      components: res?.components?.map((el) => ({
+        ...el,
+        // Нужен, что бы вью правильно перерисовывал страницы при навигации на клиенте.
+        // При этом нужен максимально рандомный
+        uuid: `${el.name}-${Math.random()}`,
+      })),
+      metaTags: res?.metaTags,
+      js: res?.js,
+      city: res?.city,
+    },
+    isTilda: res?.isTilda,
+    metaData: prepareAdminPageMeta(res),
+    layout: res?.layout,
+  };
+};
diff --git a/parent_dir/src/utils/pluralize.utils.ts b/parent_dir/src/utils/pluralize.utils.ts
new file mode 100644
index 0000000..6559c4f
--- /dev/null
+++ b/parent_dir/src/utils/pluralize.utils.ts
@@ -0,0 +1,15 @@
+export default function pluralize(number: number, one: string, two: string, five: string): string {
+  let n = Math.abs(number);
+  n %= 100;
+  if (n >= 5 && n <= 20) {
+    return five;
+  }
+  n %= 10;
+  if (n === 1) {
+    return one;
+  }
+  if (n >= 2 && n <= 4) {
+    return two;
+  }
+  return five;
+}
diff --git a/parent_dir/src/utils/reach-goal.ts b/parent_dir/src/utils/reach-goal.ts
new file mode 100644
index 0000000..e7cf905
--- /dev/null
+++ b/parent_dir/src/utils/reach-goal.ts
@@ -0,0 +1,44 @@
+import { getYandexMetrikaId } from '@/utils/international.utils';
+
+const metrikaId = getYandexMetrikaId();
+
+type Parameters = {
+  [key: string]: string | number | boolean | null;
+};
+
+export function reachGoal(event: string, params?: Parameters) {
+  window.ym && event && window.ym(metrikaId, 'reachGoal', event, params);
+}
+
+export function sendParams(parameters: string | Parameters): void {
+  window.ym && window.ym(metrikaId, 'params', parameters);
+}
+
+export function sendUserParams(parameters: string | Parameters): void {
+  window.ym && window.ym(metrikaId, 'userParams', parameters);
+}
+
+interface IDLProduct {
+  name: string;
+  category: string;
+  quantity: number;
+  price: number;
+}
+
+interface IDLActionType {
+  actionField: {
+    id: string;
+  };
+  products: IDLProduct[];
+}
+
+interface IDataLayer {
+  ecommerce: {
+    currencyCode: string;
+    purchase: IDLActionType;
+  };
+}
+
+export function pushDataLayer(data: IDataLayer) {
+  window.dataLayer && window.dataLayer.push(data);
+}
diff --git a/parent_dir/src/utils/redis-storage/RedisError.ts b/parent_dir/src/utils/redis-storage/RedisError.ts
new file mode 100644
index 0000000..031488f
--- /dev/null
+++ b/parent_dir/src/utils/redis-storage/RedisError.ts
@@ -0,0 +1,3 @@
+export class RedisError {
+  message = 'redisError';
+}
diff --git a/parent_dir/src/utils/set-locale-to-link.ts b/parent_dir/src/utils/set-locale-to-link.ts
new file mode 100644
index 0000000..1bf7256
--- /dev/null
+++ b/parent_dir/src/utils/set-locale-to-link.ts
@@ -0,0 +1,36 @@
+export function setLocaleToLink(href: string, locale: string, isSite: boolean) {
+  if (!href) {
+    return '';
+  }
+
+  if (!isSite) {
+    return href;
+  }
+  // На международке у нас могут быть ссылки с кз на ру, с ру на кз или еще куда-нибудь.
+  // Все, что написано в следующих репозиториях ожидает текующую локаль.
+  // Т.е если мы на кз, и видим ссылку /ru/smth, то результатом будет /kz/ru/smth
+  // Я не знаю как нам декетить локаль кроме как ожидать что два символа завернутые в слеши в начале
+  // строки - это префикс локали
+  if (/^(\/\w\w\/)/.test(href)) {
+    return href;
+  }
+
+  // Если внешняя ссылка ничего не длаем
+  if (href.startsWith('http')) {
+    return href;
+  }
+
+  if (href === '/') {
+    return `/${locale}`;
+  }
+
+  if (href.startsWith(`/${locale}/`) || href === `/${locale}`) {
+    return href;
+  }
+
+  if (href.startsWith('/')) {
+    return `/${locale}${href}`;
+  }
+
+  return `/${locale}/${href}`;
+}
diff --git a/parent_dir/src/utils/string.utils.ts b/parent_dir/src/utils/string.utils.ts
new file mode 100644
index 0000000..b8df2ba
--- /dev/null
+++ b/parent_dir/src/utils/string.utils.ts
@@ -0,0 +1 @@
+export const removeSideSlashes = (value = '') => value.replace(/^\/|\/$/g, '');
diff --git a/parent_dir/src/utils/time.js b/parent_dir/src/utils/time.js
new file mode 100644
index 0000000..5f3c513
--- /dev/null
+++ b/parent_dir/src/utils/time.js
@@ -0,0 +1,74 @@
+export function roundNumber(number, approximation) {
+  number = parseFloat(number);
+  const int = parseInt(number / approximation, 10);
+  return int * approximation + approximation;
+}
+
+export function getRoundedTime(
+  timeString,
+  approximation,
+  minHours,
+  maxHours,
+  minMinutes = 0,
+  maxMinutes = 0,
+) {
+  if (timeString) {
+    const [hours, minutesStr] = timeString.split(':');
+    let minutes = minutesStr;
+
+    if (
+      maxHours > parseFloat(hours) &&
+      minHours < parseFloat(hours) &&
+      parseFloat(minutes) % approximation > 0
+    ) {
+      minutes = `0${roundNumber(minutes, approximation)}`.slice(-2);
+      return `${hours}:${minutes}`;
+    }
+    if (maxHours <= parseFloat(hours)) {
+      if (parseFloat(minutes) < maxMinutes) {
+        minutes =
+          parseFloat(minutes) % approximation > 0
+            ? `0${roundNumber(minutes, approximation)}`.slice(-2)
+            : minutes;
+      } else {
+        minutes = `0${maxMinutes}`.slice(-2);
+      }
+      return `${maxHours}:${minutes}`;
+    }
+    if (minHours > parseFloat(hours)) {
+      const h = `0${minHours}`.slice(-2);
+      const m = `0${minMinutes}`.slice(-2);
+      return `${h}:${m}`;
+    }
+    if (minHours === parseFloat(hours)) {
+      if (minMinutes > parseFloat(minutes)) {
+        const h = `0${minHours}`.slice(-2);
+        const m = `0${minMinutes}`.slice(-2);
+        return `${h}:${m}`;
+      }
+      if (parseFloat(minutes) % approximation > 0) {
+        minutes = `0${roundNumber(minutes, approximation)}`.slice(-2);
+        return `${hours}:${minutes}`;
+      }
+    }
+  }
+  return timeString;
+}
+
+export function getCurrentTime(deadline, currentToMs) {
+  const total = Date.parse(deadline) - currentToMs;
+  const seconds = Math.floor((total / 1000) % 60);
+  const minutes = Math.floor((total / 1000 / 60) % 60);
+  const hours = Math.floor((total / (1000 * 60 * 60)) % 24);
+  const days = Math.floor(total / (1000 * 60 * 60 * 24));
+  if (total > 0) {
+    return {
+      total,
+      seconds,
+      minutes,
+      hours,
+      days,
+    };
+  }
+  return null;
+}