/******/ (function() { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ 8577:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

module.exports = __webpack_require__(5632);

/***/ }),

/***/ 556:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);
var settle = __webpack_require__(494);
var cookies = __webpack_require__(8861);
var buildURL = __webpack_require__(1971);
var buildFullPath = __webpack_require__(8251);
var parseHeaders = __webpack_require__(5283);
var isURLSameOrigin = __webpack_require__(7858);
var transitionalDefaults = __webpack_require__(617);
var AxiosError = __webpack_require__(4808);
var CanceledError = __webpack_require__(1259);
var parseProtocol = __webpack_require__(8499);
module.exports = function xhrAdapter(config) {
  return new Promise(function dispatchXhrRequest(resolve, reject) {
    var requestData = config.data;
    var requestHeaders = config.headers;
    var responseType = config.responseType;
    var onCanceled;
    function done() {
      if (config.cancelToken) {
        config.cancelToken.unsubscribe(onCanceled);
      }
      if (config.signal) {
        config.signal.removeEventListener('abort', onCanceled);
      }
    }
    if (utils.isFormData(requestData) && utils.isStandardBrowserEnv()) {
      delete requestHeaders['Content-Type']; // Let the browser set it
    }

    var request = new XMLHttpRequest();

    // HTTP basic authentication
    if (config.auth) {
      var username = config.auth.username || '';
      var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';
      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
    }
    var 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
      var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
      var responseData = !responseType || responseType === 'text' || responseType === 'json' ? request.responseText : request.response;
      var response = {
        data: responseData,
        status: request.status,
        statusText: request.statusText,
        headers: responseHeaders,
        config: config,
        request: 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, request));

      // Clean up request
      request = null;
    };

    // Handle timeout
    request.ontimeout = function handleTimeout() {
      var timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded';
      var 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 (utils.isStandardBrowserEnv()) {
      // Add xsrf header
      var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ? cookies.read(config.xsrfCookieName) : undefined;
      if (xsrfValue) {
        requestHeaders[config.xsrfHeaderName] = xsrfValue;
      }
    }

    // Add headers to the request
    if ('setRequestHeader' in request) {
      utils.forEach(requestHeaders, function setRequestHeader(val, key) {
        if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
          // Remove Content-Type if data is undefined
          delete requestHeaders[key];
        } else {
          // Otherwise add header to the request
          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', config.onDownloadProgress);
    }

    // Not all browsers support upload events
    if (typeof config.onUploadProgress === 'function' && request.upload) {
      request.upload.addEventListener('progress', config.onUploadProgress);
    }
    if (config.cancelToken || config.signal) {
      // Handle cancellation
      // eslint-disable-next-line func-names
      onCanceled = function onCanceled(cancel) {
        if (!request) {
          return;
        }
        reject(!cancel || cancel && cancel.type ? new CanceledError() : cancel);
        request.abort();
        request = null;
      };
      config.cancelToken && config.cancelToken.subscribe(onCanceled);
      if (config.signal) {
        config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);
      }
    }
    if (!requestData) {
      requestData = null;
    }
    var protocol = parseProtocol(fullPath);
    if (protocol && ['http', 'https', 'file'].indexOf(protocol) === -1) {
      reject(new AxiosError('Unsupported protocol ' + protocol + ':', AxiosError.ERR_BAD_REQUEST, config));
      return;
    }

    // Send the request
    request.send(requestData);
  });
};

/***/ }),

/***/ 5632:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);
var bind = __webpack_require__(8197);
var Axios = __webpack_require__(6764);
var mergeConfig = __webpack_require__(1530);
var defaults = __webpack_require__(5015);

/**
 * Create an instance of Axios
 *
 * @param {Object} defaultConfig The default config for the instance
 * @return {Axios} A new instance of Axios
 */
function createInstance(defaultConfig) {
  var context = new Axios(defaultConfig);
  var instance = bind(Axios.prototype.request, context);

  // Copy axios.prototype to instance
  utils.extend(instance, Axios.prototype, context);

  // Copy context to instance
  utils.extend(instance, context);

  // Factory for creating new instances
  instance.create = function create(instanceConfig) {
    return createInstance(mergeConfig(defaultConfig, instanceConfig));
  };
  return instance;
}

// Create the default instance to be exported
var axios = createInstance(defaults);

// Expose Axios class to allow class inheritance
axios.Axios = Axios;

// Expose Cancel & CancelToken
axios.CanceledError = __webpack_require__(1259);
axios.CancelToken = __webpack_require__(1081);
axios.isCancel = __webpack_require__(7109);
axios.VERSION = (__webpack_require__(9137).version);
axios.toFormData = __webpack_require__(5257);

// Expose AxiosError class
axios.AxiosError = __webpack_require__(4808);

// alias for CanceledError for backward compatibility
axios.Cancel = axios.CanceledError;

// Expose all/spread
axios.all = function all(promises) {
  return Promise.all(promises);
};
axios.spread = __webpack_require__(1870);

// Expose isAxiosError
axios.isAxiosError = __webpack_require__(5754);
module.exports = axios;

// Allow use of default import syntax in TypeScript
module.exports["default"] = axios;

/***/ }),

/***/ 1081:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var CanceledError = __webpack_require__(1259);

/**
 * A `CancelToken` is an object that can be used to request cancellation of an operation.
 *
 * @class
 * @param {Function} executor The executor function.
 */
function CancelToken(executor) {
  if (typeof executor !== 'function') {
    throw new TypeError('executor must be a function.');
  }
  var resolvePromise;
  this.promise = new Promise(function promiseExecutor(resolve) {
    resolvePromise = resolve;
  });
  var token = this;

  // eslint-disable-next-line func-names
  this.promise.then(function (cancel) {
    if (!token._listeners) return;
    var i;
    var l = token._listeners.length;
    for (i = 0; i < l; i++) {
      token._listeners[i](cancel);
    }
    token._listeners = null;
  });

  // eslint-disable-next-line func-names
  this.promise.then = function (onfulfilled) {
    var _resolve;
    // eslint-disable-next-line func-names
    var promise = new Promise(function (resolve) {
      token.subscribe(resolve);
      _resolve = resolve;
    }).then(onfulfilled);
    promise.cancel = function reject() {
      token.unsubscribe(_resolve);
    };
    return promise;
  };
  executor(function cancel(message) {
    if (token.reason) {
      // Cancellation has already been requested
      return;
    }
    token.reason = new CanceledError(message);
    resolvePromise(token.reason);
  });
}

/**
 * Throws a `CanceledError` if cancellation has been requested.
 */
CancelToken.prototype.throwIfRequested = function throwIfRequested() {
  if (this.reason) {
    throw this.reason;
  }
};

/**
 * Subscribe to the cancel signal
 */

CancelToken.prototype.subscribe = function 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
 */

CancelToken.prototype.unsubscribe = function unsubscribe(listener) {
  if (!this._listeners) {
    return;
  }
  var 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`.
 */
CancelToken.source = function source() {
  var cancel;
  var token = new CancelToken(function executor(c) {
    cancel = c;
  });
  return {
    token: token,
    cancel: cancel
  };
};
module.exports = CancelToken;

/***/ }),

/***/ 1259:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var AxiosError = __webpack_require__(4808);
var utils = __webpack_require__(5666);

/**
 * A `CanceledError` is an object that is thrown when an operation is canceled.
 *
 * @class
 * @param {string=} message The message.
 */
function CanceledError(message) {
  // eslint-disable-next-line no-eq-null,eqeqeq
  AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED);
  this.name = 'CanceledError';
}
utils.inherits(CanceledError, AxiosError, {
  __CANCEL__: true
});
module.exports = CanceledError;

/***/ }),

/***/ 7109:
/***/ (function(module) {

"use strict";


module.exports = function isCancel(value) {
  return !!(value && value.__CANCEL__);
};

/***/ }),

/***/ 6764:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);
var buildURL = __webpack_require__(1971);
var InterceptorManager = __webpack_require__(1820);
var dispatchRequest = __webpack_require__(3506);
var mergeConfig = __webpack_require__(1530);
var buildFullPath = __webpack_require__(8251);
var validator = __webpack_require__(4544);
var validators = validator.validators;
/**
 * Create a new instance of Axios
 *
 * @param {Object} instanceConfig The default config for the instance
 */
function Axios(instanceConfig) {
  this.defaults = instanceConfig;
  this.interceptors = {
    request: new InterceptorManager(),
    response: new InterceptorManager()
  };
}

/**
 * Dispatch a request
 *
 * @param {Object} config The config specific for this request (merged with this.defaults)
 */
Axios.prototype.request = function 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);

  // Set config.method
  if (config.method) {
    config.method = config.method.toLowerCase();
  } else if (this.defaults.method) {
    config.method = this.defaults.method.toLowerCase();
  } else {
    config.method = 'get';
  }
  var transitional = config.transitional;
  if (transitional !== undefined) {
    validator.assertOptions(transitional, {
      silentJSONParsing: validators.transitional(validators.boolean),
      forcedJSONParsing: validators.transitional(validators.boolean),
      clarifyTimeoutError: validators.transitional(validators.boolean)
    }, false);
  }

  // filter out skipped interceptors
  var requestInterceptorChain = [];
  var 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);
  });
  var responseInterceptorChain = [];
  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
    responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
  });
  var promise;
  if (!synchronousRequestInterceptors) {
    var chain = [dispatchRequest, undefined];
    Array.prototype.unshift.apply(chain, requestInterceptorChain);
    chain = chain.concat(responseInterceptorChain);
    promise = Promise.resolve(config);
    while (chain.length) {
      promise = promise.then(chain.shift(), chain.shift());
    }
    return promise;
  }
  var newConfig = config;
  while (requestInterceptorChain.length) {
    var onFulfilled = requestInterceptorChain.shift();
    var onRejected = requestInterceptorChain.shift();
    try {
      newConfig = onFulfilled(newConfig);
    } catch (error) {
      onRejected(error);
      break;
    }
  }
  try {
    promise = dispatchRequest(newConfig);
  } catch (error) {
    return Promise.reject(error);
  }
  while (responseInterceptorChain.length) {
    promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
  }
  return promise;
};
Axios.prototype.getUri = function getUri(config) {
  config = mergeConfig(this.defaults, config);
  var 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: method,
      url: 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: method,
        headers: isForm ? {
          'Content-Type': 'multipart/form-data'
        } : {},
        url: url,
        data: data
      }));
    };
  }
  Axios.prototype[method] = generateHTTPMethod();
  Axios.prototype[method + 'Form'] = generateHTTPMethod(true);
});
module.exports = Axios;

/***/ }),

/***/ 4808:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);

/**
 * 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);
  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: this.config,
      code: this.code,
      status: this.response && this.response.status ? this.response.status : null
    };
  }
});
var prototype = AxiosError.prototype;
var 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'
// eslint-disable-next-line func-names
].forEach(function (code) {
  descriptors[code] = {
    value: code
  };
});
Object.defineProperties(AxiosError, descriptors);
Object.defineProperty(prototype, 'isAxiosError', {
  value: true
});

// eslint-disable-next-line func-names
AxiosError.from = function (error, code, config, request, response, customProps) {
  var axiosError = Object.create(prototype);
  utils.toFlatObject(error, axiosError, function filter(obj) {
    return obj !== Error.prototype;
  });
  AxiosError.call(axiosError, error.message, code, config, request, response);
  axiosError.name = error.name;
  customProps && Object.assign(axiosError, customProps);
  return axiosError;
};
module.exports = AxiosError;

/***/ }),

/***/ 1820:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);
function InterceptorManager() {
  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
 */
InterceptorManager.prototype.use = function use(fulfilled, rejected, options) {
  this.handlers.push({
    fulfilled: fulfilled,
    rejected: 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`
 */
InterceptorManager.prototype.eject = function eject(id) {
  if (this.handlers[id]) {
    this.handlers[id] = null;
  }
};

/**
 * 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
 */
InterceptorManager.prototype.forEach = function forEach(fn) {
  utils.forEach(this.handlers, function forEachHandler(h) {
    if (h !== null) {
      fn(h);
    }
  });
};
module.exports = InterceptorManager;

/***/ }),

/***/ 8251:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var isAbsoluteURL = __webpack_require__(7001);
var combineURLs = __webpack_require__(4851);

/**
 * 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
 */
module.exports = function buildFullPath(baseURL, requestedURL) {
  if (baseURL && !isAbsoluteURL(requestedURL)) {
    return combineURLs(baseURL, requestedURL);
  }
  return requestedURL;
};

/***/ }),

/***/ 3506:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);
var transformData = __webpack_require__(2886);
var isCancel = __webpack_require__(7109);
var defaults = __webpack_require__(5015);
var CanceledError = __webpack_require__(1259);

/**
 * Throws a `CanceledError` if cancellation has been requested.
 */
function throwIfCancellationRequested(config) {
  if (config.cancelToken) {
    config.cancelToken.throwIfRequested();
  }
  if (config.signal && config.signal.aborted) {
    throw new CanceledError();
  }
}

/**
 * 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
 */
module.exports = function dispatchRequest(config) {
  throwIfCancellationRequested(config);

  // Ensure headers exist
  config.headers = config.headers || {};

  // Transform request data
  config.data = transformData.call(config, config.data, config.headers, config.transformRequest);

  // Flatten headers
  config.headers = utils.merge(config.headers.common || {}, config.headers[config.method] || {}, config.headers);
  utils.forEach(['delete', 'get', 'head', 'post', 'put', 'patch', 'common'], function cleanHeaderConfig(method) {
    delete config.headers[method];
  });
  var adapter = config.adapter || defaults.adapter;
  return adapter(config).then(function onAdapterResolution(response) {
    throwIfCancellationRequested(config);

    // Transform response data
    response.data = transformData.call(config, response.data, response.headers, config.transformResponse);
    return response;
  }, function onAdapterRejection(reason) {
    if (!isCancel(reason)) {
      throwIfCancellationRequested(config);

      // Transform response data
      if (reason && reason.response) {
        reason.response.data = transformData.call(config, reason.response.data, reason.response.headers, config.transformResponse);
      }
    }
    return Promise.reject(reason);
  });
};

/***/ }),

/***/ 1530:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);

/**
 * 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
 */
module.exports = function mergeConfig(config1, config2) {
  // eslint-disable-next-line no-param-reassign
  config2 = config2 || {};
  var config = {};
  function getMergedValue(target, source) {
    if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
      return utils.merge(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(prop) {
    if (!utils.isUndefined(config2[prop])) {
      return getMergedValue(config1[prop], config2[prop]);
    } else if (!utils.isUndefined(config1[prop])) {
      return getMergedValue(undefined, config1[prop]);
    }
  }

  // eslint-disable-next-line consistent-return
  function valueFromConfig2(prop) {
    if (!utils.isUndefined(config2[prop])) {
      return getMergedValue(undefined, config2[prop]);
    }
  }

  // eslint-disable-next-line consistent-return
  function defaultToConfig2(prop) {
    if (!utils.isUndefined(config2[prop])) {
      return getMergedValue(undefined, config2[prop]);
    } else if (!utils.isUndefined(config1[prop])) {
      return getMergedValue(undefined, config1[prop]);
    }
  }

  // eslint-disable-next-line consistent-return
  function mergeDirectKeys(prop) {
    if (prop in config2) {
      return getMergedValue(config1[prop], config2[prop]);
    } else if (prop in config1) {
      return getMergedValue(undefined, config1[prop]);
    }
  }
  var 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
  };
  utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
    var merge = mergeMap[prop] || mergeDeepProperties;
    var configValue = merge(prop);
    utils.isUndefined(configValue) && merge !== mergeDirectKeys || (config[prop] = configValue);
  });
  return config;
};

/***/ }),

/***/ 494:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var AxiosError = __webpack_require__(4808);

/**
 * 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.
 */
module.exports = function settle(resolve, reject, response) {
  var 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));
  }
};

/***/ }),

/***/ 2886:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);
var defaults = __webpack_require__(5015);

/**
 * Transform the data for a request or a response
 *
 * @param {Object|String} data The data to be transformed
 * @param {Array} headers The headers for the request or response
 * @param {Array|Function} fns A single function or Array of functions
 * @returns {*} The resulting transformed data
 */
module.exports = function transformData(data, headers, fns) {
  var context = this || defaults;
  /*eslint no-param-reassign:0*/
  utils.forEach(fns, function transform(fn) {
    data = fn.call(context, data, headers);
  });
  return data;
};

/***/ }),

/***/ 5015:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);
var normalizeHeaderName = __webpack_require__(9546);
var AxiosError = __webpack_require__(4808);
var transitionalDefaults = __webpack_require__(617);
var toFormData = __webpack_require__(5257);
var DEFAULT_CONTENT_TYPE = {
  'Content-Type': 'application/x-www-form-urlencoded'
};
function setContentTypeIfUnset(headers, value) {
  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
    headers['Content-Type'] = value;
  }
}
function getDefaultAdapter() {
  var adapter;
  if (typeof XMLHttpRequest !== 'undefined') {
    // For browsers use XHR adapter
    adapter = __webpack_require__(556);
  } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {
    // For node use HTTP adapter
    adapter = __webpack_require__(556);
  }
  return adapter;
}
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);
}
var defaults = {
  transitional: transitionalDefaults,
  adapter: getDefaultAdapter(),
  transformRequest: [function transformRequest(data, headers) {
    normalizeHeaderName(headers, 'Accept');
    normalizeHeaderName(headers, 'Content-Type');
    if (utils.isFormData(data) || 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)) {
      setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
      return data.toString();
    }
    var isObjectPayload = utils.isObject(data);
    var contentType = headers && headers['Content-Type'];
    var isFileList;
    if ((isFileList = utils.isFileList(data)) || isObjectPayload && contentType === 'multipart/form-data') {
      var _FormData = this.env && this.env.FormData;
      return toFormData(isFileList ? {
        'files[]': data
      } : data, _FormData && new _FormData());
    } else if (isObjectPayload || contentType === 'application/json') {
      setContentTypeIfUnset(headers, 'application/json');
      return stringifySafely(data);
    }
    return data;
  }],
  transformResponse: [function transformResponse(data) {
    var transitional = this.transitional || defaults.transitional;
    var silentJSONParsing = transitional && transitional.silentJSONParsing;
    var forcedJSONParsing = transitional && transitional.forcedJSONParsing;
    var strictJSONParsing = !silentJSONParsing && this.responseType === 'json';
    if (strictJSONParsing || forcedJSONParsing && utils.isString(data) && data.length) {
      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: __webpack_require__(2762)
  },
  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);
});
module.exports = defaults;

/***/ }),

/***/ 617:
/***/ (function(module) {

"use strict";


module.exports = {
  silentJSONParsing: true,
  forcedJSONParsing: true,
  clarifyTimeoutError: false
};

/***/ }),

/***/ 9137:
/***/ (function(module) {

module.exports = {
  "version": "0.27.2"
};

/***/ }),

/***/ 8197:
/***/ (function(module) {

"use strict";


module.exports = function bind(fn, thisArg) {
  return function wrap() {
    var args = new Array(arguments.length);
    for (var i = 0; i < args.length; i++) {
      args[i] = arguments[i];
    }
    return fn.apply(thisArg, args);
  };
};

/***/ }),

/***/ 1971:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);
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
 * @returns {string} The formatted url
 */
module.exports = function buildURL(url, params, paramsSerializer) {
  /*eslint no-param-reassign:0*/
  if (!params) {
    return url;
  }
  var serializedParams;
  if (paramsSerializer) {
    serializedParams = paramsSerializer(params);
  } else if (utils.isURLSearchParams(params)) {
    serializedParams = params.toString();
  } else {
    var parts = [];
    utils.forEach(params, function serialize(val, key) {
      if (val === null || typeof val === 'undefined') {
        return;
      }
      if (utils.isArray(val)) {
        key = key + '[]';
      } else {
        val = [val];
      }
      utils.forEach(val, function parseValue(v) {
        if (utils.isDate(v)) {
          v = v.toISOString();
        } else if (utils.isObject(v)) {
          v = JSON.stringify(v);
        }
        parts.push(encode(key) + '=' + encode(v));
      });
    });
    serializedParams = parts.join('&');
  }
  if (serializedParams) {
    var hashmarkIndex = url.indexOf('#');
    if (hashmarkIndex !== -1) {
      url = url.slice(0, hashmarkIndex);
    }
    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
  }
  return url;
};

/***/ }),

/***/ 4851:
/***/ (function(module) {

"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
 */
module.exports = function combineURLs(baseURL, relativeURL) {
  return relativeURL ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '') : baseURL;
};

/***/ }),

/***/ 8861:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);
module.exports = utils.isStandardBrowserEnv() ?
// Standard browser envs support document.cookie
function standardBrowserEnv() {
  return {
    write: function write(name, value, expires, path, domain, secure) {
      var 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) {
      var 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() {}
  };
}();

/***/ }),

/***/ 7001:
/***/ (function(module) {

"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
 */
module.exports = 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);
};

/***/ }),

/***/ 5754:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);

/**
 * 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
 */
module.exports = function isAxiosError(payload) {
  return utils.isObject(payload) && payload.isAxiosError === true;
};

/***/ }),

/***/ 7858:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);
module.exports = utils.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() {
  var msie = /(msie|trident)/i.test(navigator.userAgent);
  var urlParsingNode = document.createElement('a');
  var originURL;

  /**
  * Parse a URL to discover it's components
  *
  * @param {String} url The URL to be parsed
  * @returns {Object}
  */
  function resolveURL(url) {
    var 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) {
    var 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;
  };
}();

/***/ }),

/***/ 9546:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);
module.exports = function normalizeHeaderName(headers, normalizedName) {
  utils.forEach(headers, function processHeader(value, name) {
    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
      headers[normalizedName] = value;
      delete headers[name];
    }
  });
};

/***/ }),

/***/ 2762:
/***/ (function(module) {

// eslint-disable-next-line strict
module.exports = null;

/***/ }),

/***/ 5283:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);

// Headers whose duplicates are ignored by node
// c.f. https://nodejs.org/api/http.html#http_message_headers
var ignoreDuplicateOf = ['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} headers Headers needing to be parsed
 * @returns {Object} Headers parsed into an object
 */
module.exports = function parseHeaders(headers) {
  var parsed = {};
  var key;
  var val;
  var i;
  if (!headers) {
    return parsed;
  }
  utils.forEach(headers.split('\n'), function parser(line) {
    i = line.indexOf(':');
    key = utils.trim(line.substr(0, i)).toLowerCase();
    val = utils.trim(line.substr(i + 1));
    if (key) {
      if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
        return;
      }
      if (key === 'set-cookie') {
        parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
      } else {
        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
      }
    }
  });
  return parsed;
};

/***/ }),

/***/ 8499:
/***/ (function(module) {

"use strict";


module.exports = function parseProtocol(url) {
  var match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
  return match && match[1] || '';
};

/***/ }),

/***/ 1870:
/***/ (function(module) {

"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}
 */
module.exports = function spread(callback) {
  return function wrap(arr) {
    return callback.apply(null, arr);
  };
};

/***/ }),

/***/ 5257:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(5666);

/**
 * Convert a data object to FormData
 * @param {Object} obj
 * @param {?Object} [formData]
 * @returns {Object}
 **/

function toFormData(obj, formData) {
  // eslint-disable-next-line no-param-reassign
  formData = formData || new FormData();
  var stack = [];
  function convertValue(value) {
    if (value === null) return '';
    if (utils.isDate(value)) {
      return value.toISOString();
    }
    if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) {
      return typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);
    }
    return value;
  }
  function build(data, parentKey) {
    if (utils.isPlainObject(data) || utils.isArray(data)) {
      if (stack.indexOf(data) !== -1) {
        throw Error('Circular reference detected in ' + parentKey);
      }
      stack.push(data);
      utils.forEach(data, function each(value, key) {
        if (utils.isUndefined(value)) return;
        var fullKey = parentKey ? parentKey + '.' + key : key;
        var arr;
        if (value && !parentKey && typeof value === 'object') {
          if (utils.endsWith(key, '{}')) {
            // eslint-disable-next-line no-param-reassign
            value = JSON.stringify(value);
          } else if (utils.endsWith(key, '[]') && (arr = utils.toArray(value))) {
            // eslint-disable-next-line func-names
            arr.forEach(function (el) {
              !utils.isUndefined(el) && formData.append(fullKey, convertValue(el));
            });
            return;
          }
        }
        build(value, fullKey);
      });
      stack.pop();
    } else {
      formData.append(parentKey, convertValue(data));
    }
  }
  build(obj);
  return formData;
}
module.exports = toFormData;

/***/ }),

/***/ 4544:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var VERSION = (__webpack_require__(9137).version);
var AxiosError = __webpack_require__(4808);
var validators = {};

// eslint-disable-next-line func-names
['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach(function (type, i) {
  validators[type] = function validator(thing) {
    return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;
  };
});
var 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 function (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
 */

function assertOptions(options, schema, allowUnknown) {
  if (typeof options !== 'object') {
    throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);
  }
  var keys = Object.keys(options);
  var i = keys.length;
  while (i-- > 0) {
    var opt = keys[i];
    var validator = schema[opt];
    if (validator) {
      var value = options[opt];
      var 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);
    }
  }
}
module.exports = {
  assertOptions: assertOptions,
  validators: validators
};

/***/ }),

/***/ 5666:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var bind = __webpack_require__(8197);

// utils is a library of generic helper functions non-specific to axios

var toString = Object.prototype.toString;

// eslint-disable-next-line func-names
var kindOf = function (cache) {
  // eslint-disable-next-line func-names
  return function (thing) {
    var str = toString.call(thing);
    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
  };
}(Object.create(null));
function kindOfTest(type) {
  type = type.toLowerCase();
  return function isKindOf(thing) {
    return kindOf(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
 */
function isArray(val) {
  return Array.isArray(val);
}

/**
 * Determine if a value is undefined
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if the value is undefined, otherwise false
 */
function isUndefined(val) {
  return typeof val === 'undefined';
}

/**
 * Determine if a value is a Buffer
 *
 * @param {Object} 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) && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);
}

/**
 * Determine if a value is an ArrayBuffer
 *
 * @function
 * @param {Object} val The value to test
 * @returns {boolean} True if value is an ArrayBuffer, otherwise false
 */
var isArrayBuffer = kindOfTest('ArrayBuffer');

/**
 * Determine if a value is a view on an ArrayBuffer
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
 */
function isArrayBufferView(val) {
  var 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 {Object} val The value to test
 * @returns {boolean} True if value is a String, otherwise false
 */
function isString(val) {
  return typeof val === 'string';
}

/**
 * Determine if a value is a Number
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Number, otherwise false
 */
function isNumber(val) {
  return typeof val === 'number';
}

/**
 * Determine if a value is an Object
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is an Object, otherwise false
 */
function isObject(val) {
  return val !== null && typeof val === 'object';
}

/**
 * Determine if a value is a plain Object
 *
 * @param {Object} val The value to test
 * @return {boolean} True if value is a plain Object, otherwise false
 */
function isPlainObject(val) {
  if (kindOf(val) !== 'object') {
    return false;
  }
  var prototype = Object.getPrototypeOf(val);
  return prototype === null || prototype === Object.prototype;
}

/**
 * Determine if a value is a Date
 *
 * @function
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Date, otherwise false
 */
var isDate = kindOfTest('Date');

/**
 * Determine if a value is a File
 *
 * @function
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a File, otherwise false
 */
var isFile = kindOfTest('File');

/**
 * Determine if a value is a Blob
 *
 * @function
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Blob, otherwise false
 */
var isBlob = kindOfTest('Blob');

/**
 * Determine if a value is a FileList
 *
 * @function
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a File, otherwise false
 */
var isFileList = kindOfTest('FileList');

/**
 * Determine if a value is a Function
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Function, otherwise false
 */
function isFunction(val) {
  return toString.call(val) === '[object Function]';
}

/**
 * Determine if a value is a Stream
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Stream, otherwise false
 */
function isStream(val) {
  return isObject(val) && isFunction(val.pipe);
}

/**
 * Determine if a value is a FormData
 *
 * @param {Object} thing The value to test
 * @returns {boolean} True if value is an FormData, otherwise false
 */
function isFormData(thing) {
  var 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
 * @function
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a URLSearchParams object, otherwise false
 */
var 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
 */
function trim(str) {
  return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '');
}

/**
 * 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'
 */
function isStandardBrowserEnv() {
  if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' || navigator.product === 'NativeScript' || navigator.product === 'NS')) {
    return false;
  }
  return typeof window !== 'undefined' && typeof document !== 'undefined';
}

/**
 * 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
 */
function forEach(obj, fn) {
  // Don't bother if no value provided
  if (obj === null || typeof obj === 'undefined') {
    return;
  }

  // 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 (var i = 0, l = obj.length; i < l; i++) {
      fn.call(null, obj[i], i, obj);
    }
  } else {
    // Iterate over object keys
    for (var key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
        fn.call(null, obj[key], key, obj);
      }
    }
  }
}

/**
 * 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, ... */
) {
  var result = {};
  function assignValue(val, key) {
    if (isPlainObject(result[key]) && isPlainObject(val)) {
      result[key] = merge(result[key], val);
    } else if (isPlainObject(val)) {
      result[key] = merge({}, val);
    } else if (isArray(val)) {
      result[key] = val.slice();
    } else {
      result[key] = val;
    }
  }
  for (var i = 0, l = arguments.length; i < l; 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
 * @return {Object} The resulting value of object a
 */
function extend(a, b, thisArg) {
  forEach(b, function assignValue(val, key) {
    if (thisArg && typeof val === 'function') {
      a[key] = bind(val, thisArg);
    } else {
      a[key] = val;
    }
  });
  return a;
}

/**
 * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
 *
 * @param {string} content with BOM
 * @return {string} content value without BOM
 */
function 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]
 */

function inherits(constructor, superConstructor, props, descriptors) {
  constructor.prototype = Object.create(superConstructor.prototype, descriptors);
  constructor.prototype.constructor = constructor;
  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} [filter]
 * @returns {Object}
 */

function toFlatObject(sourceObj, destObj, filter) {
  var props;
  var i;
  var prop;
  var merged = {};
  destObj = destObj || {};
  do {
    props = Object.getOwnPropertyNames(sourceObj);
    i = props.length;
    while (i-- > 0) {
      prop = props[i];
      if (!merged[prop]) {
        destObj[prop] = sourceObj[prop];
        merged[prop] = true;
      }
    }
    sourceObj = Object.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}
 */
function endsWith(str, searchString, position) {
  str = String(str);
  if (position === undefined || position > str.length) {
    position = str.length;
  }
  position -= searchString.length;
  var lastIndex = str.indexOf(searchString, position);
  return lastIndex !== -1 && lastIndex === position;
}

/**
 * Returns new array from array like object
 * @param {*} [thing]
 * @returns {Array}
 */
function toArray(thing) {
  if (!thing) return null;
  var i = thing.length;
  if (isUndefined(i)) return null;
  var arr = new Array(i);
  while (i-- > 0) {
    arr[i] = thing[i];
  }
  return arr;
}

// eslint-disable-next-line func-names
var isTypedArray = function (TypedArray) {
  // eslint-disable-next-line func-names
  return function (thing) {
    return TypedArray && thing instanceof TypedArray;
  };
}(typeof Uint8Array !== 'undefined' && Object.getPrototypeOf(Uint8Array));
module.exports = {
  isArray: isArray,
  isArrayBuffer: isArrayBuffer,
  isBuffer: isBuffer,
  isFormData: isFormData,
  isArrayBufferView: isArrayBufferView,
  isString: isString,
  isNumber: isNumber,
  isObject: isObject,
  isPlainObject: isPlainObject,
  isUndefined: isUndefined,
  isDate: isDate,
  isFile: isFile,
  isBlob: isBlob,
  isFunction: isFunction,
  isStream: isStream,
  isURLSearchParams: isURLSearchParams,
  isStandardBrowserEnv: isStandardBrowserEnv,
  forEach: forEach,
  merge: merge,
  extend: extend,
  trim: trim,
  stripBOM: stripBOM,
  inherits: inherits,
  toFlatObject: toFlatObject,
  kindOf: kindOf,
  kindOfTest: kindOfTest,
  endsWith: endsWith,
  toArray: toArray,
  isTypedArray: isTypedArray,
  isFileList: isFileList
};

/***/ }),

/***/ 2819:
/***/ (function(module, exports) {

var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
	Copyright (c) 2018 Jed Watson.
	Licensed under the MIT License (MIT), see
	http://jedwatson.github.io/classnames
*/
/* global define */

(function () {
  'use strict';

  var hasOwn = {}.hasOwnProperty;
  var nativeCodeString = '[native code]';
  function classNames() {
    var classes = [];
    for (var i = 0; i < arguments.length; i++) {
      var arg = arguments[i];
      if (!arg) continue;
      var argType = typeof arg;
      if (argType === 'string' || argType === 'number') {
        classes.push(arg);
      } else if (Array.isArray(arg)) {
        if (arg.length) {
          var inner = classNames.apply(null, arg);
          if (inner) {
            classes.push(inner);
          }
        }
      } else if (argType === 'object') {
        if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {
          classes.push(arg.toString());
          continue;
        }
        for (var key in arg) {
          if (hasOwn.call(arg, key) && arg[key]) {
            classes.push(key);
          }
        }
      }
    }
    return classes.join(' ');
  }
  if ( true && module.exports) {
    classNames.default = classNames;
    module.exports = classNames;
  } else if (true) {
    // register as 'classnames', consistent with npm package name
    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {
      return classNames;
    }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  } else {}
})();

/***/ }),

/***/ 1569:
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "clsx": function() { return /* binding */ clsx; }
/* harmony export */ });
function r(e) {
  var t,
    f,
    n = "";
  if ("string" == typeof e || "number" == typeof e) n += e;else if ("object" == typeof e) if (Array.isArray(e)) for (t = 0; t < e.length; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);else for (t in e) e[t] && (n && (n += " "), n += t);
  return n;
}
function clsx() {
  for (var e, t, f = 0, n = ""; f < arguments.length;) (e = arguments[f++]) && (t = r(e)) && (n && (n += " "), n += t);
  return n;
}
/* harmony default export */ __webpack_exports__["default"] = (clsx);

/***/ }),

/***/ 8789:
/***/ (function(module) {

!function (t, e) {
   true ? module.exports = e() : 0;
}(this, function () {
  "use strict";

  var t = 1e3,
    e = 6e4,
    n = 36e5,
    r = "millisecond",
    i = "second",
    s = "minute",
    u = "hour",
    a = "day",
    o = "week",
    f = "month",
    h = "quarter",
    c = "year",
    d = "date",
    l = "Invalid Date",
    $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,
    y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,
    M = {
      name: "en",
      weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
      months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
      ordinal: function ordinal(t) {
        var e = ["th", "st", "nd", "rd"],
          n = t % 100;
        return "[" + t + (e[(n - 20) % 10] || e[n] || e[0]) + "]";
      }
    },
    m = function m(t, e, n) {
      var r = String(t);
      return !r || r.length >= e ? t : "" + Array(e + 1 - r.length).join(n) + t;
    },
    v = {
      s: m,
      z: function z(t) {
        var e = -t.utcOffset(),
          n = Math.abs(e),
          r = Math.floor(n / 60),
          i = n % 60;
        return (e <= 0 ? "+" : "-") + m(r, 2, "0") + ":" + m(i, 2, "0");
      },
      m: function t(e, n) {
        if (e.date() < n.date()) return -t(n, e);
        var r = 12 * (n.year() - e.year()) + (n.month() - e.month()),
          i = e.clone().add(r, f),
          s = n - i < 0,
          u = e.clone().add(r + (s ? -1 : 1), f);
        return +(-(r + (n - i) / (s ? i - u : u - i)) || 0);
      },
      a: function a(t) {
        return t < 0 ? Math.ceil(t) || 0 : Math.floor(t);
      },
      p: function p(t) {
        return {
          M: f,
          y: c,
          w: o,
          d: a,
          D: d,
          h: u,
          m: s,
          s: i,
          ms: r,
          Q: h
        }[t] || String(t || "").toLowerCase().replace(/s$/, "");
      },
      u: function u(t) {
        return void 0 === t;
      }
    },
    g = "en",
    D = {};
  D[g] = M;
  var p = function p(t) {
      return t instanceof _;
    },
    S = function t(e, n, r) {
      var i;
      if (!e) return g;
      if ("string" == typeof e) {
        var s = e.toLowerCase();
        D[s] && (i = s), n && (D[s] = n, i = s);
        var u = e.split("-");
        if (!i && u.length > 1) return t(u[0]);
      } else {
        var a = e.name;
        D[a] = e, i = a;
      }
      return !r && i && (g = i), i || !r && g;
    },
    w = function w(t, e) {
      if (p(t)) return t.clone();
      var n = "object" == typeof e ? e : {};
      return n.date = t, n.args = arguments, new _(n);
    },
    O = v;
  O.l = S, O.i = p, O.w = function (t, e) {
    return w(t, {
      locale: e.$L,
      utc: e.$u,
      x: e.$x,
      $offset: e.$offset
    });
  };
  var _ = function () {
      function M(t) {
        this.$L = S(t.locale, null, !0), this.parse(t);
      }
      var m = M.prototype;
      return m.parse = function (t) {
        this.$d = function (t) {
          var e = t.date,
            n = t.utc;
          if (null === e) return new Date(NaN);
          if (O.u(e)) return new Date();
          if (e instanceof Date) return new Date(e);
          if ("string" == typeof e && !/Z$/i.test(e)) {
            var r = e.match($);
            if (r) {
              var i = r[2] - 1 || 0,
                s = (r[7] || "0").substring(0, 3);
              return n ? new Date(Date.UTC(r[1], i, r[3] || 1, r[4] || 0, r[5] || 0, r[6] || 0, s)) : new Date(r[1], i, r[3] || 1, r[4] || 0, r[5] || 0, r[6] || 0, s);
            }
          }
          return new Date(e);
        }(t), this.$x = t.x || {}, this.init();
      }, m.init = function () {
        var t = this.$d;
        this.$y = t.getFullYear(), this.$M = t.getMonth(), this.$D = t.getDate(), this.$W = t.getDay(), this.$H = t.getHours(), this.$m = t.getMinutes(), this.$s = t.getSeconds(), this.$ms = t.getMilliseconds();
      }, m.$utils = function () {
        return O;
      }, m.isValid = function () {
        return !(this.$d.toString() === l);
      }, m.isSame = function (t, e) {
        var n = w(t);
        return this.startOf(e) <= n && n <= this.endOf(e);
      }, m.isAfter = function (t, e) {
        return w(t) < this.startOf(e);
      }, m.isBefore = function (t, e) {
        return this.endOf(e) < w(t);
      }, m.$g = function (t, e, n) {
        return O.u(t) ? this[e] : this.set(n, t);
      }, m.unix = function () {
        return Math.floor(this.valueOf() / 1e3);
      }, m.valueOf = function () {
        return this.$d.getTime();
      }, m.startOf = function (t, e) {
        var n = this,
          r = !!O.u(e) || e,
          h = O.p(t),
          l = function l(t, e) {
            var i = O.w(n.$u ? Date.UTC(n.$y, e, t) : new Date(n.$y, e, t), n);
            return r ? i : i.endOf(a);
          },
          $ = function $(t, e) {
            return O.w(n.toDate()[t].apply(n.toDate("s"), (r ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e)), n);
          },
          y = this.$W,
          M = this.$M,
          m = this.$D,
          v = "set" + (this.$u ? "UTC" : "");
        switch (h) {
          case c:
            return r ? l(1, 0) : l(31, 11);
          case f:
            return r ? l(1, M) : l(0, M + 1);
          case o:
            var g = this.$locale().weekStart || 0,
              D = (y < g ? y + 7 : y) - g;
            return l(r ? m - D : m + (6 - D), M);
          case a:
          case d:
            return $(v + "Hours", 0);
          case u:
            return $(v + "Minutes", 1);
          case s:
            return $(v + "Seconds", 2);
          case i:
            return $(v + "Milliseconds", 3);
          default:
            return this.clone();
        }
      }, m.endOf = function (t) {
        return this.startOf(t, !1);
      }, m.$set = function (t, e) {
        var n,
          o = O.p(t),
          h = "set" + (this.$u ? "UTC" : ""),
          l = (n = {}, n[a] = h + "Date", n[d] = h + "Date", n[f] = h + "Month", n[c] = h + "FullYear", n[u] = h + "Hours", n[s] = h + "Minutes", n[i] = h + "Seconds", n[r] = h + "Milliseconds", n)[o],
          $ = o === a ? this.$D + (e - this.$W) : e;
        if (o === f || o === c) {
          var y = this.clone().set(d, 1);
          y.$d[l]($), y.init(), this.$d = y.set(d, Math.min(this.$D, y.daysInMonth())).$d;
        } else l && this.$d[l]($);
        return this.init(), this;
      }, m.set = function (t, e) {
        return this.clone().$set(t, e);
      }, m.get = function (t) {
        return this[O.p(t)]();
      }, m.add = function (r, h) {
        var d,
          l = this;
        r = Number(r);
        var $ = O.p(h),
          y = function y(t) {
            var e = w(l);
            return O.w(e.date(e.date() + Math.round(t * r)), l);
          };
        if ($ === f) return this.set(f, this.$M + r);
        if ($ === c) return this.set(c, this.$y + r);
        if ($ === a) return y(1);
        if ($ === o) return y(7);
        var M = (d = {}, d[s] = e, d[u] = n, d[i] = t, d)[$] || 1,
          m = this.$d.getTime() + r * M;
        return O.w(m, this);
      }, m.subtract = function (t, e) {
        return this.add(-1 * t, e);
      }, m.format = function (t) {
        var e = this,
          n = this.$locale();
        if (!this.isValid()) return n.invalidDate || l;
        var r = t || "YYYY-MM-DDTHH:mm:ssZ",
          i = O.z(this),
          s = this.$H,
          u = this.$m,
          a = this.$M,
          o = n.weekdays,
          f = n.months,
          h = function h(t, n, i, s) {
            return t && (t[n] || t(e, r)) || i[n].slice(0, s);
          },
          c = function c(t) {
            return O.s(s % 12 || 12, t, "0");
          },
          d = n.meridiem || function (t, e, n) {
            var r = t < 12 ? "AM" : "PM";
            return n ? r.toLowerCase() : r;
          },
          $ = {
            YY: String(this.$y).slice(-2),
            YYYY: this.$y,
            M: a + 1,
            MM: O.s(a + 1, 2, "0"),
            MMM: h(n.monthsShort, a, f, 3),
            MMMM: h(f, a),
            D: this.$D,
            DD: O.s(this.$D, 2, "0"),
            d: String(this.$W),
            dd: h(n.weekdaysMin, this.$W, o, 2),
            ddd: h(n.weekdaysShort, this.$W, o, 3),
            dddd: o[this.$W],
            H: String(s),
            HH: O.s(s, 2, "0"),
            h: c(1),
            hh: c(2),
            a: d(s, u, !0),
            A: d(s, u, !1),
            m: String(u),
            mm: O.s(u, 2, "0"),
            s: String(this.$s),
            ss: O.s(this.$s, 2, "0"),
            SSS: O.s(this.$ms, 3, "0"),
            Z: i
          };
        return r.replace(y, function (t, e) {
          return e || $[t] || i.replace(":", "");
        });
      }, m.utcOffset = function () {
        return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
      }, m.diff = function (r, d, l) {
        var $,
          y = O.p(d),
          M = w(r),
          m = (M.utcOffset() - this.utcOffset()) * e,
          v = this - M,
          g = O.m(this, M);
        return g = ($ = {}, $[c] = g / 12, $[f] = g, $[h] = g / 3, $[o] = (v - m) / 6048e5, $[a] = (v - m) / 864e5, $[u] = v / n, $[s] = v / e, $[i] = v / t, $)[y] || v, l ? g : O.a(g);
      }, m.daysInMonth = function () {
        return this.endOf(f).$D;
      }, m.$locale = function () {
        return D[this.$L];
      }, m.locale = function (t, e) {
        if (!t) return this.$L;
        var n = this.clone(),
          r = S(t, e, !0);
        return r && (n.$L = r), n;
      }, m.clone = function () {
        return O.w(this.$d, this);
      }, m.toDate = function () {
        return new Date(this.valueOf());
      }, m.toJSON = function () {
        return this.isValid() ? this.toISOString() : null;
      }, m.toISOString = function () {
        return this.$d.toISOString();
      }, m.toString = function () {
        return this.$d.toUTCString();
      }, M;
    }(),
    T = _.prototype;
  return w.prototype = T, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", f], ["$y", c], ["$D", d]].forEach(function (t) {
    T[t[1]] = function (e) {
      return this.$g(e, t[0], t[1]);
    };
  }), w.extend = function (t, e) {
    return t.$i || (t(e, _, w), t.$i = !0), w;
  }, w.locale = S, w.isDayjs = p, w.unix = function (t) {
    return w(1e3 * t);
  }, w.en = D[g], w.Ls = D, w.p = {}, w;
});

/***/ }),

/***/ 8053:
/***/ (function(module) {

!function (t, s) {
   true ? module.exports = s() : 0;
}(this, function () {
  "use strict";

  var t,
    s,
    n = 1e3,
    i = 6e4,
    e = 36e5,
    r = 864e5,
    o = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,
    u = 31536e6,
    h = 2592e6,
    a = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/,
    d = {
      years: u,
      months: h,
      days: r,
      hours: e,
      minutes: i,
      seconds: n,
      milliseconds: 1,
      weeks: 6048e5
    },
    c = function c(t) {
      return t instanceof p;
    },
    f = function f(t, s, n) {
      return new p(t, n, s.$l);
    },
    m = function m(t) {
      return s.p(t) + "s";
    },
    l = function l(t) {
      return t < 0;
    },
    $ = function $(t) {
      return l(t) ? Math.ceil(t) : Math.floor(t);
    },
    y = function y(t) {
      return Math.abs(t);
    },
    g = function g(t, s) {
      return t ? l(t) ? {
        negative: !0,
        format: "" + y(t) + s
      } : {
        negative: !1,
        format: "" + t + s
      } : {
        negative: !1,
        format: ""
      };
    },
    p = function () {
      function l(t, s, n) {
        var i = this;
        if (this.$d = {}, this.$l = n, void 0 === t && (this.$ms = 0, this.parseFromMilliseconds()), s) return f(t * d[m(s)], this);
        if ("number" == typeof t) return this.$ms = t, this.parseFromMilliseconds(), this;
        if ("object" == typeof t) return Object.keys(t).forEach(function (s) {
          i.$d[m(s)] = t[s];
        }), this.calMilliseconds(), this;
        if ("string" == typeof t) {
          var e = t.match(a);
          if (e) {
            var r = e.slice(2).map(function (t) {
              return null != t ? Number(t) : 0;
            });
            return this.$d.years = r[0], this.$d.months = r[1], this.$d.weeks = r[2], this.$d.days = r[3], this.$d.hours = r[4], this.$d.minutes = r[5], this.$d.seconds = r[6], this.calMilliseconds(), this;
          }
        }
        return this;
      }
      var y = l.prototype;
      return y.calMilliseconds = function () {
        var t = this;
        this.$ms = Object.keys(this.$d).reduce(function (s, n) {
          return s + (t.$d[n] || 0) * d[n];
        }, 0);
      }, y.parseFromMilliseconds = function () {
        var t = this.$ms;
        this.$d.years = $(t / u), t %= u, this.$d.months = $(t / h), t %= h, this.$d.days = $(t / r), t %= r, this.$d.hours = $(t / e), t %= e, this.$d.minutes = $(t / i), t %= i, this.$d.seconds = $(t / n), t %= n, this.$d.milliseconds = t;
      }, y.toISOString = function () {
        var t = g(this.$d.years, "Y"),
          s = g(this.$d.months, "M"),
          n = +this.$d.days || 0;
        this.$d.weeks && (n += 7 * this.$d.weeks);
        var i = g(n, "D"),
          e = g(this.$d.hours, "H"),
          r = g(this.$d.minutes, "M"),
          o = this.$d.seconds || 0;
        this.$d.milliseconds && (o += this.$d.milliseconds / 1e3);
        var u = g(o, "S"),
          h = t.negative || s.negative || i.negative || e.negative || r.negative || u.negative,
          a = e.format || r.format || u.format ? "T" : "",
          d = (h ? "-" : "") + "P" + t.format + s.format + i.format + a + e.format + r.format + u.format;
        return "P" === d || "-P" === d ? "P0D" : d;
      }, y.toJSON = function () {
        return this.toISOString();
      }, y.format = function (t) {
        var n = t || "YYYY-MM-DDTHH:mm:ss",
          i = {
            Y: this.$d.years,
            YY: s.s(this.$d.years, 2, "0"),
            YYYY: s.s(this.$d.years, 4, "0"),
            M: this.$d.months,
            MM: s.s(this.$d.months, 2, "0"),
            D: this.$d.days,
            DD: s.s(this.$d.days, 2, "0"),
            H: this.$d.hours,
            HH: s.s(this.$d.hours, 2, "0"),
            m: this.$d.minutes,
            mm: s.s(this.$d.minutes, 2, "0"),
            s: this.$d.seconds,
            ss: s.s(this.$d.seconds, 2, "0"),
            SSS: s.s(this.$d.milliseconds, 3, "0")
          };
        return n.replace(o, function (t, s) {
          return s || String(i[t]);
        });
      }, y.as = function (t) {
        return this.$ms / d[m(t)];
      }, y.get = function (t) {
        var s = this.$ms,
          n = m(t);
        return "milliseconds" === n ? s %= 1e3 : s = "weeks" === n ? $(s / d[n]) : this.$d[n], 0 === s ? 0 : s;
      }, y.add = function (t, s, n) {
        var i;
        return i = s ? t * d[m(s)] : c(t) ? t.$ms : f(t, this).$ms, f(this.$ms + i * (n ? -1 : 1), this);
      }, y.subtract = function (t, s) {
        return this.add(t, s, !0);
      }, y.locale = function (t) {
        var s = this.clone();
        return s.$l = t, s;
      }, y.clone = function () {
        return f(this.$ms, this);
      }, y.humanize = function (s) {
        return t().add(this.$ms, "ms").locale(this.$l).fromNow(!s);
      }, y.milliseconds = function () {
        return this.get("milliseconds");
      }, y.asMilliseconds = function () {
        return this.as("milliseconds");
      }, y.seconds = function () {
        return this.get("seconds");
      }, y.asSeconds = function () {
        return this.as("seconds");
      }, y.minutes = function () {
        return this.get("minutes");
      }, y.asMinutes = function () {
        return this.as("minutes");
      }, y.hours = function () {
        return this.get("hours");
      }, y.asHours = function () {
        return this.as("hours");
      }, y.days = function () {
        return this.get("days");
      }, y.asDays = function () {
        return this.as("days");
      }, y.weeks = function () {
        return this.get("weeks");
      }, y.asWeeks = function () {
        return this.as("weeks");
      }, y.months = function () {
        return this.get("months");
      }, y.asMonths = function () {
        return this.as("months");
      }, y.years = function () {
        return this.get("years");
      }, y.asYears = function () {
        return this.as("years");
      }, l;
    }();
  return function (n, i, e) {
    t = e, s = e().$utils(), e.duration = function (t, s) {
      var n = e.locale();
      return f(t, {
        $l: n
      }, s);
    }, e.isDuration = c;
    var r = i.prototype.add,
      o = i.prototype.subtract;
    i.prototype.add = function (t, s) {
      return c(t) && (t = t.asMilliseconds()), r.bind(this)(t, s);
    }, i.prototype.subtract = function (t, s) {
      return c(t) && (t = t.asMilliseconds()), o.bind(this)(t, s);
    };
  };
});

/***/ }),

/***/ 7029:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var reactIs = __webpack_require__(4436);

/**
 * Copyright 2015, Yahoo! Inc.
 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
 */
var REACT_STATICS = {
  childContextTypes: true,
  contextType: true,
  contextTypes: true,
  defaultProps: true,
  displayName: true,
  getDefaultProps: true,
  getDerivedStateFromError: true,
  getDerivedStateFromProps: true,
  mixins: true,
  propTypes: true,
  type: true
};
var KNOWN_STATICS = {
  name: true,
  length: true,
  prototype: true,
  caller: true,
  callee: true,
  arguments: true,
  arity: true
};
var FORWARD_REF_STATICS = {
  '$$typeof': true,
  render: true,
  defaultProps: true,
  displayName: true,
  propTypes: true
};
var MEMO_STATICS = {
  '$$typeof': true,
  compare: true,
  defaultProps: true,
  displayName: true,
  propTypes: true,
  type: true
};
var TYPE_STATICS = {};
TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
function getStatics(component) {
  // React v16.11 and below
  if (reactIs.isMemo(component)) {
    return MEMO_STATICS;
  } // React v16.12 and above

  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;
}
var defineProperty = Object.defineProperty;
var getOwnPropertyNames = Object.getOwnPropertyNames;
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
var getPrototypeOf = Object.getPrototypeOf;
var objectPrototype = Object.prototype;
function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
  if (typeof sourceComponent !== 'string') {
    // don't hoist over string (html) components
    if (objectPrototype) {
      var inheritedComponent = getPrototypeOf(sourceComponent);
      if (inheritedComponent && inheritedComponent !== objectPrototype) {
        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
      }
    }
    var keys = getOwnPropertyNames(sourceComponent);
    if (getOwnPropertySymbols) {
      keys = keys.concat(getOwnPropertySymbols(sourceComponent));
    }
    var targetStatics = getStatics(targetComponent);
    var sourceStatics = getStatics(sourceComponent);
    for (var i = 0; i < keys.length; ++i) {
      var key = keys[i];
      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
        try {
          // Avoid failures from read-only properties
          defineProperty(targetComponent, key, descriptor);
        } catch (e) {}
      }
    }
  }
  return targetComponent;
}
module.exports = hoistNonReactStatics;

/***/ }),

/***/ 2346:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


// A linked list to keep track of recently-used-ness
var _classCallCheck = (__webpack_require__(8403)["default"]);
var _createClass = (__webpack_require__(2467)["default"]);
var Yallist = __webpack_require__(6451);
var MAX = Symbol('max');
var LENGTH = Symbol('length');
var LENGTH_CALCULATOR = Symbol('lengthCalculator');
var ALLOW_STALE = Symbol('allowStale');
var MAX_AGE = Symbol('maxAge');
var DISPOSE = Symbol('dispose');
var NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet');
var LRU_LIST = Symbol('lruList');
var CACHE = Symbol('cache');
var UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet');
var naiveLength = function naiveLength() {
  return 1;
};

// lruList is a yallist where the head is the youngest
// item, and the tail is the oldest.  the list contains the Hit
// objects as the entries.
// Each Hit object has a reference to its Yallist.Node.  This
// never changes.
//
// cache is a Map (or PseudoMap) that matches the keys to
// the Yallist.Node object.
var LRUCache = /*#__PURE__*/function () {
  function LRUCache(options) {
    _classCallCheck(this, LRUCache);
    if (typeof options === 'number') options = {
      max: options
    };
    if (!options) options = {};
    if (options.max && (typeof options.max !== 'number' || options.max < 0)) throw new TypeError('max must be a non-negative number');
    // Kind of weird to have a default max of Infinity, but oh well.
    var max = this[MAX] = options.max || Infinity;
    var lc = options.length || naiveLength;
    this[LENGTH_CALCULATOR] = typeof lc !== 'function' ? naiveLength : lc;
    this[ALLOW_STALE] = options.stale || false;
    if (options.maxAge && typeof options.maxAge !== 'number') throw new TypeError('maxAge must be a number');
    this[MAX_AGE] = options.maxAge || 0;
    this[DISPOSE] = options.dispose;
    this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
    this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
    this.reset();
  }

  // resize the cache when the max changes.
  _createClass(LRUCache, [{
    key: "max",
    get: function get() {
      return this[MAX];
    },
    set: function set(mL) {
      if (typeof mL !== 'number' || mL < 0) throw new TypeError('max must be a non-negative number');
      this[MAX] = mL || Infinity;
      trim(this);
    }
  }, {
    key: "allowStale",
    get: function get() {
      return this[ALLOW_STALE];
    },
    set: function set(allowStale) {
      this[ALLOW_STALE] = !!allowStale;
    }
  }, {
    key: "maxAge",
    get: function get() {
      return this[MAX_AGE];
    }

    // resize the cache when the lengthCalculator changes.
    ,
    set: function set(mA) {
      if (typeof mA !== 'number') throw new TypeError('maxAge must be a non-negative number');
      this[MAX_AGE] = mA;
      trim(this);
    }
  }, {
    key: "lengthCalculator",
    get: function get() {
      return this[LENGTH_CALCULATOR];
    },
    set: function set(lC) {
      var _this = this;
      if (typeof lC !== 'function') lC = naiveLength;
      if (lC !== this[LENGTH_CALCULATOR]) {
        this[LENGTH_CALCULATOR] = lC;
        this[LENGTH] = 0;
        this[LRU_LIST].forEach(function (hit) {
          hit.length = _this[LENGTH_CALCULATOR](hit.value, hit.key);
          _this[LENGTH] += hit.length;
        });
      }
      trim(this);
    }
  }, {
    key: "length",
    get: function get() {
      return this[LENGTH];
    }
  }, {
    key: "itemCount",
    get: function get() {
      return this[LRU_LIST].length;
    }
  }, {
    key: "rforEach",
    value: function rforEach(fn, thisp) {
      thisp = thisp || this;
      for (var walker = this[LRU_LIST].tail; walker !== null;) {
        var prev = walker.prev;
        forEachStep(this, fn, walker, thisp);
        walker = prev;
      }
    }
  }, {
    key: "forEach",
    value: function forEach(fn, thisp) {
      thisp = thisp || this;
      for (var walker = this[LRU_LIST].head; walker !== null;) {
        var next = walker.next;
        forEachStep(this, fn, walker, thisp);
        walker = next;
      }
    }
  }, {
    key: "keys",
    value: function keys() {
      return this[LRU_LIST].toArray().map(function (k) {
        return k.key;
      });
    }
  }, {
    key: "values",
    value: function values() {
      return this[LRU_LIST].toArray().map(function (k) {
        return k.value;
      });
    }
  }, {
    key: "reset",
    value: function reset() {
      var _this2 = this;
      if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
        this[LRU_LIST].forEach(function (hit) {
          return _this2[DISPOSE](hit.key, hit.value);
        });
      }
      this[CACHE] = new Map(); // hash of items by key
      this[LRU_LIST] = new Yallist(); // list of items in order of use recency
      this[LENGTH] = 0; // length of items in the list
    }
  }, {
    key: "dump",
    value: function dump() {
      var _this3 = this;
      return this[LRU_LIST].map(function (hit) {
        return isStale(_this3, hit) ? false : {
          k: hit.key,
          v: hit.value,
          e: hit.now + (hit.maxAge || 0)
        };
      }).toArray().filter(function (h) {
        return h;
      });
    }
  }, {
    key: "dumpLru",
    value: function dumpLru() {
      return this[LRU_LIST];
    }
  }, {
    key: "set",
    value: function set(key, value, maxAge) {
      maxAge = maxAge || this[MAX_AGE];
      if (maxAge && typeof maxAge !== 'number') throw new TypeError('maxAge must be a number');
      var now = maxAge ? Date.now() : 0;
      var len = this[LENGTH_CALCULATOR](value, key);
      if (this[CACHE].has(key)) {
        if (len > this[MAX]) {
          _del(this, this[CACHE].get(key));
          return false;
        }
        var node = this[CACHE].get(key);
        var item = node.value;

        // dispose of the old one before overwriting
        // split out into 2 ifs for better coverage tracking
        if (this[DISPOSE]) {
          if (!this[NO_DISPOSE_ON_SET]) this[DISPOSE](key, item.value);
        }
        item.now = now;
        item.maxAge = maxAge;
        item.value = value;
        this[LENGTH] += len - item.length;
        item.length = len;
        this.get(key);
        trim(this);
        return true;
      }
      var hit = new Entry(key, value, len, now, maxAge);

      // oversized objects fall out of cache automatically.
      if (hit.length > this[MAX]) {
        if (this[DISPOSE]) this[DISPOSE](key, value);
        return false;
      }
      this[LENGTH] += hit.length;
      this[LRU_LIST].unshift(hit);
      this[CACHE].set(key, this[LRU_LIST].head);
      trim(this);
      return true;
    }
  }, {
    key: "has",
    value: function has(key) {
      if (!this[CACHE].has(key)) return false;
      var hit = this[CACHE].get(key).value;
      return !isStale(this, hit);
    }
  }, {
    key: "get",
    value: function get(key) {
      return _get(this, key, true);
    }
  }, {
    key: "peek",
    value: function peek(key) {
      return _get(this, key, false);
    }
  }, {
    key: "pop",
    value: function pop() {
      var node = this[LRU_LIST].tail;
      if (!node) return null;
      _del(this, node);
      return node.value;
    }
  }, {
    key: "del",
    value: function del(key) {
      _del(this, this[CACHE].get(key));
    }
  }, {
    key: "load",
    value: function load(arr) {
      // reset the cache
      this.reset();
      var now = Date.now();
      // A previous serialized cache has the most recent items first
      for (var l = arr.length - 1; l >= 0; l--) {
        var hit = arr[l];
        var expiresAt = hit.e || 0;
        if (expiresAt === 0)
          // the item was created without expiration in a non aged cache
          this.set(hit.k, hit.v);else {
          var maxAge = expiresAt - now;
          // dont add already expired items
          if (maxAge > 0) {
            this.set(hit.k, hit.v, maxAge);
          }
        }
      }
    }
  }, {
    key: "prune",
    value: function prune() {
      var _this4 = this;
      this[CACHE].forEach(function (value, key) {
        return _get(_this4, key, false);
      });
    }
  }]);
  return LRUCache;
}();
var _get = function _get(self, key, doUse) {
  var node = self[CACHE].get(key);
  if (node) {
    var hit = node.value;
    if (isStale(self, hit)) {
      _del(self, node);
      if (!self[ALLOW_STALE]) return undefined;
    } else {
      if (doUse) {
        if (self[UPDATE_AGE_ON_GET]) node.value.now = Date.now();
        self[LRU_LIST].unshiftNode(node);
      }
    }
    return hit.value;
  }
};
var isStale = function isStale(self, hit) {
  if (!hit || !hit.maxAge && !self[MAX_AGE]) return false;
  var diff = Date.now() - hit.now;
  return hit.maxAge ? diff > hit.maxAge : self[MAX_AGE] && diff > self[MAX_AGE];
};
var trim = function trim(self) {
  if (self[LENGTH] > self[MAX]) {
    for (var walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && walker !== null;) {
      // We know that we're about to delete this one, and also
      // what the next least recently used key will be, so just
      // go ahead and set it now.
      var prev = walker.prev;
      _del(self, walker);
      walker = prev;
    }
  }
};
var _del = function _del(self, node) {
  if (node) {
    var hit = node.value;
    if (self[DISPOSE]) self[DISPOSE](hit.key, hit.value);
    self[LENGTH] -= hit.length;
    self[CACHE].delete(hit.key);
    self[LRU_LIST].removeNode(node);
  }
};
var Entry = /*#__PURE__*/_createClass(function Entry(key, value, length, now, maxAge) {
  _classCallCheck(this, Entry);
  this.key = key;
  this.value = value;
  this.length = length;
  this.now = now;
  this.maxAge = maxAge || 0;
});
var forEachStep = function forEachStep(self, fn, node, thisp) {
  var hit = node.value;
  if (isStale(self, hit)) {
    _del(self, node);
    if (!self[ALLOW_STALE]) hit = undefined;
  }
  if (hit) fn.call(thisp, hit.value, hit.key, self);
};
module.exports = LRUCache;

/***/ }),

/***/ 779:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";
/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */



var ReactPropTypesSecret = __webpack_require__(7106);
function emptyFunction() {}
function emptyFunctionWithReset() {}
emptyFunctionWithReset.resetWarningCache = emptyFunction;
module.exports = function () {
  function shim(props, propName, componentName, location, propFullName, secret) {
    if (secret === ReactPropTypesSecret) {
      // It is still safe when called from React.
      return;
    }
    var err = new Error('Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 'Use PropTypes.checkPropTypes() to call them. ' + 'Read more at http://fb.me/use-check-prop-types');
    err.name = 'Invariant Violation';
    throw err;
  }
  ;
  shim.isRequired = shim;
  function getShim() {
    return shim;
  }
  ;
  // Important!
  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
  var ReactPropTypes = {
    array: shim,
    bigint: shim,
    bool: shim,
    func: shim,
    number: shim,
    object: shim,
    string: shim,
    symbol: shim,
    any: shim,
    arrayOf: getShim,
    element: shim,
    elementType: shim,
    instanceOf: getShim,
    node: shim,
    objectOf: getShim,
    oneOf: getShim,
    oneOfType: getShim,
    shape: getShim,
    exact: getShim,
    checkPropTypes: emptyFunctionWithReset,
    resetWarningCache: emptyFunction
  };
  ReactPropTypes.PropTypes = ReactPropTypes;
  return ReactPropTypes;
};

/***/ }),

/***/ 1226:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

if (false) { var throwOnDirectAccess, ReactIs; } else {
  // By explicitly using `prop-types` you are opting into new production behavior.
  // http://fb.me/prop-types-in-prod
  module.exports = __webpack_require__(779)();
}

/***/ }),

/***/ 7106:
/***/ (function(module) {

"use strict";
/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */



var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
module.exports = ReactPropTypesSecret;

/***/ }),

/***/ 5478:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";
/**
 * @license React
 * react-dom.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
/*
 Modernizr 3.0.0pre (Custom Build) | MIT
*/


var aa = __webpack_require__(9512),
  ca = __webpack_require__(4086);
function p(a) {
  for (var b = "https://reactjs.org/docs/error-decoder.html?invariant=" + a, c = 1; c < arguments.length; c++) b += "&args[]=" + encodeURIComponent(arguments[c]);
  return "Minified React error #" + a + "; visit " + b + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
}
var da = new Set(),
  ea = {};
function fa(a, b) {
  ha(a, b);
  ha(a + "Capture", b);
}
function ha(a, b) {
  ea[a] = b;
  for (a = 0; a < b.length; a++) da.add(b[a]);
}
var ia = !("undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement),
  ja = Object.prototype.hasOwnProperty,
  ka = /^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,
  la = {},
  ma = {};
function oa(a) {
  if (ja.call(ma, a)) return !0;
  if (ja.call(la, a)) return !1;
  if (ka.test(a)) return ma[a] = !0;
  la[a] = !0;
  return !1;
}
function pa(a, b, c, d) {
  if (null !== c && 0 === c.type) return !1;
  switch (typeof b) {
    case "function":
    case "symbol":
      return !0;
    case "boolean":
      if (d) return !1;
      if (null !== c) return !c.acceptsBooleans;
      a = a.toLowerCase().slice(0, 5);
      return "data-" !== a && "aria-" !== a;
    default:
      return !1;
  }
}
function qa(a, b, c, d) {
  if (null === b || "undefined" === typeof b || pa(a, b, c, d)) return !0;
  if (d) return !1;
  if (null !== c) switch (c.type) {
    case 3:
      return !b;
    case 4:
      return !1 === b;
    case 5:
      return isNaN(b);
    case 6:
      return isNaN(b) || 1 > b;
  }
  return !1;
}
function v(a, b, c, d, e, f, g) {
  this.acceptsBooleans = 2 === b || 3 === b || 4 === b;
  this.attributeName = d;
  this.attributeNamespace = e;
  this.mustUseProperty = c;
  this.propertyName = a;
  this.type = b;
  this.sanitizeURL = f;
  this.removeEmptyString = g;
}
var z = {};
"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function (a) {
  z[a] = new v(a, 0, !1, a, null, !1, !1);
});
[["acceptCharset", "accept-charset"], ["className", "class"], ["htmlFor", "for"], ["httpEquiv", "http-equiv"]].forEach(function (a) {
  var b = a[0];
  z[b] = new v(b, 1, !1, a[1], null, !1, !1);
});
["contentEditable", "draggable", "spellCheck", "value"].forEach(function (a) {
  z[a] = new v(a, 2, !1, a.toLowerCase(), null, !1, !1);
});
["autoReverse", "externalResourcesRequired", "focusable", "preserveAlpha"].forEach(function (a) {
  z[a] = new v(a, 2, !1, a, null, !1, !1);
});
"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function (a) {
  z[a] = new v(a, 3, !1, a.toLowerCase(), null, !1, !1);
});
["checked", "multiple", "muted", "selected"].forEach(function (a) {
  z[a] = new v(a, 3, !0, a, null, !1, !1);
});
["capture", "download"].forEach(function (a) {
  z[a] = new v(a, 4, !1, a, null, !1, !1);
});
["cols", "rows", "size", "span"].forEach(function (a) {
  z[a] = new v(a, 6, !1, a, null, !1, !1);
});
["rowSpan", "start"].forEach(function (a) {
  z[a] = new v(a, 5, !1, a.toLowerCase(), null, !1, !1);
});
var ra = /[\-:]([a-z])/g;
function sa(a) {
  return a[1].toUpperCase();
}
"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function (a) {
  var b = a.replace(ra, sa);
  z[b] = new v(b, 1, !1, a, null, !1, !1);
});
"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function (a) {
  var b = a.replace(ra, sa);
  z[b] = new v(b, 1, !1, a, "http://www.w3.org/1999/xlink", !1, !1);
});
["xml:base", "xml:lang", "xml:space"].forEach(function (a) {
  var b = a.replace(ra, sa);
  z[b] = new v(b, 1, !1, a, "http://www.w3.org/XML/1998/namespace", !1, !1);
});
["tabIndex", "crossOrigin"].forEach(function (a) {
  z[a] = new v(a, 1, !1, a.toLowerCase(), null, !1, !1);
});
z.xlinkHref = new v("xlinkHref", 1, !1, "xlink:href", "http://www.w3.org/1999/xlink", !0, !1);
["src", "href", "action", "formAction"].forEach(function (a) {
  z[a] = new v(a, 1, !1, a.toLowerCase(), null, !0, !0);
});
function ta(a, b, c, d) {
  var e = z.hasOwnProperty(b) ? z[b] : null;
  if (null !== e ? 0 !== e.type : d || !(2 < b.length) || "o" !== b[0] && "O" !== b[0] || "n" !== b[1] && "N" !== b[1]) qa(b, c, e, d) && (c = null), d || null === e ? oa(b) && (null === c ? a.removeAttribute(b) : a.setAttribute(b, "" + c)) : e.mustUseProperty ? a[e.propertyName] = null === c ? 3 === e.type ? !1 : "" : c : (b = e.attributeName, d = e.attributeNamespace, null === c ? a.removeAttribute(b) : (e = e.type, c = 3 === e || 4 === e && !0 === c ? "" : "" + c, d ? a.setAttributeNS(d, b, c) : a.setAttribute(b, c)));
}
var ua = aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
  va = Symbol.for("react.element"),
  wa = Symbol.for("react.portal"),
  ya = Symbol.for("react.fragment"),
  za = Symbol.for("react.strict_mode"),
  Aa = Symbol.for("react.profiler"),
  Ba = Symbol.for("react.provider"),
  Ca = Symbol.for("react.context"),
  Da = Symbol.for("react.forward_ref"),
  Ea = Symbol.for("react.suspense"),
  Fa = Symbol.for("react.suspense_list"),
  Ga = Symbol.for("react.memo"),
  Ha = Symbol.for("react.lazy");
Symbol.for("react.scope");
Symbol.for("react.debug_trace_mode");
var Ia = Symbol.for("react.offscreen");
Symbol.for("react.legacy_hidden");
Symbol.for("react.cache");
Symbol.for("react.tracing_marker");
var Ja = Symbol.iterator;
function Ka(a) {
  if (null === a || "object" !== typeof a) return null;
  a = Ja && a[Ja] || a["@@iterator"];
  return "function" === typeof a ? a : null;
}
var A = Object.assign,
  La;
function Ma(a) {
  if (void 0 === La) try {
    throw Error();
  } catch (c) {
    var b = c.stack.trim().match(/\n( *(at )?)/);
    La = b && b[1] || "";
  }
  return "\n" + La + a;
}
var Na = !1;
function Oa(a, b) {
  if (!a || Na) return "";
  Na = !0;
  var c = Error.prepareStackTrace;
  Error.prepareStackTrace = void 0;
  try {
    if (b) {
      if (b = function b() {
        throw Error();
      }, Object.defineProperty(b.prototype, "props", {
        set: function set() {
          throw Error();
        }
      }), "object" === typeof Reflect && Reflect.construct) {
        try {
          Reflect.construct(b, []);
        } catch (l) {
          var d = l;
        }
        Reflect.construct(a, [], b);
      } else {
        try {
          b.call();
        } catch (l) {
          d = l;
        }
        a.call(b.prototype);
      }
    } else {
      try {
        throw Error();
      } catch (l) {
        d = l;
      }
      a();
    }
  } catch (l) {
    if (l && d && "string" === typeof l.stack) {
      for (var e = l.stack.split("\n"), f = d.stack.split("\n"), g = e.length - 1, h = f.length - 1; 1 <= g && 0 <= h && e[g] !== f[h];) h--;
      for (; 1 <= g && 0 <= h; g--, h--) if (e[g] !== f[h]) {
        if (1 !== g || 1 !== h) {
          do if (g--, h--, 0 > h || e[g] !== f[h]) {
            var k = "\n" + e[g].replace(" at new ", " at ");
            a.displayName && k.includes("<anonymous>") && (k = k.replace("<anonymous>", a.displayName));
            return k;
          } while (1 <= g && 0 <= h);
        }
        break;
      }
    }
  } finally {
    Na = !1, Error.prepareStackTrace = c;
  }
  return (a = a ? a.displayName || a.name : "") ? Ma(a) : "";
}
function Pa(a) {
  switch (a.tag) {
    case 5:
      return Ma(a.type);
    case 16:
      return Ma("Lazy");
    case 13:
      return Ma("Suspense");
    case 19:
      return Ma("SuspenseList");
    case 0:
    case 2:
    case 15:
      return a = Oa(a.type, !1), a;
    case 11:
      return a = Oa(a.type.render, !1), a;
    case 1:
      return a = Oa(a.type, !0), a;
    default:
      return "";
  }
}
function Qa(a) {
  if (null == a) return null;
  if ("function" === typeof a) return a.displayName || a.name || null;
  if ("string" === typeof a) return a;
  switch (a) {
    case ya:
      return "Fragment";
    case wa:
      return "Portal";
    case Aa:
      return "Profiler";
    case za:
      return "StrictMode";
    case Ea:
      return "Suspense";
    case Fa:
      return "SuspenseList";
  }
  if ("object" === typeof a) switch (a.$$typeof) {
    case Ca:
      return (a.displayName || "Context") + ".Consumer";
    case Ba:
      return (a._context.displayName || "Context") + ".Provider";
    case Da:
      var b = a.render;
      a = a.displayName;
      a || (a = b.displayName || b.name || "", a = "" !== a ? "ForwardRef(" + a + ")" : "ForwardRef");
      return a;
    case Ga:
      return b = a.displayName || null, null !== b ? b : Qa(a.type) || "Memo";
    case Ha:
      b = a._payload;
      a = a._init;
      try {
        return Qa(a(b));
      } catch (c) {}
  }
  return null;
}
function Ra(a) {
  var b = a.type;
  switch (a.tag) {
    case 24:
      return "Cache";
    case 9:
      return (b.displayName || "Context") + ".Consumer";
    case 10:
      return (b._context.displayName || "Context") + ".Provider";
    case 18:
      return "DehydratedFragment";
    case 11:
      return a = b.render, a = a.displayName || a.name || "", b.displayName || ("" !== a ? "ForwardRef(" + a + ")" : "ForwardRef");
    case 7:
      return "Fragment";
    case 5:
      return b;
    case 4:
      return "Portal";
    case 3:
      return "Root";
    case 6:
      return "Text";
    case 16:
      return Qa(b);
    case 8:
      return b === za ? "StrictMode" : "Mode";
    case 22:
      return "Offscreen";
    case 12:
      return "Profiler";
    case 21:
      return "Scope";
    case 13:
      return "Suspense";
    case 19:
      return "SuspenseList";
    case 25:
      return "TracingMarker";
    case 1:
    case 0:
    case 17:
    case 2:
    case 14:
    case 15:
      if ("function" === typeof b) return b.displayName || b.name || null;
      if ("string" === typeof b) return b;
  }
  return null;
}
function Sa(a) {
  switch (typeof a) {
    case "boolean":
    case "number":
    case "string":
    case "undefined":
      return a;
    case "object":
      return a;
    default:
      return "";
  }
}
function Ta(a) {
  var b = a.type;
  return (a = a.nodeName) && "input" === a.toLowerCase() && ("checkbox" === b || "radio" === b);
}
function Ua(a) {
  var b = Ta(a) ? "checked" : "value",
    c = Object.getOwnPropertyDescriptor(a.constructor.prototype, b),
    d = "" + a[b];
  if (!a.hasOwnProperty(b) && "undefined" !== typeof c && "function" === typeof c.get && "function" === typeof c.set) {
    var e = c.get,
      f = c.set;
    Object.defineProperty(a, b, {
      configurable: !0,
      get: function get() {
        return e.call(this);
      },
      set: function set(a) {
        d = "" + a;
        f.call(this, a);
      }
    });
    Object.defineProperty(a, b, {
      enumerable: c.enumerable
    });
    return {
      getValue: function getValue() {
        return d;
      },
      setValue: function setValue(a) {
        d = "" + a;
      },
      stopTracking: function stopTracking() {
        a._valueTracker = null;
        delete a[b];
      }
    };
  }
}
function Va(a) {
  a._valueTracker || (a._valueTracker = Ua(a));
}
function Wa(a) {
  if (!a) return !1;
  var b = a._valueTracker;
  if (!b) return !0;
  var c = b.getValue();
  var d = "";
  a && (d = Ta(a) ? a.checked ? "true" : "false" : a.value);
  a = d;
  return a !== c ? (b.setValue(a), !0) : !1;
}
function Xa(a) {
  a = a || ("undefined" !== typeof document ? document : void 0);
  if ("undefined" === typeof a) return null;
  try {
    return a.activeElement || a.body;
  } catch (b) {
    return a.body;
  }
}
function Ya(a, b) {
  var c = b.checked;
  return A({}, b, {
    defaultChecked: void 0,
    defaultValue: void 0,
    value: void 0,
    checked: null != c ? c : a._wrapperState.initialChecked
  });
}
function Za(a, b) {
  var c = null == b.defaultValue ? "" : b.defaultValue,
    d = null != b.checked ? b.checked : b.defaultChecked;
  c = Sa(null != b.value ? b.value : c);
  a._wrapperState = {
    initialChecked: d,
    initialValue: c,
    controlled: "checkbox" === b.type || "radio" === b.type ? null != b.checked : null != b.value
  };
}
function ab(a, b) {
  b = b.checked;
  null != b && ta(a, "checked", b, !1);
}
function bb(a, b) {
  ab(a, b);
  var c = Sa(b.value),
    d = b.type;
  if (null != c) {
    if ("number" === d) {
      if (0 === c && "" === a.value || a.value != c) a.value = "" + c;
    } else a.value !== "" + c && (a.value = "" + c);
  } else if ("submit" === d || "reset" === d) {
    a.removeAttribute("value");
    return;
  }
  b.hasOwnProperty("value") ? cb(a, b.type, c) : b.hasOwnProperty("defaultValue") && cb(a, b.type, Sa(b.defaultValue));
  null == b.checked && null != b.defaultChecked && (a.defaultChecked = !!b.defaultChecked);
}
function db(a, b, c) {
  if (b.hasOwnProperty("value") || b.hasOwnProperty("defaultValue")) {
    var d = b.type;
    if (!("submit" !== d && "reset" !== d || void 0 !== b.value && null !== b.value)) return;
    b = "" + a._wrapperState.initialValue;
    c || b === a.value || (a.value = b);
    a.defaultValue = b;
  }
  c = a.name;
  "" !== c && (a.name = "");
  a.defaultChecked = !!a._wrapperState.initialChecked;
  "" !== c && (a.name = c);
}
function cb(a, b, c) {
  if ("number" !== b || Xa(a.ownerDocument) !== a) null == c ? a.defaultValue = "" + a._wrapperState.initialValue : a.defaultValue !== "" + c && (a.defaultValue = "" + c);
}
var eb = Array.isArray;
function fb(a, b, c, d) {
  a = a.options;
  if (b) {
    b = {};
    for (var e = 0; e < c.length; e++) b["$" + c[e]] = !0;
    for (c = 0; c < a.length; c++) e = b.hasOwnProperty("$" + a[c].value), a[c].selected !== e && (a[c].selected = e), e && d && (a[c].defaultSelected = !0);
  } else {
    c = "" + Sa(c);
    b = null;
    for (e = 0; e < a.length; e++) {
      if (a[e].value === c) {
        a[e].selected = !0;
        d && (a[e].defaultSelected = !0);
        return;
      }
      null !== b || a[e].disabled || (b = a[e]);
    }
    null !== b && (b.selected = !0);
  }
}
function gb(a, b) {
  if (null != b.dangerouslySetInnerHTML) throw Error(p(91));
  return A({}, b, {
    value: void 0,
    defaultValue: void 0,
    children: "" + a._wrapperState.initialValue
  });
}
function hb(a, b) {
  var c = b.value;
  if (null == c) {
    c = b.children;
    b = b.defaultValue;
    if (null != c) {
      if (null != b) throw Error(p(92));
      if (eb(c)) {
        if (1 < c.length) throw Error(p(93));
        c = c[0];
      }
      b = c;
    }
    null == b && (b = "");
    c = b;
  }
  a._wrapperState = {
    initialValue: Sa(c)
  };
}
function ib(a, b) {
  var c = Sa(b.value),
    d = Sa(b.defaultValue);
  null != c && (c = "" + c, c !== a.value && (a.value = c), null == b.defaultValue && a.defaultValue !== c && (a.defaultValue = c));
  null != d && (a.defaultValue = "" + d);
}
function jb(a) {
  var b = a.textContent;
  b === a._wrapperState.initialValue && "" !== b && null !== b && (a.value = b);
}
function kb(a) {
  switch (a) {
    case "svg":
      return "http://www.w3.org/2000/svg";
    case "math":
      return "http://www.w3.org/1998/Math/MathML";
    default:
      return "http://www.w3.org/1999/xhtml";
  }
}
function lb(a, b) {
  return null == a || "http://www.w3.org/1999/xhtml" === a ? kb(b) : "http://www.w3.org/2000/svg" === a && "foreignObject" === b ? "http://www.w3.org/1999/xhtml" : a;
}
var mb,
  nb = function (a) {
    return "undefined" !== typeof MSApp && MSApp.execUnsafeLocalFunction ? function (b, c, d, e) {
      MSApp.execUnsafeLocalFunction(function () {
        return a(b, c, d, e);
      });
    } : a;
  }(function (a, b) {
    if ("http://www.w3.org/2000/svg" !== a.namespaceURI || "innerHTML" in a) a.innerHTML = b;else {
      mb = mb || document.createElement("div");
      mb.innerHTML = "<svg>" + b.valueOf().toString() + "</svg>";
      for (b = mb.firstChild; a.firstChild;) a.removeChild(a.firstChild);
      for (; b.firstChild;) a.appendChild(b.firstChild);
    }
  });
function ob(a, b) {
  if (b) {
    var c = a.firstChild;
    if (c && c === a.lastChild && 3 === c.nodeType) {
      c.nodeValue = b;
      return;
    }
  }
  a.textContent = b;
}
var pb = {
    animationIterationCount: !0,
    aspectRatio: !0,
    borderImageOutset: !0,
    borderImageSlice: !0,
    borderImageWidth: !0,
    boxFlex: !0,
    boxFlexGroup: !0,
    boxOrdinalGroup: !0,
    columnCount: !0,
    columns: !0,
    flex: !0,
    flexGrow: !0,
    flexPositive: !0,
    flexShrink: !0,
    flexNegative: !0,
    flexOrder: !0,
    gridArea: !0,
    gridRow: !0,
    gridRowEnd: !0,
    gridRowSpan: !0,
    gridRowStart: !0,
    gridColumn: !0,
    gridColumnEnd: !0,
    gridColumnSpan: !0,
    gridColumnStart: !0,
    fontWeight: !0,
    lineClamp: !0,
    lineHeight: !0,
    opacity: !0,
    order: !0,
    orphans: !0,
    tabSize: !0,
    widows: !0,
    zIndex: !0,
    zoom: !0,
    fillOpacity: !0,
    floodOpacity: !0,
    stopOpacity: !0,
    strokeDasharray: !0,
    strokeDashoffset: !0,
    strokeMiterlimit: !0,
    strokeOpacity: !0,
    strokeWidth: !0
  },
  qb = ["Webkit", "ms", "Moz", "O"];
Object.keys(pb).forEach(function (a) {
  qb.forEach(function (b) {
    b = b + a.charAt(0).toUpperCase() + a.substring(1);
    pb[b] = pb[a];
  });
});
function rb(a, b, c) {
  return null == b || "boolean" === typeof b || "" === b ? "" : c || "number" !== typeof b || 0 === b || pb.hasOwnProperty(a) && pb[a] ? ("" + b).trim() : b + "px";
}
function sb(a, b) {
  a = a.style;
  for (var c in b) if (b.hasOwnProperty(c)) {
    var d = 0 === c.indexOf("--"),
      e = rb(c, b[c], d);
    "float" === c && (c = "cssFloat");
    d ? a.setProperty(c, e) : a[c] = e;
  }
}
var tb = A({
  menuitem: !0
}, {
  area: !0,
  base: !0,
  br: !0,
  col: !0,
  embed: !0,
  hr: !0,
  img: !0,
  input: !0,
  keygen: !0,
  link: !0,
  meta: !0,
  param: !0,
  source: !0,
  track: !0,
  wbr: !0
});
function ub(a, b) {
  if (b) {
    if (tb[a] && (null != b.children || null != b.dangerouslySetInnerHTML)) throw Error(p(137, a));
    if (null != b.dangerouslySetInnerHTML) {
      if (null != b.children) throw Error(p(60));
      if ("object" !== typeof b.dangerouslySetInnerHTML || !("__html" in b.dangerouslySetInnerHTML)) throw Error(p(61));
    }
    if (null != b.style && "object" !== typeof b.style) throw Error(p(62));
  }
}
function vb(a, b) {
  if (-1 === a.indexOf("-")) return "string" === typeof b.is;
  switch (a) {
    case "annotation-xml":
    case "color-profile":
    case "font-face":
    case "font-face-src":
    case "font-face-uri":
    case "font-face-format":
    case "font-face-name":
    case "missing-glyph":
      return !1;
    default:
      return !0;
  }
}
var wb = null;
function xb(a) {
  a = a.target || a.srcElement || window;
  a.correspondingUseElement && (a = a.correspondingUseElement);
  return 3 === a.nodeType ? a.parentNode : a;
}
var yb = null,
  zb = null,
  Ab = null;
function Bb(a) {
  if (a = Cb(a)) {
    if ("function" !== typeof yb) throw Error(p(280));
    var b = a.stateNode;
    b && (b = Db(b), yb(a.stateNode, a.type, b));
  }
}
function Eb(a) {
  zb ? Ab ? Ab.push(a) : Ab = [a] : zb = a;
}
function Fb() {
  if (zb) {
    var a = zb,
      b = Ab;
    Ab = zb = null;
    Bb(a);
    if (b) for (a = 0; a < b.length; a++) Bb(b[a]);
  }
}
function Gb(a, b) {
  return a(b);
}
function Hb() {}
var Ib = !1;
function Jb(a, b, c) {
  if (Ib) return a(b, c);
  Ib = !0;
  try {
    return Gb(a, b, c);
  } finally {
    if (Ib = !1, null !== zb || null !== Ab) Hb(), Fb();
  }
}
function Kb(a, b) {
  var c = a.stateNode;
  if (null === c) return null;
  var d = Db(c);
  if (null === d) return null;
  c = d[b];
  a: switch (b) {
    case "onClick":
    case "onClickCapture":
    case "onDoubleClick":
    case "onDoubleClickCapture":
    case "onMouseDown":
    case "onMouseDownCapture":
    case "onMouseMove":
    case "onMouseMoveCapture":
    case "onMouseUp":
    case "onMouseUpCapture":
    case "onMouseEnter":
      (d = !d.disabled) || (a = a.type, d = !("button" === a || "input" === a || "select" === a || "textarea" === a));
      a = !d;
      break a;
    default:
      a = !1;
  }
  if (a) return null;
  if (c && "function" !== typeof c) throw Error(p(231, b, typeof c));
  return c;
}
var Lb = !1;
if (ia) try {
  var Mb = {};
  Object.defineProperty(Mb, "passive", {
    get: function get() {
      Lb = !0;
    }
  });
  window.addEventListener("test", Mb, Mb);
  window.removeEventListener("test", Mb, Mb);
} catch (a) {
  Lb = !1;
}
function Nb(a, b, c, d, e, f, g, h, k) {
  var l = Array.prototype.slice.call(arguments, 3);
  try {
    b.apply(c, l);
  } catch (m) {
    this.onError(m);
  }
}
var Ob = !1,
  Pb = null,
  Qb = !1,
  Rb = null,
  Sb = {
    onError: function onError(a) {
      Ob = !0;
      Pb = a;
    }
  };
function Tb(a, b, c, d, e, f, g, h, k) {
  Ob = !1;
  Pb = null;
  Nb.apply(Sb, arguments);
}
function Ub(a, b, c, d, e, f, g, h, k) {
  Tb.apply(this, arguments);
  if (Ob) {
    if (Ob) {
      var l = Pb;
      Ob = !1;
      Pb = null;
    } else throw Error(p(198));
    Qb || (Qb = !0, Rb = l);
  }
}
function Vb(a) {
  var b = a,
    c = a;
  if (a.alternate) for (; b.return;) b = b.return;else {
    a = b;
    do b = a, 0 !== (b.flags & 4098) && (c = b.return), a = b.return; while (a);
  }
  return 3 === b.tag ? c : null;
}
function Wb(a) {
  if (13 === a.tag) {
    var b = a.memoizedState;
    null === b && (a = a.alternate, null !== a && (b = a.memoizedState));
    if (null !== b) return b.dehydrated;
  }
  return null;
}
function Xb(a) {
  if (Vb(a) !== a) throw Error(p(188));
}
function Yb(a) {
  var b = a.alternate;
  if (!b) {
    b = Vb(a);
    if (null === b) throw Error(p(188));
    return b !== a ? null : a;
  }
  for (var c = a, d = b;;) {
    var e = c.return;
    if (null === e) break;
    var f = e.alternate;
    if (null === f) {
      d = e.return;
      if (null !== d) {
        c = d;
        continue;
      }
      break;
    }
    if (e.child === f.child) {
      for (f = e.child; f;) {
        if (f === c) return Xb(e), a;
        if (f === d) return Xb(e), b;
        f = f.sibling;
      }
      throw Error(p(188));
    }
    if (c.return !== d.return) c = e, d = f;else {
      for (var g = !1, h = e.child; h;) {
        if (h === c) {
          g = !0;
          c = e;
          d = f;
          break;
        }
        if (h === d) {
          g = !0;
          d = e;
          c = f;
          break;
        }
        h = h.sibling;
      }
      if (!g) {
        for (h = f.child; h;) {
          if (h === c) {
            g = !0;
            c = f;
            d = e;
            break;
          }
          if (h === d) {
            g = !0;
            d = f;
            c = e;
            break;
          }
          h = h.sibling;
        }
        if (!g) throw Error(p(189));
      }
    }
    if (c.alternate !== d) throw Error(p(190));
  }
  if (3 !== c.tag) throw Error(p(188));
  return c.stateNode.current === c ? a : b;
}
function Zb(a) {
  a = Yb(a);
  return null !== a ? $b(a) : null;
}
function $b(a) {
  if (5 === a.tag || 6 === a.tag) return a;
  for (a = a.child; null !== a;) {
    var b = $b(a);
    if (null !== b) return b;
    a = a.sibling;
  }
  return null;
}
var ac = ca.unstable_scheduleCallback,
  bc = ca.unstable_cancelCallback,
  cc = ca.unstable_shouldYield,
  dc = ca.unstable_requestPaint,
  B = ca.unstable_now,
  ec = ca.unstable_getCurrentPriorityLevel,
  fc = ca.unstable_ImmediatePriority,
  gc = ca.unstable_UserBlockingPriority,
  hc = ca.unstable_NormalPriority,
  ic = ca.unstable_LowPriority,
  jc = ca.unstable_IdlePriority,
  kc = null,
  lc = null;
function mc(a) {
  if (lc && "function" === typeof lc.onCommitFiberRoot) try {
    lc.onCommitFiberRoot(kc, a, void 0, 128 === (a.current.flags & 128));
  } catch (b) {}
}
var oc = Math.clz32 ? Math.clz32 : nc,
  pc = Math.log,
  qc = Math.LN2;
function nc(a) {
  a >>>= 0;
  return 0 === a ? 32 : 31 - (pc(a) / qc | 0) | 0;
}
var rc = 64,
  sc = 4194304;
function tc(a) {
  switch (a & -a) {
    case 1:
      return 1;
    case 2:
      return 2;
    case 4:
      return 4;
    case 8:
      return 8;
    case 16:
      return 16;
    case 32:
      return 32;
    case 64:
    case 128:
    case 256:
    case 512:
    case 1024:
    case 2048:
    case 4096:
    case 8192:
    case 16384:
    case 32768:
    case 65536:
    case 131072:
    case 262144:
    case 524288:
    case 1048576:
    case 2097152:
      return a & 4194240;
    case 4194304:
    case 8388608:
    case 16777216:
    case 33554432:
    case 67108864:
      return a & 130023424;
    case 134217728:
      return 134217728;
    case 268435456:
      return 268435456;
    case 536870912:
      return 536870912;
    case 1073741824:
      return 1073741824;
    default:
      return a;
  }
}
function uc(a, b) {
  var c = a.pendingLanes;
  if (0 === c) return 0;
  var d = 0,
    e = a.suspendedLanes,
    f = a.pingedLanes,
    g = c & 268435455;
  if (0 !== g) {
    var h = g & ~e;
    0 !== h ? d = tc(h) : (f &= g, 0 !== f && (d = tc(f)));
  } else g = c & ~e, 0 !== g ? d = tc(g) : 0 !== f && (d = tc(f));
  if (0 === d) return 0;
  if (0 !== b && b !== d && 0 === (b & e) && (e = d & -d, f = b & -b, e >= f || 16 === e && 0 !== (f & 4194240))) return b;
  0 !== (d & 4) && (d |= c & 16);
  b = a.entangledLanes;
  if (0 !== b) for (a = a.entanglements, b &= d; 0 < b;) c = 31 - oc(b), e = 1 << c, d |= a[c], b &= ~e;
  return d;
}
function vc(a, b) {
  switch (a) {
    case 1:
    case 2:
    case 4:
      return b + 250;
    case 8:
    case 16:
    case 32:
    case 64:
    case 128:
    case 256:
    case 512:
    case 1024:
    case 2048:
    case 4096:
    case 8192:
    case 16384:
    case 32768:
    case 65536:
    case 131072:
    case 262144:
    case 524288:
    case 1048576:
    case 2097152:
      return b + 5E3;
    case 4194304:
    case 8388608:
    case 16777216:
    case 33554432:
    case 67108864:
      return -1;
    case 134217728:
    case 268435456:
    case 536870912:
    case 1073741824:
      return -1;
    default:
      return -1;
  }
}
function wc(a, b) {
  for (var c = a.suspendedLanes, d = a.pingedLanes, e = a.expirationTimes, f = a.pendingLanes; 0 < f;) {
    var g = 31 - oc(f),
      h = 1 << g,
      k = e[g];
    if (-1 === k) {
      if (0 === (h & c) || 0 !== (h & d)) e[g] = vc(h, b);
    } else k <= b && (a.expiredLanes |= h);
    f &= ~h;
  }
}
function xc(a) {
  a = a.pendingLanes & -1073741825;
  return 0 !== a ? a : a & 1073741824 ? 1073741824 : 0;
}
function yc() {
  var a = rc;
  rc <<= 1;
  0 === (rc & 4194240) && (rc = 64);
  return a;
}
function zc(a) {
  for (var b = [], c = 0; 31 > c; c++) b.push(a);
  return b;
}
function Ac(a, b, c) {
  a.pendingLanes |= b;
  536870912 !== b && (a.suspendedLanes = 0, a.pingedLanes = 0);
  a = a.eventTimes;
  b = 31 - oc(b);
  a[b] = c;
}
function Bc(a, b) {
  var c = a.pendingLanes & ~b;
  a.pendingLanes = b;
  a.suspendedLanes = 0;
  a.pingedLanes = 0;
  a.expiredLanes &= b;
  a.mutableReadLanes &= b;
  a.entangledLanes &= b;
  b = a.entanglements;
  var d = a.eventTimes;
  for (a = a.expirationTimes; 0 < c;) {
    var e = 31 - oc(c),
      f = 1 << e;
    b[e] = 0;
    d[e] = -1;
    a[e] = -1;
    c &= ~f;
  }
}
function Cc(a, b) {
  var c = a.entangledLanes |= b;
  for (a = a.entanglements; c;) {
    var d = 31 - oc(c),
      e = 1 << d;
    e & b | a[d] & b && (a[d] |= b);
    c &= ~e;
  }
}
var C = 0;
function Dc(a) {
  a &= -a;
  return 1 < a ? 4 < a ? 0 !== (a & 268435455) ? 16 : 536870912 : 4 : 1;
}
var Ec,
  Fc,
  Gc,
  Hc,
  Ic,
  Jc = !1,
  Kc = [],
  Lc = null,
  Mc = null,
  Nc = null,
  Oc = new Map(),
  Pc = new Map(),
  Qc = [],
  Rc = "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(" ");
function Sc(a, b) {
  switch (a) {
    case "focusin":
    case "focusout":
      Lc = null;
      break;
    case "dragenter":
    case "dragleave":
      Mc = null;
      break;
    case "mouseover":
    case "mouseout":
      Nc = null;
      break;
    case "pointerover":
    case "pointerout":
      Oc.delete(b.pointerId);
      break;
    case "gotpointercapture":
    case "lostpointercapture":
      Pc.delete(b.pointerId);
  }
}
function Tc(a, b, c, d, e, f) {
  if (null === a || a.nativeEvent !== f) return a = {
    blockedOn: b,
    domEventName: c,
    eventSystemFlags: d,
    nativeEvent: f,
    targetContainers: [e]
  }, null !== b && (b = Cb(b), null !== b && Fc(b)), a;
  a.eventSystemFlags |= d;
  b = a.targetContainers;
  null !== e && -1 === b.indexOf(e) && b.push(e);
  return a;
}
function Uc(a, b, c, d, e) {
  switch (b) {
    case "focusin":
      return Lc = Tc(Lc, a, b, c, d, e), !0;
    case "dragenter":
      return Mc = Tc(Mc, a, b, c, d, e), !0;
    case "mouseover":
      return Nc = Tc(Nc, a, b, c, d, e), !0;
    case "pointerover":
      var f = e.pointerId;
      Oc.set(f, Tc(Oc.get(f) || null, a, b, c, d, e));
      return !0;
    case "gotpointercapture":
      return f = e.pointerId, Pc.set(f, Tc(Pc.get(f) || null, a, b, c, d, e)), !0;
  }
  return !1;
}
function Vc(a) {
  var b = Wc(a.target);
  if (null !== b) {
    var c = Vb(b);
    if (null !== c) if (b = c.tag, 13 === b) {
      if (b = Wb(c), null !== b) {
        a.blockedOn = b;
        Ic(a.priority, function () {
          Gc(c);
        });
        return;
      }
    } else if (3 === b && c.stateNode.current.memoizedState.isDehydrated) {
      a.blockedOn = 3 === c.tag ? c.stateNode.containerInfo : null;
      return;
    }
  }
  a.blockedOn = null;
}
function Xc(a) {
  if (null !== a.blockedOn) return !1;
  for (var b = a.targetContainers; 0 < b.length;) {
    var c = Yc(a.domEventName, a.eventSystemFlags, b[0], a.nativeEvent);
    if (null === c) {
      c = a.nativeEvent;
      var d = new c.constructor(c.type, c);
      wb = d;
      c.target.dispatchEvent(d);
      wb = null;
    } else return b = Cb(c), null !== b && Fc(b), a.blockedOn = c, !1;
    b.shift();
  }
  return !0;
}
function Zc(a, b, c) {
  Xc(a) && c.delete(b);
}
function $c() {
  Jc = !1;
  null !== Lc && Xc(Lc) && (Lc = null);
  null !== Mc && Xc(Mc) && (Mc = null);
  null !== Nc && Xc(Nc) && (Nc = null);
  Oc.forEach(Zc);
  Pc.forEach(Zc);
}
function ad(a, b) {
  a.blockedOn === b && (a.blockedOn = null, Jc || (Jc = !0, ca.unstable_scheduleCallback(ca.unstable_NormalPriority, $c)));
}
function bd(a) {
  function b(b) {
    return ad(b, a);
  }
  if (0 < Kc.length) {
    ad(Kc[0], a);
    for (var c = 1; c < Kc.length; c++) {
      var d = Kc[c];
      d.blockedOn === a && (d.blockedOn = null);
    }
  }
  null !== Lc && ad(Lc, a);
  null !== Mc && ad(Mc, a);
  null !== Nc && ad(Nc, a);
  Oc.forEach(b);
  Pc.forEach(b);
  for (c = 0; c < Qc.length; c++) d = Qc[c], d.blockedOn === a && (d.blockedOn = null);
  for (; 0 < Qc.length && (c = Qc[0], null === c.blockedOn);) Vc(c), null === c.blockedOn && Qc.shift();
}
var cd = ua.ReactCurrentBatchConfig,
  dd = !0;
function ed(a, b, c, d) {
  var e = C,
    f = cd.transition;
  cd.transition = null;
  try {
    C = 1, fd(a, b, c, d);
  } finally {
    C = e, cd.transition = f;
  }
}
function gd(a, b, c, d) {
  var e = C,
    f = cd.transition;
  cd.transition = null;
  try {
    C = 4, fd(a, b, c, d);
  } finally {
    C = e, cd.transition = f;
  }
}
function fd(a, b, c, d) {
  if (dd) {
    var e = Yc(a, b, c, d);
    if (null === e) hd(a, b, d, id, c), Sc(a, d);else if (Uc(e, a, b, c, d)) d.stopPropagation();else if (Sc(a, d), b & 4 && -1 < Rc.indexOf(a)) {
      for (; null !== e;) {
        var f = Cb(e);
        null !== f && Ec(f);
        f = Yc(a, b, c, d);
        null === f && hd(a, b, d, id, c);
        if (f === e) break;
        e = f;
      }
      null !== e && d.stopPropagation();
    } else hd(a, b, d, null, c);
  }
}
var id = null;
function Yc(a, b, c, d) {
  id = null;
  a = xb(d);
  a = Wc(a);
  if (null !== a) if (b = Vb(a), null === b) a = null;else if (c = b.tag, 13 === c) {
    a = Wb(b);
    if (null !== a) return a;
    a = null;
  } else if (3 === c) {
    if (b.stateNode.current.memoizedState.isDehydrated) return 3 === b.tag ? b.stateNode.containerInfo : null;
    a = null;
  } else b !== a && (a = null);
  id = a;
  return null;
}
function jd(a) {
  switch (a) {
    case "cancel":
    case "click":
    case "close":
    case "contextmenu":
    case "copy":
    case "cut":
    case "auxclick":
    case "dblclick":
    case "dragend":
    case "dragstart":
    case "drop":
    case "focusin":
    case "focusout":
    case "input":
    case "invalid":
    case "keydown":
    case "keypress":
    case "keyup":
    case "mousedown":
    case "mouseup":
    case "paste":
    case "pause":
    case "play":
    case "pointercancel":
    case "pointerdown":
    case "pointerup":
    case "ratechange":
    case "reset":
    case "resize":
    case "seeked":
    case "submit":
    case "touchcancel":
    case "touchend":
    case "touchstart":
    case "volumechange":
    case "change":
    case "selectionchange":
    case "textInput":
    case "compositionstart":
    case "compositionend":
    case "compositionupdate":
    case "beforeblur":
    case "afterblur":
    case "beforeinput":
    case "blur":
    case "fullscreenchange":
    case "focus":
    case "hashchange":
    case "popstate":
    case "select":
    case "selectstart":
      return 1;
    case "drag":
    case "dragenter":
    case "dragexit":
    case "dragleave":
    case "dragover":
    case "mousemove":
    case "mouseout":
    case "mouseover":
    case "pointermove":
    case "pointerout":
    case "pointerover":
    case "scroll":
    case "toggle":
    case "touchmove":
    case "wheel":
    case "mouseenter":
    case "mouseleave":
    case "pointerenter":
    case "pointerleave":
      return 4;
    case "message":
      switch (ec()) {
        case fc:
          return 1;
        case gc:
          return 4;
        case hc:
        case ic:
          return 16;
        case jc:
          return 536870912;
        default:
          return 16;
      }
    default:
      return 16;
  }
}
var kd = null,
  ld = null,
  md = null;
function nd() {
  if (md) return md;
  var a,
    b = ld,
    c = b.length,
    d,
    e = "value" in kd ? kd.value : kd.textContent,
    f = e.length;
  for (a = 0; a < c && b[a] === e[a]; a++);
  var g = c - a;
  for (d = 1; d <= g && b[c - d] === e[f - d]; d++);
  return md = e.slice(a, 1 < d ? 1 - d : void 0);
}
function od(a) {
  var b = a.keyCode;
  "charCode" in a ? (a = a.charCode, 0 === a && 13 === b && (a = 13)) : a = b;
  10 === a && (a = 13);
  return 32 <= a || 13 === a ? a : 0;
}
function pd() {
  return !0;
}
function qd() {
  return !1;
}
function rd(a) {
  function b(b, d, e, f, g) {
    this._reactName = b;
    this._targetInst = e;
    this.type = d;
    this.nativeEvent = f;
    this.target = g;
    this.currentTarget = null;
    for (var c in a) a.hasOwnProperty(c) && (b = a[c], this[c] = b ? b(f) : f[c]);
    this.isDefaultPrevented = (null != f.defaultPrevented ? f.defaultPrevented : !1 === f.returnValue) ? pd : qd;
    this.isPropagationStopped = qd;
    return this;
  }
  A(b.prototype, {
    preventDefault: function preventDefault() {
      this.defaultPrevented = !0;
      var a = this.nativeEvent;
      a && (a.preventDefault ? a.preventDefault() : "unknown" !== typeof a.returnValue && (a.returnValue = !1), this.isDefaultPrevented = pd);
    },
    stopPropagation: function stopPropagation() {
      var a = this.nativeEvent;
      a && (a.stopPropagation ? a.stopPropagation() : "unknown" !== typeof a.cancelBubble && (a.cancelBubble = !0), this.isPropagationStopped = pd);
    },
    persist: function persist() {},
    isPersistent: pd
  });
  return b;
}
var sd = {
    eventPhase: 0,
    bubbles: 0,
    cancelable: 0,
    timeStamp: function timeStamp(a) {
      return a.timeStamp || Date.now();
    },
    defaultPrevented: 0,
    isTrusted: 0
  },
  td = rd(sd),
  ud = A({}, sd, {
    view: 0,
    detail: 0
  }),
  vd = rd(ud),
  wd,
  xd,
  yd,
  Ad = A({}, ud, {
    screenX: 0,
    screenY: 0,
    clientX: 0,
    clientY: 0,
    pageX: 0,
    pageY: 0,
    ctrlKey: 0,
    shiftKey: 0,
    altKey: 0,
    metaKey: 0,
    getModifierState: zd,
    button: 0,
    buttons: 0,
    relatedTarget: function relatedTarget(a) {
      return void 0 === a.relatedTarget ? a.fromElement === a.srcElement ? a.toElement : a.fromElement : a.relatedTarget;
    },
    movementX: function movementX(a) {
      if ("movementX" in a) return a.movementX;
      a !== yd && (yd && "mousemove" === a.type ? (wd = a.screenX - yd.screenX, xd = a.screenY - yd.screenY) : xd = wd = 0, yd = a);
      return wd;
    },
    movementY: function movementY(a) {
      return "movementY" in a ? a.movementY : xd;
    }
  }),
  Bd = rd(Ad),
  Cd = A({}, Ad, {
    dataTransfer: 0
  }),
  Dd = rd(Cd),
  Ed = A({}, ud, {
    relatedTarget: 0
  }),
  Fd = rd(Ed),
  Gd = A({}, sd, {
    animationName: 0,
    elapsedTime: 0,
    pseudoElement: 0
  }),
  Hd = rd(Gd),
  Id = A({}, sd, {
    clipboardData: function clipboardData(a) {
      return "clipboardData" in a ? a.clipboardData : window.clipboardData;
    }
  }),
  Jd = rd(Id),
  Kd = A({}, sd, {
    data: 0
  }),
  Ld = rd(Kd),
  Md = {
    Esc: "Escape",
    Spacebar: " ",
    Left: "ArrowLeft",
    Up: "ArrowUp",
    Right: "ArrowRight",
    Down: "ArrowDown",
    Del: "Delete",
    Win: "OS",
    Menu: "ContextMenu",
    Apps: "ContextMenu",
    Scroll: "ScrollLock",
    MozPrintableKey: "Unidentified"
  },
  Nd = {
    8: "Backspace",
    9: "Tab",
    12: "Clear",
    13: "Enter",
    16: "Shift",
    17: "Control",
    18: "Alt",
    19: "Pause",
    20: "CapsLock",
    27: "Escape",
    32: " ",
    33: "PageUp",
    34: "PageDown",
    35: "End",
    36: "Home",
    37: "ArrowLeft",
    38: "ArrowUp",
    39: "ArrowRight",
    40: "ArrowDown",
    45: "Insert",
    46: "Delete",
    112: "F1",
    113: "F2",
    114: "F3",
    115: "F4",
    116: "F5",
    117: "F6",
    118: "F7",
    119: "F8",
    120: "F9",
    121: "F10",
    122: "F11",
    123: "F12",
    144: "NumLock",
    145: "ScrollLock",
    224: "Meta"
  },
  Od = {
    Alt: "altKey",
    Control: "ctrlKey",
    Meta: "metaKey",
    Shift: "shiftKey"
  };
function Pd(a) {
  var b = this.nativeEvent;
  return b.getModifierState ? b.getModifierState(a) : (a = Od[a]) ? !!b[a] : !1;
}
function zd() {
  return Pd;
}
var Qd = A({}, ud, {
    key: function key(a) {
      if (a.key) {
        var b = Md[a.key] || a.key;
        if ("Unidentified" !== b) return b;
      }
      return "keypress" === a.type ? (a = od(a), 13 === a ? "Enter" : String.fromCharCode(a)) : "keydown" === a.type || "keyup" === a.type ? Nd[a.keyCode] || "Unidentified" : "";
    },
    code: 0,
    location: 0,
    ctrlKey: 0,
    shiftKey: 0,
    altKey: 0,
    metaKey: 0,
    repeat: 0,
    locale: 0,
    getModifierState: zd,
    charCode: function charCode(a) {
      return "keypress" === a.type ? od(a) : 0;
    },
    keyCode: function keyCode(a) {
      return "keydown" === a.type || "keyup" === a.type ? a.keyCode : 0;
    },
    which: function which(a) {
      return "keypress" === a.type ? od(a) : "keydown" === a.type || "keyup" === a.type ? a.keyCode : 0;
    }
  }),
  Rd = rd(Qd),
  Sd = A({}, Ad, {
    pointerId: 0,
    width: 0,
    height: 0,
    pressure: 0,
    tangentialPressure: 0,
    tiltX: 0,
    tiltY: 0,
    twist: 0,
    pointerType: 0,
    isPrimary: 0
  }),
  Td = rd(Sd),
  Ud = A({}, ud, {
    touches: 0,
    targetTouches: 0,
    changedTouches: 0,
    altKey: 0,
    metaKey: 0,
    ctrlKey: 0,
    shiftKey: 0,
    getModifierState: zd
  }),
  Vd = rd(Ud),
  Wd = A({}, sd, {
    propertyName: 0,
    elapsedTime: 0,
    pseudoElement: 0
  }),
  Xd = rd(Wd),
  Yd = A({}, Ad, {
    deltaX: function deltaX(a) {
      return "deltaX" in a ? a.deltaX : "wheelDeltaX" in a ? -a.wheelDeltaX : 0;
    },
    deltaY: function deltaY(a) {
      return "deltaY" in a ? a.deltaY : "wheelDeltaY" in a ? -a.wheelDeltaY : "wheelDelta" in a ? -a.wheelDelta : 0;
    },
    deltaZ: 0,
    deltaMode: 0
  }),
  Zd = rd(Yd),
  $d = [9, 13, 27, 32],
  ae = ia && "CompositionEvent" in window,
  be = null;
ia && "documentMode" in document && (be = document.documentMode);
var ce = ia && "TextEvent" in window && !be,
  de = ia && (!ae || be && 8 < be && 11 >= be),
  ee = String.fromCharCode(32),
  fe = !1;
function ge(a, b) {
  switch (a) {
    case "keyup":
      return -1 !== $d.indexOf(b.keyCode);
    case "keydown":
      return 229 !== b.keyCode;
    case "keypress":
    case "mousedown":
    case "focusout":
      return !0;
    default:
      return !1;
  }
}
function he(a) {
  a = a.detail;
  return "object" === typeof a && "data" in a ? a.data : null;
}
var ie = !1;
function je(a, b) {
  switch (a) {
    case "compositionend":
      return he(b);
    case "keypress":
      if (32 !== b.which) return null;
      fe = !0;
      return ee;
    case "textInput":
      return a = b.data, a === ee && fe ? null : a;
    default:
      return null;
  }
}
function ke(a, b) {
  if (ie) return "compositionend" === a || !ae && ge(a, b) ? (a = nd(), md = ld = kd = null, ie = !1, a) : null;
  switch (a) {
    case "paste":
      return null;
    case "keypress":
      if (!(b.ctrlKey || b.altKey || b.metaKey) || b.ctrlKey && b.altKey) {
        if (b.char && 1 < b.char.length) return b.char;
        if (b.which) return String.fromCharCode(b.which);
      }
      return null;
    case "compositionend":
      return de && "ko" !== b.locale ? null : b.data;
    default:
      return null;
  }
}
var le = {
  color: !0,
  date: !0,
  datetime: !0,
  "datetime-local": !0,
  email: !0,
  month: !0,
  number: !0,
  password: !0,
  range: !0,
  search: !0,
  tel: !0,
  text: !0,
  time: !0,
  url: !0,
  week: !0
};
function me(a) {
  var b = a && a.nodeName && a.nodeName.toLowerCase();
  return "input" === b ? !!le[a.type] : "textarea" === b ? !0 : !1;
}
function ne(a, b, c, d) {
  Eb(d);
  b = oe(b, "onChange");
  0 < b.length && (c = new td("onChange", "change", null, c, d), a.push({
    event: c,
    listeners: b
  }));
}
var pe = null,
  qe = null;
function re(a) {
  se(a, 0);
}
function te(a) {
  var b = ue(a);
  if (Wa(b)) return a;
}
function ve(a, b) {
  if ("change" === a) return b;
}
var we = !1;
if (ia) {
  var xe;
  if (ia) {
    var ye = ("oninput" in document);
    if (!ye) {
      var ze = document.createElement("div");
      ze.setAttribute("oninput", "return;");
      ye = "function" === typeof ze.oninput;
    }
    xe = ye;
  } else xe = !1;
  we = xe && (!document.documentMode || 9 < document.documentMode);
}
function Ae() {
  pe && (pe.detachEvent("onpropertychange", Be), qe = pe = null);
}
function Be(a) {
  if ("value" === a.propertyName && te(qe)) {
    var b = [];
    ne(b, qe, a, xb(a));
    Jb(re, b);
  }
}
function Ce(a, b, c) {
  "focusin" === a ? (Ae(), pe = b, qe = c, pe.attachEvent("onpropertychange", Be)) : "focusout" === a && Ae();
}
function De(a) {
  if ("selectionchange" === a || "keyup" === a || "keydown" === a) return te(qe);
}
function Ee(a, b) {
  if ("click" === a) return te(b);
}
function Fe(a, b) {
  if ("input" === a || "change" === a) return te(b);
}
function Ge(a, b) {
  return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b;
}
var He = "function" === typeof Object.is ? Object.is : Ge;
function Ie(a, b) {
  if (He(a, b)) return !0;
  if ("object" !== typeof a || null === a || "object" !== typeof b || null === b) return !1;
  var c = Object.keys(a),
    d = Object.keys(b);
  if (c.length !== d.length) return !1;
  for (d = 0; d < c.length; d++) {
    var e = c[d];
    if (!ja.call(b, e) || !He(a[e], b[e])) return !1;
  }
  return !0;
}
function Je(a) {
  for (; a && a.firstChild;) a = a.firstChild;
  return a;
}
function Ke(a, b) {
  var c = Je(a);
  a = 0;
  for (var d; c;) {
    if (3 === c.nodeType) {
      d = a + c.textContent.length;
      if (a <= b && d >= b) return {
        node: c,
        offset: b - a
      };
      a = d;
    }
    a: {
      for (; c;) {
        if (c.nextSibling) {
          c = c.nextSibling;
          break a;
        }
        c = c.parentNode;
      }
      c = void 0;
    }
    c = Je(c);
  }
}
function Le(a, b) {
  return a && b ? a === b ? !0 : a && 3 === a.nodeType ? !1 : b && 3 === b.nodeType ? Le(a, b.parentNode) : "contains" in a ? a.contains(b) : a.compareDocumentPosition ? !!(a.compareDocumentPosition(b) & 16) : !1 : !1;
}
function Me() {
  for (var a = window, b = Xa(); b instanceof a.HTMLIFrameElement;) {
    try {
      var c = "string" === typeof b.contentWindow.location.href;
    } catch (d) {
      c = !1;
    }
    if (c) a = b.contentWindow;else break;
    b = Xa(a.document);
  }
  return b;
}
function Ne(a) {
  var b = a && a.nodeName && a.nodeName.toLowerCase();
  return b && ("input" === b && ("text" === a.type || "search" === a.type || "tel" === a.type || "url" === a.type || "password" === a.type) || "textarea" === b || "true" === a.contentEditable);
}
function Oe(a) {
  var b = Me(),
    c = a.focusedElem,
    d = a.selectionRange;
  if (b !== c && c && c.ownerDocument && Le(c.ownerDocument.documentElement, c)) {
    if (null !== d && Ne(c)) if (b = d.start, a = d.end, void 0 === a && (a = b), "selectionStart" in c) c.selectionStart = b, c.selectionEnd = Math.min(a, c.value.length);else if (a = (b = c.ownerDocument || document) && b.defaultView || window, a.getSelection) {
      a = a.getSelection();
      var e = c.textContent.length,
        f = Math.min(d.start, e);
      d = void 0 === d.end ? f : Math.min(d.end, e);
      !a.extend && f > d && (e = d, d = f, f = e);
      e = Ke(c, f);
      var g = Ke(c, d);
      e && g && (1 !== a.rangeCount || a.anchorNode !== e.node || a.anchorOffset !== e.offset || a.focusNode !== g.node || a.focusOffset !== g.offset) && (b = b.createRange(), b.setStart(e.node, e.offset), a.removeAllRanges(), f > d ? (a.addRange(b), a.extend(g.node, g.offset)) : (b.setEnd(g.node, g.offset), a.addRange(b)));
    }
    b = [];
    for (a = c; a = a.parentNode;) 1 === a.nodeType && b.push({
      element: a,
      left: a.scrollLeft,
      top: a.scrollTop
    });
    "function" === typeof c.focus && c.focus();
    for (c = 0; c < b.length; c++) a = b[c], a.element.scrollLeft = a.left, a.element.scrollTop = a.top;
  }
}
var Pe = ia && "documentMode" in document && 11 >= document.documentMode,
  Qe = null,
  Re = null,
  Se = null,
  Te = !1;
function Ue(a, b, c) {
  var d = c.window === c ? c.document : 9 === c.nodeType ? c : c.ownerDocument;
  Te || null == Qe || Qe !== Xa(d) || (d = Qe, "selectionStart" in d && Ne(d) ? d = {
    start: d.selectionStart,
    end: d.selectionEnd
  } : (d = (d.ownerDocument && d.ownerDocument.defaultView || window).getSelection(), d = {
    anchorNode: d.anchorNode,
    anchorOffset: d.anchorOffset,
    focusNode: d.focusNode,
    focusOffset: d.focusOffset
  }), Se && Ie(Se, d) || (Se = d, d = oe(Re, "onSelect"), 0 < d.length && (b = new td("onSelect", "select", null, b, c), a.push({
    event: b,
    listeners: d
  }), b.target = Qe)));
}
function Ve(a, b) {
  var c = {};
  c[a.toLowerCase()] = b.toLowerCase();
  c["Webkit" + a] = "webkit" + b;
  c["Moz" + a] = "moz" + b;
  return c;
}
var We = {
    animationend: Ve("Animation", "AnimationEnd"),
    animationiteration: Ve("Animation", "AnimationIteration"),
    animationstart: Ve("Animation", "AnimationStart"),
    transitionend: Ve("Transition", "TransitionEnd")
  },
  Xe = {},
  Ye = {};
ia && (Ye = document.createElement("div").style, "AnimationEvent" in window || (delete We.animationend.animation, delete We.animationiteration.animation, delete We.animationstart.animation), "TransitionEvent" in window || delete We.transitionend.transition);
function Ze(a) {
  if (Xe[a]) return Xe[a];
  if (!We[a]) return a;
  var b = We[a],
    c;
  for (c in b) if (b.hasOwnProperty(c) && c in Ye) return Xe[a] = b[c];
  return a;
}
var $e = Ze("animationend"),
  af = Ze("animationiteration"),
  bf = Ze("animationstart"),
  cf = Ze("transitionend"),
  df = new Map(),
  ef = "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" ");
function ff(a, b) {
  df.set(a, b);
  fa(b, [a]);
}
for (var gf = 0; gf < ef.length; gf++) {
  var hf = ef[gf],
    jf = hf.toLowerCase(),
    kf = hf[0].toUpperCase() + hf.slice(1);
  ff(jf, "on" + kf);
}
ff($e, "onAnimationEnd");
ff(af, "onAnimationIteration");
ff(bf, "onAnimationStart");
ff("dblclick", "onDoubleClick");
ff("focusin", "onFocus");
ff("focusout", "onBlur");
ff(cf, "onTransitionEnd");
ha("onMouseEnter", ["mouseout", "mouseover"]);
ha("onMouseLeave", ["mouseout", "mouseover"]);
ha("onPointerEnter", ["pointerout", "pointerover"]);
ha("onPointerLeave", ["pointerout", "pointerover"]);
fa("onChange", "change click focusin focusout input keydown keyup selectionchange".split(" "));
fa("onSelect", "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(" "));
fa("onBeforeInput", ["compositionend", "keypress", "textInput", "paste"]);
fa("onCompositionEnd", "compositionend focusout keydown keypress keyup mousedown".split(" "));
fa("onCompositionStart", "compositionstart focusout keydown keypress keyup mousedown".split(" "));
fa("onCompositionUpdate", "compositionupdate focusout keydown keypress keyup mousedown".split(" "));
var lf = "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(" "),
  mf = new Set("cancel close invalid load scroll toggle".split(" ").concat(lf));
function nf(a, b, c) {
  var d = a.type || "unknown-event";
  a.currentTarget = c;
  Ub(d, b, void 0, a);
  a.currentTarget = null;
}
function se(a, b) {
  b = 0 !== (b & 4);
  for (var c = 0; c < a.length; c++) {
    var d = a[c],
      e = d.event;
    d = d.listeners;
    a: {
      var f = void 0;
      if (b) for (var g = d.length - 1; 0 <= g; g--) {
        var h = d[g],
          k = h.instance,
          l = h.currentTarget;
        h = h.listener;
        if (k !== f && e.isPropagationStopped()) break a;
        nf(e, h, l);
        f = k;
      } else for (g = 0; g < d.length; g++) {
        h = d[g];
        k = h.instance;
        l = h.currentTarget;
        h = h.listener;
        if (k !== f && e.isPropagationStopped()) break a;
        nf(e, h, l);
        f = k;
      }
    }
  }
  if (Qb) throw a = Rb, Qb = !1, Rb = null, a;
}
function D(a, b) {
  var c = b[of];
  void 0 === c && (c = b[of] = new Set());
  var d = a + "__bubble";
  c.has(d) || (pf(b, a, 2, !1), c.add(d));
}
function qf(a, b, c) {
  var d = 0;
  b && (d |= 4);
  pf(c, a, d, b);
}
var rf = "_reactListening" + Math.random().toString(36).slice(2);
function sf(a) {
  if (!a[rf]) {
    a[rf] = !0;
    da.forEach(function (b) {
      "selectionchange" !== b && (mf.has(b) || qf(b, !1, a), qf(b, !0, a));
    });
    var b = 9 === a.nodeType ? a : a.ownerDocument;
    null === b || b[rf] || (b[rf] = !0, qf("selectionchange", !1, b));
  }
}
function pf(a, b, c, d) {
  switch (jd(b)) {
    case 1:
      var e = ed;
      break;
    case 4:
      e = gd;
      break;
    default:
      e = fd;
  }
  c = e.bind(null, b, c, a);
  e = void 0;
  !Lb || "touchstart" !== b && "touchmove" !== b && "wheel" !== b || (e = !0);
  d ? void 0 !== e ? a.addEventListener(b, c, {
    capture: !0,
    passive: e
  }) : a.addEventListener(b, c, !0) : void 0 !== e ? a.addEventListener(b, c, {
    passive: e
  }) : a.addEventListener(b, c, !1);
}
function hd(a, b, c, d, e) {
  var f = d;
  if (0 === (b & 1) && 0 === (b & 2) && null !== d) a: for (;;) {
    if (null === d) return;
    var g = d.tag;
    if (3 === g || 4 === g) {
      var h = d.stateNode.containerInfo;
      if (h === e || 8 === h.nodeType && h.parentNode === e) break;
      if (4 === g) for (g = d.return; null !== g;) {
        var k = g.tag;
        if (3 === k || 4 === k) if (k = g.stateNode.containerInfo, k === e || 8 === k.nodeType && k.parentNode === e) return;
        g = g.return;
      }
      for (; null !== h;) {
        g = Wc(h);
        if (null === g) return;
        k = g.tag;
        if (5 === k || 6 === k) {
          d = f = g;
          continue a;
        }
        h = h.parentNode;
      }
    }
    d = d.return;
  }
  Jb(function () {
    var d = f,
      e = xb(c),
      g = [];
    a: {
      var h = df.get(a);
      if (void 0 !== h) {
        var k = td,
          n = a;
        switch (a) {
          case "keypress":
            if (0 === od(c)) break a;
          case "keydown":
          case "keyup":
            k = Rd;
            break;
          case "focusin":
            n = "focus";
            k = Fd;
            break;
          case "focusout":
            n = "blur";
            k = Fd;
            break;
          case "beforeblur":
          case "afterblur":
            k = Fd;
            break;
          case "click":
            if (2 === c.button) break a;
          case "auxclick":
          case "dblclick":
          case "mousedown":
          case "mousemove":
          case "mouseup":
          case "mouseout":
          case "mouseover":
          case "contextmenu":
            k = Bd;
            break;
          case "drag":
          case "dragend":
          case "dragenter":
          case "dragexit":
          case "dragleave":
          case "dragover":
          case "dragstart":
          case "drop":
            k = Dd;
            break;
          case "touchcancel":
          case "touchend":
          case "touchmove":
          case "touchstart":
            k = Vd;
            break;
          case $e:
          case af:
          case bf:
            k = Hd;
            break;
          case cf:
            k = Xd;
            break;
          case "scroll":
            k = vd;
            break;
          case "wheel":
            k = Zd;
            break;
          case "copy":
          case "cut":
          case "paste":
            k = Jd;
            break;
          case "gotpointercapture":
          case "lostpointercapture":
          case "pointercancel":
          case "pointerdown":
          case "pointermove":
          case "pointerout":
          case "pointerover":
          case "pointerup":
            k = Td;
        }
        var t = 0 !== (b & 4),
          J = !t && "scroll" === a,
          x = t ? null !== h ? h + "Capture" : null : h;
        t = [];
        for (var w = d, u; null !== w;) {
          u = w;
          var F = u.stateNode;
          5 === u.tag && null !== F && (u = F, null !== x && (F = Kb(w, x), null != F && t.push(tf(w, F, u))));
          if (J) break;
          w = w.return;
        }
        0 < t.length && (h = new k(h, n, null, c, e), g.push({
          event: h,
          listeners: t
        }));
      }
    }
    if (0 === (b & 7)) {
      a: {
        h = "mouseover" === a || "pointerover" === a;
        k = "mouseout" === a || "pointerout" === a;
        if (h && c !== wb && (n = c.relatedTarget || c.fromElement) && (Wc(n) || n[uf])) break a;
        if (k || h) {
          h = e.window === e ? e : (h = e.ownerDocument) ? h.defaultView || h.parentWindow : window;
          if (k) {
            if (n = c.relatedTarget || c.toElement, k = d, n = n ? Wc(n) : null, null !== n && (J = Vb(n), n !== J || 5 !== n.tag && 6 !== n.tag)) n = null;
          } else k = null, n = d;
          if (k !== n) {
            t = Bd;
            F = "onMouseLeave";
            x = "onMouseEnter";
            w = "mouse";
            if ("pointerout" === a || "pointerover" === a) t = Td, F = "onPointerLeave", x = "onPointerEnter", w = "pointer";
            J = null == k ? h : ue(k);
            u = null == n ? h : ue(n);
            h = new t(F, w + "leave", k, c, e);
            h.target = J;
            h.relatedTarget = u;
            F = null;
            Wc(e) === d && (t = new t(x, w + "enter", n, c, e), t.target = u, t.relatedTarget = J, F = t);
            J = F;
            if (k && n) b: {
              t = k;
              x = n;
              w = 0;
              for (u = t; u; u = vf(u)) w++;
              u = 0;
              for (F = x; F; F = vf(F)) u++;
              for (; 0 < w - u;) t = vf(t), w--;
              for (; 0 < u - w;) x = vf(x), u--;
              for (; w--;) {
                if (t === x || null !== x && t === x.alternate) break b;
                t = vf(t);
                x = vf(x);
              }
              t = null;
            } else t = null;
            null !== k && wf(g, h, k, t, !1);
            null !== n && null !== J && wf(g, J, n, t, !0);
          }
        }
      }
      a: {
        h = d ? ue(d) : window;
        k = h.nodeName && h.nodeName.toLowerCase();
        if ("select" === k || "input" === k && "file" === h.type) var na = ve;else if (me(h)) {
          if (we) na = Fe;else {
            na = De;
            var xa = Ce;
          }
        } else (k = h.nodeName) && "input" === k.toLowerCase() && ("checkbox" === h.type || "radio" === h.type) && (na = Ee);
        if (na && (na = na(a, d))) {
          ne(g, na, c, e);
          break a;
        }
        xa && xa(a, h, d);
        "focusout" === a && (xa = h._wrapperState) && xa.controlled && "number" === h.type && cb(h, "number", h.value);
      }
      xa = d ? ue(d) : window;
      switch (a) {
        case "focusin":
          if (me(xa) || "true" === xa.contentEditable) Qe = xa, Re = d, Se = null;
          break;
        case "focusout":
          Se = Re = Qe = null;
          break;
        case "mousedown":
          Te = !0;
          break;
        case "contextmenu":
        case "mouseup":
        case "dragend":
          Te = !1;
          Ue(g, c, e);
          break;
        case "selectionchange":
          if (Pe) break;
        case "keydown":
        case "keyup":
          Ue(g, c, e);
      }
      var $a;
      if (ae) b: {
        switch (a) {
          case "compositionstart":
            var ba = "onCompositionStart";
            break b;
          case "compositionend":
            ba = "onCompositionEnd";
            break b;
          case "compositionupdate":
            ba = "onCompositionUpdate";
            break b;
        }
        ba = void 0;
      } else ie ? ge(a, c) && (ba = "onCompositionEnd") : "keydown" === a && 229 === c.keyCode && (ba = "onCompositionStart");
      ba && (de && "ko" !== c.locale && (ie || "onCompositionStart" !== ba ? "onCompositionEnd" === ba && ie && ($a = nd()) : (kd = e, ld = "value" in kd ? kd.value : kd.textContent, ie = !0)), xa = oe(d, ba), 0 < xa.length && (ba = new Ld(ba, a, null, c, e), g.push({
        event: ba,
        listeners: xa
      }), $a ? ba.data = $a : ($a = he(c), null !== $a && (ba.data = $a))));
      if ($a = ce ? je(a, c) : ke(a, c)) d = oe(d, "onBeforeInput"), 0 < d.length && (e = new Ld("onBeforeInput", "beforeinput", null, c, e), g.push({
        event: e,
        listeners: d
      }), e.data = $a);
    }
    se(g, b);
  });
}
function tf(a, b, c) {
  return {
    instance: a,
    listener: b,
    currentTarget: c
  };
}
function oe(a, b) {
  for (var c = b + "Capture", d = []; null !== a;) {
    var e = a,
      f = e.stateNode;
    5 === e.tag && null !== f && (e = f, f = Kb(a, c), null != f && d.unshift(tf(a, f, e)), f = Kb(a, b), null != f && d.push(tf(a, f, e)));
    a = a.return;
  }
  return d;
}
function vf(a) {
  if (null === a) return null;
  do a = a.return; while (a && 5 !== a.tag);
  return a ? a : null;
}
function wf(a, b, c, d, e) {
  for (var f = b._reactName, g = []; null !== c && c !== d;) {
    var h = c,
      k = h.alternate,
      l = h.stateNode;
    if (null !== k && k === d) break;
    5 === h.tag && null !== l && (h = l, e ? (k = Kb(c, f), null != k && g.unshift(tf(c, k, h))) : e || (k = Kb(c, f), null != k && g.push(tf(c, k, h))));
    c = c.return;
  }
  0 !== g.length && a.push({
    event: b,
    listeners: g
  });
}
var xf = /\r\n?/g,
  yf = /\u0000|\uFFFD/g;
function zf(a) {
  return ("string" === typeof a ? a : "" + a).replace(xf, "\n").replace(yf, "");
}
function Af(a, b, c) {
  b = zf(b);
  if (zf(a) !== b && c) throw Error(p(425));
}
function Bf() {}
var Cf = null,
  Df = null;
function Ef(a, b) {
  return "textarea" === a || "noscript" === a || "string" === typeof b.children || "number" === typeof b.children || "object" === typeof b.dangerouslySetInnerHTML && null !== b.dangerouslySetInnerHTML && null != b.dangerouslySetInnerHTML.__html;
}
var Ff = "function" === typeof setTimeout ? setTimeout : void 0,
  Gf = "function" === typeof clearTimeout ? clearTimeout : void 0,
  Hf = "function" === typeof Promise ? Promise : void 0,
  Jf = "function" === typeof queueMicrotask ? queueMicrotask : "undefined" !== typeof Hf ? function (a) {
    return Hf.resolve(null).then(a).catch(If);
  } : Ff;
function If(a) {
  setTimeout(function () {
    throw a;
  });
}
function Kf(a, b) {
  var c = b,
    d = 0;
  do {
    var e = c.nextSibling;
    a.removeChild(c);
    if (e && 8 === e.nodeType) if (c = e.data, "/$" === c) {
      if (0 === d) {
        a.removeChild(e);
        bd(b);
        return;
      }
      d--;
    } else "$" !== c && "$?" !== c && "$!" !== c || d++;
    c = e;
  } while (c);
  bd(b);
}
function Lf(a) {
  for (; null != a; a = a.nextSibling) {
    var b = a.nodeType;
    if (1 === b || 3 === b) break;
    if (8 === b) {
      b = a.data;
      if ("$" === b || "$!" === b || "$?" === b) break;
      if ("/$" === b) return null;
    }
  }
  return a;
}
function Mf(a) {
  a = a.previousSibling;
  for (var b = 0; a;) {
    if (8 === a.nodeType) {
      var c = a.data;
      if ("$" === c || "$!" === c || "$?" === c) {
        if (0 === b) return a;
        b--;
      } else "/$" === c && b++;
    }
    a = a.previousSibling;
  }
  return null;
}
var Nf = Math.random().toString(36).slice(2),
  Of = "__reactFiber$" + Nf,
  Pf = "__reactProps$" + Nf,
  uf = "__reactContainer$" + Nf,
  of = "__reactEvents$" + Nf,
  Qf = "__reactListeners$" + Nf,
  Rf = "__reactHandles$" + Nf;
function Wc(a) {
  var b = a[Of];
  if (b) return b;
  for (var c = a.parentNode; c;) {
    if (b = c[uf] || c[Of]) {
      c = b.alternate;
      if (null !== b.child || null !== c && null !== c.child) for (a = Mf(a); null !== a;) {
        if (c = a[Of]) return c;
        a = Mf(a);
      }
      return b;
    }
    a = c;
    c = a.parentNode;
  }
  return null;
}
function Cb(a) {
  a = a[Of] || a[uf];
  return !a || 5 !== a.tag && 6 !== a.tag && 13 !== a.tag && 3 !== a.tag ? null : a;
}
function ue(a) {
  if (5 === a.tag || 6 === a.tag) return a.stateNode;
  throw Error(p(33));
}
function Db(a) {
  return a[Pf] || null;
}
var Sf = [],
  Tf = -1;
function Uf(a) {
  return {
    current: a
  };
}
function E(a) {
  0 > Tf || (a.current = Sf[Tf], Sf[Tf] = null, Tf--);
}
function G(a, b) {
  Tf++;
  Sf[Tf] = a.current;
  a.current = b;
}
var Vf = {},
  H = Uf(Vf),
  Wf = Uf(!1),
  Xf = Vf;
function Yf(a, b) {
  var c = a.type.contextTypes;
  if (!c) return Vf;
  var d = a.stateNode;
  if (d && d.__reactInternalMemoizedUnmaskedChildContext === b) return d.__reactInternalMemoizedMaskedChildContext;
  var e = {},
    f;
  for (f in c) e[f] = b[f];
  d && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = b, a.__reactInternalMemoizedMaskedChildContext = e);
  return e;
}
function Zf(a) {
  a = a.childContextTypes;
  return null !== a && void 0 !== a;
}
function $f() {
  E(Wf);
  E(H);
}
function ag(a, b, c) {
  if (H.current !== Vf) throw Error(p(168));
  G(H, b);
  G(Wf, c);
}
function bg(a, b, c) {
  var d = a.stateNode;
  b = b.childContextTypes;
  if ("function" !== typeof d.getChildContext) return c;
  d = d.getChildContext();
  for (var e in d) if (!(e in b)) throw Error(p(108, Ra(a) || "Unknown", e));
  return A({}, c, d);
}
function cg(a) {
  a = (a = a.stateNode) && a.__reactInternalMemoizedMergedChildContext || Vf;
  Xf = H.current;
  G(H, a);
  G(Wf, Wf.current);
  return !0;
}
function dg(a, b, c) {
  var d = a.stateNode;
  if (!d) throw Error(p(169));
  c ? (a = bg(a, b, Xf), d.__reactInternalMemoizedMergedChildContext = a, E(Wf), E(H), G(H, a)) : E(Wf);
  G(Wf, c);
}
var eg = null,
  fg = !1,
  gg = !1;
function hg(a) {
  null === eg ? eg = [a] : eg.push(a);
}
function ig(a) {
  fg = !0;
  hg(a);
}
function jg() {
  if (!gg && null !== eg) {
    gg = !0;
    var a = 0,
      b = C;
    try {
      var c = eg;
      for (C = 1; a < c.length; a++) {
        var d = c[a];
        do d = d(!0); while (null !== d);
      }
      eg = null;
      fg = !1;
    } catch (e) {
      throw null !== eg && (eg = eg.slice(a + 1)), ac(fc, jg), e;
    } finally {
      C = b, gg = !1;
    }
  }
  return null;
}
var kg = [],
  lg = 0,
  mg = null,
  ng = 0,
  og = [],
  pg = 0,
  qg = null,
  rg = 1,
  sg = "";
function tg(a, b) {
  kg[lg++] = ng;
  kg[lg++] = mg;
  mg = a;
  ng = b;
}
function ug(a, b, c) {
  og[pg++] = rg;
  og[pg++] = sg;
  og[pg++] = qg;
  qg = a;
  var d = rg;
  a = sg;
  var e = 32 - oc(d) - 1;
  d &= ~(1 << e);
  c += 1;
  var f = 32 - oc(b) + e;
  if (30 < f) {
    var g = e - e % 5;
    f = (d & (1 << g) - 1).toString(32);
    d >>= g;
    e -= g;
    rg = 1 << 32 - oc(b) + e | c << e | d;
    sg = f + a;
  } else rg = 1 << f | c << e | d, sg = a;
}
function vg(a) {
  null !== a.return && (tg(a, 1), ug(a, 1, 0));
}
function wg(a) {
  for (; a === mg;) mg = kg[--lg], kg[lg] = null, ng = kg[--lg], kg[lg] = null;
  for (; a === qg;) qg = og[--pg], og[pg] = null, sg = og[--pg], og[pg] = null, rg = og[--pg], og[pg] = null;
}
var xg = null,
  yg = null,
  I = !1,
  zg = null;
function Ag(a, b) {
  var c = Bg(5, null, null, 0);
  c.elementType = "DELETED";
  c.stateNode = b;
  c.return = a;
  b = a.deletions;
  null === b ? (a.deletions = [c], a.flags |= 16) : b.push(c);
}
function Cg(a, b) {
  switch (a.tag) {
    case 5:
      var c = a.type;
      b = 1 !== b.nodeType || c.toLowerCase() !== b.nodeName.toLowerCase() ? null : b;
      return null !== b ? (a.stateNode = b, xg = a, yg = Lf(b.firstChild), !0) : !1;
    case 6:
      return b = "" === a.pendingProps || 3 !== b.nodeType ? null : b, null !== b ? (a.stateNode = b, xg = a, yg = null, !0) : !1;
    case 13:
      return b = 8 !== b.nodeType ? null : b, null !== b ? (c = null !== qg ? {
        id: rg,
        overflow: sg
      } : null, a.memoizedState = {
        dehydrated: b,
        treeContext: c,
        retryLane: 1073741824
      }, c = Bg(18, null, null, 0), c.stateNode = b, c.return = a, a.child = c, xg = a, yg = null, !0) : !1;
    default:
      return !1;
  }
}
function Dg(a) {
  return 0 !== (a.mode & 1) && 0 === (a.flags & 128);
}
function Eg(a) {
  if (I) {
    var b = yg;
    if (b) {
      var c = b;
      if (!Cg(a, b)) {
        if (Dg(a)) throw Error(p(418));
        b = Lf(c.nextSibling);
        var d = xg;
        b && Cg(a, b) ? Ag(d, c) : (a.flags = a.flags & -4097 | 2, I = !1, xg = a);
      }
    } else {
      if (Dg(a)) throw Error(p(418));
      a.flags = a.flags & -4097 | 2;
      I = !1;
      xg = a;
    }
  }
}
function Fg(a) {
  for (a = a.return; null !== a && 5 !== a.tag && 3 !== a.tag && 13 !== a.tag;) a = a.return;
  xg = a;
}
function Gg(a) {
  if (a !== xg) return !1;
  if (!I) return Fg(a), I = !0, !1;
  var b;
  (b = 3 !== a.tag) && !(b = 5 !== a.tag) && (b = a.type, b = "head" !== b && "body" !== b && !Ef(a.type, a.memoizedProps));
  if (b && (b = yg)) {
    if (Dg(a)) throw Hg(), Error(p(418));
    for (; b;) Ag(a, b), b = Lf(b.nextSibling);
  }
  Fg(a);
  if (13 === a.tag) {
    a = a.memoizedState;
    a = null !== a ? a.dehydrated : null;
    if (!a) throw Error(p(317));
    a: {
      a = a.nextSibling;
      for (b = 0; a;) {
        if (8 === a.nodeType) {
          var c = a.data;
          if ("/$" === c) {
            if (0 === b) {
              yg = Lf(a.nextSibling);
              break a;
            }
            b--;
          } else "$" !== c && "$!" !== c && "$?" !== c || b++;
        }
        a = a.nextSibling;
      }
      yg = null;
    }
  } else yg = xg ? Lf(a.stateNode.nextSibling) : null;
  return !0;
}
function Hg() {
  for (var a = yg; a;) a = Lf(a.nextSibling);
}
function Ig() {
  yg = xg = null;
  I = !1;
}
function Jg(a) {
  null === zg ? zg = [a] : zg.push(a);
}
var Kg = ua.ReactCurrentBatchConfig;
function Lg(a, b) {
  if (a && a.defaultProps) {
    b = A({}, b);
    a = a.defaultProps;
    for (var c in a) void 0 === b[c] && (b[c] = a[c]);
    return b;
  }
  return b;
}
var Mg = Uf(null),
  Ng = null,
  Og = null,
  Pg = null;
function Qg() {
  Pg = Og = Ng = null;
}
function Rg(a) {
  var b = Mg.current;
  E(Mg);
  a._currentValue = b;
}
function Sg(a, b, c) {
  for (; null !== a;) {
    var d = a.alternate;
    (a.childLanes & b) !== b ? (a.childLanes |= b, null !== d && (d.childLanes |= b)) : null !== d && (d.childLanes & b) !== b && (d.childLanes |= b);
    if (a === c) break;
    a = a.return;
  }
}
function Tg(a, b) {
  Ng = a;
  Pg = Og = null;
  a = a.dependencies;
  null !== a && null !== a.firstContext && (0 !== (a.lanes & b) && (Ug = !0), a.firstContext = null);
}
function Vg(a) {
  var b = a._currentValue;
  if (Pg !== a) if (a = {
    context: a,
    memoizedValue: b,
    next: null
  }, null === Og) {
    if (null === Ng) throw Error(p(308));
    Og = a;
    Ng.dependencies = {
      lanes: 0,
      firstContext: a
    };
  } else Og = Og.next = a;
  return b;
}
var Wg = null;
function Xg(a) {
  null === Wg ? Wg = [a] : Wg.push(a);
}
function Yg(a, b, c, d) {
  var e = b.interleaved;
  null === e ? (c.next = c, Xg(b)) : (c.next = e.next, e.next = c);
  b.interleaved = c;
  return Zg(a, d);
}
function Zg(a, b) {
  a.lanes |= b;
  var c = a.alternate;
  null !== c && (c.lanes |= b);
  c = a;
  for (a = a.return; null !== a;) a.childLanes |= b, c = a.alternate, null !== c && (c.childLanes |= b), c = a, a = a.return;
  return 3 === c.tag ? c.stateNode : null;
}
var $g = !1;
function ah(a) {
  a.updateQueue = {
    baseState: a.memoizedState,
    firstBaseUpdate: null,
    lastBaseUpdate: null,
    shared: {
      pending: null,
      interleaved: null,
      lanes: 0
    },
    effects: null
  };
}
function bh(a, b) {
  a = a.updateQueue;
  b.updateQueue === a && (b.updateQueue = {
    baseState: a.baseState,
    firstBaseUpdate: a.firstBaseUpdate,
    lastBaseUpdate: a.lastBaseUpdate,
    shared: a.shared,
    effects: a.effects
  });
}
function ch(a, b) {
  return {
    eventTime: a,
    lane: b,
    tag: 0,
    payload: null,
    callback: null,
    next: null
  };
}
function dh(a, b, c) {
  var d = a.updateQueue;
  if (null === d) return null;
  d = d.shared;
  if (0 !== (K & 2)) {
    var e = d.pending;
    null === e ? b.next = b : (b.next = e.next, e.next = b);
    d.pending = b;
    return Zg(a, c);
  }
  e = d.interleaved;
  null === e ? (b.next = b, Xg(d)) : (b.next = e.next, e.next = b);
  d.interleaved = b;
  return Zg(a, c);
}
function eh(a, b, c) {
  b = b.updateQueue;
  if (null !== b && (b = b.shared, 0 !== (c & 4194240))) {
    var d = b.lanes;
    d &= a.pendingLanes;
    c |= d;
    b.lanes = c;
    Cc(a, c);
  }
}
function fh(a, b) {
  var c = a.updateQueue,
    d = a.alternate;
  if (null !== d && (d = d.updateQueue, c === d)) {
    var e = null,
      f = null;
    c = c.firstBaseUpdate;
    if (null !== c) {
      do {
        var g = {
          eventTime: c.eventTime,
          lane: c.lane,
          tag: c.tag,
          payload: c.payload,
          callback: c.callback,
          next: null
        };
        null === f ? e = f = g : f = f.next = g;
        c = c.next;
      } while (null !== c);
      null === f ? e = f = b : f = f.next = b;
    } else e = f = b;
    c = {
      baseState: d.baseState,
      firstBaseUpdate: e,
      lastBaseUpdate: f,
      shared: d.shared,
      effects: d.effects
    };
    a.updateQueue = c;
    return;
  }
  a = c.lastBaseUpdate;
  null === a ? c.firstBaseUpdate = b : a.next = b;
  c.lastBaseUpdate = b;
}
function gh(a, b, c, d) {
  var e = a.updateQueue;
  $g = !1;
  var f = e.firstBaseUpdate,
    g = e.lastBaseUpdate,
    h = e.shared.pending;
  if (null !== h) {
    e.shared.pending = null;
    var k = h,
      l = k.next;
    k.next = null;
    null === g ? f = l : g.next = l;
    g = k;
    var m = a.alternate;
    null !== m && (m = m.updateQueue, h = m.lastBaseUpdate, h !== g && (null === h ? m.firstBaseUpdate = l : h.next = l, m.lastBaseUpdate = k));
  }
  if (null !== f) {
    var q = e.baseState;
    g = 0;
    m = l = k = null;
    h = f;
    do {
      var r = h.lane,
        y = h.eventTime;
      if ((d & r) === r) {
        null !== m && (m = m.next = {
          eventTime: y,
          lane: 0,
          tag: h.tag,
          payload: h.payload,
          callback: h.callback,
          next: null
        });
        a: {
          var n = a,
            t = h;
          r = b;
          y = c;
          switch (t.tag) {
            case 1:
              n = t.payload;
              if ("function" === typeof n) {
                q = n.call(y, q, r);
                break a;
              }
              q = n;
              break a;
            case 3:
              n.flags = n.flags & -65537 | 128;
            case 0:
              n = t.payload;
              r = "function" === typeof n ? n.call(y, q, r) : n;
              if (null === r || void 0 === r) break a;
              q = A({}, q, r);
              break a;
            case 2:
              $g = !0;
          }
        }
        null !== h.callback && 0 !== h.lane && (a.flags |= 64, r = e.effects, null === r ? e.effects = [h] : r.push(h));
      } else y = {
        eventTime: y,
        lane: r,
        tag: h.tag,
        payload: h.payload,
        callback: h.callback,
        next: null
      }, null === m ? (l = m = y, k = q) : m = m.next = y, g |= r;
      h = h.next;
      if (null === h) if (h = e.shared.pending, null === h) break;else r = h, h = r.next, r.next = null, e.lastBaseUpdate = r, e.shared.pending = null;
    } while (1);
    null === m && (k = q);
    e.baseState = k;
    e.firstBaseUpdate = l;
    e.lastBaseUpdate = m;
    b = e.shared.interleaved;
    if (null !== b) {
      e = b;
      do g |= e.lane, e = e.next; while (e !== b);
    } else null === f && (e.shared.lanes = 0);
    hh |= g;
    a.lanes = g;
    a.memoizedState = q;
  }
}
function ih(a, b, c) {
  a = b.effects;
  b.effects = null;
  if (null !== a) for (b = 0; b < a.length; b++) {
    var d = a[b],
      e = d.callback;
    if (null !== e) {
      d.callback = null;
      d = c;
      if ("function" !== typeof e) throw Error(p(191, e));
      e.call(d);
    }
  }
}
var jh = new aa.Component().refs;
function kh(a, b, c, d) {
  b = a.memoizedState;
  c = c(d, b);
  c = null === c || void 0 === c ? b : A({}, b, c);
  a.memoizedState = c;
  0 === a.lanes && (a.updateQueue.baseState = c);
}
var nh = {
  isMounted: function isMounted(a) {
    return (a = a._reactInternals) ? Vb(a) === a : !1;
  },
  enqueueSetState: function enqueueSetState(a, b, c) {
    a = a._reactInternals;
    var d = L(),
      e = lh(a),
      f = ch(d, e);
    f.payload = b;
    void 0 !== c && null !== c && (f.callback = c);
    b = dh(a, f, e);
    null !== b && (mh(b, a, e, d), eh(b, a, e));
  },
  enqueueReplaceState: function enqueueReplaceState(a, b, c) {
    a = a._reactInternals;
    var d = L(),
      e = lh(a),
      f = ch(d, e);
    f.tag = 1;
    f.payload = b;
    void 0 !== c && null !== c && (f.callback = c);
    b = dh(a, f, e);
    null !== b && (mh(b, a, e, d), eh(b, a, e));
  },
  enqueueForceUpdate: function enqueueForceUpdate(a, b) {
    a = a._reactInternals;
    var c = L(),
      d = lh(a),
      e = ch(c, d);
    e.tag = 2;
    void 0 !== b && null !== b && (e.callback = b);
    b = dh(a, e, d);
    null !== b && (mh(b, a, d, c), eh(b, a, d));
  }
};
function oh(a, b, c, d, e, f, g) {
  a = a.stateNode;
  return "function" === typeof a.shouldComponentUpdate ? a.shouldComponentUpdate(d, f, g) : b.prototype && b.prototype.isPureReactComponent ? !Ie(c, d) || !Ie(e, f) : !0;
}
function ph(a, b, c) {
  var d = !1,
    e = Vf;
  var f = b.contextType;
  "object" === typeof f && null !== f ? f = Vg(f) : (e = Zf(b) ? Xf : H.current, d = b.contextTypes, f = (d = null !== d && void 0 !== d) ? Yf(a, e) : Vf);
  b = new b(c, f);
  a.memoizedState = null !== b.state && void 0 !== b.state ? b.state : null;
  b.updater = nh;
  a.stateNode = b;
  b._reactInternals = a;
  d && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = e, a.__reactInternalMemoizedMaskedChildContext = f);
  return b;
}
function qh(a, b, c, d) {
  a = b.state;
  "function" === typeof b.componentWillReceiveProps && b.componentWillReceiveProps(c, d);
  "function" === typeof b.UNSAFE_componentWillReceiveProps && b.UNSAFE_componentWillReceiveProps(c, d);
  b.state !== a && nh.enqueueReplaceState(b, b.state, null);
}
function rh(a, b, c, d) {
  var e = a.stateNode;
  e.props = c;
  e.state = a.memoizedState;
  e.refs = jh;
  ah(a);
  var f = b.contextType;
  "object" === typeof f && null !== f ? e.context = Vg(f) : (f = Zf(b) ? Xf : H.current, e.context = Yf(a, f));
  e.state = a.memoizedState;
  f = b.getDerivedStateFromProps;
  "function" === typeof f && (kh(a, b, f, c), e.state = a.memoizedState);
  "function" === typeof b.getDerivedStateFromProps || "function" === typeof e.getSnapshotBeforeUpdate || "function" !== typeof e.UNSAFE_componentWillMount && "function" !== typeof e.componentWillMount || (b = e.state, "function" === typeof e.componentWillMount && e.componentWillMount(), "function" === typeof e.UNSAFE_componentWillMount && e.UNSAFE_componentWillMount(), b !== e.state && nh.enqueueReplaceState(e, e.state, null), gh(a, c, e, d), e.state = a.memoizedState);
  "function" === typeof e.componentDidMount && (a.flags |= 4194308);
}
function sh(a, b, c) {
  a = c.ref;
  if (null !== a && "function" !== typeof a && "object" !== typeof a) {
    if (c._owner) {
      c = c._owner;
      if (c) {
        if (1 !== c.tag) throw Error(p(309));
        var d = c.stateNode;
      }
      if (!d) throw Error(p(147, a));
      var e = d,
        f = "" + a;
      if (null !== b && null !== b.ref && "function" === typeof b.ref && b.ref._stringRef === f) return b.ref;
      b = function b(a) {
        var b = e.refs;
        b === jh && (b = e.refs = {});
        null === a ? delete b[f] : b[f] = a;
      };
      b._stringRef = f;
      return b;
    }
    if ("string" !== typeof a) throw Error(p(284));
    if (!c._owner) throw Error(p(290, a));
  }
  return a;
}
function th(a, b) {
  a = Object.prototype.toString.call(b);
  throw Error(p(31, "[object Object]" === a ? "object with keys {" + Object.keys(b).join(", ") + "}" : a));
}
function uh(a) {
  var b = a._init;
  return b(a._payload);
}
function vh(a) {
  function b(b, c) {
    if (a) {
      var d = b.deletions;
      null === d ? (b.deletions = [c], b.flags |= 16) : d.push(c);
    }
  }
  function c(c, d) {
    if (!a) return null;
    for (; null !== d;) b(c, d), d = d.sibling;
    return null;
  }
  function d(a, b) {
    for (a = new Map(); null !== b;) null !== b.key ? a.set(b.key, b) : a.set(b.index, b), b = b.sibling;
    return a;
  }
  function e(a, b) {
    a = wh(a, b);
    a.index = 0;
    a.sibling = null;
    return a;
  }
  function f(b, c, d) {
    b.index = d;
    if (!a) return b.flags |= 1048576, c;
    d = b.alternate;
    if (null !== d) return d = d.index, d < c ? (b.flags |= 2, c) : d;
    b.flags |= 2;
    return c;
  }
  function g(b) {
    a && null === b.alternate && (b.flags |= 2);
    return b;
  }
  function h(a, b, c, d) {
    if (null === b || 6 !== b.tag) return b = xh(c, a.mode, d), b.return = a, b;
    b = e(b, c);
    b.return = a;
    return b;
  }
  function k(a, b, c, d) {
    var f = c.type;
    if (f === ya) return m(a, b, c.props.children, d, c.key);
    if (null !== b && (b.elementType === f || "object" === typeof f && null !== f && f.$$typeof === Ha && uh(f) === b.type)) return d = e(b, c.props), d.ref = sh(a, b, c), d.return = a, d;
    d = yh(c.type, c.key, c.props, null, a.mode, d);
    d.ref = sh(a, b, c);
    d.return = a;
    return d;
  }
  function l(a, b, c, d) {
    if (null === b || 4 !== b.tag || b.stateNode.containerInfo !== c.containerInfo || b.stateNode.implementation !== c.implementation) return b = zh(c, a.mode, d), b.return = a, b;
    b = e(b, c.children || []);
    b.return = a;
    return b;
  }
  function m(a, b, c, d, f) {
    if (null === b || 7 !== b.tag) return b = Ah(c, a.mode, d, f), b.return = a, b;
    b = e(b, c);
    b.return = a;
    return b;
  }
  function q(a, b, c) {
    if ("string" === typeof b && "" !== b || "number" === typeof b) return b = xh("" + b, a.mode, c), b.return = a, b;
    if ("object" === typeof b && null !== b) {
      switch (b.$$typeof) {
        case va:
          return c = yh(b.type, b.key, b.props, null, a.mode, c), c.ref = sh(a, null, b), c.return = a, c;
        case wa:
          return b = zh(b, a.mode, c), b.return = a, b;
        case Ha:
          var d = b._init;
          return q(a, d(b._payload), c);
      }
      if (eb(b) || Ka(b)) return b = Ah(b, a.mode, c, null), b.return = a, b;
      th(a, b);
    }
    return null;
  }
  function r(a, b, c, d) {
    var e = null !== b ? b.key : null;
    if ("string" === typeof c && "" !== c || "number" === typeof c) return null !== e ? null : h(a, b, "" + c, d);
    if ("object" === typeof c && null !== c) {
      switch (c.$$typeof) {
        case va:
          return c.key === e ? k(a, b, c, d) : null;
        case wa:
          return c.key === e ? l(a, b, c, d) : null;
        case Ha:
          return e = c._init, r(a, b, e(c._payload), d);
      }
      if (eb(c) || Ka(c)) return null !== e ? null : m(a, b, c, d, null);
      th(a, c);
    }
    return null;
  }
  function y(a, b, c, d, e) {
    if ("string" === typeof d && "" !== d || "number" === typeof d) return a = a.get(c) || null, h(b, a, "" + d, e);
    if ("object" === typeof d && null !== d) {
      switch (d.$$typeof) {
        case va:
          return a = a.get(null === d.key ? c : d.key) || null, k(b, a, d, e);
        case wa:
          return a = a.get(null === d.key ? c : d.key) || null, l(b, a, d, e);
        case Ha:
          var f = d._init;
          return y(a, b, c, f(d._payload), e);
      }
      if (eb(d) || Ka(d)) return a = a.get(c) || null, m(b, a, d, e, null);
      th(b, d);
    }
    return null;
  }
  function n(e, g, h, k) {
    for (var l = null, m = null, u = g, w = g = 0, x = null; null !== u && w < h.length; w++) {
      u.index > w ? (x = u, u = null) : x = u.sibling;
      var n = r(e, u, h[w], k);
      if (null === n) {
        null === u && (u = x);
        break;
      }
      a && u && null === n.alternate && b(e, u);
      g = f(n, g, w);
      null === m ? l = n : m.sibling = n;
      m = n;
      u = x;
    }
    if (w === h.length) return c(e, u), I && tg(e, w), l;
    if (null === u) {
      for (; w < h.length; w++) u = q(e, h[w], k), null !== u && (g = f(u, g, w), null === m ? l = u : m.sibling = u, m = u);
      I && tg(e, w);
      return l;
    }
    for (u = d(e, u); w < h.length; w++) x = y(u, e, w, h[w], k), null !== x && (a && null !== x.alternate && u.delete(null === x.key ? w : x.key), g = f(x, g, w), null === m ? l = x : m.sibling = x, m = x);
    a && u.forEach(function (a) {
      return b(e, a);
    });
    I && tg(e, w);
    return l;
  }
  function t(e, g, h, k) {
    var l = Ka(h);
    if ("function" !== typeof l) throw Error(p(150));
    h = l.call(h);
    if (null == h) throw Error(p(151));
    for (var u = l = null, m = g, w = g = 0, x = null, n = h.next(); null !== m && !n.done; w++, n = h.next()) {
      m.index > w ? (x = m, m = null) : x = m.sibling;
      var t = r(e, m, n.value, k);
      if (null === t) {
        null === m && (m = x);
        break;
      }
      a && m && null === t.alternate && b(e, m);
      g = f(t, g, w);
      null === u ? l = t : u.sibling = t;
      u = t;
      m = x;
    }
    if (n.done) return c(e, m), I && tg(e, w), l;
    if (null === m) {
      for (; !n.done; w++, n = h.next()) n = q(e, n.value, k), null !== n && (g = f(n, g, w), null === u ? l = n : u.sibling = n, u = n);
      I && tg(e, w);
      return l;
    }
    for (m = d(e, m); !n.done; w++, n = h.next()) n = y(m, e, w, n.value, k), null !== n && (a && null !== n.alternate && m.delete(null === n.key ? w : n.key), g = f(n, g, w), null === u ? l = n : u.sibling = n, u = n);
    a && m.forEach(function (a) {
      return b(e, a);
    });
    I && tg(e, w);
    return l;
  }
  function J(a, d, f, h) {
    "object" === typeof f && null !== f && f.type === ya && null === f.key && (f = f.props.children);
    if ("object" === typeof f && null !== f) {
      switch (f.$$typeof) {
        case va:
          a: {
            for (var k = f.key, l = d; null !== l;) {
              if (l.key === k) {
                k = f.type;
                if (k === ya) {
                  if (7 === l.tag) {
                    c(a, l.sibling);
                    d = e(l, f.props.children);
                    d.return = a;
                    a = d;
                    break a;
                  }
                } else if (l.elementType === k || "object" === typeof k && null !== k && k.$$typeof === Ha && uh(k) === l.type) {
                  c(a, l.sibling);
                  d = e(l, f.props);
                  d.ref = sh(a, l, f);
                  d.return = a;
                  a = d;
                  break a;
                }
                c(a, l);
                break;
              } else b(a, l);
              l = l.sibling;
            }
            f.type === ya ? (d = Ah(f.props.children, a.mode, h, f.key), d.return = a, a = d) : (h = yh(f.type, f.key, f.props, null, a.mode, h), h.ref = sh(a, d, f), h.return = a, a = h);
          }
          return g(a);
        case wa:
          a: {
            for (l = f.key; null !== d;) {
              if (d.key === l) {
                if (4 === d.tag && d.stateNode.containerInfo === f.containerInfo && d.stateNode.implementation === f.implementation) {
                  c(a, d.sibling);
                  d = e(d, f.children || []);
                  d.return = a;
                  a = d;
                  break a;
                } else {
                  c(a, d);
                  break;
                }
              } else b(a, d);
              d = d.sibling;
            }
            d = zh(f, a.mode, h);
            d.return = a;
            a = d;
          }
          return g(a);
        case Ha:
          return l = f._init, J(a, d, l(f._payload), h);
      }
      if (eb(f)) return n(a, d, f, h);
      if (Ka(f)) return t(a, d, f, h);
      th(a, f);
    }
    return "string" === typeof f && "" !== f || "number" === typeof f ? (f = "" + f, null !== d && 6 === d.tag ? (c(a, d.sibling), d = e(d, f), d.return = a, a = d) : (c(a, d), d = xh(f, a.mode, h), d.return = a, a = d), g(a)) : c(a, d);
  }
  return J;
}
var Bh = vh(!0),
  Ch = vh(!1),
  Dh = {},
  Eh = Uf(Dh),
  Fh = Uf(Dh),
  Gh = Uf(Dh);
function Hh(a) {
  if (a === Dh) throw Error(p(174));
  return a;
}
function Ih(a, b) {
  G(Gh, b);
  G(Fh, a);
  G(Eh, Dh);
  a = b.nodeType;
  switch (a) {
    case 9:
    case 11:
      b = (b = b.documentElement) ? b.namespaceURI : lb(null, "");
      break;
    default:
      a = 8 === a ? b.parentNode : b, b = a.namespaceURI || null, a = a.tagName, b = lb(b, a);
  }
  E(Eh);
  G(Eh, b);
}
function Jh() {
  E(Eh);
  E(Fh);
  E(Gh);
}
function Kh(a) {
  Hh(Gh.current);
  var b = Hh(Eh.current);
  var c = lb(b, a.type);
  b !== c && (G(Fh, a), G(Eh, c));
}
function Lh(a) {
  Fh.current === a && (E(Eh), E(Fh));
}
var M = Uf(0);
function Mh(a) {
  for (var b = a; null !== b;) {
    if (13 === b.tag) {
      var c = b.memoizedState;
      if (null !== c && (c = c.dehydrated, null === c || "$?" === c.data || "$!" === c.data)) return b;
    } else if (19 === b.tag && void 0 !== b.memoizedProps.revealOrder) {
      if (0 !== (b.flags & 128)) return b;
    } else if (null !== b.child) {
      b.child.return = b;
      b = b.child;
      continue;
    }
    if (b === a) break;
    for (; null === b.sibling;) {
      if (null === b.return || b.return === a) return null;
      b = b.return;
    }
    b.sibling.return = b.return;
    b = b.sibling;
  }
  return null;
}
var Nh = [];
function Oh() {
  for (var a = 0; a < Nh.length; a++) Nh[a]._workInProgressVersionPrimary = null;
  Nh.length = 0;
}
var Ph = ua.ReactCurrentDispatcher,
  Qh = ua.ReactCurrentBatchConfig,
  Rh = 0,
  N = null,
  O = null,
  P = null,
  Sh = !1,
  Th = !1,
  Uh = 0,
  Vh = 0;
function Q() {
  throw Error(p(321));
}
function Wh(a, b) {
  if (null === b) return !1;
  for (var c = 0; c < b.length && c < a.length; c++) if (!He(a[c], b[c])) return !1;
  return !0;
}
function Xh(a, b, c, d, e, f) {
  Rh = f;
  N = b;
  b.memoizedState = null;
  b.updateQueue = null;
  b.lanes = 0;
  Ph.current = null === a || null === a.memoizedState ? Yh : Zh;
  a = c(d, e);
  if (Th) {
    f = 0;
    do {
      Th = !1;
      Uh = 0;
      if (25 <= f) throw Error(p(301));
      f += 1;
      P = O = null;
      b.updateQueue = null;
      Ph.current = $h;
      a = c(d, e);
    } while (Th);
  }
  Ph.current = ai;
  b = null !== O && null !== O.next;
  Rh = 0;
  P = O = N = null;
  Sh = !1;
  if (b) throw Error(p(300));
  return a;
}
function bi() {
  var a = 0 !== Uh;
  Uh = 0;
  return a;
}
function ci() {
  var a = {
    memoizedState: null,
    baseState: null,
    baseQueue: null,
    queue: null,
    next: null
  };
  null === P ? N.memoizedState = P = a : P = P.next = a;
  return P;
}
function di() {
  if (null === O) {
    var a = N.alternate;
    a = null !== a ? a.memoizedState : null;
  } else a = O.next;
  var b = null === P ? N.memoizedState : P.next;
  if (null !== b) P = b, O = a;else {
    if (null === a) throw Error(p(310));
    O = a;
    a = {
      memoizedState: O.memoizedState,
      baseState: O.baseState,
      baseQueue: O.baseQueue,
      queue: O.queue,
      next: null
    };
    null === P ? N.memoizedState = P = a : P = P.next = a;
  }
  return P;
}
function ei(a, b) {
  return "function" === typeof b ? b(a) : b;
}
function fi(a) {
  var b = di(),
    c = b.queue;
  if (null === c) throw Error(p(311));
  c.lastRenderedReducer = a;
  var d = O,
    e = d.baseQueue,
    f = c.pending;
  if (null !== f) {
    if (null !== e) {
      var g = e.next;
      e.next = f.next;
      f.next = g;
    }
    d.baseQueue = e = f;
    c.pending = null;
  }
  if (null !== e) {
    f = e.next;
    d = d.baseState;
    var h = g = null,
      k = null,
      l = f;
    do {
      var m = l.lane;
      if ((Rh & m) === m) null !== k && (k = k.next = {
        lane: 0,
        action: l.action,
        hasEagerState: l.hasEagerState,
        eagerState: l.eagerState,
        next: null
      }), d = l.hasEagerState ? l.eagerState : a(d, l.action);else {
        var q = {
          lane: m,
          action: l.action,
          hasEagerState: l.hasEagerState,
          eagerState: l.eagerState,
          next: null
        };
        null === k ? (h = k = q, g = d) : k = k.next = q;
        N.lanes |= m;
        hh |= m;
      }
      l = l.next;
    } while (null !== l && l !== f);
    null === k ? g = d : k.next = h;
    He(d, b.memoizedState) || (Ug = !0);
    b.memoizedState = d;
    b.baseState = g;
    b.baseQueue = k;
    c.lastRenderedState = d;
  }
  a = c.interleaved;
  if (null !== a) {
    e = a;
    do f = e.lane, N.lanes |= f, hh |= f, e = e.next; while (e !== a);
  } else null === e && (c.lanes = 0);
  return [b.memoizedState, c.dispatch];
}
function gi(a) {
  var b = di(),
    c = b.queue;
  if (null === c) throw Error(p(311));
  c.lastRenderedReducer = a;
  var d = c.dispatch,
    e = c.pending,
    f = b.memoizedState;
  if (null !== e) {
    c.pending = null;
    var g = e = e.next;
    do f = a(f, g.action), g = g.next; while (g !== e);
    He(f, b.memoizedState) || (Ug = !0);
    b.memoizedState = f;
    null === b.baseQueue && (b.baseState = f);
    c.lastRenderedState = f;
  }
  return [f, d];
}
function hi() {}
function ii(a, b) {
  var c = N,
    d = di(),
    e = b(),
    f = !He(d.memoizedState, e);
  f && (d.memoizedState = e, Ug = !0);
  d = d.queue;
  ji(ki.bind(null, c, d, a), [a]);
  if (d.getSnapshot !== b || f || null !== P && P.memoizedState.tag & 1) {
    c.flags |= 2048;
    li(9, mi.bind(null, c, d, e, b), void 0, null);
    if (null === R) throw Error(p(349));
    0 !== (Rh & 30) || ni(c, b, e);
  }
  return e;
}
function ni(a, b, c) {
  a.flags |= 16384;
  a = {
    getSnapshot: b,
    value: c
  };
  b = N.updateQueue;
  null === b ? (b = {
    lastEffect: null,
    stores: null
  }, N.updateQueue = b, b.stores = [a]) : (c = b.stores, null === c ? b.stores = [a] : c.push(a));
}
function mi(a, b, c, d) {
  b.value = c;
  b.getSnapshot = d;
  oi(b) && pi(a);
}
function ki(a, b, c) {
  return c(function () {
    oi(b) && pi(a);
  });
}
function oi(a) {
  var b = a.getSnapshot;
  a = a.value;
  try {
    var c = b();
    return !He(a, c);
  } catch (d) {
    return !0;
  }
}
function pi(a) {
  var b = Zg(a, 1);
  null !== b && mh(b, a, 1, -1);
}
function qi(a) {
  var b = ci();
  "function" === typeof a && (a = a());
  b.memoizedState = b.baseState = a;
  a = {
    pending: null,
    interleaved: null,
    lanes: 0,
    dispatch: null,
    lastRenderedReducer: ei,
    lastRenderedState: a
  };
  b.queue = a;
  a = a.dispatch = ri.bind(null, N, a);
  return [b.memoizedState, a];
}
function li(a, b, c, d) {
  a = {
    tag: a,
    create: b,
    destroy: c,
    deps: d,
    next: null
  };
  b = N.updateQueue;
  null === b ? (b = {
    lastEffect: null,
    stores: null
  }, N.updateQueue = b, b.lastEffect = a.next = a) : (c = b.lastEffect, null === c ? b.lastEffect = a.next = a : (d = c.next, c.next = a, a.next = d, b.lastEffect = a));
  return a;
}
function si() {
  return di().memoizedState;
}
function ti(a, b, c, d) {
  var e = ci();
  N.flags |= a;
  e.memoizedState = li(1 | b, c, void 0, void 0 === d ? null : d);
}
function ui(a, b, c, d) {
  var e = di();
  d = void 0 === d ? null : d;
  var f = void 0;
  if (null !== O) {
    var g = O.memoizedState;
    f = g.destroy;
    if (null !== d && Wh(d, g.deps)) {
      e.memoizedState = li(b, c, f, d);
      return;
    }
  }
  N.flags |= a;
  e.memoizedState = li(1 | b, c, f, d);
}
function vi(a, b) {
  return ti(8390656, 8, a, b);
}
function ji(a, b) {
  return ui(2048, 8, a, b);
}
function wi(a, b) {
  return ui(4, 2, a, b);
}
function xi(a, b) {
  return ui(4, 4, a, b);
}
function yi(a, b) {
  if ("function" === typeof b) return a = a(), b(a), function () {
    b(null);
  };
  if (null !== b && void 0 !== b) return a = a(), b.current = a, function () {
    b.current = null;
  };
}
function zi(a, b, c) {
  c = null !== c && void 0 !== c ? c.concat([a]) : null;
  return ui(4, 4, yi.bind(null, b, a), c);
}
function Ai() {}
function Bi(a, b) {
  var c = di();
  b = void 0 === b ? null : b;
  var d = c.memoizedState;
  if (null !== d && null !== b && Wh(b, d[1])) return d[0];
  c.memoizedState = [a, b];
  return a;
}
function Ci(a, b) {
  var c = di();
  b = void 0 === b ? null : b;
  var d = c.memoizedState;
  if (null !== d && null !== b && Wh(b, d[1])) return d[0];
  a = a();
  c.memoizedState = [a, b];
  return a;
}
function Di(a, b, c) {
  if (0 === (Rh & 21)) return a.baseState && (a.baseState = !1, Ug = !0), a.memoizedState = c;
  He(c, b) || (c = yc(), N.lanes |= c, hh |= c, a.baseState = !0);
  return b;
}
function Ei(a, b) {
  var c = C;
  C = 0 !== c && 4 > c ? c : 4;
  a(!0);
  var d = Qh.transition;
  Qh.transition = {};
  try {
    a(!1), b();
  } finally {
    C = c, Qh.transition = d;
  }
}
function Fi() {
  return di().memoizedState;
}
function Gi(a, b, c) {
  var d = lh(a);
  c = {
    lane: d,
    action: c,
    hasEagerState: !1,
    eagerState: null,
    next: null
  };
  if (Hi(a)) Ii(b, c);else if (c = Yg(a, b, c, d), null !== c) {
    var e = L();
    mh(c, a, d, e);
    Ji(c, b, d);
  }
}
function ri(a, b, c) {
  var d = lh(a),
    e = {
      lane: d,
      action: c,
      hasEagerState: !1,
      eagerState: null,
      next: null
    };
  if (Hi(a)) Ii(b, e);else {
    var f = a.alternate;
    if (0 === a.lanes && (null === f || 0 === f.lanes) && (f = b.lastRenderedReducer, null !== f)) try {
      var g = b.lastRenderedState,
        h = f(g, c);
      e.hasEagerState = !0;
      e.eagerState = h;
      if (He(h, g)) {
        var k = b.interleaved;
        null === k ? (e.next = e, Xg(b)) : (e.next = k.next, k.next = e);
        b.interleaved = e;
        return;
      }
    } catch (l) {} finally {}
    c = Yg(a, b, e, d);
    null !== c && (e = L(), mh(c, a, d, e), Ji(c, b, d));
  }
}
function Hi(a) {
  var b = a.alternate;
  return a === N || null !== b && b === N;
}
function Ii(a, b) {
  Th = Sh = !0;
  var c = a.pending;
  null === c ? b.next = b : (b.next = c.next, c.next = b);
  a.pending = b;
}
function Ji(a, b, c) {
  if (0 !== (c & 4194240)) {
    var d = b.lanes;
    d &= a.pendingLanes;
    c |= d;
    b.lanes = c;
    Cc(a, c);
  }
}
var ai = {
    readContext: Vg,
    useCallback: Q,
    useContext: Q,
    useEffect: Q,
    useImperativeHandle: Q,
    useInsertionEffect: Q,
    useLayoutEffect: Q,
    useMemo: Q,
    useReducer: Q,
    useRef: Q,
    useState: Q,
    useDebugValue: Q,
    useDeferredValue: Q,
    useTransition: Q,
    useMutableSource: Q,
    useSyncExternalStore: Q,
    useId: Q,
    unstable_isNewReconciler: !1
  },
  Yh = {
    readContext: Vg,
    useCallback: function useCallback(a, b) {
      ci().memoizedState = [a, void 0 === b ? null : b];
      return a;
    },
    useContext: Vg,
    useEffect: vi,
    useImperativeHandle: function useImperativeHandle(a, b, c) {
      c = null !== c && void 0 !== c ? c.concat([a]) : null;
      return ti(4194308, 4, yi.bind(null, b, a), c);
    },
    useLayoutEffect: function useLayoutEffect(a, b) {
      return ti(4194308, 4, a, b);
    },
    useInsertionEffect: function useInsertionEffect(a, b) {
      return ti(4, 2, a, b);
    },
    useMemo: function useMemo(a, b) {
      var c = ci();
      b = void 0 === b ? null : b;
      a = a();
      c.memoizedState = [a, b];
      return a;
    },
    useReducer: function useReducer(a, b, c) {
      var d = ci();
      b = void 0 !== c ? c(b) : b;
      d.memoizedState = d.baseState = b;
      a = {
        pending: null,
        interleaved: null,
        lanes: 0,
        dispatch: null,
        lastRenderedReducer: a,
        lastRenderedState: b
      };
      d.queue = a;
      a = a.dispatch = Gi.bind(null, N, a);
      return [d.memoizedState, a];
    },
    useRef: function useRef(a) {
      var b = ci();
      a = {
        current: a
      };
      return b.memoizedState = a;
    },
    useState: qi,
    useDebugValue: Ai,
    useDeferredValue: function useDeferredValue(a) {
      return ci().memoizedState = a;
    },
    useTransition: function useTransition() {
      var a = qi(!1),
        b = a[0];
      a = Ei.bind(null, a[1]);
      ci().memoizedState = a;
      return [b, a];
    },
    useMutableSource: function useMutableSource() {},
    useSyncExternalStore: function useSyncExternalStore(a, b, c) {
      var d = N,
        e = ci();
      if (I) {
        if (void 0 === c) throw Error(p(407));
        c = c();
      } else {
        c = b();
        if (null === R) throw Error(p(349));
        0 !== (Rh & 30) || ni(d, b, c);
      }
      e.memoizedState = c;
      var f = {
        value: c,
        getSnapshot: b
      };
      e.queue = f;
      vi(ki.bind(null, d, f, a), [a]);
      d.flags |= 2048;
      li(9, mi.bind(null, d, f, c, b), void 0, null);
      return c;
    },
    useId: function useId() {
      var a = ci(),
        b = R.identifierPrefix;
      if (I) {
        var c = sg;
        var d = rg;
        c = (d & ~(1 << 32 - oc(d) - 1)).toString(32) + c;
        b = ":" + b + "R" + c;
        c = Uh++;
        0 < c && (b += "H" + c.toString(32));
        b += ":";
      } else c = Vh++, b = ":" + b + "r" + c.toString(32) + ":";
      return a.memoizedState = b;
    },
    unstable_isNewReconciler: !1
  },
  Zh = {
    readContext: Vg,
    useCallback: Bi,
    useContext: Vg,
    useEffect: ji,
    useImperativeHandle: zi,
    useInsertionEffect: wi,
    useLayoutEffect: xi,
    useMemo: Ci,
    useReducer: fi,
    useRef: si,
    useState: function useState() {
      return fi(ei);
    },
    useDebugValue: Ai,
    useDeferredValue: function useDeferredValue(a) {
      var b = di();
      return Di(b, O.memoizedState, a);
    },
    useTransition: function useTransition() {
      var a = fi(ei)[0],
        b = di().memoizedState;
      return [a, b];
    },
    useMutableSource: hi,
    useSyncExternalStore: ii,
    useId: Fi,
    unstable_isNewReconciler: !1
  },
  $h = {
    readContext: Vg,
    useCallback: Bi,
    useContext: Vg,
    useEffect: ji,
    useImperativeHandle: zi,
    useInsertionEffect: wi,
    useLayoutEffect: xi,
    useMemo: Ci,
    useReducer: gi,
    useRef: si,
    useState: function useState() {
      return gi(ei);
    },
    useDebugValue: Ai,
    useDeferredValue: function useDeferredValue(a) {
      var b = di();
      return null === O ? b.memoizedState = a : Di(b, O.memoizedState, a);
    },
    useTransition: function useTransition() {
      var a = gi(ei)[0],
        b = di().memoizedState;
      return [a, b];
    },
    useMutableSource: hi,
    useSyncExternalStore: ii,
    useId: Fi,
    unstable_isNewReconciler: !1
  };
function Ki(a, b) {
  try {
    var c = "",
      d = b;
    do c += Pa(d), d = d.return; while (d);
    var e = c;
  } catch (f) {
    e = "\nError generating stack: " + f.message + "\n" + f.stack;
  }
  return {
    value: a,
    source: b,
    stack: e,
    digest: null
  };
}
function Li(a, b, c) {
  return {
    value: a,
    source: null,
    stack: null != c ? c : null,
    digest: null != b ? b : null
  };
}
function Mi(a, b) {
  try {
    console.error(b.value);
  } catch (c) {
    setTimeout(function () {
      throw c;
    });
  }
}
var Ni = "function" === typeof WeakMap ? WeakMap : Map;
function Oi(a, b, c) {
  c = ch(-1, c);
  c.tag = 3;
  c.payload = {
    element: null
  };
  var d = b.value;
  c.callback = function () {
    Pi || (Pi = !0, Qi = d);
    Mi(a, b);
  };
  return c;
}
function Ri(a, b, c) {
  c = ch(-1, c);
  c.tag = 3;
  var d = a.type.getDerivedStateFromError;
  if ("function" === typeof d) {
    var e = b.value;
    c.payload = function () {
      return d(e);
    };
    c.callback = function () {
      Mi(a, b);
    };
  }
  var f = a.stateNode;
  null !== f && "function" === typeof f.componentDidCatch && (c.callback = function () {
    Mi(a, b);
    "function" !== typeof d && (null === Si ? Si = new Set([this]) : Si.add(this));
    var c = b.stack;
    this.componentDidCatch(b.value, {
      componentStack: null !== c ? c : ""
    });
  });
  return c;
}
function Ti(a, b, c) {
  var d = a.pingCache;
  if (null === d) {
    d = a.pingCache = new Ni();
    var e = new Set();
    d.set(b, e);
  } else e = d.get(b), void 0 === e && (e = new Set(), d.set(b, e));
  e.has(c) || (e.add(c), a = Ui.bind(null, a, b, c), b.then(a, a));
}
function Vi(a) {
  do {
    var b;
    if (b = 13 === a.tag) b = a.memoizedState, b = null !== b ? null !== b.dehydrated ? !0 : !1 : !0;
    if (b) return a;
    a = a.return;
  } while (null !== a);
  return null;
}
function Wi(a, b, c, d, e) {
  if (0 === (a.mode & 1)) return a === b ? a.flags |= 65536 : (a.flags |= 128, c.flags |= 131072, c.flags &= -52805, 1 === c.tag && (null === c.alternate ? c.tag = 17 : (b = ch(-1, 1), b.tag = 2, dh(c, b, 1))), c.lanes |= 1), a;
  a.flags |= 65536;
  a.lanes = e;
  return a;
}
var Xi = ua.ReactCurrentOwner,
  Ug = !1;
function Yi(a, b, c, d) {
  b.child = null === a ? Ch(b, null, c, d) : Bh(b, a.child, c, d);
}
function Zi(a, b, c, d, e) {
  c = c.render;
  var f = b.ref;
  Tg(b, e);
  d = Xh(a, b, c, d, f, e);
  c = bi();
  if (null !== a && !Ug) return b.updateQueue = a.updateQueue, b.flags &= -2053, a.lanes &= ~e, $i(a, b, e);
  I && c && vg(b);
  b.flags |= 1;
  Yi(a, b, d, e);
  return b.child;
}
function aj(a, b, c, d, e) {
  if (null === a) {
    var f = c.type;
    if ("function" === typeof f && !bj(f) && void 0 === f.defaultProps && null === c.compare && void 0 === c.defaultProps) return b.tag = 15, b.type = f, cj(a, b, f, d, e);
    a = yh(c.type, null, d, b, b.mode, e);
    a.ref = b.ref;
    a.return = b;
    return b.child = a;
  }
  f = a.child;
  if (0 === (a.lanes & e)) {
    var g = f.memoizedProps;
    c = c.compare;
    c = null !== c ? c : Ie;
    if (c(g, d) && a.ref === b.ref) return $i(a, b, e);
  }
  b.flags |= 1;
  a = wh(f, d);
  a.ref = b.ref;
  a.return = b;
  return b.child = a;
}
function cj(a, b, c, d, e) {
  if (null !== a) {
    var f = a.memoizedProps;
    if (Ie(f, d) && a.ref === b.ref) if (Ug = !1, b.pendingProps = d = f, 0 !== (a.lanes & e)) 0 !== (a.flags & 131072) && (Ug = !0);else return b.lanes = a.lanes, $i(a, b, e);
  }
  return dj(a, b, c, d, e);
}
function ej(a, b, c) {
  var d = b.pendingProps,
    e = d.children,
    f = null !== a ? a.memoizedState : null;
  if ("hidden" === d.mode) {
    if (0 === (b.mode & 1)) b.memoizedState = {
      baseLanes: 0,
      cachePool: null,
      transitions: null
    }, G(fj, gj), gj |= c;else {
      if (0 === (c & 1073741824)) return a = null !== f ? f.baseLanes | c : c, b.lanes = b.childLanes = 1073741824, b.memoizedState = {
        baseLanes: a,
        cachePool: null,
        transitions: null
      }, b.updateQueue = null, G(fj, gj), gj |= a, null;
      b.memoizedState = {
        baseLanes: 0,
        cachePool: null,
        transitions: null
      };
      d = null !== f ? f.baseLanes : c;
      G(fj, gj);
      gj |= d;
    }
  } else null !== f ? (d = f.baseLanes | c, b.memoizedState = null) : d = c, G(fj, gj), gj |= d;
  Yi(a, b, e, c);
  return b.child;
}
function hj(a, b) {
  var c = b.ref;
  if (null === a && null !== c || null !== a && a.ref !== c) b.flags |= 512, b.flags |= 2097152;
}
function dj(a, b, c, d, e) {
  var f = Zf(c) ? Xf : H.current;
  f = Yf(b, f);
  Tg(b, e);
  c = Xh(a, b, c, d, f, e);
  d = bi();
  if (null !== a && !Ug) return b.updateQueue = a.updateQueue, b.flags &= -2053, a.lanes &= ~e, $i(a, b, e);
  I && d && vg(b);
  b.flags |= 1;
  Yi(a, b, c, e);
  return b.child;
}
function ij(a, b, c, d, e) {
  if (Zf(c)) {
    var f = !0;
    cg(b);
  } else f = !1;
  Tg(b, e);
  if (null === b.stateNode) jj(a, b), ph(b, c, d), rh(b, c, d, e), d = !0;else if (null === a) {
    var g = b.stateNode,
      h = b.memoizedProps;
    g.props = h;
    var k = g.context,
      l = c.contextType;
    "object" === typeof l && null !== l ? l = Vg(l) : (l = Zf(c) ? Xf : H.current, l = Yf(b, l));
    var m = c.getDerivedStateFromProps,
      q = "function" === typeof m || "function" === typeof g.getSnapshotBeforeUpdate;
    q || "function" !== typeof g.UNSAFE_componentWillReceiveProps && "function" !== typeof g.componentWillReceiveProps || (h !== d || k !== l) && qh(b, g, d, l);
    $g = !1;
    var r = b.memoizedState;
    g.state = r;
    gh(b, d, g, e);
    k = b.memoizedState;
    h !== d || r !== k || Wf.current || $g ? ("function" === typeof m && (kh(b, c, m, d), k = b.memoizedState), (h = $g || oh(b, c, h, d, r, k, l)) ? (q || "function" !== typeof g.UNSAFE_componentWillMount && "function" !== typeof g.componentWillMount || ("function" === typeof g.componentWillMount && g.componentWillMount(), "function" === typeof g.UNSAFE_componentWillMount && g.UNSAFE_componentWillMount()), "function" === typeof g.componentDidMount && (b.flags |= 4194308)) : ("function" === typeof g.componentDidMount && (b.flags |= 4194308), b.memoizedProps = d, b.memoizedState = k), g.props = d, g.state = k, g.context = l, d = h) : ("function" === typeof g.componentDidMount && (b.flags |= 4194308), d = !1);
  } else {
    g = b.stateNode;
    bh(a, b);
    h = b.memoizedProps;
    l = b.type === b.elementType ? h : Lg(b.type, h);
    g.props = l;
    q = b.pendingProps;
    r = g.context;
    k = c.contextType;
    "object" === typeof k && null !== k ? k = Vg(k) : (k = Zf(c) ? Xf : H.current, k = Yf(b, k));
    var y = c.getDerivedStateFromProps;
    (m = "function" === typeof y || "function" === typeof g.getSnapshotBeforeUpdate) || "function" !== typeof g.UNSAFE_componentWillReceiveProps && "function" !== typeof g.componentWillReceiveProps || (h !== q || r !== k) && qh(b, g, d, k);
    $g = !1;
    r = b.memoizedState;
    g.state = r;
    gh(b, d, g, e);
    var n = b.memoizedState;
    h !== q || r !== n || Wf.current || $g ? ("function" === typeof y && (kh(b, c, y, d), n = b.memoizedState), (l = $g || oh(b, c, l, d, r, n, k) || !1) ? (m || "function" !== typeof g.UNSAFE_componentWillUpdate && "function" !== typeof g.componentWillUpdate || ("function" === typeof g.componentWillUpdate && g.componentWillUpdate(d, n, k), "function" === typeof g.UNSAFE_componentWillUpdate && g.UNSAFE_componentWillUpdate(d, n, k)), "function" === typeof g.componentDidUpdate && (b.flags |= 4), "function" === typeof g.getSnapshotBeforeUpdate && (b.flags |= 1024)) : ("function" !== typeof g.componentDidUpdate || h === a.memoizedProps && r === a.memoizedState || (b.flags |= 4), "function" !== typeof g.getSnapshotBeforeUpdate || h === a.memoizedProps && r === a.memoizedState || (b.flags |= 1024), b.memoizedProps = d, b.memoizedState = n), g.props = d, g.state = n, g.context = k, d = l) : ("function" !== typeof g.componentDidUpdate || h === a.memoizedProps && r === a.memoizedState || (b.flags |= 4), "function" !== typeof g.getSnapshotBeforeUpdate || h === a.memoizedProps && r === a.memoizedState || (b.flags |= 1024), d = !1);
  }
  return kj(a, b, c, d, f, e);
}
function kj(a, b, c, d, e, f) {
  hj(a, b);
  var g = 0 !== (b.flags & 128);
  if (!d && !g) return e && dg(b, c, !1), $i(a, b, f);
  d = b.stateNode;
  Xi.current = b;
  var h = g && "function" !== typeof c.getDerivedStateFromError ? null : d.render();
  b.flags |= 1;
  null !== a && g ? (b.child = Bh(b, a.child, null, f), b.child = Bh(b, null, h, f)) : Yi(a, b, h, f);
  b.memoizedState = d.state;
  e && dg(b, c, !0);
  return b.child;
}
function lj(a) {
  var b = a.stateNode;
  b.pendingContext ? ag(a, b.pendingContext, b.pendingContext !== b.context) : b.context && ag(a, b.context, !1);
  Ih(a, b.containerInfo);
}
function mj(a, b, c, d, e) {
  Ig();
  Jg(e);
  b.flags |= 256;
  Yi(a, b, c, d);
  return b.child;
}
var nj = {
  dehydrated: null,
  treeContext: null,
  retryLane: 0
};
function oj(a) {
  return {
    baseLanes: a,
    cachePool: null,
    transitions: null
  };
}
function pj(a, b, c) {
  var d = b.pendingProps,
    e = M.current,
    f = !1,
    g = 0 !== (b.flags & 128),
    h;
  (h = g) || (h = null !== a && null === a.memoizedState ? !1 : 0 !== (e & 2));
  if (h) f = !0, b.flags &= -129;else if (null === a || null !== a.memoizedState) e |= 1;
  G(M, e & 1);
  if (null === a) {
    Eg(b);
    a = b.memoizedState;
    if (null !== a && (a = a.dehydrated, null !== a)) return 0 === (b.mode & 1) ? b.lanes = 1 : "$!" === a.data ? b.lanes = 8 : b.lanes = 1073741824, null;
    g = d.children;
    a = d.fallback;
    return f ? (d = b.mode, f = b.child, g = {
      mode: "hidden",
      children: g
    }, 0 === (d & 1) && null !== f ? (f.childLanes = 0, f.pendingProps = g) : f = qj(g, d, 0, null), a = Ah(a, d, c, null), f.return = b, a.return = b, f.sibling = a, b.child = f, b.child.memoizedState = oj(c), b.memoizedState = nj, a) : rj(b, g);
  }
  e = a.memoizedState;
  if (null !== e && (h = e.dehydrated, null !== h)) return sj(a, b, g, d, h, e, c);
  if (f) {
    f = d.fallback;
    g = b.mode;
    e = a.child;
    h = e.sibling;
    var k = {
      mode: "hidden",
      children: d.children
    };
    0 === (g & 1) && b.child !== e ? (d = b.child, d.childLanes = 0, d.pendingProps = k, b.deletions = null) : (d = wh(e, k), d.subtreeFlags = e.subtreeFlags & 14680064);
    null !== h ? f = wh(h, f) : (f = Ah(f, g, c, null), f.flags |= 2);
    f.return = b;
    d.return = b;
    d.sibling = f;
    b.child = d;
    d = f;
    f = b.child;
    g = a.child.memoizedState;
    g = null === g ? oj(c) : {
      baseLanes: g.baseLanes | c,
      cachePool: null,
      transitions: g.transitions
    };
    f.memoizedState = g;
    f.childLanes = a.childLanes & ~c;
    b.memoizedState = nj;
    return d;
  }
  f = a.child;
  a = f.sibling;
  d = wh(f, {
    mode: "visible",
    children: d.children
  });
  0 === (b.mode & 1) && (d.lanes = c);
  d.return = b;
  d.sibling = null;
  null !== a && (c = b.deletions, null === c ? (b.deletions = [a], b.flags |= 16) : c.push(a));
  b.child = d;
  b.memoizedState = null;
  return d;
}
function rj(a, b) {
  b = qj({
    mode: "visible",
    children: b
  }, a.mode, 0, null);
  b.return = a;
  return a.child = b;
}
function tj(a, b, c, d) {
  null !== d && Jg(d);
  Bh(b, a.child, null, c);
  a = rj(b, b.pendingProps.children);
  a.flags |= 2;
  b.memoizedState = null;
  return a;
}
function sj(a, b, c, d, e, f, g) {
  if (c) {
    if (b.flags & 256) return b.flags &= -257, d = Li(Error(p(422))), tj(a, b, g, d);
    if (null !== b.memoizedState) return b.child = a.child, b.flags |= 128, null;
    f = d.fallback;
    e = b.mode;
    d = qj({
      mode: "visible",
      children: d.children
    }, e, 0, null);
    f = Ah(f, e, g, null);
    f.flags |= 2;
    d.return = b;
    f.return = b;
    d.sibling = f;
    b.child = d;
    0 !== (b.mode & 1) && Bh(b, a.child, null, g);
    b.child.memoizedState = oj(g);
    b.memoizedState = nj;
    return f;
  }
  if (0 === (b.mode & 1)) return tj(a, b, g, null);
  if ("$!" === e.data) {
    d = e.nextSibling && e.nextSibling.dataset;
    if (d) var h = d.dgst;
    d = h;
    f = Error(p(419));
    d = Li(f, d, void 0);
    return tj(a, b, g, d);
  }
  h = 0 !== (g & a.childLanes);
  if (Ug || h) {
    d = R;
    if (null !== d) {
      switch (g & -g) {
        case 4:
          e = 2;
          break;
        case 16:
          e = 8;
          break;
        case 64:
        case 128:
        case 256:
        case 512:
        case 1024:
        case 2048:
        case 4096:
        case 8192:
        case 16384:
        case 32768:
        case 65536:
        case 131072:
        case 262144:
        case 524288:
        case 1048576:
        case 2097152:
        case 4194304:
        case 8388608:
        case 16777216:
        case 33554432:
        case 67108864:
          e = 32;
          break;
        case 536870912:
          e = 268435456;
          break;
        default:
          e = 0;
      }
      e = 0 !== (e & (d.suspendedLanes | g)) ? 0 : e;
      0 !== e && e !== f.retryLane && (f.retryLane = e, Zg(a, e), mh(d, a, e, -1));
    }
    uj();
    d = Li(Error(p(421)));
    return tj(a, b, g, d);
  }
  if ("$?" === e.data) return b.flags |= 128, b.child = a.child, b = vj.bind(null, a), e._reactRetry = b, null;
  a = f.treeContext;
  yg = Lf(e.nextSibling);
  xg = b;
  I = !0;
  zg = null;
  null !== a && (og[pg++] = rg, og[pg++] = sg, og[pg++] = qg, rg = a.id, sg = a.overflow, qg = b);
  b = rj(b, d.children);
  b.flags |= 4096;
  return b;
}
function wj(a, b, c) {
  a.lanes |= b;
  var d = a.alternate;
  null !== d && (d.lanes |= b);
  Sg(a.return, b, c);
}
function xj(a, b, c, d, e) {
  var f = a.memoizedState;
  null === f ? a.memoizedState = {
    isBackwards: b,
    rendering: null,
    renderingStartTime: 0,
    last: d,
    tail: c,
    tailMode: e
  } : (f.isBackwards = b, f.rendering = null, f.renderingStartTime = 0, f.last = d, f.tail = c, f.tailMode = e);
}
function yj(a, b, c) {
  var d = b.pendingProps,
    e = d.revealOrder,
    f = d.tail;
  Yi(a, b, d.children, c);
  d = M.current;
  if (0 !== (d & 2)) d = d & 1 | 2, b.flags |= 128;else {
    if (null !== a && 0 !== (a.flags & 128)) a: for (a = b.child; null !== a;) {
      if (13 === a.tag) null !== a.memoizedState && wj(a, c, b);else if (19 === a.tag) wj(a, c, b);else if (null !== a.child) {
        a.child.return = a;
        a = a.child;
        continue;
      }
      if (a === b) break a;
      for (; null === a.sibling;) {
        if (null === a.return || a.return === b) break a;
        a = a.return;
      }
      a.sibling.return = a.return;
      a = a.sibling;
    }
    d &= 1;
  }
  G(M, d);
  if (0 === (b.mode & 1)) b.memoizedState = null;else switch (e) {
    case "forwards":
      c = b.child;
      for (e = null; null !== c;) a = c.alternate, null !== a && null === Mh(a) && (e = c), c = c.sibling;
      c = e;
      null === c ? (e = b.child, b.child = null) : (e = c.sibling, c.sibling = null);
      xj(b, !1, e, c, f);
      break;
    case "backwards":
      c = null;
      e = b.child;
      for (b.child = null; null !== e;) {
        a = e.alternate;
        if (null !== a && null === Mh(a)) {
          b.child = e;
          break;
        }
        a = e.sibling;
        e.sibling = c;
        c = e;
        e = a;
      }
      xj(b, !0, c, null, f);
      break;
    case "together":
      xj(b, !1, null, null, void 0);
      break;
    default:
      b.memoizedState = null;
  }
  return b.child;
}
function jj(a, b) {
  0 === (b.mode & 1) && null !== a && (a.alternate = null, b.alternate = null, b.flags |= 2);
}
function $i(a, b, c) {
  null !== a && (b.dependencies = a.dependencies);
  hh |= b.lanes;
  if (0 === (c & b.childLanes)) return null;
  if (null !== a && b.child !== a.child) throw Error(p(153));
  if (null !== b.child) {
    a = b.child;
    c = wh(a, a.pendingProps);
    b.child = c;
    for (c.return = b; null !== a.sibling;) a = a.sibling, c = c.sibling = wh(a, a.pendingProps), c.return = b;
    c.sibling = null;
  }
  return b.child;
}
function zj(a, b, c) {
  switch (b.tag) {
    case 3:
      lj(b);
      Ig();
      break;
    case 5:
      Kh(b);
      break;
    case 1:
      Zf(b.type) && cg(b);
      break;
    case 4:
      Ih(b, b.stateNode.containerInfo);
      break;
    case 10:
      var d = b.type._context,
        e = b.memoizedProps.value;
      G(Mg, d._currentValue);
      d._currentValue = e;
      break;
    case 13:
      d = b.memoizedState;
      if (null !== d) {
        if (null !== d.dehydrated) return G(M, M.current & 1), b.flags |= 128, null;
        if (0 !== (c & b.child.childLanes)) return pj(a, b, c);
        G(M, M.current & 1);
        a = $i(a, b, c);
        return null !== a ? a.sibling : null;
      }
      G(M, M.current & 1);
      break;
    case 19:
      d = 0 !== (c & b.childLanes);
      if (0 !== (a.flags & 128)) {
        if (d) return yj(a, b, c);
        b.flags |= 128;
      }
      e = b.memoizedState;
      null !== e && (e.rendering = null, e.tail = null, e.lastEffect = null);
      G(M, M.current);
      if (d) break;else return null;
    case 22:
    case 23:
      return b.lanes = 0, ej(a, b, c);
  }
  return $i(a, b, c);
}
var Aj, Bj, Cj, Dj;
Aj = function Aj(a, b) {
  for (var c = b.child; null !== c;) {
    if (5 === c.tag || 6 === c.tag) a.appendChild(c.stateNode);else if (4 !== c.tag && null !== c.child) {
      c.child.return = c;
      c = c.child;
      continue;
    }
    if (c === b) break;
    for (; null === c.sibling;) {
      if (null === c.return || c.return === b) return;
      c = c.return;
    }
    c.sibling.return = c.return;
    c = c.sibling;
  }
};
Bj = function Bj() {};
Cj = function Cj(a, b, c, d) {
  var e = a.memoizedProps;
  if (e !== d) {
    a = b.stateNode;
    Hh(Eh.current);
    var f = null;
    switch (c) {
      case "input":
        e = Ya(a, e);
        d = Ya(a, d);
        f = [];
        break;
      case "select":
        e = A({}, e, {
          value: void 0
        });
        d = A({}, d, {
          value: void 0
        });
        f = [];
        break;
      case "textarea":
        e = gb(a, e);
        d = gb(a, d);
        f = [];
        break;
      default:
        "function" !== typeof e.onClick && "function" === typeof d.onClick && (a.onclick = Bf);
    }
    ub(c, d);
    var g;
    c = null;
    for (l in e) if (!d.hasOwnProperty(l) && e.hasOwnProperty(l) && null != e[l]) if ("style" === l) {
      var h = e[l];
      for (g in h) h.hasOwnProperty(g) && (c || (c = {}), c[g] = "");
    } else "dangerouslySetInnerHTML" !== l && "children" !== l && "suppressContentEditableWarning" !== l && "suppressHydrationWarning" !== l && "autoFocus" !== l && (ea.hasOwnProperty(l) ? f || (f = []) : (f = f || []).push(l, null));
    for (l in d) {
      var k = d[l];
      h = null != e ? e[l] : void 0;
      if (d.hasOwnProperty(l) && k !== h && (null != k || null != h)) if ("style" === l) {
        if (h) {
          for (g in h) !h.hasOwnProperty(g) || k && k.hasOwnProperty(g) || (c || (c = {}), c[g] = "");
          for (g in k) k.hasOwnProperty(g) && h[g] !== k[g] && (c || (c = {}), c[g] = k[g]);
        } else c || (f || (f = []), f.push(l, c)), c = k;
      } else "dangerouslySetInnerHTML" === l ? (k = k ? k.__html : void 0, h = h ? h.__html : void 0, null != k && h !== k && (f = f || []).push(l, k)) : "children" === l ? "string" !== typeof k && "number" !== typeof k || (f = f || []).push(l, "" + k) : "suppressContentEditableWarning" !== l && "suppressHydrationWarning" !== l && (ea.hasOwnProperty(l) ? (null != k && "onScroll" === l && D("scroll", a), f || h === k || (f = [])) : (f = f || []).push(l, k));
    }
    c && (f = f || []).push("style", c);
    var l = f;
    if (b.updateQueue = l) b.flags |= 4;
  }
};
Dj = function Dj(a, b, c, d) {
  c !== d && (b.flags |= 4);
};
function Ej(a, b) {
  if (!I) switch (a.tailMode) {
    case "hidden":
      b = a.tail;
      for (var c = null; null !== b;) null !== b.alternate && (c = b), b = b.sibling;
      null === c ? a.tail = null : c.sibling = null;
      break;
    case "collapsed":
      c = a.tail;
      for (var d = null; null !== c;) null !== c.alternate && (d = c), c = c.sibling;
      null === d ? b || null === a.tail ? a.tail = null : a.tail.sibling = null : d.sibling = null;
  }
}
function S(a) {
  var b = null !== a.alternate && a.alternate.child === a.child,
    c = 0,
    d = 0;
  if (b) for (var e = a.child; null !== e;) c |= e.lanes | e.childLanes, d |= e.subtreeFlags & 14680064, d |= e.flags & 14680064, e.return = a, e = e.sibling;else for (e = a.child; null !== e;) c |= e.lanes | e.childLanes, d |= e.subtreeFlags, d |= e.flags, e.return = a, e = e.sibling;
  a.subtreeFlags |= d;
  a.childLanes = c;
  return b;
}
function Fj(a, b, c) {
  var d = b.pendingProps;
  wg(b);
  switch (b.tag) {
    case 2:
    case 16:
    case 15:
    case 0:
    case 11:
    case 7:
    case 8:
    case 12:
    case 9:
    case 14:
      return S(b), null;
    case 1:
      return Zf(b.type) && $f(), S(b), null;
    case 3:
      d = b.stateNode;
      Jh();
      E(Wf);
      E(H);
      Oh();
      d.pendingContext && (d.context = d.pendingContext, d.pendingContext = null);
      if (null === a || null === a.child) Gg(b) ? b.flags |= 4 : null === a || a.memoizedState.isDehydrated && 0 === (b.flags & 256) || (b.flags |= 1024, null !== zg && (Gj(zg), zg = null));
      Bj(a, b);
      S(b);
      return null;
    case 5:
      Lh(b);
      var e = Hh(Gh.current);
      c = b.type;
      if (null !== a && null != b.stateNode) Cj(a, b, c, d, e), a.ref !== b.ref && (b.flags |= 512, b.flags |= 2097152);else {
        if (!d) {
          if (null === b.stateNode) throw Error(p(166));
          S(b);
          return null;
        }
        a = Hh(Eh.current);
        if (Gg(b)) {
          d = b.stateNode;
          c = b.type;
          var f = b.memoizedProps;
          d[Of] = b;
          d[Pf] = f;
          a = 0 !== (b.mode & 1);
          switch (c) {
            case "dialog":
              D("cancel", d);
              D("close", d);
              break;
            case "iframe":
            case "object":
            case "embed":
              D("load", d);
              break;
            case "video":
            case "audio":
              for (e = 0; e < lf.length; e++) D(lf[e], d);
              break;
            case "source":
              D("error", d);
              break;
            case "img":
            case "image":
            case "link":
              D("error", d);
              D("load", d);
              break;
            case "details":
              D("toggle", d);
              break;
            case "input":
              Za(d, f);
              D("invalid", d);
              break;
            case "select":
              d._wrapperState = {
                wasMultiple: !!f.multiple
              };
              D("invalid", d);
              break;
            case "textarea":
              hb(d, f), D("invalid", d);
          }
          ub(c, f);
          e = null;
          for (var g in f) if (f.hasOwnProperty(g)) {
            var h = f[g];
            "children" === g ? "string" === typeof h ? d.textContent !== h && (!0 !== f.suppressHydrationWarning && Af(d.textContent, h, a), e = ["children", h]) : "number" === typeof h && d.textContent !== "" + h && (!0 !== f.suppressHydrationWarning && Af(d.textContent, h, a), e = ["children", "" + h]) : ea.hasOwnProperty(g) && null != h && "onScroll" === g && D("scroll", d);
          }
          switch (c) {
            case "input":
              Va(d);
              db(d, f, !0);
              break;
            case "textarea":
              Va(d);
              jb(d);
              break;
            case "select":
            case "option":
              break;
            default:
              "function" === typeof f.onClick && (d.onclick = Bf);
          }
          d = e;
          b.updateQueue = d;
          null !== d && (b.flags |= 4);
        } else {
          g = 9 === e.nodeType ? e : e.ownerDocument;
          "http://www.w3.org/1999/xhtml" === a && (a = kb(c));
          "http://www.w3.org/1999/xhtml" === a ? "script" === c ? (a = g.createElement("div"), a.innerHTML = "<script>\x3c/script>", a = a.removeChild(a.firstChild)) : "string" === typeof d.is ? a = g.createElement(c, {
            is: d.is
          }) : (a = g.createElement(c), "select" === c && (g = a, d.multiple ? g.multiple = !0 : d.size && (g.size = d.size))) : a = g.createElementNS(a, c);
          a[Of] = b;
          a[Pf] = d;
          Aj(a, b, !1, !1);
          b.stateNode = a;
          a: {
            g = vb(c, d);
            switch (c) {
              case "dialog":
                D("cancel", a);
                D("close", a);
                e = d;
                break;
              case "iframe":
              case "object":
              case "embed":
                D("load", a);
                e = d;
                break;
              case "video":
              case "audio":
                for (e = 0; e < lf.length; e++) D(lf[e], a);
                e = d;
                break;
              case "source":
                D("error", a);
                e = d;
                break;
              case "img":
              case "image":
              case "link":
                D("error", a);
                D("load", a);
                e = d;
                break;
              case "details":
                D("toggle", a);
                e = d;
                break;
              case "input":
                Za(a, d);
                e = Ya(a, d);
                D("invalid", a);
                break;
              case "option":
                e = d;
                break;
              case "select":
                a._wrapperState = {
                  wasMultiple: !!d.multiple
                };
                e = A({}, d, {
                  value: void 0
                });
                D("invalid", a);
                break;
              case "textarea":
                hb(a, d);
                e = gb(a, d);
                D("invalid", a);
                break;
              default:
                e = d;
            }
            ub(c, e);
            h = e;
            for (f in h) if (h.hasOwnProperty(f)) {
              var k = h[f];
              "style" === f ? sb(a, k) : "dangerouslySetInnerHTML" === f ? (k = k ? k.__html : void 0, null != k && nb(a, k)) : "children" === f ? "string" === typeof k ? ("textarea" !== c || "" !== k) && ob(a, k) : "number" === typeof k && ob(a, "" + k) : "suppressContentEditableWarning" !== f && "suppressHydrationWarning" !== f && "autoFocus" !== f && (ea.hasOwnProperty(f) ? null != k && "onScroll" === f && D("scroll", a) : null != k && ta(a, f, k, g));
            }
            switch (c) {
              case "input":
                Va(a);
                db(a, d, !1);
                break;
              case "textarea":
                Va(a);
                jb(a);
                break;
              case "option":
                null != d.value && a.setAttribute("value", "" + Sa(d.value));
                break;
              case "select":
                a.multiple = !!d.multiple;
                f = d.value;
                null != f ? fb(a, !!d.multiple, f, !1) : null != d.defaultValue && fb(a, !!d.multiple, d.defaultValue, !0);
                break;
              default:
                "function" === typeof e.onClick && (a.onclick = Bf);
            }
            switch (c) {
              case "button":
              case "input":
              case "select":
              case "textarea":
                d = !!d.autoFocus;
                break a;
              case "img":
                d = !0;
                break a;
              default:
                d = !1;
            }
          }
          d && (b.flags |= 4);
        }
        null !== b.ref && (b.flags |= 512, b.flags |= 2097152);
      }
      S(b);
      return null;
    case 6:
      if (a && null != b.stateNode) Dj(a, b, a.memoizedProps, d);else {
        if ("string" !== typeof d && null === b.stateNode) throw Error(p(166));
        c = Hh(Gh.current);
        Hh(Eh.current);
        if (Gg(b)) {
          d = b.stateNode;
          c = b.memoizedProps;
          d[Of] = b;
          if (f = d.nodeValue !== c) if (a = xg, null !== a) switch (a.tag) {
            case 3:
              Af(d.nodeValue, c, 0 !== (a.mode & 1));
              break;
            case 5:
              !0 !== a.memoizedProps.suppressHydrationWarning && Af(d.nodeValue, c, 0 !== (a.mode & 1));
          }
          f && (b.flags |= 4);
        } else d = (9 === c.nodeType ? c : c.ownerDocument).createTextNode(d), d[Of] = b, b.stateNode = d;
      }
      S(b);
      return null;
    case 13:
      E(M);
      d = b.memoizedState;
      if (null === a || null !== a.memoizedState && null !== a.memoizedState.dehydrated) {
        if (I && null !== yg && 0 !== (b.mode & 1) && 0 === (b.flags & 128)) Hg(), Ig(), b.flags |= 98560, f = !1;else if (f = Gg(b), null !== d && null !== d.dehydrated) {
          if (null === a) {
            if (!f) throw Error(p(318));
            f = b.memoizedState;
            f = null !== f ? f.dehydrated : null;
            if (!f) throw Error(p(317));
            f[Of] = b;
          } else Ig(), 0 === (b.flags & 128) && (b.memoizedState = null), b.flags |= 4;
          S(b);
          f = !1;
        } else null !== zg && (Gj(zg), zg = null), f = !0;
        if (!f) return b.flags & 65536 ? b : null;
      }
      if (0 !== (b.flags & 128)) return b.lanes = c, b;
      d = null !== d;
      d !== (null !== a && null !== a.memoizedState) && d && (b.child.flags |= 8192, 0 !== (b.mode & 1) && (null === a || 0 !== (M.current & 1) ? 0 === T && (T = 3) : uj()));
      null !== b.updateQueue && (b.flags |= 4);
      S(b);
      return null;
    case 4:
      return Jh(), Bj(a, b), null === a && sf(b.stateNode.containerInfo), S(b), null;
    case 10:
      return Rg(b.type._context), S(b), null;
    case 17:
      return Zf(b.type) && $f(), S(b), null;
    case 19:
      E(M);
      f = b.memoizedState;
      if (null === f) return S(b), null;
      d = 0 !== (b.flags & 128);
      g = f.rendering;
      if (null === g) {
        if (d) Ej(f, !1);else {
          if (0 !== T || null !== a && 0 !== (a.flags & 128)) for (a = b.child; null !== a;) {
            g = Mh(a);
            if (null !== g) {
              b.flags |= 128;
              Ej(f, !1);
              d = g.updateQueue;
              null !== d && (b.updateQueue = d, b.flags |= 4);
              b.subtreeFlags = 0;
              d = c;
              for (c = b.child; null !== c;) f = c, a = d, f.flags &= 14680066, g = f.alternate, null === g ? (f.childLanes = 0, f.lanes = a, f.child = null, f.subtreeFlags = 0, f.memoizedProps = null, f.memoizedState = null, f.updateQueue = null, f.dependencies = null, f.stateNode = null) : (f.childLanes = g.childLanes, f.lanes = g.lanes, f.child = g.child, f.subtreeFlags = 0, f.deletions = null, f.memoizedProps = g.memoizedProps, f.memoizedState = g.memoizedState, f.updateQueue = g.updateQueue, f.type = g.type, a = g.dependencies, f.dependencies = null === a ? null : {
                lanes: a.lanes,
                firstContext: a.firstContext
              }), c = c.sibling;
              G(M, M.current & 1 | 2);
              return b.child;
            }
            a = a.sibling;
          }
          null !== f.tail && B() > Hj && (b.flags |= 128, d = !0, Ej(f, !1), b.lanes = 4194304);
        }
      } else {
        if (!d) if (a = Mh(g), null !== a) {
          if (b.flags |= 128, d = !0, c = a.updateQueue, null !== c && (b.updateQueue = c, b.flags |= 4), Ej(f, !0), null === f.tail && "hidden" === f.tailMode && !g.alternate && !I) return S(b), null;
        } else 2 * B() - f.renderingStartTime > Hj && 1073741824 !== c && (b.flags |= 128, d = !0, Ej(f, !1), b.lanes = 4194304);
        f.isBackwards ? (g.sibling = b.child, b.child = g) : (c = f.last, null !== c ? c.sibling = g : b.child = g, f.last = g);
      }
      if (null !== f.tail) return b = f.tail, f.rendering = b, f.tail = b.sibling, f.renderingStartTime = B(), b.sibling = null, c = M.current, G(M, d ? c & 1 | 2 : c & 1), b;
      S(b);
      return null;
    case 22:
    case 23:
      return Ij(), d = null !== b.memoizedState, null !== a && null !== a.memoizedState !== d && (b.flags |= 8192), d && 0 !== (b.mode & 1) ? 0 !== (gj & 1073741824) && (S(b), b.subtreeFlags & 6 && (b.flags |= 8192)) : S(b), null;
    case 24:
      return null;
    case 25:
      return null;
  }
  throw Error(p(156, b.tag));
}
function Jj(a, b) {
  wg(b);
  switch (b.tag) {
    case 1:
      return Zf(b.type) && $f(), a = b.flags, a & 65536 ? (b.flags = a & -65537 | 128, b) : null;
    case 3:
      return Jh(), E(Wf), E(H), Oh(), a = b.flags, 0 !== (a & 65536) && 0 === (a & 128) ? (b.flags = a & -65537 | 128, b) : null;
    case 5:
      return Lh(b), null;
    case 13:
      E(M);
      a = b.memoizedState;
      if (null !== a && null !== a.dehydrated) {
        if (null === b.alternate) throw Error(p(340));
        Ig();
      }
      a = b.flags;
      return a & 65536 ? (b.flags = a & -65537 | 128, b) : null;
    case 19:
      return E(M), null;
    case 4:
      return Jh(), null;
    case 10:
      return Rg(b.type._context), null;
    case 22:
    case 23:
      return Ij(), null;
    case 24:
      return null;
    default:
      return null;
  }
}
var Kj = !1,
  U = !1,
  Lj = "function" === typeof WeakSet ? WeakSet : Set,
  V = null;
function Mj(a, b) {
  var c = a.ref;
  if (null !== c) if ("function" === typeof c) try {
    c(null);
  } catch (d) {
    W(a, b, d);
  } else c.current = null;
}
function Nj(a, b, c) {
  try {
    c();
  } catch (d) {
    W(a, b, d);
  }
}
var Oj = !1;
function Pj(a, b) {
  Cf = dd;
  a = Me();
  if (Ne(a)) {
    if ("selectionStart" in a) var c = {
      start: a.selectionStart,
      end: a.selectionEnd
    };else a: {
      c = (c = a.ownerDocument) && c.defaultView || window;
      var d = c.getSelection && c.getSelection();
      if (d && 0 !== d.rangeCount) {
        c = d.anchorNode;
        var e = d.anchorOffset,
          f = d.focusNode;
        d = d.focusOffset;
        try {
          c.nodeType, f.nodeType;
        } catch (F) {
          c = null;
          break a;
        }
        var g = 0,
          h = -1,
          k = -1,
          l = 0,
          m = 0,
          q = a,
          r = null;
        b: for (;;) {
          for (var y;;) {
            q !== c || 0 !== e && 3 !== q.nodeType || (h = g + e);
            q !== f || 0 !== d && 3 !== q.nodeType || (k = g + d);
            3 === q.nodeType && (g += q.nodeValue.length);
            if (null === (y = q.firstChild)) break;
            r = q;
            q = y;
          }
          for (;;) {
            if (q === a) break b;
            r === c && ++l === e && (h = g);
            r === f && ++m === d && (k = g);
            if (null !== (y = q.nextSibling)) break;
            q = r;
            r = q.parentNode;
          }
          q = y;
        }
        c = -1 === h || -1 === k ? null : {
          start: h,
          end: k
        };
      } else c = null;
    }
    c = c || {
      start: 0,
      end: 0
    };
  } else c = null;
  Df = {
    focusedElem: a,
    selectionRange: c
  };
  dd = !1;
  for (V = b; null !== V;) if (b = V, a = b.child, 0 !== (b.subtreeFlags & 1028) && null !== a) a.return = b, V = a;else for (; null !== V;) {
    b = V;
    try {
      var n = b.alternate;
      if (0 !== (b.flags & 1024)) switch (b.tag) {
        case 0:
        case 11:
        case 15:
          break;
        case 1:
          if (null !== n) {
            var t = n.memoizedProps,
              J = n.memoizedState,
              x = b.stateNode,
              w = x.getSnapshotBeforeUpdate(b.elementType === b.type ? t : Lg(b.type, t), J);
            x.__reactInternalSnapshotBeforeUpdate = w;
          }
          break;
        case 3:
          var u = b.stateNode.containerInfo;
          1 === u.nodeType ? u.textContent = "" : 9 === u.nodeType && u.documentElement && u.removeChild(u.documentElement);
          break;
        case 5:
        case 6:
        case 4:
        case 17:
          break;
        default:
          throw Error(p(163));
      }
    } catch (F) {
      W(b, b.return, F);
    }
    a = b.sibling;
    if (null !== a) {
      a.return = b.return;
      V = a;
      break;
    }
    V = b.return;
  }
  n = Oj;
  Oj = !1;
  return n;
}
function Qj(a, b, c) {
  var d = b.updateQueue;
  d = null !== d ? d.lastEffect : null;
  if (null !== d) {
    var e = d = d.next;
    do {
      if ((e.tag & a) === a) {
        var f = e.destroy;
        e.destroy = void 0;
        void 0 !== f && Nj(b, c, f);
      }
      e = e.next;
    } while (e !== d);
  }
}
function Rj(a, b) {
  b = b.updateQueue;
  b = null !== b ? b.lastEffect : null;
  if (null !== b) {
    var c = b = b.next;
    do {
      if ((c.tag & a) === a) {
        var d = c.create;
        c.destroy = d();
      }
      c = c.next;
    } while (c !== b);
  }
}
function Sj(a) {
  var b = a.ref;
  if (null !== b) {
    var c = a.stateNode;
    switch (a.tag) {
      case 5:
        a = c;
        break;
      default:
        a = c;
    }
    "function" === typeof b ? b(a) : b.current = a;
  }
}
function Tj(a) {
  var b = a.alternate;
  null !== b && (a.alternate = null, Tj(b));
  a.child = null;
  a.deletions = null;
  a.sibling = null;
  5 === a.tag && (b = a.stateNode, null !== b && (delete b[Of], delete b[Pf], delete b[of], delete b[Qf], delete b[Rf]));
  a.stateNode = null;
  a.return = null;
  a.dependencies = null;
  a.memoizedProps = null;
  a.memoizedState = null;
  a.pendingProps = null;
  a.stateNode = null;
  a.updateQueue = null;
}
function Uj(a) {
  return 5 === a.tag || 3 === a.tag || 4 === a.tag;
}
function Vj(a) {
  a: for (;;) {
    for (; null === a.sibling;) {
      if (null === a.return || Uj(a.return)) return null;
      a = a.return;
    }
    a.sibling.return = a.return;
    for (a = a.sibling; 5 !== a.tag && 6 !== a.tag && 18 !== a.tag;) {
      if (a.flags & 2) continue a;
      if (null === a.child || 4 === a.tag) continue a;else a.child.return = a, a = a.child;
    }
    if (!(a.flags & 2)) return a.stateNode;
  }
}
function Wj(a, b, c) {
  var d = a.tag;
  if (5 === d || 6 === d) a = a.stateNode, b ? 8 === c.nodeType ? c.parentNode.insertBefore(a, b) : c.insertBefore(a, b) : (8 === c.nodeType ? (b = c.parentNode, b.insertBefore(a, c)) : (b = c, b.appendChild(a)), c = c._reactRootContainer, null !== c && void 0 !== c || null !== b.onclick || (b.onclick = Bf));else if (4 !== d && (a = a.child, null !== a)) for (Wj(a, b, c), a = a.sibling; null !== a;) Wj(a, b, c), a = a.sibling;
}
function Xj(a, b, c) {
  var d = a.tag;
  if (5 === d || 6 === d) a = a.stateNode, b ? c.insertBefore(a, b) : c.appendChild(a);else if (4 !== d && (a = a.child, null !== a)) for (Xj(a, b, c), a = a.sibling; null !== a;) Xj(a, b, c), a = a.sibling;
}
var X = null,
  Yj = !1;
function Zj(a, b, c) {
  for (c = c.child; null !== c;) ak(a, b, c), c = c.sibling;
}
function ak(a, b, c) {
  if (lc && "function" === typeof lc.onCommitFiberUnmount) try {
    lc.onCommitFiberUnmount(kc, c);
  } catch (h) {}
  switch (c.tag) {
    case 5:
      U || Mj(c, b);
    case 6:
      var d = X,
        e = Yj;
      X = null;
      Zj(a, b, c);
      X = d;
      Yj = e;
      null !== X && (Yj ? (a = X, c = c.stateNode, 8 === a.nodeType ? a.parentNode.removeChild(c) : a.removeChild(c)) : X.removeChild(c.stateNode));
      break;
    case 18:
      null !== X && (Yj ? (a = X, c = c.stateNode, 8 === a.nodeType ? Kf(a.parentNode, c) : 1 === a.nodeType && Kf(a, c), bd(a)) : Kf(X, c.stateNode));
      break;
    case 4:
      d = X;
      e = Yj;
      X = c.stateNode.containerInfo;
      Yj = !0;
      Zj(a, b, c);
      X = d;
      Yj = e;
      break;
    case 0:
    case 11:
    case 14:
    case 15:
      if (!U && (d = c.updateQueue, null !== d && (d = d.lastEffect, null !== d))) {
        e = d = d.next;
        do {
          var f = e,
            g = f.destroy;
          f = f.tag;
          void 0 !== g && (0 !== (f & 2) ? Nj(c, b, g) : 0 !== (f & 4) && Nj(c, b, g));
          e = e.next;
        } while (e !== d);
      }
      Zj(a, b, c);
      break;
    case 1:
      if (!U && (Mj(c, b), d = c.stateNode, "function" === typeof d.componentWillUnmount)) try {
        d.props = c.memoizedProps, d.state = c.memoizedState, d.componentWillUnmount();
      } catch (h) {
        W(c, b, h);
      }
      Zj(a, b, c);
      break;
    case 21:
      Zj(a, b, c);
      break;
    case 22:
      c.mode & 1 ? (U = (d = U) || null !== c.memoizedState, Zj(a, b, c), U = d) : Zj(a, b, c);
      break;
    default:
      Zj(a, b, c);
  }
}
function bk(a) {
  var b = a.updateQueue;
  if (null !== b) {
    a.updateQueue = null;
    var c = a.stateNode;
    null === c && (c = a.stateNode = new Lj());
    b.forEach(function (b) {
      var d = ck.bind(null, a, b);
      c.has(b) || (c.add(b), b.then(d, d));
    });
  }
}
function dk(a, b) {
  var c = b.deletions;
  if (null !== c) for (var d = 0; d < c.length; d++) {
    var e = c[d];
    try {
      var f = a,
        g = b,
        h = g;
      a: for (; null !== h;) {
        switch (h.tag) {
          case 5:
            X = h.stateNode;
            Yj = !1;
            break a;
          case 3:
            X = h.stateNode.containerInfo;
            Yj = !0;
            break a;
          case 4:
            X = h.stateNode.containerInfo;
            Yj = !0;
            break a;
        }
        h = h.return;
      }
      if (null === X) throw Error(p(160));
      ak(f, g, e);
      X = null;
      Yj = !1;
      var k = e.alternate;
      null !== k && (k.return = null);
      e.return = null;
    } catch (l) {
      W(e, b, l);
    }
  }
  if (b.subtreeFlags & 12854) for (b = b.child; null !== b;) ek(b, a), b = b.sibling;
}
function ek(a, b) {
  var c = a.alternate,
    d = a.flags;
  switch (a.tag) {
    case 0:
    case 11:
    case 14:
    case 15:
      dk(b, a);
      fk(a);
      if (d & 4) {
        try {
          Qj(3, a, a.return), Rj(3, a);
        } catch (t) {
          W(a, a.return, t);
        }
        try {
          Qj(5, a, a.return);
        } catch (t) {
          W(a, a.return, t);
        }
      }
      break;
    case 1:
      dk(b, a);
      fk(a);
      d & 512 && null !== c && Mj(c, c.return);
      break;
    case 5:
      dk(b, a);
      fk(a);
      d & 512 && null !== c && Mj(c, c.return);
      if (a.flags & 32) {
        var e = a.stateNode;
        try {
          ob(e, "");
        } catch (t) {
          W(a, a.return, t);
        }
      }
      if (d & 4 && (e = a.stateNode, null != e)) {
        var f = a.memoizedProps,
          g = null !== c ? c.memoizedProps : f,
          h = a.type,
          k = a.updateQueue;
        a.updateQueue = null;
        if (null !== k) try {
          "input" === h && "radio" === f.type && null != f.name && ab(e, f);
          vb(h, g);
          var l = vb(h, f);
          for (g = 0; g < k.length; g += 2) {
            var m = k[g],
              q = k[g + 1];
            "style" === m ? sb(e, q) : "dangerouslySetInnerHTML" === m ? nb(e, q) : "children" === m ? ob(e, q) : ta(e, m, q, l);
          }
          switch (h) {
            case "input":
              bb(e, f);
              break;
            case "textarea":
              ib(e, f);
              break;
            case "select":
              var r = e._wrapperState.wasMultiple;
              e._wrapperState.wasMultiple = !!f.multiple;
              var y = f.value;
              null != y ? fb(e, !!f.multiple, y, !1) : r !== !!f.multiple && (null != f.defaultValue ? fb(e, !!f.multiple, f.defaultValue, !0) : fb(e, !!f.multiple, f.multiple ? [] : "", !1));
          }
          e[Pf] = f;
        } catch (t) {
          W(a, a.return, t);
        }
      }
      break;
    case 6:
      dk(b, a);
      fk(a);
      if (d & 4) {
        if (null === a.stateNode) throw Error(p(162));
        e = a.stateNode;
        f = a.memoizedProps;
        try {
          e.nodeValue = f;
        } catch (t) {
          W(a, a.return, t);
        }
      }
      break;
    case 3:
      dk(b, a);
      fk(a);
      if (d & 4 && null !== c && c.memoizedState.isDehydrated) try {
        bd(b.containerInfo);
      } catch (t) {
        W(a, a.return, t);
      }
      break;
    case 4:
      dk(b, a);
      fk(a);
      break;
    case 13:
      dk(b, a);
      fk(a);
      e = a.child;
      e.flags & 8192 && (f = null !== e.memoizedState, e.stateNode.isHidden = f, !f || null !== e.alternate && null !== e.alternate.memoizedState || (gk = B()));
      d & 4 && bk(a);
      break;
    case 22:
      m = null !== c && null !== c.memoizedState;
      a.mode & 1 ? (U = (l = U) || m, dk(b, a), U = l) : dk(b, a);
      fk(a);
      if (d & 8192) {
        l = null !== a.memoizedState;
        if ((a.stateNode.isHidden = l) && !m && 0 !== (a.mode & 1)) for (V = a, m = a.child; null !== m;) {
          for (q = V = m; null !== V;) {
            r = V;
            y = r.child;
            switch (r.tag) {
              case 0:
              case 11:
              case 14:
              case 15:
                Qj(4, r, r.return);
                break;
              case 1:
                Mj(r, r.return);
                var n = r.stateNode;
                if ("function" === typeof n.componentWillUnmount) {
                  d = r;
                  c = r.return;
                  try {
                    b = d, n.props = b.memoizedProps, n.state = b.memoizedState, n.componentWillUnmount();
                  } catch (t) {
                    W(d, c, t);
                  }
                }
                break;
              case 5:
                Mj(r, r.return);
                break;
              case 22:
                if (null !== r.memoizedState) {
                  hk(q);
                  continue;
                }
            }
            null !== y ? (y.return = r, V = y) : hk(q);
          }
          m = m.sibling;
        }
        a: for (m = null, q = a;;) {
          if (5 === q.tag) {
            if (null === m) {
              m = q;
              try {
                e = q.stateNode, l ? (f = e.style, "function" === typeof f.setProperty ? f.setProperty("display", "none", "important") : f.display = "none") : (h = q.stateNode, k = q.memoizedProps.style, g = void 0 !== k && null !== k && k.hasOwnProperty("display") ? k.display : null, h.style.display = rb("display", g));
              } catch (t) {
                W(a, a.return, t);
              }
            }
          } else if (6 === q.tag) {
            if (null === m) try {
              q.stateNode.nodeValue = l ? "" : q.memoizedProps;
            } catch (t) {
              W(a, a.return, t);
            }
          } else if ((22 !== q.tag && 23 !== q.tag || null === q.memoizedState || q === a) && null !== q.child) {
            q.child.return = q;
            q = q.child;
            continue;
          }
          if (q === a) break a;
          for (; null === q.sibling;) {
            if (null === q.return || q.return === a) break a;
            m === q && (m = null);
            q = q.return;
          }
          m === q && (m = null);
          q.sibling.return = q.return;
          q = q.sibling;
        }
      }
      break;
    case 19:
      dk(b, a);
      fk(a);
      d & 4 && bk(a);
      break;
    case 21:
      break;
    default:
      dk(b, a), fk(a);
  }
}
function fk(a) {
  var b = a.flags;
  if (b & 2) {
    try {
      a: {
        for (var c = a.return; null !== c;) {
          if (Uj(c)) {
            var d = c;
            break a;
          }
          c = c.return;
        }
        throw Error(p(160));
      }
      switch (d.tag) {
        case 5:
          var e = d.stateNode;
          d.flags & 32 && (ob(e, ""), d.flags &= -33);
          var f = Vj(a);
          Xj(a, f, e);
          break;
        case 3:
        case 4:
          var g = d.stateNode.containerInfo,
            h = Vj(a);
          Wj(a, h, g);
          break;
        default:
          throw Error(p(161));
      }
    } catch (k) {
      W(a, a.return, k);
    }
    a.flags &= -3;
  }
  b & 4096 && (a.flags &= -4097);
}
function ik(a, b, c) {
  V = a;
  jk(a, b, c);
}
function jk(a, b, c) {
  for (var d = 0 !== (a.mode & 1); null !== V;) {
    var e = V,
      f = e.child;
    if (22 === e.tag && d) {
      var g = null !== e.memoizedState || Kj;
      if (!g) {
        var h = e.alternate,
          k = null !== h && null !== h.memoizedState || U;
        h = Kj;
        var l = U;
        Kj = g;
        if ((U = k) && !l) for (V = e; null !== V;) g = V, k = g.child, 22 === g.tag && null !== g.memoizedState ? kk(e) : null !== k ? (k.return = g, V = k) : kk(e);
        for (; null !== f;) V = f, jk(f, b, c), f = f.sibling;
        V = e;
        Kj = h;
        U = l;
      }
      lk(a, b, c);
    } else 0 !== (e.subtreeFlags & 8772) && null !== f ? (f.return = e, V = f) : lk(a, b, c);
  }
}
function lk(a) {
  for (; null !== V;) {
    var b = V;
    if (0 !== (b.flags & 8772)) {
      var c = b.alternate;
      try {
        if (0 !== (b.flags & 8772)) switch (b.tag) {
          case 0:
          case 11:
          case 15:
            U || Rj(5, b);
            break;
          case 1:
            var d = b.stateNode;
            if (b.flags & 4 && !U) if (null === c) d.componentDidMount();else {
              var e = b.elementType === b.type ? c.memoizedProps : Lg(b.type, c.memoizedProps);
              d.componentDidUpdate(e, c.memoizedState, d.__reactInternalSnapshotBeforeUpdate);
            }
            var f = b.updateQueue;
            null !== f && ih(b, f, d);
            break;
          case 3:
            var g = b.updateQueue;
            if (null !== g) {
              c = null;
              if (null !== b.child) switch (b.child.tag) {
                case 5:
                  c = b.child.stateNode;
                  break;
                case 1:
                  c = b.child.stateNode;
              }
              ih(b, g, c);
            }
            break;
          case 5:
            var h = b.stateNode;
            if (null === c && b.flags & 4) {
              c = h;
              var k = b.memoizedProps;
              switch (b.type) {
                case "button":
                case "input":
                case "select":
                case "textarea":
                  k.autoFocus && c.focus();
                  break;
                case "img":
                  k.src && (c.src = k.src);
              }
            }
            break;
          case 6:
            break;
          case 4:
            break;
          case 12:
            break;
          case 13:
            if (null === b.memoizedState) {
              var l = b.alternate;
              if (null !== l) {
                var m = l.memoizedState;
                if (null !== m) {
                  var q = m.dehydrated;
                  null !== q && bd(q);
                }
              }
            }
            break;
          case 19:
          case 17:
          case 21:
          case 22:
          case 23:
          case 25:
            break;
          default:
            throw Error(p(163));
        }
        U || b.flags & 512 && Sj(b);
      } catch (r) {
        W(b, b.return, r);
      }
    }
    if (b === a) {
      V = null;
      break;
    }
    c = b.sibling;
    if (null !== c) {
      c.return = b.return;
      V = c;
      break;
    }
    V = b.return;
  }
}
function hk(a) {
  for (; null !== V;) {
    var b = V;
    if (b === a) {
      V = null;
      break;
    }
    var c = b.sibling;
    if (null !== c) {
      c.return = b.return;
      V = c;
      break;
    }
    V = b.return;
  }
}
function kk(a) {
  for (; null !== V;) {
    var b = V;
    try {
      switch (b.tag) {
        case 0:
        case 11:
        case 15:
          var c = b.return;
          try {
            Rj(4, b);
          } catch (k) {
            W(b, c, k);
          }
          break;
        case 1:
          var d = b.stateNode;
          if ("function" === typeof d.componentDidMount) {
            var e = b.return;
            try {
              d.componentDidMount();
            } catch (k) {
              W(b, e, k);
            }
          }
          var f = b.return;
          try {
            Sj(b);
          } catch (k) {
            W(b, f, k);
          }
          break;
        case 5:
          var g = b.return;
          try {
            Sj(b);
          } catch (k) {
            W(b, g, k);
          }
      }
    } catch (k) {
      W(b, b.return, k);
    }
    if (b === a) {
      V = null;
      break;
    }
    var h = b.sibling;
    if (null !== h) {
      h.return = b.return;
      V = h;
      break;
    }
    V = b.return;
  }
}
var mk = Math.ceil,
  nk = ua.ReactCurrentDispatcher,
  ok = ua.ReactCurrentOwner,
  pk = ua.ReactCurrentBatchConfig,
  K = 0,
  R = null,
  Y = null,
  Z = 0,
  gj = 0,
  fj = Uf(0),
  T = 0,
  qk = null,
  hh = 0,
  rk = 0,
  sk = 0,
  tk = null,
  uk = null,
  gk = 0,
  Hj = Infinity,
  vk = null,
  Pi = !1,
  Qi = null,
  Si = null,
  wk = !1,
  xk = null,
  yk = 0,
  zk = 0,
  Ak = null,
  Bk = -1,
  Ck = 0;
function L() {
  return 0 !== (K & 6) ? B() : -1 !== Bk ? Bk : Bk = B();
}
function lh(a) {
  if (0 === (a.mode & 1)) return 1;
  if (0 !== (K & 2) && 0 !== Z) return Z & -Z;
  if (null !== Kg.transition) return 0 === Ck && (Ck = yc()), Ck;
  a = C;
  if (0 !== a) return a;
  a = window.event;
  a = void 0 === a ? 16 : jd(a.type);
  return a;
}
function mh(a, b, c, d) {
  if (50 < zk) throw zk = 0, Ak = null, Error(p(185));
  Ac(a, c, d);
  if (0 === (K & 2) || a !== R) a === R && (0 === (K & 2) && (rk |= c), 4 === T && Dk(a, Z)), Ek(a, d), 1 === c && 0 === K && 0 === (b.mode & 1) && (Hj = B() + 500, fg && jg());
}
function Ek(a, b) {
  var c = a.callbackNode;
  wc(a, b);
  var d = uc(a, a === R ? Z : 0);
  if (0 === d) null !== c && bc(c), a.callbackNode = null, a.callbackPriority = 0;else if (b = d & -d, a.callbackPriority !== b) {
    null != c && bc(c);
    if (1 === b) 0 === a.tag ? ig(Fk.bind(null, a)) : hg(Fk.bind(null, a)), Jf(function () {
      0 === (K & 6) && jg();
    }), c = null;else {
      switch (Dc(d)) {
        case 1:
          c = fc;
          break;
        case 4:
          c = gc;
          break;
        case 16:
          c = hc;
          break;
        case 536870912:
          c = jc;
          break;
        default:
          c = hc;
      }
      c = Gk(c, Hk.bind(null, a));
    }
    a.callbackPriority = b;
    a.callbackNode = c;
  }
}
function Hk(a, b) {
  Bk = -1;
  Ck = 0;
  if (0 !== (K & 6)) throw Error(p(327));
  var c = a.callbackNode;
  if (Ik() && a.callbackNode !== c) return null;
  var d = uc(a, a === R ? Z : 0);
  if (0 === d) return null;
  if (0 !== (d & 30) || 0 !== (d & a.expiredLanes) || b) b = Jk(a, d);else {
    b = d;
    var e = K;
    K |= 2;
    var f = Kk();
    if (R !== a || Z !== b) vk = null, Hj = B() + 500, Lk(a, b);
    do try {
      Mk();
      break;
    } catch (h) {
      Nk(a, h);
    } while (1);
    Qg();
    nk.current = f;
    K = e;
    null !== Y ? b = 0 : (R = null, Z = 0, b = T);
  }
  if (0 !== b) {
    2 === b && (e = xc(a), 0 !== e && (d = e, b = Ok(a, e)));
    if (1 === b) throw c = qk, Lk(a, 0), Dk(a, d), Ek(a, B()), c;
    if (6 === b) Dk(a, d);else {
      e = a.current.alternate;
      if (0 === (d & 30) && !Pk(e) && (b = Jk(a, d), 2 === b && (f = xc(a), 0 !== f && (d = f, b = Ok(a, f))), 1 === b)) throw c = qk, Lk(a, 0), Dk(a, d), Ek(a, B()), c;
      a.finishedWork = e;
      a.finishedLanes = d;
      switch (b) {
        case 0:
        case 1:
          throw Error(p(345));
        case 2:
          Qk(a, uk, vk);
          break;
        case 3:
          Dk(a, d);
          if ((d & 130023424) === d && (b = gk + 500 - B(), 10 < b)) {
            if (0 !== uc(a, 0)) break;
            e = a.suspendedLanes;
            if ((e & d) !== d) {
              L();
              a.pingedLanes |= a.suspendedLanes & e;
              break;
            }
            a.timeoutHandle = Ff(Qk.bind(null, a, uk, vk), b);
            break;
          }
          Qk(a, uk, vk);
          break;
        case 4:
          Dk(a, d);
          if ((d & 4194240) === d) break;
          b = a.eventTimes;
          for (e = -1; 0 < d;) {
            var g = 31 - oc(d);
            f = 1 << g;
            g = b[g];
            g > e && (e = g);
            d &= ~f;
          }
          d = e;
          d = B() - d;
          d = (120 > d ? 120 : 480 > d ? 480 : 1080 > d ? 1080 : 1920 > d ? 1920 : 3E3 > d ? 3E3 : 4320 > d ? 4320 : 1960 * mk(d / 1960)) - d;
          if (10 < d) {
            a.timeoutHandle = Ff(Qk.bind(null, a, uk, vk), d);
            break;
          }
          Qk(a, uk, vk);
          break;
        case 5:
          Qk(a, uk, vk);
          break;
        default:
          throw Error(p(329));
      }
    }
  }
  Ek(a, B());
  return a.callbackNode === c ? Hk.bind(null, a) : null;
}
function Ok(a, b) {
  var c = tk;
  a.current.memoizedState.isDehydrated && (Lk(a, b).flags |= 256);
  a = Jk(a, b);
  2 !== a && (b = uk, uk = c, null !== b && Gj(b));
  return a;
}
function Gj(a) {
  null === uk ? uk = a : uk.push.apply(uk, a);
}
function Pk(a) {
  for (var b = a;;) {
    if (b.flags & 16384) {
      var c = b.updateQueue;
      if (null !== c && (c = c.stores, null !== c)) for (var d = 0; d < c.length; d++) {
        var e = c[d],
          f = e.getSnapshot;
        e = e.value;
        try {
          if (!He(f(), e)) return !1;
        } catch (g) {
          return !1;
        }
      }
    }
    c = b.child;
    if (b.subtreeFlags & 16384 && null !== c) c.return = b, b = c;else {
      if (b === a) break;
      for (; null === b.sibling;) {
        if (null === b.return || b.return === a) return !0;
        b = b.return;
      }
      b.sibling.return = b.return;
      b = b.sibling;
    }
  }
  return !0;
}
function Dk(a, b) {
  b &= ~sk;
  b &= ~rk;
  a.suspendedLanes |= b;
  a.pingedLanes &= ~b;
  for (a = a.expirationTimes; 0 < b;) {
    var c = 31 - oc(b),
      d = 1 << c;
    a[c] = -1;
    b &= ~d;
  }
}
function Fk(a) {
  if (0 !== (K & 6)) throw Error(p(327));
  Ik();
  var b = uc(a, 0);
  if (0 === (b & 1)) return Ek(a, B()), null;
  var c = Jk(a, b);
  if (0 !== a.tag && 2 === c) {
    var d = xc(a);
    0 !== d && (b = d, c = Ok(a, d));
  }
  if (1 === c) throw c = qk, Lk(a, 0), Dk(a, b), Ek(a, B()), c;
  if (6 === c) throw Error(p(345));
  a.finishedWork = a.current.alternate;
  a.finishedLanes = b;
  Qk(a, uk, vk);
  Ek(a, B());
  return null;
}
function Rk(a, b) {
  var c = K;
  K |= 1;
  try {
    return a(b);
  } finally {
    K = c, 0 === K && (Hj = B() + 500, fg && jg());
  }
}
function Sk(a) {
  null !== xk && 0 === xk.tag && 0 === (K & 6) && Ik();
  var b = K;
  K |= 1;
  var c = pk.transition,
    d = C;
  try {
    if (pk.transition = null, C = 1, a) return a();
  } finally {
    C = d, pk.transition = c, K = b, 0 === (K & 6) && jg();
  }
}
function Ij() {
  gj = fj.current;
  E(fj);
}
function Lk(a, b) {
  a.finishedWork = null;
  a.finishedLanes = 0;
  var c = a.timeoutHandle;
  -1 !== c && (a.timeoutHandle = -1, Gf(c));
  if (null !== Y) for (c = Y.return; null !== c;) {
    var d = c;
    wg(d);
    switch (d.tag) {
      case 1:
        d = d.type.childContextTypes;
        null !== d && void 0 !== d && $f();
        break;
      case 3:
        Jh();
        E(Wf);
        E(H);
        Oh();
        break;
      case 5:
        Lh(d);
        break;
      case 4:
        Jh();
        break;
      case 13:
        E(M);
        break;
      case 19:
        E(M);
        break;
      case 10:
        Rg(d.type._context);
        break;
      case 22:
      case 23:
        Ij();
    }
    c = c.return;
  }
  R = a;
  Y = a = wh(a.current, null);
  Z = gj = b;
  T = 0;
  qk = null;
  sk = rk = hh = 0;
  uk = tk = null;
  if (null !== Wg) {
    for (b = 0; b < Wg.length; b++) if (c = Wg[b], d = c.interleaved, null !== d) {
      c.interleaved = null;
      var e = d.next,
        f = c.pending;
      if (null !== f) {
        var g = f.next;
        f.next = e;
        d.next = g;
      }
      c.pending = d;
    }
    Wg = null;
  }
  return a;
}
function Nk(a, b) {
  do {
    var c = Y;
    try {
      Qg();
      Ph.current = ai;
      if (Sh) {
        for (var d = N.memoizedState; null !== d;) {
          var e = d.queue;
          null !== e && (e.pending = null);
          d = d.next;
        }
        Sh = !1;
      }
      Rh = 0;
      P = O = N = null;
      Th = !1;
      Uh = 0;
      ok.current = null;
      if (null === c || null === c.return) {
        T = 1;
        qk = b;
        Y = null;
        break;
      }
      a: {
        var f = a,
          g = c.return,
          h = c,
          k = b;
        b = Z;
        h.flags |= 32768;
        if (null !== k && "object" === typeof k && "function" === typeof k.then) {
          var l = k,
            m = h,
            q = m.tag;
          if (0 === (m.mode & 1) && (0 === q || 11 === q || 15 === q)) {
            var r = m.alternate;
            r ? (m.updateQueue = r.updateQueue, m.memoizedState = r.memoizedState, m.lanes = r.lanes) : (m.updateQueue = null, m.memoizedState = null);
          }
          var y = Vi(g);
          if (null !== y) {
            y.flags &= -257;
            Wi(y, g, h, f, b);
            y.mode & 1 && Ti(f, l, b);
            b = y;
            k = l;
            var n = b.updateQueue;
            if (null === n) {
              var t = new Set();
              t.add(k);
              b.updateQueue = t;
            } else n.add(k);
            break a;
          } else {
            if (0 === (b & 1)) {
              Ti(f, l, b);
              uj();
              break a;
            }
            k = Error(p(426));
          }
        } else if (I && h.mode & 1) {
          var J = Vi(g);
          if (null !== J) {
            0 === (J.flags & 65536) && (J.flags |= 256);
            Wi(J, g, h, f, b);
            Jg(Ki(k, h));
            break a;
          }
        }
        f = k = Ki(k, h);
        4 !== T && (T = 2);
        null === tk ? tk = [f] : tk.push(f);
        f = g;
        do {
          switch (f.tag) {
            case 3:
              f.flags |= 65536;
              b &= -b;
              f.lanes |= b;
              var x = Oi(f, k, b);
              fh(f, x);
              break a;
            case 1:
              h = k;
              var w = f.type,
                u = f.stateNode;
              if (0 === (f.flags & 128) && ("function" === typeof w.getDerivedStateFromError || null !== u && "function" === typeof u.componentDidCatch && (null === Si || !Si.has(u)))) {
                f.flags |= 65536;
                b &= -b;
                f.lanes |= b;
                var F = Ri(f, h, b);
                fh(f, F);
                break a;
              }
          }
          f = f.return;
        } while (null !== f);
      }
      Tk(c);
    } catch (na) {
      b = na;
      Y === c && null !== c && (Y = c = c.return);
      continue;
    }
    break;
  } while (1);
}
function Kk() {
  var a = nk.current;
  nk.current = ai;
  return null === a ? ai : a;
}
function uj() {
  if (0 === T || 3 === T || 2 === T) T = 4;
  null === R || 0 === (hh & 268435455) && 0 === (rk & 268435455) || Dk(R, Z);
}
function Jk(a, b) {
  var c = K;
  K |= 2;
  var d = Kk();
  if (R !== a || Z !== b) vk = null, Lk(a, b);
  do try {
    Uk();
    break;
  } catch (e) {
    Nk(a, e);
  } while (1);
  Qg();
  K = c;
  nk.current = d;
  if (null !== Y) throw Error(p(261));
  R = null;
  Z = 0;
  return T;
}
function Uk() {
  for (; null !== Y;) Vk(Y);
}
function Mk() {
  for (; null !== Y && !cc();) Vk(Y);
}
function Vk(a) {
  var b = Wk(a.alternate, a, gj);
  a.memoizedProps = a.pendingProps;
  null === b ? Tk(a) : Y = b;
  ok.current = null;
}
function Tk(a) {
  var b = a;
  do {
    var c = b.alternate;
    a = b.return;
    if (0 === (b.flags & 32768)) {
      if (c = Fj(c, b, gj), null !== c) {
        Y = c;
        return;
      }
    } else {
      c = Jj(c, b);
      if (null !== c) {
        c.flags &= 32767;
        Y = c;
        return;
      }
      if (null !== a) a.flags |= 32768, a.subtreeFlags = 0, a.deletions = null;else {
        T = 6;
        Y = null;
        return;
      }
    }
    b = b.sibling;
    if (null !== b) {
      Y = b;
      return;
    }
    Y = b = a;
  } while (null !== b);
  0 === T && (T = 5);
}
function Qk(a, b, c) {
  var d = C,
    e = pk.transition;
  try {
    pk.transition = null, C = 1, Xk(a, b, c, d);
  } finally {
    pk.transition = e, C = d;
  }
  return null;
}
function Xk(a, b, c, d) {
  do Ik(); while (null !== xk);
  if (0 !== (K & 6)) throw Error(p(327));
  c = a.finishedWork;
  var e = a.finishedLanes;
  if (null === c) return null;
  a.finishedWork = null;
  a.finishedLanes = 0;
  if (c === a.current) throw Error(p(177));
  a.callbackNode = null;
  a.callbackPriority = 0;
  var f = c.lanes | c.childLanes;
  Bc(a, f);
  a === R && (Y = R = null, Z = 0);
  0 === (c.subtreeFlags & 2064) && 0 === (c.flags & 2064) || wk || (wk = !0, Gk(hc, function () {
    Ik();
    return null;
  }));
  f = 0 !== (c.flags & 15990);
  if (0 !== (c.subtreeFlags & 15990) || f) {
    f = pk.transition;
    pk.transition = null;
    var g = C;
    C = 1;
    var h = K;
    K |= 4;
    ok.current = null;
    Pj(a, c);
    ek(c, a);
    Oe(Df);
    dd = !!Cf;
    Df = Cf = null;
    a.current = c;
    ik(c, a, e);
    dc();
    K = h;
    C = g;
    pk.transition = f;
  } else a.current = c;
  wk && (wk = !1, xk = a, yk = e);
  f = a.pendingLanes;
  0 === f && (Si = null);
  mc(c.stateNode, d);
  Ek(a, B());
  if (null !== b) for (d = a.onRecoverableError, c = 0; c < b.length; c++) e = b[c], d(e.value, {
    componentStack: e.stack,
    digest: e.digest
  });
  if (Pi) throw Pi = !1, a = Qi, Qi = null, a;
  0 !== (yk & 1) && 0 !== a.tag && Ik();
  f = a.pendingLanes;
  0 !== (f & 1) ? a === Ak ? zk++ : (zk = 0, Ak = a) : zk = 0;
  jg();
  return null;
}
function Ik() {
  if (null !== xk) {
    var a = Dc(yk),
      b = pk.transition,
      c = C;
    try {
      pk.transition = null;
      C = 16 > a ? 16 : a;
      if (null === xk) var d = !1;else {
        a = xk;
        xk = null;
        yk = 0;
        if (0 !== (K & 6)) throw Error(p(331));
        var e = K;
        K |= 4;
        for (V = a.current; null !== V;) {
          var f = V,
            g = f.child;
          if (0 !== (V.flags & 16)) {
            var h = f.deletions;
            if (null !== h) {
              for (var k = 0; k < h.length; k++) {
                var l = h[k];
                for (V = l; null !== V;) {
                  var m = V;
                  switch (m.tag) {
                    case 0:
                    case 11:
                    case 15:
                      Qj(8, m, f);
                  }
                  var q = m.child;
                  if (null !== q) q.return = m, V = q;else for (; null !== V;) {
                    m = V;
                    var r = m.sibling,
                      y = m.return;
                    Tj(m);
                    if (m === l) {
                      V = null;
                      break;
                    }
                    if (null !== r) {
                      r.return = y;
                      V = r;
                      break;
                    }
                    V = y;
                  }
                }
              }
              var n = f.alternate;
              if (null !== n) {
                var t = n.child;
                if (null !== t) {
                  n.child = null;
                  do {
                    var J = t.sibling;
                    t.sibling = null;
                    t = J;
                  } while (null !== t);
                }
              }
              V = f;
            }
          }
          if (0 !== (f.subtreeFlags & 2064) && null !== g) g.return = f, V = g;else b: for (; null !== V;) {
            f = V;
            if (0 !== (f.flags & 2048)) switch (f.tag) {
              case 0:
              case 11:
              case 15:
                Qj(9, f, f.return);
            }
            var x = f.sibling;
            if (null !== x) {
              x.return = f.return;
              V = x;
              break b;
            }
            V = f.return;
          }
        }
        var w = a.current;
        for (V = w; null !== V;) {
          g = V;
          var u = g.child;
          if (0 !== (g.subtreeFlags & 2064) && null !== u) u.return = g, V = u;else b: for (g = w; null !== V;) {
            h = V;
            if (0 !== (h.flags & 2048)) try {
              switch (h.tag) {
                case 0:
                case 11:
                case 15:
                  Rj(9, h);
              }
            } catch (na) {
              W(h, h.return, na);
            }
            if (h === g) {
              V = null;
              break b;
            }
            var F = h.sibling;
            if (null !== F) {
              F.return = h.return;
              V = F;
              break b;
            }
            V = h.return;
          }
        }
        K = e;
        jg();
        if (lc && "function" === typeof lc.onPostCommitFiberRoot) try {
          lc.onPostCommitFiberRoot(kc, a);
        } catch (na) {}
        d = !0;
      }
      return d;
    } finally {
      C = c, pk.transition = b;
    }
  }
  return !1;
}
function Yk(a, b, c) {
  b = Ki(c, b);
  b = Oi(a, b, 1);
  a = dh(a, b, 1);
  b = L();
  null !== a && (Ac(a, 1, b), Ek(a, b));
}
function W(a, b, c) {
  if (3 === a.tag) Yk(a, a, c);else for (; null !== b;) {
    if (3 === b.tag) {
      Yk(b, a, c);
      break;
    } else if (1 === b.tag) {
      var d = b.stateNode;
      if ("function" === typeof b.type.getDerivedStateFromError || "function" === typeof d.componentDidCatch && (null === Si || !Si.has(d))) {
        a = Ki(c, a);
        a = Ri(b, a, 1);
        b = dh(b, a, 1);
        a = L();
        null !== b && (Ac(b, 1, a), Ek(b, a));
        break;
      }
    }
    b = b.return;
  }
}
function Ui(a, b, c) {
  var d = a.pingCache;
  null !== d && d.delete(b);
  b = L();
  a.pingedLanes |= a.suspendedLanes & c;
  R === a && (Z & c) === c && (4 === T || 3 === T && (Z & 130023424) === Z && 500 > B() - gk ? Lk(a, 0) : sk |= c);
  Ek(a, b);
}
function Zk(a, b) {
  0 === b && (0 === (a.mode & 1) ? b = 1 : (b = sc, sc <<= 1, 0 === (sc & 130023424) && (sc = 4194304)));
  var c = L();
  a = Zg(a, b);
  null !== a && (Ac(a, b, c), Ek(a, c));
}
function vj(a) {
  var b = a.memoizedState,
    c = 0;
  null !== b && (c = b.retryLane);
  Zk(a, c);
}
function ck(a, b) {
  var c = 0;
  switch (a.tag) {
    case 13:
      var d = a.stateNode;
      var e = a.memoizedState;
      null !== e && (c = e.retryLane);
      break;
    case 19:
      d = a.stateNode;
      break;
    default:
      throw Error(p(314));
  }
  null !== d && d.delete(b);
  Zk(a, c);
}
var Wk;
Wk = function Wk(a, b, c) {
  if (null !== a) {
    if (a.memoizedProps !== b.pendingProps || Wf.current) Ug = !0;else {
      if (0 === (a.lanes & c) && 0 === (b.flags & 128)) return Ug = !1, zj(a, b, c);
      Ug = 0 !== (a.flags & 131072) ? !0 : !1;
    }
  } else Ug = !1, I && 0 !== (b.flags & 1048576) && ug(b, ng, b.index);
  b.lanes = 0;
  switch (b.tag) {
    case 2:
      var d = b.type;
      jj(a, b);
      a = b.pendingProps;
      var e = Yf(b, H.current);
      Tg(b, c);
      e = Xh(null, b, d, a, e, c);
      var f = bi();
      b.flags |= 1;
      "object" === typeof e && null !== e && "function" === typeof e.render && void 0 === e.$$typeof ? (b.tag = 1, b.memoizedState = null, b.updateQueue = null, Zf(d) ? (f = !0, cg(b)) : f = !1, b.memoizedState = null !== e.state && void 0 !== e.state ? e.state : null, ah(b), e.updater = nh, b.stateNode = e, e._reactInternals = b, rh(b, d, a, c), b = kj(null, b, d, !0, f, c)) : (b.tag = 0, I && f && vg(b), Yi(null, b, e, c), b = b.child);
      return b;
    case 16:
      d = b.elementType;
      a: {
        jj(a, b);
        a = b.pendingProps;
        e = d._init;
        d = e(d._payload);
        b.type = d;
        e = b.tag = $k(d);
        a = Lg(d, a);
        switch (e) {
          case 0:
            b = dj(null, b, d, a, c);
            break a;
          case 1:
            b = ij(null, b, d, a, c);
            break a;
          case 11:
            b = Zi(null, b, d, a, c);
            break a;
          case 14:
            b = aj(null, b, d, Lg(d.type, a), c);
            break a;
        }
        throw Error(p(306, d, ""));
      }
      return b;
    case 0:
      return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : Lg(d, e), dj(a, b, d, e, c);
    case 1:
      return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : Lg(d, e), ij(a, b, d, e, c);
    case 3:
      a: {
        lj(b);
        if (null === a) throw Error(p(387));
        d = b.pendingProps;
        f = b.memoizedState;
        e = f.element;
        bh(a, b);
        gh(b, d, null, c);
        var g = b.memoizedState;
        d = g.element;
        if (f.isDehydrated) {
          if (f = {
            element: d,
            isDehydrated: !1,
            cache: g.cache,
            pendingSuspenseBoundaries: g.pendingSuspenseBoundaries,
            transitions: g.transitions
          }, b.updateQueue.baseState = f, b.memoizedState = f, b.flags & 256) {
            e = Ki(Error(p(423)), b);
            b = mj(a, b, d, c, e);
            break a;
          } else if (d !== e) {
            e = Ki(Error(p(424)), b);
            b = mj(a, b, d, c, e);
            break a;
          } else for (yg = Lf(b.stateNode.containerInfo.firstChild), xg = b, I = !0, zg = null, c = Ch(b, null, d, c), b.child = c; c;) c.flags = c.flags & -3 | 4096, c = c.sibling;
        } else {
          Ig();
          if (d === e) {
            b = $i(a, b, c);
            break a;
          }
          Yi(a, b, d, c);
        }
        b = b.child;
      }
      return b;
    case 5:
      return Kh(b), null === a && Eg(b), d = b.type, e = b.pendingProps, f = null !== a ? a.memoizedProps : null, g = e.children, Ef(d, e) ? g = null : null !== f && Ef(d, f) && (b.flags |= 32), hj(a, b), Yi(a, b, g, c), b.child;
    case 6:
      return null === a && Eg(b), null;
    case 13:
      return pj(a, b, c);
    case 4:
      return Ih(b, b.stateNode.containerInfo), d = b.pendingProps, null === a ? b.child = Bh(b, null, d, c) : Yi(a, b, d, c), b.child;
    case 11:
      return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : Lg(d, e), Zi(a, b, d, e, c);
    case 7:
      return Yi(a, b, b.pendingProps, c), b.child;
    case 8:
      return Yi(a, b, b.pendingProps.children, c), b.child;
    case 12:
      return Yi(a, b, b.pendingProps.children, c), b.child;
    case 10:
      a: {
        d = b.type._context;
        e = b.pendingProps;
        f = b.memoizedProps;
        g = e.value;
        G(Mg, d._currentValue);
        d._currentValue = g;
        if (null !== f) if (He(f.value, g)) {
          if (f.children === e.children && !Wf.current) {
            b = $i(a, b, c);
            break a;
          }
        } else for (f = b.child, null !== f && (f.return = b); null !== f;) {
          var h = f.dependencies;
          if (null !== h) {
            g = f.child;
            for (var k = h.firstContext; null !== k;) {
              if (k.context === d) {
                if (1 === f.tag) {
                  k = ch(-1, c & -c);
                  k.tag = 2;
                  var l = f.updateQueue;
                  if (null !== l) {
                    l = l.shared;
                    var m = l.pending;
                    null === m ? k.next = k : (k.next = m.next, m.next = k);
                    l.pending = k;
                  }
                }
                f.lanes |= c;
                k = f.alternate;
                null !== k && (k.lanes |= c);
                Sg(f.return, c, b);
                h.lanes |= c;
                break;
              }
              k = k.next;
            }
          } else if (10 === f.tag) g = f.type === b.type ? null : f.child;else if (18 === f.tag) {
            g = f.return;
            if (null === g) throw Error(p(341));
            g.lanes |= c;
            h = g.alternate;
            null !== h && (h.lanes |= c);
            Sg(g, c, b);
            g = f.sibling;
          } else g = f.child;
          if (null !== g) g.return = f;else for (g = f; null !== g;) {
            if (g === b) {
              g = null;
              break;
            }
            f = g.sibling;
            if (null !== f) {
              f.return = g.return;
              g = f;
              break;
            }
            g = g.return;
          }
          f = g;
        }
        Yi(a, b, e.children, c);
        b = b.child;
      }
      return b;
    case 9:
      return e = b.type, d = b.pendingProps.children, Tg(b, c), e = Vg(e), d = d(e), b.flags |= 1, Yi(a, b, d, c), b.child;
    case 14:
      return d = b.type, e = Lg(d, b.pendingProps), e = Lg(d.type, e), aj(a, b, d, e, c);
    case 15:
      return cj(a, b, b.type, b.pendingProps, c);
    case 17:
      return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : Lg(d, e), jj(a, b), b.tag = 1, Zf(d) ? (a = !0, cg(b)) : a = !1, Tg(b, c), ph(b, d, e), rh(b, d, e, c), kj(null, b, d, !0, a, c);
    case 19:
      return yj(a, b, c);
    case 22:
      return ej(a, b, c);
  }
  throw Error(p(156, b.tag));
};
function Gk(a, b) {
  return ac(a, b);
}
function al(a, b, c, d) {
  this.tag = a;
  this.key = c;
  this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
  this.index = 0;
  this.ref = null;
  this.pendingProps = b;
  this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
  this.mode = d;
  this.subtreeFlags = this.flags = 0;
  this.deletions = null;
  this.childLanes = this.lanes = 0;
  this.alternate = null;
}
function Bg(a, b, c, d) {
  return new al(a, b, c, d);
}
function bj(a) {
  a = a.prototype;
  return !(!a || !a.isReactComponent);
}
function $k(a) {
  if ("function" === typeof a) return bj(a) ? 1 : 0;
  if (void 0 !== a && null !== a) {
    a = a.$$typeof;
    if (a === Da) return 11;
    if (a === Ga) return 14;
  }
  return 2;
}
function wh(a, b) {
  var c = a.alternate;
  null === c ? (c = Bg(a.tag, b, a.key, a.mode), c.elementType = a.elementType, c.type = a.type, c.stateNode = a.stateNode, c.alternate = a, a.alternate = c) : (c.pendingProps = b, c.type = a.type, c.flags = 0, c.subtreeFlags = 0, c.deletions = null);
  c.flags = a.flags & 14680064;
  c.childLanes = a.childLanes;
  c.lanes = a.lanes;
  c.child = a.child;
  c.memoizedProps = a.memoizedProps;
  c.memoizedState = a.memoizedState;
  c.updateQueue = a.updateQueue;
  b = a.dependencies;
  c.dependencies = null === b ? null : {
    lanes: b.lanes,
    firstContext: b.firstContext
  };
  c.sibling = a.sibling;
  c.index = a.index;
  c.ref = a.ref;
  return c;
}
function yh(a, b, c, d, e, f) {
  var g = 2;
  d = a;
  if ("function" === typeof a) bj(a) && (g = 1);else if ("string" === typeof a) g = 5;else a: switch (a) {
    case ya:
      return Ah(c.children, e, f, b);
    case za:
      g = 8;
      e |= 8;
      break;
    case Aa:
      return a = Bg(12, c, b, e | 2), a.elementType = Aa, a.lanes = f, a;
    case Ea:
      return a = Bg(13, c, b, e), a.elementType = Ea, a.lanes = f, a;
    case Fa:
      return a = Bg(19, c, b, e), a.elementType = Fa, a.lanes = f, a;
    case Ia:
      return qj(c, e, f, b);
    default:
      if ("object" === typeof a && null !== a) switch (a.$$typeof) {
        case Ba:
          g = 10;
          break a;
        case Ca:
          g = 9;
          break a;
        case Da:
          g = 11;
          break a;
        case Ga:
          g = 14;
          break a;
        case Ha:
          g = 16;
          d = null;
          break a;
      }
      throw Error(p(130, null == a ? a : typeof a, ""));
  }
  b = Bg(g, c, b, e);
  b.elementType = a;
  b.type = d;
  b.lanes = f;
  return b;
}
function Ah(a, b, c, d) {
  a = Bg(7, a, d, b);
  a.lanes = c;
  return a;
}
function qj(a, b, c, d) {
  a = Bg(22, a, d, b);
  a.elementType = Ia;
  a.lanes = c;
  a.stateNode = {
    isHidden: !1
  };
  return a;
}
function xh(a, b, c) {
  a = Bg(6, a, null, b);
  a.lanes = c;
  return a;
}
function zh(a, b, c) {
  b = Bg(4, null !== a.children ? a.children : [], a.key, b);
  b.lanes = c;
  b.stateNode = {
    containerInfo: a.containerInfo,
    pendingChildren: null,
    implementation: a.implementation
  };
  return b;
}
function bl(a, b, c, d, e) {
  this.tag = b;
  this.containerInfo = a;
  this.finishedWork = this.pingCache = this.current = this.pendingChildren = null;
  this.timeoutHandle = -1;
  this.callbackNode = this.pendingContext = this.context = null;
  this.callbackPriority = 0;
  this.eventTimes = zc(0);
  this.expirationTimes = zc(-1);
  this.entangledLanes = this.finishedLanes = this.mutableReadLanes = this.expiredLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0;
  this.entanglements = zc(0);
  this.identifierPrefix = d;
  this.onRecoverableError = e;
  this.mutableSourceEagerHydrationData = null;
}
function cl(a, b, c, d, e, f, g, h, k) {
  a = new bl(a, b, c, h, k);
  1 === b ? (b = 1, !0 === f && (b |= 8)) : b = 0;
  f = Bg(3, null, null, b);
  a.current = f;
  f.stateNode = a;
  f.memoizedState = {
    element: d,
    isDehydrated: c,
    cache: null,
    transitions: null,
    pendingSuspenseBoundaries: null
  };
  ah(f);
  return a;
}
function dl(a, b, c) {
  var d = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
  return {
    $$typeof: wa,
    key: null == d ? null : "" + d,
    children: a,
    containerInfo: b,
    implementation: c
  };
}
function el(a) {
  if (!a) return Vf;
  a = a._reactInternals;
  a: {
    if (Vb(a) !== a || 1 !== a.tag) throw Error(p(170));
    var b = a;
    do {
      switch (b.tag) {
        case 3:
          b = b.stateNode.context;
          break a;
        case 1:
          if (Zf(b.type)) {
            b = b.stateNode.__reactInternalMemoizedMergedChildContext;
            break a;
          }
      }
      b = b.return;
    } while (null !== b);
    throw Error(p(171));
  }
  if (1 === a.tag) {
    var c = a.type;
    if (Zf(c)) return bg(a, c, b);
  }
  return b;
}
function fl(a, b, c, d, e, f, g, h, k) {
  a = cl(c, d, !0, a, e, f, g, h, k);
  a.context = el(null);
  c = a.current;
  d = L();
  e = lh(c);
  f = ch(d, e);
  f.callback = void 0 !== b && null !== b ? b : null;
  dh(c, f, e);
  a.current.lanes = e;
  Ac(a, e, d);
  Ek(a, d);
  return a;
}
function gl(a, b, c, d) {
  var e = b.current,
    f = L(),
    g = lh(e);
  c = el(c);
  null === b.context ? b.context = c : b.pendingContext = c;
  b = ch(f, g);
  b.payload = {
    element: a
  };
  d = void 0 === d ? null : d;
  null !== d && (b.callback = d);
  a = dh(e, b, g);
  null !== a && (mh(a, e, g, f), eh(a, e, g));
  return g;
}
function hl(a) {
  a = a.current;
  if (!a.child) return null;
  switch (a.child.tag) {
    case 5:
      return a.child.stateNode;
    default:
      return a.child.stateNode;
  }
}
function il(a, b) {
  a = a.memoizedState;
  if (null !== a && null !== a.dehydrated) {
    var c = a.retryLane;
    a.retryLane = 0 !== c && c < b ? c : b;
  }
}
function jl(a, b) {
  il(a, b);
  (a = a.alternate) && il(a, b);
}
function kl() {
  return null;
}
var ll = "function" === typeof reportError ? reportError : function (a) {
  console.error(a);
};
function ml(a) {
  this._internalRoot = a;
}
nl.prototype.render = ml.prototype.render = function (a) {
  var b = this._internalRoot;
  if (null === b) throw Error(p(409));
  gl(a, b, null, null);
};
nl.prototype.unmount = ml.prototype.unmount = function () {
  var a = this._internalRoot;
  if (null !== a) {
    this._internalRoot = null;
    var b = a.containerInfo;
    Sk(function () {
      gl(null, a, null, null);
    });
    b[uf] = null;
  }
};
function nl(a) {
  this._internalRoot = a;
}
nl.prototype.unstable_scheduleHydration = function (a) {
  if (a) {
    var b = Hc();
    a = {
      blockedOn: null,
      target: a,
      priority: b
    };
    for (var c = 0; c < Qc.length && 0 !== b && b < Qc[c].priority; c++);
    Qc.splice(c, 0, a);
    0 === c && Vc(a);
  }
};
function ol(a) {
  return !(!a || 1 !== a.nodeType && 9 !== a.nodeType && 11 !== a.nodeType);
}
function pl(a) {
  return !(!a || 1 !== a.nodeType && 9 !== a.nodeType && 11 !== a.nodeType && (8 !== a.nodeType || " react-mount-point-unstable " !== a.nodeValue));
}
function ql() {}
function rl(a, b, c, d, e) {
  if (e) {
    if ("function" === typeof d) {
      var f = d;
      d = function d() {
        var a = hl(g);
        f.call(a);
      };
    }
    var g = fl(b, d, a, 0, null, !1, !1, "", ql);
    a._reactRootContainer = g;
    a[uf] = g.current;
    sf(8 === a.nodeType ? a.parentNode : a);
    Sk();
    return g;
  }
  for (; e = a.lastChild;) a.removeChild(e);
  if ("function" === typeof d) {
    var h = d;
    d = function d() {
      var a = hl(k);
      h.call(a);
    };
  }
  var k = cl(a, 0, !1, null, null, !1, !1, "", ql);
  a._reactRootContainer = k;
  a[uf] = k.current;
  sf(8 === a.nodeType ? a.parentNode : a);
  Sk(function () {
    gl(b, k, c, d);
  });
  return k;
}
function sl(a, b, c, d, e) {
  var f = c._reactRootContainer;
  if (f) {
    var g = f;
    if ("function" === typeof e) {
      var h = e;
      e = function e() {
        var a = hl(g);
        h.call(a);
      };
    }
    gl(b, g, a, e);
  } else g = rl(c, b, a, e, d);
  return hl(g);
}
Ec = function Ec(a) {
  switch (a.tag) {
    case 3:
      var b = a.stateNode;
      if (b.current.memoizedState.isDehydrated) {
        var c = tc(b.pendingLanes);
        0 !== c && (Cc(b, c | 1), Ek(b, B()), 0 === (K & 6) && (Hj = B() + 500, jg()));
      }
      break;
    case 13:
      Sk(function () {
        var b = Zg(a, 1);
        if (null !== b) {
          var c = L();
          mh(b, a, 1, c);
        }
      }), jl(a, 1);
  }
};
Fc = function Fc(a) {
  if (13 === a.tag) {
    var b = Zg(a, 134217728);
    if (null !== b) {
      var c = L();
      mh(b, a, 134217728, c);
    }
    jl(a, 134217728);
  }
};
Gc = function Gc(a) {
  if (13 === a.tag) {
    var b = lh(a),
      c = Zg(a, b);
    if (null !== c) {
      var d = L();
      mh(c, a, b, d);
    }
    jl(a, b);
  }
};
Hc = function Hc() {
  return C;
};
Ic = function Ic(a, b) {
  var c = C;
  try {
    return C = a, b();
  } finally {
    C = c;
  }
};
yb = function yb(a, b, c) {
  switch (b) {
    case "input":
      bb(a, c);
      b = c.name;
      if ("radio" === c.type && null != b) {
        for (c = a; c.parentNode;) c = c.parentNode;
        c = c.querySelectorAll("input[name=" + JSON.stringify("" + b) + '][type="radio"]');
        for (b = 0; b < c.length; b++) {
          var d = c[b];
          if (d !== a && d.form === a.form) {
            var e = Db(d);
            if (!e) throw Error(p(90));
            Wa(d);
            bb(d, e);
          }
        }
      }
      break;
    case "textarea":
      ib(a, c);
      break;
    case "select":
      b = c.value, null != b && fb(a, !!c.multiple, b, !1);
  }
};
Gb = Rk;
Hb = Sk;
var tl = {
    usingClientEntryPoint: !1,
    Events: [Cb, ue, Db, Eb, Fb, Rk]
  },
  ul = {
    findFiberByHostInstance: Wc,
    bundleType: 0,
    version: "18.2.0",
    rendererPackageName: "react-dom"
  };
var vl = {
  bundleType: ul.bundleType,
  version: ul.version,
  rendererPackageName: ul.rendererPackageName,
  rendererConfig: ul.rendererConfig,
  overrideHookState: null,
  overrideHookStateDeletePath: null,
  overrideHookStateRenamePath: null,
  overrideProps: null,
  overridePropsDeletePath: null,
  overridePropsRenamePath: null,
  setErrorHandler: null,
  setSuspenseHandler: null,
  scheduleUpdate: null,
  currentDispatcherRef: ua.ReactCurrentDispatcher,
  findHostInstanceByFiber: function findHostInstanceByFiber(a) {
    a = Zb(a);
    return null === a ? null : a.stateNode;
  },
  findFiberByHostInstance: ul.findFiberByHostInstance || kl,
  findHostInstancesForRefresh: null,
  scheduleRefresh: null,
  scheduleRoot: null,
  setRefreshHandler: null,
  getCurrentFiber: null,
  reconcilerVersion: "18.2.0-next-9e3b772b8-20220608"
};
if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
  var wl = __REACT_DEVTOOLS_GLOBAL_HOOK__;
  if (!wl.isDisabled && wl.supportsFiber) try {
    kc = wl.inject(vl), lc = wl;
  } catch (a) {}
}
exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = tl;
exports.createPortal = function (a, b) {
  var c = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;
  if (!ol(b)) throw Error(p(200));
  return dl(a, b, null, c);
};
exports.createRoot = function (a, b) {
  if (!ol(a)) throw Error(p(299));
  var c = !1,
    d = "",
    e = ll;
  null !== b && void 0 !== b && (!0 === b.unstable_strictMode && (c = !0), void 0 !== b.identifierPrefix && (d = b.identifierPrefix), void 0 !== b.onRecoverableError && (e = b.onRecoverableError));
  b = cl(a, 1, !1, null, null, c, !1, d, e);
  a[uf] = b.current;
  sf(8 === a.nodeType ? a.parentNode : a);
  return new ml(b);
};
exports.findDOMNode = function (a) {
  if (null == a) return null;
  if (1 === a.nodeType) return a;
  var b = a._reactInternals;
  if (void 0 === b) {
    if ("function" === typeof a.render) throw Error(p(188));
    a = Object.keys(a).join(",");
    throw Error(p(268, a));
  }
  a = Zb(b);
  a = null === a ? null : a.stateNode;
  return a;
};
exports.flushSync = function (a) {
  return Sk(a);
};
exports.hydrate = function (a, b, c) {
  if (!pl(b)) throw Error(p(200));
  return sl(null, a, b, !0, c);
};
exports.hydrateRoot = function (a, b, c) {
  if (!ol(a)) throw Error(p(405));
  var d = null != c && c.hydratedSources || null,
    e = !1,
    f = "",
    g = ll;
  null !== c && void 0 !== c && (!0 === c.unstable_strictMode && (e = !0), void 0 !== c.identifierPrefix && (f = c.identifierPrefix), void 0 !== c.onRecoverableError && (g = c.onRecoverableError));
  b = fl(b, null, a, 1, null != c ? c : null, e, !1, f, g);
  a[uf] = b.current;
  sf(a);
  if (d) for (a = 0; a < d.length; a++) c = d[a], e = c._getVersion, e = e(c._source), null == b.mutableSourceEagerHydrationData ? b.mutableSourceEagerHydrationData = [c, e] : b.mutableSourceEagerHydrationData.push(c, e);
  return new nl(b);
};
exports.render = function (a, b, c) {
  if (!pl(b)) throw Error(p(200));
  return sl(null, a, b, !1, c);
};
exports.unmountComponentAtNode = function (a) {
  if (!pl(a)) throw Error(p(40));
  return a._reactRootContainer ? (Sk(function () {
    sl(null, null, a, !1, function () {
      a._reactRootContainer = null;
      a[uf] = null;
    });
  }), !0) : !1;
};
exports.unstable_batchedUpdates = Rk;
exports.unstable_renderSubtreeIntoContainer = function (a, b, c, d) {
  if (!pl(c)) throw Error(p(200));
  if (null == a || void 0 === a._reactInternals) throw Error(p(38));
  return sl(a, b, c, !1, d);
};
exports.version = "18.2.0-next-9e3b772b8-20220608";

/***/ }),

/***/ 545:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


var m = __webpack_require__(1162);
if (true) {
  exports.createRoot = m.createRoot;
  exports.hydrateRoot = m.hydrateRoot;
} else { var i; }

/***/ }),

/***/ 1162:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


function checkDCE() {
  /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
  if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined' || typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== 'function') {
    return;
  }
  if (false) {}
  try {
    // Verify that the code above has been dead code eliminated (DCE'd).
    __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);
  } catch (err) {
    // DevTools shouldn't crash React, no matter what.
    // We should still report in case we break this code.
    console.error(err);
  }
}
if (true) {
  // DCE check should happen before ReactDOM bundle executes so that
  // DevTools can report bad minification during injection.
  checkDCE();
  module.exports = __webpack_require__(5478);
} else {}

/***/ }),

/***/ 1672:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


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);
}
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
Object.defineProperty(exports, "DraggableCore", ({
  enumerable: true,
  get: function get() {
    return _DraggableCore.default;
  }
}));
exports["default"] = void 0;
var React = _interopRequireWildcard(__webpack_require__(9512));
var _propTypes = _interopRequireDefault(__webpack_require__(1226));
var _reactDom = _interopRequireDefault(__webpack_require__(1162));
var _clsx2 = _interopRequireDefault(__webpack_require__(1569));
var _domFns = __webpack_require__(2156);
var _positionFns = __webpack_require__(4336);
var _shims = __webpack_require__(6776);
var _DraggableCore = _interopRequireDefault(__webpack_require__(8334));
var _log = _interopRequireDefault(__webpack_require__(6992));
var _excluded = ["axis", "bounds", "children", "defaultPosition", "defaultClassName", "defaultClassNameDragging", "defaultClassNameDragged", "position", "positionOffset", "scale"];
function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : {
    default: obj
  };
}
function _getRequireWildcardCache(nodeInterop) {
  if (typeof WeakMap !== "function") return null;
  var cacheBabelInterop = new WeakMap();
  var cacheNodeInterop = new WeakMap();
  return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
  })(nodeInterop);
}
function _interopRequireWildcard(obj, nodeInterop) {
  if (!nodeInterop && obj && obj.__esModule) {
    return obj;
  }
  if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") {
    return {
      default: obj
    };
  }
  var cache = _getRequireWildcardCache(nodeInterop);
  if (cache && cache.has(obj)) {
    return cache.get(obj);
  }
  var newObj = {};
  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
  for (var key in obj) {
    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
      if (desc && (desc.get || desc.set)) {
        Object.defineProperty(newObj, key, desc);
      } else {
        newObj[key] = obj[key];
      }
    }
  }
  newObj.default = obj;
  if (cache) {
    cache.set(obj, newObj);
  }
  return newObj;
}
function _extends() {
  _extends = Object.assign || function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];
      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }
    return target;
  };
  return _extends.apply(this, arguments);
}
function _objectWithoutProperties(source, excluded) {
  if (source == null) return {};
  var target = _objectWithoutPropertiesLoose(source, excluded);
  var key, i;
  if (Object.getOwnPropertySymbols) {
    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
    for (i = 0; i < sourceSymbolKeys.length; i++) {
      key = sourceSymbolKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
      target[key] = source[key];
    }
  }
  return target;
}
function _objectWithoutPropertiesLoose(source, excluded) {
  if (source == null) return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i;
  for (i = 0; i < sourceKeys.length; i++) {
    key = sourceKeys[i];
    if (excluded.indexOf(key) >= 0) continue;
    target[key] = source[key];
  }
  return target;
}
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 _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;
}
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;
}
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 _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };
  return _setPrototypeOf(o, p);
}
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 _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 _getPrototypeOf(o) {
  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  return _getPrototypeOf(o);
}
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;
}

//
// Define <Draggable>
//
var Draggable = /*#__PURE__*/function (_React$Component) {
  _inherits(Draggable, _React$Component);
  var _super = _createSuper(Draggable);
  function Draggable(props
  /*: DraggableProps*/) {
    var _this;
    _classCallCheck(this, Draggable);
    _this = _super.call(this, props);
    _defineProperty(_assertThisInitialized(_this), "onDragStart", function (e, coreData) {
      (0, _log.default)('Draggable: onDragStart: %j', coreData); // Short-circuit if user's callback killed it.

      var shouldStart = _this.props.onStart(e, (0, _positionFns.createDraggableData)(_assertThisInitialized(_this), coreData)); // Kills start event on core as well, so move handlers are never bound.

      if (shouldStart === false) return false;
      _this.setState({
        dragging: true,
        dragged: true
      });
    });
    _defineProperty(_assertThisInitialized(_this), "onDrag", function (e, coreData) {
      if (!_this.state.dragging) return false;
      (0, _log.default)('Draggable: onDrag: %j', coreData);
      var uiData = (0, _positionFns.createDraggableData)(_assertThisInitialized(_this), coreData);
      var newState
      /*: $Shape<DraggableState>*/ = {
        x: uiData.x,
        y: uiData.y
      }; // Keep within bounds.

      if (_this.props.bounds) {
        // Save original x and y.
        var x = newState.x,
          y = newState.y; // Add slack to the values used to calculate bound position. This will ensure that if
        // we start removing slack, the element won't react to it right away until it's been
        // completely removed.

        newState.x += _this.state.slackX;
        newState.y += _this.state.slackY; // Get bound position. This will ceil/floor the x and y within the boundaries.

        var _getBoundPosition = (0, _positionFns.getBoundPosition)(_assertThisInitialized(_this), newState.x, newState.y),
          _getBoundPosition2 = _slicedToArray(_getBoundPosition, 2),
          newStateX = _getBoundPosition2[0],
          newStateY = _getBoundPosition2[1];
        newState.x = newStateX;
        newState.y = newStateY; // Recalculate slack by noting how much was shaved by the boundPosition handler.

        newState.slackX = _this.state.slackX + (x - newState.x);
        newState.slackY = _this.state.slackY + (y - newState.y); // Update the event we fire to reflect what really happened after bounds took effect.

        uiData.x = newState.x;
        uiData.y = newState.y;
        uiData.deltaX = newState.x - _this.state.x;
        uiData.deltaY = newState.y - _this.state.y;
      } // Short-circuit if user's callback killed it.

      var shouldUpdate = _this.props.onDrag(e, uiData);
      if (shouldUpdate === false) return false;
      _this.setState(newState);
    });
    _defineProperty(_assertThisInitialized(_this), "onDragStop", function (e, coreData) {
      if (!_this.state.dragging) return false; // Short-circuit if user's callback killed it.

      var shouldContinue = _this.props.onStop(e, (0, _positionFns.createDraggableData)(_assertThisInitialized(_this), coreData));
      if (shouldContinue === false) return false;
      (0, _log.default)('Draggable: onDragStop: %j', coreData);
      var newState
      /*: $Shape<DraggableState>*/ = {
        dragging: false,
        slackX: 0,
        slackY: 0
      }; // If this is a controlled component, the result of this operation will be to
      // revert back to the old position. We expect a handler on `onDragStop`, at the least.

      var controlled = Boolean(_this.props.position);
      if (controlled) {
        var _this$props$position = _this.props.position,
          x = _this$props$position.x,
          y = _this$props$position.y;
        newState.x = x;
        newState.y = y;
      }
      _this.setState(newState);
    });
    _this.state = {
      // Whether or not we are currently dragging.
      dragging: false,
      // Whether or not we have been dragged before.
      dragged: false,
      // Current transform x and y.
      x: props.position ? props.position.x : props.defaultPosition.x,
      y: props.position ? props.position.y : props.defaultPosition.y,
      prevPropsPosition: _objectSpread({}, props.position),
      // Used for compensating for out-of-bounds drags
      slackX: 0,
      slackY: 0,
      // Can only determine if SVG after mounting
      isElementSVG: false
    };
    if (props.position && !(props.onDrag || props.onStop)) {
      // eslint-disable-next-line no-console
      console.warn('A `position` was applied to this <Draggable>, without drag handlers. This will make this ' + 'component effectively undraggable. Please attach `onDrag` or `onStop` handlers so you can adjust the ' + '`position` of this element.');
    }
    return _this;
  }
  _createClass(Draggable, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      // Check to see if the element passed is an instanceof SVGElement
      if (typeof window.SVGElement !== 'undefined' && this.findDOMNode() instanceof window.SVGElement) {
        this.setState({
          isElementSVG: true
        });
      }
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      this.setState({
        dragging: false
      }); // prevents invariant if unmounted while dragging
    } // React Strict Mode compatibility: if `nodeRef` is passed, we will use it instead of trying to find
    // the underlying DOM node ourselves. See the README for more information.
  }, {
    key: "findDOMNode",
    value: function findDOMNode() /*: ?HTMLElement*/
    {
      var _this$props$nodeRef$c, _this$props, _this$props$nodeRef;
      return (_this$props$nodeRef$c = (_this$props = this.props) === null || _this$props === void 0 ? void 0 : (_this$props$nodeRef = _this$props.nodeRef) === null || _this$props$nodeRef === void 0 ? void 0 : _this$props$nodeRef.current) !== null && _this$props$nodeRef$c !== void 0 ? _this$props$nodeRef$c : _reactDom.default.findDOMNode(this);
    }
  }, {
    key: "render",
    value: function render() /*: ReactElement<any>*/
    {
      var _clsx;
      var _this$props2 = this.props,
        axis = _this$props2.axis,
        bounds = _this$props2.bounds,
        children = _this$props2.children,
        defaultPosition = _this$props2.defaultPosition,
        defaultClassName = _this$props2.defaultClassName,
        defaultClassNameDragging = _this$props2.defaultClassNameDragging,
        defaultClassNameDragged = _this$props2.defaultClassNameDragged,
        position = _this$props2.position,
        positionOffset = _this$props2.positionOffset,
        scale = _this$props2.scale,
        draggableCoreProps = _objectWithoutProperties(_this$props2, _excluded);
      var style = {};
      var svgTransform = null; // If this is controlled, we don't want to move it - unless it's dragging.

      var controlled = Boolean(position);
      var draggable = !controlled || this.state.dragging;
      var validPosition = position || defaultPosition;
      var transformOpts = {
        // Set left if horizontal drag is enabled
        x: (0, _positionFns.canDragX)(this) && draggable ? this.state.x : validPosition.x,
        // Set top if vertical drag is enabled
        y: (0, _positionFns.canDragY)(this) && draggable ? this.state.y : validPosition.y
      }; // If this element was SVG, we use the `transform` attribute.

      if (this.state.isElementSVG) {
        svgTransform = (0, _domFns.createSVGTransform)(transformOpts, positionOffset);
      } else {
        // Add a CSS transform to move the element around. This allows us to move the element around
        // without worrying about whether or not it is relatively or absolutely positioned.
        // If the item you are dragging already has a transform set, wrap it in a <span> so <Draggable>
        // has a clean slate.
        style = (0, _domFns.createCSSTransform)(transformOpts, positionOffset);
      } // Mark with class while dragging

      var className = (0, _clsx2.default)(children.props.className || '', defaultClassName, (_clsx = {}, _defineProperty(_clsx, defaultClassNameDragging, this.state.dragging), _defineProperty(_clsx, defaultClassNameDragged, this.state.dragged), _clsx)); // Reuse the child provided
      // This makes it flexible to use whatever element is wanted (div, ul, etc)

      return /*#__PURE__*/React.createElement(_DraggableCore.default, _extends({}, draggableCoreProps, {
        onStart: this.onDragStart,
        onDrag: this.onDrag,
        onStop: this.onDragStop
      }), /*#__PURE__*/React.cloneElement(React.Children.only(children), {
        className: className,
        style: _objectSpread(_objectSpread({}, children.props.style), style),
        transform: svgTransform
      }));
    }
  }], [{
    key: "getDerivedStateFromProps",
    value:
    // React 16.3+
    // Arity (props, state)
    function getDerivedStateFromProps(_ref, _ref2) /*: ?$Shape<DraggableState>*/
    {
      var position = _ref.position;
      var prevPropsPosition = _ref2.prevPropsPosition;

      // Set x/y if a new position is provided in props that is different than the previous.
      if (position && (!prevPropsPosition || position.x !== prevPropsPosition.x || position.y !== prevPropsPosition.y)) {
        (0, _log.default)('Draggable: getDerivedStateFromProps %j', {
          position: position,
          prevPropsPosition: prevPropsPosition
        });
        return {
          x: position.x,
          y: position.y,
          prevPropsPosition: _objectSpread({}, position)
        };
      }
      return null;
    }
  }]);
  return Draggable;
}(React.Component);
exports["default"] = Draggable;
_defineProperty(Draggable, "displayName", 'Draggable');
_defineProperty(Draggable, "propTypes", _objectSpread(_objectSpread({}, _DraggableCore.default.propTypes), {}, {
  /**
   * `axis` determines which axis the draggable can move.
   *
   *  Note that all callbacks will still return data as normal. This only
   *  controls flushing to the DOM.
   *
   * 'both' allows movement horizontally and vertically.
   * 'x' limits movement to horizontal axis.
   * 'y' limits movement to vertical axis.
   * 'none' limits all movement.
   *
   * Defaults to 'both'.
   */
  axis: _propTypes.default.oneOf(['both', 'x', 'y', 'none']),
  /**
   * `bounds` determines the range of movement available to the element.
   * Available values are:
   *
   * 'parent' restricts movement within the Draggable's parent node.
   *
   * Alternatively, pass an object with the following properties, all of which are optional:
   *
   * {left: LEFT_BOUND, right: RIGHT_BOUND, bottom: BOTTOM_BOUND, top: TOP_BOUND}
   *
   * All values are in px.
   *
   * Example:
   *
   * ```jsx
   *   let App = React.createClass({
   *       render: function () {
   *         return (
   *            <Draggable bounds={{right: 300, bottom: 300}}>
   *              <div>Content</div>
   *           </Draggable>
   *         );
   *       }
   *   });
   * ```
   */
  bounds: _propTypes.default.oneOfType([_propTypes.default.shape({
    left: _propTypes.default.number,
    right: _propTypes.default.number,
    top: _propTypes.default.number,
    bottom: _propTypes.default.number
  }), _propTypes.default.string, _propTypes.default.oneOf([false])]),
  defaultClassName: _propTypes.default.string,
  defaultClassNameDragging: _propTypes.default.string,
  defaultClassNameDragged: _propTypes.default.string,
  /**
   * `defaultPosition` specifies the x and y that the dragged item should start at
   *
   * Example:
   *
   * ```jsx
   *      let App = React.createClass({
   *          render: function () {
   *              return (
   *                  <Draggable defaultPosition={{x: 25, y: 25}}>
   *                      <div>I start with transformX: 25px and transformY: 25px;</div>
   *                  </Draggable>
   *              );
   *          }
   *      });
   * ```
   */
  defaultPosition: _propTypes.default.shape({
    x: _propTypes.default.number,
    y: _propTypes.default.number
  }),
  positionOffset: _propTypes.default.shape({
    x: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string]),
    y: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string])
  }),
  /**
   * `position`, if present, defines the current position of the element.
   *
   *  This is similar to how form elements in React work - if no `position` is supplied, the component
   *  is uncontrolled.
   *
   * Example:
   *
   * ```jsx
   *      let App = React.createClass({
   *          render: function () {
   *              return (
   *                  <Draggable position={{x: 25, y: 25}}>
   *                      <div>I start with transformX: 25px and transformY: 25px;</div>
   *                  </Draggable>
   *              );
   *          }
   *      });
   * ```
   */
  position: _propTypes.default.shape({
    x: _propTypes.default.number,
    y: _propTypes.default.number
  }),
  /**
   * These properties should be defined on the child, not here.
   */
  className: _shims.dontSetMe,
  style: _shims.dontSetMe,
  transform: _shims.dontSetMe
}));
_defineProperty(Draggable, "defaultProps", _objectSpread(_objectSpread({}, _DraggableCore.default.defaultProps), {}, {
  axis: 'both',
  bounds: false,
  defaultClassName: 'react-draggable',
  defaultClassNameDragging: 'react-draggable-dragging',
  defaultClassNameDragged: 'react-draggable-dragged',
  defaultPosition: {
    x: 0,
    y: 0
  },
  scale: 1
}));

/***/ }),

/***/ 8334:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


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);
}
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var React = _interopRequireWildcard(__webpack_require__(9512));
var _propTypes = _interopRequireDefault(__webpack_require__(1226));
var _reactDom = _interopRequireDefault(__webpack_require__(1162));
var _domFns = __webpack_require__(2156);
var _positionFns = __webpack_require__(4336);
var _shims = __webpack_require__(6776);
var _log = _interopRequireDefault(__webpack_require__(6992));
function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : {
    default: obj
  };
}
function _getRequireWildcardCache(nodeInterop) {
  if (typeof WeakMap !== "function") return null;
  var cacheBabelInterop = new WeakMap();
  var cacheNodeInterop = new WeakMap();
  return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
  })(nodeInterop);
}
function _interopRequireWildcard(obj, nodeInterop) {
  if (!nodeInterop && obj && obj.__esModule) {
    return obj;
  }
  if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") {
    return {
      default: obj
    };
  }
  var cache = _getRequireWildcardCache(nodeInterop);
  if (cache && cache.has(obj)) {
    return cache.get(obj);
  }
  var newObj = {};
  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
  for (var key in obj) {
    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
      if (desc && (desc.get || desc.set)) {
        Object.defineProperty(newObj, key, desc);
      } else {
        newObj[key] = obj[key];
      }
    }
  }
  newObj.default = obj;
  if (cache) {
    cache.set(obj, newObj);
  }
  return newObj;
}
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;
}
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;
}
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 _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };
  return _setPrototypeOf(o, p);
}
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 _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 _getPrototypeOf(o) {
  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  return _getPrototypeOf(o);
}
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;
}

// Simple abstraction for dragging events names.
var eventsFor = {
  touch: {
    start: 'touchstart',
    move: 'touchmove',
    stop: 'touchend'
  },
  mouse: {
    start: 'mousedown',
    move: 'mousemove',
    stop: 'mouseup'
  }
}; // Default to mouse events.

var dragEventFor = eventsFor.mouse;
/*:: type DraggableCoreState = {
  dragging: boolean,
  lastX: number,
  lastY: number,
  touchIdentifier: ?number
};*/

/*:: export type DraggableData = {
  node: HTMLElement,
  x: number, y: number,
  deltaX: number, deltaY: number,
  lastX: number, lastY: number,
};*/

/*:: export type DraggableEventHandler = (e: MouseEvent, data: DraggableData) => void | false;*/

/*:: export type ControlPosition = {x: number, y: number};*/

/*:: export type PositionOffsetControlPosition = {x: number|string, y: number|string};*/

/*:: export type DraggableCoreDefaultProps = {
  allowAnyClick: boolean,
  disabled: boolean,
  enableUserSelectHack: boolean,
  onStart: DraggableEventHandler,
  onDrag: DraggableEventHandler,
  onStop: DraggableEventHandler,
  onMouseDown: (e: MouseEvent) => void,
  scale: number,
};*/

/*:: export type DraggableCoreProps = {
  ...DraggableCoreDefaultProps,
  cancel: string,
  children: ReactElement<any>,
  offsetParent: HTMLElement,
  grid: [number, number],
  handle: string,
  nodeRef?: ?React.ElementRef<any>,
};*/

//
// Define <DraggableCore>.
//
// <DraggableCore> is for advanced usage of <Draggable>. It maintains minimal internal state so it can
// work well with libraries that require more control over the element.
//
var DraggableCore = /*#__PURE__*/function (_React$Component) {
  _inherits(DraggableCore, _React$Component);
  var _super = _createSuper(DraggableCore);
  function DraggableCore() {
    var _this;
    _classCallCheck(this, DraggableCore);
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    _this = _super.call.apply(_super, [this].concat(args));
    _defineProperty(_assertThisInitialized(_this), "state", {
      dragging: false,
      // Used while dragging to determine deltas.
      lastX: NaN,
      lastY: NaN,
      touchIdentifier: null
    });
    _defineProperty(_assertThisInitialized(_this), "mounted", false);
    _defineProperty(_assertThisInitialized(_this), "handleDragStart", function (e) {
      // Make it possible to attach event handlers on top of this one.
      _this.props.onMouseDown(e); // Only accept left-clicks.

      if (!_this.props.allowAnyClick && typeof e.button === 'number' && e.button !== 0) return false; // Get nodes. Be sure to grab relative document (could be iframed)

      var thisNode = _this.findDOMNode();
      if (!thisNode || !thisNode.ownerDocument || !thisNode.ownerDocument.body) {
        throw new Error('<DraggableCore> not mounted on DragStart!');
      }
      var ownerDocument = thisNode.ownerDocument; // Short circuit if handle or cancel prop was provided and selector doesn't match.

      if (_this.props.disabled || !(e.target instanceof ownerDocument.defaultView.Node) || _this.props.handle && !(0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.handle, thisNode) || _this.props.cancel && (0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.cancel, thisNode)) {
        return;
      } // Prevent scrolling on mobile devices, like ipad/iphone.
      // Important that this is after handle/cancel.

      if (e.type === 'touchstart') e.preventDefault(); // Set touch identifier in component state if this is a touch event. This allows us to
      // distinguish between individual touches on multitouch screens by identifying which
      // touchpoint was set to this element.

      var touchIdentifier = (0, _domFns.getTouchIdentifier)(e);
      _this.setState({
        touchIdentifier: touchIdentifier
      }); // Get the current drag point from the event. This is used as the offset.

      var position = (0, _positionFns.getControlPosition)(e, touchIdentifier, _assertThisInitialized(_this));
      if (position == null) return; // not possible but satisfies flow

      var x = position.x,
        y = position.y; // Create an event object with all the data parents need to make a decision here.

      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y);
      (0, _log.default)('DraggableCore: handleDragStart: %j', coreEvent); // Call event handler. If it returns explicit false, cancel.

      (0, _log.default)('calling', _this.props.onStart);
      var shouldUpdate = _this.props.onStart(e, coreEvent);
      if (shouldUpdate === false || _this.mounted === false) return; // Add a style to the body to disable user-select. This prevents text from
      // being selected all over the page.

      if (_this.props.enableUserSelectHack) (0, _domFns.addUserSelectStyles)(ownerDocument); // Initiate dragging. Set the current x and y as offsets
      // so we know how much we've moved during the drag. This allows us
      // to drag elements around even if they have been moved, without issue.

      _this.setState({
        dragging: true,
        lastX: x,
        lastY: y
      }); // Add events to the document directly so we catch when the user's mouse/touch moves outside of
      // this element. We use different events depending on whether or not we have detected that this
      // is a touch-capable device.

      (0, _domFns.addEvent)(ownerDocument, dragEventFor.move, _this.handleDrag);
      (0, _domFns.addEvent)(ownerDocument, dragEventFor.stop, _this.handleDragStop);
    });
    _defineProperty(_assertThisInitialized(_this), "handleDrag", function (e) {
      // Get the current drag point from the event. This is used as the offset.
      var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _assertThisInitialized(_this));
      if (position == null) return;
      var x = position.x,
        y = position.y; // Snap to grid if prop has been provided

      if (Array.isArray(_this.props.grid)) {
        var deltaX = x - _this.state.lastX,
          deltaY = y - _this.state.lastY;
        var _snapToGrid = (0, _positionFns.snapToGrid)(_this.props.grid, deltaX, deltaY);
        var _snapToGrid2 = _slicedToArray(_snapToGrid, 2);
        deltaX = _snapToGrid2[0];
        deltaY = _snapToGrid2[1];
        if (!deltaX && !deltaY) return; // skip useless drag

        x = _this.state.lastX + deltaX, y = _this.state.lastY + deltaY;
      }
      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y);
      (0, _log.default)('DraggableCore: handleDrag: %j', coreEvent); // Call event handler. If it returns explicit false, trigger end.

      var shouldUpdate = _this.props.onDrag(e, coreEvent);
      if (shouldUpdate === false || _this.mounted === false) {
        try {
          // $FlowIgnore
          _this.handleDragStop(new MouseEvent('mouseup'));
        } catch (err) {
          // Old browsers
          var event = document.createEvent('MouseEvents')
          /*: any*/

          /*: MouseTouchEvent*/; // I see why this insanity was deprecated
          // $FlowIgnore

          event.initMouseEvent('mouseup', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
          _this.handleDragStop(event);
        }
        return;
      }
      _this.setState({
        lastX: x,
        lastY: y
      });
    });
    _defineProperty(_assertThisInitialized(_this), "handleDragStop", function (e) {
      if (!_this.state.dragging) return;
      var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _assertThisInitialized(_this));
      if (position == null) return;
      var x = position.x,
        y = position.y; // Snap to grid if prop has been provided

      if (Array.isArray(_this.props.grid)) {
        var deltaX = x - _this.state.lastX || 0;
        var deltaY = y - _this.state.lastY || 0;
        var _snapToGrid3 = (0, _positionFns.snapToGrid)(_this.props.grid, deltaX, deltaY);
        var _snapToGrid4 = _slicedToArray(_snapToGrid3, 2);
        deltaX = _snapToGrid4[0];
        deltaY = _snapToGrid4[1];
        x = _this.state.lastX + deltaX, y = _this.state.lastY + deltaY;
      }
      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y); // Call event handler

      var shouldContinue = _this.props.onStop(e, coreEvent);
      if (shouldContinue === false || _this.mounted === false) return false;
      var thisNode = _this.findDOMNode();
      if (thisNode) {
        // Remove user-select hack
        if (_this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(thisNode.ownerDocument);
      }
      (0, _log.default)('DraggableCore: handleDragStop: %j', coreEvent); // Reset the el.

      _this.setState({
        dragging: false,
        lastX: NaN,
        lastY: NaN
      });
      if (thisNode) {
        // Remove event handlers
        (0, _log.default)('DraggableCore: Removing handlers');
        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.move, _this.handleDrag);
        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.stop, _this.handleDragStop);
      }
    });
    _defineProperty(_assertThisInitialized(_this), "onMouseDown", function (e) {
      dragEventFor = eventsFor.mouse; // on touchscreen laptops we could switch back to mouse

      return _this.handleDragStart(e);
    });
    _defineProperty(_assertThisInitialized(_this), "onMouseUp", function (e) {
      dragEventFor = eventsFor.mouse;
      return _this.handleDragStop(e);
    });
    _defineProperty(_assertThisInitialized(_this), "onTouchStart", function (e) {
      // We're on a touch device now, so change the event handlers
      dragEventFor = eventsFor.touch;
      return _this.handleDragStart(e);
    });
    _defineProperty(_assertThisInitialized(_this), "onTouchEnd", function (e) {
      // We're on a touch device now, so change the event handlers
      dragEventFor = eventsFor.touch;
      return _this.handleDragStop(e);
    });
    return _this;
  }
  _createClass(DraggableCore, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      this.mounted = true; // Touch handlers must be added with {passive: false} to be cancelable.
      // https://developers.google.com/web/updates/2017/01/scrolling-intervention

      var thisNode = this.findDOMNode();
      if (thisNode) {
        (0, _domFns.addEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {
          passive: false
        });
      }
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      this.mounted = false; // Remove any leftover event handlers. Remove both touch and mouse handlers in case
      // some browser quirk caused a touch event to fire during a mouse move, or vice versa.

      var thisNode = this.findDOMNode();
      if (thisNode) {
        var ownerDocument = thisNode.ownerDocument;
        (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.move, this.handleDrag);
        (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.move, this.handleDrag);
        (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.stop, this.handleDragStop);
        (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.stop, this.handleDragStop);
        (0, _domFns.removeEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {
          passive: false
        });
        if (this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(ownerDocument);
      }
    } // React Strict Mode compatibility: if `nodeRef` is passed, we will use it instead of trying to find
    // the underlying DOM node ourselves. See the README for more information.
  }, {
    key: "findDOMNode",
    value: function findDOMNode() /*: ?HTMLElement*/
    {
      var _this$props, _this$props2, _this$props2$nodeRef;
      return (_this$props = this.props) !== null && _this$props !== void 0 && _this$props.nodeRef ? (_this$props2 = this.props) === null || _this$props2 === void 0 ? void 0 : (_this$props2$nodeRef = _this$props2.nodeRef) === null || _this$props2$nodeRef === void 0 ? void 0 : _this$props2$nodeRef.current : _reactDom.default.findDOMNode(this);
    }
  }, {
    key: "render",
    value: function render() /*: React.Element<any>*/
    {
      // Reuse the child provided
      // This makes it flexible to use whatever element is wanted (div, ul, etc)
      return /*#__PURE__*/React.cloneElement(React.Children.only(this.props.children), {
        // Note: mouseMove handler is attached to document so it will still function
        // when the user drags quickly and leaves the bounds of the element.
        onMouseDown: this.onMouseDown,
        onMouseUp: this.onMouseUp,
        // onTouchStart is added on `componentDidMount` so they can be added with
        // {passive: false}, which allows it to cancel. See
        // https://developers.google.com/web/updates/2017/01/scrolling-intervention
        onTouchEnd: this.onTouchEnd
      });
    }
  }]);
  return DraggableCore;
}(React.Component);
exports["default"] = DraggableCore;
_defineProperty(DraggableCore, "displayName", 'DraggableCore');
_defineProperty(DraggableCore, "propTypes", {
  /**
   * `allowAnyClick` allows dragging using any mouse button.
   * By default, we only accept the left button.
   *
   * Defaults to `false`.
   */
  allowAnyClick: _propTypes.default.bool,
  /**
   * `disabled`, if true, stops the <Draggable> from dragging. All handlers,
   * with the exception of `onMouseDown`, will not fire.
   */
  disabled: _propTypes.default.bool,
  /**
   * By default, we add 'user-select:none' attributes to the document body
   * to prevent ugly text selection during drag. If this is causing problems
   * for your app, set this to `false`.
   */
  enableUserSelectHack: _propTypes.default.bool,
  /**
   * `offsetParent`, if set, uses the passed DOM node to compute drag offsets
   * instead of using the parent node.
   */
  offsetParent: function offsetParent(props
  /*: DraggableCoreProps*/, propName
  /*: $Keys<DraggableCoreProps>*/) {
    if (props[propName] && props[propName].nodeType !== 1) {
      throw new Error('Draggable\'s offsetParent must be a DOM Node.');
    }
  },
  /**
   * `grid` specifies the x and y that dragging should snap to.
   */
  grid: _propTypes.default.arrayOf(_propTypes.default.number),
  /**
   * `handle` specifies a selector to be used as the handle that initiates drag.
   *
   * Example:
   *
   * ```jsx
   *   let App = React.createClass({
   *       render: function () {
   *         return (
   *            <Draggable handle=".handle">
   *              <div>
   *                  <div className="handle">Click me to drag</div>
   *                  <div>This is some other content</div>
   *              </div>
   *           </Draggable>
   *         );
   *       }
   *   });
   * ```
   */
  handle: _propTypes.default.string,
  /**
   * `cancel` specifies a selector to be used to prevent drag initialization.
   *
   * Example:
   *
   * ```jsx
   *   let App = React.createClass({
   *       render: function () {
   *           return(
   *               <Draggable cancel=".cancel">
   *                   <div>
   *                     <div className="cancel">You can't drag from here</div>
   *                     <div>Dragging here works fine</div>
   *                   </div>
   *               </Draggable>
   *           );
   *       }
   *   });
   * ```
   */
  cancel: _propTypes.default.string,
  /* If running in React Strict mode, ReactDOM.findDOMNode() is deprecated.
   * Unfortunately, in order for <Draggable> to work properly, we need raw access
   * to the underlying DOM node. If you want to avoid the warning, pass a `nodeRef`
   * as in this example:
   *
   * function MyComponent() {
   *   const nodeRef = React.useRef(null);
   *   return (
   *     <Draggable nodeRef={nodeRef}>
   *       <div ref={nodeRef}>Example Target</div>
   *     </Draggable>
   *   );
   * }
   *
   * This can be used for arbitrarily nested components, so long as the ref ends up
   * pointing to the actual child DOM node and not a custom component.
   */
  nodeRef: _propTypes.default.object,
  /**
   * Called when dragging starts.
   * If this function returns the boolean false, dragging will be canceled.
   */
  onStart: _propTypes.default.func,
  /**
   * Called while dragging.
   * If this function returns the boolean false, dragging will be canceled.
   */
  onDrag: _propTypes.default.func,
  /**
   * Called when dragging stops.
   * If this function returns the boolean false, the drag will remain active.
   */
  onStop: _propTypes.default.func,
  /**
   * A workaround option which can be passed if onMouseDown needs to be accessed,
   * since it'll always be blocked (as there is internal use of onMouseDown)
   */
  onMouseDown: _propTypes.default.func,
  /**
   * `scale`, if set, applies scaling while dragging an element
   */
  scale: _propTypes.default.number,
  /**
   * These properties should be defined on the child, not here.
   */
  className: _shims.dontSetMe,
  style: _shims.dontSetMe,
  transform: _shims.dontSetMe
});
_defineProperty(DraggableCore, "defaultProps", {
  allowAnyClick: false,
  // by default only accept left click
  disabled: false,
  enableUserSelectHack: true,
  onStart: function onStart() {},
  onDrag: function onDrag() {},
  onStop: function onStop() {},
  onMouseDown: function onMouseDown() {},
  scale: 1
});

/***/ }),

/***/ 1710:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var _require = __webpack_require__(1672),
  Draggable = _require.default,
  DraggableCore = _require.DraggableCore; // Previous versions of this lib exported <Draggable> as the root export. As to no-// them, or TypeScript, we export *both* as the root and as 'default'.
// See https://github.com/mzabriskie/react-draggable/pull/254
// and https://github.com/mzabriskie/react-draggable/issues/266

module.exports = Draggable;
module.exports["default"] = Draggable;
module.exports.DraggableCore = DraggableCore;

/***/ }),

/***/ 2156:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


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);
}
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.addClassName = addClassName;
exports.addEvent = addEvent;
exports.addUserSelectStyles = addUserSelectStyles;
exports.createCSSTransform = createCSSTransform;
exports.createSVGTransform = createSVGTransform;
exports.getTouch = getTouch;
exports.getTouchIdentifier = getTouchIdentifier;
exports.getTranslation = getTranslation;
exports.innerHeight = innerHeight;
exports.innerWidth = innerWidth;
exports.matchesSelector = matchesSelector;
exports.matchesSelectorAndParentsTo = matchesSelectorAndParentsTo;
exports.offsetXYFromParent = offsetXYFromParent;
exports.outerHeight = outerHeight;
exports.outerWidth = outerWidth;
exports.removeClassName = removeClassName;
exports.removeEvent = removeEvent;
exports.removeUserSelectStyles = removeUserSelectStyles;
var _shims = __webpack_require__(6776);
var _getPrefix = _interopRequireWildcard(__webpack_require__(8907));
function _getRequireWildcardCache(nodeInterop) {
  if (typeof WeakMap !== "function") return null;
  var cacheBabelInterop = new WeakMap();
  var cacheNodeInterop = new WeakMap();
  return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
  })(nodeInterop);
}
function _interopRequireWildcard(obj, nodeInterop) {
  if (!nodeInterop && obj && obj.__esModule) {
    return obj;
  }
  if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") {
    return {
      default: obj
    };
  }
  var cache = _getRequireWildcardCache(nodeInterop);
  if (cache && cache.has(obj)) {
    return cache.get(obj);
  }
  var newObj = {};
  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
  for (var key in obj) {
    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
      if (desc && (desc.get || desc.set)) {
        Object.defineProperty(newObj, key, desc);
      } else {
        newObj[key] = obj[key];
      }
    }
  }
  newObj.default = obj;
  if (cache) {
    cache.set(obj, newObj);
  }
  return newObj;
}
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;
}
var matchesSelectorFunc = '';
function matchesSelector(el
/*: Node*/, selector
/*: string*/) /*: boolean*/
{
  if (!matchesSelectorFunc) {
    matchesSelectorFunc = (0, _shims.findInArray)(['matches', 'webkitMatchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector'], function (method) {
      // $FlowIgnore: Doesn't think elements are indexable
      return (0, _shims.isFunction)(el[method]);
    });
  } // Might not be found entirely (not an Element?) - in that case, bail
  // $FlowIgnore: Doesn't think elements are indexable

  if (!(0, _shims.isFunction)(el[matchesSelectorFunc])) return false; // $FlowIgnore: Doesn't think elements are indexable

  return el[matchesSelectorFunc](selector);
} // Works up the tree to the draggable itself attempting to match selector.

function matchesSelectorAndParentsTo(el
/*: Node*/, selector
/*: string*/, baseNode
/*: Node*/) /*: boolean*/
{
  var node = el;
  do {
    if (matchesSelector(node, selector)) return true;
    if (node === baseNode) return false;
    node = node.parentNode;
  } while (node);
  return false;
}
function addEvent(el
/*: ?Node*/, event
/*: string*/, handler
/*: Function*/, inputOptions
/*: Object*/) /*: void*/
{
  if (!el) return;
  var options = _objectSpread({
    capture: true
  }, inputOptions); // $FlowIgnore[method-unbinding]

  if (el.addEventListener) {
    el.addEventListener(event, handler, options);
  } else if (el.attachEvent) {
    el.attachEvent('on' + event, handler);
  } else {
    // $FlowIgnore: Doesn't think elements are indexable
    el['on' + event] = handler;
  }
}
function removeEvent(el
/*: ?Node*/, event
/*: string*/, handler
/*: Function*/, inputOptions
/*: Object*/) /*: void*/
{
  if (!el) return;
  var options = _objectSpread({
    capture: true
  }, inputOptions); // $FlowIgnore[method-unbinding]

  if (el.removeEventListener) {
    el.removeEventListener(event, handler, options);
  } else if (el.detachEvent) {
    el.detachEvent('on' + event, handler);
  } else {
    // $FlowIgnore: Doesn't think elements are indexable
    el['on' + event] = null;
  }
}
function outerHeight(node
/*: HTMLElement*/) /*: number*/
{
  // This is deliberately excluding margin for our calculations, since we are using
  // offsetTop which is including margin. See getBoundPosition
  var height = node.clientHeight;
  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
  height += (0, _shims.int)(computedStyle.borderTopWidth);
  height += (0, _shims.int)(computedStyle.borderBottomWidth);
  return height;
}
function outerWidth(node
/*: HTMLElement*/) /*: number*/
{
  // This is deliberately excluding margin for our calculations, since we are using
  // offsetLeft which is including margin. See getBoundPosition
  var width = node.clientWidth;
  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
  width += (0, _shims.int)(computedStyle.borderLeftWidth);
  width += (0, _shims.int)(computedStyle.borderRightWidth);
  return width;
}
function innerHeight(node
/*: HTMLElement*/) /*: number*/
{
  var height = node.clientHeight;
  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
  height -= (0, _shims.int)(computedStyle.paddingTop);
  height -= (0, _shims.int)(computedStyle.paddingBottom);
  return height;
}
function innerWidth(node
/*: HTMLElement*/) /*: number*/
{
  var width = node.clientWidth;
  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
  width -= (0, _shims.int)(computedStyle.paddingLeft);
  width -= (0, _shims.int)(computedStyle.paddingRight);
  return width;
}
/*:: interface EventWithOffset {
  clientX: number, clientY: number
}*/

// Get from offsetParent
function offsetXYFromParent(evt
/*: EventWithOffset*/, offsetParent
/*: HTMLElement*/, scale
/*: number*/) /*: ControlPosition*/
{
  var isBody = offsetParent === offsetParent.ownerDocument.body;
  var offsetParentRect = isBody ? {
    left: 0,
    top: 0
  } : offsetParent.getBoundingClientRect();
  var x = (evt.clientX + offsetParent.scrollLeft - offsetParentRect.left) / scale;
  var y = (evt.clientY + offsetParent.scrollTop - offsetParentRect.top) / scale;
  return {
    x: x,
    y: y
  };
}
function createCSSTransform(controlPos
/*: ControlPosition*/, positionOffset
/*: PositionOffsetControlPosition*/) /*: Object*/
{
  var translation = getTranslation(controlPos, positionOffset, 'px');
  return _defineProperty({}, (0, _getPrefix.browserPrefixToKey)('transform', _getPrefix.default), translation);
}
function createSVGTransform(controlPos
/*: ControlPosition*/, positionOffset
/*: PositionOffsetControlPosition*/) /*: string*/
{
  var translation = getTranslation(controlPos, positionOffset, '');
  return translation;
}
function getTranslation(_ref2, positionOffset
/*: PositionOffsetControlPosition*/, unitSuffix
/*: string*/) /*: string*/
{
  var x = _ref2.x,
    y = _ref2.y;
  var translation = "translate(".concat(x).concat(unitSuffix, ",").concat(y).concat(unitSuffix, ")");
  if (positionOffset) {
    var defaultX = "".concat(typeof positionOffset.x === 'string' ? positionOffset.x : positionOffset.x + unitSuffix);
    var defaultY = "".concat(typeof positionOffset.y === 'string' ? positionOffset.y : positionOffset.y + unitSuffix);
    translation = "translate(".concat(defaultX, ", ").concat(defaultY, ")") + translation;
  }
  return translation;
}
function getTouch(e
/*: MouseTouchEvent*/, identifier
/*: number*/) /*: ?{clientX: number, clientY: number}*/
{
  return e.targetTouches && (0, _shims.findInArray)(e.targetTouches, function (t) {
    return identifier === t.identifier;
  }) || e.changedTouches && (0, _shims.findInArray)(e.changedTouches, function (t) {
    return identifier === t.identifier;
  });
}
function getTouchIdentifier(e
/*: MouseTouchEvent*/) /*: ?number*/
{
  if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;
  if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;
} // User-select Hacks:
//
// Useful for preventing blue highlights all over everything when dragging.
// Note we're passing `document` b/c we could be iframed

function addUserSelectStyles(doc
/*: ?Document*/) {
  if (!doc) return;
  var styleEl = doc.getElementById('react-draggable-style-el');
  if (!styleEl) {
    styleEl = doc.createElement('style');
    styleEl.type = 'text/css';
    styleEl.id = 'react-draggable-style-el';
    styleEl.innerHTML = '.react-draggable-transparent-selection *::-moz-selection {all: inherit;}\n';
    styleEl.innerHTML += '.react-draggable-transparent-selection *::selection {all: inherit;}\n';
    doc.getElementsByTagName('head')[0].appendChild(styleEl);
  }
  if (doc.body) addClassName(doc.body, 'react-draggable-transparent-selection');
}
function removeUserSelectStyles(doc
/*: ?Document*/) {
  if (!doc) return;
  try {
    if (doc.body) removeClassName(doc.body, 'react-draggable-transparent-selection'); // $FlowIgnore: IE

    if (doc.selection) {
      // $FlowIgnore: IE
      doc.selection.empty();
    } else {
      // Remove selection caused by scroll, unless it's a focused input
      // (we use doc.defaultView in case we're in an iframe)
      var selection = (doc.defaultView || window).getSelection();
      if (selection && selection.type !== 'Caret') {
        selection.removeAllRanges();
      }
    }
  } catch (e) {// probably IE
  }
}
function addClassName(el
/*: HTMLElement*/, className
/*: string*/) {
  if (el.classList) {
    el.classList.add(className);
  } else {
    if (!el.className.match(new RegExp("(?:^|\\s)".concat(className, "(?!\\S)")))) {
      el.className += " ".concat(className);
    }
  }
}
function removeClassName(el
/*: HTMLElement*/, className
/*: string*/) {
  if (el.classList) {
    el.classList.remove(className);
  } else {
    el.className = el.className.replace(new RegExp("(?:^|\\s)".concat(className, "(?!\\S)"), 'g'), '');
  }
}

/***/ }),

/***/ 8907:
/***/ (function(__unused_webpack_module, exports) {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.browserPrefixToKey = browserPrefixToKey;
exports.browserPrefixToStyle = browserPrefixToStyle;
exports["default"] = void 0;
exports.getPrefix = getPrefix;
var prefixes = ['Moz', 'Webkit', 'O', 'ms'];
function getPrefix() /*: string*/
{
  var _window$document, _window$document$docu;
  var prop
  /*: string*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';
  // Ensure we're running in an environment where there is actually a global
  // `window` obj
  if (typeof window === 'undefined') return ''; // If we're in a pseudo-browser server-side environment, this access
  // path may not exist, so bail out if it doesn't.

  var style = (_window$document = window.document) === null || _window$document === void 0 ? void 0 : (_window$document$docu = _window$document.documentElement) === null || _window$document$docu === void 0 ? void 0 : _window$document$docu.style;
  if (!style) return '';
  if (prop in style) return '';
  for (var i = 0; i < prefixes.length; i++) {
    if (browserPrefixToKey(prop, prefixes[i]) in style) return prefixes[i];
  }
  return '';
}
function browserPrefixToKey(prop
/*: string*/, prefix
/*: string*/) /*: string*/
{
  return prefix ? "".concat(prefix).concat(kebabToTitleCase(prop)) : prop;
}
function browserPrefixToStyle(prop
/*: string*/, prefix
/*: string*/) /*: string*/
{
  return prefix ? "-".concat(prefix.toLowerCase(), "-").concat(prop) : prop;
}
function kebabToTitleCase(str
/*: string*/) /*: string*/
{
  var out = '';
  var shouldCapitalize = true;
  for (var i = 0; i < str.length; i++) {
    if (shouldCapitalize) {
      out += str[i].toUpperCase();
      shouldCapitalize = false;
    } else if (str[i] === '-') {
      shouldCapitalize = true;
    } else {
      out += str[i];
    }
  }
  return out;
} // Default export is the prefix itself, like 'Moz', 'Webkit', etc
// Note that you may have to re-test for certain things; for instance, Chrome 50
// can handle unprefixed `transform`, but not unprefixed `user-select`

var _default = getPrefix()
/*: string*/;

exports["default"] = _default;

/***/ }),

/***/ 6992:
/***/ (function(__unused_webpack_module, exports) {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = log;

/*eslint no-console:0*/
function log() {
  var _console;
  if (false) {}
}

/***/ }),

/***/ 4336:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.canDragX = canDragX;
exports.canDragY = canDragY;
exports.createCoreData = createCoreData;
exports.createDraggableData = createDraggableData;
exports.getBoundPosition = getBoundPosition;
exports.getControlPosition = getControlPosition;
exports.snapToGrid = snapToGrid;
var _shims = __webpack_require__(6776);
var _domFns = __webpack_require__(2156);
function getBoundPosition(draggable
/*: Draggable*/, x
/*: number*/, y
/*: number*/) /*: [number, number]*/
{
  // If no bounds, short-circuit and move on
  if (!draggable.props.bounds) return [x, y]; // Clone new bounds

  var bounds = draggable.props.bounds;
  bounds = typeof bounds === 'string' ? bounds : cloneBounds(bounds);
  var node = findDOMNode(draggable);
  if (typeof bounds === 'string') {
    var ownerDocument = node.ownerDocument;
    var ownerWindow = ownerDocument.defaultView;
    var boundNode;
    if (bounds === 'parent') {
      boundNode = node.parentNode;
    } else {
      boundNode = ownerDocument.querySelector(bounds);
    }
    if (!(boundNode instanceof ownerWindow.HTMLElement)) {
      throw new Error('Bounds selector "' + bounds + '" could not find an element.');
    }
    var boundNodeEl
    /*: HTMLElement*/ = boundNode; // for Flow, can't seem to refine correctly

    var nodeStyle = ownerWindow.getComputedStyle(node);
    var boundNodeStyle = ownerWindow.getComputedStyle(boundNodeEl); // Compute bounds. This is a pain with padding and offsets but this gets it exactly right.

    bounds = {
      left: -node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingLeft) + (0, _shims.int)(nodeStyle.marginLeft),
      top: -node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingTop) + (0, _shims.int)(nodeStyle.marginTop),
      right: (0, _domFns.innerWidth)(boundNodeEl) - (0, _domFns.outerWidth)(node) - node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingRight) - (0, _shims.int)(nodeStyle.marginRight),
      bottom: (0, _domFns.innerHeight)(boundNodeEl) - (0, _domFns.outerHeight)(node) - node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingBottom) - (0, _shims.int)(nodeStyle.marginBottom)
    };
  } // Keep x and y below right and bottom limits...

  if ((0, _shims.isNum)(bounds.right)) x = Math.min(x, bounds.right);
  if ((0, _shims.isNum)(bounds.bottom)) y = Math.min(y, bounds.bottom); // But above left and top limits.

  if ((0, _shims.isNum)(bounds.left)) x = Math.max(x, bounds.left);
  if ((0, _shims.isNum)(bounds.top)) y = Math.max(y, bounds.top);
  return [x, y];
}
function snapToGrid(grid
/*: [number, number]*/, pendingX
/*: number*/, pendingY
/*: number*/) /*: [number, number]*/
{
  var x = Math.round(pendingX / grid[0]) * grid[0];
  var y = Math.round(pendingY / grid[1]) * grid[1];
  return [x, y];
}
function canDragX(draggable
/*: Draggable*/) /*: boolean*/
{
  return draggable.props.axis === 'both' || draggable.props.axis === 'x';
}
function canDragY(draggable
/*: Draggable*/) /*: boolean*/
{
  return draggable.props.axis === 'both' || draggable.props.axis === 'y';
} // Get {x, y} positions from event.

function getControlPosition(e
/*: MouseTouchEvent*/, touchIdentifier
/*: ?number*/, draggableCore
/*: DraggableCore*/) /*: ?ControlPosition*/
{
  var touchObj = typeof touchIdentifier === 'number' ? (0, _domFns.getTouch)(e, touchIdentifier) : null;
  if (typeof touchIdentifier === 'number' && !touchObj) return null; // not the right touch

  var node = findDOMNode(draggableCore); // User can provide an offsetParent if desired.

  var offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;
  return (0, _domFns.offsetXYFromParent)(touchObj || e, offsetParent, draggableCore.props.scale);
} // Create an data object exposed by <DraggableCore>'s events

function createCoreData(draggable
/*: DraggableCore*/, x
/*: number*/, y
/*: number*/) /*: DraggableData*/
{
  var state = draggable.state;
  var isStart = !(0, _shims.isNum)(state.lastX);
  var node = findDOMNode(draggable);
  if (isStart) {
    // If this is our first move, use the x and y as last coords.
    return {
      node: node,
      deltaX: 0,
      deltaY: 0,
      lastX: x,
      lastY: y,
      x: x,
      y: y
    };
  } else {
    // Otherwise calculate proper values.
    return {
      node: node,
      deltaX: x - state.lastX,
      deltaY: y - state.lastY,
      lastX: state.lastX,
      lastY: state.lastY,
      x: x,
      y: y
    };
  }
} // Create an data exposed by <Draggable>'s events

function createDraggableData(draggable
/*: Draggable*/, coreData
/*: DraggableData*/) /*: DraggableData*/
{
  var scale = draggable.props.scale;
  return {
    node: coreData.node,
    x: draggable.state.x + coreData.deltaX / scale,
    y: draggable.state.y + coreData.deltaY / scale,
    deltaX: coreData.deltaX / scale,
    deltaY: coreData.deltaY / scale,
    lastX: draggable.state.x,
    lastY: draggable.state.y
  };
} // A lot faster than stringify/parse

function cloneBounds(bounds
/*: Bounds*/) /*: Bounds*/
{
  return {
    left: bounds.left,
    top: bounds.top,
    right: bounds.right,
    bottom: bounds.bottom
  };
}
function findDOMNode(draggable
/*: Draggable | DraggableCore*/) /*: HTMLElement*/
{
  var node = draggable.findDOMNode();
  if (!node) {
    throw new Error('<DraggableCore>: Unmounted during event!');
  } // $FlowIgnore we can't assert on HTMLElement due to tests... FIXME

  return node;
}

/***/ }),

/***/ 6776:
/***/ (function(__unused_webpack_module, exports) {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.dontSetMe = dontSetMe;
exports.findInArray = findInArray;
exports.int = int;
exports.isFunction = isFunction;
exports.isNum = isNum;

// @credits https://gist.github.com/rogozhnikoff/a43cfed27c41e4e68cdc
function findInArray(array
/*: Array<any> | TouchList*/, callback
/*: Function*/) /*: any*/
{
  for (var i = 0, length = array.length; i < length; i++) {
    if (callback.apply(callback, [array[i], i, array])) return array[i];
  }
}
function isFunction(func
/*: any*/) /*: boolean %checks*/
{
  // $FlowIgnore[method-unbinding]
  return typeof func === 'function' || Object.prototype.toString.call(func) === '[object Function]';
}
function isNum(num
/*: any*/) /*: boolean %checks*/
{
  return typeof num === 'number' && !isNaN(num);
}
function int(a
/*: string*/) /*: number*/
{
  return parseInt(a, 10);
}
function dontSetMe(props
/*: Object*/, propName
/*: string*/, componentName
/*: string*/) /*: ?Error*/
{
  if (props[propName]) {
    return new Error("Invalid prop ".concat(propName, " passed to ").concat(componentName, " - do not set this, set it on the child."));
  }
}

/***/ }),

/***/ 8414:
/***/ (function(__unused_webpack_module, exports) {

"use strict";
/** @license React v16.13.1
 * react-is.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */



var b = "function" === typeof Symbol && Symbol.for,
  c = b ? Symbol.for("react.element") : 60103,
  d = b ? Symbol.for("react.portal") : 60106,
  e = b ? Symbol.for("react.fragment") : 60107,
  f = b ? Symbol.for("react.strict_mode") : 60108,
  g = b ? Symbol.for("react.profiler") : 60114,
  h = b ? Symbol.for("react.provider") : 60109,
  k = b ? Symbol.for("react.context") : 60110,
  l = b ? Symbol.for("react.async_mode") : 60111,
  m = b ? Symbol.for("react.concurrent_mode") : 60111,
  n = b ? Symbol.for("react.forward_ref") : 60112,
  p = b ? Symbol.for("react.suspense") : 60113,
  q = b ? Symbol.for("react.suspense_list") : 60120,
  r = b ? Symbol.for("react.memo") : 60115,
  t = b ? Symbol.for("react.lazy") : 60116,
  v = b ? Symbol.for("react.block") : 60121,
  w = b ? Symbol.for("react.fundamental") : 60117,
  x = b ? Symbol.for("react.responder") : 60118,
  y = b ? Symbol.for("react.scope") : 60119;
function z(a) {
  if ("object" === typeof a && null !== a) {
    var u = a.$$typeof;
    switch (u) {
      case c:
        switch (a = a.type, a) {
          case l:
          case m:
          case e:
          case g:
          case f:
          case p:
            return a;
          default:
            switch (a = a && a.$$typeof, a) {
              case k:
              case n:
              case t:
              case r:
              case h:
                return a;
              default:
                return u;
            }
        }
      case d:
        return u;
    }
  }
}
function A(a) {
  return z(a) === m;
}
exports.AsyncMode = l;
exports.ConcurrentMode = m;
exports.ContextConsumer = k;
exports.ContextProvider = h;
exports.Element = c;
exports.ForwardRef = n;
exports.Fragment = e;
exports.Lazy = t;
exports.Memo = r;
exports.Portal = d;
exports.Profiler = g;
exports.StrictMode = f;
exports.Suspense = p;
exports.isAsyncMode = function (a) {
  return A(a) || z(a) === l;
};
exports.isConcurrentMode = A;
exports.isContextConsumer = function (a) {
  return z(a) === k;
};
exports.isContextProvider = function (a) {
  return z(a) === h;
};
exports.isElement = function (a) {
  return "object" === typeof a && null !== a && a.$$typeof === c;
};
exports.isForwardRef = function (a) {
  return z(a) === n;
};
exports.isFragment = function (a) {
  return z(a) === e;
};
exports.isLazy = function (a) {
  return z(a) === t;
};
exports.isMemo = function (a) {
  return z(a) === r;
};
exports.isPortal = function (a) {
  return z(a) === d;
};
exports.isProfiler = function (a) {
  return z(a) === g;
};
exports.isStrictMode = function (a) {
  return z(a) === f;
};
exports.isSuspense = function (a) {
  return z(a) === p;
};
exports.isValidElementType = function (a) {
  return "string" === typeof a || "function" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || "object" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);
};
exports.typeOf = z;

/***/ }),

/***/ 4436:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


if (true) {
  module.exports = __webpack_require__(8414);
} else {}

/***/ }),

/***/ 130:
/***/ (function(__unused_webpack_module, exports) {

"use strict";
var __webpack_unused_export__;
/**
 * @license React
 * react-is.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */


var b = Symbol.for("react.element"),
  c = Symbol.for("react.portal"),
  d = Symbol.for("react.fragment"),
  e = Symbol.for("react.strict_mode"),
  f = Symbol.for("react.profiler"),
  g = Symbol.for("react.provider"),
  h = Symbol.for("react.context"),
  k = Symbol.for("react.server_context"),
  l = Symbol.for("react.forward_ref"),
  m = Symbol.for("react.suspense"),
  n = Symbol.for("react.suspense_list"),
  p = Symbol.for("react.memo"),
  q = Symbol.for("react.lazy"),
  t = Symbol.for("react.offscreen"),
  u;
u = Symbol.for("react.module.reference");
function v(a) {
  if ("object" === typeof a && null !== a) {
    var r = a.$$typeof;
    switch (r) {
      case b:
        switch (a = a.type, a) {
          case d:
          case f:
          case e:
          case m:
          case n:
            return a;
          default:
            switch (a = a && a.$$typeof, a) {
              case k:
              case h:
              case l:
              case q:
              case p:
              case g:
                return a;
              default:
                return r;
            }
        }
      case c:
        return r;
    }
  }
}
__webpack_unused_export__ = h;
__webpack_unused_export__ = g;
__webpack_unused_export__ = b;
__webpack_unused_export__ = l;
__webpack_unused_export__ = d;
__webpack_unused_export__ = q;
__webpack_unused_export__ = p;
__webpack_unused_export__ = c;
__webpack_unused_export__ = f;
__webpack_unused_export__ = e;
__webpack_unused_export__ = m;
__webpack_unused_export__ = n;
__webpack_unused_export__ = function () {
  return !1;
};
__webpack_unused_export__ = function () {
  return !1;
};
__webpack_unused_export__ = function (a) {
  return v(a) === h;
};
__webpack_unused_export__ = function (a) {
  return v(a) === g;
};
__webpack_unused_export__ = function (a) {
  return "object" === typeof a && null !== a && a.$$typeof === b;
};
__webpack_unused_export__ = function (a) {
  return v(a) === l;
};
__webpack_unused_export__ = function (a) {
  return v(a) === d;
};
__webpack_unused_export__ = function (a) {
  return v(a) === q;
};
__webpack_unused_export__ = function (a) {
  return v(a) === p;
};
__webpack_unused_export__ = function (a) {
  return v(a) === c;
};
__webpack_unused_export__ = function (a) {
  return v(a) === f;
};
__webpack_unused_export__ = function (a) {
  return v(a) === e;
};
__webpack_unused_export__ = function (a) {
  return v(a) === m;
};
__webpack_unused_export__ = function (a) {
  return v(a) === n;
};
exports.isValidElementType = function (a) {
  return "string" === typeof a || "function" === typeof a || a === d || a === f || a === e || a === m || a === n || a === t || "object" === typeof a && null !== a && (a.$$typeof === q || a.$$typeof === p || a.$$typeof === g || a.$$typeof === h || a.$$typeof === l || a.$$typeof === u || void 0 !== a.getModuleId) ? !0 : !1;
};
exports.typeOf = v;

/***/ }),

/***/ 9827:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


if (true) {
  module.exports = __webpack_require__(130);
} else {}

/***/ }),

/***/ 7939:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


exports.__esModule = true;
exports["default"] = void 0;
var React = _interopRequireWildcard(__webpack_require__(9512));
var _reactDraggable = __webpack_require__(1710);
var _utils = __webpack_require__(7748);
var _propTypes = __webpack_require__(3691);
var _excluded = ["children", "className", "draggableOpts", "width", "height", "handle", "handleSize", "lockAspectRatio", "axis", "minConstraints", "maxConstraints", "onResize", "onResizeStop", "onResizeStart", "resizeHandles", "transformScale"];
function _getRequireWildcardCache(nodeInterop) {
  if (typeof WeakMap !== "function") return null;
  var cacheBabelInterop = new WeakMap();
  var cacheNodeInterop = new WeakMap();
  return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
  })(nodeInterop);
}
function _interopRequireWildcard(obj, nodeInterop) {
  if (!nodeInterop && obj && obj.__esModule) {
    return obj;
  }
  if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
    return {
      default: obj
    };
  }
  var cache = _getRequireWildcardCache(nodeInterop);
  if (cache && cache.has(obj)) {
    return cache.get(obj);
  }
  var newObj = {};
  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
  for (var key in obj) {
    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
      if (desc && (desc.get || desc.set)) {
        Object.defineProperty(newObj, key, desc);
      } else {
        newObj[key] = obj[key];
      }
    }
  }
  newObj.default = obj;
  if (cache) {
    cache.set(obj, newObj);
  }
  return newObj;
}
function _extends() {
  _extends = Object.assign ? Object.assign.bind() : function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];
      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }
    return target;
  };
  return _extends.apply(this, arguments);
}
function _objectWithoutPropertiesLoose(source, excluded) {
  if (source == null) return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i;
  for (i = 0; i < sourceKeys.length; i++) {
    key = sourceKeys[i];
    if (excluded.indexOf(key) >= 0) continue;
    target[key] = source[key];
  }
  return target;
}
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) {
  key = _toPropertyKey(key);
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }
  return obj;
}
function _toPropertyKey(arg) {
  var key = _toPrimitive(arg, "string");
  return typeof key === "symbol" ? key : String(key);
}
function _toPrimitive(input, hint) {
  if (typeof input !== "object" || input === null) return input;
  var prim = input[Symbol.toPrimitive];
  if (prim !== undefined) {
    var res = prim.call(input, hint || "default");
    if (typeof res !== "object") return res;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return (hint === "string" ? String : Number)(input);
}
function _inheritsLoose(subClass, superClass) {
  subClass.prototype = Object.create(superClass.prototype);
  subClass.prototype.constructor = subClass;
  _setPrototypeOf(subClass, superClass);
}
function _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };
  return _setPrototypeOf(o, p);
}
// The base <Resizable> component.
// This component does not have state and relies on the parent to set its props based on callback data.
var Resizable = /*#__PURE__*/function (_React$Component) {
  _inheritsLoose(Resizable, _React$Component);
  function Resizable() {
    var _this;
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
    _this.handleRefs = {};
    _this.lastHandleRect = null;
    _this.slack = null;
    return _this;
  }
  var _proto = Resizable.prototype;
  _proto.componentWillUnmount = function componentWillUnmount() {
    this.resetData();
  };
  _proto.resetData = function resetData() {
    this.lastHandleRect = this.slack = null;
  }

  // Clamp width and height within provided constraints
  ;

  _proto.runConstraints = function runConstraints(width, height) {
    var _this$props = this.props,
      minConstraints = _this$props.minConstraints,
      maxConstraints = _this$props.maxConstraints,
      lockAspectRatio = _this$props.lockAspectRatio;
    // short circuit
    if (!minConstraints && !maxConstraints && !lockAspectRatio) return [width, height];

    // If constraining to min and max, we need to also fit width and height to aspect ratio.
    if (lockAspectRatio) {
      var ratio = this.props.width / this.props.height;
      var deltaW = width - this.props.width;
      var deltaH = height - this.props.height;

      // Find which coordinate was greater and should push the other toward it.
      // E.g.:
      // ratio = 1, deltaW = 10, deltaH = 5, deltaH should become 10.
      // ratio = 2, deltaW = 10, deltaH = 6, deltaW should become 12.
      if (Math.abs(deltaW) > Math.abs(deltaH * ratio)) {
        height = width / ratio;
      } else {
        width = height * ratio;
      }
    }
    var oldW = width,
      oldH = height;

    // Add slack to the values used to calculate bound position. This will ensure that if
    // we start removing slack, the element won't react to it right away until it's been
    // completely removed.
    var _ref = this.slack || [0, 0],
      slackW = _ref[0],
      slackH = _ref[1];
    width += slackW;
    height += slackH;
    if (minConstraints) {
      width = Math.max(minConstraints[0], width);
      height = Math.max(minConstraints[1], height);
    }
    if (maxConstraints) {
      width = Math.min(maxConstraints[0], width);
      height = Math.min(maxConstraints[1], height);
    }

    // If the width or height changed, we must have introduced some slack. Record it for the next iteration.
    this.slack = [slackW + (oldW - width), slackH + (oldH - height)];
    return [width, height];
  }

  /**
   * Wrapper around drag events to provide more useful data.
   *
   * @param  {String} handlerName Handler name to wrap.
   * @return {Function}           Handler function.
   */;
  _proto.resizeHandler = function resizeHandler(handlerName, axis) {
    var _this2 = this;
    return function (e, _ref2) {
      var node = _ref2.node,
        deltaX = _ref2.deltaX,
        deltaY = _ref2.deltaY;
      // Reset data in case it was left over somehow (should not be possible)
      if (handlerName === 'onResizeStart') _this2.resetData();

      // Axis restrictions
      var canDragX = (_this2.props.axis === 'both' || _this2.props.axis === 'x') && axis !== 'n' && axis !== 's';
      var canDragY = (_this2.props.axis === 'both' || _this2.props.axis === 'y') && axis !== 'e' && axis !== 'w';
      // No dragging possible.
      if (!canDragX && !canDragY) return;

      // Decompose axis for later use
      var axisV = axis[0];
      var axisH = axis[axis.length - 1]; // intentionally not axis[1], so that this catches axis === 'w' for example

      // Track the element being dragged to account for changes in position.
      // If a handle's position is changed between callbacks, we need to factor this in to the next callback.
      // Failure to do so will cause the element to "skip" when resized upwards or leftwards.
      var handleRect = node.getBoundingClientRect();
      if (_this2.lastHandleRect != null) {
        // If the handle has repositioned on either axis since last render,
        // we need to increase our callback values by this much.
        // Only checking 'n', 'w' since resizing by 's', 'w' won't affect the overall position on page,
        if (axisH === 'w') {
          var deltaLeftSinceLast = handleRect.left - _this2.lastHandleRect.left;
          deltaX += deltaLeftSinceLast;
        }
        if (axisV === 'n') {
          var deltaTopSinceLast = handleRect.top - _this2.lastHandleRect.top;
          deltaY += deltaTopSinceLast;
        }
      }
      // Storage of last rect so we know how much it has really moved.
      _this2.lastHandleRect = handleRect;

      // Reverse delta if using top or left drag handles.
      if (axisH === 'w') deltaX = -deltaX;
      if (axisV === 'n') deltaY = -deltaY;

      // Update w/h by the deltas. Also factor in transformScale.
      var width = _this2.props.width + (canDragX ? deltaX / _this2.props.transformScale : 0);
      var height = _this2.props.height + (canDragY ? deltaY / _this2.props.transformScale : 0);

      // Run user-provided constraints.
      var _this2$runConstraints = _this2.runConstraints(width, height);
      width = _this2$runConstraints[0];
      height = _this2$runConstraints[1];
      var dimensionsChanged = width !== _this2.props.width || height !== _this2.props.height;

      // Call user-supplied callback if present.
      var cb = typeof _this2.props[handlerName] === 'function' ? _this2.props[handlerName] : null;
      // Don't call 'onResize' if dimensions haven't changed.
      var shouldSkipCb = handlerName === 'onResize' && !dimensionsChanged;
      if (cb && !shouldSkipCb) {
        e.persist == null ? void 0 : e.persist();
        cb(e, {
          node: node,
          size: {
            width: width,
            height: height
          },
          handle: axis
        });
      }

      // Reset internal data
      if (handlerName === 'onResizeStop') _this2.resetData();
    };
  }

  // Render a resize handle given an axis & DOM ref. Ref *must* be attached for
  // the underlying draggable library to work properly.
  ;

  _proto.renderResizeHandle = function renderResizeHandle(handleAxis, ref) {
    var handle = this.props.handle;
    // No handle provided, make the default
    if (!handle) {
      return /*#__PURE__*/React.createElement("span", {
        className: "react-resizable-handle react-resizable-handle-" + handleAxis,
        ref: ref
      });
    }
    // Handle is a function, such as:
    // `handle={(handleAxis) => <span className={...} />}`
    if (typeof handle === 'function') {
      return handle(handleAxis, ref);
    }
    // Handle is a React component (composite or DOM).
    var isDOMElement = typeof handle.type === 'string';
    var props = _objectSpread({
      ref: ref
    }, isDOMElement ? {} : {
      handleAxis: handleAxis
    });
    return /*#__PURE__*/React.cloneElement(handle, props);
  };
  _proto.render = function render() {
    var _this3 = this;
    // Pass along only props not meant for the `<Resizable>`.`
    // eslint-disable-next-line no-unused-vars
    var _this$props2 = this.props,
      children = _this$props2.children,
      className = _this$props2.className,
      draggableOpts = _this$props2.draggableOpts,
      width = _this$props2.width,
      height = _this$props2.height,
      handle = _this$props2.handle,
      handleSize = _this$props2.handleSize,
      lockAspectRatio = _this$props2.lockAspectRatio,
      axis = _this$props2.axis,
      minConstraints = _this$props2.minConstraints,
      maxConstraints = _this$props2.maxConstraints,
      onResize = _this$props2.onResize,
      onResizeStop = _this$props2.onResizeStop,
      onResizeStart = _this$props2.onResizeStart,
      resizeHandles = _this$props2.resizeHandles,
      transformScale = _this$props2.transformScale,
      p = _objectWithoutPropertiesLoose(_this$props2, _excluded);

    // What we're doing here is getting the child of this element, and cloning it with this element's props.
    // We are then defining its children as:
    // 1. Its original children (resizable's child's children), and
    // 2. One or more draggable handles.
    return (0, _utils.cloneElement)(children, _objectSpread(_objectSpread({}, p), {}, {
      className: (className ? className + " " : '') + "react-resizable",
      children: [].concat(children.props.children, resizeHandles.map(function (handleAxis) {
        var _this3$handleRefs$han;
        // Create a ref to the handle so that `<DraggableCore>` doesn't have to use ReactDOM.findDOMNode().
        var ref = (_this3$handleRefs$han = _this3.handleRefs[handleAxis]) != null ? _this3$handleRefs$han : _this3.handleRefs[handleAxis] = /*#__PURE__*/React.createRef();
        return /*#__PURE__*/React.createElement(_reactDraggable.DraggableCore, _extends({}, draggableOpts, {
          nodeRef: ref,
          key: "resizableHandle-" + handleAxis,
          onStop: _this3.resizeHandler('onResizeStop', handleAxis),
          onStart: _this3.resizeHandler('onResizeStart', handleAxis),
          onDrag: _this3.resizeHandler('onResize', handleAxis)
        }), _this3.renderResizeHandle(handleAxis, ref));
      }))
    }));
  };
  return Resizable;
}(React.Component);
exports["default"] = Resizable;
Resizable.propTypes = _propTypes.resizableProps;
Resizable.defaultProps = {
  axis: 'both',
  handleSize: [20, 20],
  lockAspectRatio: false,
  minConstraints: [20, 20],
  maxConstraints: [Infinity, Infinity],
  resizeHandles: ['se'],
  transformScale: 1
};

/***/ }),

/***/ 8690:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";
var __webpack_unused_export__;


__webpack_unused_export__ = true;
exports["default"] = void 0;
var React = _interopRequireWildcard(__webpack_require__(9512));
var _propTypes = _interopRequireDefault(__webpack_require__(1226));
var _Resizable = _interopRequireDefault(__webpack_require__(7939));
var _propTypes2 = __webpack_require__(3691);
var _excluded = ["handle", "handleSize", "onResize", "onResizeStart", "onResizeStop", "draggableOpts", "minConstraints", "maxConstraints", "lockAspectRatio", "axis", "width", "height", "resizeHandles", "style", "transformScale"];
function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : {
    default: obj
  };
}
function _getRequireWildcardCache(nodeInterop) {
  if (typeof WeakMap !== "function") return null;
  var cacheBabelInterop = new WeakMap();
  var cacheNodeInterop = new WeakMap();
  return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
  })(nodeInterop);
}
function _interopRequireWildcard(obj, nodeInterop) {
  if (!nodeInterop && obj && obj.__esModule) {
    return obj;
  }
  if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
    return {
      default: obj
    };
  }
  var cache = _getRequireWildcardCache(nodeInterop);
  if (cache && cache.has(obj)) {
    return cache.get(obj);
  }
  var newObj = {};
  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
  for (var key in obj) {
    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
      if (desc && (desc.get || desc.set)) {
        Object.defineProperty(newObj, key, desc);
      } else {
        newObj[key] = obj[key];
      }
    }
  }
  newObj.default = obj;
  if (cache) {
    cache.set(obj, newObj);
  }
  return newObj;
}
function _extends() {
  _extends = Object.assign ? Object.assign.bind() : function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];
      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }
    return target;
  };
  return _extends.apply(this, arguments);
}
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) {
  key = _toPropertyKey(key);
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }
  return obj;
}
function _toPropertyKey(arg) {
  var key = _toPrimitive(arg, "string");
  return typeof key === "symbol" ? key : String(key);
}
function _toPrimitive(input, hint) {
  if (typeof input !== "object" || input === null) return input;
  var prim = input[Symbol.toPrimitive];
  if (prim !== undefined) {
    var res = prim.call(input, hint || "default");
    if (typeof res !== "object") return res;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return (hint === "string" ? String : Number)(input);
}
function _objectWithoutPropertiesLoose(source, excluded) {
  if (source == null) return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i;
  for (i = 0; i < sourceKeys.length; i++) {
    key = sourceKeys[i];
    if (excluded.indexOf(key) >= 0) continue;
    target[key] = source[key];
  }
  return target;
}
function _inheritsLoose(subClass, superClass) {
  subClass.prototype = Object.create(superClass.prototype);
  subClass.prototype.constructor = subClass;
  _setPrototypeOf(subClass, superClass);
}
function _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };
  return _setPrototypeOf(o, p);
}
var ResizableBox = /*#__PURE__*/function (_React$Component) {
  _inheritsLoose(ResizableBox, _React$Component);
  function ResizableBox() {
    var _this;
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
    _this.state = {
      width: _this.props.width,
      height: _this.props.height,
      propsWidth: _this.props.width,
      propsHeight: _this.props.height
    };
    _this.onResize = function (e, data) {
      var size = data.size;
      if (_this.props.onResize) {
        e.persist == null ? void 0 : e.persist();
        _this.setState(size, function () {
          return _this.props.onResize && _this.props.onResize(e, data);
        });
      } else {
        _this.setState(size);
      }
    };
    return _this;
  }
  ResizableBox.getDerivedStateFromProps = function getDerivedStateFromProps(props, state) {
    // If parent changes height/width, set that in our state.
    if (state.propsWidth !== props.width || state.propsHeight !== props.height) {
      return {
        width: props.width,
        height: props.height,
        propsWidth: props.width,
        propsHeight: props.height
      };
    }
    return null;
  };
  var _proto = ResizableBox.prototype;
  _proto.render = function render() {
    // Basic wrapper around a Resizable instance.
    // If you use Resizable directly, you are responsible for updating the child component
    // with a new width and height.
    var _this$props = this.props,
      handle = _this$props.handle,
      handleSize = _this$props.handleSize,
      onResize = _this$props.onResize,
      onResizeStart = _this$props.onResizeStart,
      onResizeStop = _this$props.onResizeStop,
      draggableOpts = _this$props.draggableOpts,
      minConstraints = _this$props.minConstraints,
      maxConstraints = _this$props.maxConstraints,
      lockAspectRatio = _this$props.lockAspectRatio,
      axis = _this$props.axis,
      width = _this$props.width,
      height = _this$props.height,
      resizeHandles = _this$props.resizeHandles,
      style = _this$props.style,
      transformScale = _this$props.transformScale,
      props = _objectWithoutPropertiesLoose(_this$props, _excluded);
    return /*#__PURE__*/React.createElement(_Resizable.default, {
      axis: axis,
      draggableOpts: draggableOpts,
      handle: handle,
      handleSize: handleSize,
      height: this.state.height,
      lockAspectRatio: lockAspectRatio,
      maxConstraints: maxConstraints,
      minConstraints: minConstraints,
      onResizeStart: onResizeStart,
      onResize: this.onResize,
      onResizeStop: onResizeStop,
      resizeHandles: resizeHandles,
      transformScale: transformScale,
      width: this.state.width
    }, /*#__PURE__*/React.createElement("div", _extends({}, props, {
      style: _objectSpread(_objectSpread({}, style), {}, {
        width: this.state.width + 'px',
        height: this.state.height + 'px'
      })
    })));
  };
  return ResizableBox;
}(React.Component);
exports["default"] = ResizableBox;
// PropTypes are identical to <Resizable>, except that children are not strictly required to be present.
ResizableBox.propTypes = _objectSpread(_objectSpread({}, _propTypes2.resizableProps), {}, {
  children: _propTypes.default.element
});

/***/ }),

/***/ 3691:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


exports.__esModule = true;
exports.resizableProps = void 0;
var _propTypes = _interopRequireDefault(__webpack_require__(1226));
var _reactDraggable = __webpack_require__(1710);
function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : {
    default: obj
  };
}
var resizableProps = {
  /*
  * Restricts resizing to a particular axis (default: 'both')
  * 'both' - allows resizing by width or height
  * 'x' - only allows the width to be changed
  * 'y' - only allows the height to be changed
  * 'none' - disables resizing altogether
  * */
  axis: _propTypes.default.oneOf(['both', 'x', 'y', 'none']),
  className: _propTypes.default.string,
  /*
  * Require that one and only one child be present.
  * */
  children: _propTypes.default.element.isRequired,
  /*
  * These will be passed wholesale to react-draggable's DraggableCore
  * */
  draggableOpts: _propTypes.default.shape({
    allowAnyClick: _propTypes.default.bool,
    cancel: _propTypes.default.string,
    children: _propTypes.default.node,
    disabled: _propTypes.default.bool,
    enableUserSelectHack: _propTypes.default.bool,
    offsetParent: _propTypes.default.node,
    grid: _propTypes.default.arrayOf(_propTypes.default.number),
    handle: _propTypes.default.string,
    nodeRef: _propTypes.default.object,
    onStart: _propTypes.default.func,
    onDrag: _propTypes.default.func,
    onStop: _propTypes.default.func,
    onMouseDown: _propTypes.default.func,
    scale: _propTypes.default.number
  }),
  /*
  * Initial height
  * */
  height: function height() {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    var props = args[0];
    // Required if resizing height or both
    if (props.axis === 'both' || props.axis === 'y') {
      var _PropTypes$number;
      return (_PropTypes$number = _propTypes.default.number).isRequired.apply(_PropTypes$number, args);
    }
    return _propTypes.default.number.apply(_propTypes.default, args);
  },
  /*
  * Customize cursor resize handle
  * */
  handle: _propTypes.default.oneOfType([_propTypes.default.node, _propTypes.default.func]),
  /*
  * If you change this, be sure to update your css
  * */
  handleSize: _propTypes.default.arrayOf(_propTypes.default.number),
  lockAspectRatio: _propTypes.default.bool,
  /*
  * Max X & Y measure
  * */
  maxConstraints: _propTypes.default.arrayOf(_propTypes.default.number),
  /*
  * Min X & Y measure
  * */
  minConstraints: _propTypes.default.arrayOf(_propTypes.default.number),
  /*
  * Called on stop resize event
  * */
  onResizeStop: _propTypes.default.func,
  /*
  * Called on start resize event
  * */
  onResizeStart: _propTypes.default.func,
  /*
  * Called on resize event
  * */
  onResize: _propTypes.default.func,
  /*
  * Defines which resize handles should be rendered (default: 'se')
  * 's' - South handle (bottom-center)
  * 'w' - West handle (left-center)
  * 'e' - East handle (right-center)
  * 'n' - North handle (top-center)
  * 'sw' - Southwest handle (bottom-left)
  * 'nw' - Northwest handle (top-left)
  * 'se' - Southeast handle (bottom-right)
  * 'ne' - Northeast handle (top-center)
  * */
  resizeHandles: _propTypes.default.arrayOf(_propTypes.default.oneOf(['s', 'w', 'e', 'n', 'sw', 'nw', 'se', 'ne'])),
  /*
  * If `transform: scale(n)` is set on the parent, this should be set to `n`.
  * */
  transformScale: _propTypes.default.number,
  /*
   * Initial width
   */
  width: function width() {
    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }
    var props = args[0];
    // Required if resizing width or both
    if (props.axis === 'both' || props.axis === 'x') {
      var _PropTypes$number2;
      return (_PropTypes$number2 = _propTypes.default.number).isRequired.apply(_PropTypes$number2, args);
    }
    return _propTypes.default.number.apply(_propTypes.default, args);
  }
};
exports.resizableProps = resizableProps;

/***/ }),

/***/ 7748:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


exports.__esModule = true;
exports.cloneElement = cloneElement;
var _react = _interopRequireDefault(__webpack_require__(9512));
function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : {
    default: 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) {
  key = _toPropertyKey(key);
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }
  return obj;
}
function _toPropertyKey(arg) {
  var key = _toPrimitive(arg, "string");
  return typeof key === "symbol" ? key : String(key);
}
function _toPrimitive(input, hint) {
  if (typeof input !== "object" || input === null) return input;
  var prim = input[Symbol.toPrimitive];
  if (prim !== undefined) {
    var res = prim.call(input, hint || "default");
    if (typeof res !== "object") return res;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return (hint === "string" ? String : Number)(input);
}
// React.addons.cloneWithProps look-alike that merges style & className.
function cloneElement(element, props) {
  if (props.style && element.props.style) {
    props.style = _objectSpread(_objectSpread({}, element.props.style), props.style);
  }
  if (props.className && element.props.className) {
    props.className = element.props.className + " " + props.className;
  }
  return /*#__PURE__*/_react.default.cloneElement(element, props);
}

/***/ }),

/***/ 3350:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


module.exports = function () {
  throw new Error("Don't instantiate Resizable directly! Use require('react-resizable').Resizable");
};
module.exports.Resizable = __webpack_require__(7939)["default"];
module.exports.ResizableBox = __webpack_require__(8690)["default"];

/***/ }),

/***/ 4992:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";
/**
 * @license React
 * react-jsx-runtime.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */


var f = __webpack_require__(9512),
  k = Symbol.for("react.element"),
  l = Symbol.for("react.fragment"),
  m = Object.prototype.hasOwnProperty,
  n = f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,
  p = {
    key: !0,
    ref: !0,
    __self: !0,
    __source: !0
  };
function q(c, a, g) {
  var b,
    d = {},
    e = null,
    h = null;
  void 0 !== g && (e = "" + g);
  void 0 !== a.key && (e = "" + a.key);
  void 0 !== a.ref && (h = a.ref);
  for (b in a) m.call(a, b) && !p.hasOwnProperty(b) && (d[b] = a[b]);
  if (c && c.defaultProps) for (b in a = c.defaultProps, a) void 0 === d[b] && (d[b] = a[b]);
  return {
    $$typeof: k,
    type: c,
    key: e,
    ref: h,
    props: d,
    _owner: n.current
  };
}
exports.Fragment = l;
exports.jsx = q;
exports.jsxs = q;

/***/ }),

/***/ 7276:
/***/ (function(__unused_webpack_module, exports) {

"use strict";
/**
 * @license React
 * react.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */


var l = Symbol.for("react.element"),
  n = Symbol.for("react.portal"),
  p = Symbol.for("react.fragment"),
  q = Symbol.for("react.strict_mode"),
  r = Symbol.for("react.profiler"),
  t = Symbol.for("react.provider"),
  u = Symbol.for("react.context"),
  v = Symbol.for("react.forward_ref"),
  w = Symbol.for("react.suspense"),
  x = Symbol.for("react.memo"),
  y = Symbol.for("react.lazy"),
  z = Symbol.iterator;
function A(a) {
  if (null === a || "object" !== typeof a) return null;
  a = z && a[z] || a["@@iterator"];
  return "function" === typeof a ? a : null;
}
var B = {
    isMounted: function isMounted() {
      return !1;
    },
    enqueueForceUpdate: function enqueueForceUpdate() {},
    enqueueReplaceState: function enqueueReplaceState() {},
    enqueueSetState: function enqueueSetState() {}
  },
  C = Object.assign,
  D = {};
function E(a, b, e) {
  this.props = a;
  this.context = b;
  this.refs = D;
  this.updater = e || B;
}
E.prototype.isReactComponent = {};
E.prototype.setState = function (a, b) {
  if ("object" !== typeof a && "function" !== typeof a && null != a) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
  this.updater.enqueueSetState(this, a, b, "setState");
};
E.prototype.forceUpdate = function (a) {
  this.updater.enqueueForceUpdate(this, a, "forceUpdate");
};
function F() {}
F.prototype = E.prototype;
function G(a, b, e) {
  this.props = a;
  this.context = b;
  this.refs = D;
  this.updater = e || B;
}
var H = G.prototype = new F();
H.constructor = G;
C(H, E.prototype);
H.isPureReactComponent = !0;
var I = Array.isArray,
  J = Object.prototype.hasOwnProperty,
  K = {
    current: null
  },
  L = {
    key: !0,
    ref: !0,
    __self: !0,
    __source: !0
  };
function M(a, b, e) {
  var d,
    c = {},
    k = null,
    h = null;
  if (null != b) for (d in void 0 !== b.ref && (h = b.ref), void 0 !== b.key && (k = "" + b.key), b) J.call(b, d) && !L.hasOwnProperty(d) && (c[d] = b[d]);
  var g = arguments.length - 2;
  if (1 === g) c.children = e;else if (1 < g) {
    for (var f = Array(g), m = 0; m < g; m++) f[m] = arguments[m + 2];
    c.children = f;
  }
  if (a && a.defaultProps) for (d in g = a.defaultProps, g) void 0 === c[d] && (c[d] = g[d]);
  return {
    $$typeof: l,
    type: a,
    key: k,
    ref: h,
    props: c,
    _owner: K.current
  };
}
function N(a, b) {
  return {
    $$typeof: l,
    type: a.type,
    key: b,
    ref: a.ref,
    props: a.props,
    _owner: a._owner
  };
}
function O(a) {
  return "object" === typeof a && null !== a && a.$$typeof === l;
}
function escape(a) {
  var b = {
    "=": "=0",
    ":": "=2"
  };
  return "$" + a.replace(/[=:]/g, function (a) {
    return b[a];
  });
}
var P = /\/+/g;
function Q(a, b) {
  return "object" === typeof a && null !== a && null != a.key ? escape("" + a.key) : b.toString(36);
}
function R(a, b, e, d, c) {
  var k = typeof a;
  if ("undefined" === k || "boolean" === k) a = null;
  var h = !1;
  if (null === a) h = !0;else switch (k) {
    case "string":
    case "number":
      h = !0;
      break;
    case "object":
      switch (a.$$typeof) {
        case l:
        case n:
          h = !0;
      }
  }
  if (h) return h = a, c = c(h), a = "" === d ? "." + Q(h, 0) : d, I(c) ? (e = "", null != a && (e = a.replace(P, "$&/") + "/"), R(c, b, e, "", function (a) {
    return a;
  })) : null != c && (O(c) && (c = N(c, e + (!c.key || h && h.key === c.key ? "" : ("" + c.key).replace(P, "$&/") + "/") + a)), b.push(c)), 1;
  h = 0;
  d = "" === d ? "." : d + ":";
  if (I(a)) for (var g = 0; g < a.length; g++) {
    k = a[g];
    var f = d + Q(k, g);
    h += R(k, b, e, f, c);
  } else if (f = A(a), "function" === typeof f) for (a = f.call(a), g = 0; !(k = a.next()).done;) k = k.value, f = d + Q(k, g++), h += R(k, b, e, f, c);else if ("object" === k) throw b = String(a), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(a).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
  return h;
}
function S(a, b, e) {
  if (null == a) return a;
  var d = [],
    c = 0;
  R(a, d, "", "", function (a) {
    return b.call(e, a, c++);
  });
  return d;
}
function T(a) {
  if (-1 === a._status) {
    var b = a._result;
    b = b();
    b.then(function (b) {
      if (0 === a._status || -1 === a._status) a._status = 1, a._result = b;
    }, function (b) {
      if (0 === a._status || -1 === a._status) a._status = 2, a._result = b;
    });
    -1 === a._status && (a._status = 0, a._result = b);
  }
  if (1 === a._status) return a._result.default;
  throw a._result;
}
var U = {
    current: null
  },
  V = {
    transition: null
  },
  W = {
    ReactCurrentDispatcher: U,
    ReactCurrentBatchConfig: V,
    ReactCurrentOwner: K
  };
exports.Children = {
  map: S,
  forEach: function forEach(a, b, e) {
    S(a, function () {
      b.apply(this, arguments);
    }, e);
  },
  count: function count(a) {
    var b = 0;
    S(a, function () {
      b++;
    });
    return b;
  },
  toArray: function toArray(a) {
    return S(a, function (a) {
      return a;
    }) || [];
  },
  only: function only(a) {
    if (!O(a)) throw Error("React.Children.only expected to receive a single React element child.");
    return a;
  }
};
exports.Component = E;
exports.Fragment = p;
exports.Profiler = r;
exports.PureComponent = G;
exports.StrictMode = q;
exports.Suspense = w;
exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W;
exports.cloneElement = function (a, b, e) {
  if (null === a || void 0 === a) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a + ".");
  var d = C({}, a.props),
    c = a.key,
    k = a.ref,
    h = a._owner;
  if (null != b) {
    void 0 !== b.ref && (k = b.ref, h = K.current);
    void 0 !== b.key && (c = "" + b.key);
    if (a.type && a.type.defaultProps) var g = a.type.defaultProps;
    for (f in b) J.call(b, f) && !L.hasOwnProperty(f) && (d[f] = void 0 === b[f] && void 0 !== g ? g[f] : b[f]);
  }
  var f = arguments.length - 2;
  if (1 === f) d.children = e;else if (1 < f) {
    g = Array(f);
    for (var m = 0; m < f; m++) g[m] = arguments[m + 2];
    d.children = g;
  }
  return {
    $$typeof: l,
    type: a.type,
    key: c,
    ref: k,
    props: d,
    _owner: h
  };
};
exports.createContext = function (a) {
  a = {
    $$typeof: u,
    _currentValue: a,
    _currentValue2: a,
    _threadCount: 0,
    Provider: null,
    Consumer: null,
    _defaultValue: null,
    _globalName: null
  };
  a.Provider = {
    $$typeof: t,
    _context: a
  };
  return a.Consumer = a;
};
exports.createElement = M;
exports.createFactory = function (a) {
  var b = M.bind(null, a);
  b.type = a;
  return b;
};
exports.createRef = function () {
  return {
    current: null
  };
};
exports.forwardRef = function (a) {
  return {
    $$typeof: v,
    render: a
  };
};
exports.isValidElement = O;
exports.lazy = function (a) {
  return {
    $$typeof: y,
    _payload: {
      _status: -1,
      _result: a
    },
    _init: T
  };
};
exports.memo = function (a, b) {
  return {
    $$typeof: x,
    type: a,
    compare: void 0 === b ? null : b
  };
};
exports.startTransition = function (a) {
  var b = V.transition;
  V.transition = {};
  try {
    a();
  } finally {
    V.transition = b;
  }
};
exports.unstable_act = function () {
  throw Error("act(...) is not supported in production builds of React.");
};
exports.useCallback = function (a, b) {
  return U.current.useCallback(a, b);
};
exports.useContext = function (a) {
  return U.current.useContext(a);
};
exports.useDebugValue = function () {};
exports.useDeferredValue = function (a) {
  return U.current.useDeferredValue(a);
};
exports.useEffect = function (a, b) {
  return U.current.useEffect(a, b);
};
exports.useId = function () {
  return U.current.useId();
};
exports.useImperativeHandle = function (a, b, e) {
  return U.current.useImperativeHandle(a, b, e);
};
exports.useInsertionEffect = function (a, b) {
  return U.current.useInsertionEffect(a, b);
};
exports.useLayoutEffect = function (a, b) {
  return U.current.useLayoutEffect(a, b);
};
exports.useMemo = function (a, b) {
  return U.current.useMemo(a, b);
};
exports.useReducer = function (a, b, e) {
  return U.current.useReducer(a, b, e);
};
exports.useRef = function (a) {
  return U.current.useRef(a);
};
exports.useState = function (a) {
  return U.current.useState(a);
};
exports.useSyncExternalStore = function (a, b, e) {
  return U.current.useSyncExternalStore(a, b, e);
};
exports.useTransition = function () {
  return U.current.useTransition();
};
exports.version = "18.2.0";

/***/ }),

/***/ 9512:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


if (true) {
  module.exports = __webpack_require__(7276);
} else {}

/***/ }),

/***/ 9386:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


if (true) {
  module.exports = __webpack_require__(4992);
} else {}

/***/ }),

/***/ 875:
/***/ (function(__unused_webpack_module, exports) {

"use strict";
/**
 * @license React
 * scheduler.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */


function f(a, b) {
  var c = a.length;
  a.push(b);
  a: for (; 0 < c;) {
    var d = c - 1 >>> 1,
      e = a[d];
    if (0 < g(e, b)) a[d] = b, a[c] = e, c = d;else break a;
  }
}
function h(a) {
  return 0 === a.length ? null : a[0];
}
function k(a) {
  if (0 === a.length) return null;
  var b = a[0],
    c = a.pop();
  if (c !== b) {
    a[0] = c;
    a: for (var d = 0, e = a.length, w = e >>> 1; d < w;) {
      var m = 2 * (d + 1) - 1,
        C = a[m],
        n = m + 1,
        x = a[n];
      if (0 > g(C, c)) n < e && 0 > g(x, C) ? (a[d] = x, a[n] = c, d = n) : (a[d] = C, a[m] = c, d = m);else if (n < e && 0 > g(x, c)) a[d] = x, a[n] = c, d = n;else break a;
    }
  }
  return b;
}
function g(a, b) {
  var c = a.sortIndex - b.sortIndex;
  return 0 !== c ? c : a.id - b.id;
}
if ("object" === typeof performance && "function" === typeof performance.now) {
  var l = performance;
  exports.unstable_now = function () {
    return l.now();
  };
} else {
  var p = Date,
    q = p.now();
  exports.unstable_now = function () {
    return p.now() - q;
  };
}
var r = [],
  t = [],
  u = 1,
  v = null,
  y = 3,
  z = !1,
  A = !1,
  B = !1,
  D = "function" === typeof setTimeout ? setTimeout : null,
  E = "function" === typeof clearTimeout ? clearTimeout : null,
  F = "undefined" !== typeof setImmediate ? setImmediate : null;
"undefined" !== typeof navigator && void 0 !== navigator.scheduling && void 0 !== navigator.scheduling.isInputPending && navigator.scheduling.isInputPending.bind(navigator.scheduling);
function G(a) {
  for (var b = h(t); null !== b;) {
    if (null === b.callback) k(t);else if (b.startTime <= a) k(t), b.sortIndex = b.expirationTime, f(r, b);else break;
    b = h(t);
  }
}
function H(a) {
  B = !1;
  G(a);
  if (!A) if (null !== h(r)) A = !0, I(J);else {
    var b = h(t);
    null !== b && K(H, b.startTime - a);
  }
}
function J(a, b) {
  A = !1;
  B && (B = !1, E(L), L = -1);
  z = !0;
  var c = y;
  try {
    G(b);
    for (v = h(r); null !== v && (!(v.expirationTime > b) || a && !M());) {
      var d = v.callback;
      if ("function" === typeof d) {
        v.callback = null;
        y = v.priorityLevel;
        var e = d(v.expirationTime <= b);
        b = exports.unstable_now();
        "function" === typeof e ? v.callback = e : v === h(r) && k(r);
        G(b);
      } else k(r);
      v = h(r);
    }
    if (null !== v) var w = !0;else {
      var m = h(t);
      null !== m && K(H, m.startTime - b);
      w = !1;
    }
    return w;
  } finally {
    v = null, y = c, z = !1;
  }
}
var N = !1,
  O = null,
  L = -1,
  P = 5,
  Q = -1;
function M() {
  return exports.unstable_now() - Q < P ? !1 : !0;
}
function R() {
  if (null !== O) {
    var a = exports.unstable_now();
    Q = a;
    var b = !0;
    try {
      b = O(!0, a);
    } finally {
      b ? S() : (N = !1, O = null);
    }
  } else N = !1;
}
var S;
if ("function" === typeof F) S = function S() {
  F(R);
};else if ("undefined" !== typeof MessageChannel) {
  var T = new MessageChannel(),
    U = T.port2;
  T.port1.onmessage = R;
  S = function S() {
    U.postMessage(null);
  };
} else S = function S() {
  D(R, 0);
};
function I(a) {
  O = a;
  N || (N = !0, S());
}
function K(a, b) {
  L = D(function () {
    a(exports.unstable_now());
  }, b);
}
exports.unstable_IdlePriority = 5;
exports.unstable_ImmediatePriority = 1;
exports.unstable_LowPriority = 4;
exports.unstable_NormalPriority = 3;
exports.unstable_Profiling = null;
exports.unstable_UserBlockingPriority = 2;
exports.unstable_cancelCallback = function (a) {
  a.callback = null;
};
exports.unstable_continueExecution = function () {
  A || z || (A = !0, I(J));
};
exports.unstable_forceFrameRate = function (a) {
  0 > a || 125 < a ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported") : P = 0 < a ? Math.floor(1E3 / a) : 5;
};
exports.unstable_getCurrentPriorityLevel = function () {
  return y;
};
exports.unstable_getFirstCallbackNode = function () {
  return h(r);
};
exports.unstable_next = function (a) {
  switch (y) {
    case 1:
    case 2:
    case 3:
      var b = 3;
      break;
    default:
      b = y;
  }
  var c = y;
  y = b;
  try {
    return a();
  } finally {
    y = c;
  }
};
exports.unstable_pauseExecution = function () {};
exports.unstable_requestPaint = function () {};
exports.unstable_runWithPriority = function (a, b) {
  switch (a) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      break;
    default:
      a = 3;
  }
  var c = y;
  y = a;
  try {
    return b();
  } finally {
    y = c;
  }
};
exports.unstable_scheduleCallback = function (a, b, c) {
  var d = exports.unstable_now();
  "object" === typeof c && null !== c ? (c = c.delay, c = "number" === typeof c && 0 < c ? d + c : d) : c = d;
  switch (a) {
    case 1:
      var e = -1;
      break;
    case 2:
      e = 250;
      break;
    case 5:
      e = 1073741823;
      break;
    case 4:
      e = 1E4;
      break;
    default:
      e = 5E3;
  }
  e = c + e;
  a = {
    id: u++,
    callback: b,
    priorityLevel: a,
    startTime: c,
    expirationTime: e,
    sortIndex: -1
  };
  c > d ? (a.sortIndex = c, f(t, a), null === h(r) && a === h(t) && (B ? (E(L), L = -1) : B = !0, K(H, c - d))) : (a.sortIndex = e, f(r, a), A || z || (A = !0, I(J)));
  return a;
};
exports.unstable_shouldYield = M;
exports.unstable_wrapCallback = function (a) {
  var b = y;
  return function () {
    var c = y;
    y = b;
    try {
      return a.apply(this, arguments);
    } finally {
      y = c;
    }
  };
};

/***/ }),

/***/ 4086:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


if (true) {
  module.exports = __webpack_require__(875);
} else {}

/***/ }),

/***/ 301:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var _classCallCheck = (__webpack_require__(8403)["default"]);
var _createClass = (__webpack_require__(2467)["default"]);
var ANY = Symbol('SemVer ANY');
// hoisted class for cyclic dependency
var Comparator = /*#__PURE__*/function () {
  "use strict";

  function Comparator(comp, options) {
    _classCallCheck(this, Comparator);
    options = parseOptions(options);
    if (comp instanceof Comparator) {
      if (comp.loose === !!options.loose) {
        return comp;
      } else {
        comp = comp.value;
      }
    }
    debug('comparator', comp, options);
    this.options = options;
    this.loose = !!options.loose;
    this.parse(comp);
    if (this.semver === ANY) {
      this.value = '';
    } else {
      this.value = this.operator + this.semver.version;
    }
    debug('comp', this);
  }
  _createClass(Comparator, [{
    key: "parse",
    value: function parse(comp) {
      var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
      var m = comp.match(r);
      if (!m) {
        throw new TypeError("Invalid comparator: ".concat(comp));
      }
      this.operator = m[1] !== undefined ? m[1] : '';
      if (this.operator === '=') {
        this.operator = '';
      }

      // if it literally is just '>' or '' then allow anything.
      if (!m[2]) {
        this.semver = ANY;
      } else {
        this.semver = new SemVer(m[2], this.options.loose);
      }
    }
  }, {
    key: "toString",
    value: function toString() {
      return this.value;
    }
  }, {
    key: "test",
    value: function test(version) {
      debug('Comparator.test', version, this.options.loose);
      if (this.semver === ANY || version === ANY) {
        return true;
      }
      if (typeof version === 'string') {
        try {
          version = new SemVer(version, this.options);
        } catch (er) {
          return false;
        }
      }
      return cmp(version, this.operator, this.semver, this.options);
    }
  }, {
    key: "intersects",
    value: function intersects(comp, options) {
      if (!(comp instanceof Comparator)) {
        throw new TypeError('a Comparator is required');
      }
      if (this.operator === '') {
        if (this.value === '') {
          return true;
        }
        return new Range(comp.value, options).test(this.value);
      } else if (comp.operator === '') {
        if (comp.value === '') {
          return true;
        }
        return new Range(this.value, options).test(comp.semver);
      }
      options = parseOptions(options);

      // Special cases where nothing can possibly be lower
      if (options.includePrerelease && (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {
        return false;
      }
      if (!options.includePrerelease && (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {
        return false;
      }

      // Same direction increasing (> or >=)
      if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {
        return true;
      }
      // Same direction decreasing (< or <=)
      if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {
        return true;
      }
      // same SemVer and both sides are inclusive (<= or >=)
      if (this.semver.version === comp.semver.version && this.operator.includes('=') && comp.operator.includes('=')) {
        return true;
      }
      // opposite directions less than
      if (cmp(this.semver, '<', comp.semver, options) && this.operator.startsWith('>') && comp.operator.startsWith('<')) {
        return true;
      }
      // opposite directions greater than
      if (cmp(this.semver, '>', comp.semver, options) && this.operator.startsWith('<') && comp.operator.startsWith('>')) {
        return true;
      }
      return false;
    }
  }], [{
    key: "ANY",
    get: function get() {
      return ANY;
    }
  }]);
  return Comparator;
}();
module.exports = Comparator;
var parseOptions = __webpack_require__(504);
var _require = __webpack_require__(8369),
  re = _require.re,
  t = _require.t;
var cmp = __webpack_require__(9900);
var debug = __webpack_require__(6298);
var SemVer = __webpack_require__(1186);
var Range = __webpack_require__(7258);

/***/ }),

/***/ 7258:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var _toConsumableArray = (__webpack_require__(7685)["default"]);
var _createForOfIteratorHelper = (__webpack_require__(3762)["default"]);
var _classCallCheck = (__webpack_require__(8403)["default"]);
var _createClass = (__webpack_require__(2467)["default"]);
// hoisted class for cyclic dependency
var Range = /*#__PURE__*/function () {
  "use strict";

  function Range(range, options) {
    var _this = this;
    _classCallCheck(this, Range);
    options = parseOptions(options);
    if (range instanceof Range) {
      if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
        return range;
      } else {
        return new Range(range.raw, options);
      }
    }
    if (range instanceof Comparator) {
      // just put it in the set and return
      this.raw = range.value;
      this.set = [[range]];
      this.format();
      return this;
    }
    this.options = options;
    this.loose = !!options.loose;
    this.includePrerelease = !!options.includePrerelease;

    // First, split based on boolean or ||
    this.raw = range;
    this.set = range.split('||')
    // map the range to a 2d array of comparators
    .map(function (r) {
      return _this.parseRange(r.trim());
    })
    // throw out any comparator lists that are empty
    // this generally means that it was not a valid range, which is allowed
    // in loose mode, but will still throw if the WHOLE range is invalid.
    .filter(function (c) {
      return c.length;
    });
    if (!this.set.length) {
      throw new TypeError("Invalid SemVer Range: ".concat(range));
    }

    // if we have any that are not the null set, throw out null sets.
    if (this.set.length > 1) {
      // keep the first one, in case they're all null sets
      var first = this.set[0];
      this.set = this.set.filter(function (c) {
        return !isNullSet(c[0]);
      });
      if (this.set.length === 0) {
        this.set = [first];
      } else if (this.set.length > 1) {
        // if we have any that are *, then the range is just *
        var _iterator = _createForOfIteratorHelper(this.set),
          _step;
        try {
          for (_iterator.s(); !(_step = _iterator.n()).done;) {
            var c = _step.value;
            if (c.length === 1 && isAny(c[0])) {
              this.set = [c];
              break;
            }
          }
        } catch (err) {
          _iterator.e(err);
        } finally {
          _iterator.f();
        }
      }
    }
    this.format();
  }
  _createClass(Range, [{
    key: "format",
    value: function format() {
      this.range = this.set.map(function (comps) {
        return comps.join(' ').trim();
      }).join('||').trim();
      return this.range;
    }
  }, {
    key: "toString",
    value: function toString() {
      return this.range;
    }
  }, {
    key: "parseRange",
    value: function parseRange(range) {
      var _this2 = this;
      range = range.trim();

      // memoize range parsing for performance.
      // this is a very hot path, and fully deterministic.
      var memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
      var memoKey = memoOpts + ':' + range;
      var cached = cache.get(memoKey);
      if (cached) {
        return cached;
      }
      var loose = this.options.loose;
      // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
      var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
      range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
      debug('hyphen replace', range);
      // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
      range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
      debug('comparator trim', range);

      // `~ 1.2.3` => `~1.2.3`
      range = range.replace(re[t.TILDETRIM], tildeTrimReplace);

      // `^ 1.2.3` => `^1.2.3`
      range = range.replace(re[t.CARETTRIM], caretTrimReplace);

      // normalize spaces
      range = range.split(/\s+/).join(' ');

      // At this point, the range is completely trimmed and
      // ready to be split into comparators.

      var rangeList = range.split(' ').map(function (comp) {
        return parseComparator(comp, _this2.options);
      }).join(' ').split(/\s+/)
      // >=0.0.0 is equivalent to *
      .map(function (comp) {
        return replaceGTE0(comp, _this2.options);
      });
      if (loose) {
        // in loose mode, throw out any that are not valid comparators
        rangeList = rangeList.filter(function (comp) {
          debug('loose invalid filter', comp, _this2.options);
          return !!comp.match(re[t.COMPARATORLOOSE]);
        });
      }
      debug('range list', rangeList);

      // if any comparators are the null set, then replace with JUST null set
      // if more than one comparator, remove any * comparators
      // also, don't include the same comparator more than once
      var rangeMap = new Map();
      var comparators = rangeList.map(function (comp) {
        return new Comparator(comp, _this2.options);
      });
      var _iterator2 = _createForOfIteratorHelper(comparators),
        _step2;
      try {
        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
          var comp = _step2.value;
          if (isNullSet(comp)) {
            return [comp];
          }
          rangeMap.set(comp.value, comp);
        }
      } catch (err) {
        _iterator2.e(err);
      } finally {
        _iterator2.f();
      }
      if (rangeMap.size > 1 && rangeMap.has('')) {
        rangeMap.delete('');
      }
      var result = _toConsumableArray(rangeMap.values());
      cache.set(memoKey, result);
      return result;
    }
  }, {
    key: "intersects",
    value: function intersects(range, options) {
      if (!(range instanceof Range)) {
        throw new TypeError('a Range is required');
      }
      return this.set.some(function (thisComparators) {
        return isSatisfiable(thisComparators, options) && range.set.some(function (rangeComparators) {
          return isSatisfiable(rangeComparators, options) && thisComparators.every(function (thisComparator) {
            return rangeComparators.every(function (rangeComparator) {
              return thisComparator.intersects(rangeComparator, options);
            });
          });
        });
      });
    }

    // if ANY of the sets match ALL of its comparators, then pass
  }, {
    key: "test",
    value: function test(version) {
      if (!version) {
        return false;
      }
      if (typeof version === 'string') {
        try {
          version = new SemVer(version, this.options);
        } catch (er) {
          return false;
        }
      }
      for (var i = 0; i < this.set.length; i++) {
        if (testSet(this.set[i], version, this.options)) {
          return true;
        }
      }
      return false;
    }
  }]);
  return Range;
}();
module.exports = Range;
var LRU = __webpack_require__(2346);
var cache = new LRU({
  max: 1000
});
var parseOptions = __webpack_require__(504);
var Comparator = __webpack_require__(301);
var debug = __webpack_require__(6298);
var SemVer = __webpack_require__(1186);
var _require = __webpack_require__(8369),
  re = _require.re,
  t = _require.t,
  comparatorTrimReplace = _require.comparatorTrimReplace,
  tildeTrimReplace = _require.tildeTrimReplace,
  caretTrimReplace = _require.caretTrimReplace;
var _require2 = __webpack_require__(6028),
  FLAG_INCLUDE_PRERELEASE = _require2.FLAG_INCLUDE_PRERELEASE,
  FLAG_LOOSE = _require2.FLAG_LOOSE;
var isNullSet = function isNullSet(c) {
  return c.value === '<0.0.0-0';
};
var isAny = function isAny(c) {
  return c.value === '';
};

// take a set of comparators and determine whether there
// exists a version which can satisfy it
var isSatisfiable = function isSatisfiable(comparators, options) {
  var result = true;
  var remainingComparators = comparators.slice();
  var testComparator = remainingComparators.pop();
  while (result && remainingComparators.length) {
    result = remainingComparators.every(function (otherComparator) {
      return testComparator.intersects(otherComparator, options);
    });
    testComparator = remainingComparators.pop();
  }
  return result;
};

// comprised of xranges, tildes, stars, and gtlt's at this point.
// already replaced the hyphen ranges
// turn into a set of JUST comparators.
var parseComparator = function parseComparator(comp, options) {
  debug('comp', comp, options);
  comp = replaceCarets(comp, options);
  debug('caret', comp);
  comp = replaceTildes(comp, options);
  debug('tildes', comp);
  comp = replaceXRanges(comp, options);
  debug('xrange', comp);
  comp = replaceStars(comp, options);
  debug('stars', comp);
  return comp;
};
var isX = function isX(id) {
  return !id || id.toLowerCase() === 'x' || id === '*';
};

// ~, ~> --> * (any, kinda silly)
// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
// ~0.0.1 --> >=0.0.1 <0.1.0-0
var replaceTildes = function replaceTildes(comp, options) {
  return comp.trim().split(/\s+/).map(function (c) {
    return replaceTilde(c, options);
  }).join(' ');
};
var replaceTilde = function replaceTilde(comp, options) {
  var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
  return comp.replace(r, function (_, M, m, p, pr) {
    debug('tilde', comp, _, M, m, p, pr);
    var ret;
    if (isX(M)) {
      ret = '';
    } else if (isX(m)) {
      ret = ">=".concat(M, ".0.0 <").concat(+M + 1, ".0.0-0");
    } else if (isX(p)) {
      // ~1.2 == >=1.2.0 <1.3.0-0
      ret = ">=".concat(M, ".").concat(m, ".0 <").concat(M, ".").concat(+m + 1, ".0-0");
    } else if (pr) {
      debug('replaceTilde pr', pr);
      ret = ">=".concat(M, ".").concat(m, ".").concat(p, "-").concat(pr, " <").concat(M, ".").concat(+m + 1, ".0-0");
    } else {
      // ~1.2.3 == >=1.2.3 <1.3.0-0
      ret = ">=".concat(M, ".").concat(m, ".").concat(p, " <").concat(M, ".").concat(+m + 1, ".0-0");
    }
    debug('tilde return', ret);
    return ret;
  });
};

// ^ --> * (any, kinda silly)
// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
// ^1.2.3 --> >=1.2.3 <2.0.0-0
// ^1.2.0 --> >=1.2.0 <2.0.0-0
// ^0.0.1 --> >=0.0.1 <0.0.2-0
// ^0.1.0 --> >=0.1.0 <0.2.0-0
var replaceCarets = function replaceCarets(comp, options) {
  return comp.trim().split(/\s+/).map(function (c) {
    return replaceCaret(c, options);
  }).join(' ');
};
var replaceCaret = function replaceCaret(comp, options) {
  debug('caret', comp, options);
  var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
  var z = options.includePrerelease ? '-0' : '';
  return comp.replace(r, function (_, M, m, p, pr) {
    debug('caret', comp, _, M, m, p, pr);
    var ret;
    if (isX(M)) {
      ret = '';
    } else if (isX(m)) {
      ret = ">=".concat(M, ".0.0").concat(z, " <").concat(+M + 1, ".0.0-0");
    } else if (isX(p)) {
      if (M === '0') {
        ret = ">=".concat(M, ".").concat(m, ".0").concat(z, " <").concat(M, ".").concat(+m + 1, ".0-0");
      } else {
        ret = ">=".concat(M, ".").concat(m, ".0").concat(z, " <").concat(+M + 1, ".0.0-0");
      }
    } else if (pr) {
      debug('replaceCaret pr', pr);
      if (M === '0') {
        if (m === '0') {
          ret = ">=".concat(M, ".").concat(m, ".").concat(p, "-").concat(pr, " <").concat(M, ".").concat(m, ".").concat(+p + 1, "-0");
        } else {
          ret = ">=".concat(M, ".").concat(m, ".").concat(p, "-").concat(pr, " <").concat(M, ".").concat(+m + 1, ".0-0");
        }
      } else {
        ret = ">=".concat(M, ".").concat(m, ".").concat(p, "-").concat(pr, " <").concat(+M + 1, ".0.0-0");
      }
    } else {
      debug('no pr');
      if (M === '0') {
        if (m === '0') {
          ret = ">=".concat(M, ".").concat(m, ".").concat(p).concat(z, " <").concat(M, ".").concat(m, ".").concat(+p + 1, "-0");
        } else {
          ret = ">=".concat(M, ".").concat(m, ".").concat(p).concat(z, " <").concat(M, ".").concat(+m + 1, ".0-0");
        }
      } else {
        ret = ">=".concat(M, ".").concat(m, ".").concat(p, " <").concat(+M + 1, ".0.0-0");
      }
    }
    debug('caret return', ret);
    return ret;
  });
};
var replaceXRanges = function replaceXRanges(comp, options) {
  debug('replaceXRanges', comp, options);
  return comp.split(/\s+/).map(function (c) {
    return replaceXRange(c, options);
  }).join(' ');
};
var replaceXRange = function replaceXRange(comp, options) {
  comp = comp.trim();
  var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
  return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
    debug('xRange', comp, ret, gtlt, M, m, p, pr);
    var xM = isX(M);
    var xm = xM || isX(m);
    var xp = xm || isX(p);
    var anyX = xp;
    if (gtlt === '=' && anyX) {
      gtlt = '';
    }

    // if we're including prereleases in the match, then we need
    // to fix this to -0, the lowest possible prerelease value
    pr = options.includePrerelease ? '-0' : '';
    if (xM) {
      if (gtlt === '>' || gtlt === '<') {
        // nothing is allowed
        ret = '<0.0.0-0';
      } else {
        // nothing is forbidden
        ret = '*';
      }
    } else if (gtlt && anyX) {
      // we know patch is an x, because we have any x at all.
      // replace X with 0
      if (xm) {
        m = 0;
      }
      p = 0;
      if (gtlt === '>') {
        // >1 => >=2.0.0
        // >1.2 => >=1.3.0
        gtlt = '>=';
        if (xm) {
          M = +M + 1;
          m = 0;
          p = 0;
        } else {
          m = +m + 1;
          p = 0;
        }
      } else if (gtlt === '<=') {
        // <=0.7.x is actually <0.8.0, since any 0.7.x should
        // pass.  Similarly, <=7.x is actually <8.0.0, etc.
        gtlt = '<';
        if (xm) {
          M = +M + 1;
        } else {
          m = +m + 1;
        }
      }
      if (gtlt === '<') {
        pr = '-0';
      }
      ret = "".concat(gtlt + M, ".").concat(m, ".").concat(p).concat(pr);
    } else if (xm) {
      ret = ">=".concat(M, ".0.0").concat(pr, " <").concat(+M + 1, ".0.0-0");
    } else if (xp) {
      ret = ">=".concat(M, ".").concat(m, ".0").concat(pr, " <").concat(M, ".").concat(+m + 1, ".0-0");
    }
    debug('xRange return', ret);
    return ret;
  });
};

// Because * is AND-ed with everything else in the comparator,
// and '' means "any version", just remove the *s entirely.
var replaceStars = function replaceStars(comp, options) {
  debug('replaceStars', comp, options);
  // Looseness is ignored here.  star is always as loose as it gets!
  return comp.trim().replace(re[t.STAR], '');
};
var replaceGTE0 = function replaceGTE0(comp, options) {
  debug('replaceGTE0', comp, options);
  return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '');
};

// This function is passed to string.replace(re[t.HYPHENRANGE])
// M, m, patch, prerelease, build
// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
var hyphenReplace = function hyphenReplace(incPr) {
  return function ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
    if (isX(fM)) {
      from = '';
    } else if (isX(fm)) {
      from = ">=".concat(fM, ".0.0").concat(incPr ? '-0' : '');
    } else if (isX(fp)) {
      from = ">=".concat(fM, ".").concat(fm, ".0").concat(incPr ? '-0' : '');
    } else if (fpr) {
      from = ">=".concat(from);
    } else {
      from = ">=".concat(from).concat(incPr ? '-0' : '');
    }
    if (isX(tM)) {
      to = '';
    } else if (isX(tm)) {
      to = "<".concat(+tM + 1, ".0.0-0");
    } else if (isX(tp)) {
      to = "<".concat(tM, ".").concat(+tm + 1, ".0-0");
    } else if (tpr) {
      to = "<=".concat(tM, ".").concat(tm, ".").concat(tp, "-").concat(tpr);
    } else if (incPr) {
      to = "<".concat(tM, ".").concat(tm, ".").concat(+tp + 1, "-0");
    } else {
      to = "<=".concat(to);
    }
    return "".concat(from, " ").concat(to).trim();
  };
};
var testSet = function testSet(set, version, options) {
  for (var i = 0; i < set.length; i++) {
    if (!set[i].test(version)) {
      return false;
    }
  }
  if (version.prerelease.length && !options.includePrerelease) {
    // Find the set of versions that are allowed to have prereleases
    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
    // That should allow `1.2.3-pr.2` to pass.
    // However, `1.2.4-alpha.notready` should NOT be allowed,
    // even though it's within the range set by the comparators.
    for (var _i = 0; _i < set.length; _i++) {
      debug(set[_i].semver);
      if (set[_i].semver === Comparator.ANY) {
        continue;
      }
      if (set[_i].semver.prerelease.length > 0) {
        var allowed = set[_i].semver;
        if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
          return true;
        }
      }
    }

    // Version has a -pre, but it's not one of the ones we like.
    return false;
  }
  return true;
};

/***/ }),

/***/ 1186:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var _classCallCheck = (__webpack_require__(8403)["default"]);
var _createClass = (__webpack_require__(2467)["default"]);
var debug = __webpack_require__(6298);
var _require = __webpack_require__(6028),
  MAX_LENGTH = _require.MAX_LENGTH,
  MAX_SAFE_INTEGER = _require.MAX_SAFE_INTEGER;
var _require2 = __webpack_require__(8369),
  re = _require2.re,
  t = _require2.t;
var parseOptions = __webpack_require__(504);
var _require3 = __webpack_require__(1399),
  compareIdentifiers = _require3.compareIdentifiers;
var SemVer = /*#__PURE__*/function () {
  "use strict";

  function SemVer(version, options) {
    _classCallCheck(this, SemVer);
    options = parseOptions(options);
    if (version instanceof SemVer) {
      if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
        return version;
      } else {
        version = version.version;
      }
    } else if (typeof version !== 'string') {
      throw new TypeError("Invalid Version: ".concat(version));
    }
    if (version.length > MAX_LENGTH) {
      throw new TypeError("version is longer than ".concat(MAX_LENGTH, " characters"));
    }
    debug('SemVer', version, options);
    this.options = options;
    this.loose = !!options.loose;
    // this isn't actually relevant for versions, but keep it so that we
    // don't run into trouble passing this.options around.
    this.includePrerelease = !!options.includePrerelease;
    var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
    if (!m) {
      throw new TypeError("Invalid Version: ".concat(version));
    }
    this.raw = version;

    // these are actually numbers
    this.major = +m[1];
    this.minor = +m[2];
    this.patch = +m[3];
    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
      throw new TypeError('Invalid major version');
    }
    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
      throw new TypeError('Invalid minor version');
    }
    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
      throw new TypeError('Invalid patch version');
    }

    // numberify any prerelease numeric ids
    if (!m[4]) {
      this.prerelease = [];
    } else {
      this.prerelease = m[4].split('.').map(function (id) {
        if (/^[0-9]+$/.test(id)) {
          var num = +id;
          if (num >= 0 && num < MAX_SAFE_INTEGER) {
            return num;
          }
        }
        return id;
      });
    }
    this.build = m[5] ? m[5].split('.') : [];
    this.format();
  }
  _createClass(SemVer, [{
    key: "format",
    value: function format() {
      this.version = "".concat(this.major, ".").concat(this.minor, ".").concat(this.patch);
      if (this.prerelease.length) {
        this.version += "-".concat(this.prerelease.join('.'));
      }
      return this.version;
    }
  }, {
    key: "toString",
    value: function toString() {
      return this.version;
    }
  }, {
    key: "compare",
    value: function compare(other) {
      debug('SemVer.compare', this.version, this.options, other);
      if (!(other instanceof SemVer)) {
        if (typeof other === 'string' && other === this.version) {
          return 0;
        }
        other = new SemVer(other, this.options);
      }
      if (other.version === this.version) {
        return 0;
      }
      return this.compareMain(other) || this.comparePre(other);
    }
  }, {
    key: "compareMain",
    value: function compareMain(other) {
      if (!(other instanceof SemVer)) {
        other = new SemVer(other, this.options);
      }
      return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
    }
  }, {
    key: "comparePre",
    value: function comparePre(other) {
      if (!(other instanceof SemVer)) {
        other = new SemVer(other, this.options);
      }

      // NOT having a prerelease is > having one
      if (this.prerelease.length && !other.prerelease.length) {
        return -1;
      } else if (!this.prerelease.length && other.prerelease.length) {
        return 1;
      } else if (!this.prerelease.length && !other.prerelease.length) {
        return 0;
      }
      var i = 0;
      do {
        var a = this.prerelease[i];
        var b = other.prerelease[i];
        debug('prerelease compare', i, a, b);
        if (a === undefined && b === undefined) {
          return 0;
        } else if (b === undefined) {
          return 1;
        } else if (a === undefined) {
          return -1;
        } else if (a === b) {
          continue;
        } else {
          return compareIdentifiers(a, b);
        }
      } while (++i);
    }
  }, {
    key: "compareBuild",
    value: function compareBuild(other) {
      if (!(other instanceof SemVer)) {
        other = new SemVer(other, this.options);
      }
      var i = 0;
      do {
        var a = this.build[i];
        var b = other.build[i];
        debug('prerelease compare', i, a, b);
        if (a === undefined && b === undefined) {
          return 0;
        } else if (b === undefined) {
          return 1;
        } else if (a === undefined) {
          return -1;
        } else if (a === b) {
          continue;
        } else {
          return compareIdentifiers(a, b);
        }
      } while (++i);
    }

    // preminor will bump the version up to the next minor release, and immediately
    // down to pre-release. premajor and prepatch work the same way.
  }, {
    key: "inc",
    value: function inc(release, identifier, identifierBase) {
      switch (release) {
        case 'premajor':
          this.prerelease.length = 0;
          this.patch = 0;
          this.minor = 0;
          this.major++;
          this.inc('pre', identifier, identifierBase);
          break;
        case 'preminor':
          this.prerelease.length = 0;
          this.patch = 0;
          this.minor++;
          this.inc('pre', identifier, identifierBase);
          break;
        case 'prepatch':
          // If this is already a prerelease, it will bump to the next version
          // drop any prereleases that might already exist, since they are not
          // relevant at this point.
          this.prerelease.length = 0;
          this.inc('patch', identifier, identifierBase);
          this.inc('pre', identifier, identifierBase);
          break;
        // If the input is a non-prerelease version, this acts the same as
        // prepatch.
        case 'prerelease':
          if (this.prerelease.length === 0) {
            this.inc('patch', identifier, identifierBase);
          }
          this.inc('pre', identifier, identifierBase);
          break;
        case 'major':
          // If this is a pre-major version, bump up to the same major version.
          // Otherwise increment major.
          // 1.0.0-5 bumps to 1.0.0
          // 1.1.0 bumps to 2.0.0
          if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
            this.major++;
          }
          this.minor = 0;
          this.patch = 0;
          this.prerelease = [];
          break;
        case 'minor':
          // If this is a pre-minor version, bump up to the same minor version.
          // Otherwise increment minor.
          // 1.2.0-5 bumps to 1.2.0
          // 1.2.1 bumps to 1.3.0
          if (this.patch !== 0 || this.prerelease.length === 0) {
            this.minor++;
          }
          this.patch = 0;
          this.prerelease = [];
          break;
        case 'patch':
          // If this is not a pre-release version, it will increment the patch.
          // If it is a pre-release it will bump up to the same patch version.
          // 1.2.0-5 patches to 1.2.0
          // 1.2.0 patches to 1.2.1
          if (this.prerelease.length === 0) {
            this.patch++;
          }
          this.prerelease = [];
          break;
        // This probably shouldn't be used publicly.
        // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
        case 'pre':
          if (this.prerelease.length === 0) {
            this.prerelease = [0];
          } else {
            var i = this.prerelease.length;
            while (--i >= 0) {
              if (typeof this.prerelease[i] === 'number') {
                this.prerelease[i]++;
                i = -2;
              }
            }
            if (i === -1) {
              // didn't increment anything
              this.prerelease.push(0);
            }
          }
          if (identifier) {
            var base = Number(identifierBase) ? 1 : 0;
            // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
            // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
            if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
              if (isNaN(this.prerelease[1])) {
                this.prerelease = [identifier, base];
              }
            } else {
              this.prerelease = [identifier, base];
            }
          }
          break;
        default:
          throw new Error("invalid increment argument: ".concat(release));
      }
      this.format();
      this.raw = this.version;
      return this;
    }
  }]);
  return SemVer;
}();
module.exports = SemVer;

/***/ }),

/***/ 4129:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var parse = __webpack_require__(9050);
var clean = function clean(version, options) {
  var s = parse(version.trim().replace(/^[=v]+/, ''), options);
  return s ? s.version : null;
};
module.exports = clean;

/***/ }),

/***/ 9900:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var eq = __webpack_require__(488);
var neq = __webpack_require__(5956);
var gt = __webpack_require__(1524);
var gte = __webpack_require__(7488);
var lt = __webpack_require__(4025);
var lte = __webpack_require__(4518);
var cmp = function cmp(a, op, b, loose) {
  switch (op) {
    case '===':
      if (typeof a === 'object') {
        a = a.version;
      }
      if (typeof b === 'object') {
        b = b.version;
      }
      return a === b;
    case '!==':
      if (typeof a === 'object') {
        a = a.version;
      }
      if (typeof b === 'object') {
        b = b.version;
      }
      return a !== b;
    case '':
    case '=':
    case '==':
      return eq(a, b, loose);
    case '!=':
      return neq(a, b, loose);
    case '>':
      return gt(a, b, loose);
    case '>=':
      return gte(a, b, loose);
    case '<':
      return lt(a, b, loose);
    case '<=':
      return lte(a, b, loose);
    default:
      throw new TypeError("Invalid operator: ".concat(op));
  }
};
module.exports = cmp;

/***/ }),

/***/ 4349:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var SemVer = __webpack_require__(1186);
var parse = __webpack_require__(9050);
var _require = __webpack_require__(8369),
  re = _require.re,
  t = _require.t;
var coerce = function coerce(version, options) {
  if (version instanceof SemVer) {
    return version;
  }
  if (typeof version === 'number') {
    version = String(version);
  }
  if (typeof version !== 'string') {
    return null;
  }
  options = options || {};
  var match = null;
  if (!options.rtl) {
    match = version.match(re[t.COERCE]);
  } else {
    // Find the right-most coercible string that does not share
    // a terminus with a more left-ward coercible string.
    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
    //
    // Walk through the string checking with a /g regexp
    // Manually set the index so as to pick up overlapping matches.
    // Stop when we get a match that ends at the string end, since no
    // coercible string can be more right-ward without the same terminus.
    var next;
    while ((next = re[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)) {
      if (!match || next.index + next[0].length !== match.index + match[0].length) {
        match = next;
      }
      re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
    }
    // leave it in a clean state
    re[t.COERCERTL].lastIndex = -1;
  }
  if (match === null) {
    return null;
  }
  return parse("".concat(match[2], ".").concat(match[3] || '0', ".").concat(match[4] || '0'), options);
};
module.exports = coerce;

/***/ }),

/***/ 1999:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var SemVer = __webpack_require__(1186);
var compareBuild = function compareBuild(a, b, loose) {
  var versionA = new SemVer(a, loose);
  var versionB = new SemVer(b, loose);
  return versionA.compare(versionB) || versionA.compareBuild(versionB);
};
module.exports = compareBuild;

/***/ }),

/***/ 6368:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var compare = __webpack_require__(1119);
var compareLoose = function compareLoose(a, b) {
  return compare(a, b, true);
};
module.exports = compareLoose;

/***/ }),

/***/ 1119:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var SemVer = __webpack_require__(1186);
var compare = function compare(a, b, loose) {
  return new SemVer(a, loose).compare(new SemVer(b, loose));
};
module.exports = compare;

/***/ }),

/***/ 754:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var parse = __webpack_require__(9050);
var eq = __webpack_require__(488);
var diff = function diff(version1, version2) {
  var v1 = parse(version1);
  var v2 = parse(version2);
  if (eq(v1, v2)) {
    return null;
  } else {
    var hasPre = v1.prerelease.length || v2.prerelease.length;
    var prefix = hasPre ? 'pre' : '';
    var defaultResult = hasPre ? 'prerelease' : '';
    if (v1.major !== v2.major) {
      return prefix + 'major';
    }
    if (v1.minor !== v2.minor) {
      return prefix + 'minor';
    }
    if (v1.patch !== v2.patch) {
      return prefix + 'patch';
    }
    if (!v1.prerelease.length || !v2.prerelease.length) {
      if (v1.patch) {
        return 'patch';
      }
      if (v1.minor) {
        return 'minor';
      }
      if (v1.major) {
        return 'major';
      }
    }
    return defaultResult; // may be undefined
  }
};

module.exports = diff;

/***/ }),

/***/ 488:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var compare = __webpack_require__(1119);
var eq = function eq(a, b, loose) {
  return compare(a, b, loose) === 0;
};
module.exports = eq;

/***/ }),

/***/ 1524:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var compare = __webpack_require__(1119);
var gt = function gt(a, b, loose) {
  return compare(a, b, loose) > 0;
};
module.exports = gt;

/***/ }),

/***/ 7488:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var compare = __webpack_require__(1119);
var gte = function gte(a, b, loose) {
  return compare(a, b, loose) >= 0;
};
module.exports = gte;

/***/ }),

/***/ 5574:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var SemVer = __webpack_require__(1186);
var inc = function inc(version, release, options, identifier, identifierBase) {
  if (typeof options === 'string') {
    identifierBase = identifier;
    identifier = options;
    options = undefined;
  }
  try {
    return new SemVer(version instanceof SemVer ? version.version : version, options).inc(release, identifier, identifierBase).version;
  } catch (er) {
    return null;
  }
};
module.exports = inc;

/***/ }),

/***/ 4025:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var compare = __webpack_require__(1119);
var lt = function lt(a, b, loose) {
  return compare(a, b, loose) < 0;
};
module.exports = lt;

/***/ }),

/***/ 4518:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var compare = __webpack_require__(1119);
var lte = function lte(a, b, loose) {
  return compare(a, b, loose) <= 0;
};
module.exports = lte;

/***/ }),

/***/ 9715:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var SemVer = __webpack_require__(1186);
var major = function major(a, loose) {
  return new SemVer(a, loose).major;
};
module.exports = major;

/***/ }),

/***/ 2303:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var SemVer = __webpack_require__(1186);
var minor = function minor(a, loose) {
  return new SemVer(a, loose).minor;
};
module.exports = minor;

/***/ }),

/***/ 5956:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var compare = __webpack_require__(1119);
var neq = function neq(a, b, loose) {
  return compare(a, b, loose) !== 0;
};
module.exports = neq;

/***/ }),

/***/ 9050:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var _require = __webpack_require__(6028),
  MAX_LENGTH = _require.MAX_LENGTH;
var SemVer = __webpack_require__(1186);
var parse = function parse(version, options) {
  if (version instanceof SemVer) {
    return version;
  }
  if (typeof version !== 'string') {
    return null;
  }
  if (version.length > MAX_LENGTH) {
    return null;
  }
  try {
    return new SemVer(version, options);
  } catch (er) {
    return null;
  }
};
module.exports = parse;

/***/ }),

/***/ 8210:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var SemVer = __webpack_require__(1186);
var patch = function patch(a, loose) {
  return new SemVer(a, loose).patch;
};
module.exports = patch;

/***/ }),

/***/ 2161:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var parse = __webpack_require__(9050);
var prerelease = function prerelease(version, options) {
  var parsed = parse(version, options);
  return parsed && parsed.prerelease.length ? parsed.prerelease : null;
};
module.exports = prerelease;

/***/ }),

/***/ 4698:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var compare = __webpack_require__(1119);
var rcompare = function rcompare(a, b, loose) {
  return compare(b, a, loose);
};
module.exports = rcompare;

/***/ }),

/***/ 7331:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var compareBuild = __webpack_require__(1999);
var rsort = function rsort(list, loose) {
  return list.sort(function (a, b) {
    return compareBuild(b, a, loose);
  });
};
module.exports = rsort;

/***/ }),

/***/ 3597:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var Range = __webpack_require__(7258);
var satisfies = function satisfies(version, range, options) {
  try {
    range = new Range(range, options);
  } catch (er) {
    return false;
  }
  return range.test(version);
};
module.exports = satisfies;

/***/ }),

/***/ 8097:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var compareBuild = __webpack_require__(1999);
var sort = function sort(list, loose) {
  return list.sort(function (a, b) {
    return compareBuild(a, b, loose);
  });
};
module.exports = sort;

/***/ }),

/***/ 1635:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var parse = __webpack_require__(9050);
var valid = function valid(version, options) {
  var v = parse(version, options);
  return v ? v.version : null;
};
module.exports = valid;

/***/ }),

/***/ 9383:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

// just pre-load all the stuff that index.js lazily exports
var internalRe = __webpack_require__(8369);
var constants = __webpack_require__(6028);
var SemVer = __webpack_require__(1186);
var identifiers = __webpack_require__(1399);
var parse = __webpack_require__(9050);
var valid = __webpack_require__(1635);
var clean = __webpack_require__(4129);
var inc = __webpack_require__(5574);
var diff = __webpack_require__(754);
var major = __webpack_require__(9715);
var minor = __webpack_require__(2303);
var patch = __webpack_require__(8210);
var prerelease = __webpack_require__(2161);
var compare = __webpack_require__(1119);
var rcompare = __webpack_require__(4698);
var compareLoose = __webpack_require__(6368);
var compareBuild = __webpack_require__(1999);
var sort = __webpack_require__(8097);
var rsort = __webpack_require__(7331);
var gt = __webpack_require__(1524);
var lt = __webpack_require__(4025);
var eq = __webpack_require__(488);
var neq = __webpack_require__(5956);
var gte = __webpack_require__(7488);
var lte = __webpack_require__(4518);
var cmp = __webpack_require__(9900);
var coerce = __webpack_require__(4349);
var Comparator = __webpack_require__(301);
var Range = __webpack_require__(7258);
var satisfies = __webpack_require__(3597);
var toComparators = __webpack_require__(9002);
var maxSatisfying = __webpack_require__(3711);
var minSatisfying = __webpack_require__(7245);
var minVersion = __webpack_require__(9074);
var validRange = __webpack_require__(5359);
var outside = __webpack_require__(8815);
var gtr = __webpack_require__(46);
var ltr = __webpack_require__(6062);
var intersects = __webpack_require__(9378);
var simplifyRange = __webpack_require__(4989);
var subset = __webpack_require__(8701);
module.exports = {
  parse: parse,
  valid: valid,
  clean: clean,
  inc: inc,
  diff: diff,
  major: major,
  minor: minor,
  patch: patch,
  prerelease: prerelease,
  compare: compare,
  rcompare: rcompare,
  compareLoose: compareLoose,
  compareBuild: compareBuild,
  sort: sort,
  rsort: rsort,
  gt: gt,
  lt: lt,
  eq: eq,
  neq: neq,
  gte: gte,
  lte: lte,
  cmp: cmp,
  coerce: coerce,
  Comparator: Comparator,
  Range: Range,
  satisfies: satisfies,
  toComparators: toComparators,
  maxSatisfying: maxSatisfying,
  minSatisfying: minSatisfying,
  minVersion: minVersion,
  validRange: validRange,
  outside: outside,
  gtr: gtr,
  ltr: ltr,
  intersects: intersects,
  simplifyRange: simplifyRange,
  subset: subset,
  SemVer: SemVer,
  re: internalRe.re,
  src: internalRe.src,
  tokens: internalRe.t,
  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
  RELEASE_TYPES: constants.RELEASE_TYPES,
  compareIdentifiers: identifiers.compareIdentifiers,
  rcompareIdentifiers: identifiers.rcompareIdentifiers
};

/***/ }),

/***/ 6028:
/***/ (function(module) {

// Note: this is the semver.org version of the spec that it implements
// Not necessarily the package version of this code.
var SEMVER_SPEC_VERSION = '2.0.0';
var MAX_LENGTH = 256;
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */9007199254740991;

// Max safe segment length for coercion.
var MAX_SAFE_COMPONENT_LENGTH = 16;
var RELEASE_TYPES = ['major', 'premajor', 'minor', 'preminor', 'patch', 'prepatch', 'prerelease'];
module.exports = {
  MAX_LENGTH: MAX_LENGTH,
  MAX_SAFE_COMPONENT_LENGTH: MAX_SAFE_COMPONENT_LENGTH,
  MAX_SAFE_INTEGER: MAX_SAFE_INTEGER,
  RELEASE_TYPES: RELEASE_TYPES,
  SEMVER_SPEC_VERSION: SEMVER_SPEC_VERSION,
  FLAG_INCLUDE_PRERELEASE: 1,
  FLAG_LOOSE: 2
};

/***/ }),

/***/ 6298:
/***/ (function(module) {

var debug = typeof process === 'object' && ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}) && ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}).NODE_DEBUG && /\bsemver\b/i.test(({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}).NODE_DEBUG) ? function () {
  var _console;
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }
  return (_console = console).error.apply(_console, ['SEMVER'].concat(args));
} : function () {};
module.exports = debug;

/***/ }),

/***/ 1399:
/***/ (function(module) {

var numeric = /^[0-9]+$/;
var compareIdentifiers = function compareIdentifiers(a, b) {
  var anum = numeric.test(a);
  var bnum = numeric.test(b);
  if (anum && bnum) {
    a = +a;
    b = +b;
  }
  return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
};
var rcompareIdentifiers = function rcompareIdentifiers(a, b) {
  return compareIdentifiers(b, a);
};
module.exports = {
  compareIdentifiers: compareIdentifiers,
  rcompareIdentifiers: rcompareIdentifiers
};

/***/ }),

/***/ 504:
/***/ (function(module) {

// parse out just the options we care about
var looseOption = Object.freeze({
  loose: true
});
var emptyOpts = Object.freeze({});
var parseOptions = function parseOptions(options) {
  if (!options) {
    return emptyOpts;
  }
  if (typeof options !== 'object') {
    return looseOption;
  }
  return options;
};
module.exports = parseOptions;

/***/ }),

/***/ 8369:
/***/ (function(module, exports, __webpack_require__) {

var _require = __webpack_require__(6028),
  MAX_SAFE_COMPONENT_LENGTH = _require.MAX_SAFE_COMPONENT_LENGTH;
var debug = __webpack_require__(6298);
exports = module.exports = {};

// The actual regexps go on exports.re
var re = exports.re = [];
var src = exports.src = [];
var t = exports.t = {};
var R = 0;
var createToken = function createToken(name, value, isGlobal) {
  var index = R++;
  debug(name, index, value);
  t[name] = index;
  src[index] = value;
  re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
};

// The following Regular Expressions can be used for tokenizing,
// validating, and parsing SemVer version strings.

// ## Numeric Identifier
// A single `0`, or a non-zero digit followed by zero or more digits.

createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+');

// ## Non-numeric Identifier
// Zero or more digits, followed by a letter or hyphen, and then zero or
// more letters, digits, or hyphens.

createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*');

// ## Main Version
// Three dot-separated numeric identifiers.

createToken('MAINVERSION', "(".concat(src[t.NUMERICIDENTIFIER], ")\\.") + "(".concat(src[t.NUMERICIDENTIFIER], ")\\.") + "(".concat(src[t.NUMERICIDENTIFIER], ")"));
createToken('MAINVERSIONLOOSE', "(".concat(src[t.NUMERICIDENTIFIERLOOSE], ")\\.") + "(".concat(src[t.NUMERICIDENTIFIERLOOSE], ")\\.") + "(".concat(src[t.NUMERICIDENTIFIERLOOSE], ")"));

// ## Pre-release Version Identifier
// A numeric identifier, or a non-numeric identifier.

createToken('PRERELEASEIDENTIFIER', "(?:".concat(src[t.NUMERICIDENTIFIER], "|").concat(src[t.NONNUMERICIDENTIFIER], ")"));
createToken('PRERELEASEIDENTIFIERLOOSE', "(?:".concat(src[t.NUMERICIDENTIFIERLOOSE], "|").concat(src[t.NONNUMERICIDENTIFIER], ")"));

// ## Pre-release Version
// Hyphen, followed by one or more dot-separated pre-release version
// identifiers.

createToken('PRERELEASE', "(?:-(".concat(src[t.PRERELEASEIDENTIFIER], "(?:\\.").concat(src[t.PRERELEASEIDENTIFIER], ")*))"));
createToken('PRERELEASELOOSE', "(?:-?(".concat(src[t.PRERELEASEIDENTIFIERLOOSE], "(?:\\.").concat(src[t.PRERELEASEIDENTIFIERLOOSE], ")*))"));

// ## Build Metadata Identifier
// Any combination of digits, letters, or hyphens.

createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+');

// ## Build Metadata
// Plus sign, followed by one or more period-separated build metadata
// identifiers.

createToken('BUILD', "(?:\\+(".concat(src[t.BUILDIDENTIFIER], "(?:\\.").concat(src[t.BUILDIDENTIFIER], ")*))"));

// ## Full Version String
// A main version, followed optionally by a pre-release version and
// build metadata.

// Note that the only major, minor, patch, and pre-release sections of
// the version string are capturing groups.  The build metadata is not a
// capturing group, because it should not ever be used in version
// comparison.

createToken('FULLPLAIN', "v?".concat(src[t.MAINVERSION]).concat(src[t.PRERELEASE], "?").concat(src[t.BUILD], "?"));
createToken('FULL', "^".concat(src[t.FULLPLAIN], "$"));

// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
// common in the npm registry.
createToken('LOOSEPLAIN', "[v=\\s]*".concat(src[t.MAINVERSIONLOOSE]).concat(src[t.PRERELEASELOOSE], "?").concat(src[t.BUILD], "?"));
createToken('LOOSE', "^".concat(src[t.LOOSEPLAIN], "$"));
createToken('GTLT', '((?:<|>)?=?)');

// Something like "2.*" or "1.2.x".
// Note that "x.x" is a valid xRange identifer, meaning "any version"
// Only the first item is strictly required.
createToken('XRANGEIDENTIFIERLOOSE', "".concat(src[t.NUMERICIDENTIFIERLOOSE], "|x|X|\\*"));
createToken('XRANGEIDENTIFIER', "".concat(src[t.NUMERICIDENTIFIER], "|x|X|\\*"));
createToken('XRANGEPLAIN', "[v=\\s]*(".concat(src[t.XRANGEIDENTIFIER], ")") + "(?:\\.(".concat(src[t.XRANGEIDENTIFIER], ")") + "(?:\\.(".concat(src[t.XRANGEIDENTIFIER], ")") + "(?:".concat(src[t.PRERELEASE], ")?").concat(src[t.BUILD], "?") + ")?)?");
createToken('XRANGEPLAINLOOSE', "[v=\\s]*(".concat(src[t.XRANGEIDENTIFIERLOOSE], ")") + "(?:\\.(".concat(src[t.XRANGEIDENTIFIERLOOSE], ")") + "(?:\\.(".concat(src[t.XRANGEIDENTIFIERLOOSE], ")") + "(?:".concat(src[t.PRERELEASELOOSE], ")?").concat(src[t.BUILD], "?") + ")?)?");
createToken('XRANGE', "^".concat(src[t.GTLT], "\\s*").concat(src[t.XRANGEPLAIN], "$"));
createToken('XRANGELOOSE', "^".concat(src[t.GTLT], "\\s*").concat(src[t.XRANGEPLAINLOOSE], "$"));

// Coercion.
// Extract anything that could conceivably be a part of a valid semver
createToken('COERCE', "".concat('(^|[^\\d])' + '(\\d{1,').concat(MAX_SAFE_COMPONENT_LENGTH, "})") + "(?:\\.(\\d{1,".concat(MAX_SAFE_COMPONENT_LENGTH, "}))?") + "(?:\\.(\\d{1,".concat(MAX_SAFE_COMPONENT_LENGTH, "}))?") + "(?:$|[^\\d])");
createToken('COERCERTL', src[t.COERCE], true);

// Tilde ranges.
// Meaning is "reasonably at or greater than"
createToken('LONETILDE', '(?:~>?)');
createToken('TILDETRIM', "(\\s*)".concat(src[t.LONETILDE], "\\s+"), true);
exports.tildeTrimReplace = '$1~';
createToken('TILDE', "^".concat(src[t.LONETILDE]).concat(src[t.XRANGEPLAIN], "$"));
createToken('TILDELOOSE', "^".concat(src[t.LONETILDE]).concat(src[t.XRANGEPLAINLOOSE], "$"));

// Caret ranges.
// Meaning is "at least and backwards compatible with"
createToken('LONECARET', '(?:\\^)');
createToken('CARETTRIM', "(\\s*)".concat(src[t.LONECARET], "\\s+"), true);
exports.caretTrimReplace = '$1^';
createToken('CARET', "^".concat(src[t.LONECARET]).concat(src[t.XRANGEPLAIN], "$"));
createToken('CARETLOOSE', "^".concat(src[t.LONECARET]).concat(src[t.XRANGEPLAINLOOSE], "$"));

// A simple gt/lt/eq thing, or just "" to indicate "any version"
createToken('COMPARATORLOOSE', "^".concat(src[t.GTLT], "\\s*(").concat(src[t.LOOSEPLAIN], ")$|^$"));
createToken('COMPARATOR', "^".concat(src[t.GTLT], "\\s*(").concat(src[t.FULLPLAIN], ")$|^$"));

// An expression to strip any whitespace between the gtlt and the thing
// it modifies, so that `> 1.2.3` ==> `>1.2.3`
createToken('COMPARATORTRIM', "(\\s*)".concat(src[t.GTLT], "\\s*(").concat(src[t.LOOSEPLAIN], "|").concat(src[t.XRANGEPLAIN], ")"), true);
exports.comparatorTrimReplace = '$1$2$3';

// Something like `1.2.3 - 1.2.4`
// Note that these all use the loose form, because they'll be
// checked against either the strict or loose comparator form
// later.
createToken('HYPHENRANGE', "^\\s*(".concat(src[t.XRANGEPLAIN], ")") + "\\s+-\\s+" + "(".concat(src[t.XRANGEPLAIN], ")") + "\\s*$");
createToken('HYPHENRANGELOOSE', "^\\s*(".concat(src[t.XRANGEPLAINLOOSE], ")") + "\\s+-\\s+" + "(".concat(src[t.XRANGEPLAINLOOSE], ")") + "\\s*$");

// Star ranges basically just allow anything at all.
createToken('STAR', '(<|>)?=?\\s*\\*');
// >=0.0.0 is like a star
createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$');
createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$');

/***/ }),

/***/ 46:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

// Determine if version is greater than all the versions possible in the range.
var outside = __webpack_require__(8815);
var gtr = function gtr(version, range, options) {
  return outside(version, range, '>', options);
};
module.exports = gtr;

/***/ }),

/***/ 9378:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var Range = __webpack_require__(7258);
var intersects = function intersects(r1, r2, options) {
  r1 = new Range(r1, options);
  r2 = new Range(r2, options);
  return r1.intersects(r2, options);
};
module.exports = intersects;

/***/ }),

/***/ 6062:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var outside = __webpack_require__(8815);
// Determine if version is less than all the versions possible in the range
var ltr = function ltr(version, range, options) {
  return outside(version, range, '<', options);
};
module.exports = ltr;

/***/ }),

/***/ 3711:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var SemVer = __webpack_require__(1186);
var Range = __webpack_require__(7258);
var maxSatisfying = function maxSatisfying(versions, range, options) {
  var max = null;
  var maxSV = null;
  var rangeObj = null;
  try {
    rangeObj = new Range(range, options);
  } catch (er) {
    return null;
  }
  versions.forEach(function (v) {
    if (rangeObj.test(v)) {
      // satisfies(v, range, options)
      if (!max || maxSV.compare(v) === -1) {
        // compare(max, v, true)
        max = v;
        maxSV = new SemVer(max, options);
      }
    }
  });
  return max;
};
module.exports = maxSatisfying;

/***/ }),

/***/ 7245:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var SemVer = __webpack_require__(1186);
var Range = __webpack_require__(7258);
var minSatisfying = function minSatisfying(versions, range, options) {
  var min = null;
  var minSV = null;
  var rangeObj = null;
  try {
    rangeObj = new Range(range, options);
  } catch (er) {
    return null;
  }
  versions.forEach(function (v) {
    if (rangeObj.test(v)) {
      // satisfies(v, range, options)
      if (!min || minSV.compare(v) === 1) {
        // compare(min, v, true)
        min = v;
        minSV = new SemVer(min, options);
      }
    }
  });
  return min;
};
module.exports = minSatisfying;

/***/ }),

/***/ 9074:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var SemVer = __webpack_require__(1186);
var Range = __webpack_require__(7258);
var gt = __webpack_require__(1524);
var minVersion = function minVersion(range, loose) {
  range = new Range(range, loose);
  var minver = new SemVer('0.0.0');
  if (range.test(minver)) {
    return minver;
  }
  minver = new SemVer('0.0.0-0');
  if (range.test(minver)) {
    return minver;
  }
  minver = null;
  var _loop = function _loop() {
    var comparators = range.set[i];
    var setMin = null;
    comparators.forEach(function (comparator) {
      // Clone to avoid manipulating the comparator's semver object.
      var compver = new SemVer(comparator.semver.version);
      switch (comparator.operator) {
        case '>':
          if (compver.prerelease.length === 0) {
            compver.patch++;
          } else {
            compver.prerelease.push(0);
          }
          compver.raw = compver.format();
        /* fallthrough */
        case '':
        case '>=':
          if (!setMin || gt(compver, setMin)) {
            setMin = compver;
          }
          break;
        case '<':
        case '<=':
          /* Ignore maximum versions */
          break;
        /* istanbul ignore next */
        default:
          throw new Error("Unexpected operation: ".concat(comparator.operator));
      }
    });
    if (setMin && (!minver || gt(minver, setMin))) {
      minver = setMin;
    }
  };
  for (var i = 0; i < range.set.length; ++i) {
    _loop();
  }
  if (minver && range.test(minver)) {
    return minver;
  }
  return null;
};
module.exports = minVersion;

/***/ }),

/***/ 8815:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var SemVer = __webpack_require__(1186);
var Comparator = __webpack_require__(301);
var ANY = Comparator.ANY;
var Range = __webpack_require__(7258);
var satisfies = __webpack_require__(3597);
var gt = __webpack_require__(1524);
var lt = __webpack_require__(4025);
var lte = __webpack_require__(4518);
var gte = __webpack_require__(7488);
var outside = function outside(version, range, hilo, options) {
  version = new SemVer(version, options);
  range = new Range(range, options);
  var gtfn, ltefn, ltfn, comp, ecomp;
  switch (hilo) {
    case '>':
      gtfn = gt;
      ltefn = lte;
      ltfn = lt;
      comp = '>';
      ecomp = '>=';
      break;
    case '<':
      gtfn = lt;
      ltefn = gte;
      ltfn = gt;
      comp = '<';
      ecomp = '<=';
      break;
    default:
      throw new TypeError('Must provide a hilo val of "<" or ">"');
  }

  // If it satisfies the range it is not outside
  if (satisfies(version, range, options)) {
    return false;
  }

  // From now on, variable terms are as if we're in "gtr" mode.
  // but note that everything is flipped for the "ltr" function.
  var _loop = function _loop() {
    var comparators = range.set[i];
    var high = null;
    var low = null;
    comparators.forEach(function (comparator) {
      if (comparator.semver === ANY) {
        comparator = new Comparator('>=0.0.0');
      }
      high = high || comparator;
      low = low || comparator;
      if (gtfn(comparator.semver, high.semver, options)) {
        high = comparator;
      } else if (ltfn(comparator.semver, low.semver, options)) {
        low = comparator;
      }
    });

    // If the edge version comparator has a operator then our version
    // isn't outside it
    if (high.operator === comp || high.operator === ecomp) {
      return {
        v: false
      };
    }

    // If the lowest version comparator has an operator and our version
    // is less than it then it isn't higher than the range
    if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
      return {
        v: false
      };
    } else if (low.operator === ecomp && ltfn(version, low.semver)) {
      return {
        v: false
      };
    }
  };
  for (var i = 0; i < range.set.length; ++i) {
    var _ret = _loop();
    if (typeof _ret === "object") return _ret.v;
  }
  return true;
};
module.exports = outside;

/***/ }),

/***/ 4989:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var _slicedToArray = (__webpack_require__(6854)["default"]);
var _createForOfIteratorHelper = (__webpack_require__(3762)["default"]);
// given a set of versions and a range, create a "simplified" range
// that includes the same versions that the original range does
// If the original range is shorter than the simplified one, return that.
var satisfies = __webpack_require__(3597);
var compare = __webpack_require__(1119);
module.exports = function (versions, range, options) {
  var set = [];
  var first = null;
  var prev = null;
  var v = versions.sort(function (a, b) {
    return compare(a, b, options);
  });
  var _iterator = _createForOfIteratorHelper(v),
    _step;
  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var version = _step.value;
      var included = satisfies(version, range, options);
      if (included) {
        prev = version;
        if (!first) {
          first = version;
        }
      } else {
        if (prev) {
          set.push([first, prev]);
        }
        prev = null;
        first = null;
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
  if (first) {
    set.push([first, null]);
  }
  var ranges = [];
  for (var _i = 0, _set = set; _i < _set.length; _i++) {
    var _set$_i = _slicedToArray(_set[_i], 2),
      min = _set$_i[0],
      max = _set$_i[1];
    if (min === max) {
      ranges.push(min);
    } else if (!max && min === v[0]) {
      ranges.push('*');
    } else if (!max) {
      ranges.push(">=".concat(min));
    } else if (min === v[0]) {
      ranges.push("<=".concat(max));
    } else {
      ranges.push("".concat(min, " - ").concat(max));
    }
  }
  var simplified = ranges.join(' || ');
  var original = typeof range.raw === 'string' ? range.raw : String(range);
  return simplified.length < original.length ? simplified : range;
};

/***/ }),

/***/ 8701:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var _createForOfIteratorHelper = (__webpack_require__(3762)["default"]);
var Range = __webpack_require__(7258);
var Comparator = __webpack_require__(301);
var ANY = Comparator.ANY;
var satisfies = __webpack_require__(3597);
var compare = __webpack_require__(1119);

// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:
// - Every simple range `r1, r2, ...` is a null set, OR
// - Every simple range `r1, r2, ...` which is not a null set is a subset of
//   some `R1, R2, ...`
//
// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:
// - If c is only the ANY comparator
//   - If C is only the ANY comparator, return true
//   - Else if in prerelease mode, return false
//   - else replace c with `[>=0.0.0]`
// - If C is only the ANY comparator
//   - if in prerelease mode, return true
//   - else replace C with `[>=0.0.0]`
// - Let EQ be the set of = comparators in c
// - If EQ is more than one, return true (null set)
// - Let GT be the highest > or >= comparator in c
// - Let LT be the lowest < or <= comparator in c
// - If GT and LT, and GT.semver > LT.semver, return true (null set)
// - If any C is a = range, and GT or LT are set, return false
// - If EQ
//   - If GT, and EQ does not satisfy GT, return true (null set)
//   - If LT, and EQ does not satisfy LT, return true (null set)
//   - If EQ satisfies every C, return true
//   - Else return false
// - If GT
//   - If GT.semver is lower than any > or >= comp in C, return false
//   - If GT is >=, and GT.semver does not satisfy every C, return false
//   - If GT.semver has a prerelease, and not in prerelease mode
//     - If no C has a prerelease and the GT.semver tuple, return false
// - If LT
//   - If LT.semver is greater than any < or <= comp in C, return false
//   - If LT is <=, and LT.semver does not satisfy every C, return false
//   - If GT.semver has a prerelease, and not in prerelease mode
//     - If no C has a prerelease and the LT.semver tuple, return false
// - Else return true

var subset = function subset(sub, dom) {
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  if (sub === dom) {
    return true;
  }
  sub = new Range(sub, options);
  dom = new Range(dom, options);
  var sawNonNull = false;
  var _iterator = _createForOfIteratorHelper(sub.set),
    _step;
  try {
    OUTER: for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var simpleSub = _step.value;
      var _iterator2 = _createForOfIteratorHelper(dom.set),
        _step2;
      try {
        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
          var simpleDom = _step2.value;
          var isSub = simpleSubset(simpleSub, simpleDom, options);
          sawNonNull = sawNonNull || isSub !== null;
          if (isSub) {
            continue OUTER;
          }
        }
        // the null set is a subset of everything, but null simple ranges in
        // a complex range should be ignored.  so if we saw a non-null range,
        // then we know this isn't a subset, but if EVERY simple range was null,
        // then it is a subset.
      } catch (err) {
        _iterator2.e(err);
      } finally {
        _iterator2.f();
      }
      if (sawNonNull) {
        return false;
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
  return true;
};
var minimumVersionWithPreRelease = [new Comparator('>=0.0.0-0')];
var minimumVersion = [new Comparator('>=0.0.0')];
var simpleSubset = function simpleSubset(sub, dom, options) {
  if (sub === dom) {
    return true;
  }
  if (sub.length === 1 && sub[0].semver === ANY) {
    if (dom.length === 1 && dom[0].semver === ANY) {
      return true;
    } else if (options.includePrerelease) {
      sub = minimumVersionWithPreRelease;
    } else {
      sub = minimumVersion;
    }
  }
  if (dom.length === 1 && dom[0].semver === ANY) {
    if (options.includePrerelease) {
      return true;
    } else {
      dom = minimumVersion;
    }
  }
  var eqSet = new Set();
  var gt, lt;
  var _iterator3 = _createForOfIteratorHelper(sub),
    _step3;
  try {
    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
      var c = _step3.value;
      if (c.operator === '>' || c.operator === '>=') {
        gt = higherGT(gt, c, options);
      } else if (c.operator === '<' || c.operator === '<=') {
        lt = lowerLT(lt, c, options);
      } else {
        eqSet.add(c.semver);
      }
    }
  } catch (err) {
    _iterator3.e(err);
  } finally {
    _iterator3.f();
  }
  if (eqSet.size > 1) {
    return null;
  }
  var gtltComp;
  if (gt && lt) {
    gtltComp = compare(gt.semver, lt.semver, options);
    if (gtltComp > 0) {
      return null;
    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {
      return null;
    }
  }

  // will iterate one or zero times
  var _iterator4 = _createForOfIteratorHelper(eqSet),
    _step4;
  try {
    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
      var eq = _step4.value;
      if (gt && !satisfies(eq, String(gt), options)) {
        return null;
      }
      if (lt && !satisfies(eq, String(lt), options)) {
        return null;
      }
      var _iterator6 = _createForOfIteratorHelper(dom),
        _step6;
      try {
        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
          var _c = _step6.value;
          if (!satisfies(eq, String(_c), options)) {
            return false;
          }
        }
      } catch (err) {
        _iterator6.e(err);
      } finally {
        _iterator6.f();
      }
      return true;
    }
  } catch (err) {
    _iterator4.e(err);
  } finally {
    _iterator4.f();
  }
  var higher, lower;
  var hasDomLT, hasDomGT;
  // if the subset has a prerelease, we need a comparator in the superset
  // with the same tuple and a prerelease, or it's not a subset
  var needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
  var needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
  // exception: <1.2.3-0 is the same as <1.2.3
  if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {
    needDomLTPre = false;
  }
  var _iterator5 = _createForOfIteratorHelper(dom),
    _step5;
  try {
    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
      var _c2 = _step5.value;
      hasDomGT = hasDomGT || _c2.operator === '>' || _c2.operator === '>=';
      hasDomLT = hasDomLT || _c2.operator === '<' || _c2.operator === '<=';
      if (gt) {
        if (needDomGTPre) {
          if (_c2.semver.prerelease && _c2.semver.prerelease.length && _c2.semver.major === needDomGTPre.major && _c2.semver.minor === needDomGTPre.minor && _c2.semver.patch === needDomGTPre.patch) {
            needDomGTPre = false;
          }
        }
        if (_c2.operator === '>' || _c2.operator === '>=') {
          higher = higherGT(gt, _c2, options);
          if (higher === _c2 && higher !== gt) {
            return false;
          }
        } else if (gt.operator === '>=' && !satisfies(gt.semver, String(_c2), options)) {
          return false;
        }
      }
      if (lt) {
        if (needDomLTPre) {
          if (_c2.semver.prerelease && _c2.semver.prerelease.length && _c2.semver.major === needDomLTPre.major && _c2.semver.minor === needDomLTPre.minor && _c2.semver.patch === needDomLTPre.patch) {
            needDomLTPre = false;
          }
        }
        if (_c2.operator === '<' || _c2.operator === '<=') {
          lower = lowerLT(lt, _c2, options);
          if (lower === _c2 && lower !== lt) {
            return false;
          }
        } else if (lt.operator === '<=' && !satisfies(lt.semver, String(_c2), options)) {
          return false;
        }
      }
      if (!_c2.operator && (lt || gt) && gtltComp !== 0) {
        return false;
      }
    }

    // if there was a < or >, and nothing in the dom, then must be false
    // UNLESS it was limited by another range in the other direction.
    // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
  } catch (err) {
    _iterator5.e(err);
  } finally {
    _iterator5.f();
  }
  if (gt && hasDomLT && !lt && gtltComp !== 0) {
    return false;
  }
  if (lt && hasDomGT && !gt && gtltComp !== 0) {
    return false;
  }

  // we needed a prerelease range in a specific tuple, but didn't get one
  // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,
  // because it includes prereleases in the 1.2.3 tuple
  if (needDomGTPre || needDomLTPre) {
    return false;
  }
  return true;
};

// >=1.2.3 is lower than >1.2.3
var higherGT = function higherGT(a, b, options) {
  if (!a) {
    return b;
  }
  var comp = compare(a.semver, b.semver, options);
  return comp > 0 ? a : comp < 0 ? b : b.operator === '>' && a.operator === '>=' ? b : a;
};

// <=1.2.3 is higher than <1.2.3
var lowerLT = function lowerLT(a, b, options) {
  if (!a) {
    return b;
  }
  var comp = compare(a.semver, b.semver, options);
  return comp < 0 ? a : comp > 0 ? b : b.operator === '<' && a.operator === '<=' ? b : a;
};
module.exports = subset;

/***/ }),

/***/ 9002:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var Range = __webpack_require__(7258);

// Mostly just for testing and legacy API reasons
var toComparators = function toComparators(range, options) {
  return new Range(range, options).set.map(function (comp) {
    return comp.map(function (c) {
      return c.value;
    }).join(' ').trim().split(' ');
  });
};
module.exports = toComparators;

/***/ }),

/***/ 5359:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var Range = __webpack_require__(7258);
var validRange = function validRange(range, options) {
  try {
    // Return '*' instead of '' so that truthiness works.
    // This will throw if it's invalid anyway
    return new Range(range, options).range || '*';
  } catch (er) {
    return null;
  }
};
module.exports = validRange;

/***/ }),

/***/ 7537:
/***/ (function(module) {

//

module.exports = function shallowEqual(objA, objB, compare, compareContext) {
  var ret = compare ? compare.call(compareContext, objA, objB) : void 0;
  if (ret !== void 0) {
    return !!ret;
  }
  if (objA === objB) {
    return true;
  }
  if (typeof objA !== "object" || !objA || typeof objB !== "object" || !objB) {
    return false;
  }
  var keysA = Object.keys(objA);
  var keysB = Object.keys(objB);
  if (keysA.length !== keysB.length) {
    return false;
  }
  var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);

  // Test for A's keys different from B.
  for (var idx = 0; idx < keysA.length; idx++) {
    var key = keysA[idx];
    if (!bHasOwnProperty(key)) {
      return false;
    }
    var valueA = objA[key];
    var valueB = objB[key];
    ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;
    if (ret === false || ret === void 0 && valueA !== valueB) {
      return false;
    }
  }
  return true;
};

/***/ }),

/***/ 9984:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


var _regeneratorRuntime = (__webpack_require__(8775)["default"]);
module.exports = function (Yallist) {
  Yallist.prototype[Symbol.iterator] = /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
    var walker;
    return _regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          walker = this.head;
        case 1:
          if (!walker) {
            _context.next = 7;
            break;
          }
          _context.next = 4;
          return walker.value;
        case 4:
          walker = walker.next;
          _context.next = 1;
          break;
        case 7:
        case "end":
          return _context.stop();
      }
    }, _callee, this);
  });
};

/***/ }),

/***/ 6451:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";


module.exports = Yallist;
Yallist.Node = Node;
Yallist.create = Yallist;
function Yallist(list) {
  var self = this;
  if (!(self instanceof Yallist)) {
    self = new Yallist();
  }
  self.tail = null;
  self.head = null;
  self.length = 0;
  if (list && typeof list.forEach === 'function') {
    list.forEach(function (item) {
      self.push(item);
    });
  } else if (arguments.length > 0) {
    for (var i = 0, l = arguments.length; i < l; i++) {
      self.push(arguments[i]);
    }
  }
  return self;
}
Yallist.prototype.removeNode = function (node) {
  if (node.list !== this) {
    throw new Error('removing node which does not belong to this list');
  }
  var next = node.next;
  var prev = node.prev;
  if (next) {
    next.prev = prev;
  }
  if (prev) {
    prev.next = next;
  }
  if (node === this.head) {
    this.head = next;
  }
  if (node === this.tail) {
    this.tail = prev;
  }
  node.list.length--;
  node.next = null;
  node.prev = null;
  node.list = null;
  return next;
};
Yallist.prototype.unshiftNode = function (node) {
  if (node === this.head) {
    return;
  }
  if (node.list) {
    node.list.removeNode(node);
  }
  var head = this.head;
  node.list = this;
  node.next = head;
  if (head) {
    head.prev = node;
  }
  this.head = node;
  if (!this.tail) {
    this.tail = node;
  }
  this.length++;
};
Yallist.prototype.pushNode = function (node) {
  if (node === this.tail) {
    return;
  }
  if (node.list) {
    node.list.removeNode(node);
  }
  var tail = this.tail;
  node.list = this;
  node.prev = tail;
  if (tail) {
    tail.next = node;
  }
  this.tail = node;
  if (!this.head) {
    this.head = node;
  }
  this.length++;
};
Yallist.prototype.push = function () {
  for (var i = 0, l = arguments.length; i < l; i++) {
    push(this, arguments[i]);
  }
  return this.length;
};
Yallist.prototype.unshift = function () {
  for (var i = 0, l = arguments.length; i < l; i++) {
    unshift(this, arguments[i]);
  }
  return this.length;
};
Yallist.prototype.pop = function () {
  if (!this.tail) {
    return undefined;
  }
  var res = this.tail.value;
  this.tail = this.tail.prev;
  if (this.tail) {
    this.tail.next = null;
  } else {
    this.head = null;
  }
  this.length--;
  return res;
};
Yallist.prototype.shift = function () {
  if (!this.head) {
    return undefined;
  }
  var res = this.head.value;
  this.head = this.head.next;
  if (this.head) {
    this.head.prev = null;
  } else {
    this.tail = null;
  }
  this.length--;
  return res;
};
Yallist.prototype.forEach = function (fn, thisp) {
  thisp = thisp || this;
  for (var walker = this.head, i = 0; walker !== null; i++) {
    fn.call(thisp, walker.value, i, this);
    walker = walker.next;
  }
};
Yallist.prototype.forEachReverse = function (fn, thisp) {
  thisp = thisp || this;
  for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
    fn.call(thisp, walker.value, i, this);
    walker = walker.prev;
  }
};
Yallist.prototype.get = function (n) {
  for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
    // abort out of the list early if we hit a cycle
    walker = walker.next;
  }
  if (i === n && walker !== null) {
    return walker.value;
  }
};
Yallist.prototype.getReverse = function (n) {
  for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
    // abort out of the list early if we hit a cycle
    walker = walker.prev;
  }
  if (i === n && walker !== null) {
    return walker.value;
  }
};
Yallist.prototype.map = function (fn, thisp) {
  thisp = thisp || this;
  var res = new Yallist();
  for (var walker = this.head; walker !== null;) {
    res.push(fn.call(thisp, walker.value, this));
    walker = walker.next;
  }
  return res;
};
Yallist.prototype.mapReverse = function (fn, thisp) {
  thisp = thisp || this;
  var res = new Yallist();
  for (var walker = this.tail; walker !== null;) {
    res.push(fn.call(thisp, walker.value, this));
    walker = walker.prev;
  }
  return res;
};
Yallist.prototype.reduce = function (fn, initial) {
  var acc;
  var walker = this.head;
  if (arguments.length > 1) {
    acc = initial;
  } else if (this.head) {
    walker = this.head.next;
    acc = this.head.value;
  } else {
    throw new TypeError('Reduce of empty list with no initial value');
  }
  for (var i = 0; walker !== null; i++) {
    acc = fn(acc, walker.value, i);
    walker = walker.next;
  }
  return acc;
};
Yallist.prototype.reduceReverse = function (fn, initial) {
  var acc;
  var walker = this.tail;
  if (arguments.length > 1) {
    acc = initial;
  } else if (this.tail) {
    walker = this.tail.prev;
    acc = this.tail.value;
  } else {
    throw new TypeError('Reduce of empty list with no initial value');
  }
  for (var i = this.length - 1; walker !== null; i--) {
    acc = fn(acc, walker.value, i);
    walker = walker.prev;
  }
  return acc;
};
Yallist.prototype.toArray = function () {
  var arr = new Array(this.length);
  for (var i = 0, walker = this.head; walker !== null; i++) {
    arr[i] = walker.value;
    walker = walker.next;
  }
  return arr;
};
Yallist.prototype.toArrayReverse = function () {
  var arr = new Array(this.length);
  for (var i = 0, walker = this.tail; walker !== null; i++) {
    arr[i] = walker.value;
    walker = walker.prev;
  }
  return arr;
};
Yallist.prototype.slice = function (from, to) {
  to = to || this.length;
  if (to < 0) {
    to += this.length;
  }
  from = from || 0;
  if (from < 0) {
    from += this.length;
  }
  var ret = new Yallist();
  if (to < from || to < 0) {
    return ret;
  }
  if (from < 0) {
    from = 0;
  }
  if (to > this.length) {
    to = this.length;
  }
  for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
    walker = walker.next;
  }
  for (; walker !== null && i < to; i++, walker = walker.next) {
    ret.push(walker.value);
  }
  return ret;
};
Yallist.prototype.sliceReverse = function (from, to) {
  to = to || this.length;
  if (to < 0) {
    to += this.length;
  }
  from = from || 0;
  if (from < 0) {
    from += this.length;
  }
  var ret = new Yallist();
  if (to < from || to < 0) {
    return ret;
  }
  if (from < 0) {
    from = 0;
  }
  if (to > this.length) {
    to = this.length;
  }
  for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
    walker = walker.prev;
  }
  for (; walker !== null && i > from; i--, walker = walker.prev) {
    ret.push(walker.value);
  }
  return ret;
};
Yallist.prototype.splice = function (start, deleteCount) {
  if (start > this.length) {
    start = this.length - 1;
  }
  if (start < 0) {
    start = this.length + start;
  }
  for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
    walker = walker.next;
  }
  var ret = [];
  for (var i = 0; walker && i < deleteCount; i++) {
    ret.push(walker.value);
    walker = this.removeNode(walker);
  }
  if (walker === null) {
    walker = this.tail;
  }
  if (walker !== this.head && walker !== this.tail) {
    walker = walker.prev;
  }
  for (var i = 0; i < (arguments.length <= 2 ? 0 : arguments.length - 2); i++) {
    walker = insert(this, walker, i + 2 < 2 || arguments.length <= i + 2 ? undefined : arguments[i + 2]);
  }
  return ret;
};
Yallist.prototype.reverse = function () {
  var head = this.head;
  var tail = this.tail;
  for (var walker = head; walker !== null; walker = walker.prev) {
    var p = walker.prev;
    walker.prev = walker.next;
    walker.next = p;
  }
  this.head = tail;
  this.tail = head;
  return this;
};
function insert(self, node, value) {
  var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self);
  if (inserted.next === null) {
    self.tail = inserted;
  }
  if (inserted.prev === null) {
    self.head = inserted;
  }
  self.length++;
  return inserted;
}
function push(self, item) {
  self.tail = new Node(item, self.tail, null, self);
  if (!self.head) {
    self.head = self.tail;
  }
  self.length++;
}
function unshift(self, item) {
  self.head = new Node(item, null, self.head, self);
  if (!self.tail) {
    self.tail = self.head;
  }
  self.length++;
}
function Node(value, prev, next, list) {
  if (!(this instanceof Node)) {
    return new Node(value, prev, next, list);
  }
  this.list = list;
  this.value = value;
  if (prev) {
    prev.next = this;
    this.prev = prev;
  } else {
    this.prev = null;
  }
  if (next) {
    next.prev = this;
    this.next = next;
  } else {
    this.next = null;
  }
}
try {
  // add if support for Symbol.iterator is present
  __webpack_require__(9984)(Yallist);
} catch (er) {}

/***/ }),

/***/ 4823:
/***/ (function(module) {

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;
}
module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 5284:
/***/ (function(module) {

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}
module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 766:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var arrayLikeToArray = __webpack_require__(4823);
function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr)) return arrayLikeToArray(arr);
}
module.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 8403:
/***/ (function(module) {

function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}
module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 2467:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var toPropertyKey = __webpack_require__(8182);
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, toPropertyKey(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;
}
module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 3762:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var unsupportedIterableToArray = __webpack_require__(9093);
function _createForOfIteratorHelper(o, allowArrayLike) {
  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
  if (!it) {
    if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
      if (it) o = it;
      var i = 0;
      var F = function F() {};
      return {
        s: F,
        n: function n() {
          if (i >= o.length) return {
            done: true
          };
          return {
            done: false,
            value: o[i++]
          };
        },
        e: function e(_e) {
          throw _e;
        },
        f: F
      };
    }
    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }
  var normalCompletion = true,
    didErr = false,
    err;
  return {
    s: function s() {
      it = it.call(o);
    },
    n: function n() {
      var step = it.next();
      normalCompletion = step.done;
      return step;
    },
    e: function e(_e2) {
      didErr = true;
      err = _e2;
    },
    f: function f() {
      try {
        if (!normalCompletion && it["return"] != null) it["return"]();
      } finally {
        if (didErr) throw err;
      }
    }
  };
}
module.exports = _createForOfIteratorHelper, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 9015:
/***/ (function(module) {

function _iterableToArray(iter) {
  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
module.exports = _iterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 9791:
/***/ (function(module) {

function _iterableToArrayLimit(arr, i) {
  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
  if (null != _i) {
    var _s,
      _e,
      _x,
      _r,
      _arr = [],
      _n = !0,
      _d = !1;
    try {
      if (_x = (_i = _i.call(arr)).next, 0 === i) {
        if (Object(_i) !== _i) return;
        _n = !1;
      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
    } catch (err) {
      _d = !0, _e = err;
    } finally {
      try {
        if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return;
      } finally {
        if (_d) throw _e;
      }
    }
    return _arr;
  }
}
module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 7698:
/***/ (function(module) {

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.");
}
module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 9464:
/***/ (function(module) {

function _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
module.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 8775:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var _typeof = (__webpack_require__(2929)["default"]);
function _regeneratorRuntime() {
  "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
    return exports;
  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
  var exports = {},
    Op = Object.prototype,
    hasOwn = Op.hasOwnProperty,
    defineProperty = Object.defineProperty || function (obj, key, desc) {
      obj[key] = desc.value;
    },
    $Symbol = "function" == typeof Symbol ? Symbol : {},
    iteratorSymbol = $Symbol.iterator || "@@iterator",
    asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
    toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
  function define(obj, key, value) {
    return Object.defineProperty(obj, key, {
      value: value,
      enumerable: !0,
      configurable: !0,
      writable: !0
    }), obj[key];
  }
  try {
    define({}, "");
  } catch (err) {
    define = function define(obj, key, value) {
      return obj[key] = value;
    };
  }
  function wrap(innerFn, outerFn, self, tryLocsList) {
    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
      generator = Object.create(protoGenerator.prototype),
      context = new Context(tryLocsList || []);
    return defineProperty(generator, "_invoke", {
      value: makeInvokeMethod(innerFn, self, context)
    }), generator;
  }
  function tryCatch(fn, obj, arg) {
    try {
      return {
        type: "normal",
        arg: fn.call(obj, arg)
      };
    } catch (err) {
      return {
        type: "throw",
        arg: err
      };
    }
  }
  exports.wrap = wrap;
  var ContinueSentinel = {};
  function Generator() {}
  function GeneratorFunction() {}
  function GeneratorFunctionPrototype() {}
  var IteratorPrototype = {};
  define(IteratorPrototype, iteratorSymbol, function () {
    return this;
  });
  var getProto = Object.getPrototypeOf,
    NativeIteratorPrototype = getProto && getProto(getProto(values([])));
  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
  function defineIteratorMethods(prototype) {
    ["next", "throw", "return"].forEach(function (method) {
      define(prototype, method, function (arg) {
        return this._invoke(method, arg);
      });
    });
  }
  function AsyncIterator(generator, PromiseImpl) {
    function invoke(method, arg, resolve, reject) {
      var record = tryCatch(generator[method], generator, arg);
      if ("throw" !== record.type) {
        var result = record.arg,
          value = result.value;
        return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
          invoke("next", value, resolve, reject);
        }, function (err) {
          invoke("throw", err, resolve, reject);
        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
          result.value = unwrapped, resolve(result);
        }, function (error) {
          return invoke("throw", error, resolve, reject);
        });
      }
      reject(record.arg);
    }
    var previousPromise;
    defineProperty(this, "_invoke", {
      value: function value(method, arg) {
        function callInvokeWithMethodAndArg() {
          return new PromiseImpl(function (resolve, reject) {
            invoke(method, arg, resolve, reject);
          });
        }
        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
      }
    });
  }
  function makeInvokeMethod(innerFn, self, context) {
    var state = "suspendedStart";
    return function (method, arg) {
      if ("executing" === state) throw new Error("Generator is already running");
      if ("completed" === state) {
        if ("throw" === method) throw arg;
        return doneResult();
      }
      for (context.method = method, context.arg = arg;;) {
        var delegate = context.delegate;
        if (delegate) {
          var delegateResult = maybeInvokeDelegate(delegate, context);
          if (delegateResult) {
            if (delegateResult === ContinueSentinel) continue;
            return delegateResult;
          }
        }
        if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
          if ("suspendedStart" === state) throw state = "completed", context.arg;
          context.dispatchException(context.arg);
        } else "return" === context.method && context.abrupt("return", context.arg);
        state = "executing";
        var record = tryCatch(innerFn, self, context);
        if ("normal" === record.type) {
          if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
          return {
            value: record.arg,
            done: context.done
          };
        }
        "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
      }
    };
  }
  function maybeInvokeDelegate(delegate, context) {
    var methodName = context.method,
      method = delegate.iterator[methodName];
    if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator["return"] && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel;
    var record = tryCatch(method, delegate.iterator, context.arg);
    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
    var info = record.arg;
    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
  }
  function pushTryEntry(locs) {
    var entry = {
      tryLoc: locs[0]
    };
    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
  }
  function resetTryEntry(entry) {
    var record = entry.completion || {};
    record.type = "normal", delete record.arg, entry.completion = record;
  }
  function Context(tryLocsList) {
    this.tryEntries = [{
      tryLoc: "root"
    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
  }
  function values(iterable) {
    if (iterable) {
      var iteratorMethod = iterable[iteratorSymbol];
      if (iteratorMethod) return iteratorMethod.call(iterable);
      if ("function" == typeof iterable.next) return iterable;
      if (!isNaN(iterable.length)) {
        var i = -1,
          next = function next() {
            for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
            return next.value = undefined, next.done = !0, next;
          };
        return next.next = next;
      }
    }
    return {
      next: doneResult
    };
  }
  function doneResult() {
    return {
      value: undefined,
      done: !0
    };
  }
  return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
    value: GeneratorFunctionPrototype,
    configurable: !0
  }), defineProperty(GeneratorFunctionPrototype, "constructor", {
    value: GeneratorFunction,
    configurable: !0
  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
    var ctor = "function" == typeof genFun && genFun.constructor;
    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
  }, exports.mark = function (genFun) {
    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
  }, exports.awrap = function (arg) {
    return {
      __await: arg
    };
  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
    return this;
  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
    void 0 === PromiseImpl && (PromiseImpl = Promise);
    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
      return result.done ? result.value : iter.next();
    });
  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
    return this;
  }), define(Gp, "toString", function () {
    return "[object Generator]";
  }), exports.keys = function (val) {
    var object = Object(val),
      keys = [];
    for (var key in object) keys.push(key);
    return keys.reverse(), function next() {
      for (; keys.length;) {
        var key = keys.pop();
        if (key in object) return next.value = key, next.done = !1, next;
      }
      return next.done = !0, next;
    };
  }, exports.values = values, Context.prototype = {
    constructor: Context,
    reset: function reset(skipTempReset) {
      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
    },
    stop: function stop() {
      this.done = !0;
      var rootRecord = this.tryEntries[0].completion;
      if ("throw" === rootRecord.type) throw rootRecord.arg;
      return this.rval;
    },
    dispatchException: function dispatchException(exception) {
      if (this.done) throw exception;
      var context = this;
      function handle(loc, caught) {
        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
      }
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i],
          record = entry.completion;
        if ("root" === entry.tryLoc) return handle("end");
        if (entry.tryLoc <= this.prev) {
          var hasCatch = hasOwn.call(entry, "catchLoc"),
            hasFinally = hasOwn.call(entry, "finallyLoc");
          if (hasCatch && hasFinally) {
            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
          } else if (hasCatch) {
            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
          } else {
            if (!hasFinally) throw new Error("try statement without catch or finally");
            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
          }
        }
      }
    },
    abrupt: function abrupt(type, arg) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
          var finallyEntry = entry;
          break;
        }
      }
      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
      var record = finallyEntry ? finallyEntry.completion : {};
      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
    },
    complete: function complete(record, afterLoc) {
      if ("throw" === record.type) throw record.arg;
      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
    },
    finish: function finish(finallyLoc) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
      }
    },
    "catch": function _catch(tryLoc) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.tryLoc === tryLoc) {
          var record = entry.completion;
          if ("throw" === record.type) {
            var thrown = record.arg;
            resetTryEntry(entry);
          }
          return thrown;
        }
      }
      throw new Error("illegal catch attempt");
    },
    delegateYield: function delegateYield(iterable, resultName, nextLoc) {
      return this.delegate = {
        iterator: values(iterable),
        resultName: resultName,
        nextLoc: nextLoc
      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
    }
  }, exports;
}
module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 6854:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var arrayWithHoles = __webpack_require__(5284);
var iterableToArrayLimit = __webpack_require__(9791);
var unsupportedIterableToArray = __webpack_require__(9093);
var nonIterableRest = __webpack_require__(7698);
function _slicedToArray(arr, i) {
  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
}
module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 7685:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var arrayWithoutHoles = __webpack_require__(766);
var iterableToArray = __webpack_require__(9015);
var unsupportedIterableToArray = __webpack_require__(9093);
var nonIterableSpread = __webpack_require__(9464);
function _toConsumableArray(arr) {
  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();
}
module.exports = _toConsumableArray, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 1105:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var _typeof = (__webpack_require__(2929)["default"]);
function _toPrimitive(input, hint) {
  if (_typeof(input) !== "object" || input === null) return input;
  var prim = input[Symbol.toPrimitive];
  if (prim !== undefined) {
    var res = prim.call(input, hint || "default");
    if (_typeof(res) !== "object") return res;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return (hint === "string" ? String : Number)(input);
}
module.exports = _toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 8182:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var _typeof = (__webpack_require__(2929)["default"]);
var toPrimitive = __webpack_require__(1105);
function _toPropertyKey(arg) {
  var key = toPrimitive(arg, "string");
  return _typeof(key) === "symbol" ? key : String(key);
}
module.exports = _toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 2929:
/***/ (function(module) {

function _typeof(obj) {
  "@babel/helpers - typeof";

  return (module.exports = _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;
  }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(obj);
}
module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 9093:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var arrayLikeToArray = __webpack_require__(4823);
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);
}
module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = __webpack_modules__;
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/compat get default export */
/******/ 	!function() {
/******/ 		// getDefaultExport function for compatibility with non-harmony modules
/******/ 		__webpack_require__.n = function(module) {
/******/ 			var getter = module && module.__esModule ?
/******/ 				function() { return module['default']; } :
/******/ 				function() { return module; };
/******/ 			__webpack_require__.d(getter, { a: getter });
/******/ 			return getter;
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/create fake namespace object */
/******/ 	!function() {
/******/ 		var getProto = Object.getPrototypeOf ? function(obj) { return Object.getPrototypeOf(obj); } : function(obj) { return obj.__proto__; };
/******/ 		var leafPrototypes;
/******/ 		// create a fake namespace object
/******/ 		// mode & 1: value is a module id, require it
/******/ 		// mode & 2: merge all properties of value into the ns
/******/ 		// mode & 4: return value when already ns object
/******/ 		// mode & 16: return value when it's Promise-like
/******/ 		// mode & 8|1: behave like require
/******/ 		__webpack_require__.t = function(value, mode) {
/******/ 			if(mode & 1) value = this(value);
/******/ 			if(mode & 8) return value;
/******/ 			if(typeof value === 'object' && value) {
/******/ 				if((mode & 4) && value.__esModule) return value;
/******/ 				if((mode & 16) && typeof value.then === 'function') return value;
/******/ 			}
/******/ 			var ns = Object.create(null);
/******/ 			__webpack_require__.r(ns);
/******/ 			var def = {};
/******/ 			leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];
/******/ 			for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {
/******/ 				Object.getOwnPropertyNames(current).forEach(function(key) { def[key] = function() { return value[key]; }; });
/******/ 			}
/******/ 			def['default'] = function() { return value; };
/******/ 			__webpack_require__.d(ns, def);
/******/ 			return ns;
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/define property getters */
/******/ 	!function() {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = function(exports, definition) {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/ensure chunk */
/******/ 	!function() {
/******/ 		__webpack_require__.f = {};
/******/ 		// This file contains only the entry chunk.
/******/ 		// The chunk loading function for additional chunks
/******/ 		__webpack_require__.e = function(chunkId) {
/******/ 			return Promise.all(Object.keys(__webpack_require__.f).reduce(function(promises, key) {
/******/ 				__webpack_require__.f[key](chunkId, promises);
/******/ 				return promises;
/******/ 			}, []));
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/get javascript chunk filename */
/******/ 	!function() {
/******/ 		// This function allow to reference async chunks
/******/ 		__webpack_require__.u = function(chunkId) {
/******/ 			// return url for filenames based on template
/******/ 			return "static/js/" + chunkId + "." + "58c4c15f" + ".chunk.js";
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/get mini-css chunk filename */
/******/ 	!function() {
/******/ 		// This function allow to reference async chunks
/******/ 		__webpack_require__.miniCssF = function(chunkId) {
/******/ 			// return url for filenames based on template
/******/ 			return undefined;
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/global */
/******/ 	!function() {
/******/ 		__webpack_require__.g = (function() {
/******/ 			if (typeof globalThis === 'object') return globalThis;
/******/ 			try {
/******/ 				return this || new Function('return this')();
/******/ 			} catch (e) {
/******/ 				if (typeof window === 'object') return window;
/******/ 			}
/******/ 		})();
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	!function() {
/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/load script */
/******/ 	!function() {
/******/ 		var inProgress = {};
/******/ 		var dataWebpackPrefix = "tingwu-chrome-extension:";
/******/ 		// loadScript function to load a script via script tag
/******/ 		__webpack_require__.l = function(url, done, key, chunkId) {
/******/ 			if(inProgress[url]) { inProgress[url].push(done); return; }
/******/ 			var script, needAttach;
/******/ 			if(key !== undefined) {
/******/ 				var scripts = document.getElementsByTagName("script");
/******/ 				for(var i = 0; i < scripts.length; i++) {
/******/ 					var s = scripts[i];
/******/ 					if(s.getAttribute("src") == url || s.getAttribute("data-webpack") == dataWebpackPrefix + key) { script = s; break; }
/******/ 				}
/******/ 			}
/******/ 			if(!script) {
/******/ 				needAttach = true;
/******/ 				script = document.createElement('script');
/******/ 		
/******/ 				script.charset = 'utf-8';
/******/ 				script.timeout = 120;
/******/ 				if (__webpack_require__.nc) {
/******/ 					script.setAttribute("nonce", __webpack_require__.nc);
/******/ 				}
/******/ 				script.setAttribute("data-webpack", dataWebpackPrefix + key);
/******/ 				script.src = url;
/******/ 			}
/******/ 			inProgress[url] = [done];
/******/ 			var onScriptComplete = function(prev, event) {
/******/ 				// avoid mem leaks in IE.
/******/ 				script.onerror = script.onload = null;
/******/ 				clearTimeout(timeout);
/******/ 				var doneFns = inProgress[url];
/******/ 				delete inProgress[url];
/******/ 				script.parentNode && script.parentNode.removeChild(script);
/******/ 				doneFns && doneFns.forEach(function(fn) { return fn(event); });
/******/ 				if(prev) return prev(event);
/******/ 			}
/******/ 			var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);
/******/ 			script.onerror = onScriptComplete.bind(null, script.onerror);
/******/ 			script.onload = onScriptComplete.bind(null, script.onload);
/******/ 			needAttach && document.head.appendChild(script);
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	!function() {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = function(exports) {
/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 			}
/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/publicPath */
/******/ 	!function() {
/******/ 		__webpack_require__.p = "/";
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/jsonp chunk loading */
/******/ 	!function() {
/******/ 		// no baseURI
/******/ 		
/******/ 		// object to store loaded and loading chunks
/******/ 		// undefined = chunk not loaded, null = chunk preloaded/prefetched
/******/ 		// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
/******/ 		var installedChunks = {
/******/ 			179: 0
/******/ 		};
/******/ 		
/******/ 		__webpack_require__.f.j = function(chunkId, promises) {
/******/ 				// JSONP chunk loading for javascript
/******/ 				var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;
/******/ 				if(installedChunkData !== 0) { // 0 means "already installed".
/******/ 		
/******/ 					// a Promise means "currently loading".
/******/ 					if(installedChunkData) {
/******/ 						promises.push(installedChunkData[2]);
/******/ 					} else {
/******/ 						if(true) { // all chunks have JS
/******/ 							// setup Promise in chunk cache
/******/ 							var promise = new Promise(function(resolve, reject) { installedChunkData = installedChunks[chunkId] = [resolve, reject]; });
/******/ 							promises.push(installedChunkData[2] = promise);
/******/ 		
/******/ 							// start chunk loading
/******/ 							var url = __webpack_require__.p + __webpack_require__.u(chunkId);
/******/ 							// create error before stack unwound to get useful stacktrace later
/******/ 							var error = new Error();
/******/ 							var loadingEnded = function(event) {
/******/ 								if(__webpack_require__.o(installedChunks, chunkId)) {
/******/ 									installedChunkData = installedChunks[chunkId];
/******/ 									if(installedChunkData !== 0) installedChunks[chunkId] = undefined;
/******/ 									if(installedChunkData) {
/******/ 										var errorType = event && (event.type === 'load' ? 'missing' : event.type);
/******/ 										var realSrc = event && event.target && event.target.src;
/******/ 										error.message = 'Loading chunk ' + chunkId + ' failed.\n(' + errorType + ': ' + realSrc + ')';
/******/ 										error.name = 'ChunkLoadError';
/******/ 										error.type = errorType;
/******/ 										error.request = realSrc;
/******/ 										installedChunkData[1](error);
/******/ 									}
/******/ 								}
/******/ 							};
/******/ 							__webpack_require__.l(url, loadingEnded, "chunk-" + chunkId, chunkId);
/******/ 						} else installedChunks[chunkId] = 0;
/******/ 					}
/******/ 				}
/******/ 		};
/******/ 		
/******/ 		// no prefetching
/******/ 		
/******/ 		// no preloaded
/******/ 		
/******/ 		// no HMR
/******/ 		
/******/ 		// no HMR manifest
/******/ 		
/******/ 		// no on chunks loaded
/******/ 		
/******/ 		// install a JSONP callback for chunk loading
/******/ 		var webpackJsonpCallback = function(parentChunkLoadingFunction, data) {
/******/ 			var chunkIds = data[0];
/******/ 			var moreModules = data[1];
/******/ 			var runtime = data[2];
/******/ 			// add "moreModules" to the modules object,
/******/ 			// then flag all "chunkIds" as loaded and fire callback
/******/ 			var moduleId, chunkId, i = 0;
/******/ 			if(chunkIds.some(function(id) { return installedChunks[id] !== 0; })) {
/******/ 				for(moduleId in moreModules) {
/******/ 					if(__webpack_require__.o(moreModules, moduleId)) {
/******/ 						__webpack_require__.m[moduleId] = moreModules[moduleId];
/******/ 					}
/******/ 				}
/******/ 				if(runtime) var result = runtime(__webpack_require__);
/******/ 			}
/******/ 			if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);
/******/ 			for(;i < chunkIds.length; i++) {
/******/ 				chunkId = chunkIds[i];
/******/ 				if(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
/******/ 					installedChunks[chunkId][0]();
/******/ 				}
/******/ 				installedChunks[chunkId] = 0;
/******/ 			}
/******/ 		
/******/ 		}
/******/ 		
/******/ 		var chunkLoadingGlobal = self["webpackChunktingwu_chrome_extension"] = self["webpackChunktingwu_chrome_extension"] || [];
/******/ 		chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
/******/ 		chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/nonce */
/******/ 	!function() {
/******/ 		__webpack_require__.nc = undefined;
/******/ 	}();
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
!function() {
"use strict";

;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/typeof.js
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);
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/regeneratorRuntime.js

function regeneratorRuntime_regeneratorRuntime() {
  "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
  regeneratorRuntime_regeneratorRuntime = function _regeneratorRuntime() {
    return exports;
  };
  var exports = {},
    Op = Object.prototype,
    hasOwn = Op.hasOwnProperty,
    defineProperty = Object.defineProperty || function (obj, key, desc) {
      obj[key] = desc.value;
    },
    $Symbol = "function" == typeof Symbol ? Symbol : {},
    iteratorSymbol = $Symbol.iterator || "@@iterator",
    asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
    toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
  function define(obj, key, value) {
    return Object.defineProperty(obj, key, {
      value: value,
      enumerable: !0,
      configurable: !0,
      writable: !0
    }), obj[key];
  }
  try {
    define({}, "");
  } catch (err) {
    define = function define(obj, key, value) {
      return obj[key] = value;
    };
  }
  function wrap(innerFn, outerFn, self, tryLocsList) {
    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
      generator = Object.create(protoGenerator.prototype),
      context = new Context(tryLocsList || []);
    return defineProperty(generator, "_invoke", {
      value: makeInvokeMethod(innerFn, self, context)
    }), generator;
  }
  function tryCatch(fn, obj, arg) {
    try {
      return {
        type: "normal",
        arg: fn.call(obj, arg)
      };
    } catch (err) {
      return {
        type: "throw",
        arg: err
      };
    }
  }
  exports.wrap = wrap;
  var ContinueSentinel = {};
  function Generator() {}
  function GeneratorFunction() {}
  function GeneratorFunctionPrototype() {}
  var IteratorPrototype = {};
  define(IteratorPrototype, iteratorSymbol, function () {
    return this;
  });
  var getProto = Object.getPrototypeOf,
    NativeIteratorPrototype = getProto && getProto(getProto(values([])));
  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
  function defineIteratorMethods(prototype) {
    ["next", "throw", "return"].forEach(function (method) {
      define(prototype, method, function (arg) {
        return this._invoke(method, arg);
      });
    });
  }
  function AsyncIterator(generator, PromiseImpl) {
    function invoke(method, arg, resolve, reject) {
      var record = tryCatch(generator[method], generator, arg);
      if ("throw" !== record.type) {
        var result = record.arg,
          value = result.value;
        return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
          invoke("next", value, resolve, reject);
        }, function (err) {
          invoke("throw", err, resolve, reject);
        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
          result.value = unwrapped, resolve(result);
        }, function (error) {
          return invoke("throw", error, resolve, reject);
        });
      }
      reject(record.arg);
    }
    var previousPromise;
    defineProperty(this, "_invoke", {
      value: function value(method, arg) {
        function callInvokeWithMethodAndArg() {
          return new PromiseImpl(function (resolve, reject) {
            invoke(method, arg, resolve, reject);
          });
        }
        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
      }
    });
  }
  function makeInvokeMethod(innerFn, self, context) {
    var state = "suspendedStart";
    return function (method, arg) {
      if ("executing" === state) throw new Error("Generator is already running");
      if ("completed" === state) {
        if ("throw" === method) throw arg;
        return doneResult();
      }
      for (context.method = method, context.arg = arg;;) {
        var delegate = context.delegate;
        if (delegate) {
          var delegateResult = maybeInvokeDelegate(delegate, context);
          if (delegateResult) {
            if (delegateResult === ContinueSentinel) continue;
            return delegateResult;
          }
        }
        if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
          if ("suspendedStart" === state) throw state = "completed", context.arg;
          context.dispatchException(context.arg);
        } else "return" === context.method && context.abrupt("return", context.arg);
        state = "executing";
        var record = tryCatch(innerFn, self, context);
        if ("normal" === record.type) {
          if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
          return {
            value: record.arg,
            done: context.done
          };
        }
        "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
      }
    };
  }
  function maybeInvokeDelegate(delegate, context) {
    var methodName = context.method,
      method = delegate.iterator[methodName];
    if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator["return"] && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel;
    var record = tryCatch(method, delegate.iterator, context.arg);
    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
    var info = record.arg;
    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
  }
  function pushTryEntry(locs) {
    var entry = {
      tryLoc: locs[0]
    };
    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
  }
  function resetTryEntry(entry) {
    var record = entry.completion || {};
    record.type = "normal", delete record.arg, entry.completion = record;
  }
  function Context(tryLocsList) {
    this.tryEntries = [{
      tryLoc: "root"
    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
  }
  function values(iterable) {
    if (iterable) {
      var iteratorMethod = iterable[iteratorSymbol];
      if (iteratorMethod) return iteratorMethod.call(iterable);
      if ("function" == typeof iterable.next) return iterable;
      if (!isNaN(iterable.length)) {
        var i = -1,
          next = function next() {
            for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
            return next.value = undefined, next.done = !0, next;
          };
        return next.next = next;
      }
    }
    return {
      next: doneResult
    };
  }
  function doneResult() {
    return {
      value: undefined,
      done: !0
    };
  }
  return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
    value: GeneratorFunctionPrototype,
    configurable: !0
  }), defineProperty(GeneratorFunctionPrototype, "constructor", {
    value: GeneratorFunction,
    configurable: !0
  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
    var ctor = "function" == typeof genFun && genFun.constructor;
    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
  }, exports.mark = function (genFun) {
    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
  }, exports.awrap = function (arg) {
    return {
      __await: arg
    };
  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
    return this;
  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
    void 0 === PromiseImpl && (PromiseImpl = Promise);
    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
      return result.done ? result.value : iter.next();
    });
  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
    return this;
  }), define(Gp, "toString", function () {
    return "[object Generator]";
  }), exports.keys = function (val) {
    var object = Object(val),
      keys = [];
    for (var key in object) keys.push(key);
    return keys.reverse(), function next() {
      for (; keys.length;) {
        var key = keys.pop();
        if (key in object) return next.value = key, next.done = !1, next;
      }
      return next.done = !0, next;
    };
  }, exports.values = values, Context.prototype = {
    constructor: Context,
    reset: function reset(skipTempReset) {
      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
    },
    stop: function stop() {
      this.done = !0;
      var rootRecord = this.tryEntries[0].completion;
      if ("throw" === rootRecord.type) throw rootRecord.arg;
      return this.rval;
    },
    dispatchException: function dispatchException(exception) {
      if (this.done) throw exception;
      var context = this;
      function handle(loc, caught) {
        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
      }
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i],
          record = entry.completion;
        if ("root" === entry.tryLoc) return handle("end");
        if (entry.tryLoc <= this.prev) {
          var hasCatch = hasOwn.call(entry, "catchLoc"),
            hasFinally = hasOwn.call(entry, "finallyLoc");
          if (hasCatch && hasFinally) {
            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
          } else if (hasCatch) {
            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
          } else {
            if (!hasFinally) throw new Error("try statement without catch or finally");
            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
          }
        }
      }
    },
    abrupt: function abrupt(type, arg) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
          var finallyEntry = entry;
          break;
        }
      }
      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
      var record = finallyEntry ? finallyEntry.completion : {};
      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
    },
    complete: function complete(record, afterLoc) {
      if ("throw" === record.type) throw record.arg;
      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
    },
    finish: function finish(finallyLoc) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
      }
    },
    "catch": function _catch(tryLoc) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.tryLoc === tryLoc) {
          var record = entry.completion;
          if ("throw" === record.type) {
            var thrown = record.arg;
            resetTryEntry(entry);
          }
          return thrown;
        }
      }
      throw new Error("illegal catch attempt");
    },
    delegateYield: function delegateYield(iterable, resultName, nextLoc) {
      return this.delegate = {
        iterator: values(iterable),
        resultName: resultName,
        nextLoc: nextLoc
      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
    }
  }, exports;
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/asyncToGenerator.js
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
  try {
    var info = gen[key](arg);
    var value = info.value;
  } catch (error) {
    reject(error);
    return;
  }
  if (info.done) {
    resolve(value);
  } else {
    Promise.resolve(value).then(_next, _throw);
  }
}
function asyncToGenerator_asyncToGenerator(fn) {
  return function () {
    var self = this,
      args = arguments;
    return new Promise(function (resolve, reject) {
      var gen = fn.apply(self, args);
      function _next(value) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
      }
      function _throw(err) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
      }
      _next(undefined);
    });
  };
}
// EXTERNAL MODULE: ./node_modules/_react@18.2.0@react/index.js
var _react_18_2_0_react = __webpack_require__(9512);
var _react_18_2_0_react_namespaceObject = /*#__PURE__*/__webpack_require__.t(_react_18_2_0_react, 2);
// EXTERNAL MODULE: ./node_modules/_react-dom@18.2.0@react-dom/client.js
var client = __webpack_require__(545);
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/arrayWithHoles.js
function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/iterableToArrayLimit.js
function _iterableToArrayLimit(arr, i) {
  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
  if (null != _i) {
    var _s,
      _e,
      _x,
      _r,
      _arr = [],
      _n = !0,
      _d = !1;
    try {
      if (_x = (_i = _i.call(arr)).next, 0 === i) {
        if (Object(_i) !== _i) return;
        _n = !1;
      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
    } catch (err) {
      _d = !0, _e = err;
    } finally {
      try {
        if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return;
      } finally {
        if (_d) throw _e;
      }
    }
    return _arr;
  }
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/arrayLikeToArray.js
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;
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/unsupportedIterableToArray.js

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);
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/nonIterableRest.js
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.");
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/slicedToArray.js




function slicedToArray_slicedToArray(arr, i) {
  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/taggedTemplateLiteral.js
function _taggedTemplateLiteral(strings, raw) {
  if (!raw) {
    raw = strings.slice(0);
  }
  return Object.freeze(Object.defineProperties(strings, {
    raw: {
      value: Object.freeze(raw)
    }
  }));
}
// EXTERNAL MODULE: ./node_modules/_react-is@18.2.0@react-is/index.js
var _react_is_18_2_0_react_is = __webpack_require__(9827);
// EXTERNAL MODULE: ./node_modules/_shallowequal@1.1.0@shallowequal/index.js
var _shallowequal_1_1_0_shallowequal = __webpack_require__(7537);
var _shallowequal_1_1_0_shallowequal_default = /*#__PURE__*/__webpack_require__.n(_shallowequal_1_1_0_shallowequal);
;// CONCATENATED MODULE: ./node_modules/_@emotion_stylis@0.8.5@@emotion/stylis/dist/stylis.browser.esm.js
function stylis_min(W) {
  function M(d, c, e, h, a) {
    for (var m = 0, b = 0, v = 0, n = 0, q, g, x = 0, K = 0, k, u = k = q = 0, l = 0, r = 0, I = 0, t = 0, B = e.length, J = B - 1, y, f = '', p = '', F = '', G = '', C; l < B;) {
      g = e.charCodeAt(l);
      l === J && 0 !== b + n + v + m && (0 !== b && (g = 47 === b ? 10 : 47), n = v = m = 0, B++, J++);
      if (0 === b + n + v + m) {
        if (l === J && (0 < r && (f = f.replace(N, '')), 0 < f.trim().length)) {
          switch (g) {
            case 32:
            case 9:
            case 59:
            case 13:
            case 10:
              break;
            default:
              f += e.charAt(l);
          }
          g = 59;
        }
        switch (g) {
          case 123:
            f = f.trim();
            q = f.charCodeAt(0);
            k = 1;
            for (t = ++l; l < B;) {
              switch (g = e.charCodeAt(l)) {
                case 123:
                  k++;
                  break;
                case 125:
                  k--;
                  break;
                case 47:
                  switch (g = e.charCodeAt(l + 1)) {
                    case 42:
                    case 47:
                      a: {
                        for (u = l + 1; u < J; ++u) {
                          switch (e.charCodeAt(u)) {
                            case 47:
                              if (42 === g && 42 === e.charCodeAt(u - 1) && l + 2 !== u) {
                                l = u + 1;
                                break a;
                              }
                              break;
                            case 10:
                              if (47 === g) {
                                l = u + 1;
                                break a;
                              }
                          }
                        }
                        l = u;
                      }
                  }
                  break;
                case 91:
                  g++;
                case 40:
                  g++;
                case 34:
                case 39:
                  for (; l++ < J && e.charCodeAt(l) !== g;) {}
              }
              if (0 === k) break;
              l++;
            }
            k = e.substring(t, l);
            0 === q && (q = (f = f.replace(ca, '').trim()).charCodeAt(0));
            switch (q) {
              case 64:
                0 < r && (f = f.replace(N, ''));
                g = f.charCodeAt(1);
                switch (g) {
                  case 100:
                  case 109:
                  case 115:
                  case 45:
                    r = c;
                    break;
                  default:
                    r = O;
                }
                k = M(c, r, k, g, a + 1);
                t = k.length;
                0 < A && (r = X(O, f, I), C = H(3, k, r, c, D, z, t, g, a, h), f = r.join(''), void 0 !== C && 0 === (t = (k = C.trim()).length) && (g = 0, k = ''));
                if (0 < t) switch (g) {
                  case 115:
                    f = f.replace(da, ea);
                  case 100:
                  case 109:
                  case 45:
                    k = f + '{' + k + '}';
                    break;
                  case 107:
                    f = f.replace(fa, '$1 $2');
                    k = f + '{' + k + '}';
                    k = 1 === w || 2 === w && L('@' + k, 3) ? '@-webkit-' + k + '@' + k : '@' + k;
                    break;
                  default:
                    k = f + k, 112 === h && (k = (p += k, ''));
                } else k = '';
                break;
              default:
                k = M(c, X(c, f, I), k, h, a + 1);
            }
            F += k;
            k = I = r = u = q = 0;
            f = '';
            g = e.charCodeAt(++l);
            break;
          case 125:
          case 59:
            f = (0 < r ? f.replace(N, '') : f).trim();
            if (1 < (t = f.length)) switch (0 === u && (q = f.charCodeAt(0), 45 === q || 96 < q && 123 > q) && (t = (f = f.replace(' ', ':')).length), 0 < A && void 0 !== (C = H(1, f, c, d, D, z, p.length, h, a, h)) && 0 === (t = (f = C.trim()).length) && (f = '\x00\x00'), q = f.charCodeAt(0), g = f.charCodeAt(1), q) {
              case 0:
                break;
              case 64:
                if (105 === g || 99 === g) {
                  G += f + e.charAt(l);
                  break;
                }
              default:
                58 !== f.charCodeAt(t - 1) && (p += P(f, q, g, f.charCodeAt(2)));
            }
            I = r = u = q = 0;
            f = '';
            g = e.charCodeAt(++l);
        }
      }
      switch (g) {
        case 13:
        case 10:
          47 === b ? b = 0 : 0 === 1 + q && 107 !== h && 0 < f.length && (r = 1, f += '\x00');
          0 < A * Y && H(0, f, c, d, D, z, p.length, h, a, h);
          z = 1;
          D++;
          break;
        case 59:
        case 125:
          if (0 === b + n + v + m) {
            z++;
            break;
          }
        default:
          z++;
          y = e.charAt(l);
          switch (g) {
            case 9:
            case 32:
              if (0 === n + m + b) switch (x) {
                case 44:
                case 58:
                case 9:
                case 32:
                  y = '';
                  break;
                default:
                  32 !== g && (y = ' ');
              }
              break;
            case 0:
              y = '\\0';
              break;
            case 12:
              y = '\\f';
              break;
            case 11:
              y = '\\v';
              break;
            case 38:
              0 === n + b + m && (r = I = 1, y = '\f' + y);
              break;
            case 108:
              if (0 === n + b + m + E && 0 < u) switch (l - u) {
                case 2:
                  112 === x && 58 === e.charCodeAt(l - 3) && (E = x);
                case 8:
                  111 === K && (E = K);
              }
              break;
            case 58:
              0 === n + b + m && (u = l);
              break;
            case 44:
              0 === b + v + n + m && (r = 1, y += '\r');
              break;
            case 34:
            case 39:
              0 === b && (n = n === g ? 0 : 0 === n ? g : n);
              break;
            case 91:
              0 === n + b + v && m++;
              break;
            case 93:
              0 === n + b + v && m--;
              break;
            case 41:
              0 === n + b + m && v--;
              break;
            case 40:
              if (0 === n + b + m) {
                if (0 === q) switch (2 * x + 3 * K) {
                  case 533:
                    break;
                  default:
                    q = 1;
                }
                v++;
              }
              break;
            case 64:
              0 === b + v + n + m + u + k && (k = 1);
              break;
            case 42:
            case 47:
              if (!(0 < n + m + v)) switch (b) {
                case 0:
                  switch (2 * g + 3 * e.charCodeAt(l + 1)) {
                    case 235:
                      b = 47;
                      break;
                    case 220:
                      t = l, b = 42;
                  }
                  break;
                case 42:
                  47 === g && 42 === x && t + 2 !== l && (33 === e.charCodeAt(t + 2) && (p += e.substring(t, l + 1)), y = '', b = 0);
              }
          }
          0 === b && (f += y);
      }
      K = x;
      x = g;
      l++;
    }
    t = p.length;
    if (0 < t) {
      r = c;
      if (0 < A && (C = H(2, p, r, d, D, z, t, h, a, h), void 0 !== C && 0 === (p = C).length)) return G + p + F;
      p = r.join(',') + '{' + p + '}';
      if (0 !== w * E) {
        2 !== w || L(p, 2) || (E = 0);
        switch (E) {
          case 111:
            p = p.replace(ha, ':-moz-$1') + p;
            break;
          case 112:
            p = p.replace(Q, '::-webkit-input-$1') + p.replace(Q, '::-moz-$1') + p.replace(Q, ':-ms-input-$1') + p;
        }
        E = 0;
      }
    }
    return G + p + F;
  }
  function X(d, c, e) {
    var h = c.trim().split(ia);
    c = h;
    var a = h.length,
      m = d.length;
    switch (m) {
      case 0:
      case 1:
        var b = 0;
        for (d = 0 === m ? '' : d[0] + ' '; b < a; ++b) {
          c[b] = Z(d, c[b], e).trim();
        }
        break;
      default:
        var v = b = 0;
        for (c = []; b < a; ++b) {
          for (var n = 0; n < m; ++n) {
            c[v++] = Z(d[n] + ' ', h[b], e).trim();
          }
        }
    }
    return c;
  }
  function Z(d, c, e) {
    var h = c.charCodeAt(0);
    33 > h && (h = (c = c.trim()).charCodeAt(0));
    switch (h) {
      case 38:
        return c.replace(F, '$1' + d.trim());
      case 58:
        return d.trim() + c.replace(F, '$1' + d.trim());
      default:
        if (0 < 1 * e && 0 < c.indexOf('\f')) return c.replace(F, (58 === d.charCodeAt(0) ? '' : '$1') + d.trim());
    }
    return d + c;
  }
  function P(d, c, e, h) {
    var a = d + ';',
      m = 2 * c + 3 * e + 4 * h;
    if (944 === m) {
      d = a.indexOf(':', 9) + 1;
      var b = a.substring(d, a.length - 1).trim();
      b = a.substring(0, d).trim() + b + ';';
      return 1 === w || 2 === w && L(b, 1) ? '-webkit-' + b + b : b;
    }
    if (0 === w || 2 === w && !L(a, 1)) return a;
    switch (m) {
      case 1015:
        return 97 === a.charCodeAt(10) ? '-webkit-' + a + a : a;
      case 951:
        return 116 === a.charCodeAt(3) ? '-webkit-' + a + a : a;
      case 963:
        return 110 === a.charCodeAt(5) ? '-webkit-' + a + a : a;
      case 1009:
        if (100 !== a.charCodeAt(4)) break;
      case 969:
      case 942:
        return '-webkit-' + a + a;
      case 978:
        return '-webkit-' + a + '-moz-' + a + a;
      case 1019:
      case 983:
        return '-webkit-' + a + '-moz-' + a + '-ms-' + a + a;
      case 883:
        if (45 === a.charCodeAt(8)) return '-webkit-' + a + a;
        if (0 < a.indexOf('image-set(', 11)) return a.replace(ja, '$1-webkit-$2') + a;
        break;
      case 932:
        if (45 === a.charCodeAt(4)) switch (a.charCodeAt(5)) {
          case 103:
            return '-webkit-box-' + a.replace('-grow', '') + '-webkit-' + a + '-ms-' + a.replace('grow', 'positive') + a;
          case 115:
            return '-webkit-' + a + '-ms-' + a.replace('shrink', 'negative') + a;
          case 98:
            return '-webkit-' + a + '-ms-' + a.replace('basis', 'preferred-size') + a;
        }
        return '-webkit-' + a + '-ms-' + a + a;
      case 964:
        return '-webkit-' + a + '-ms-flex-' + a + a;
      case 1023:
        if (99 !== a.charCodeAt(8)) break;
        b = a.substring(a.indexOf(':', 15)).replace('flex-', '').replace('space-between', 'justify');
        return '-webkit-box-pack' + b + '-webkit-' + a + '-ms-flex-pack' + b + a;
      case 1005:
        return ka.test(a) ? a.replace(aa, ':-webkit-') + a.replace(aa, ':-moz-') + a : a;
      case 1e3:
        b = a.substring(13).trim();
        c = b.indexOf('-') + 1;
        switch (b.charCodeAt(0) + b.charCodeAt(c)) {
          case 226:
            b = a.replace(G, 'tb');
            break;
          case 232:
            b = a.replace(G, 'tb-rl');
            break;
          case 220:
            b = a.replace(G, 'lr');
            break;
          default:
            return a;
        }
        return '-webkit-' + a + '-ms-' + b + a;
      case 1017:
        if (-1 === a.indexOf('sticky', 9)) break;
      case 975:
        c = (a = d).length - 10;
        b = (33 === a.charCodeAt(c) ? a.substring(0, c) : a).substring(d.indexOf(':', 7) + 1).trim();
        switch (m = b.charCodeAt(0) + (b.charCodeAt(7) | 0)) {
          case 203:
            if (111 > b.charCodeAt(8)) break;
          case 115:
            a = a.replace(b, '-webkit-' + b) + ';' + a;
            break;
          case 207:
          case 102:
            a = a.replace(b, '-webkit-' + (102 < m ? 'inline-' : '') + 'box') + ';' + a.replace(b, '-webkit-' + b) + ';' + a.replace(b, '-ms-' + b + 'box') + ';' + a;
        }
        return a + ';';
      case 938:
        if (45 === a.charCodeAt(5)) switch (a.charCodeAt(6)) {
          case 105:
            return b = a.replace('-items', ''), '-webkit-' + a + '-webkit-box-' + b + '-ms-flex-' + b + a;
          case 115:
            return '-webkit-' + a + '-ms-flex-item-' + a.replace(ba, '') + a;
          default:
            return '-webkit-' + a + '-ms-flex-line-pack' + a.replace('align-content', '').replace(ba, '') + a;
        }
        break;
      case 973:
      case 989:
        if (45 !== a.charCodeAt(3) || 122 === a.charCodeAt(4)) break;
      case 931:
      case 953:
        if (!0 === la.test(d)) return 115 === (b = d.substring(d.indexOf(':') + 1)).charCodeAt(0) ? P(d.replace('stretch', 'fill-available'), c, e, h).replace(':fill-available', ':stretch') : a.replace(b, '-webkit-' + b) + a.replace(b, '-moz-' + b.replace('fill-', '')) + a;
        break;
      case 962:
        if (a = '-webkit-' + a + (102 === a.charCodeAt(5) ? '-ms-' + a : '') + a, 211 === e + h && 105 === a.charCodeAt(13) && 0 < a.indexOf('transform', 10)) return a.substring(0, a.indexOf(';', 27) + 1).replace(ma, '$1-webkit-$2') + a;
    }
    return a;
  }
  function L(d, c) {
    var e = d.indexOf(1 === c ? ':' : '{'),
      h = d.substring(0, 3 !== c ? e : 10);
    e = d.substring(e + 1, d.length - 1);
    return R(2 !== c ? h : h.replace(na, '$1'), e, c);
  }
  function ea(d, c) {
    var e = P(c, c.charCodeAt(0), c.charCodeAt(1), c.charCodeAt(2));
    return e !== c + ';' ? e.replace(oa, ' or ($1)').substring(4) : '(' + c + ')';
  }
  function H(d, c, e, h, a, m, b, v, n, q) {
    for (var g = 0, x = c, w; g < A; ++g) {
      switch (w = S[g].call(B, d, x, e, h, a, m, b, v, n, q)) {
        case void 0:
        case !1:
        case !0:
        case null:
          break;
        default:
          x = w;
      }
    }
    if (x !== c) return x;
  }
  function T(d) {
    switch (d) {
      case void 0:
      case null:
        A = S.length = 0;
        break;
      default:
        if ('function' === typeof d) S[A++] = d;else if ('object' === typeof d) for (var c = 0, e = d.length; c < e; ++c) {
          T(d[c]);
        } else Y = !!d | 0;
    }
    return T;
  }
  function U(d) {
    d = d.prefix;
    void 0 !== d && (R = null, d ? 'function' !== typeof d ? w = 1 : (w = 2, R = d) : w = 0);
    return U;
  }
  function B(d, c) {
    var e = d;
    33 > e.charCodeAt(0) && (e = e.trim());
    V = e;
    e = [V];
    if (0 < A) {
      var h = H(-1, c, e, e, D, z, 0, 0, 0, 0);
      void 0 !== h && 'string' === typeof h && (c = h);
    }
    var a = M(O, e, c, 0, 0);
    0 < A && (h = H(-2, a, e, e, D, z, a.length, 0, 0, 0), void 0 !== h && (a = h));
    V = '';
    E = 0;
    z = D = 1;
    return a;
  }
  var ca = /^\0+/g,
    N = /[\0\r\f]/g,
    aa = /: */g,
    ka = /zoo|gra/,
    ma = /([,: ])(transform)/g,
    ia = /,\r+?/g,
    F = /([\t\r\n ])*\f?&/g,
    fa = /@(k\w+)\s*(\S*)\s*/,
    Q = /::(place)/g,
    ha = /:(read-only)/g,
    G = /[svh]\w+-[tblr]{2}/,
    da = /\(\s*(.*)\s*\)/g,
    oa = /([\s\S]*?);/g,
    ba = /-self|flex-/g,
    na = /[^]*?(:[rp][el]a[\w-]+)[^]*/,
    la = /stretch|:\s*\w+\-(?:conte|avail)/,
    ja = /([^-])(image-set\()/,
    z = 1,
    D = 1,
    E = 0,
    w = 1,
    O = [],
    S = [],
    A = 0,
    R = null,
    Y = 0,
    V = '';
  B.use = T;
  B.set = U;
  void 0 !== W && U(W);
  return B;
}
/* harmony default export */ var stylis_browser_esm = (stylis_min);
;// CONCATENATED MODULE: ./node_modules/_@emotion_unitless@0.7.5@@emotion/unitless/dist/unitless.browser.esm.js
var unitlessKeys = {
  animationIterationCount: 1,
  borderImageOutset: 1,
  borderImageSlice: 1,
  borderImageWidth: 1,
  boxFlex: 1,
  boxFlexGroup: 1,
  boxOrdinalGroup: 1,
  columnCount: 1,
  columns: 1,
  flex: 1,
  flexGrow: 1,
  flexPositive: 1,
  flexShrink: 1,
  flexNegative: 1,
  flexOrder: 1,
  gridRow: 1,
  gridRowEnd: 1,
  gridRowSpan: 1,
  gridRowStart: 1,
  gridColumn: 1,
  gridColumnEnd: 1,
  gridColumnSpan: 1,
  gridColumnStart: 1,
  msGridRow: 1,
  msGridRowSpan: 1,
  msGridColumn: 1,
  msGridColumnSpan: 1,
  fontWeight: 1,
  lineHeight: 1,
  opacity: 1,
  order: 1,
  orphans: 1,
  tabSize: 1,
  widows: 1,
  zIndex: 1,
  zoom: 1,
  WebkitLineClamp: 1,
  // SVG-related properties
  fillOpacity: 1,
  floodOpacity: 1,
  stopOpacity: 1,
  strokeDasharray: 1,
  strokeDashoffset: 1,
  strokeMiterlimit: 1,
  strokeOpacity: 1,
  strokeWidth: 1
};
/* harmony default export */ var unitless_browser_esm = (unitlessKeys);
;// CONCATENATED MODULE: ./node_modules/_@emotion_memoize@0.8.0@@emotion/memoize/dist/emotion-memoize.esm.js
function memoize(fn) {
  var cache = Object.create(null);
  return function (arg) {
    if (cache[arg] === undefined) cache[arg] = fn(arg);
    return cache[arg];
  };
}
/* harmony default export */ var emotion_memoize_esm = (memoize);
;// CONCATENATED MODULE: ./node_modules/_@emotion_is-prop-valid@1.2.0@@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js

var reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|download|draggable|encType|enterKeyHint|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23

var isPropValid = /* #__PURE__ */emotion_memoize_esm(function (prop) {
  return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111
  /* o */ && prop.charCodeAt(1) === 110
  /* n */ && prop.charCodeAt(2) < 91;
}
/* Z+1 */);

/* harmony default export */ var emotion_is_prop_valid_esm = (isPropValid);
// EXTERNAL MODULE: ./node_modules/_hoist-non-react-statics@3.3.2@hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js
var hoist_non_react_statics_cjs = __webpack_require__(7029);
var hoist_non_react_statics_cjs_default = /*#__PURE__*/__webpack_require__.n(hoist_non_react_statics_cjs);
;// CONCATENATED MODULE: ./node_modules/_styled-components@5.3.9@styled-components/dist/styled-components.browser.esm.js







function v() {
  return (v = Object.assign || function (e) {
    for (var t = 1; t < arguments.length; t++) {
      var n = arguments[t];
      for (var r in n) Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r]);
    }
    return e;
  }).apply(this, arguments);
}
var g = function g(e, t) {
    for (var n = [e[0]], r = 0, o = t.length; r < o; r += 1) n.push(t[r], e[r + 1]);
    return n;
  },
  S = function S(t) {
    return null !== t && "object" == typeof t && "[object Object]" === (t.toString ? t.toString() : Object.prototype.toString.call(t)) && !(0,_react_is_18_2_0_react_is.typeOf)(t);
  },
  w = Object.freeze([]),
  E = Object.freeze({});
function b(e) {
  return "function" == typeof e;
}
function _(e) {
  return  false || e.displayName || e.name || "Component";
}
function N(e) {
  return e && "string" == typeof e.styledComponentId;
}
var A = "undefined" != typeof process && void 0 !== ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}) && (({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}).REACT_APP_SC_ATTR || ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}).SC_ATTR) || "data-styled",
  C = "5.3.9",
  I = "undefined" != typeof window && "HTMLElement" in window,
  P = Boolean("boolean" == typeof SC_DISABLE_SPEEDY ? SC_DISABLE_SPEEDY : "undefined" != typeof process && void 0 !== ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}) && (void 0 !== ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}).REACT_APP_SC_DISABLE_SPEEDY && "" !== ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}).REACT_APP_SC_DISABLE_SPEEDY ? "false" !== ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}).REACT_APP_SC_DISABLE_SPEEDY && ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}).REACT_APP_SC_DISABLE_SPEEDY : void 0 !== ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}).SC_DISABLE_SPEEDY && "" !== ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}).SC_DISABLE_SPEEDY ? "false" !== ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}).SC_DISABLE_SPEEDY && ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}).SC_DISABLE_SPEEDY : "production" !== "production")),
  O = {},
  R =  false ? 0 : {};
function D() {
  for (var e = arguments.length <= 0 ? void 0 : arguments[0], t = [], n = 1, r = arguments.length; n < r; n += 1) t.push(n < 0 || arguments.length <= n ? void 0 : arguments[n]);
  return t.forEach(function (t) {
    e = e.replace(/%[a-z]/, t);
  }), e;
}
function j(e) {
  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), r = 1; r < t; r++) n[r - 1] = arguments[r];
  throw  true ? new Error("An error occurred. See https://git.io/JUIaE#" + e + " for more information." + (n.length > 0 ? " Args: " + n.join(", ") : "")) : 0;
}
var T = function () {
    function e(e) {
      this.groupSizes = new Uint32Array(512), this.length = 512, this.tag = e;
    }
    var t = e.prototype;
    return t.indexOfGroup = function (e) {
      for (var t = 0, n = 0; n < e; n++) t += this.groupSizes[n];
      return t;
    }, t.insertRules = function (e, t) {
      if (e >= this.groupSizes.length) {
        for (var n = this.groupSizes, r = n.length, o = r; e >= o;) (o <<= 1) < 0 && j(16, "" + e);
        this.groupSizes = new Uint32Array(o), this.groupSizes.set(n), this.length = o;
        for (var s = r; s < o; s++) this.groupSizes[s] = 0;
      }
      for (var i = this.indexOfGroup(e + 1), a = 0, c = t.length; a < c; a++) this.tag.insertRule(i, t[a]) && (this.groupSizes[e]++, i++);
    }, t.clearGroup = function (e) {
      if (e < this.length) {
        var t = this.groupSizes[e],
          n = this.indexOfGroup(e),
          r = n + t;
        this.groupSizes[e] = 0;
        for (var o = n; o < r; o++) this.tag.deleteRule(n);
      }
    }, t.getGroup = function (e) {
      var t = "";
      if (e >= this.length || 0 === this.groupSizes[e]) return t;
      for (var n = this.groupSizes[e], r = this.indexOfGroup(e), o = r + n, s = r; s < o; s++) t += this.tag.getRule(s) + "/*!sc*/\n";
      return t;
    }, e;
  }(),
  x = new Map(),
  k = new Map(),
  V = 1,
  B = function B(e) {
    if (x.has(e)) return x.get(e);
    for (; k.has(V);) V++;
    var t = V++;
    return  false && 0, x.set(e, t), k.set(t, e), t;
  },
  z = function z(e) {
    return k.get(e);
  },
  M = function M(e, t) {
    t >= V && (V = t + 1), x.set(e, t), k.set(t, e);
  },
  G = "style[" + A + '][data-styled-version="5.3.9"]',
  L = new RegExp("^" + A + '\\.g(\\d+)\\[id="([\\w\\d-]+)"\\].*?"([^"]*)'),
  F = function F(e, t, n) {
    for (var r, o = n.split(","), s = 0, i = o.length; s < i; s++) (r = o[s]) && e.registerName(t, r);
  },
  Y = function Y(e, t) {
    for (var n = (t.textContent || "").split("/*!sc*/\n"), r = [], o = 0, s = n.length; o < s; o++) {
      var i = n[o].trim();
      if (i) {
        var a = i.match(L);
        if (a) {
          var c = 0 | parseInt(a[1], 10),
            u = a[2];
          0 !== c && (M(u, c), F(e, u, a[3]), e.getTag().insertRules(c, r)), r.length = 0;
        } else r.push(i);
      }
    }
  },
  q = function q() {
    return  true ? __webpack_require__.nc : 0;
  },
  H = function H(e) {
    var t = document.head,
      n = e || t,
      r = document.createElement("style"),
      o = function (e) {
        for (var t = e.childNodes, n = t.length; n >= 0; n--) {
          var r = t[n];
          if (r && 1 === r.nodeType && r.hasAttribute(A)) return r;
        }
      }(n),
      s = void 0 !== o ? o.nextSibling : null;
    r.setAttribute(A, "active"), r.setAttribute("data-styled-version", "5.3.9");
    var i = q();
    return i && r.setAttribute("nonce", i), n.insertBefore(r, s), r;
  },
  $ = function () {
    function e(e) {
      var t = this.element = H(e);
      t.appendChild(document.createTextNode("")), this.sheet = function (e) {
        if (e.sheet) return e.sheet;
        for (var t = document.styleSheets, n = 0, r = t.length; n < r; n++) {
          var o = t[n];
          if (o.ownerNode === e) return o;
        }
        j(17);
      }(t), this.length = 0;
    }
    var t = e.prototype;
    return t.insertRule = function (e, t) {
      try {
        return this.sheet.insertRule(t, e), this.length++, !0;
      } catch (e) {
        return !1;
      }
    }, t.deleteRule = function (e) {
      this.sheet.deleteRule(e), this.length--;
    }, t.getRule = function (e) {
      var t = this.sheet.cssRules[e];
      return void 0 !== t && "string" == typeof t.cssText ? t.cssText : "";
    }, e;
  }(),
  W = function () {
    function e(e) {
      var t = this.element = H(e);
      this.nodes = t.childNodes, this.length = 0;
    }
    var t = e.prototype;
    return t.insertRule = function (e, t) {
      if (e <= this.length && e >= 0) {
        var n = document.createTextNode(t),
          r = this.nodes[e];
        return this.element.insertBefore(n, r || null), this.length++, !0;
      }
      return !1;
    }, t.deleteRule = function (e) {
      this.element.removeChild(this.nodes[e]), this.length--;
    }, t.getRule = function (e) {
      return e < this.length ? this.nodes[e].textContent : "";
    }, e;
  }(),
  U = function () {
    function e(e) {
      this.rules = [], this.length = 0;
    }
    var t = e.prototype;
    return t.insertRule = function (e, t) {
      return e <= this.length && (this.rules.splice(e, 0, t), this.length++, !0);
    }, t.deleteRule = function (e) {
      this.rules.splice(e, 1), this.length--;
    }, t.getRule = function (e) {
      return e < this.length ? this.rules[e] : "";
    }, e;
  }(),
  J = I,
  X = {
    isServer: !I,
    useCSSOMInjection: !P
  },
  Z = function () {
    function e(e, t, n) {
      void 0 === e && (e = E), void 0 === t && (t = {}), this.options = v({}, X, {}, e), this.gs = t, this.names = new Map(n), this.server = !!e.isServer, !this.server && I && J && (J = !1, function (e) {
        for (var t = document.querySelectorAll(G), n = 0, r = t.length; n < r; n++) {
          var o = t[n];
          o && "active" !== o.getAttribute(A) && (Y(e, o), o.parentNode && o.parentNode.removeChild(o));
        }
      }(this));
    }
    e.registerId = function (e) {
      return B(e);
    };
    var t = e.prototype;
    return t.reconstructWithOptions = function (t, n) {
      return void 0 === n && (n = !0), new e(v({}, this.options, {}, t), this.gs, n && this.names || void 0);
    }, t.allocateGSInstance = function (e) {
      return this.gs[e] = (this.gs[e] || 0) + 1;
    }, t.getTag = function () {
      return this.tag || (this.tag = (n = (t = this.options).isServer, r = t.useCSSOMInjection, o = t.target, e = n ? new U(o) : r ? new $(o) : new W(o), new T(e)));
      var e, t, n, r, o;
    }, t.hasNameForId = function (e, t) {
      return this.names.has(e) && this.names.get(e).has(t);
    }, t.registerName = function (e, t) {
      if (B(e), this.names.has(e)) this.names.get(e).add(t);else {
        var n = new Set();
        n.add(t), this.names.set(e, n);
      }
    }, t.insertRules = function (e, t, n) {
      this.registerName(e, t), this.getTag().insertRules(B(e), n);
    }, t.clearNames = function (e) {
      this.names.has(e) && this.names.get(e).clear();
    }, t.clearRules = function (e) {
      this.getTag().clearGroup(B(e)), this.clearNames(e);
    }, t.clearTag = function () {
      this.tag = void 0;
    }, t.toString = function () {
      return function (e) {
        for (var t = e.getTag(), n = t.length, r = "", o = 0; o < n; o++) {
          var s = z(o);
          if (void 0 !== s) {
            var i = e.names.get(s),
              a = t.getGroup(o);
            if (i && a && i.size) {
              var c = A + ".g" + o + '[id="' + s + '"]',
                u = "";
              void 0 !== i && i.forEach(function (e) {
                e.length > 0 && (u += e + ",");
              }), r += "" + a + c + '{content:"' + u + '"}/*!sc*/\n';
            }
          }
        }
        return r;
      }(this);
    }, e;
  }(),
  K = /(a)(d)/gi,
  Q = function Q(e) {
    return String.fromCharCode(e + (e > 25 ? 39 : 97));
  };
function ee(e) {
  var t,
    n = "";
  for (t = Math.abs(e); t > 52; t = t / 52 | 0) n = Q(t % 52) + n;
  return (Q(t % 52) + n).replace(K, "$1-$2");
}
var te = function te(e, t) {
    for (var n = t.length; n;) e = 33 * e ^ t.charCodeAt(--n);
    return e;
  },
  ne = function ne(e) {
    return te(5381, e);
  };
function re(e) {
  for (var t = 0; t < e.length; t += 1) {
    var n = e[t];
    if (b(n) && !N(n)) return !1;
  }
  return !0;
}
var oe = ne("5.3.9"),
  se = function () {
    function e(e, t, n) {
      this.rules = e, this.staticRulesId = "", this.isStatic =  true && (void 0 === n || n.isStatic) && re(e), this.componentId = t, this.baseHash = te(oe, t), this.baseStyle = n, Z.registerId(t);
    }
    return e.prototype.generateAndInjectStyles = function (e, t, n) {
      var r = this.componentId,
        o = [];
      if (this.baseStyle && o.push(this.baseStyle.generateAndInjectStyles(e, t, n)), this.isStatic && !n.hash) {
        if (this.staticRulesId && t.hasNameForId(r, this.staticRulesId)) o.push(this.staticRulesId);else {
          var s = Ne(this.rules, e, t, n).join(""),
            i = ee(te(this.baseHash, s) >>> 0);
          if (!t.hasNameForId(r, i)) {
            var a = n(s, "." + i, void 0, r);
            t.insertRules(r, i, a);
          }
          o.push(i), this.staticRulesId = i;
        }
      } else {
        for (var c = this.rules.length, u = te(this.baseHash, n.hash), l = "", d = 0; d < c; d++) {
          var h = this.rules[d];
          if ("string" == typeof h) l += h,  false && (0);else if (h) {
            var p = Ne(h, e, t, n),
              f = Array.isArray(p) ? p.join("") : p;
            u = te(u, f + d), l += f;
          }
        }
        if (l) {
          var m = ee(u >>> 0);
          if (!t.hasNameForId(r, m)) {
            var y = n(l, "." + m, void 0, r);
            t.insertRules(r, m, y);
          }
          o.push(m);
        }
      }
      return o.join(" ");
    }, e;
  }(),
  ie = /^\s*\/\/.*$/gm,
  ae = [":", "[", ".", "#"];
function ce(e) {
  var t,
    n,
    r,
    o,
    s = void 0 === e ? E : e,
    i = s.options,
    a = void 0 === i ? E : i,
    c = s.plugins,
    u = void 0 === c ? w : c,
    l = new stylis_browser_esm(a),
    d = [],
    h = function (e) {
      function t(t) {
        if (t) try {
          e(t + "}");
        } catch (e) {}
      }
      return function (n, r, o, s, i, a, c, u, l, d) {
        switch (n) {
          case 1:
            if (0 === l && 64 === r.charCodeAt(0)) return e(r + ";"), "";
            break;
          case 2:
            if (0 === u) return r + "/*|*/";
            break;
          case 3:
            switch (u) {
              case 102:
              case 112:
                return e(o[0] + r), "";
              default:
                return r + (0 === d ? "/*|*/" : "");
            }
          case -2:
            r.split("/*|*/}").forEach(t);
        }
      };
    }(function (e) {
      d.push(e);
    }),
    f = function f(e, r, s) {
      return 0 === r && -1 !== ae.indexOf(s[n.length]) || s.match(o) ? e : "." + t;
    };
  function m(e, s, i, a) {
    void 0 === a && (a = "&");
    var c = e.replace(ie, ""),
      u = s && i ? i + " " + s + " { " + c + " }" : c;
    return t = a, n = s, r = new RegExp("\\" + n + "\\b", "g"), o = new RegExp("(\\" + n + "\\b){2,}"), l(i || !s ? "" : s, u);
  }
  return l.use([].concat(u, [function (e, t, o) {
    2 === e && o.length && o[0].lastIndexOf(n) > 0 && (o[0] = o[0].replace(r, f));
  }, h, function (e) {
    if (-2 === e) {
      var t = d;
      return d = [], t;
    }
  }])), m.hash = u.length ? u.reduce(function (e, t) {
    return t.name || j(15), te(e, t.name);
  }, 5381).toString() : "", m;
}
var ue = _react_18_2_0_react.createContext(),
  le = ue.Consumer,
  de = _react_18_2_0_react.createContext(),
  he = (de.Consumer, new Z()),
  pe = ce();
function fe() {
  return (0,_react_18_2_0_react.useContext)(ue) || he;
}
function me() {
  return (0,_react_18_2_0_react.useContext)(de) || pe;
}
function ye(e) {
  var t = (0,_react_18_2_0_react.useState)(e.stylisPlugins),
    n = t[0],
    s = t[1],
    c = fe(),
    u = (0,_react_18_2_0_react.useMemo)(function () {
      var t = c;
      return e.sheet ? t = e.sheet : e.target && (t = t.reconstructWithOptions({
        target: e.target
      }, !1)), e.disableCSSOMInjection && (t = t.reconstructWithOptions({
        useCSSOMInjection: !1
      })), t;
    }, [e.disableCSSOMInjection, e.sheet, e.target]),
    l = (0,_react_18_2_0_react.useMemo)(function () {
      return ce({
        options: {
          prefix: !e.disableVendorPrefixes
        },
        plugins: n
      });
    }, [e.disableVendorPrefixes, n]);
  return (0,_react_18_2_0_react.useEffect)(function () {
    _shallowequal_1_1_0_shallowequal_default()(n, e.stylisPlugins) || s(e.stylisPlugins);
  }, [e.stylisPlugins]), _react_18_2_0_react.createElement(ue.Provider, {
    value: u
  }, _react_18_2_0_react.createElement(de.Provider, {
    value: l
  },  false ? 0 : e.children));
}
var ve = function () {
    function e(e, t) {
      var n = this;
      this.inject = function (e, t) {
        void 0 === t && (t = pe);
        var r = n.name + t.hash;
        e.hasNameForId(n.id, r) || e.insertRules(n.id, r, t(n.rules, r, "@keyframes"));
      }, this.toString = function () {
        return j(12, String(n.name));
      }, this.name = e, this.id = "sc-keyframes-" + e, this.rules = t;
    }
    return e.prototype.getName = function (e) {
      return void 0 === e && (e = pe), this.name + e.hash;
    }, e;
  }(),
  ge = /([A-Z])/,
  Se = /([A-Z])/g,
  we = /^ms-/,
  Ee = function Ee(e) {
    return "-" + e.toLowerCase();
  };
function be(e) {
  return ge.test(e) ? e.replace(Se, Ee).replace(we, "-ms-") : e;
}
var _e = function _e(e) {
  return null == e || !1 === e || "" === e;
};
function Ne(e, n, r, o) {
  if (Array.isArray(e)) {
    for (var s, i = [], a = 0, c = e.length; a < c; a += 1) "" !== (s = Ne(e[a], n, r, o)) && (Array.isArray(s) ? i.push.apply(i, s) : i.push(s));
    return i;
  }
  if (_e(e)) return "";
  if (N(e)) return "." + e.styledComponentId;
  if (b(e)) {
    if ("function" != typeof (l = e) || l.prototype && l.prototype.isReactComponent || !n) return e;
    var u = e(n);
    return  false && 0, Ne(u, n, r, o);
  }
  var l;
  return e instanceof ve ? r ? (e.inject(r, o), e.getName(o)) : e : S(e) ? function e(t, n) {
    var r,
      o,
      s = [];
    for (var i in t) t.hasOwnProperty(i) && !_e(t[i]) && (Array.isArray(t[i]) && t[i].isCss || b(t[i]) ? s.push(be(i) + ":", t[i], ";") : S(t[i]) ? s.push.apply(s, e(t[i], i)) : s.push(be(i) + ": " + (r = i, null == (o = t[i]) || "boolean" == typeof o || "" === o ? "" : "number" != typeof o || 0 === o || r in unitless_browser_esm ? String(o).trim() : o + "px") + ";"));
    return n ? [n + " {"].concat(s, ["}"]) : s;
  }(e) : e.toString();
}
var Ae = function Ae(e) {
  return Array.isArray(e) && (e.isCss = !0), e;
};
function Ce(e) {
  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), r = 1; r < t; r++) n[r - 1] = arguments[r];
  return b(e) || S(e) ? Ae(Ne(g(w, [e].concat(n)))) : 0 === n.length && 1 === e.length && "string" == typeof e[0] ? e : Ae(Ne(g(e, n)));
}
var Ie = /invalid hook call/i,
  Pe = new Set(),
  Oe = function Oe(e, t) {
    if (false) { var o, n, r; }
  },
  Re = function Re(e, t, n) {
    return void 0 === n && (n = E), e.theme !== n.theme && e.theme || t || n.theme;
  },
  De = /[!"#$%&'()*+,./:;<=>?@[\\\]^`{|}~-]+/g,
  je = /(^-|-$)/g;
function Te(e) {
  return e.replace(De, "-").replace(je, "");
}
var xe = function xe(e) {
  return ee(ne(e) >>> 0);
};
function ke(e) {
  return "string" == typeof e && ( true || 0);
}
var Ve = function Ve(e) {
    return "function" == typeof e || "object" == typeof e && null !== e && !Array.isArray(e);
  },
  Be = function Be(e) {
    return "__proto__" !== e && "constructor" !== e && "prototype" !== e;
  };
function ze(e, t, n) {
  var r = e[n];
  Ve(t) && Ve(r) ? Me(r, t) : e[n] = t;
}
function Me(e) {
  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), r = 1; r < t; r++) n[r - 1] = arguments[r];
  for (var o = 0, s = n; o < s.length; o++) {
    var i = s[o];
    if (Ve(i)) for (var a in i) Be(a) && ze(e, i[a], a);
  }
  return e;
}
var Ge = _react_18_2_0_react.createContext(),
  Le = Ge.Consumer;
function Fe(e) {
  var t = s(Ge),
    n = i(function () {
      return function (e, t) {
        if (!e) return j(14);
        if (b(e)) {
          var n = e(t);
          return  true ? n : 0;
        }
        return Array.isArray(e) || "object" != typeof e ? j(8) : t ? v({}, t, {}, e) : e;
      }(e.theme, t);
    }, [e.theme, t]);
  return e.children ? r.createElement(Ge.Provider, {
    value: n
  }, e.children) : null;
}
var Ye = {};
function qe(e, t, n) {
  var o = N(e),
    i = !ke(e),
    a = t.attrs,
    c = void 0 === a ? w : a,
    d = t.componentId,
    h = void 0 === d ? function (e, t) {
      var n = "string" != typeof e ? "sc" : Te(e);
      Ye[n] = (Ye[n] || 0) + 1;
      var r = n + "-" + xe("5.3.9" + n + Ye[n]);
      return t ? t + "-" + r : r;
    }(t.displayName, t.parentComponentId) : d,
    p = t.displayName,
    f = void 0 === p ? function (e) {
      return ke(e) ? "styled." + e : "Styled(" + _(e) + ")";
    }(e) : p,
    g = t.displayName && t.componentId ? Te(t.displayName) + "-" + t.componentId : t.componentId || h,
    S = o && e.attrs ? Array.prototype.concat(e.attrs, c).filter(Boolean) : c,
    A = t.shouldForwardProp;
  o && e.shouldForwardProp && (A = t.shouldForwardProp ? function (n, r, o) {
    return e.shouldForwardProp(n, r, o) && t.shouldForwardProp(n, r, o);
  } : e.shouldForwardProp);
  var C,
    I = new se(n, g, o ? e.componentStyle : void 0),
    P = I.isStatic && 0 === c.length,
    O = function O(e, t) {
      return function (e, t, n, r) {
        var o = e.attrs,
          i = e.componentStyle,
          a = e.defaultProps,
          c = e.foldedComponentIds,
          d = e.shouldForwardProp,
          h = e.styledComponentId,
          p = e.target;
         false && 0;
        var f = function (e, t, n) {
            void 0 === e && (e = E);
            var r = v({}, t, {
                theme: e
              }),
              o = {};
            return n.forEach(function (e) {
              var t,
                n,
                s,
                i = e;
              for (t in b(i) && (i = i(r)), i) r[t] = o[t] = "className" === t ? (n = o[t], s = i[t], n && s ? n + " " + s : n || s) : i[t];
            }), [r, o];
          }(Re(t, (0,_react_18_2_0_react.useContext)(Ge), a) || E, t, o),
          y = f[0],
          g = f[1],
          S = function (e, t, n, r) {
            var o = fe(),
              s = me(),
              i = t ? e.generateAndInjectStyles(E, o, s) : e.generateAndInjectStyles(n, o, s);
            return  false && 0,  false && 0, i;
          }(i, r, y,  false ? 0 : void 0),
          w = n,
          _ = g.$as || t.$as || g.as || t.as || p,
          N = ke(_),
          A = g !== t ? v({}, t, {}, g) : t,
          C = {};
        for (var I in A) "$" !== I[0] && "as" !== I && ("forwardedAs" === I ? C.as = A[I] : (d ? d(I, emotion_is_prop_valid_esm, _) : !N || emotion_is_prop_valid_esm(I)) && (C[I] = A[I]));
        return t.style && g.style !== t.style && (C.style = v({}, t.style, {}, g.style)), C.className = Array.prototype.concat(c, h, S !== h ? S : null, t.className, g.className).filter(Boolean).join(" "), C.ref = w, (0,_react_18_2_0_react.createElement)(_, C);
      }(C, e, t, P);
    };
  return O.displayName = f, (C = _react_18_2_0_react.forwardRef(O)).attrs = S, C.componentStyle = I, C.displayName = f, C.shouldForwardProp = A, C.foldedComponentIds = o ? Array.prototype.concat(e.foldedComponentIds, e.styledComponentId) : w, C.styledComponentId = g, C.target = o ? e.target : e, C.withComponent = function (e) {
    var r = t.componentId,
      o = function (e, t) {
        if (null == e) return {};
        var n,
          r,
          o = {},
          s = Object.keys(e);
        for (r = 0; r < s.length; r++) n = s[r], t.indexOf(n) >= 0 || (o[n] = e[n]);
        return o;
      }(t, ["componentId"]),
      s = r && r + "-" + (ke(e) ? e : Te(_(e)));
    return qe(e, v({}, o, {
      attrs: S,
      componentId: s
    }), n);
  }, Object.defineProperty(C, "defaultProps", {
    get: function get() {
      return this._foldedDefaultProps;
    },
    set: function set(t) {
      this._foldedDefaultProps = o ? Me({}, e.defaultProps, t) : t;
    }
  }),  false && (0), Object.defineProperty(C, "toString", {
    value: function value() {
      return "." + C.styledComponentId;
    }
  }), i && hoist_non_react_statics_cjs_default()(C, e, {
    attrs: !0,
    componentStyle: !0,
    displayName: !0,
    foldedComponentIds: !0,
    shouldForwardProp: !0,
    styledComponentId: !0,
    target: !0,
    withComponent: !0
  }), C;
}
var He = function He(e) {
  return function e(t, r, o) {
    if (void 0 === o && (o = E), !(0,_react_is_18_2_0_react_is.isValidElementType)(r)) return j(1, String(r));
    var s = function s() {
      return t(r, o, Ce.apply(void 0, arguments));
    };
    return s.withConfig = function (n) {
      return e(t, r, v({}, o, {}, n));
    }, s.attrs = function (n) {
      return e(t, r, v({}, o, {
        attrs: Array.prototype.concat(o.attrs, n).filter(Boolean)
      }));
    }, s;
  }(qe, e);
};
["a", "abbr", "address", "area", "article", "aside", "audio", "b", "base", "bdi", "bdo", "big", "blockquote", "body", "br", "button", "canvas", "caption", "cite", "code", "col", "colgroup", "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt", "em", "embed", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "iframe", "img", "input", "ins", "kbd", "keygen", "label", "legend", "li", "link", "main", "map", "mark", "marquee", "menu", "menuitem", "meta", "meter", "nav", "noscript", "object", "ol", "optgroup", "option", "output", "p", "param", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "script", "section", "select", "small", "source", "span", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "textarea", "tfoot", "th", "thead", "time", "title", "tr", "track", "u", "ul", "var", "video", "wbr", "circle", "clipPath", "defs", "ellipse", "foreignObject", "g", "image", "line", "linearGradient", "marker", "mask", "path", "pattern", "polygon", "polyline", "radialGradient", "rect", "stop", "svg", "text", "textPath", "tspan"].forEach(function (e) {
  He[e] = He(e);
});
var $e = function () {
  function e(e, t) {
    this.rules = e, this.componentId = t, this.isStatic = re(e), Z.registerId(this.componentId + 1);
  }
  var t = e.prototype;
  return t.createStyles = function (e, t, n, r) {
    var o = r(Ne(this.rules, t, n, r).join(""), ""),
      s = this.componentId + e;
    n.insertRules(s, s, o);
  }, t.removeStyles = function (e, t) {
    t.clearRules(this.componentId + e);
  }, t.renderStyles = function (e, t, n, r) {
    e > 2 && Z.registerId(this.componentId + e), this.removeStyles(e, n), this.createStyles(e, t, n, r);
  }, e;
}();
function We(e) {
  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), o = 1; o < t; o++) n[o - 1] = arguments[o];
  var i = Ce.apply(void 0, [e].concat(n)),
    a = "sc-global-" + xe(JSON.stringify(i)),
    u = new $e(i, a);
  function l(e) {
    var t = fe(),
      n = me(),
      o = (0,_react_18_2_0_react.useContext)(Ge),
      l = (0,_react_18_2_0_react.useRef)(t.allocateGSInstance(a)).current;
    return  false && 0,  false && 0, t.server && h(l, e, t, o, n), (0,_react_18_2_0_react.useLayoutEffect)(function () {
      if (!t.server) return h(l, e, t, o, n), function () {
        return u.removeStyles(l, t);
      };
    }, [l, e, t, o, n]), null;
  }
  function h(e, t, n, r, o) {
    if (u.isStatic) u.renderStyles(e, O, n, o);else {
      var s = v({}, t, {
        theme: Re(t, r, l.defaultProps)
      });
      u.renderStyles(e, s, n, o);
    }
  }
  return  false && 0, _react_18_2_0_react.memo(l);
}
function Ue(e) {
   false && 0;
  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), r = 1; r < t; r++) n[r - 1] = arguments[r];
  var o = Ce.apply(void 0, [e].concat(n)).join(""),
    s = xe(o);
  return new ve(s, o);
}
var Je = function () {
    function e() {
      var e = this;
      this._emitSheetCSS = function () {
        var t = e.instance.toString();
        if (!t) return "";
        var n = q();
        return "<style " + [n && 'nonce="' + n + '"', A + '="true"', 'data-styled-version="5.3.9"'].filter(Boolean).join(" ") + ">" + t + "</style>";
      }, this.getStyleTags = function () {
        return e.sealed ? j(2) : e._emitSheetCSS();
      }, this.getStyleElement = function () {
        var t;
        if (e.sealed) return j(2);
        var n = ((t = {})[A] = "", t["data-styled-version"] = "5.3.9", t.dangerouslySetInnerHTML = {
            __html: e.instance.toString()
          }, t),
          o = q();
        return o && (n.nonce = o), [_react_18_2_0_react.createElement("style", v({}, n, {
          key: "sc-0-0"
        }))];
      }, this.seal = function () {
        e.sealed = !0;
      }, this.instance = new Z({
        isServer: !0
      }), this.sealed = !1;
    }
    var t = e.prototype;
    return t.collectStyles = function (e) {
      return this.sealed ? j(2) : _react_18_2_0_react.createElement(ye, {
        sheet: this.instance
      }, e);
    }, t.interleaveWithNodeStream = function (e) {
      return j(3);
    }, e;
  }(),
  Xe = function Xe(e) {
    var t = r.forwardRef(function (t, n) {
      var o = s(Ge),
        i = e.defaultProps,
        a = Re(t, o, i);
      return  false && 0, r.createElement(e, v({}, t, {
        theme: a,
        ref: n
      }));
    });
    return y(t, e), t.displayName = "WithTheme(" + _(e) + ")", t;
  },
  Ze = function Ze() {
    return s(Ge);
  },
  Ke = {
    StyleSheet: Z,
    masterSheet: he
  };
 false && 0,  false && (0);
/* harmony default export */ var styled_components_browser_esm = (He);

;// CONCATENATED MODULE: ./src/components/popup/styled.tsx
var _templateObject,_templateObject2;var GlobalStyle=We(_templateObject||(_templateObject=_taggedTemplateLiteral(["\n  body {\n    width: 300px;\n    height: 300px;\n  }\n"])));var Wrapper=styled_components_browser_esm.div(_templateObject2||(_templateObject2=_taggedTemplateLiteral(["\n\n"])));
// EXTERNAL MODULE: ./node_modules/_axios@0.27.2@axios/index.js
var _axios_0_27_2_axios = __webpack_require__(8577);
var _axios_0_27_2_axios_default = /*#__PURE__*/__webpack_require__.n(_axios_0_27_2_axios);
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/toPrimitive.js

function _toPrimitive(input, hint) {
  if (_typeof(input) !== "object" || input === null) return input;
  var prim = input[Symbol.toPrimitive];
  if (prim !== undefined) {
    var res = prim.call(input, hint || "default");
    if (_typeof(res) !== "object") return res;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return (hint === "string" ? String : Number)(input);
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/toPropertyKey.js


function _toPropertyKey(arg) {
  var key = _toPrimitive(arg, "string");
  return _typeof(key) === "symbol" ? key : String(key);
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/defineProperty.js

function defineProperty_defineProperty(obj, key, value) {
  key = _toPropertyKey(key);
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }
  return obj;
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/objectSpread2.js

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 _objectSpread2(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_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;
}
;// CONCATENATED MODULE: ./src/services/createAxiosInstance.ts
function randomTraceId(){var len=arguments.length>0&&arguments[0]!==undefined?arguments[0]:32;// 16位16进制字符
var digits='0123456789abcdef';var n='';for(var i=0;i<len;i+=1){var rand=Math.floor(Math.random()*digits.length);n+=digits[rand];}return n;}var createAxiosInstance=function createAxiosInstance(){var instance=_axios_0_27_2_axios_default().create({withCredentials:true});instance.interceptors.request.use(function(config){var traceId=randomTraceId(32);var spanId=randomTraceId(16);var newConfig=_objectSpread2(_objectSpread2({},config),{},{headers:_objectSpread2(_objectSpread2({},config.headers),{},{'X-B3-Sampled':1,'X-B3-TraceId':traceId,'X-B3-SpanId':spanId}),traceId:traceId,spanId:spanId});return newConfig;});instance.interceptors.response.use(function(response){if(response.status===200){var _response$data;switch(String((_response$data=response.data)===null||_response$data===void 0?void 0:_response$data.code)){case'0':return Promise.resolve(response.data);case'CMN.NotLogin':{// 未登录
return Promise.reject('User not login');}default:{// 业务错误
return Promise.reject(response.data);}}}// Something went wrong
// 服务错误
var _msg="".concat(response.statusText,"\uFF08status=").concat(response.status,"\uFF09");return Promise.reject(new Error(_msg));},// 网络错误
function(error){// message.error('网络异常，请恢复后重试');
return Promise.reject(error);});return instance;};
;// CONCATENATED MODULE: ./src/services/home.ts
var genGetDirList=function genGetDirList(instance,config){return function(){var body={action:'getDirList',version:'1.0',returnDetails:true};return instance.post("".concat(config.apiPrefix,"/directory/request?getDirList"),body);};};
;// CONCATENATED MODULE: ./src/services/meeting.ts
;var genStartMeeting=function genStartMeeting(instance,config){return function(name){var dirId=arguments.length>1&&arguments[1]!==undefined?arguments[1]:0;var sourceLanguage=arguments.length>2&&arguments[2]!==undefined?arguments[2]:'cn';var body={action:'createMeeting',meetingType:'101',version:'1.0',dirId:dirId,tag:{showName:name,fileType:'meeting',lang:sourceLanguage,meetingPgPartial:'1',client:'chrome_extension',nFix:'1'}};return instance.post("".concat(config.apiPrefix,"/meeting/request?createMeeting"),body);};};var genStopMeeting=function genStopMeeting(instance,config){return function(meetingId){var body={action:'stopMeeting',version:'1.0',meetingId:meetingId,tag:{roleSplitNum:-1}};return instance.post("".concat(config.apiPrefix,"/meeting/request?stopMeeting"),body);};};var domainConfig=function domainConfig(instance,config){return function(){var body={namespace:'chrome'};return instance.post("".concat(config.apiPrefix,"/conf/pc"),body);};};var genSaveMeetingDocResult=function genSaveMeetingDocResult(instance,config){return function(transId,payload){var body={action:'saveMeetingDocResult',version:'1.0',content:JSON.stringify(payload),transId:transId};return instance.post("".concat(config.apiPrefix,"/meeting/request?saveMeetingDocResult"),body);};};var genGetTranslates=function genGetTranslates(instance,config){return function(meetingId,sourceLanguage,targetLanguage,needTranslates){var body={action:'transientTranslate',version:'1.0',meetingId:meetingId,sourceLanguage:sourceLanguage,targetLanguage:targetLanguage,textList:needTranslates,userId:''};return instance.post("".concat(config.apiPrefix,"/meeting/request?transientTranslate"),body);};};var genGetRealtimeTranslate=function genGetRealtimeTranslate(instance,config){return function(meetingId,sourceLanguage,targetLanguage,payload){var body={action:'realtimeTranslate',version:'1.0',meetingId:meetingId,sourceLanguage:sourceLanguage,targetLanguage:targetLanguage,sourceDoc:JSON.stringify(payload)};return instance.post("".concat(config.apiPrefix,"/meeting/request?realtimeTranslate"),body);};};var getGetMeetingHistoryTranslate=function getGetMeetingHistoryTranslate(instance,config){return function(meetingId,sourceLanguage,targetLanguage,paragraphIds){var body={action:'meetingTranslate',version:'1.0',meetingId:meetingId,sourceLanguage:sourceLanguage,targetLanguage:targetLanguage,paragraphIds:paragraphIds};return instance.post("".concat(config.apiPrefix,"/meeting/request?meetingTranslate"),body);};};var genGetSyncTransTag=function genGetSyncTransTag(instance,config){return function(transId,tag){var body={action:"syncTransTag",version:"1.0",transId:transId,tag:tag};return instance.post("".concat(config.apiPrefix,"/tag/request?syncTransTag"),body);};};
;// CONCATENATED MODULE: ./src/services/user.ts
var genGetUserInfo=function genGetUserInfo(instance,config){return function(){return instance.get("".concat(config.apiPrefix,"/account/info?Trans"));};};// 设置标记引导弹窗数据
var senMarksGuideStatus=function senMarksGuideStatus(instance,config){return function(recordValue){var body={action:'syncClientRecord',recordType:0,recordKey:'MarkupFeatureGuide',recordValue:recordValue};return instance.post("".concat(config.apiPrefix,"/record/request?setMarksGuideStatus"),body);};};// 获取标记引导弹窗数据
var genMarksGuideStatus=function genMarksGuideStatus(instance,config){return function(){var body={action:'getClientRecord',recordType:0,recordKey:'MarkupFeatureGuide'};return instance.post("".concat(config.apiPrefix,"/record/request?getMarksGuideStatus"),body);};};
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/extends.js
function extends_extends() {
  extends_extends = Object.assign ? Object.assign.bind() : function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];
      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }
    return target;
  };
  return extends_extends.apply(this, arguments);
}
;// CONCATENATED MODULE: ./node_modules/_@ali_ateb@0.0.5@@ali/ateb/dist-web/index.js


// Key Types
function isExtension(ext) {
  return ext instanceof Function;
}
function defaultApplicator(generator, strategy) {
  return generator(strategy);
}
var Ateb = /*#__PURE__*/function () {
  /**
   * The partial generator taking a strategy object and generate a target object
   * 
   * @type {PartialGenerator<R, S, D>}
   * @memberof Ateb
   */

  /**
   * The applicator deciding how to apply the generator on the strategy
   *
   * @type {Applicator<O, R>}
   * @memberof Ateb
   */

  /**
   * A wrapper of the extensible expression with chained methods
   * @param generator
   * @param strategy 
   * @param applicator 
   */
  function Ateb(generator, strategy, applicator) {
    this.generator = void 0;
    this.strategy = void 0;
    this.generate = void 0;
    this.applicator = void 0;
    this.generator = generator;
    this.strategy = strategy;
    this.applicator = applicator;
    this.generate =
    /**
     * Generate value from a partial strategy using the given applicator (by default \gs.gs)
     * @param override A partial strategy to override the defaults
     * @returns A value generated through the given applicator (by default \gs.gs)
     */
    function (override) {
      return applicator(generator, extends_extends({}, strategy, override));
    };
  }
  /**
   * Extend the Ateb to generated a new Ateb with additional behaviors and extensible strategies
   * @param extender An extension to the Ateb with additional strategy of T
   * @returns A new Ateb with strategy S & T
   */

  var _proto = Ateb.prototype;
  _proto.extendedBy = function extendedBy(ext) {
    var generator = this.generator,
      strategy = this.strategy;
    var _ref = isExtension(ext) ? ext({}) : ext,
      decorator = _ref[0],
      override = _ref[1];
    return new Ateb(decorator(generator), extends_extends({}, strategy, override), this.applicator);
  }
  /**
   * Get a new Ateb using the given applicator
   * @param applicator The applicator
   * @returns The new Ateb
   */;

  _proto.usingApplicator = function usingApplicator(applicator) {
    return new Ateb(this.generator, this.strategy, applicator);
  }
  /**
   * Define an extension for the Ateb with given strategy
   * @param strategy The default strategy filling the slots in the extension
   * @returns The clause to fill the Decorator of the extension
   */;

  _proto.extensionWithStrategy = function extensionWithStrategy(strategy) {
    return {
      /**
       * The clause to fill the Decorator of the extension
       * @param decorator The Decorator of the extension
       * @returns An extension for the specified Ateb
       */
      andDecorator: function andDecorator(decorator) {
        /**
         * Generator extender from the extension with an overriding strategy
         * @param strategy The overriding strategy
         * @returns A tuple of [Decorator, Strategy] as an extender
         */
        var extension = function extension(override) {
          return [decorator, extends_extends({}, strategy, override)];
        };
        return extension;
      }
    };
  };
  return Ateb;
}();
var index = {
  /**
   * The clause to fill the default strategy of the Ateb
   * @param strategy The default strategy of the Ateb
   * @returns The clause to fill the Generator of the Ateb
   */
  withStrategy: function withStrategy(strategy) {
    return {
      /**
       * The clause to fill the Generator of the Ateb
       * @param generator The Generator of the Ateb
       * @returns The Ateb with given Strategy and Generator
       */
      andGenerator: function andGenerator(generator) {
        return new Ateb(generator, strategy, defaultApplicator);
      }
    };
  }
};
/* harmony default export */ var dist_web = (index);

;// CONCATENATED MODULE: ./src/extends/logo.ts
var logoInAliBase64='data:image/svg+xml;base64, ';var logoBase64='data:image/svg+xml;base64, ';
;// CONCATENATED MODULE: ./src/extends/atebBasicConfig.ts
var atebBasicConfig=dist_web.withStrategy({version:'1.0.0',getTestInfo:function getTestInfo(){return'basic';},renderExtContent:function renderExtContent(){var idName=arguments.length>0&&arguments[0]!==undefined?arguments[0]:"";return null;},renderLogoSize:function renderLogoSize(){return'100px';},renderLogoUrl:function renderLogoUrl(){return'logoStartPanelAli.svg';},renderLogoSizeInCaption:function renderLogoSizeInCaption(){return'86px';},renderLogoBase64:function renderLogoBase64(){return logoInAliBase64;},getEnvInfo:function getEnvInfo(){return{publishName:'alibabaGroup',tingwuUrl:'https://tingwu.aliyuncs.com',loginUrl:'https://tingwu.aliyuncs.com/register/login',apiPrefix:'https://tingwu.aliyuncs.com/api',env:'prod'};}}).andGenerator(function(s){return s;});var extPreBasicConfig=atebBasicConfig.extensionWithStrategy({getEnvInfo:function getEnvInfo(){return{publishName:'alibabaGroup',tingwuUrl:'https://pre-tingwu.aliyuncs.com',loginUrl:'https://pre-tingwu.aliyuncs.com/register/login',apiPrefix:'https://pre-tingwu.aliyuncs.com/api',env:'pre'};}}).andDecorator(function(generator){return function(props){return generator(_objectSpread2(_objectSpread2({},props),{},{getTestInfo:function getTestInfo(){return props.getTestInfo()+'/pre';}}));};});
;// CONCATENATED MODULE: ./src/extends/extPublicServerConfig.ts
var extPublicServerConfig=atebBasicConfig.extensionWithStrategy({getEnvInfo:function getEnvInfo(){return{publishName:'publicServer',tingwuUrl:'https://www.tingwu.cn',loginUrl:'https://www.tingwu.cn/register/login',apiPrefix:'https://www.tingwu.cn/api',env:'prod'};},renderLogoSize:function renderLogoSize(){return'72px';},renderLogoSizeInCaption:function renderLogoSizeInCaption(){return'58.92px';},renderLogoUrl:function renderLogoUrl(){return'logoStartPanel.svg';},renderLogoBase64:function renderLogoBase64(){return logoBase64;}}).andDecorator(function(generator){return function(props){return generator(_objectSpread2(_objectSpread2({},props),{},{getTestInfo:function getTestInfo(){return props.getTestInfo()+'/publicServer';}}));};});var extPrePublicServerConfig=atebBasicConfig.extendedBy(extPublicServerConfig).extensionWithStrategy({getEnvInfo:function getEnvInfo(){return{publishName:'publicServer',tingwuUrl:'https://pre-tingwu.aliyun-inc.com',loginUrl:'https://pre-tingwu.aliyun-inc.com/register/login',apiPrefix:'https://pre-tingwu.aliyun-inc.com/api',env:'pre'};}}).andDecorator(function(generator){return function(props){return generator(_objectSpread2(_objectSpread2({},props),{},{getTestInfo:function getTestInfo(){return props.getTestInfo()+'/publicServerPre';}}));};});
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/arrayWithoutHoles.js

function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/iterableToArray.js
function _iterableToArray(iter) {
  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/nonIterableSpread.js
function _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/toConsumableArray.js




function _toConsumableArray(arr) {
  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons-svg@4.2.1@@ant-design/icons-svg/es/asn/CheckCircleOutlined.js
// This icon file is generated automatically.
var CheckCircleOutlined = {
  "icon": {
    "tag": "svg",
    "attrs": {
      "viewBox": "64 64 896 896",
      "focusable": "false"
    },
    "children": [{
      "tag": "path",
      "attrs": {
        "d": "M699 353h-46.9c-10.2 0-19.9 4.9-25.9 13.3L469 584.3l-71.2-98.8c-6-8.3-15.6-13.3-25.9-13.3H325c-6.5 0-10.3 7.4-6.5 12.7l124.6 172.8a31.8 31.8 0 0051.7 0l210.6-292c3.9-5.3.1-12.7-6.4-12.7z"
      }
    }, {
      "tag": "path",
      "attrs": {
        "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z"
      }
    }]
  },
  "name": "check-circle",
  "theme": "outlined"
};
/* harmony default export */ var asn_CheckCircleOutlined = (CheckCircleOutlined);
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js
function _objectWithoutPropertiesLoose(source, excluded) {
  if (source == null) return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i;
  for (i = 0; i < sourceKeys.length; i++) {
    key = sourceKeys[i];
    if (excluded.indexOf(key) >= 0) continue;
    target[key] = source[key];
  }
  return target;
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/objectWithoutProperties.js

function _objectWithoutProperties(source, excluded) {
  if (source == null) return {};
  var target = _objectWithoutPropertiesLoose(source, excluded);
  var key, i;
  if (Object.getOwnPropertySymbols) {
    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
    for (i = 0; i < sourceSymbolKeys.length; i++) {
      key = sourceSymbolKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
      target[key] = source[key];
    }
  }
  return target;
}
// EXTERNAL MODULE: ./node_modules/_classnames@2.3.2@classnames/index.js
var _classnames_2_3_2_classnames = __webpack_require__(2819);
var _classnames_2_3_2_classnames_default = /*#__PURE__*/__webpack_require__.n(_classnames_2_3_2_classnames);
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons@4.8.0@@ant-design/icons/es/components/Context.js

var IconContext = /*#__PURE__*/(0,_react_18_2_0_react.createContext)({});
/* harmony default export */ var Context = (IconContext);
;// CONCATENATED MODULE: ./node_modules/_@ctrl_tinycolor@3.6.0@@ctrl/tinycolor/dist/module/util.js
/**
 * Take input from [0, n] and return it as [0, 1]
 * @hidden
 */
function bound01(n, max) {
  if (isOnePointZero(n)) {
    n = '100%';
  }
  var isPercent = isPercentage(n);
  n = max === 360 ? n : Math.min(max, Math.max(0, parseFloat(n)));
  // Automatically convert percentage into number
  if (isPercent) {
    n = parseInt(String(n * max), 10) / 100;
  }
  // Handle floating point rounding errors
  if (Math.abs(n - max) < 0.000001) {
    return 1;
  }
  // Convert into [0, 1] range if it isn't already
  if (max === 360) {
    // If n is a hue given in degrees,
    // wrap around out-of-range values into [0, 360] range
    // then convert into [0, 1].
    n = (n < 0 ? n % max + max : n % max) / parseFloat(String(max));
  } else {
    // If n not a hue given in degrees
    // Convert into [0, 1] range if it isn't already.
    n = n % max / parseFloat(String(max));
  }
  return n;
}
/**
 * Force a number between 0 and 1
 * @hidden
 */
function clamp01(val) {
  return Math.min(1, Math.max(0, val));
}
/**
 * Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1
 * <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>
 * @hidden
 */
function isOnePointZero(n) {
  return typeof n === 'string' && n.indexOf('.') !== -1 && parseFloat(n) === 1;
}
/**
 * Check to see if string passed in is a percentage
 * @hidden
 */
function isPercentage(n) {
  return typeof n === 'string' && n.indexOf('%') !== -1;
}
/**
 * Return a valid alpha value [0,1] with all invalid values being set to 1
 * @hidden
 */
function boundAlpha(a) {
  a = parseFloat(a);
  if (isNaN(a) || a < 0 || a > 1) {
    a = 1;
  }
  return a;
}
/**
 * Replace a decimal with it's percentage value
 * @hidden
 */
function convertToPercentage(n) {
  if (n <= 1) {
    return "".concat(Number(n) * 100, "%");
  }
  return n;
}
/**
 * Force a hex value to have 2 characters
 * @hidden
 */
function util_pad2(c) {
  return c.length === 1 ? '0' + c : String(c);
}
;// CONCATENATED MODULE: ./node_modules/_@ctrl_tinycolor@3.6.0@@ctrl/tinycolor/dist/module/conversion.js

// `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:
// <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>
/**
 * Handle bounds / percentage checking to conform to CSS color spec
 * <http://www.w3.org/TR/css3-color/>
 * *Assumes:* r, g, b in [0, 255] or [0, 1]
 * *Returns:* { r, g, b } in [0, 255]
 */
function rgbToRgb(r, g, b) {
  return {
    r: bound01(r, 255) * 255,
    g: bound01(g, 255) * 255,
    b: bound01(b, 255) * 255
  };
}
/**
 * Converts an RGB color value to HSL.
 * *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]
 * *Returns:* { h, s, l } in [0,1]
 */
function rgbToHsl(r, g, b) {
  r = bound01(r, 255);
  g = bound01(g, 255);
  b = bound01(b, 255);
  var max = Math.max(r, g, b);
  var min = Math.min(r, g, b);
  var h = 0;
  var s = 0;
  var l = (max + min) / 2;
  if (max === min) {
    s = 0;
    h = 0; // achromatic
  } else {
    var d = max - min;
    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
    switch (max) {
      case r:
        h = (g - b) / d + (g < b ? 6 : 0);
        break;
      case g:
        h = (b - r) / d + 2;
        break;
      case b:
        h = (r - g) / d + 4;
        break;
      default:
        break;
    }
    h /= 6;
  }
  return {
    h: h,
    s: s,
    l: l
  };
}
function hue2rgb(p, q, t) {
  if (t < 0) {
    t += 1;
  }
  if (t > 1) {
    t -= 1;
  }
  if (t < 1 / 6) {
    return p + (q - p) * (6 * t);
  }
  if (t < 1 / 2) {
    return q;
  }
  if (t < 2 / 3) {
    return p + (q - p) * (2 / 3 - t) * 6;
  }
  return p;
}
/**
 * Converts an HSL color value to RGB.
 *
 * *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]
 * *Returns:* { r, g, b } in the set [0, 255]
 */
function hslToRgb(h, s, l) {
  var r;
  var g;
  var b;
  h = bound01(h, 360);
  s = bound01(s, 100);
  l = bound01(l, 100);
  if (s === 0) {
    // achromatic
    g = l;
    b = l;
    r = l;
  } else {
    var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
    var p = 2 * l - q;
    r = hue2rgb(p, q, h + 1 / 3);
    g = hue2rgb(p, q, h);
    b = hue2rgb(p, q, h - 1 / 3);
  }
  return {
    r: r * 255,
    g: g * 255,
    b: b * 255
  };
}
/**
 * Converts an RGB color value to HSV
 *
 * *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]
 * *Returns:* { h, s, v } in [0,1]
 */
function rgbToHsv(r, g, b) {
  r = bound01(r, 255);
  g = bound01(g, 255);
  b = bound01(b, 255);
  var max = Math.max(r, g, b);
  var min = Math.min(r, g, b);
  var h = 0;
  var v = max;
  var d = max - min;
  var s = max === 0 ? 0 : d / max;
  if (max === min) {
    h = 0; // achromatic
  } else {
    switch (max) {
      case r:
        h = (g - b) / d + (g < b ? 6 : 0);
        break;
      case g:
        h = (b - r) / d + 2;
        break;
      case b:
        h = (r - g) / d + 4;
        break;
      default:
        break;
    }
    h /= 6;
  }
  return {
    h: h,
    s: s,
    v: v
  };
}
/**
 * Converts an HSV color value to RGB.
 *
 * *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]
 * *Returns:* { r, g, b } in the set [0, 255]
 */
function hsvToRgb(h, s, v) {
  h = bound01(h, 360) * 6;
  s = bound01(s, 100);
  v = bound01(v, 100);
  var i = Math.floor(h);
  var f = h - i;
  var p = v * (1 - s);
  var q = v * (1 - f * s);
  var t = v * (1 - (1 - f) * s);
  var mod = i % 6;
  var r = [v, q, p, p, t, v][mod];
  var g = [t, v, v, q, p, p][mod];
  var b = [p, p, t, v, v, q][mod];
  return {
    r: r * 255,
    g: g * 255,
    b: b * 255
  };
}
/**
 * Converts an RGB color to hex
 *
 * Assumes r, g, and b are contained in the set [0, 255]
 * Returns a 3 or 6 character hex
 */
function rgbToHex(r, g, b, allow3Char) {
  var hex = [util_pad2(Math.round(r).toString(16)), util_pad2(Math.round(g).toString(16)), util_pad2(Math.round(b).toString(16))];
  // Return a 3 character hex if possible
  if (allow3Char && hex[0].startsWith(hex[0].charAt(1)) && hex[1].startsWith(hex[1].charAt(1)) && hex[2].startsWith(hex[2].charAt(1))) {
    return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
  }
  return hex.join('');
}
/**
 * Converts an RGBA color plus alpha transparency to hex
 *
 * Assumes r, g, b are contained in the set [0, 255] and
 * a in [0, 1]. Returns a 4 or 8 character rgba hex
 */
// eslint-disable-next-line max-params
function rgbaToHex(r, g, b, a, allow4Char) {
  var hex = [util_pad2(Math.round(r).toString(16)), util_pad2(Math.round(g).toString(16)), util_pad2(Math.round(b).toString(16)), util_pad2(convertDecimalToHex(a))];
  // Return a 4 character hex if possible
  if (allow4Char && hex[0].startsWith(hex[0].charAt(1)) && hex[1].startsWith(hex[1].charAt(1)) && hex[2].startsWith(hex[2].charAt(1)) && hex[3].startsWith(hex[3].charAt(1))) {
    return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
  }
  return hex.join('');
}
/**
 * Converts an RGBA color to an ARGB Hex8 string
 * Rarely used, but required for "toFilter()"
 */
function rgbaToArgbHex(r, g, b, a) {
  var hex = [pad2(convertDecimalToHex(a)), pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16))];
  return hex.join('');
}
/** Converts a decimal to a hex value */
function convertDecimalToHex(d) {
  return Math.round(parseFloat(d) * 255).toString(16);
}
/** Converts a hex value to a decimal */
function convertHexToDecimal(h) {
  return parseIntFromHex(h) / 255;
}
/** Parse a base-16 hex value into a base-10 integer */
function parseIntFromHex(val) {
  return parseInt(val, 16);
}
function numberInputToObject(color) {
  return {
    r: color >> 16,
    g: (color & 0xff00) >> 8,
    b: color & 0xff
  };
}
;// CONCATENATED MODULE: ./node_modules/_@ctrl_tinycolor@3.6.0@@ctrl/tinycolor/dist/module/css-color-names.js
// https://github.com/bahamas10/css-color-names/blob/master/css-color-names.json
/**
 * @hidden
 */
var names = {
  aliceblue: '#f0f8ff',
  antiquewhite: '#faebd7',
  aqua: '#00ffff',
  aquamarine: '#7fffd4',
  azure: '#f0ffff',
  beige: '#f5f5dc',
  bisque: '#ffe4c4',
  black: '#000000',
  blanchedalmond: '#ffebcd',
  blue: '#0000ff',
  blueviolet: '#8a2be2',
  brown: '#a52a2a',
  burlywood: '#deb887',
  cadetblue: '#5f9ea0',
  chartreuse: '#7fff00',
  chocolate: '#d2691e',
  coral: '#ff7f50',
  cornflowerblue: '#6495ed',
  cornsilk: '#fff8dc',
  crimson: '#dc143c',
  cyan: '#00ffff',
  darkblue: '#00008b',
  darkcyan: '#008b8b',
  darkgoldenrod: '#b8860b',
  darkgray: '#a9a9a9',
  darkgreen: '#006400',
  darkgrey: '#a9a9a9',
  darkkhaki: '#bdb76b',
  darkmagenta: '#8b008b',
  darkolivegreen: '#556b2f',
  darkorange: '#ff8c00',
  darkorchid: '#9932cc',
  darkred: '#8b0000',
  darksalmon: '#e9967a',
  darkseagreen: '#8fbc8f',
  darkslateblue: '#483d8b',
  darkslategray: '#2f4f4f',
  darkslategrey: '#2f4f4f',
  darkturquoise: '#00ced1',
  darkviolet: '#9400d3',
  deeppink: '#ff1493',
  deepskyblue: '#00bfff',
  dimgray: '#696969',
  dimgrey: '#696969',
  dodgerblue: '#1e90ff',
  firebrick: '#b22222',
  floralwhite: '#fffaf0',
  forestgreen: '#228b22',
  fuchsia: '#ff00ff',
  gainsboro: '#dcdcdc',
  ghostwhite: '#f8f8ff',
  goldenrod: '#daa520',
  gold: '#ffd700',
  gray: '#808080',
  green: '#008000',
  greenyellow: '#adff2f',
  grey: '#808080',
  honeydew: '#f0fff0',
  hotpink: '#ff69b4',
  indianred: '#cd5c5c',
  indigo: '#4b0082',
  ivory: '#fffff0',
  khaki: '#f0e68c',
  lavenderblush: '#fff0f5',
  lavender: '#e6e6fa',
  lawngreen: '#7cfc00',
  lemonchiffon: '#fffacd',
  lightblue: '#add8e6',
  lightcoral: '#f08080',
  lightcyan: '#e0ffff',
  lightgoldenrodyellow: '#fafad2',
  lightgray: '#d3d3d3',
  lightgreen: '#90ee90',
  lightgrey: '#d3d3d3',
  lightpink: '#ffb6c1',
  lightsalmon: '#ffa07a',
  lightseagreen: '#20b2aa',
  lightskyblue: '#87cefa',
  lightslategray: '#778899',
  lightslategrey: '#778899',
  lightsteelblue: '#b0c4de',
  lightyellow: '#ffffe0',
  lime: '#00ff00',
  limegreen: '#32cd32',
  linen: '#faf0e6',
  magenta: '#ff00ff',
  maroon: '#800000',
  mediumaquamarine: '#66cdaa',
  mediumblue: '#0000cd',
  mediumorchid: '#ba55d3',
  mediumpurple: '#9370db',
  mediumseagreen: '#3cb371',
  mediumslateblue: '#7b68ee',
  mediumspringgreen: '#00fa9a',
  mediumturquoise: '#48d1cc',
  mediumvioletred: '#c71585',
  midnightblue: '#191970',
  mintcream: '#f5fffa',
  mistyrose: '#ffe4e1',
  moccasin: '#ffe4b5',
  navajowhite: '#ffdead',
  navy: '#000080',
  oldlace: '#fdf5e6',
  olive: '#808000',
  olivedrab: '#6b8e23',
  orange: '#ffa500',
  orangered: '#ff4500',
  orchid: '#da70d6',
  palegoldenrod: '#eee8aa',
  palegreen: '#98fb98',
  paleturquoise: '#afeeee',
  palevioletred: '#db7093',
  papayawhip: '#ffefd5',
  peachpuff: '#ffdab9',
  peru: '#cd853f',
  pink: '#ffc0cb',
  plum: '#dda0dd',
  powderblue: '#b0e0e6',
  purple: '#800080',
  rebeccapurple: '#663399',
  red: '#ff0000',
  rosybrown: '#bc8f8f',
  royalblue: '#4169e1',
  saddlebrown: '#8b4513',
  salmon: '#fa8072',
  sandybrown: '#f4a460',
  seagreen: '#2e8b57',
  seashell: '#fff5ee',
  sienna: '#a0522d',
  silver: '#c0c0c0',
  skyblue: '#87ceeb',
  slateblue: '#6a5acd',
  slategray: '#708090',
  slategrey: '#708090',
  snow: '#fffafa',
  springgreen: '#00ff7f',
  steelblue: '#4682b4',
  tan: '#d2b48c',
  teal: '#008080',
  thistle: '#d8bfd8',
  tomato: '#ff6347',
  turquoise: '#40e0d0',
  violet: '#ee82ee',
  wheat: '#f5deb3',
  white: '#ffffff',
  whitesmoke: '#f5f5f5',
  yellow: '#ffff00',
  yellowgreen: '#9acd32'
};
;// CONCATENATED MODULE: ./node_modules/_@ctrl_tinycolor@3.6.0@@ctrl/tinycolor/dist/module/format-input.js
/* eslint-disable @typescript-eslint/no-redundant-type-constituents */



/**
 * Given a string or object, convert that input to RGB
 *
 * Possible string inputs:
 * ```
 * "red"
 * "#f00" or "f00"
 * "#ff0000" or "ff0000"
 * "#ff000000" or "ff000000"
 * "rgb 255 0 0" or "rgb (255, 0, 0)"
 * "rgb 1.0 0 0" or "rgb (1, 0, 0)"
 * "rgba (255, 0, 0, 1)" or "rgba 255, 0, 0, 1"
 * "rgba (1.0, 0, 0, 1)" or "rgba 1.0, 0, 0, 1"
 * "hsl(0, 100%, 50%)" or "hsl 0 100% 50%"
 * "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1"
 * "hsv(0, 100%, 100%)" or "hsv 0 100% 100%"
 * ```
 */
function inputToRGB(color) {
  var rgb = {
    r: 0,
    g: 0,
    b: 0
  };
  var a = 1;
  var s = null;
  var v = null;
  var l = null;
  var ok = false;
  var format = false;
  if (typeof color === 'string') {
    color = stringInputToObject(color);
  }
  if (typeof color === 'object') {
    if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
      rgb = rgbToRgb(color.r, color.g, color.b);
      ok = true;
      format = String(color.r).substr(-1) === '%' ? 'prgb' : 'rgb';
    } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
      s = convertToPercentage(color.s);
      v = convertToPercentage(color.v);
      rgb = hsvToRgb(color.h, s, v);
      ok = true;
      format = 'hsv';
    } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
      s = convertToPercentage(color.s);
      l = convertToPercentage(color.l);
      rgb = hslToRgb(color.h, s, l);
      ok = true;
      format = 'hsl';
    }
    if (Object.prototype.hasOwnProperty.call(color, 'a')) {
      a = color.a;
    }
  }
  a = boundAlpha(a);
  return {
    ok: ok,
    format: color.format || format,
    r: Math.min(255, Math.max(rgb.r, 0)),
    g: Math.min(255, Math.max(rgb.g, 0)),
    b: Math.min(255, Math.max(rgb.b, 0)),
    a: a
  };
}
// <http://www.w3.org/TR/css3-values/#integers>
var CSS_INTEGER = '[-\\+]?\\d+%?';
// <http://www.w3.org/TR/css3-values/#number-value>
var CSS_NUMBER = '[-\\+]?\\d*\\.\\d+%?';
// Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.
var CSS_UNIT = "(?:".concat(CSS_NUMBER, ")|(?:").concat(CSS_INTEGER, ")");
// Actual matching.
// Parentheses and commas are optional, but not required.
// Whitespace can take the place of commas or opening paren
var PERMISSIVE_MATCH3 = "[\\s|\\(]+(".concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")\\s*\\)?");
var PERMISSIVE_MATCH4 = "[\\s|\\(]+(".concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")\\s*\\)?");
var matchers = {
  CSS_UNIT: new RegExp(CSS_UNIT),
  rgb: new RegExp('rgb' + PERMISSIVE_MATCH3),
  rgba: new RegExp('rgba' + PERMISSIVE_MATCH4),
  hsl: new RegExp('hsl' + PERMISSIVE_MATCH3),
  hsla: new RegExp('hsla' + PERMISSIVE_MATCH4),
  hsv: new RegExp('hsv' + PERMISSIVE_MATCH3),
  hsva: new RegExp('hsva' + PERMISSIVE_MATCH4),
  hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
  hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
  hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
  hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
};
/**
 * Permissive string parsing.  Take in a number of formats, and output an object
 * based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`
 */
function stringInputToObject(color) {
  color = color.trim().toLowerCase();
  if (color.length === 0) {
    return false;
  }
  var named = false;
  if (names[color]) {
    color = names[color];
    named = true;
  } else if (color === 'transparent') {
    return {
      r: 0,
      g: 0,
      b: 0,
      a: 0,
      format: 'name'
    };
  }
  // Try to match string input using regular expressions.
  // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]
  // Just return an object and let the conversion functions handle that.
  // This way the result will be the same whether the tinycolor is initialized with string or object.
  var match = matchers.rgb.exec(color);
  if (match) {
    return {
      r: match[1],
      g: match[2],
      b: match[3]
    };
  }
  match = matchers.rgba.exec(color);
  if (match) {
    return {
      r: match[1],
      g: match[2],
      b: match[3],
      a: match[4]
    };
  }
  match = matchers.hsl.exec(color);
  if (match) {
    return {
      h: match[1],
      s: match[2],
      l: match[3]
    };
  }
  match = matchers.hsla.exec(color);
  if (match) {
    return {
      h: match[1],
      s: match[2],
      l: match[3],
      a: match[4]
    };
  }
  match = matchers.hsv.exec(color);
  if (match) {
    return {
      h: match[1],
      s: match[2],
      v: match[3]
    };
  }
  match = matchers.hsva.exec(color);
  if (match) {
    return {
      h: match[1],
      s: match[2],
      v: match[3],
      a: match[4]
    };
  }
  match = matchers.hex8.exec(color);
  if (match) {
    return {
      r: parseIntFromHex(match[1]),
      g: parseIntFromHex(match[2]),
      b: parseIntFromHex(match[3]),
      a: convertHexToDecimal(match[4]),
      format: named ? 'name' : 'hex8'
    };
  }
  match = matchers.hex6.exec(color);
  if (match) {
    return {
      r: parseIntFromHex(match[1]),
      g: parseIntFromHex(match[2]),
      b: parseIntFromHex(match[3]),
      format: named ? 'name' : 'hex'
    };
  }
  match = matchers.hex4.exec(color);
  if (match) {
    return {
      r: parseIntFromHex(match[1] + match[1]),
      g: parseIntFromHex(match[2] + match[2]),
      b: parseIntFromHex(match[3] + match[3]),
      a: convertHexToDecimal(match[4] + match[4]),
      format: named ? 'name' : 'hex8'
    };
  }
  match = matchers.hex3.exec(color);
  if (match) {
    return {
      r: parseIntFromHex(match[1] + match[1]),
      g: parseIntFromHex(match[2] + match[2]),
      b: parseIntFromHex(match[3] + match[3]),
      format: named ? 'name' : 'hex'
    };
  }
  return false;
}
/**
 * Check to see if it looks like a CSS unit
 * (see `matchers` above for definition).
 */
function isValidCSSUnit(color) {
  return Boolean(matchers.CSS_UNIT.exec(String(color)));
}
;// CONCATENATED MODULE: ./node_modules/_@ant-design_colors@6.0.0@@ant-design/colors/dist/index.esm.js

var hueStep = 2; // 色相阶梯

var saturationStep = 0.16; // 饱和度阶梯，浅色部分

var saturationStep2 = 0.05; // 饱和度阶梯，深色部分

var brightnessStep1 = 0.05; // 亮度阶梯，浅色部分

var brightnessStep2 = 0.15; // 亮度阶梯，深色部分

var lightColorCount = 5; // 浅色数量，主色上

var darkColorCount = 4; // 深色数量，主色下
// 暗色主题颜色映射关系表

var darkColorMap = [{
  index: 7,
  opacity: 0.15
}, {
  index: 6,
  opacity: 0.25
}, {
  index: 5,
  opacity: 0.3
}, {
  index: 5,
  opacity: 0.45
}, {
  index: 5,
  opacity: 0.65
}, {
  index: 5,
  opacity: 0.85
}, {
  index: 4,
  opacity: 0.9
}, {
  index: 3,
  opacity: 0.95
}, {
  index: 2,
  opacity: 0.97
}, {
  index: 1,
  opacity: 0.98
}]; // Wrapper function ported from TinyColor.prototype.toHsv
// Keep it here because of `hsv.h * 360`

function toHsv(_ref) {
  var r = _ref.r,
    g = _ref.g,
    b = _ref.b;
  var hsv = rgbToHsv(r, g, b);
  return {
    h: hsv.h * 360,
    s: hsv.s,
    v: hsv.v
  };
} // Wrapper function ported from TinyColor.prototype.toHexString
// Keep it here because of the prefix `#`

function toHex(_ref2) {
  var r = _ref2.r,
    g = _ref2.g,
    b = _ref2.b;
  return "#".concat(rgbToHex(r, g, b, false));
} // Wrapper function ported from TinyColor.prototype.mix, not treeshakable.
// Amount in range [0, 1]
// Assume color1 & color2 has no alpha, since the following src code did so.

function mix(rgb1, rgb2, amount) {
  var p = amount / 100;
  var rgb = {
    r: (rgb2.r - rgb1.r) * p + rgb1.r,
    g: (rgb2.g - rgb1.g) * p + rgb1.g,
    b: (rgb2.b - rgb1.b) * p + rgb1.b
  };
  return rgb;
}
function getHue(hsv, i, light) {
  var hue; // 根据色相不同，色相转向不同

  if (Math.round(hsv.h) >= 60 && Math.round(hsv.h) <= 240) {
    hue = light ? Math.round(hsv.h) - hueStep * i : Math.round(hsv.h) + hueStep * i;
  } else {
    hue = light ? Math.round(hsv.h) + hueStep * i : Math.round(hsv.h) - hueStep * i;
  }
  if (hue < 0) {
    hue += 360;
  } else if (hue >= 360) {
    hue -= 360;
  }
  return hue;
}
function getSaturation(hsv, i, light) {
  // grey color don't change saturation
  if (hsv.h === 0 && hsv.s === 0) {
    return hsv.s;
  }
  var saturation;
  if (light) {
    saturation = hsv.s - saturationStep * i;
  } else if (i === darkColorCount) {
    saturation = hsv.s + saturationStep;
  } else {
    saturation = hsv.s + saturationStep2 * i;
  } // 边界值修正

  if (saturation > 1) {
    saturation = 1;
  } // 第一格的 s 限制在 0.06-0.1 之间

  if (light && i === lightColorCount && saturation > 0.1) {
    saturation = 0.1;
  }
  if (saturation < 0.06) {
    saturation = 0.06;
  }
  return Number(saturation.toFixed(2));
}
function getValue(hsv, i, light) {
  var value;
  if (light) {
    value = hsv.v + brightnessStep1 * i;
  } else {
    value = hsv.v - brightnessStep2 * i;
  }
  if (value > 1) {
    value = 1;
  }
  return Number(value.toFixed(2));
}
function generate(color) {
  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var patterns = [];
  var pColor = inputToRGB(color);
  for (var i = lightColorCount; i > 0; i -= 1) {
    var hsv = toHsv(pColor);
    var colorString = toHex(inputToRGB({
      h: getHue(hsv, i, true),
      s: getSaturation(hsv, i, true),
      v: getValue(hsv, i, true)
    }));
    patterns.push(colorString);
  }
  patterns.push(toHex(pColor));
  for (var _i = 1; _i <= darkColorCount; _i += 1) {
    var _hsv = toHsv(pColor);
    var _colorString = toHex(inputToRGB({
      h: getHue(_hsv, _i),
      s: getSaturation(_hsv, _i),
      v: getValue(_hsv, _i)
    }));
    patterns.push(_colorString);
  } // dark theme patterns

  if (opts.theme === 'dark') {
    return darkColorMap.map(function (_ref3) {
      var index = _ref3.index,
        opacity = _ref3.opacity;
      var darkColorString = toHex(mix(inputToRGB(opts.backgroundColor || '#141414'), inputToRGB(patterns[index]), opacity * 100));
      return darkColorString;
    });
  }
  return patterns;
}
var presetPrimaryColors = {
  red: '#F5222D',
  volcano: '#FA541C',
  orange: '#FA8C16',
  gold: '#FAAD14',
  yellow: '#FADB14',
  lime: '#A0D911',
  green: '#52C41A',
  cyan: '#13C2C2',
  blue: '#1890FF',
  geekblue: '#2F54EB',
  purple: '#722ED1',
  magenta: '#EB2F96',
  grey: '#666666'
};
var presetPalettes = {};
var presetDarkPalettes = {};
Object.keys(presetPrimaryColors).forEach(function (key) {
  presetPalettes[key] = generate(presetPrimaryColors[key]);
  presetPalettes[key].primary = presetPalettes[key][5]; // dark presetPalettes

  presetDarkPalettes[key] = generate(presetPrimaryColors[key], {
    theme: 'dark',
    backgroundColor: '#141414'
  });
  presetDarkPalettes[key].primary = presetDarkPalettes[key][5];
});
var red = presetPalettes.red;
var volcano = presetPalettes.volcano;
var gold = presetPalettes.gold;
var orange = presetPalettes.orange;
var yellow = presetPalettes.yellow;
var lime = presetPalettes.lime;
var green = presetPalettes.green;
var cyan = presetPalettes.cyan;
var blue = presetPalettes.blue;
var geekblue = presetPalettes.geekblue;
var purple = presetPalettes.purple;
var magenta = presetPalettes.magenta;
var grey = presetPalettes.grey;

;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/warning.js
/* eslint-disable no-console */
var warned = {};
function warning(valid, message) {
  // Support uglify
  if (false) {}
}
function note(valid, message) {
  // Support uglify
  if (false) {}
}
function resetWarned() {
  warned = {};
}
function call(method, valid, message) {
  if (!valid && !warned[message]) {
    method(false, message);
    warned[message] = true;
  }
}
function warningOnce(valid, message) {
  call(warning, valid, message);
}
function noteOnce(valid, message) {
  call(note, valid, message);
}
/* harmony default export */ var es_warning = (warningOnce);
/* eslint-enable */
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/Dom/canUseDom.js
function canUseDom() {
  return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
}
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/Dom/contains.js
function contains(root, n) {
  if (!root) {
    return false;
  }

  // Use native if support
  if (root.contains) {
    return root.contains(n);
  }

  // `document.contains` not support with IE11
  var node = n;
  while (node) {
    if (node === root) {
      return true;
    }
    node = node.parentNode;
  }
  return false;
}
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/Dom/dynamicCSS.js


var APPEND_ORDER = 'data-rc-order';
var MARK_KEY = "rc-util-key";
var containerCache = new Map();
function getMark() {
  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
    mark = _ref.mark;
  if (mark) {
    return mark.startsWith('data-') ? mark : "data-".concat(mark);
  }
  return MARK_KEY;
}
function getContainer(option) {
  if (option.attachTo) {
    return option.attachTo;
  }
  var head = document.querySelector('head');
  return head || document.body;
}
function getOrder(prepend) {
  if (prepend === 'queue') {
    return 'prependQueue';
  }
  return prepend ? 'prepend' : 'append';
}

/**
 * Find style which inject by rc-util
 */
function findStyles(container) {
  return Array.from((containerCache.get(container) || container).children).filter(function (node) {
    return node.tagName === 'STYLE';
  });
}
function injectCSS(css) {
  var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  if (!canUseDom()) {
    return null;
  }
  var csp = option.csp,
    prepend = option.prepend;
  var styleNode = document.createElement('style');
  styleNode.setAttribute(APPEND_ORDER, getOrder(prepend));
  if (csp !== null && csp !== void 0 && csp.nonce) {
    styleNode.nonce = csp === null || csp === void 0 ? void 0 : csp.nonce;
  }
  styleNode.innerHTML = css;
  var container = getContainer(option);
  var firstChild = container.firstChild;
  if (prepend) {
    // If is queue `prepend`, it will prepend first style and then append rest style
    if (prepend === 'queue') {
      var existStyle = findStyles(container).filter(function (node) {
        return ['prepend', 'prependQueue'].includes(node.getAttribute(APPEND_ORDER));
      });
      if (existStyle.length) {
        container.insertBefore(styleNode, existStyle[existStyle.length - 1].nextSibling);
        return styleNode;
      }
    }

    // Use `insertBefore` as `prepend`
    container.insertBefore(styleNode, firstChild);
  } else {
    container.appendChild(styleNode);
  }
  return styleNode;
}
function findExistNode(key) {
  var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var container = getContainer(option);
  return findStyles(container).find(function (node) {
    return node.getAttribute(getMark(option)) === key;
  });
}
function removeCSS(key) {
  var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var existNode = findExistNode(key, option);
  if (existNode) {
    var container = getContainer(option);
    container.removeChild(existNode);
  }
}

/**
 * qiankun will inject `appendChild` to insert into other
 */
function syncRealContainer(container, option) {
  var cachedRealContainer = containerCache.get(container);

  // Find real container when not cached or cached container removed
  if (!cachedRealContainer || !contains(document, cachedRealContainer)) {
    var placeholderStyle = injectCSS('', option);
    var parentNode = placeholderStyle.parentNode;
    containerCache.set(container, parentNode);
    container.removeChild(placeholderStyle);
  }
}

/**
 * manually clear container cache to avoid global cache in unit testes
 */
function clearContainerCache() {
  containerCache.clear();
}
function updateCSS(css, key) {
  var option = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  var container = getContainer(option);

  // Sync real parent
  syncRealContainer(container, option);
  var existNode = findExistNode(key, option);
  if (existNode) {
    var _option$csp, _option$csp2;
    if ((_option$csp = option.csp) !== null && _option$csp !== void 0 && _option$csp.nonce && existNode.nonce !== ((_option$csp2 = option.csp) === null || _option$csp2 === void 0 ? void 0 : _option$csp2.nonce)) {
      var _option$csp3;
      existNode.nonce = (_option$csp3 = option.csp) === null || _option$csp3 === void 0 ? void 0 : _option$csp3.nonce;
    }
    if (existNode.innerHTML !== css) {
      existNode.innerHTML = css;
    }
    return existNode;
  }
  var newNode = injectCSS(css, option);
  newNode.setAttribute(getMark(option), key);
  return newNode;
}
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons@4.8.0@@ant-design/icons/es/utils.js







function utils_warning(valid, message) {
  es_warning(valid, "[@ant-design/icons] ".concat(message));
}
function isIconDefinition(target) {
  return _typeof(target) === 'object' && typeof target.name === 'string' && typeof target.theme === 'string' && (_typeof(target.icon) === 'object' || typeof target.icon === 'function');
}
function normalizeAttrs() {
  var attrs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return Object.keys(attrs).reduce(function (acc, key) {
    var val = attrs[key];
    switch (key) {
      case 'class':
        acc.className = val;
        delete acc.class;
        break;
      default:
        acc[key] = val;
    }
    return acc;
  }, {});
}
function utils_generate(node, key, rootProps) {
  if (!rootProps) {
    return /*#__PURE__*/_react_18_2_0_react.createElement(node.tag, _objectSpread2({
      key: key
    }, normalizeAttrs(node.attrs)), (node.children || []).map(function (child, index) {
      return utils_generate(child, "".concat(key, "-").concat(node.tag, "-").concat(index));
    }));
  }
  return /*#__PURE__*/_react_18_2_0_react.createElement(node.tag, _objectSpread2(_objectSpread2({
    key: key
  }, normalizeAttrs(node.attrs)), rootProps), (node.children || []).map(function (child, index) {
    return utils_generate(child, "".concat(key, "-").concat(node.tag, "-").concat(index));
  }));
}
function getSecondaryColor(primaryColor) {
  // choose the second color
  return generate(primaryColor)[0];
}
function normalizeTwoToneColors(twoToneColor) {
  if (!twoToneColor) {
    return [];
  }
  return Array.isArray(twoToneColor) ? twoToneColor : [twoToneColor];
}
// These props make sure that the SVG behaviours like general text.
// Reference: https://blog.prototypr.io/align-svg-icons-to-text-and-say-goodbye-to-font-icons-d44b3d7b26b4
var svgBaseProps = {
  width: '1em',
  height: '1em',
  fill: 'currentColor',
  'aria-hidden': 'true',
  focusable: 'false'
};
var iconStyles = "\n.anticon {\n  display: inline-block;\n  color: inherit;\n  font-style: normal;\n  line-height: 0;\n  text-align: center;\n  text-transform: none;\n  vertical-align: -0.125em;\n  text-rendering: optimizeLegibility;\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n}\n\n.anticon > * {\n  line-height: 1;\n}\n\n.anticon svg {\n  display: inline-block;\n}\n\n.anticon::before {\n  display: none;\n}\n\n.anticon .anticon-icon {\n  display: block;\n}\n\n.anticon[tabindex] {\n  cursor: pointer;\n}\n\n.anticon-spin::before,\n.anticon-spin {\n  display: inline-block;\n  -webkit-animation: loadingCircle 1s infinite linear;\n  animation: loadingCircle 1s infinite linear;\n}\n\n@-webkit-keyframes loadingCircle {\n  100% {\n    -webkit-transform: rotate(360deg);\n    transform: rotate(360deg);\n  }\n}\n\n@keyframes loadingCircle {\n  100% {\n    -webkit-transform: rotate(360deg);\n    transform: rotate(360deg);\n  }\n}\n";
var useInsertStyles = function useInsertStyles() {
  var styleStr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : iconStyles;
  var _useContext = (0,_react_18_2_0_react.useContext)(Context),
    csp = _useContext.csp;
  (0,_react_18_2_0_react.useEffect)(function () {
    updateCSS(styleStr, '@ant-design-icons', {
      prepend: true,
      csp: csp
    });
  }, []);
};
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons@4.8.0@@ant-design/icons/es/components/IconBase.js


var _excluded = ["icon", "className", "onClick", "style", "primaryColor", "secondaryColor"];

var twoToneColorPalette = {
  primaryColor: '#333',
  secondaryColor: '#E6E6E6',
  calculated: false
};
function setTwoToneColors(_ref) {
  var primaryColor = _ref.primaryColor,
    secondaryColor = _ref.secondaryColor;
  twoToneColorPalette.primaryColor = primaryColor;
  twoToneColorPalette.secondaryColor = secondaryColor || getSecondaryColor(primaryColor);
  twoToneColorPalette.calculated = !!secondaryColor;
}
function getTwoToneColors() {
  return _objectSpread2({}, twoToneColorPalette);
}
var IconBase = function IconBase(props) {
  var icon = props.icon,
    className = props.className,
    onClick = props.onClick,
    style = props.style,
    primaryColor = props.primaryColor,
    secondaryColor = props.secondaryColor,
    restProps = _objectWithoutProperties(props, _excluded);
  var colors = twoToneColorPalette;
  if (primaryColor) {
    colors = {
      primaryColor: primaryColor,
      secondaryColor: secondaryColor || getSecondaryColor(primaryColor)
    };
  }
  useInsertStyles();
  utils_warning(isIconDefinition(icon), "icon should be icon definiton, but got ".concat(icon));
  if (!isIconDefinition(icon)) {
    return null;
  }
  var target = icon;
  if (target && typeof target.icon === 'function') {
    target = _objectSpread2(_objectSpread2({}, target), {}, {
      icon: target.icon(colors.primaryColor, colors.secondaryColor)
    });
  }
  return utils_generate(target.icon, "svg-".concat(target.name), _objectSpread2({
    className: className,
    onClick: onClick,
    style: style,
    'data-icon': target.name,
    width: '1em',
    height: '1em',
    fill: 'currentColor',
    'aria-hidden': 'true'
  }, restProps));
};
IconBase.displayName = 'IconReact';
IconBase.getTwoToneColors = getTwoToneColors;
IconBase.setTwoToneColors = setTwoToneColors;
/* harmony default export */ var components_IconBase = (IconBase);
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons@4.8.0@@ant-design/icons/es/components/twoTonePrimaryColor.js



function setTwoToneColor(twoToneColor) {
  var _normalizeTwoToneColo = normalizeTwoToneColors(twoToneColor),
    _normalizeTwoToneColo2 = slicedToArray_slicedToArray(_normalizeTwoToneColo, 2),
    primaryColor = _normalizeTwoToneColo2[0],
    secondaryColor = _normalizeTwoToneColo2[1];
  return components_IconBase.setTwoToneColors({
    primaryColor: primaryColor,
    secondaryColor: secondaryColor
  });
}
function getTwoToneColor() {
  var colors = components_IconBase.getTwoToneColors();
  if (!colors.calculated) {
    return colors.primaryColor;
  }
  return [colors.primaryColor, colors.secondaryColor];
}
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons@4.8.0@@ant-design/icons/es/components/AntdIcon.js




var AntdIcon_excluded = ["className", "icon", "spin", "rotate", "tabIndex", "onClick", "twoToneColor"];






// Initial setting
// should move it to antd main repo?
setTwoToneColor('#1890ff');
var Icon = /*#__PURE__*/_react_18_2_0_react.forwardRef(function (props, ref) {
  var _classNames;
  var className = props.className,
    icon = props.icon,
    spin = props.spin,
    rotate = props.rotate,
    tabIndex = props.tabIndex,
    onClick = props.onClick,
    twoToneColor = props.twoToneColor,
    restProps = _objectWithoutProperties(props, AntdIcon_excluded);
  var _React$useContext = _react_18_2_0_react.useContext(Context),
    _React$useContext$pre = _React$useContext.prefixCls,
    prefixCls = _React$useContext$pre === void 0 ? 'anticon' : _React$useContext$pre,
    rootClassName = _React$useContext.rootClassName;
  var classString = _classnames_2_3_2_classnames_default()(rootClassName, prefixCls, (_classNames = {}, defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-").concat(icon.name), !!icon.name), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-spin"), !!spin || icon.name === 'loading'), _classNames), className);
  var iconTabIndex = tabIndex;
  if (iconTabIndex === undefined && onClick) {
    iconTabIndex = -1;
  }
  var svgStyle = rotate ? {
    msTransform: "rotate(".concat(rotate, "deg)"),
    transform: "rotate(".concat(rotate, "deg)")
  } : undefined;
  var _normalizeTwoToneColo = normalizeTwoToneColors(twoToneColor),
    _normalizeTwoToneColo2 = slicedToArray_slicedToArray(_normalizeTwoToneColo, 2),
    primaryColor = _normalizeTwoToneColo2[0],
    secondaryColor = _normalizeTwoToneColo2[1];
  return /*#__PURE__*/_react_18_2_0_react.createElement("span", _objectSpread2(_objectSpread2({
    role: "img",
    "aria-label": icon.name
  }, restProps), {}, {
    ref: ref,
    tabIndex: iconTabIndex,
    onClick: onClick,
    className: classString
  }), /*#__PURE__*/_react_18_2_0_react.createElement(components_IconBase, {
    icon: icon,
    primaryColor: primaryColor,
    secondaryColor: secondaryColor,
    style: svgStyle
  }));
});
Icon.displayName = 'AntdIcon';
Icon.getTwoToneColor = getTwoToneColor;
Icon.setTwoToneColor = setTwoToneColor;
/* harmony default export */ var AntdIcon = (Icon);
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons@4.8.0@@ant-design/icons/es/icons/CheckCircleOutlined.js

// GENERATE BY ./scripts/generate.ts
// DON NOT EDIT IT MANUALLY



var CheckCircleOutlined_CheckCircleOutlined = function CheckCircleOutlined(props, ref) {
  return /*#__PURE__*/_react_18_2_0_react.createElement(AntdIcon, _objectSpread2(_objectSpread2({}, props), {}, {
    ref: ref,
    icon: asn_CheckCircleOutlined
  }));
};
CheckCircleOutlined_CheckCircleOutlined.displayName = 'CheckCircleOutlined';
/* harmony default export */ var icons_CheckCircleOutlined = (/*#__PURE__*/_react_18_2_0_react.forwardRef(CheckCircleOutlined_CheckCircleOutlined));
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons-svg@4.2.1@@ant-design/icons-svg/es/asn/CloseCircleOutlined.js
// This icon file is generated automatically.
var CloseCircleOutlined = {
  "icon": {
    "tag": "svg",
    "attrs": {
      "viewBox": "64 64 896 896",
      "focusable": "false"
    },
    "children": [{
      "tag": "path",
      "attrs": {
        "d": "M685.4 354.8c0-4.4-3.6-8-8-8l-66 .3L512 465.6l-99.3-118.4-66.1-.3c-4.4 0-8 3.5-8 8 0 1.9.7 3.7 1.9 5.2l130.1 155L340.5 670a8.32 8.32 0 00-1.9 5.2c0 4.4 3.6 8 8 8l66.1-.3L512 564.4l99.3 118.4 66 .3c4.4 0 8-3.5 8-8 0-1.9-.7-3.7-1.9-5.2L553.5 515l130.1-155c1.2-1.4 1.8-3.3 1.8-5.2z"
      }
    }, {
      "tag": "path",
      "attrs": {
        "d": "M512 65C264.6 65 64 265.6 64 513s200.6 448 448 448 448-200.6 448-448S759.4 65 512 65zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z"
      }
    }]
  },
  "name": "close-circle",
  "theme": "outlined"
};
/* harmony default export */ var asn_CloseCircleOutlined = (CloseCircleOutlined);
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons@4.8.0@@ant-design/icons/es/icons/CloseCircleOutlined.js

// GENERATE BY ./scripts/generate.ts
// DON NOT EDIT IT MANUALLY



var CloseCircleOutlined_CloseCircleOutlined = function CloseCircleOutlined(props, ref) {
  return /*#__PURE__*/_react_18_2_0_react.createElement(AntdIcon, _objectSpread2(_objectSpread2({}, props), {}, {
    ref: ref,
    icon: asn_CloseCircleOutlined
  }));
};
CloseCircleOutlined_CloseCircleOutlined.displayName = 'CloseCircleOutlined';
/* harmony default export */ var icons_CloseCircleOutlined = (/*#__PURE__*/_react_18_2_0_react.forwardRef(CloseCircleOutlined_CloseCircleOutlined));
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons-svg@4.2.1@@ant-design/icons-svg/es/asn/ExclamationCircleOutlined.js
// This icon file is generated automatically.
var ExclamationCircleOutlined = {
  "icon": {
    "tag": "svg",
    "attrs": {
      "viewBox": "64 64 896 896",
      "focusable": "false"
    },
    "children": [{
      "tag": "path",
      "attrs": {
        "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z"
      }
    }, {
      "tag": "path",
      "attrs": {
        "d": "M464 688a48 48 0 1096 0 48 48 0 10-96 0zm24-112h48c4.4 0 8-3.6 8-8V296c0-4.4-3.6-8-8-8h-48c-4.4 0-8 3.6-8 8v272c0 4.4 3.6 8 8 8z"
      }
    }]
  },
  "name": "exclamation-circle",
  "theme": "outlined"
};
/* harmony default export */ var asn_ExclamationCircleOutlined = (ExclamationCircleOutlined);
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons@4.8.0@@ant-design/icons/es/icons/ExclamationCircleOutlined.js

// GENERATE BY ./scripts/generate.ts
// DON NOT EDIT IT MANUALLY



var ExclamationCircleOutlined_ExclamationCircleOutlined = function ExclamationCircleOutlined(props, ref) {
  return /*#__PURE__*/_react_18_2_0_react.createElement(AntdIcon, _objectSpread2(_objectSpread2({}, props), {}, {
    ref: ref,
    icon: asn_ExclamationCircleOutlined
  }));
};
ExclamationCircleOutlined_ExclamationCircleOutlined.displayName = 'ExclamationCircleOutlined';
/* harmony default export */ var icons_ExclamationCircleOutlined = (/*#__PURE__*/_react_18_2_0_react.forwardRef(ExclamationCircleOutlined_ExclamationCircleOutlined));
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons-svg@4.2.1@@ant-design/icons-svg/es/asn/InfoCircleOutlined.js
// This icon file is generated automatically.
var InfoCircleOutlined = {
  "icon": {
    "tag": "svg",
    "attrs": {
      "viewBox": "64 64 896 896",
      "focusable": "false"
    },
    "children": [{
      "tag": "path",
      "attrs": {
        "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z"
      }
    }, {
      "tag": "path",
      "attrs": {
        "d": "M464 336a48 48 0 1096 0 48 48 0 10-96 0zm72 112h-48c-4.4 0-8 3.6-8 8v272c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8V456c0-4.4-3.6-8-8-8z"
      }
    }]
  },
  "name": "info-circle",
  "theme": "outlined"
};
/* harmony default export */ var asn_InfoCircleOutlined = (InfoCircleOutlined);
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons@4.8.0@@ant-design/icons/es/icons/InfoCircleOutlined.js

// GENERATE BY ./scripts/generate.ts
// DON NOT EDIT IT MANUALLY



var InfoCircleOutlined_InfoCircleOutlined = function InfoCircleOutlined(props, ref) {
  return /*#__PURE__*/_react_18_2_0_react.createElement(AntdIcon, _objectSpread2(_objectSpread2({}, props), {}, {
    ref: ref,
    icon: asn_InfoCircleOutlined
  }));
};
InfoCircleOutlined_InfoCircleOutlined.displayName = 'InfoCircleOutlined';
/* harmony default export */ var icons_InfoCircleOutlined = (/*#__PURE__*/_react_18_2_0_react.forwardRef(InfoCircleOutlined_InfoCircleOutlined));
// EXTERNAL MODULE: ./node_modules/_react-dom@18.2.0@react-dom/index.js
var _react_dom_18_2_0_react_dom = __webpack_require__(1162);
var _react_dom_18_2_0_react_dom_namespaceObject = /*#__PURE__*/__webpack_require__.t(_react_dom_18_2_0_react_dom, 2);
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/React/render.js





// Let compiler not to search module usage
var fullClone = _objectSpread2({}, _react_dom_18_2_0_react_dom_namespaceObject);
var version = fullClone.version,
  reactRender = fullClone.render,
  unmountComponentAtNode = fullClone.unmountComponentAtNode;
var createRoot;
try {
  var mainVersion = Number((version || '').split('.')[0]);
  if (mainVersion >= 18) {
    createRoot = fullClone.createRoot;
  }
} catch (e) {
  // Do nothing;
}
function toggleWarning(skip) {
  var __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = fullClone.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
  if (__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED && _typeof(__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED) === 'object') {
    __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.usingClientEntryPoint = skip;
  }
}
var MARK = '__rc_react_root__';

// ========================== Render ==========================

function modernRender(node, container) {
  toggleWarning(true);
  var root = container[MARK] || createRoot(container);
  toggleWarning(false);
  root.render(node);
  container[MARK] = root;
}
function legacyRender(node, container) {
  reactRender(node, container);
}

/** @private Test usage. Not work in prod */
function _r(node, container) {
  if (false) {}
}
function render_render(node, container) {
  if (createRoot) {
    modernRender(node, container);
    return;
  }
  legacyRender(node, container);
}

// ========================= Unmount ==========================
function modernUnmount(_x) {
  return _modernUnmount.apply(this, arguments);
}
function _modernUnmount() {
  _modernUnmount = asyncToGenerator_asyncToGenerator( /*#__PURE__*/regeneratorRuntime_regeneratorRuntime().mark(function _callee(container) {
    return regeneratorRuntime_regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          return _context.abrupt("return", Promise.resolve().then(function () {
            var _container$MARK;
            (_container$MARK = container[MARK]) === null || _container$MARK === void 0 ? void 0 : _container$MARK.unmount();
            delete container[MARK];
          }));
        case 1:
        case "end":
          return _context.stop();
      }
    }, _callee);
  }));
  return _modernUnmount.apply(this, arguments);
}
function legacyUnmount(container) {
  unmountComponentAtNode(container);
}

/** @private Test usage. Not work in prod */
function _u(container) {
  if (false) {}
}
function unmount(_x2) {
  return _unmount.apply(this, arguments);
}
function _unmount() {
  _unmount = asyncToGenerator_asyncToGenerator( /*#__PURE__*/regeneratorRuntime_regeneratorRuntime().mark(function _callee2(container) {
    return regeneratorRuntime_regeneratorRuntime().wrap(function _callee2$(_context2) {
      while (1) switch (_context2.prev = _context2.next) {
        case 0:
          if (!(createRoot !== undefined)) {
            _context2.next = 2;
            break;
          }
          return _context2.abrupt("return", modernUnmount(container));
        case 2:
          legacyUnmount(container);
        case 3:
        case "end":
          return _context2.stop();
      }
    }, _callee2);
  }));
  return _unmount.apply(this, arguments);
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/classCallCheck.js
function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/createClass.js

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, _toPropertyKey(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;
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/assertThisInitialized.js
function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }
  return self;
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/setPrototypeOf.js
function _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };
  return _setPrototypeOf(o, p);
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/inherits.js

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);
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/getPrototypeOf.js
function _getPrototypeOf(o) {
  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  return _getPrototypeOf(o);
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/isNativeReflectConstruct.js
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;
  }
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/possibleConstructorReturn.js


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);
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/createSuper.js



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);
  };
}
// EXTERNAL MODULE: ./node_modules/_react-is@16.13.1@react-is/index.js
var _react_is_16_13_1_react_is = __webpack_require__(4436);
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/Children/toArray.js


function toArray_toArray(children) {
  var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var ret = [];
  _react_18_2_0_react.Children.forEach(children, function (child) {
    if ((child === undefined || child === null) && !option.keepEmpty) {
      return;
    }
    if (Array.isArray(child)) {
      ret = ret.concat(toArray_toArray(child));
    } else if ((0,_react_is_16_13_1_react_is.isFragment)(child) && child.props) {
      ret = ret.concat(toArray_toArray(child.props.children, option));
    } else {
      ret.push(child);
    }
  });
  return ret;
}
;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/FieldContext.js


var HOOK_MARK = 'RC_FORM_INTERNAL_HOOKS';
// eslint-disable-next-line @typescript-eslint/no-explicit-any
var warningFunc = function warningFunc() {
  es_warning(false, 'Can not find FormContext. Please make sure you wrap Field under Form.');
};
var FieldContext_Context = /*#__PURE__*/_react_18_2_0_react.createContext({
  getFieldValue: warningFunc,
  getFieldsValue: warningFunc,
  getFieldError: warningFunc,
  getFieldWarning: warningFunc,
  getFieldsError: warningFunc,
  isFieldsTouched: warningFunc,
  isFieldTouched: warningFunc,
  isFieldValidating: warningFunc,
  isFieldsValidating: warningFunc,
  resetFields: warningFunc,
  setFields: warningFunc,
  setFieldValue: warningFunc,
  setFieldsValue: warningFunc,
  validateFields: warningFunc,
  submit: warningFunc,
  getInternalHooks: function getInternalHooks() {
    warningFunc();
    return {
      dispatch: warningFunc,
      initEntityValue: warningFunc,
      registerField: warningFunc,
      useSubscribe: warningFunc,
      setInitialValues: warningFunc,
      destroyForm: warningFunc,
      setCallbacks: warningFunc,
      registerWatch: warningFunc,
      getFields: warningFunc,
      setValidateMessages: warningFunc,
      setPreserve: warningFunc,
      getInitialValue: warningFunc
    };
  }
});
/* harmony default export */ var FieldContext = (FieldContext_Context);
;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/utils/typeUtil.js
function typeUtil_toArray(value) {
  if (value === undefined || value === null) {
    return [];
  }
  return Array.isArray(value) ? value : [value];
}
;// CONCATENATED MODULE: ./node_modules/_async-validator@4.2.5@async-validator/dist-web/index.js
function dist_web_extends() {
  dist_web_extends = Object.assign ? Object.assign.bind() : function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];
      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }
    return target;
  };
  return dist_web_extends.apply(this, arguments);
}
function dist_web_inheritsLoose(subClass, superClass) {
  subClass.prototype = Object.create(superClass.prototype);
  subClass.prototype.constructor = subClass;
  dist_web_setPrototypeOf(subClass, superClass);
}
function dist_web_getPrototypeOf(o) {
  dist_web_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  return dist_web_getPrototypeOf(o);
}
function dist_web_setPrototypeOf(o, p) {
  dist_web_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };
  return dist_web_setPrototypeOf(o, p);
}
function dist_web_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 _construct(Parent, args, Class) {
  if (dist_web_isNativeReflectConstruct()) {
    _construct = Reflect.construct.bind();
  } 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) dist_web_setPrototypeOf(instance, Class.prototype);
      return instance;
    };
  }
  return _construct.apply(null, arguments);
}
function _isNativeFunction(fn) {
  return Function.toString.call(fn).indexOf("[native code]") !== -1;
}
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, dist_web_getPrototypeOf(this).constructor);
    }
    Wrapper.prototype = Object.create(Class.prototype, {
      constructor: {
        value: Wrapper,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
    return dist_web_setPrototypeOf(Wrapper, Class);
  };
  return _wrapNativeSuper(Class);
}

/* eslint no-console:0 */
var formatRegExp = /%[sdj%]/g;
var dist_web_warning = function warning() {}; // don't print warning message when in production env or node runtime

if (typeof process !== 'undefined' && ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"}) && "production" !== 'production' && 0 && 0) {}
function convertFieldsError(errors) {
  if (!errors || !errors.length) return null;
  var fields = {};
  errors.forEach(function (error) {
    var field = error.field;
    fields[field] = fields[field] || [];
    fields[field].push(error);
  });
  return fields;
}
function format(template) {
  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    args[_key - 1] = arguments[_key];
  }
  var i = 0;
  var len = args.length;
  if (typeof template === 'function') {
    return template.apply(null, args);
  }
  if (typeof template === 'string') {
    var str = template.replace(formatRegExp, function (x) {
      if (x === '%%') {
        return '%';
      }
      if (i >= len) {
        return x;
      }
      switch (x) {
        case '%s':
          return String(args[i++]);
        case '%d':
          return Number(args[i++]);
        case '%j':
          try {
            return JSON.stringify(args[i++]);
          } catch (_) {
            return '[Circular]';
          }
          break;
        default:
          return x;
      }
    });
    return str;
  }
  return template;
}
function isNativeStringType(type) {
  return type === 'string' || type === 'url' || type === 'hex' || type === 'email' || type === 'date' || type === 'pattern';
}
function isEmptyValue(value, type) {
  if (value === undefined || value === null) {
    return true;
  }
  if (type === 'array' && Array.isArray(value) && !value.length) {
    return true;
  }
  if (isNativeStringType(type) && typeof value === 'string' && !value) {
    return true;
  }
  return false;
}
function asyncParallelArray(arr, func, callback) {
  var results = [];
  var total = 0;
  var arrLength = arr.length;
  function count(errors) {
    results.push.apply(results, errors || []);
    total++;
    if (total === arrLength) {
      callback(results);
    }
  }
  arr.forEach(function (a) {
    func(a, count);
  });
}
function asyncSerialArray(arr, func, callback) {
  var index = 0;
  var arrLength = arr.length;
  function next(errors) {
    if (errors && errors.length) {
      callback(errors);
      return;
    }
    var original = index;
    index = index + 1;
    if (original < arrLength) {
      func(arr[original], next);
    } else {
      callback([]);
    }
  }
  next([]);
}
function flattenObjArr(objArr) {
  var ret = [];
  Object.keys(objArr).forEach(function (k) {
    ret.push.apply(ret, objArr[k] || []);
  });
  return ret;
}
var AsyncValidationError = /*#__PURE__*/function (_Error) {
  dist_web_inheritsLoose(AsyncValidationError, _Error);
  function AsyncValidationError(errors, fields) {
    var _this;
    _this = _Error.call(this, 'Async Validation Error') || this;
    _this.errors = errors;
    _this.fields = fields;
    return _this;
  }
  return AsyncValidationError;
}( /*#__PURE__*/_wrapNativeSuper(Error));
function asyncMap(objArr, option, func, callback, source) {
  if (option.first) {
    var _pending = new Promise(function (resolve, reject) {
      var next = function next(errors) {
        callback(errors);
        return errors.length ? reject(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve(source);
      };
      var flattenArr = flattenObjArr(objArr);
      asyncSerialArray(flattenArr, func, next);
    });
    _pending["catch"](function (e) {
      return e;
    });
    return _pending;
  }
  var firstFields = option.firstFields === true ? Object.keys(objArr) : option.firstFields || [];
  var objArrKeys = Object.keys(objArr);
  var objArrLength = objArrKeys.length;
  var total = 0;
  var results = [];
  var pending = new Promise(function (resolve, reject) {
    var next = function next(errors) {
      results.push.apply(results, errors);
      total++;
      if (total === objArrLength) {
        callback(results);
        return results.length ? reject(new AsyncValidationError(results, convertFieldsError(results))) : resolve(source);
      }
    };
    if (!objArrKeys.length) {
      callback(results);
      resolve(source);
    }
    objArrKeys.forEach(function (key) {
      var arr = objArr[key];
      if (firstFields.indexOf(key) !== -1) {
        asyncSerialArray(arr, func, next);
      } else {
        asyncParallelArray(arr, func, next);
      }
    });
  });
  pending["catch"](function (e) {
    return e;
  });
  return pending;
}
function isErrorObj(obj) {
  return !!(obj && obj.message !== undefined);
}
function dist_web_getValue(value, path) {
  var v = value;
  for (var i = 0; i < path.length; i++) {
    if (v == undefined) {
      return v;
    }
    v = v[path[i]];
  }
  return v;
}
function complementError(rule, source) {
  return function (oe) {
    var fieldValue;
    if (rule.fullFields) {
      fieldValue = dist_web_getValue(source, rule.fullFields);
    } else {
      fieldValue = source[oe.field || rule.fullField];
    }
    if (isErrorObj(oe)) {
      oe.field = oe.field || rule.fullField;
      oe.fieldValue = fieldValue;
      return oe;
    }
    return {
      message: typeof oe === 'function' ? oe() : oe,
      fieldValue: fieldValue,
      field: oe.field || rule.fullField
    };
  };
}
function deepMerge(target, source) {
  if (source) {
    for (var s in source) {
      if (source.hasOwnProperty(s)) {
        var value = source[s];
        if (typeof value === 'object' && typeof target[s] === 'object') {
          target[s] = dist_web_extends({}, target[s], value);
        } else {
          target[s] = value;
        }
      }
    }
  }
  return target;
}
var required$1 = function required(rule, value, source, errors, options, type) {
  if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type || rule.type))) {
    errors.push(format(options.messages.required, rule.fullField));
  }
};

/**
 *  Rule for validating whitespace.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param source The source object being validated.
 *  @param errors An array of errors that this rule may add
 *  validation errors to.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

var whitespace = function whitespace(rule, value, source, errors, options) {
  if (/^\s+$/.test(value) || value === '') {
    errors.push(format(options.messages.whitespace, rule.fullField));
  }
};

// https://github.com/kevva/url-regex/blob/master/index.js
var urlReg;
var getUrlRegex = function getUrlRegex() {
  if (urlReg) {
    return urlReg;
  }
  var word = '[a-fA-F\\d:]';
  var b = function b(options) {
    return options && options.includeBoundaries ? "(?:(?<=\\s|^)(?=" + word + ")|(?<=" + word + ")(?=\\s|$))" : '';
  };
  var v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}';
  var v6seg = '[a-fA-F\\d]{1,4}';
  var v6 = ("\n(?:\n(?:" + v6seg + ":){7}(?:" + v6seg + "|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8\n(?:" + v6seg + ":){6}(?:" + v4 + "|:" + v6seg + "|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4\n(?:" + v6seg + ":){5}(?::" + v4 + "|(?::" + v6seg + "){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4\n(?:" + v6seg + ":){4}(?:(?::" + v6seg + "){0,1}:" + v4 + "|(?::" + v6seg + "){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4\n(?:" + v6seg + ":){3}(?:(?::" + v6seg + "){0,2}:" + v4 + "|(?::" + v6seg + "){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4\n(?:" + v6seg + ":){2}(?:(?::" + v6seg + "){0,3}:" + v4 + "|(?::" + v6seg + "){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4\n(?:" + v6seg + ":){1}(?:(?::" + v6seg + "){0,4}:" + v4 + "|(?::" + v6seg + "){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4\n(?::(?:(?::" + v6seg + "){0,5}:" + v4 + "|(?::" + v6seg + "){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4\n)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1\n").replace(/\s*\/\/.*$/gm, '').replace(/\n/g, '').trim(); // Pre-compile only the exact regexes because adding a global flag make regexes stateful

  var v46Exact = new RegExp("(?:^" + v4 + "$)|(?:^" + v6 + "$)");
  var v4exact = new RegExp("^" + v4 + "$");
  var v6exact = new RegExp("^" + v6 + "$");
  var ip = function ip(options) {
    return options && options.exact ? v46Exact : new RegExp("(?:" + b(options) + v4 + b(options) + ")|(?:" + b(options) + v6 + b(options) + ")", 'g');
  };
  ip.v4 = function (options) {
    return options && options.exact ? v4exact : new RegExp("" + b(options) + v4 + b(options), 'g');
  };
  ip.v6 = function (options) {
    return options && options.exact ? v6exact : new RegExp("" + b(options) + v6 + b(options), 'g');
  };
  var protocol = "(?:(?:[a-z]+:)?//)";
  var auth = '(?:\\S+(?::\\S*)?@)?';
  var ipv4 = ip.v4().source;
  var ipv6 = ip.v6().source;
  var host = "(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)";
  var domain = "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*";
  var tld = "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))";
  var port = '(?::\\d{2,5})?';
  var path = '(?:[/?#][^\\s"]*)?';
  var regex = "(?:" + protocol + "|www\\.)" + auth + "(?:localhost|" + ipv4 + "|" + ipv6 + "|" + host + domain + tld + ")" + port + path;
  urlReg = new RegExp("(?:^" + regex + "$)", 'i');
  return urlReg;
};

/* eslint max-len:0 */

var pattern$2 = {
  // http://emailregex.com/
  email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}))$/,
  // url: new RegExp(
  //   '^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$',
  //   'i',
  // ),
  hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i
};
var types = {
  integer: function integer(value) {
    return types.number(value) && parseInt(value, 10) === value;
  },
  "float": function float(value) {
    return types.number(value) && !types.integer(value);
  },
  array: function array(value) {
    return Array.isArray(value);
  },
  regexp: function regexp(value) {
    if (value instanceof RegExp) {
      return true;
    }
    try {
      return !!new RegExp(value);
    } catch (e) {
      return false;
    }
  },
  date: function date(value) {
    return typeof value.getTime === 'function' && typeof value.getMonth === 'function' && typeof value.getYear === 'function' && !isNaN(value.getTime());
  },
  number: function number(value) {
    if (isNaN(value)) {
      return false;
    }
    return typeof value === 'number';
  },
  object: function object(value) {
    return typeof value === 'object' && !types.array(value);
  },
  method: function method(value) {
    return typeof value === 'function';
  },
  email: function email(value) {
    return typeof value === 'string' && value.length <= 320 && !!value.match(pattern$2.email);
  },
  url: function url(value) {
    return typeof value === 'string' && value.length <= 2048 && !!value.match(getUrlRegex());
  },
  hex: function hex(value) {
    return typeof value === 'string' && !!value.match(pattern$2.hex);
  }
};
var type$1 = function type(rule, value, source, errors, options) {
  if (rule.required && value === undefined) {
    required$1(rule, value, source, errors, options);
    return;
  }
  var custom = ['integer', 'float', 'array', 'regexp', 'object', 'method', 'email', 'number', 'date', 'url', 'hex'];
  var ruleType = rule.type;
  if (custom.indexOf(ruleType) > -1) {
    if (!types[ruleType](value)) {
      errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
    } // straight typeof check
  } else if (ruleType && typeof value !== rule.type) {
    errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
  }
};
var range = function range(rule, value, source, errors, options) {
  var len = typeof rule.len === 'number';
  var min = typeof rule.min === 'number';
  var max = typeof rule.max === 'number'; // 正则匹配码点范围从U+010000一直到U+10FFFF的文字（补充平面Supplementary Plane）

  var spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
  var val = value;
  var key = null;
  var num = typeof value === 'number';
  var str = typeof value === 'string';
  var arr = Array.isArray(value);
  if (num) {
    key = 'number';
  } else if (str) {
    key = 'string';
  } else if (arr) {
    key = 'array';
  } // if the value is not of a supported type for range validation
  // the validation rule rule should use the
  // type property to also test for a particular type

  if (!key) {
    return false;
  }
  if (arr) {
    val = value.length;
  }
  if (str) {
    // 处理码点大于U+010000的文字length属性不准确的bug，如"𠮷𠮷𠮷".lenght !== 3
    val = value.replace(spRegexp, '_').length;
  }
  if (len) {
    if (val !== rule.len) {
      errors.push(format(options.messages[key].len, rule.fullField, rule.len));
    }
  } else if (min && !max && val < rule.min) {
    errors.push(format(options.messages[key].min, rule.fullField, rule.min));
  } else if (max && !min && val > rule.max) {
    errors.push(format(options.messages[key].max, rule.fullField, rule.max));
  } else if (min && max && (val < rule.min || val > rule.max)) {
    errors.push(format(options.messages[key].range, rule.fullField, rule.min, rule.max));
  }
};
var ENUM$1 = 'enum';
var enumerable$1 = function enumerable(rule, value, source, errors, options) {
  rule[ENUM$1] = Array.isArray(rule[ENUM$1]) ? rule[ENUM$1] : [];
  if (rule[ENUM$1].indexOf(value) === -1) {
    errors.push(format(options.messages[ENUM$1], rule.fullField, rule[ENUM$1].join(', ')));
  }
};
var pattern$1 = function pattern(rule, value, source, errors, options) {
  if (rule.pattern) {
    if (rule.pattern instanceof RegExp) {
      // if a RegExp instance is passed, reset `lastIndex` in case its `global`
      // flag is accidentally set to `true`, which in a validation scenario
      // is not necessary and the result might be misleading
      rule.pattern.lastIndex = 0;
      if (!rule.pattern.test(value)) {
        errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
      }
    } else if (typeof rule.pattern === 'string') {
      var _pattern = new RegExp(rule.pattern);
      if (!_pattern.test(value)) {
        errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
      }
    }
  }
};
var rules = {
  required: required$1,
  whitespace: whitespace,
  type: type$1,
  range: range,
  "enum": enumerable$1,
  pattern: pattern$1
};
var string = function string(rule, value, callback, source, options) {
  var errors = [];
  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
  if (validate) {
    if (isEmptyValue(value, 'string') && !rule.required) {
      return callback();
    }
    rules.required(rule, value, source, errors, options, 'string');
    if (!isEmptyValue(value, 'string')) {
      rules.type(rule, value, source, errors, options);
      rules.range(rule, value, source, errors, options);
      rules.pattern(rule, value, source, errors, options);
      if (rule.whitespace === true) {
        rules.whitespace(rule, value, source, errors, options);
      }
    }
  }
  callback(errors);
};
var method = function method(rule, value, callback, source, options) {
  var errors = [];
  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
  if (validate) {
    if (isEmptyValue(value) && !rule.required) {
      return callback();
    }
    rules.required(rule, value, source, errors, options);
    if (value !== undefined) {
      rules.type(rule, value, source, errors, options);
    }
  }
  callback(errors);
};
var number = function number(rule, value, callback, source, options) {
  var errors = [];
  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
  if (validate) {
    if (value === '') {
      value = undefined;
    }
    if (isEmptyValue(value) && !rule.required) {
      return callback();
    }
    rules.required(rule, value, source, errors, options);
    if (value !== undefined) {
      rules.type(rule, value, source, errors, options);
      rules.range(rule, value, source, errors, options);
    }
  }
  callback(errors);
};
var _boolean = function _boolean(rule, value, callback, source, options) {
  var errors = [];
  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
  if (validate) {
    if (isEmptyValue(value) && !rule.required) {
      return callback();
    }
    rules.required(rule, value, source, errors, options);
    if (value !== undefined) {
      rules.type(rule, value, source, errors, options);
    }
  }
  callback(errors);
};
var regexp = function regexp(rule, value, callback, source, options) {
  var errors = [];
  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
  if (validate) {
    if (isEmptyValue(value) && !rule.required) {
      return callback();
    }
    rules.required(rule, value, source, errors, options);
    if (!isEmptyValue(value)) {
      rules.type(rule, value, source, errors, options);
    }
  }
  callback(errors);
};
var integer = function integer(rule, value, callback, source, options) {
  var errors = [];
  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
  if (validate) {
    if (isEmptyValue(value) && !rule.required) {
      return callback();
    }
    rules.required(rule, value, source, errors, options);
    if (value !== undefined) {
      rules.type(rule, value, source, errors, options);
      rules.range(rule, value, source, errors, options);
    }
  }
  callback(errors);
};
var floatFn = function floatFn(rule, value, callback, source, options) {
  var errors = [];
  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
  if (validate) {
    if (isEmptyValue(value) && !rule.required) {
      return callback();
    }
    rules.required(rule, value, source, errors, options);
    if (value !== undefined) {
      rules.type(rule, value, source, errors, options);
      rules.range(rule, value, source, errors, options);
    }
  }
  callback(errors);
};
var array = function array(rule, value, callback, source, options) {
  var errors = [];
  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
  if (validate) {
    if ((value === undefined || value === null) && !rule.required) {
      return callback();
    }
    rules.required(rule, value, source, errors, options, 'array');
    if (value !== undefined && value !== null) {
      rules.type(rule, value, source, errors, options);
      rules.range(rule, value, source, errors, options);
    }
  }
  callback(errors);
};
var object = function object(rule, value, callback, source, options) {
  var errors = [];
  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
  if (validate) {
    if (isEmptyValue(value) && !rule.required) {
      return callback();
    }
    rules.required(rule, value, source, errors, options);
    if (value !== undefined) {
      rules.type(rule, value, source, errors, options);
    }
  }
  callback(errors);
};
var ENUM = 'enum';
var enumerable = function enumerable(rule, value, callback, source, options) {
  var errors = [];
  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
  if (validate) {
    if (isEmptyValue(value) && !rule.required) {
      return callback();
    }
    rules.required(rule, value, source, errors, options);
    if (value !== undefined) {
      rules[ENUM](rule, value, source, errors, options);
    }
  }
  callback(errors);
};
var pattern = function pattern(rule, value, callback, source, options) {
  var errors = [];
  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
  if (validate) {
    if (isEmptyValue(value, 'string') && !rule.required) {
      return callback();
    }
    rules.required(rule, value, source, errors, options);
    if (!isEmptyValue(value, 'string')) {
      rules.pattern(rule, value, source, errors, options);
    }
  }
  callback(errors);
};
var date = function date(rule, value, callback, source, options) {
  // console.log('integer rule called %j', rule);
  var errors = [];
  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field); // console.log('validate on %s value', value);

  if (validate) {
    if (isEmptyValue(value, 'date') && !rule.required) {
      return callback();
    }
    rules.required(rule, value, source, errors, options);
    if (!isEmptyValue(value, 'date')) {
      var dateObject;
      if (value instanceof Date) {
        dateObject = value;
      } else {
        dateObject = new Date(value);
      }
      rules.type(rule, dateObject, source, errors, options);
      if (dateObject) {
        rules.range(rule, dateObject.getTime(), source, errors, options);
      }
    }
  }
  callback(errors);
};
var required = function required(rule, value, callback, source, options) {
  var errors = [];
  var type = Array.isArray(value) ? 'array' : typeof value;
  rules.required(rule, value, source, errors, options, type);
  callback(errors);
};
var type = function type(rule, value, callback, source, options) {
  var ruleType = rule.type;
  var errors = [];
  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
  if (validate) {
    if (isEmptyValue(value, ruleType) && !rule.required) {
      return callback();
    }
    rules.required(rule, value, source, errors, options, ruleType);
    if (!isEmptyValue(value, ruleType)) {
      rules.type(rule, value, source, errors, options);
    }
  }
  callback(errors);
};
var any = function any(rule, value, callback, source, options) {
  var errors = [];
  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
  if (validate) {
    if (isEmptyValue(value) && !rule.required) {
      return callback();
    }
    rules.required(rule, value, source, errors, options);
  }
  callback(errors);
};
var validators = {
  string: string,
  method: method,
  number: number,
  "boolean": _boolean,
  regexp: regexp,
  integer: integer,
  "float": floatFn,
  array: array,
  object: object,
  "enum": enumerable,
  pattern: pattern,
  date: date,
  url: type,
  hex: type,
  email: type,
  required: required,
  any: any
};
function newMessages() {
  return {
    "default": 'Validation error on field %s',
    required: '%s is required',
    "enum": '%s must be one of %s',
    whitespace: '%s cannot be empty',
    date: {
      format: '%s date %s is invalid for format %s',
      parse: '%s date could not be parsed, %s is invalid ',
      invalid: '%s date %s is invalid'
    },
    types: {
      string: '%s is not a %s',
      method: '%s is not a %s (function)',
      array: '%s is not an %s',
      object: '%s is not an %s',
      number: '%s is not a %s',
      date: '%s is not a %s',
      "boolean": '%s is not a %s',
      integer: '%s is not an %s',
      "float": '%s is not a %s',
      regexp: '%s is not a valid %s',
      email: '%s is not a valid %s',
      url: '%s is not a valid %s',
      hex: '%s is not a valid %s'
    },
    string: {
      len: '%s must be exactly %s characters',
      min: '%s must be at least %s characters',
      max: '%s cannot be longer than %s characters',
      range: '%s must be between %s and %s characters'
    },
    number: {
      len: '%s must equal %s',
      min: '%s cannot be less than %s',
      max: '%s cannot be greater than %s',
      range: '%s must be between %s and %s'
    },
    array: {
      len: '%s must be exactly %s in length',
      min: '%s cannot be less than %s in length',
      max: '%s cannot be greater than %s in length',
      range: '%s must be between %s and %s in length'
    },
    pattern: {
      mismatch: '%s value %s does not match pattern %s'
    },
    clone: function clone() {
      var cloned = JSON.parse(JSON.stringify(this));
      cloned.clone = this.clone;
      return cloned;
    }
  };
}
var messages = newMessages();

/**
 *  Encapsulates a validation schema.
 *
 *  @param descriptor An object declaring validation rules
 *  for this schema.
 */

var Schema = /*#__PURE__*/function () {
  // ========================= Static =========================
  // ======================== Instance ========================
  function Schema(descriptor) {
    this.rules = null;
    this._messages = messages;
    this.define(descriptor);
  }
  var _proto = Schema.prototype;
  _proto.define = function define(rules) {
    var _this = this;
    if (!rules) {
      throw new Error('Cannot configure a schema with no rules');
    }
    if (typeof rules !== 'object' || Array.isArray(rules)) {
      throw new Error('Rules must be an object');
    }
    this.rules = {};
    Object.keys(rules).forEach(function (name) {
      var item = rules[name];
      _this.rules[name] = Array.isArray(item) ? item : [item];
    });
  };
  _proto.messages = function messages(_messages) {
    if (_messages) {
      this._messages = deepMerge(newMessages(), _messages);
    }
    return this._messages;
  };
  _proto.validate = function validate(source_, o, oc) {
    var _this2 = this;
    if (o === void 0) {
      o = {};
    }
    if (oc === void 0) {
      oc = function oc() {};
    }
    var source = source_;
    var options = o;
    var callback = oc;
    if (typeof options === 'function') {
      callback = options;
      options = {};
    }
    if (!this.rules || Object.keys(this.rules).length === 0) {
      if (callback) {
        callback(null, source);
      }
      return Promise.resolve(source);
    }
    function complete(results) {
      var errors = [];
      var fields = {};
      function add(e) {
        if (Array.isArray(e)) {
          var _errors;
          errors = (_errors = errors).concat.apply(_errors, e);
        } else {
          errors.push(e);
        }
      }
      for (var i = 0; i < results.length; i++) {
        add(results[i]);
      }
      if (!errors.length) {
        callback(null, source);
      } else {
        fields = convertFieldsError(errors);
        callback(errors, fields);
      }
    }
    if (options.messages) {
      var messages$1 = this.messages();
      if (messages$1 === messages) {
        messages$1 = newMessages();
      }
      deepMerge(messages$1, options.messages);
      options.messages = messages$1;
    } else {
      options.messages = this.messages();
    }
    var series = {};
    var keys = options.keys || Object.keys(this.rules);
    keys.forEach(function (z) {
      var arr = _this2.rules[z];
      var value = source[z];
      arr.forEach(function (r) {
        var rule = r;
        if (typeof rule.transform === 'function') {
          if (source === source_) {
            source = dist_web_extends({}, source);
          }
          value = source[z] = rule.transform(value);
        }
        if (typeof rule === 'function') {
          rule = {
            validator: rule
          };
        } else {
          rule = dist_web_extends({}, rule);
        } // Fill validator. Skip if nothing need to validate

        rule.validator = _this2.getValidationMethod(rule);
        if (!rule.validator) {
          return;
        }
        rule.field = z;
        rule.fullField = rule.fullField || z;
        rule.type = _this2.getType(rule);
        series[z] = series[z] || [];
        series[z].push({
          rule: rule,
          value: value,
          source: source,
          field: z
        });
      });
    });
    var errorFields = {};
    return asyncMap(series, options, function (data, doIt) {
      var rule = data.rule;
      var deep = (rule.type === 'object' || rule.type === 'array') && (typeof rule.fields === 'object' || typeof rule.defaultField === 'object');
      deep = deep && (rule.required || !rule.required && data.value);
      rule.field = data.field;
      function addFullField(key, schema) {
        return dist_web_extends({}, schema, {
          fullField: rule.fullField + "." + key,
          fullFields: rule.fullFields ? [].concat(rule.fullFields, [key]) : [key]
        });
      }
      function cb(e) {
        if (e === void 0) {
          e = [];
        }
        var errorList = Array.isArray(e) ? e : [e];
        if (!options.suppressWarning && errorList.length) {
          Schema.warning('async-validator:', errorList);
        }
        if (errorList.length && rule.message !== undefined) {
          errorList = [].concat(rule.message);
        } // Fill error info

        var filledErrors = errorList.map(complementError(rule, source));
        if (options.first && filledErrors.length) {
          errorFields[rule.field] = 1;
          return doIt(filledErrors);
        }
        if (!deep) {
          doIt(filledErrors);
        } else {
          // if rule is required but the target object
          // does not exist fail at the rule level and don't
          // go deeper
          if (rule.required && !data.value) {
            if (rule.message !== undefined) {
              filledErrors = [].concat(rule.message).map(complementError(rule, source));
            } else if (options.error) {
              filledErrors = [options.error(rule, format(options.messages.required, rule.field))];
            }
            return doIt(filledErrors);
          }
          var fieldsSchema = {};
          if (rule.defaultField) {
            Object.keys(data.value).map(function (key) {
              fieldsSchema[key] = rule.defaultField;
            });
          }
          fieldsSchema = dist_web_extends({}, fieldsSchema, data.rule.fields);
          var paredFieldsSchema = {};
          Object.keys(fieldsSchema).forEach(function (field) {
            var fieldSchema = fieldsSchema[field];
            var fieldSchemaList = Array.isArray(fieldSchema) ? fieldSchema : [fieldSchema];
            paredFieldsSchema[field] = fieldSchemaList.map(addFullField.bind(null, field));
          });
          var schema = new Schema(paredFieldsSchema);
          schema.messages(options.messages);
          if (data.rule.options) {
            data.rule.options.messages = options.messages;
            data.rule.options.error = options.error;
          }
          schema.validate(data.value, data.rule.options || options, function (errs) {
            var finalErrors = [];
            if (filledErrors && filledErrors.length) {
              finalErrors.push.apply(finalErrors, filledErrors);
            }
            if (errs && errs.length) {
              finalErrors.push.apply(finalErrors, errs);
            }
            doIt(finalErrors.length ? finalErrors : null);
          });
        }
      }
      var res;
      if (rule.asyncValidator) {
        res = rule.asyncValidator(rule, data.value, cb, data.source, options);
      } else if (rule.validator) {
        try {
          res = rule.validator(rule, data.value, cb, data.source, options);
        } catch (error) {
          console.error == null ? void 0 : console.error(error); // rethrow to report error

          if (!options.suppressValidatorError) {
            setTimeout(function () {
              throw error;
            }, 0);
          }
          cb(error.message);
        }
        if (res === true) {
          cb();
        } else if (res === false) {
          cb(typeof rule.message === 'function' ? rule.message(rule.fullField || rule.field) : rule.message || (rule.fullField || rule.field) + " fails");
        } else if (res instanceof Array) {
          cb(res);
        } else if (res instanceof Error) {
          cb(res.message);
        }
      }
      if (res && res.then) {
        res.then(function () {
          return cb();
        }, function (e) {
          return cb(e);
        });
      }
    }, function (results) {
      complete(results);
    }, source);
  };
  _proto.getType = function getType(rule) {
    if (rule.type === undefined && rule.pattern instanceof RegExp) {
      rule.type = 'pattern';
    }
    if (typeof rule.validator !== 'function' && rule.type && !validators.hasOwnProperty(rule.type)) {
      throw new Error(format('Unknown rule type %s', rule.type));
    }
    return rule.type || 'string';
  };
  _proto.getValidationMethod = function getValidationMethod(rule) {
    if (typeof rule.validator === 'function') {
      return rule.validator;
    }
    var keys = Object.keys(rule);
    var messageIndex = keys.indexOf('message');
    if (messageIndex !== -1) {
      keys.splice(messageIndex, 1);
    }
    if (keys.length === 1 && keys[0] === 'required') {
      return validators.required;
    }
    return validators[this.getType(rule)] || undefined;
  };
  return Schema;
}();
Schema.register = function register(type, validator) {
  if (typeof validator !== 'function') {
    throw new Error('Cannot register a validator by type, validator is not a function');
  }
  validators[type] = validator;
};
Schema.warning = dist_web_warning;
Schema.messages = messages;
Schema.validators = validators;

;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/utils/messages.js
var typeTemplate = "'${name}' is not a valid ${type}";
var defaultValidateMessages = {
  default: "Validation error on field '${name}'",
  required: "'${name}' is required",
  enum: "'${name}' must be one of [${enum}]",
  whitespace: "'${name}' cannot be empty",
  date: {
    format: "'${name}' is invalid for format date",
    parse: "'${name}' could not be parsed as date",
    invalid: "'${name}' is invalid date"
  },
  types: {
    string: typeTemplate,
    method: typeTemplate,
    array: typeTemplate,
    object: typeTemplate,
    number: typeTemplate,
    date: typeTemplate,
    boolean: typeTemplate,
    integer: typeTemplate,
    float: typeTemplate,
    regexp: typeTemplate,
    email: typeTemplate,
    url: typeTemplate,
    hex: typeTemplate
  },
  string: {
    len: "'${name}' must be exactly ${len} characters",
    min: "'${name}' must be at least ${min} characters",
    max: "'${name}' cannot be longer than ${max} characters",
    range: "'${name}' must be between ${min} and ${max} characters"
  },
  number: {
    len: "'${name}' must equal ${len}",
    min: "'${name}' cannot be less than ${min}",
    max: "'${name}' cannot be greater than ${max}",
    range: "'${name}' must be between ${min} and ${max}"
  },
  array: {
    len: "'${name}' must be exactly ${len} in length",
    min: "'${name}' cannot be less than ${min} in length",
    max: "'${name}' cannot be greater than ${max} in length",
    range: "'${name}' must be between ${min} and ${max} in length"
  },
  pattern: {
    mismatch: "'${name}' does not match pattern ${pattern}"
  }
};
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/utils/get.js
function get(entity, path) {
  var current = entity;
  for (var i = 0; i < path.length; i += 1) {
    if (current === null || current === undefined) {
      return undefined;
    }
    current = current[path[i]];
  }
  return current;
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/toArray.js




function _toArray(arr) {
  return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest();
}
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/utils/set.js




function internalSet(entity, paths, value, removeIfUndefined) {
  if (!paths.length) {
    return value;
  }
  var _paths = _toArray(paths),
    path = _paths[0],
    restPath = _paths.slice(1);
  var clone;
  if (!entity && typeof path === 'number') {
    clone = [];
  } else if (Array.isArray(entity)) {
    clone = _toConsumableArray(entity);
  } else {
    clone = _objectSpread2({}, entity);
  }

  // Delete prop if `removeIfUndefined` and value is undefined
  if (removeIfUndefined && value === undefined && restPath.length === 1) {
    delete clone[path][restPath[0]];
  } else {
    clone[path] = internalSet(clone[path], restPath, value, removeIfUndefined);
  }
  return clone;
}
function set(entity, paths, value) {
  var removeIfUndefined = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
  // Do nothing if `removeIfUndefined` and parent object not exist
  if (paths.length && removeIfUndefined && value === undefined && !get(entity, paths.slice(0, -1))) {
    return entity;
  }
  return internalSet(entity, paths, value, removeIfUndefined);
}
;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/utils/cloneDeep.js

function cloneDeep(val) {
  if (Array.isArray(val)) {
    return cloneArrayDeep(val);
  } else if (_typeof(val) === 'object' && val !== null) {
    return cloneObjectDeep(val);
  }
  return val;
}
function cloneObjectDeep(val) {
  if (Object.getPrototypeOf(val) === Object.prototype) {
    var res = {};
    for (var key in val) {
      res[key] = cloneDeep(val[key]);
    }
    return res;
  }
  return val;
}
function cloneArrayDeep(val) {
  return val.map(function (item) {
    return cloneDeep(item);
  });
}
/* harmony default export */ var utils_cloneDeep = (cloneDeep);
;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/utils/valueUtil.js







/**
 * Convert name to internal supported format.
 * This function should keep since we still thinking if need support like `a.b.c` format.
 * 'a' => ['a']
 * 123 => [123]
 * ['a', 123] => ['a', 123]
 */
function getNamePath(path) {
  return typeUtil_toArray(path);
}
function valueUtil_getValue(store, namePath) {
  var value = get(store, namePath);
  return value;
}
function setValue(store, namePath, value) {
  var removeIfUndefined = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
  var newStore = set(store, namePath, value, removeIfUndefined);
  return newStore;
}
function cloneByNamePathList(store, namePathList) {
  var newStore = {};
  namePathList.forEach(function (namePath) {
    var value = valueUtil_getValue(store, namePath);
    newStore = setValue(newStore, namePath, value);
  });
  return newStore;
}
function containsNamePath(namePathList, namePath) {
  return namePathList && namePathList.some(function (path) {
    return matchNamePath(path, namePath);
  });
}
function isObject(obj) {
  return _typeof(obj) === 'object' && obj !== null && Object.getPrototypeOf(obj) === Object.prototype;
}
/**
 * Copy values into store and return a new values object
 * ({ a: 1, b: { c: 2 } }, { a: 4, b: { d: 5 } }) => { a: 4, b: { c: 2, d: 5 } }
 */
function internalSetValues(store, values) {
  var newStore = Array.isArray(store) ? _toConsumableArray(store) : _objectSpread2({}, store);
  if (!values) {
    return newStore;
  }
  Object.keys(values).forEach(function (key) {
    var prevValue = newStore[key];
    var value = values[key];
    // If both are object (but target is not array), we use recursion to set deep value
    var recursive = isObject(prevValue) && isObject(value);
    newStore[key] = recursive ? internalSetValues(prevValue, value || {}) : utils_cloneDeep(value); // Clone deep for arrays
  });

  return newStore;
}
function setValues(store) {
  for (var _len = arguments.length, restValues = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    restValues[_key - 1] = arguments[_key];
  }
  return restValues.reduce(function (current, newStore) {
    return internalSetValues(current, newStore);
  }, store);
}
function matchNamePath(namePath, changedNamePath) {
  if (!namePath || !changedNamePath || namePath.length !== changedNamePath.length) {
    return false;
  }
  return namePath.every(function (nameUnit, i) {
    return changedNamePath[i] === nameUnit;
  });
}
function isSimilar(source, target) {
  if (source === target) {
    return true;
  }
  if (!source && target || source && !target) {
    return false;
  }
  if (!source || !target || _typeof(source) !== 'object' || _typeof(target) !== 'object') {
    return false;
  }
  var sourceKeys = Object.keys(source);
  var targetKeys = Object.keys(target);
  var keys = new Set([].concat(sourceKeys, targetKeys));
  return _toConsumableArray(keys).every(function (key) {
    var sourceValue = source[key];
    var targetValue = target[key];
    if (typeof sourceValue === 'function' && typeof targetValue === 'function') {
      return true;
    }
    return sourceValue === targetValue;
  });
}
function defaultGetValueFromEvent(valuePropName) {
  var event = arguments.length <= 1 ? undefined : arguments[1];
  if (event && event.target && _typeof(event.target) === 'object' && valuePropName in event.target) {
    return event.target[valuePropName];
  }
  return event;
}
/**
 * Moves an array item from one position in an array to another.
 *
 * Note: This is a pure function so a new array will be returned, instead
 * of altering the array argument.
 *
 * @param array         Array in which to move an item.         (required)
 * @param moveIndex     The index of the item to move.          (required)
 * @param toIndex       The index to move item at moveIndex to. (required)
 */
function valueUtil_move(array, moveIndex, toIndex) {
  var length = array.length;
  if (moveIndex < 0 || moveIndex >= length || toIndex < 0 || toIndex >= length) {
    return array;
  }
  var item = array[moveIndex];
  var diff = moveIndex - toIndex;
  if (diff > 0) {
    // move left
    return [].concat(_toConsumableArray(array.slice(0, toIndex)), [item], _toConsumableArray(array.slice(toIndex, moveIndex)), _toConsumableArray(array.slice(moveIndex + 1, length)));
  }
  if (diff < 0) {
    // move right
    return [].concat(_toConsumableArray(array.slice(0, moveIndex)), _toConsumableArray(array.slice(moveIndex + 1, toIndex + 1)), [item], _toConsumableArray(array.slice(toIndex + 1, length)));
  }
  return array;
}
;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/utils/validateUtil.js










// Remove incorrect original ts define
var AsyncValidator = Schema;
/**
 * Replace with template.
 *   `I'm ${name}` + { name: 'bamboo' } = I'm bamboo
 */
function replaceMessage(template, kv) {
  return template.replace(/\$\{\w+\}/g, function (str) {
    var key = str.slice(2, -1);
    return kv[key];
  });
}
var CODE_LOGIC_ERROR = 'CODE_LOGIC_ERROR';
function validateRule(_x, _x2, _x3, _x4, _x5) {
  return _validateRule.apply(this, arguments);
}
/**
 * We use `async-validator` to validate the value.
 * But only check one value in a time to avoid namePath validate issue.
 */
function _validateRule() {
  _validateRule = asyncToGenerator_asyncToGenerator( /*#__PURE__*/regeneratorRuntime_regeneratorRuntime().mark(function _callee2(name, value, rule, options, messageVariables) {
    var cloneRule, originValidator, subRuleField, validator, messages, result, subResults, kv, fillVariableResult;
    return regeneratorRuntime_regeneratorRuntime().wrap(function _callee2$(_context2) {
      while (1) switch (_context2.prev = _context2.next) {
        case 0:
          cloneRule = _objectSpread2({}, rule); // Bug of `async-validator`
          // https://github.com/react-component/field-form/issues/316
          // https://github.com/react-component/field-form/issues/313
          delete cloneRule.ruleIndex;
          if (cloneRule.validator) {
            originValidator = cloneRule.validator;
            cloneRule.validator = function () {
              try {
                return originValidator.apply(void 0, arguments);
              } catch (error) {
                console.error(error);
                return Promise.reject(CODE_LOGIC_ERROR);
              }
            };
          }
          // We should special handle array validate
          subRuleField = null;
          if (cloneRule && cloneRule.type === 'array' && cloneRule.defaultField) {
            subRuleField = cloneRule.defaultField;
            delete cloneRule.defaultField;
          }
          validator = new AsyncValidator(defineProperty_defineProperty({}, name, [cloneRule]));
          messages = setValues({}, defaultValidateMessages, options.validateMessages);
          validator.messages(messages);
          result = [];
          _context2.prev = 9;
          _context2.next = 12;
          return Promise.resolve(validator.validate(defineProperty_defineProperty({}, name, value), _objectSpread2({}, options)));
        case 12:
          _context2.next = 17;
          break;
        case 14:
          _context2.prev = 14;
          _context2.t0 = _context2["catch"](9);
          if (_context2.t0.errors) {
            result = _context2.t0.errors.map(function (_ref4, index) {
              var message = _ref4.message;
              var mergedMessage = message === CODE_LOGIC_ERROR ? messages.default : message;
              return /*#__PURE__*/_react_18_2_0_react.isValidElement(mergedMessage) ? /*#__PURE__*/
              // Wrap ReactNode with `key`
              _react_18_2_0_react.cloneElement(mergedMessage, {
                key: "error_".concat(index)
              }) : mergedMessage;
            });
          }
        case 17:
          if (!(!result.length && subRuleField)) {
            _context2.next = 22;
            break;
          }
          _context2.next = 20;
          return Promise.all(value.map(function (subValue, i) {
            return validateRule("".concat(name, ".").concat(i), subValue, subRuleField, options, messageVariables);
          }));
        case 20:
          subResults = _context2.sent;
          return _context2.abrupt("return", subResults.reduce(function (prev, errors) {
            return [].concat(_toConsumableArray(prev), _toConsumableArray(errors));
          }, []));
        case 22:
          // Replace message with variables
          kv = _objectSpread2(_objectSpread2({}, rule), {}, {
            name: name,
            enum: (rule.enum || []).join(', ')
          }, messageVariables);
          fillVariableResult = result.map(function (error) {
            if (typeof error === 'string') {
              return replaceMessage(error, kv);
            }
            return error;
          });
          return _context2.abrupt("return", fillVariableResult);
        case 25:
        case "end":
          return _context2.stop();
      }
    }, _callee2, null, [[9, 14]]);
  }));
  return _validateRule.apply(this, arguments);
}
function validateRules(namePath, value, rules, options, validateFirst, messageVariables) {
  var name = namePath.join('.');
  // Fill rule with context
  var filledRules = rules.map(function (currentRule, ruleIndex) {
    var originValidatorFunc = currentRule.validator;
    var cloneRule = _objectSpread2(_objectSpread2({}, currentRule), {}, {
      ruleIndex: ruleIndex
    });
    // Replace validator if needed
    if (originValidatorFunc) {
      cloneRule.validator = function (rule, val, callback) {
        var hasPromise = false;
        // Wrap callback only accept when promise not provided
        var wrappedCallback = function wrappedCallback() {
          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }
          // Wait a tick to make sure return type is a promise
          Promise.resolve().then(function () {
            es_warning(!hasPromise, 'Your validator function has already return a promise. `callback` will be ignored.');
            if (!hasPromise) {
              callback.apply(void 0, args);
            }
          });
        };
        // Get promise
        var promise = originValidatorFunc(rule, val, wrappedCallback);
        hasPromise = promise && typeof promise.then === 'function' && typeof promise.catch === 'function';
        /**
         * 1. Use promise as the first priority.
         * 2. If promise not exist, use callback with warning instead
         */
        es_warning(hasPromise, '`callback` is deprecated. Please return a promise instead.');
        if (hasPromise) {
          promise.then(function () {
            callback();
          }).catch(function (err) {
            callback(err || ' ');
          });
        }
      };
    }
    return cloneRule;
  }).sort(function (_ref, _ref2) {
    var w1 = _ref.warningOnly,
      i1 = _ref.ruleIndex;
    var w2 = _ref2.warningOnly,
      i2 = _ref2.ruleIndex;
    if (!!w1 === !!w2) {
      // Let keep origin order
      return i1 - i2;
    }
    if (w1) {
      return 1;
    }
    return -1;
  });
  // Do validate rules
  var summaryPromise;
  if (validateFirst === true) {
    // >>>>> Validate by serialization
    summaryPromise = new Promise( /*#__PURE__*/function () {
      var _ref3 = asyncToGenerator_asyncToGenerator( /*#__PURE__*/regeneratorRuntime_regeneratorRuntime().mark(function _callee(resolve, reject) {
        var i, rule, errors;
        return regeneratorRuntime_regeneratorRuntime().wrap(function _callee$(_context) {
          while (1) switch (_context.prev = _context.next) {
            case 0:
              i = 0;
            case 1:
              if (!(i < filledRules.length)) {
                _context.next = 12;
                break;
              }
              rule = filledRules[i];
              _context.next = 5;
              return validateRule(name, value, rule, options, messageVariables);
            case 5:
              errors = _context.sent;
              if (!errors.length) {
                _context.next = 9;
                break;
              }
              reject([{
                errors: errors,
                rule: rule
              }]);
              return _context.abrupt("return");
            case 9:
              i += 1;
              _context.next = 1;
              break;
            case 12:
              /* eslint-enable */
              resolve([]);
            case 13:
            case "end":
              return _context.stop();
          }
        }, _callee);
      }));
      return function (_x6, _x7) {
        return _ref3.apply(this, arguments);
      };
    }());
  } else {
    // >>>>> Validate by parallel
    var rulePromises = filledRules.map(function (rule) {
      return validateRule(name, value, rule, options, messageVariables).then(function (errors) {
        return {
          errors: errors,
          rule: rule
        };
      });
    });
    summaryPromise = (validateFirst ? finishOnFirstFailed(rulePromises) : finishOnAllFailed(rulePromises)).then(function (errors) {
      // Always change to rejection for Field to catch
      return Promise.reject(errors);
    });
  }
  // Internal catch error to avoid console error log.
  summaryPromise.catch(function (e) {
    return e;
  });
  return summaryPromise;
}
function finishOnAllFailed(_x8) {
  return _finishOnAllFailed.apply(this, arguments);
}
function _finishOnAllFailed() {
  _finishOnAllFailed = asyncToGenerator_asyncToGenerator( /*#__PURE__*/regeneratorRuntime_regeneratorRuntime().mark(function _callee3(rulePromises) {
    return regeneratorRuntime_regeneratorRuntime().wrap(function _callee3$(_context3) {
      while (1) switch (_context3.prev = _context3.next) {
        case 0:
          return _context3.abrupt("return", Promise.all(rulePromises).then(function (errorsList) {
            var _ref5;
            var errors = (_ref5 = []).concat.apply(_ref5, _toConsumableArray(errorsList));
            return errors;
          }));
        case 1:
        case "end":
          return _context3.stop();
      }
    }, _callee3);
  }));
  return _finishOnAllFailed.apply(this, arguments);
}
function finishOnFirstFailed(_x9) {
  return _finishOnFirstFailed.apply(this, arguments);
}
function _finishOnFirstFailed() {
  _finishOnFirstFailed = asyncToGenerator_asyncToGenerator( /*#__PURE__*/regeneratorRuntime_regeneratorRuntime().mark(function _callee4(rulePromises) {
    var count;
    return regeneratorRuntime_regeneratorRuntime().wrap(function _callee4$(_context4) {
      while (1) switch (_context4.prev = _context4.next) {
        case 0:
          count = 0;
          return _context4.abrupt("return", new Promise(function (resolve) {
            rulePromises.forEach(function (promise) {
              promise.then(function (ruleError) {
                if (ruleError.errors.length) {
                  resolve([ruleError]);
                }
                count += 1;
                if (count === rulePromises.length) {
                  resolve([]);
                }
              });
            });
          }));
        case 2:
        case "end":
          return _context4.stop();
      }
    }, _callee4);
  }));
  return _finishOnFirstFailed.apply(this, arguments);
}
;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/Field.js










var Field_excluded = ["name"];







var EMPTY_ERRORS = [];
function requireUpdate(shouldUpdate, prev, next, prevValue, nextValue, info) {
  if (typeof shouldUpdate === 'function') {
    return shouldUpdate(prev, next, 'source' in info ? {
      source: info.source
    } : {});
  }
  return prevValue !== nextValue;
}
// We use Class instead of Hooks here since it will cost much code by using Hooks.
var Field = /*#__PURE__*/function (_React$Component) {
  _inherits(Field, _React$Component);
  var _super = _createSuper(Field);
  /**
   * Follow state should not management in State since it will async update by React.
   * This makes first render of form can not get correct state value.
   */

  /**
   * Mark when touched & validated. Currently only used for `dependencies`.
   * Note that we do not think field with `initialValue` is dirty
   * but this will be by `isFieldDirty` func.
   */

  // ============================== Subscriptions ==============================
  function Field(props) {
    var _this;
    _classCallCheck(this, Field);
    _this = _super.call(this, props);
    // Register on init
    _this.state = {
      resetCount: 0
    };
    _this.cancelRegisterFunc = null;
    _this.mounted = false;
    _this.touched = false;
    _this.dirty = false;
    _this.validatePromise = null;
    _this.prevValidating = void 0;
    _this.errors = EMPTY_ERRORS;
    _this.warnings = EMPTY_ERRORS;
    _this.cancelRegister = function () {
      var _this$props = _this.props,
        preserve = _this$props.preserve,
        isListField = _this$props.isListField,
        name = _this$props.name;
      if (_this.cancelRegisterFunc) {
        _this.cancelRegisterFunc(isListField, preserve, getNamePath(name));
      }
      _this.cancelRegisterFunc = null;
    };
    _this.getNamePath = function () {
      var _this$props2 = _this.props,
        name = _this$props2.name,
        fieldContext = _this$props2.fieldContext;
      var _fieldContext$prefixN = fieldContext.prefixName,
        prefixName = _fieldContext$prefixN === void 0 ? [] : _fieldContext$prefixN;
      return name !== undefined ? [].concat(_toConsumableArray(prefixName), _toConsumableArray(name)) : [];
    };
    _this.getRules = function () {
      var _this$props3 = _this.props,
        _this$props3$rules = _this$props3.rules,
        rules = _this$props3$rules === void 0 ? [] : _this$props3$rules,
        fieldContext = _this$props3.fieldContext;
      return rules.map(function (rule) {
        if (typeof rule === 'function') {
          return rule(fieldContext);
        }
        return rule;
      });
    };
    _this.refresh = function () {
      if (!_this.mounted) return;
      /**
       * Clean up current node.
       */
      _this.setState(function (_ref) {
        var resetCount = _ref.resetCount;
        return {
          resetCount: resetCount + 1
        };
      });
    };
    _this.triggerMetaEvent = function (destroy) {
      var onMetaChange = _this.props.onMetaChange;
      onMetaChange === null || onMetaChange === void 0 ? void 0 : onMetaChange(_objectSpread2(_objectSpread2({}, _this.getMeta()), {}, {
        destroy: destroy
      }));
    };
    _this.onStoreChange = function (prevStore, namePathList, info) {
      var _this$props4 = _this.props,
        shouldUpdate = _this$props4.shouldUpdate,
        _this$props4$dependen = _this$props4.dependencies,
        dependencies = _this$props4$dependen === void 0 ? [] : _this$props4$dependen,
        onReset = _this$props4.onReset;
      var store = info.store;
      var namePath = _this.getNamePath();
      var prevValue = _this.getValue(prevStore);
      var curValue = _this.getValue(store);
      var namePathMatch = namePathList && containsNamePath(namePathList, namePath);
      // `setFieldsValue` is a quick access to update related status
      if (info.type === 'valueUpdate' && info.source === 'external' && prevValue !== curValue) {
        _this.touched = true;
        _this.dirty = true;
        _this.validatePromise = null;
        _this.errors = EMPTY_ERRORS;
        _this.warnings = EMPTY_ERRORS;
        _this.triggerMetaEvent();
      }
      switch (info.type) {
        case 'reset':
          if (!namePathList || namePathMatch) {
            // Clean up state
            _this.touched = false;
            _this.dirty = false;
            _this.validatePromise = null;
            _this.errors = EMPTY_ERRORS;
            _this.warnings = EMPTY_ERRORS;
            _this.triggerMetaEvent();
            onReset === null || onReset === void 0 ? void 0 : onReset();
            _this.refresh();
            return;
          }
          break;
        /**
         * In case field with `preserve = false` nest deps like:
         * - A = 1 => show B
         * - B = 1 => show C
         * - Reset A, need clean B, C
         */
        case 'remove':
          {
            if (shouldUpdate) {
              _this.reRender();
              return;
            }
            break;
          }
        case 'setField':
          {
            if (namePathMatch) {
              var data = info.data;
              if ('touched' in data) {
                _this.touched = data.touched;
              }
              if ('validating' in data && !('originRCField' in data)) {
                _this.validatePromise = data.validating ? Promise.resolve([]) : null;
              }
              if ('errors' in data) {
                _this.errors = data.errors || EMPTY_ERRORS;
              }
              if ('warnings' in data) {
                _this.warnings = data.warnings || EMPTY_ERRORS;
              }
              _this.dirty = true;
              _this.triggerMetaEvent();
              _this.reRender();
              return;
            }
            // Handle update by `setField` with `shouldUpdate`
            if (shouldUpdate && !namePath.length && requireUpdate(shouldUpdate, prevStore, store, prevValue, curValue, info)) {
              _this.reRender();
              return;
            }
            break;
          }
        case 'dependenciesUpdate':
          {
            /**
             * Trigger when marked `dependencies` updated. Related fields will all update
             */
            var dependencyList = dependencies.map(getNamePath);
            // No need for `namePathMath` check and `shouldUpdate` check, since `valueUpdate` will be
            // emitted earlier and they will work there
            // If set it may cause unnecessary twice rerendering
            if (dependencyList.some(function (dependency) {
              return containsNamePath(info.relatedFields, dependency);
            })) {
              _this.reRender();
              return;
            }
            break;
          }
        default:
          // 1. If `namePath` exists in `namePathList`, means it's related value and should update
          //      For example <List name="list"><Field name={['list', 0]}></List>
          //      If `namePathList` is [['list']] (List value update), Field should be updated
          //      If `namePathList` is [['list', 0]] (Field value update), List shouldn't be updated
          // 2.
          //   2.1 If `dependencies` is set, `name` is not set and `shouldUpdate` is not set,
          //       don't use `shouldUpdate`. `dependencies` is view as a shortcut if `shouldUpdate`
          //       is not provided
          //   2.2 If `shouldUpdate` provided, use customize logic to update the field
          //       else to check if value changed
          if (namePathMatch || (!dependencies.length || namePath.length || shouldUpdate) && requireUpdate(shouldUpdate, prevStore, store, prevValue, curValue, info)) {
            _this.reRender();
            return;
          }
          break;
      }
      if (shouldUpdate === true) {
        _this.reRender();
      }
    };
    _this.validateRules = function (options) {
      // We should fixed namePath & value to avoid developer change then by form function
      var namePath = _this.getNamePath();
      var currentValue = _this.getValue();
      // Force change to async to avoid rule OOD under renderProps field
      var rootPromise = Promise.resolve().then(function () {
        if (!_this.mounted) {
          return [];
        }
        var _this$props5 = _this.props,
          _this$props5$validate = _this$props5.validateFirst,
          validateFirst = _this$props5$validate === void 0 ? false : _this$props5$validate,
          messageVariables = _this$props5.messageVariables;
        var _ref2 = options || {},
          triggerName = _ref2.triggerName;
        var filteredRules = _this.getRules();
        if (triggerName) {
          filteredRules = filteredRules.filter(function (rule) {
            return rule;
          }).filter(function (rule) {
            var validateTrigger = rule.validateTrigger;
            if (!validateTrigger) {
              return true;
            }
            var triggerList = typeUtil_toArray(validateTrigger);
            return triggerList.includes(triggerName);
          });
        }
        var promise = validateRules(namePath, currentValue, filteredRules, options, validateFirst, messageVariables);
        promise.catch(function (e) {
          return e;
        }).then(function () {
          var ruleErrors = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : EMPTY_ERRORS;
          if (_this.validatePromise === rootPromise) {
            var _ruleErrors$forEach;
            _this.validatePromise = null;
            // Get errors & warnings
            var nextErrors = [];
            var nextWarnings = [];
            (_ruleErrors$forEach = ruleErrors.forEach) === null || _ruleErrors$forEach === void 0 ? void 0 : _ruleErrors$forEach.call(ruleErrors, function (_ref3) {
              var warningOnly = _ref3.rule.warningOnly,
                _ref3$errors = _ref3.errors,
                errors = _ref3$errors === void 0 ? EMPTY_ERRORS : _ref3$errors;
              if (warningOnly) {
                nextWarnings.push.apply(nextWarnings, _toConsumableArray(errors));
              } else {
                nextErrors.push.apply(nextErrors, _toConsumableArray(errors));
              }
            });
            _this.errors = nextErrors;
            _this.warnings = nextWarnings;
            _this.triggerMetaEvent();
            _this.reRender();
          }
        });
        return promise;
      });
      _this.validatePromise = rootPromise;
      _this.dirty = true;
      _this.errors = EMPTY_ERRORS;
      _this.warnings = EMPTY_ERRORS;
      _this.triggerMetaEvent();
      // Force trigger re-render since we need sync renderProps with new meta
      _this.reRender();
      return rootPromise;
    };
    _this.isFieldValidating = function () {
      return !!_this.validatePromise;
    };
    _this.isFieldTouched = function () {
      return _this.touched;
    };
    _this.isFieldDirty = function () {
      // Touched or validate or has initialValue
      if (_this.dirty || _this.props.initialValue !== undefined) {
        return true;
      }
      // Form set initialValue
      var fieldContext = _this.props.fieldContext;
      var _fieldContext$getInte = fieldContext.getInternalHooks(HOOK_MARK),
        getInitialValue = _fieldContext$getInte.getInitialValue;
      if (getInitialValue(_this.getNamePath()) !== undefined) {
        return true;
      }
      return false;
    };
    _this.getErrors = function () {
      return _this.errors;
    };
    _this.getWarnings = function () {
      return _this.warnings;
    };
    _this.isListField = function () {
      return _this.props.isListField;
    };
    _this.isList = function () {
      return _this.props.isList;
    };
    _this.isPreserve = function () {
      return _this.props.preserve;
    };
    _this.getMeta = function () {
      // Make error & validating in cache to save perf
      _this.prevValidating = _this.isFieldValidating();
      var meta = {
        touched: _this.isFieldTouched(),
        validating: _this.prevValidating,
        errors: _this.errors,
        warnings: _this.warnings,
        name: _this.getNamePath()
      };
      return meta;
    };
    _this.getOnlyChild = function (children) {
      // Support render props
      if (typeof children === 'function') {
        var meta = _this.getMeta();
        return _objectSpread2(_objectSpread2({}, _this.getOnlyChild(children(_this.getControlled(), meta, _this.props.fieldContext))), {}, {
          isFunction: true
        });
      }
      // Filed element only
      var childList = toArray_toArray(children);
      if (childList.length !== 1 || ! /*#__PURE__*/_react_18_2_0_react.isValidElement(childList[0])) {
        return {
          child: childList,
          isFunction: false
        };
      }
      return {
        child: childList[0],
        isFunction: false
      };
    };
    _this.getValue = function (store) {
      var getFieldsValue = _this.props.fieldContext.getFieldsValue;
      var namePath = _this.getNamePath();
      return valueUtil_getValue(store || getFieldsValue(true), namePath);
    };
    _this.getControlled = function () {
      var childProps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var _this$props6 = _this.props,
        trigger = _this$props6.trigger,
        validateTrigger = _this$props6.validateTrigger,
        getValueFromEvent = _this$props6.getValueFromEvent,
        normalize = _this$props6.normalize,
        valuePropName = _this$props6.valuePropName,
        getValueProps = _this$props6.getValueProps,
        fieldContext = _this$props6.fieldContext;
      var mergedValidateTrigger = validateTrigger !== undefined ? validateTrigger : fieldContext.validateTrigger;
      var namePath = _this.getNamePath();
      var getInternalHooks = fieldContext.getInternalHooks,
        getFieldsValue = fieldContext.getFieldsValue;
      var _getInternalHooks = getInternalHooks(HOOK_MARK),
        dispatch = _getInternalHooks.dispatch;
      var value = _this.getValue();
      var mergedGetValueProps = getValueProps || function (val) {
        return defineProperty_defineProperty({}, valuePropName, val);
      };
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      var originTriggerFunc = childProps[trigger];
      var control = _objectSpread2(_objectSpread2({}, childProps), mergedGetValueProps(value));
      // Add trigger
      control[trigger] = function () {
        // Mark as touched
        _this.touched = true;
        _this.dirty = true;
        _this.triggerMetaEvent();
        var newValue;
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }
        if (getValueFromEvent) {
          newValue = getValueFromEvent.apply(void 0, args);
        } else {
          newValue = defaultGetValueFromEvent.apply(void 0, [valuePropName].concat(args));
        }
        if (normalize) {
          newValue = normalize(newValue, value, getFieldsValue(true));
        }
        dispatch({
          type: 'updateValue',
          namePath: namePath,
          value: newValue
        });
        if (originTriggerFunc) {
          originTriggerFunc.apply(void 0, args);
        }
      };
      // Add validateTrigger
      var validateTriggerList = typeUtil_toArray(mergedValidateTrigger || []);
      validateTriggerList.forEach(function (triggerName) {
        // Wrap additional function of component, so that we can get latest value from store
        var originTrigger = control[triggerName];
        control[triggerName] = function () {
          if (originTrigger) {
            originTrigger.apply(void 0, arguments);
          }
          // Always use latest rules
          var rules = _this.props.rules;
          if (rules && rules.length) {
            // We dispatch validate to root,
            // since it will update related data with other field with same name
            dispatch({
              type: 'validateField',
              namePath: namePath,
              triggerName: triggerName
            });
          }
        };
      });
      return control;
    };
    if (props.fieldContext) {
      var getInternalHooks = props.fieldContext.getInternalHooks;
      var _getInternalHooks2 = getInternalHooks(HOOK_MARK),
        initEntityValue = _getInternalHooks2.initEntityValue;
      initEntityValue(_assertThisInitialized(_this));
    }
    return _this;
  }
  _createClass(Field, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      var _this$props7 = this.props,
        shouldUpdate = _this$props7.shouldUpdate,
        fieldContext = _this$props7.fieldContext;
      this.mounted = true;
      // Register on init
      if (fieldContext) {
        var getInternalHooks = fieldContext.getInternalHooks;
        var _getInternalHooks3 = getInternalHooks(HOOK_MARK),
          registerField = _getInternalHooks3.registerField;
        this.cancelRegisterFunc = registerField(this);
      }
      // One more render for component in case fields not ready
      if (shouldUpdate === true) {
        this.reRender();
      }
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      this.cancelRegister();
      this.triggerMetaEvent(true);
      this.mounted = false;
    }
  }, {
    key: "reRender",
    value: function reRender() {
      if (!this.mounted) return;
      this.forceUpdate();
    }
  }, {
    key: "render",
    value: function render() {
      var resetCount = this.state.resetCount;
      var children = this.props.children;
      var _this$getOnlyChild = this.getOnlyChild(children),
        child = _this$getOnlyChild.child,
        isFunction = _this$getOnlyChild.isFunction;
      // Not need to `cloneElement` since user can handle this in render function self
      var returnChildNode;
      if (isFunction) {
        returnChildNode = child;
      } else if ( /*#__PURE__*/_react_18_2_0_react.isValidElement(child)) {
        returnChildNode = /*#__PURE__*/_react_18_2_0_react.cloneElement(child, this.getControlled(child.props));
      } else {
        es_warning(!child, '`children` of Field is not validate ReactElement.');
        returnChildNode = child;
      }
      return /*#__PURE__*/_react_18_2_0_react.createElement(_react_18_2_0_react.Fragment, {
        key: resetCount
      }, returnChildNode);
    }
  }]);
  return Field;
}(_react_18_2_0_react.Component);
Field.contextType = FieldContext;
Field.defaultProps = {
  trigger: 'onChange',
  valuePropName: 'value'
};
function WrapperField(_ref5) {
  var name = _ref5.name,
    restProps = _objectWithoutProperties(_ref5, Field_excluded);
  var fieldContext = _react_18_2_0_react.useContext(FieldContext);
  var namePath = name !== undefined ? getNamePath(name) : undefined;
  var key = 'keep';
  if (!restProps.isListField) {
    key = "_".concat((namePath || []).join('_'));
  }
  // Warning if it's a directly list field.
  // We can still support multiple level field preserve.
  if (false) {}
  return /*#__PURE__*/_react_18_2_0_react.createElement(Field, extends_extends({
    key: key,
    name: namePath
  }, restProps, {
    fieldContext: fieldContext
  }));
}
/* harmony default export */ var es_Field = (WrapperField);
;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/ListContext.js

var ListContext = /*#__PURE__*/_react_18_2_0_react.createContext(null);
/* harmony default export */ var es_ListContext = (ListContext);
;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/List.js








var List = function List(_ref) {
  var name = _ref.name,
    initialValue = _ref.initialValue,
    children = _ref.children,
    rules = _ref.rules,
    validateTrigger = _ref.validateTrigger;
  var context = _react_18_2_0_react.useContext(FieldContext);
  var keyRef = _react_18_2_0_react.useRef({
    keys: [],
    id: 0
  });
  var keyManager = keyRef.current;
  var prefixName = _react_18_2_0_react.useMemo(function () {
    var parentPrefixName = getNamePath(context.prefixName) || [];
    return [].concat(_toConsumableArray(parentPrefixName), _toConsumableArray(getNamePath(name)));
  }, [context.prefixName, name]);
  var fieldContext = _react_18_2_0_react.useMemo(function () {
    return _objectSpread2(_objectSpread2({}, context), {}, {
      prefixName: prefixName
    });
  }, [context, prefixName]);
  // List context
  var listContext = _react_18_2_0_react.useMemo(function () {
    return {
      getKey: function getKey(namePath) {
        var len = prefixName.length;
        var pathName = namePath[len];
        return [keyManager.keys[pathName], namePath.slice(len + 1)];
      }
    };
  }, [prefixName]);
  // User should not pass `children` as other type.
  if (typeof children !== 'function') {
    es_warning(false, 'Form.List only accepts function as children.');
    return null;
  }
  var shouldUpdate = function shouldUpdate(prevValue, nextValue, _ref2) {
    var source = _ref2.source;
    if (source === 'internal') {
      return false;
    }
    return prevValue !== nextValue;
  };
  return /*#__PURE__*/_react_18_2_0_react.createElement(es_ListContext.Provider, {
    value: listContext
  }, /*#__PURE__*/_react_18_2_0_react.createElement(FieldContext.Provider, {
    value: fieldContext
  }, /*#__PURE__*/_react_18_2_0_react.createElement(es_Field, {
    name: [],
    shouldUpdate: shouldUpdate,
    rules: rules,
    validateTrigger: validateTrigger,
    initialValue: initialValue,
    isList: true
  }, function (_ref3, meta) {
    var _ref3$value = _ref3.value,
      value = _ref3$value === void 0 ? [] : _ref3$value,
      onChange = _ref3.onChange;
    var getFieldValue = context.getFieldValue;
    var getNewValue = function getNewValue() {
      var values = getFieldValue(prefixName || []);
      return values || [];
    };
    /**
     * Always get latest value in case user update fields by `form` api.
     */
    var operations = {
      add: function add(defaultValue, index) {
        // Mapping keys
        var newValue = getNewValue();
        if (index >= 0 && index <= newValue.length) {
          keyManager.keys = [].concat(_toConsumableArray(keyManager.keys.slice(0, index)), [keyManager.id], _toConsumableArray(keyManager.keys.slice(index)));
          onChange([].concat(_toConsumableArray(newValue.slice(0, index)), [defaultValue], _toConsumableArray(newValue.slice(index))));
        } else {
          if (false) {}
          keyManager.keys = [].concat(_toConsumableArray(keyManager.keys), [keyManager.id]);
          onChange([].concat(_toConsumableArray(newValue), [defaultValue]));
        }
        keyManager.id += 1;
      },
      remove: function remove(index) {
        var newValue = getNewValue();
        var indexSet = new Set(Array.isArray(index) ? index : [index]);
        if (indexSet.size <= 0) {
          return;
        }
        keyManager.keys = keyManager.keys.filter(function (_, keysIndex) {
          return !indexSet.has(keysIndex);
        });
        // Trigger store change
        onChange(newValue.filter(function (_, valueIndex) {
          return !indexSet.has(valueIndex);
        }));
      },
      move: function move(from, to) {
        if (from === to) {
          return;
        }
        var newValue = getNewValue();
        // Do not handle out of range
        if (from < 0 || from >= newValue.length || to < 0 || to >= newValue.length) {
          return;
        }
        keyManager.keys = valueUtil_move(keyManager.keys, from, to);
        // Trigger store change
        onChange(valueUtil_move(newValue, from, to));
      }
    };
    var listValue = value || [];
    if (!Array.isArray(listValue)) {
      listValue = [];
      if (false) {}
    }
    return children(listValue.map(function (__, index) {
      var key = keyManager.keys[index];
      if (key === undefined) {
        keyManager.keys[index] = keyManager.id;
        key = keyManager.keys[index];
        keyManager.id += 1;
      }
      return {
        name: index,
        key: key,
        isListField: true
      };
    }), operations, meta);
  })));
};
/* harmony default export */ var es_List = (List);
;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/utils/asyncUtil.js
function allPromiseFinish(promiseList) {
  var hasError = false;
  var count = promiseList.length;
  var results = [];
  if (!promiseList.length) {
    return Promise.resolve([]);
  }
  return new Promise(function (resolve, reject) {
    promiseList.forEach(function (promise, index) {
      promise.catch(function (e) {
        hasError = true;
        return e;
      }).then(function (result) {
        count -= 1;
        results[index] = result;
        if (count > 0) {
          return;
        }
        if (hasError) {
          reject(results);
        }
        resolve(results);
      });
    });
  });
}
;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/utils/NameMap.js





var SPLIT = '__@field_split__';
/**
 * Convert name path into string to fast the fetch speed of Map.
 */
function normalize(namePath) {
  return namePath.map(function (cell) {
    return "".concat(_typeof(cell), ":").concat(cell);
  })
  // Magic split
  .join(SPLIT);
}
/**
 * NameMap like a `Map` but accepts `string[]` as key.
 */
var NameMap = /*#__PURE__*/function () {
  function NameMap() {
    _classCallCheck(this, NameMap);
    this.kvs = new Map();
  }
  _createClass(NameMap, [{
    key: "set",
    value: function set(key, value) {
      this.kvs.set(normalize(key), value);
    }
  }, {
    key: "get",
    value: function get(key) {
      return this.kvs.get(normalize(key));
    }
  }, {
    key: "update",
    value: function update(key, updater) {
      var origin = this.get(key);
      var next = updater(origin);
      if (!next) {
        this.delete(key);
      } else {
        this.set(key, next);
      }
    }
  }, {
    key: "delete",
    value: function _delete(key) {
      this.kvs.delete(normalize(key));
    }
    // Since we only use this in test, let simply realize this
  }, {
    key: "map",
    value: function map(callback) {
      return _toConsumableArray(this.kvs.entries()).map(function (_ref) {
        var _ref2 = slicedToArray_slicedToArray(_ref, 2),
          key = _ref2[0],
          value = _ref2[1];
        var cells = key.split(SPLIT);
        return callback({
          key: cells.map(function (cell) {
            var _cell$match = cell.match(/^([^:]*):(.*)$/),
              _cell$match2 = slicedToArray_slicedToArray(_cell$match, 3),
              type = _cell$match2[1],
              unit = _cell$match2[2];
            return type === 'number' ? Number(unit) : unit;
          }),
          value: value
        });
      });
    }
  }, {
    key: "toJSON",
    value: function toJSON() {
      var json = {};
      this.map(function (_ref3) {
        var key = _ref3.key,
          value = _ref3.value;
        json[key.join('.')] = value;
        return null;
      });
      return json;
    }
  }]);
  return NameMap;
}();
/* harmony default export */ var utils_NameMap = (NameMap);
;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/useForm.js






var useForm_excluded = ["name", "errors"];








var FormStore = /*#__PURE__*/_createClass(function FormStore(forceRootUpdate) {
  var _this = this;
  _classCallCheck(this, FormStore);
  this.formHooked = false;
  this.forceRootUpdate = void 0;
  this.subscribable = true;
  this.store = {};
  this.fieldEntities = [];
  this.initialValues = {};
  this.callbacks = {};
  this.validateMessages = null;
  this.preserve = null;
  this.lastValidatePromise = null;
  this.getForm = function () {
    return {
      getFieldValue: _this.getFieldValue,
      getFieldsValue: _this.getFieldsValue,
      getFieldError: _this.getFieldError,
      getFieldWarning: _this.getFieldWarning,
      getFieldsError: _this.getFieldsError,
      isFieldsTouched: _this.isFieldsTouched,
      isFieldTouched: _this.isFieldTouched,
      isFieldValidating: _this.isFieldValidating,
      isFieldsValidating: _this.isFieldsValidating,
      resetFields: _this.resetFields,
      setFields: _this.setFields,
      setFieldValue: _this.setFieldValue,
      setFieldsValue: _this.setFieldsValue,
      validateFields: _this.validateFields,
      submit: _this.submit,
      _init: true,
      getInternalHooks: _this.getInternalHooks
    };
  };
  this.getInternalHooks = function (key) {
    if (key === HOOK_MARK) {
      _this.formHooked = true;
      return {
        dispatch: _this.dispatch,
        initEntityValue: _this.initEntityValue,
        registerField: _this.registerField,
        useSubscribe: _this.useSubscribe,
        setInitialValues: _this.setInitialValues,
        destroyForm: _this.destroyForm,
        setCallbacks: _this.setCallbacks,
        setValidateMessages: _this.setValidateMessages,
        getFields: _this.getFields,
        setPreserve: _this.setPreserve,
        getInitialValue: _this.getInitialValue,
        registerWatch: _this.registerWatch
      };
    }
    es_warning(false, '`getInternalHooks` is internal usage. Should not call directly.');
    return null;
  };
  this.useSubscribe = function (subscribable) {
    _this.subscribable = subscribable;
  };
  this.prevWithoutPreserves = null;
  this.setInitialValues = function (initialValues, init) {
    _this.initialValues = initialValues || {};
    if (init) {
      var _this$prevWithoutPres;
      var nextStore = setValues({}, initialValues, _this.store);
      // We will take consider prev form unmount fields.
      // When the field is not `preserve`, we need fill this with initialValues instead of store.
      // eslint-disable-next-line array-callback-return
      (_this$prevWithoutPres = _this.prevWithoutPreserves) === null || _this$prevWithoutPres === void 0 ? void 0 : _this$prevWithoutPres.map(function (_ref) {
        var namePath = _ref.key;
        nextStore = setValue(nextStore, namePath, valueUtil_getValue(initialValues, namePath));
      });
      _this.prevWithoutPreserves = null;
      _this.updateStore(nextStore);
    }
  };
  this.destroyForm = function () {
    var prevWithoutPreserves = new utils_NameMap();
    _this.getFieldEntities(true).forEach(function (entity) {
      if (!_this.isMergedPreserve(entity.isPreserve())) {
        prevWithoutPreserves.set(entity.getNamePath(), true);
      }
    });
    _this.prevWithoutPreserves = prevWithoutPreserves;
  };
  this.getInitialValue = function (namePath) {
    var initValue = valueUtil_getValue(_this.initialValues, namePath);
    // Not cloneDeep when without `namePath`
    return namePath.length ? utils_cloneDeep(initValue) : initValue;
  };
  this.setCallbacks = function (callbacks) {
    _this.callbacks = callbacks;
  };
  this.setValidateMessages = function (validateMessages) {
    _this.validateMessages = validateMessages;
  };
  this.setPreserve = function (preserve) {
    _this.preserve = preserve;
  };
  this.watchList = [];
  this.registerWatch = function (callback) {
    _this.watchList.push(callback);
    return function () {
      _this.watchList = _this.watchList.filter(function (fn) {
        return fn !== callback;
      });
    };
  };
  this.notifyWatch = function () {
    var namePath = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
    // No need to cost perf when nothing need to watch
    if (_this.watchList.length) {
      var values = _this.getFieldsValue();
      _this.watchList.forEach(function (callback) {
        callback(values, namePath);
      });
    }
  };
  this.timeoutId = null;
  this.warningUnhooked = function () {
    if (false) {}
  };
  this.updateStore = function (nextStore) {
    _this.store = nextStore;
  };
  this.getFieldEntities = function () {
    var pure = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
    if (!pure) {
      return _this.fieldEntities;
    }
    return _this.fieldEntities.filter(function (field) {
      return field.getNamePath().length;
    });
  };
  this.getFieldsMap = function () {
    var pure = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
    var cache = new utils_NameMap();
    _this.getFieldEntities(pure).forEach(function (field) {
      var namePath = field.getNamePath();
      cache.set(namePath, field);
    });
    return cache;
  };
  this.getFieldEntitiesForNamePathList = function (nameList) {
    if (!nameList) {
      return _this.getFieldEntities(true);
    }
    var cache = _this.getFieldsMap(true);
    return nameList.map(function (name) {
      var namePath = getNamePath(name);
      return cache.get(namePath) || {
        INVALIDATE_NAME_PATH: getNamePath(name)
      };
    });
  };
  this.getFieldsValue = function (nameList, filterFunc) {
    _this.warningUnhooked();
    if (nameList === true && !filterFunc) {
      return _this.store;
    }
    var fieldEntities = _this.getFieldEntitiesForNamePathList(Array.isArray(nameList) ? nameList : null);
    var filteredNameList = [];
    fieldEntities.forEach(function (entity) {
      var _entity$isListField;
      var namePath = 'INVALIDATE_NAME_PATH' in entity ? entity.INVALIDATE_NAME_PATH : entity.getNamePath();
      // Ignore when it's a list item and not specific the namePath,
      // since parent field is already take in count
      if (!nameList && ((_entity$isListField = entity.isListField) === null || _entity$isListField === void 0 ? void 0 : _entity$isListField.call(entity))) {
        return;
      }
      if (!filterFunc) {
        filteredNameList.push(namePath);
      } else {
        var meta = 'getMeta' in entity ? entity.getMeta() : null;
        if (filterFunc(meta)) {
          filteredNameList.push(namePath);
        }
      }
    });
    return cloneByNamePathList(_this.store, filteredNameList.map(getNamePath));
  };
  this.getFieldValue = function (name) {
    _this.warningUnhooked();
    var namePath = getNamePath(name);
    return valueUtil_getValue(_this.store, namePath);
  };
  this.getFieldsError = function (nameList) {
    _this.warningUnhooked();
    var fieldEntities = _this.getFieldEntitiesForNamePathList(nameList);
    return fieldEntities.map(function (entity, index) {
      if (entity && !('INVALIDATE_NAME_PATH' in entity)) {
        return {
          name: entity.getNamePath(),
          errors: entity.getErrors(),
          warnings: entity.getWarnings()
        };
      }
      return {
        name: getNamePath(nameList[index]),
        errors: [],
        warnings: []
      };
    });
  };
  this.getFieldError = function (name) {
    _this.warningUnhooked();
    var namePath = getNamePath(name);
    var fieldError = _this.getFieldsError([namePath])[0];
    return fieldError.errors;
  };
  this.getFieldWarning = function (name) {
    _this.warningUnhooked();
    var namePath = getNamePath(name);
    var fieldError = _this.getFieldsError([namePath])[0];
    return fieldError.warnings;
  };
  this.isFieldsTouched = function () {
    _this.warningUnhooked();
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    var arg0 = args[0],
      arg1 = args[1];
    var namePathList;
    var isAllFieldsTouched = false;
    if (args.length === 0) {
      namePathList = null;
    } else if (args.length === 1) {
      if (Array.isArray(arg0)) {
        namePathList = arg0.map(getNamePath);
        isAllFieldsTouched = false;
      } else {
        namePathList = null;
        isAllFieldsTouched = arg0;
      }
    } else {
      namePathList = arg0.map(getNamePath);
      isAllFieldsTouched = arg1;
    }
    var fieldEntities = _this.getFieldEntities(true);
    var isFieldTouched = function isFieldTouched(field) {
      return field.isFieldTouched();
    };
    // ===== Will get fully compare when not config namePathList =====
    if (!namePathList) {
      return isAllFieldsTouched ? fieldEntities.every(isFieldTouched) : fieldEntities.some(isFieldTouched);
    }
    // Generate a nest tree for validate
    var map = new utils_NameMap();
    namePathList.forEach(function (shortNamePath) {
      map.set(shortNamePath, []);
    });
    fieldEntities.forEach(function (field) {
      var fieldNamePath = field.getNamePath();
      // Find matched entity and put into list
      namePathList.forEach(function (shortNamePath) {
        if (shortNamePath.every(function (nameUnit, i) {
          return fieldNamePath[i] === nameUnit;
        })) {
          map.update(shortNamePath, function (list) {
            return [].concat(_toConsumableArray(list), [field]);
          });
        }
      });
    });
    // Check if NameMap value is touched
    var isNamePathListTouched = function isNamePathListTouched(entities) {
      return entities.some(isFieldTouched);
    };
    var namePathListEntities = map.map(function (_ref2) {
      var value = _ref2.value;
      return value;
    });
    return isAllFieldsTouched ? namePathListEntities.every(isNamePathListTouched) : namePathListEntities.some(isNamePathListTouched);
  };
  this.isFieldTouched = function (name) {
    _this.warningUnhooked();
    return _this.isFieldsTouched([name]);
  };
  this.isFieldsValidating = function (nameList) {
    _this.warningUnhooked();
    var fieldEntities = _this.getFieldEntities();
    if (!nameList) {
      return fieldEntities.some(function (testField) {
        return testField.isFieldValidating();
      });
    }
    var namePathList = nameList.map(getNamePath);
    return fieldEntities.some(function (testField) {
      var fieldNamePath = testField.getNamePath();
      return containsNamePath(namePathList, fieldNamePath) && testField.isFieldValidating();
    });
  };
  this.isFieldValidating = function (name) {
    _this.warningUnhooked();
    return _this.isFieldsValidating([name]);
  };
  this.resetWithFieldInitialValue = function () {
    var info = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    // Create cache
    var cache = new utils_NameMap();
    var fieldEntities = _this.getFieldEntities(true);
    fieldEntities.forEach(function (field) {
      var initialValue = field.props.initialValue;
      var namePath = field.getNamePath();
      // Record only if has `initialValue`
      if (initialValue !== undefined) {
        var records = cache.get(namePath) || new Set();
        records.add({
          entity: field,
          value: initialValue
        });
        cache.set(namePath, records);
      }
    });
    // Reset
    var resetWithFields = function resetWithFields(entities) {
      entities.forEach(function (field) {
        var initialValue = field.props.initialValue;
        if (initialValue !== undefined) {
          var namePath = field.getNamePath();
          var formInitialValue = _this.getInitialValue(namePath);
          if (formInitialValue !== undefined) {
            // Warning if conflict with form initialValues and do not modify value
            es_warning(false, "Form already set 'initialValues' with path '".concat(namePath.join('.'), "'. Field can not overwrite it."));
          } else {
            var records = cache.get(namePath);
            if (records && records.size > 1) {
              // Warning if multiple field set `initialValue`and do not modify value
              es_warning(false, "Multiple Field with path '".concat(namePath.join('.'), "' set 'initialValue'. Can not decide which one to pick."));
            } else if (records) {
              var originValue = _this.getFieldValue(namePath);
              // Set `initialValue`
              if (!info.skipExist || originValue === undefined) {
                _this.updateStore(setValue(_this.store, namePath, _toConsumableArray(records)[0].value));
              }
            }
          }
        }
      });
    };
    var requiredFieldEntities;
    if (info.entities) {
      requiredFieldEntities = info.entities;
    } else if (info.namePathList) {
      requiredFieldEntities = [];
      info.namePathList.forEach(function (namePath) {
        var records = cache.get(namePath);
        if (records) {
          var _requiredFieldEntitie;
          (_requiredFieldEntitie = requiredFieldEntities).push.apply(_requiredFieldEntitie, _toConsumableArray(_toConsumableArray(records).map(function (r) {
            return r.entity;
          })));
        }
      });
    } else {
      requiredFieldEntities = fieldEntities;
    }
    resetWithFields(requiredFieldEntities);
  };
  this.resetFields = function (nameList) {
    _this.warningUnhooked();
    var prevStore = _this.store;
    if (!nameList) {
      _this.updateStore(setValues({}, _this.initialValues));
      _this.resetWithFieldInitialValue();
      _this.notifyObservers(prevStore, null, {
        type: 'reset'
      });
      _this.notifyWatch();
      return;
    }
    // Reset by `nameList`
    var namePathList = nameList.map(getNamePath);
    namePathList.forEach(function (namePath) {
      var initialValue = _this.getInitialValue(namePath);
      _this.updateStore(setValue(_this.store, namePath, initialValue));
    });
    _this.resetWithFieldInitialValue({
      namePathList: namePathList
    });
    _this.notifyObservers(prevStore, namePathList, {
      type: 'reset'
    });
    _this.notifyWatch(namePathList);
  };
  this.setFields = function (fields) {
    _this.warningUnhooked();
    var prevStore = _this.store;
    var namePathList = [];
    fields.forEach(function (fieldData) {
      var name = fieldData.name,
        errors = fieldData.errors,
        data = _objectWithoutProperties(fieldData, useForm_excluded);
      var namePath = getNamePath(name);
      namePathList.push(namePath);
      // Value
      if ('value' in data) {
        _this.updateStore(setValue(_this.store, namePath, data.value));
      }
      _this.notifyObservers(prevStore, [namePath], {
        type: 'setField',
        data: fieldData
      });
    });
    _this.notifyWatch(namePathList);
  };
  this.getFields = function () {
    var entities = _this.getFieldEntities(true);
    var fields = entities.map(function (field) {
      var namePath = field.getNamePath();
      var meta = field.getMeta();
      var fieldData = _objectSpread2(_objectSpread2({}, meta), {}, {
        name: namePath,
        value: _this.getFieldValue(namePath)
      });
      Object.defineProperty(fieldData, 'originRCField', {
        value: true
      });
      return fieldData;
    });
    return fields;
  };
  this.initEntityValue = function (entity) {
    var initialValue = entity.props.initialValue;
    if (initialValue !== undefined) {
      var namePath = entity.getNamePath();
      var prevValue = valueUtil_getValue(_this.store, namePath);
      if (prevValue === undefined) {
        _this.updateStore(setValue(_this.store, namePath, initialValue));
      }
    }
  };
  this.isMergedPreserve = function (fieldPreserve) {
    var mergedPreserve = fieldPreserve !== undefined ? fieldPreserve : _this.preserve;
    return mergedPreserve !== null && mergedPreserve !== void 0 ? mergedPreserve : true;
  };
  this.registerField = function (entity) {
    _this.fieldEntities.push(entity);
    var namePath = entity.getNamePath();
    _this.notifyWatch([namePath]);
    // Set initial values
    if (entity.props.initialValue !== undefined) {
      var prevStore = _this.store;
      _this.resetWithFieldInitialValue({
        entities: [entity],
        skipExist: true
      });
      _this.notifyObservers(prevStore, [entity.getNamePath()], {
        type: 'valueUpdate',
        source: 'internal'
      });
    }
    // un-register field callback
    return function (isListField, preserve) {
      var subNamePath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
      _this.fieldEntities = _this.fieldEntities.filter(function (item) {
        return item !== entity;
      });
      // Clean up store value if not preserve
      if (!_this.isMergedPreserve(preserve) && (!isListField || subNamePath.length > 1)) {
        var defaultValue = isListField ? undefined : _this.getInitialValue(namePath);
        if (namePath.length && _this.getFieldValue(namePath) !== defaultValue && _this.fieldEntities.every(function (field) {
          return (
            // Only reset when no namePath exist
            !matchNamePath(field.getNamePath(), namePath)
          );
        })) {
          var _prevStore = _this.store;
          _this.updateStore(setValue(_prevStore, namePath, defaultValue, true));
          // Notify that field is unmount
          _this.notifyObservers(_prevStore, [namePath], {
            type: 'remove'
          });
          // Dependencies update
          _this.triggerDependenciesUpdate(_prevStore, namePath);
        }
      }
      _this.notifyWatch([namePath]);
    };
  };
  this.dispatch = function (action) {
    switch (action.type) {
      case 'updateValue':
        {
          var namePath = action.namePath,
            value = action.value;
          _this.updateValue(namePath, value);
          break;
        }
      case 'validateField':
        {
          var _namePath = action.namePath,
            triggerName = action.triggerName;
          _this.validateFields([_namePath], {
            triggerName: triggerName
          });
          break;
        }
      default:
      // Currently we don't have other action. Do nothing.
    }
  };

  this.notifyObservers = function (prevStore, namePathList, info) {
    if (_this.subscribable) {
      var mergedInfo = _objectSpread2(_objectSpread2({}, info), {}, {
        store: _this.getFieldsValue(true)
      });
      _this.getFieldEntities().forEach(function (_ref3) {
        var onStoreChange = _ref3.onStoreChange;
        onStoreChange(prevStore, namePathList, mergedInfo);
      });
    } else {
      _this.forceRootUpdate();
    }
  };
  this.triggerDependenciesUpdate = function (prevStore, namePath) {
    var childrenFields = _this.getDependencyChildrenFields(namePath);
    if (childrenFields.length) {
      _this.validateFields(childrenFields);
    }
    _this.notifyObservers(prevStore, childrenFields, {
      type: 'dependenciesUpdate',
      relatedFields: [namePath].concat(_toConsumableArray(childrenFields))
    });
    return childrenFields;
  };
  this.updateValue = function (name, value) {
    var namePath = getNamePath(name);
    var prevStore = _this.store;
    _this.updateStore(setValue(_this.store, namePath, value));
    _this.notifyObservers(prevStore, [namePath], {
      type: 'valueUpdate',
      source: 'internal'
    });
    _this.notifyWatch([namePath]);
    // Dependencies update
    var childrenFields = _this.triggerDependenciesUpdate(prevStore, namePath);
    // trigger callback function
    var onValuesChange = _this.callbacks.onValuesChange;
    if (onValuesChange) {
      var changedValues = cloneByNamePathList(_this.store, [namePath]);
      onValuesChange(changedValues, _this.getFieldsValue());
    }
    _this.triggerOnFieldsChange([namePath].concat(_toConsumableArray(childrenFields)));
  };
  this.setFieldsValue = function (store) {
    _this.warningUnhooked();
    var prevStore = _this.store;
    if (store) {
      var nextStore = setValues(_this.store, store);
      _this.updateStore(nextStore);
    }
    _this.notifyObservers(prevStore, null, {
      type: 'valueUpdate',
      source: 'external'
    });
    _this.notifyWatch();
  };
  this.setFieldValue = function (name, value) {
    _this.setFields([{
      name: name,
      value: value
    }]);
  };
  this.getDependencyChildrenFields = function (rootNamePath) {
    var children = new Set();
    var childrenFields = [];
    var dependencies2fields = new utils_NameMap();
    /**
     * Generate maps
     * Can use cache to save perf if user report performance issue with this
     */
    _this.getFieldEntities().forEach(function (field) {
      var dependencies = field.props.dependencies;
      (dependencies || []).forEach(function (dependency) {
        var dependencyNamePath = getNamePath(dependency);
        dependencies2fields.update(dependencyNamePath, function () {
          var fields = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Set();
          fields.add(field);
          return fields;
        });
      });
    });
    var fillChildren = function fillChildren(namePath) {
      var fields = dependencies2fields.get(namePath) || new Set();
      fields.forEach(function (field) {
        if (!children.has(field)) {
          children.add(field);
          var fieldNamePath = field.getNamePath();
          if (field.isFieldDirty() && fieldNamePath.length) {
            childrenFields.push(fieldNamePath);
            fillChildren(fieldNamePath);
          }
        }
      });
    };
    fillChildren(rootNamePath);
    return childrenFields;
  };
  this.triggerOnFieldsChange = function (namePathList, filedErrors) {
    var onFieldsChange = _this.callbacks.onFieldsChange;
    if (onFieldsChange) {
      var fields = _this.getFields();
      /**
       * Fill errors since `fields` may be replaced by controlled fields
       */
      if (filedErrors) {
        var cache = new utils_NameMap();
        filedErrors.forEach(function (_ref4) {
          var name = _ref4.name,
            errors = _ref4.errors;
          cache.set(name, errors);
        });
        fields.forEach(function (field) {
          // eslint-disable-next-line no-param-reassign
          field.errors = cache.get(field.name) || field.errors;
        });
      }
      var changedFields = fields.filter(function (_ref5) {
        var fieldName = _ref5.name;
        return containsNamePath(namePathList, fieldName);
      });
      onFieldsChange(changedFields, fields);
    }
  };
  this.validateFields = function (nameList, options) {
    _this.warningUnhooked();
    var provideNameList = !!nameList;
    var namePathList = provideNameList ? nameList.map(getNamePath) : [];
    // Collect result in promise list
    var promiseList = [];
    _this.getFieldEntities(true).forEach(function (field) {
      // Add field if not provide `nameList`
      if (!provideNameList) {
        namePathList.push(field.getNamePath());
      }
      /**
       * Recursive validate if configured.
       * TODO: perf improvement @zombieJ
       */
      if ((options === null || options === void 0 ? void 0 : options.recursive) && provideNameList) {
        var namePath = field.getNamePath();
        if (
        // nameList[i] === undefined 说明是以 nameList 开头的
        // ['name'] -> ['name','list']
        namePath.every(function (nameUnit, i) {
          return nameList[i] === nameUnit || nameList[i] === undefined;
        })) {
          namePathList.push(namePath);
        }
      }
      // Skip if without rule
      if (!field.props.rules || !field.props.rules.length) {
        return;
      }
      var fieldNamePath = field.getNamePath();
      // Add field validate rule in to promise list
      if (!provideNameList || containsNamePath(namePathList, fieldNamePath)) {
        var promise = field.validateRules(_objectSpread2({
          validateMessages: _objectSpread2(_objectSpread2({}, defaultValidateMessages), _this.validateMessages)
        }, options));
        // Wrap promise with field
        promiseList.push(promise.then(function () {
          return {
            name: fieldNamePath,
            errors: [],
            warnings: []
          };
        }).catch(function (ruleErrors) {
          var _ruleErrors$forEach;
          var mergedErrors = [];
          var mergedWarnings = [];
          (_ruleErrors$forEach = ruleErrors.forEach) === null || _ruleErrors$forEach === void 0 ? void 0 : _ruleErrors$forEach.call(ruleErrors, function (_ref6) {
            var warningOnly = _ref6.rule.warningOnly,
              errors = _ref6.errors;
            if (warningOnly) {
              mergedWarnings.push.apply(mergedWarnings, _toConsumableArray(errors));
            } else {
              mergedErrors.push.apply(mergedErrors, _toConsumableArray(errors));
            }
          });
          if (mergedErrors.length) {
            return Promise.reject({
              name: fieldNamePath,
              errors: mergedErrors,
              warnings: mergedWarnings
            });
          }
          return {
            name: fieldNamePath,
            errors: mergedErrors,
            warnings: mergedWarnings
          };
        }));
      }
    });
    var summaryPromise = allPromiseFinish(promiseList);
    _this.lastValidatePromise = summaryPromise;
    // Notify fields with rule that validate has finished and need update
    summaryPromise.catch(function (results) {
      return results;
    }).then(function (results) {
      var resultNamePathList = results.map(function (_ref7) {
        var name = _ref7.name;
        return name;
      });
      _this.notifyObservers(_this.store, resultNamePathList, {
        type: 'validateFinish'
      });
      _this.triggerOnFieldsChange(resultNamePathList, results);
    });
    var returnPromise = summaryPromise.then(function () {
      if (_this.lastValidatePromise === summaryPromise) {
        return Promise.resolve(_this.getFieldsValue(namePathList));
      }
      return Promise.reject([]);
    }).catch(function (results) {
      var errorList = results.filter(function (result) {
        return result && result.errors.length;
      });
      return Promise.reject({
        values: _this.getFieldsValue(namePathList),
        errorFields: errorList,
        outOfDate: _this.lastValidatePromise !== summaryPromise
      });
    });
    // Do not throw in console
    returnPromise.catch(function (e) {
      return e;
    });
    return returnPromise;
  };
  this.submit = function () {
    _this.warningUnhooked();
    _this.validateFields().then(function (values) {
      var onFinish = _this.callbacks.onFinish;
      if (onFinish) {
        try {
          onFinish(values);
        } catch (err) {
          // Should print error if user `onFinish` callback failed
          console.error(err);
        }
      }
    }).catch(function (e) {
      var onFinishFailed = _this.callbacks.onFinishFailed;
      if (onFinishFailed) {
        onFinishFailed(e);
      }
    });
  };
  this.forceRootUpdate = forceRootUpdate;
});
function useForm(form) {
  var formRef = _react_18_2_0_react.useRef();
  var _React$useState = _react_18_2_0_react.useState({}),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 2),
    forceUpdate = _React$useState2[1];
  if (!formRef.current) {
    if (form) {
      formRef.current = form;
    } else {
      // Create a new FormStore if not provided
      var forceReRender = function forceReRender() {
        forceUpdate({});
      };
      var formStore = new FormStore(forceReRender);
      formRef.current = formStore.getForm();
    }
  }
  return [formRef.current];
}
/* harmony default export */ var es_useForm = (useForm);
;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/FormContext.js



var FormContext = /*#__PURE__*/_react_18_2_0_react.createContext({
  triggerFormChange: function triggerFormChange() {},
  triggerFormFinish: function triggerFormFinish() {},
  registerForm: function registerForm() {},
  unregisterForm: function unregisterForm() {}
});
var FormProvider = function FormProvider(_ref) {
  var validateMessages = _ref.validateMessages,
    onFormChange = _ref.onFormChange,
    onFormFinish = _ref.onFormFinish,
    children = _ref.children;
  var formContext = _react_18_2_0_react.useContext(FormContext);
  var formsRef = _react_18_2_0_react.useRef({});
  return /*#__PURE__*/_react_18_2_0_react.createElement(FormContext.Provider, {
    value: _objectSpread2(_objectSpread2({}, formContext), {}, {
      validateMessages: _objectSpread2(_objectSpread2({}, formContext.validateMessages), validateMessages),
      // =========================================================
      // =                  Global Form Control                  =
      // =========================================================
      triggerFormChange: function triggerFormChange(name, changedFields) {
        if (onFormChange) {
          onFormChange(name, {
            changedFields: changedFields,
            forms: formsRef.current
          });
        }
        formContext.triggerFormChange(name, changedFields);
      },
      triggerFormFinish: function triggerFormFinish(name, values) {
        if (onFormFinish) {
          onFormFinish(name, {
            values: values,
            forms: formsRef.current
          });
        }
        formContext.triggerFormFinish(name, values);
      },
      registerForm: function registerForm(name, form) {
        if (name) {
          formsRef.current = _objectSpread2(_objectSpread2({}, formsRef.current), {}, defineProperty_defineProperty({}, name, form));
        }
        formContext.registerForm(name, form);
      },
      unregisterForm: function unregisterForm(name) {
        var newForms = _objectSpread2({}, formsRef.current);
        delete newForms[name];
        formsRef.current = newForms;
        formContext.unregisterForm(name);
      }
    })
  }, children);
};

/* harmony default export */ var es_FormContext = (FormContext);
;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/Form.js




var Form_excluded = ["name", "initialValues", "fields", "form", "preserve", "children", "component", "validateMessages", "validateTrigger", "onValuesChange", "onFieldsChange", "onFinish", "onFinishFailed"];





var Form_Form = function Form(_ref, ref) {
  var name = _ref.name,
    initialValues = _ref.initialValues,
    fields = _ref.fields,
    form = _ref.form,
    preserve = _ref.preserve,
    children = _ref.children,
    _ref$component = _ref.component,
    Component = _ref$component === void 0 ? 'form' : _ref$component,
    validateMessages = _ref.validateMessages,
    _ref$validateTrigger = _ref.validateTrigger,
    validateTrigger = _ref$validateTrigger === void 0 ? 'onChange' : _ref$validateTrigger,
    onValuesChange = _ref.onValuesChange,
    _onFieldsChange = _ref.onFieldsChange,
    _onFinish = _ref.onFinish,
    onFinishFailed = _ref.onFinishFailed,
    restProps = _objectWithoutProperties(_ref, Form_excluded);
  var formContext = _react_18_2_0_react.useContext(es_FormContext);
  // We customize handle event since Context will makes all the consumer re-render:
  // https://reactjs.org/docs/context.html#contextprovider
  var _useForm = es_useForm(form),
    _useForm2 = slicedToArray_slicedToArray(_useForm, 1),
    formInstance = _useForm2[0];
  var _formInstance$getInte = formInstance.getInternalHooks(HOOK_MARK),
    useSubscribe = _formInstance$getInte.useSubscribe,
    setInitialValues = _formInstance$getInte.setInitialValues,
    setCallbacks = _formInstance$getInte.setCallbacks,
    setValidateMessages = _formInstance$getInte.setValidateMessages,
    setPreserve = _formInstance$getInte.setPreserve,
    destroyForm = _formInstance$getInte.destroyForm;
  // Pass ref with form instance
  _react_18_2_0_react.useImperativeHandle(ref, function () {
    return formInstance;
  });
  // Register form into Context
  _react_18_2_0_react.useEffect(function () {
    formContext.registerForm(name, formInstance);
    return function () {
      formContext.unregisterForm(name);
    };
  }, [formContext, formInstance, name]);
  // Pass props to store
  setValidateMessages(_objectSpread2(_objectSpread2({}, formContext.validateMessages), validateMessages));
  setCallbacks({
    onValuesChange: onValuesChange,
    onFieldsChange: function onFieldsChange(changedFields) {
      formContext.triggerFormChange(name, changedFields);
      if (_onFieldsChange) {
        for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          rest[_key - 1] = arguments[_key];
        }
        _onFieldsChange.apply(void 0, [changedFields].concat(rest));
      }
    },
    onFinish: function onFinish(values) {
      formContext.triggerFormFinish(name, values);
      if (_onFinish) {
        _onFinish(values);
      }
    },
    onFinishFailed: onFinishFailed
  });
  setPreserve(preserve);
  // Set initial value, init store value when first mount
  var mountRef = _react_18_2_0_react.useRef(null);
  setInitialValues(initialValues, !mountRef.current);
  if (!mountRef.current) {
    mountRef.current = true;
  }
  _react_18_2_0_react.useEffect(function () {
    return destroyForm;
  },
  // eslint-disable-next-line react-hooks/exhaustive-deps
  []);
  // Prepare children by `children` type
  var childrenNode;
  var childrenRenderProps = typeof children === 'function';
  if (childrenRenderProps) {
    var values = formInstance.getFieldsValue(true);
    childrenNode = children(values, formInstance);
  } else {
    childrenNode = children;
  }
  // Not use subscribe when using render props
  useSubscribe(!childrenRenderProps);
  // Listen if fields provided. We use ref to save prev data here to avoid additional render
  var prevFieldsRef = _react_18_2_0_react.useRef();
  _react_18_2_0_react.useEffect(function () {
    if (!isSimilar(prevFieldsRef.current || [], fields || [])) {
      formInstance.setFields(fields || []);
    }
    prevFieldsRef.current = fields;
  }, [fields, formInstance]);
  var formContextValue = _react_18_2_0_react.useMemo(function () {
    return _objectSpread2(_objectSpread2({}, formInstance), {}, {
      validateTrigger: validateTrigger
    });
  }, [formInstance, validateTrigger]);
  var wrapperNode = /*#__PURE__*/_react_18_2_0_react.createElement(FieldContext.Provider, {
    value: formContextValue
  }, childrenNode);
  if (Component === false) {
    return wrapperNode;
  }
  return /*#__PURE__*/_react_18_2_0_react.createElement(Component, extends_extends({}, restProps, {
    onSubmit: function onSubmit(event) {
      event.preventDefault();
      event.stopPropagation();
      formInstance.submit();
    },
    onReset: function onReset(event) {
      var _restProps$onReset;
      event.preventDefault();
      formInstance.resetFields();
      (_restProps$onReset = restProps.onReset) === null || _restProps$onReset === void 0 ? void 0 : _restProps$onReset.call(restProps, event);
    }
  }), wrapperNode);
};
/* harmony default export */ var es_Form = (Form_Form);
;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/useWatch.js






function stringify(value) {
  try {
    return JSON.stringify(value);
  } catch (err) {
    return Math.random();
  }
}
var useWatchWarning =  false ? 0 : function () {};
function useWatch() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }
  var _args$ = args[0],
    dependencies = _args$ === void 0 ? [] : _args$,
    form = args[1];
  var _useState = (0,_react_18_2_0_react.useState)(),
    _useState2 = slicedToArray_slicedToArray(_useState, 2),
    value = _useState2[0],
    setValue = _useState2[1];
  var valueStr = (0,_react_18_2_0_react.useMemo)(function () {
    return stringify(value);
  }, [value]);
  var valueStrRef = (0,_react_18_2_0_react.useRef)(valueStr);
  valueStrRef.current = valueStr;
  var fieldContext = (0,_react_18_2_0_react.useContext)(FieldContext);
  var formInstance = form || fieldContext;
  var isValidForm = formInstance && formInstance._init;
  // Warning if not exist form instance
  if (false) {}
  var namePath = getNamePath(dependencies);
  var namePathRef = (0,_react_18_2_0_react.useRef)(namePath);
  namePathRef.current = namePath;
  useWatchWarning(namePath);
  (0,_react_18_2_0_react.useEffect)(function () {
    // Skip if not exist form instance
    if (!isValidForm) {
      return;
    }
    var getFieldsValue = formInstance.getFieldsValue,
      getInternalHooks = formInstance.getInternalHooks;
    var _getInternalHooks = getInternalHooks(HOOK_MARK),
      registerWatch = _getInternalHooks.registerWatch;
    var cancelRegister = registerWatch(function (store) {
      var newValue = valueUtil_getValue(store, namePathRef.current);
      var nextValueStr = stringify(newValue);
      // Compare stringify in case it's nest object
      if (valueStrRef.current !== nextValueStr) {
        valueStrRef.current = nextValueStr;
        setValue(newValue);
      }
    });
    // TODO: We can improve this perf in future
    var initialValue = valueUtil_getValue(getFieldsValue(), namePathRef.current);
    setValue(initialValue);
    return cancelRegister;
  },
  // We do not need re-register since namePath content is the same
  // eslint-disable-next-line react-hooks/exhaustive-deps
  [isValidForm]);
  return value;
}
/* harmony default export */ var es_useWatch = (useWatch);
;// CONCATENATED MODULE: ./node_modules/_rc-field-form@1.27.4@rc-field-form/es/index.js









var InternalForm = /*#__PURE__*/_react_18_2_0_react.forwardRef(es_Form);
var RefForm = InternalForm;
RefForm.FormProvider = FormProvider;
RefForm.Field = es_Field;
RefForm.List = es_List;
RefForm.useForm = es_useForm;
RefForm.useWatch = es_useWatch;

/* harmony default export */ var es = ((/* unused pure expression or super */ null && (RefForm)));
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/hooks/useMemo.js

function useMemo_useMemo(getValue, condition, shouldUpdate) {
  var cacheRef = _react_18_2_0_react.useRef({});
  if (!('value' in cacheRef.current) || shouldUpdate(cacheRef.current.condition, condition)) {
    cacheRef.current.value = getValue();
    cacheRef.current.condition = condition;
  }
  return cacheRef.current.value;
}
;// CONCATENATED MODULE: ./node_modules/_rc-pagination@3.2.0@rc-pagination/es/locale/en_US.js
/* harmony default export */ var en_US = ({
  // Options.jsx
  items_per_page: '/ page',
  jump_to: 'Go to',
  jump_to_confirm: 'confirm',
  page: 'Page',
  // Pagination.jsx
  prev_page: 'Previous Page',
  next_page: 'Next Page',
  prev_5: 'Previous 5 Pages',
  next_5: 'Next 5 Pages',
  prev_3: 'Previous 3 Pages',
  next_3: 'Next 3 Pages',
  page_size: 'Page Size'
});
;// CONCATENATED MODULE: ./node_modules/_rc-picker@2.7.0@rc-picker/es/locale/en_US.js
var locale = {
  locale: 'en_US',
  today: 'Today',
  now: 'Now',
  backToToday: 'Back to today',
  ok: 'OK',
  clear: 'Clear',
  month: 'Month',
  year: 'Year',
  timeSelect: 'select time',
  dateSelect: 'select date',
  weekSelect: 'Choose a week',
  monthSelect: 'Choose a month',
  yearSelect: 'Choose a year',
  decadeSelect: 'Choose a decade',
  yearFormat: 'YYYY',
  dateFormat: 'M/D/YYYY',
  dayFormat: 'D',
  dateTimeFormat: 'M/D/YYYY HH:mm:ss',
  monthBeforeYear: true,
  previousMonth: 'Previous month (PageUp)',
  nextMonth: 'Next month (PageDown)',
  previousYear: 'Last year (Control + left)',
  nextYear: 'Next year (Control + right)',
  previousDecade: 'Last decade',
  nextDecade: 'Next decade',
  previousCentury: 'Last century',
  nextCentury: 'Next century'
};
/* harmony default export */ var locale_en_US = (locale);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/time-picker/locale/en_US.js
var en_US_locale = {
  placeholder: 'Select time',
  rangePlaceholder: ['Start time', 'End time']
};
/* harmony default export */ var time_picker_locale_en_US = (en_US_locale);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/date-picker/locale/en_US.js



// Merge into a locale object
var locale_en_US_locale = {
  lang: extends_extends({
    placeholder: 'Select date',
    yearPlaceholder: 'Select year',
    quarterPlaceholder: 'Select quarter',
    monthPlaceholder: 'Select month',
    weekPlaceholder: 'Select week',
    rangePlaceholder: ['Start date', 'End date'],
    rangeYearPlaceholder: ['Start year', 'End year'],
    rangeQuarterPlaceholder: ['Start quarter', 'End quarter'],
    rangeMonthPlaceholder: ['Start month', 'End month'],
    rangeWeekPlaceholder: ['Start week', 'End week']
  }, locale_en_US),
  timePickerLocale: extends_extends({}, time_picker_locale_en_US)
};
// All settings at:
// https://github.com/ant-design/ant-design/blob/master/components/date-picker/locale/example.json
/* harmony default export */ var date_picker_locale_en_US = (locale_en_US_locale);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/calendar/locale/en_US.js

/* harmony default export */ var calendar_locale_en_US = (date_picker_locale_en_US);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/locale/default.js
/* eslint-disable no-template-curly-in-string */




var default_typeTemplate = '${label} is not a valid ${type}';
var localeValues = {
  locale: 'en',
  Pagination: en_US,
  DatePicker: date_picker_locale_en_US,
  TimePicker: time_picker_locale_en_US,
  Calendar: calendar_locale_en_US,
  global: {
    placeholder: 'Please select'
  },
  Table: {
    filterTitle: 'Filter menu',
    filterConfirm: 'OK',
    filterReset: 'Reset',
    filterEmptyText: 'No filters',
    filterCheckall: 'Select all items',
    filterSearchPlaceholder: 'Search in filters',
    emptyText: 'No data',
    selectAll: 'Select current page',
    selectInvert: 'Invert current page',
    selectNone: 'Clear all data',
    selectionAll: 'Select all data',
    sortTitle: 'Sort',
    expand: 'Expand row',
    collapse: 'Collapse row',
    triggerDesc: 'Click to sort descending',
    triggerAsc: 'Click to sort ascending',
    cancelSort: 'Click to cancel sorting'
  },
  Modal: {
    okText: 'OK',
    cancelText: 'Cancel',
    justOkText: 'OK'
  },
  Popconfirm: {
    okText: 'OK',
    cancelText: 'Cancel'
  },
  Transfer: {
    titles: ['', ''],
    searchPlaceholder: 'Search here',
    itemUnit: 'item',
    itemsUnit: 'items',
    remove: 'Remove',
    selectCurrent: 'Select current page',
    removeCurrent: 'Remove current page',
    selectAll: 'Select all data',
    removeAll: 'Remove all data',
    selectInvert: 'Invert current page'
  },
  Upload: {
    uploading: 'Uploading...',
    removeFile: 'Remove file',
    uploadError: 'Upload error',
    previewFile: 'Preview file',
    downloadFile: 'Download file'
  },
  Empty: {
    description: 'No data'
  },
  Icon: {
    icon: 'icon'
  },
  Text: {
    edit: 'Edit',
    copy: 'Copy',
    copied: 'Copied',
    expand: 'Expand'
  },
  PageHeader: {
    back: 'Back'
  },
  Form: {
    optional: '(optional)',
    defaultValidateMessages: {
      "default": 'Field validation error for ${label}',
      required: 'Please enter ${label}',
      "enum": '${label} must be one of [${enum}]',
      whitespace: '${label} cannot be a blank character',
      date: {
        format: '${label} date format is invalid',
        parse: '${label} cannot be converted to a date',
        invalid: '${label} is an invalid date'
      },
      types: {
        string: default_typeTemplate,
        method: default_typeTemplate,
        array: default_typeTemplate,
        object: default_typeTemplate,
        number: default_typeTemplate,
        date: default_typeTemplate,
        "boolean": default_typeTemplate,
        integer: default_typeTemplate,
        "float": default_typeTemplate,
        regexp: default_typeTemplate,
        email: default_typeTemplate,
        url: default_typeTemplate,
        hex: default_typeTemplate
      },
      string: {
        len: '${label} must be ${len} characters',
        min: '${label} must be at least ${min} characters',
        max: '${label} must be up to ${max} characters',
        range: '${label} must be between ${min}-${max} characters'
      },
      number: {
        len: '${label} must be equal to ${len}',
        min: '${label} must be minimum ${min}',
        max: '${label} must be maximum ${max}',
        range: '${label} must be between ${min}-${max}'
      },
      array: {
        len: 'Must be ${len} ${label}',
        min: 'At least ${min} ${label}',
        max: 'At most ${max} ${label}',
        range: 'The amount of ${label} must be between ${min}-${max}'
      },
      pattern: {
        mismatch: '${label} does not match the pattern ${pattern}'
      }
    }
  },
  Image: {
    preview: 'Preview'
  }
};
/* harmony default export */ var locale_default = (localeValues);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/modal/locale.js


var runtimeLocale = extends_extends({}, locale_default.Modal);
function changeConfirmLocale(newLocale) {
  if (newLocale) {
    runtimeLocale = extends_extends(extends_extends({}, runtimeLocale), newLocale);
  } else {
    runtimeLocale = extends_extends({}, locale_default.Modal);
  }
}
function getConfirmLocale() {
  return runtimeLocale;
}
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/locale-provider/context.js

var context_LocaleContext = /*#__PURE__*/(0,_react_18_2_0_react.createContext)(undefined);
/* harmony default export */ var context = (context_LocaleContext);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/locale-provider/index.js





var ANT_MARK = 'internalMark';
var LocaleProvider = function LocaleProvider(props) {
  var _props$locale = props.locale,
    locale = _props$locale === void 0 ? {} : _props$locale,
    children = props.children,
    _ANT_MARK__ = props._ANT_MARK__;
  if (false) {}
  _react_18_2_0_react.useEffect(function () {
    changeConfirmLocale(locale && locale.Modal);
    return function () {
      changeConfirmLocale();
    };
  }, [locale]);
  var getMemoizedContextValue = _react_18_2_0_react.useMemo(function () {
    return extends_extends(extends_extends({}, locale), {
      exist: true
    });
  }, [locale]);
  return /*#__PURE__*/_react_18_2_0_react.createElement(context.Provider, {
    value: getMemoizedContextValue
  }, children);
};
/* harmony default export */ var locale_provider = (LocaleProvider);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/locale-provider/default.js

/* harmony default export */ var locale_provider_default = (locale_default);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/locale-provider/LocaleReceiver.js




var LocaleReceiver = function LocaleReceiver(props) {
  var _props$componentName = props.componentName,
    componentName = _props$componentName === void 0 ? 'global' : _props$componentName,
    defaultLocale = props.defaultLocale,
    children = props.children;
  var antLocale = _react_18_2_0_react.useContext(context);
  var getLocale = _react_18_2_0_react.useMemo(function () {
    var _a;
    var locale = defaultLocale || locale_provider_default[componentName];
    var localeFromContext = (_a = antLocale === null || antLocale === void 0 ? void 0 : antLocale[componentName]) !== null && _a !== void 0 ? _a : {};
    return extends_extends(extends_extends({}, locale instanceof Function ? locale() : locale), localeFromContext || {});
  }, [componentName, defaultLocale, antLocale]);
  var getLocaleCode = _react_18_2_0_react.useMemo(function () {
    var localeCode = antLocale && antLocale.locale;
    // Had use LocaleProvide but didn't set locale
    if (antLocale && antLocale.exist && !localeCode) {
      return locale_provider_default.locale;
    }
    return localeCode;
  }, [antLocale]);
  return children(getLocale, getLocaleCode, antLocale);
};
/* harmony default export */ var locale_provider_LocaleReceiver = (LocaleReceiver);
var useLocaleReceiver = function useLocaleReceiver(componentName, defaultLocale) {
  var antLocale = React.useContext(LocaleContext);
  var getLocale = React.useMemo(function () {
    var _a;
    var locale = defaultLocale || defaultLocaleData[componentName];
    var localeFromContext = (_a = antLocale === null || antLocale === void 0 ? void 0 : antLocale[componentName]) !== null && _a !== void 0 ? _a : {};
    return _extends(_extends({}, typeof locale === 'function' ? locale() : locale), localeFromContext || {});
  }, [componentName, defaultLocale, antLocale]);
  return [getLocale];
};
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons-svg@4.2.1@@ant-design/icons-svg/es/asn/CheckCircleFilled.js
// This icon file is generated automatically.
var CheckCircleFilled = {
  "icon": {
    "tag": "svg",
    "attrs": {
      "viewBox": "64 64 896 896",
      "focusable": "false"
    },
    "children": [{
      "tag": "path",
      "attrs": {
        "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm193.5 301.7l-210.6 292a31.8 31.8 0 01-51.7 0L318.5 484.9c-3.8-5.3 0-12.7 6.5-12.7h46.9c10.2 0 19.9 4.9 25.9 13.3l71.2 98.8 157.2-218c6-8.3 15.6-13.3 25.9-13.3H699c6.5 0 10.3 7.4 6.5 12.7z"
      }
    }]
  },
  "name": "check-circle",
  "theme": "filled"
};
/* harmony default export */ var asn_CheckCircleFilled = (CheckCircleFilled);
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons@4.8.0@@ant-design/icons/es/icons/CheckCircleFilled.js

// GENERATE BY ./scripts/generate.ts
// DON NOT EDIT IT MANUALLY



var CheckCircleFilled_CheckCircleFilled = function CheckCircleFilled(props, ref) {
  return /*#__PURE__*/_react_18_2_0_react.createElement(AntdIcon, _objectSpread2(_objectSpread2({}, props), {}, {
    ref: ref,
    icon: asn_CheckCircleFilled
  }));
};
CheckCircleFilled_CheckCircleFilled.displayName = 'CheckCircleFilled';
/* harmony default export */ var icons_CheckCircleFilled = (/*#__PURE__*/_react_18_2_0_react.forwardRef(CheckCircleFilled_CheckCircleFilled));
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons-svg@4.2.1@@ant-design/icons-svg/es/asn/CloseCircleFilled.js
// This icon file is generated automatically.
var CloseCircleFilled = {
  "icon": {
    "tag": "svg",
    "attrs": {
      "viewBox": "64 64 896 896",
      "focusable": "false"
    },
    "children": [{
      "tag": "path",
      "attrs": {
        "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm165.4 618.2l-66-.3L512 563.4l-99.3 118.4-66.1.3c-4.4 0-8-3.5-8-8 0-1.9.7-3.7 1.9-5.2l130.1-155L340.5 359a8.32 8.32 0 01-1.9-5.2c0-4.4 3.6-8 8-8l66.1.3L512 464.6l99.3-118.4 66-.3c4.4 0 8 3.5 8 8 0 1.9-.7 3.7-1.9 5.2L553.5 514l130 155c1.2 1.5 1.9 3.3 1.9 5.2 0 4.4-3.6 8-8 8z"
      }
    }]
  },
  "name": "close-circle",
  "theme": "filled"
};
/* harmony default export */ var asn_CloseCircleFilled = (CloseCircleFilled);
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons@4.8.0@@ant-design/icons/es/icons/CloseCircleFilled.js

// GENERATE BY ./scripts/generate.ts
// DON NOT EDIT IT MANUALLY



var CloseCircleFilled_CloseCircleFilled = function CloseCircleFilled(props, ref) {
  return /*#__PURE__*/_react_18_2_0_react.createElement(AntdIcon, _objectSpread2(_objectSpread2({}, props), {}, {
    ref: ref,
    icon: asn_CloseCircleFilled
  }));
};
CloseCircleFilled_CloseCircleFilled.displayName = 'CloseCircleFilled';
/* harmony default export */ var icons_CloseCircleFilled = (/*#__PURE__*/_react_18_2_0_react.forwardRef(CloseCircleFilled_CloseCircleFilled));
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons-svg@4.2.1@@ant-design/icons-svg/es/asn/ExclamationCircleFilled.js
// This icon file is generated automatically.
var ExclamationCircleFilled = {
  "icon": {
    "tag": "svg",
    "attrs": {
      "viewBox": "64 64 896 896",
      "focusable": "false"
    },
    "children": [{
      "tag": "path",
      "attrs": {
        "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm-32 232c0-4.4 3.6-8 8-8h48c4.4 0 8 3.6 8 8v272c0 4.4-3.6 8-8 8h-48c-4.4 0-8-3.6-8-8V296zm32 440a48.01 48.01 0 010-96 48.01 48.01 0 010 96z"
      }
    }]
  },
  "name": "exclamation-circle",
  "theme": "filled"
};
/* harmony default export */ var asn_ExclamationCircleFilled = (ExclamationCircleFilled);
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons@4.8.0@@ant-design/icons/es/icons/ExclamationCircleFilled.js

// GENERATE BY ./scripts/generate.ts
// DON NOT EDIT IT MANUALLY



var ExclamationCircleFilled_ExclamationCircleFilled = function ExclamationCircleFilled(props, ref) {
  return /*#__PURE__*/_react_18_2_0_react.createElement(AntdIcon, _objectSpread2(_objectSpread2({}, props), {}, {
    ref: ref,
    icon: asn_ExclamationCircleFilled
  }));
};
ExclamationCircleFilled_ExclamationCircleFilled.displayName = 'ExclamationCircleFilled';
/* harmony default export */ var icons_ExclamationCircleFilled = (/*#__PURE__*/_react_18_2_0_react.forwardRef(ExclamationCircleFilled_ExclamationCircleFilled));
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons-svg@4.2.1@@ant-design/icons-svg/es/asn/InfoCircleFilled.js
// This icon file is generated automatically.
var InfoCircleFilled = {
  "icon": {
    "tag": "svg",
    "attrs": {
      "viewBox": "64 64 896 896",
      "focusable": "false"
    },
    "children": [{
      "tag": "path",
      "attrs": {
        "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm32 664c0 4.4-3.6 8-8 8h-48c-4.4 0-8-3.6-8-8V456c0-4.4 3.6-8 8-8h48c4.4 0 8 3.6 8 8v272zm-32-344a48.01 48.01 0 010-96 48.01 48.01 0 010 96z"
      }
    }]
  },
  "name": "info-circle",
  "theme": "filled"
};
/* harmony default export */ var asn_InfoCircleFilled = (InfoCircleFilled);
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons@4.8.0@@ant-design/icons/es/icons/InfoCircleFilled.js

// GENERATE BY ./scripts/generate.ts
// DON NOT EDIT IT MANUALLY



var InfoCircleFilled_InfoCircleFilled = function InfoCircleFilled(props, ref) {
  return /*#__PURE__*/_react_18_2_0_react.createElement(AntdIcon, _objectSpread2(_objectSpread2({}, props), {}, {
    ref: ref,
    icon: asn_InfoCircleFilled
  }));
};
InfoCircleFilled_InfoCircleFilled.displayName = 'InfoCircleFilled';
/* harmony default export */ var icons_InfoCircleFilled = (/*#__PURE__*/_react_18_2_0_react.forwardRef(InfoCircleFilled_InfoCircleFilled));
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons-svg@4.2.1@@ant-design/icons-svg/es/asn/LoadingOutlined.js
// This icon file is generated automatically.
var LoadingOutlined = {
  "icon": {
    "tag": "svg",
    "attrs": {
      "viewBox": "0 0 1024 1024",
      "focusable": "false"
    },
    "children": [{
      "tag": "path",
      "attrs": {
        "d": "M988 548c-19.9 0-36-16.1-36-36 0-59.4-11.6-117-34.6-171.3a440.45 440.45 0 00-94.3-139.9 437.71 437.71 0 00-139.9-94.3C629 83.6 571.4 72 512 72c-19.9 0-36-16.1-36-36s16.1-36 36-36c69.1 0 136.2 13.5 199.3 40.3C772.3 66 827 103 874 150c47 47 83.9 101.8 109.7 162.7 26.7 63.1 40.2 130.2 40.2 199.3.1 19.9-16 36-35.9 36z"
      }
    }]
  },
  "name": "loading",
  "theme": "outlined"
};
/* harmony default export */ var asn_LoadingOutlined = (LoadingOutlined);
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons@4.8.0@@ant-design/icons/es/icons/LoadingOutlined.js

// GENERATE BY ./scripts/generate.ts
// DON NOT EDIT IT MANUALLY



var LoadingOutlined_LoadingOutlined = function LoadingOutlined(props, ref) {
  return /*#__PURE__*/_react_18_2_0_react.createElement(AntdIcon, _objectSpread2(_objectSpread2({}, props), {}, {
    ref: ref,
    icon: asn_LoadingOutlined
  }));
};
LoadingOutlined_LoadingOutlined.displayName = 'LoadingOutlined';
/* harmony default export */ var icons_LoadingOutlined = (/*#__PURE__*/_react_18_2_0_react.forwardRef(LoadingOutlined_LoadingOutlined));
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/Dom/findDOMNode.js


function isDOM(node) {
  // https://developer.mozilla.org/en-US/docs/Web/API/Element
  // Since XULElement is also subclass of Element, we only need HTMLElement and SVGElement
  return node instanceof HTMLElement || node instanceof SVGElement;
}

/**
 * Return if a node is a DOM node. Else will return by `findDOMNode`
 */
function findDOMNode(node) {
  if (isDOM(node)) {
    return node;
  }
  if (node instanceof _react_18_2_0_react.Component) {
    return _react_dom_18_2_0_react_dom.findDOMNode(node);
  }
  return null;
}
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/ref.js

/* eslint-disable no-param-reassign */



function fillRef(ref, node) {
  if (typeof ref === 'function') {
    ref(node);
  } else if (_typeof(ref) === 'object' && ref && 'current' in ref) {
    ref.current = node;
  }
}

/**
 * Merge refs into one ref function to support ref passing.
 */
function composeRef() {
  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
    refs[_key] = arguments[_key];
  }
  var refList = refs.filter(function (ref) {
    return ref;
  });
  if (refList.length <= 1) {
    return refList[0];
  }
  return function (node) {
    refs.forEach(function (ref) {
      fillRef(ref, node);
    });
  };
}
function useComposeRef() {
  for (var _len2 = arguments.length, refs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
    refs[_key2] = arguments[_key2];
  }
  return useMemo_useMemo(function () {
    return composeRef.apply(void 0, refs);
  }, refs, function (prev, next) {
    return prev.length === next.length && prev.every(function (ref, i) {
      return ref === next[i];
    });
  });
}
function supportRef(nodeOrComponent) {
  var _type$prototype, _nodeOrComponent$prot;
  var type = (0,_react_is_16_13_1_react_is.isMemo)(nodeOrComponent) ? nodeOrComponent.type.type : nodeOrComponent.type;

  // Function component node
  if (typeof type === 'function' && !((_type$prototype = type.prototype) !== null && _type$prototype !== void 0 && _type$prototype.render)) {
    return false;
  }

  // Class component
  if (typeof nodeOrComponent === 'function' && !((_nodeOrComponent$prot = nodeOrComponent.prototype) !== null && _nodeOrComponent$prot !== void 0 && _nodeOrComponent$prot.render)) {
    return false;
  }
  return true;
}
/* eslint-enable */
;// CONCATENATED MODULE: ./node_modules/_rc-motion@2.6.3@rc-motion/es/util/motion.js



// ================= Transition =================
// Event wrapper. Copy from react source code
function makePrefixMap(styleProp, eventName) {
  var prefixes = {};
  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
  prefixes["Webkit".concat(styleProp)] = "webkit".concat(eventName);
  prefixes["Moz".concat(styleProp)] = "moz".concat(eventName);
  prefixes["ms".concat(styleProp)] = "MS".concat(eventName);
  prefixes["O".concat(styleProp)] = "o".concat(eventName.toLowerCase());
  return prefixes;
}
function getVendorPrefixes(domSupport, win) {
  var prefixes = {
    animationend: makePrefixMap('Animation', 'AnimationEnd'),
    transitionend: makePrefixMap('Transition', 'TransitionEnd')
  };
  if (domSupport) {
    if (!('AnimationEvent' in win)) {
      delete prefixes.animationend.animation;
    }
    if (!('TransitionEvent' in win)) {
      delete prefixes.transitionend.transition;
    }
  }
  return prefixes;
}
var vendorPrefixes = getVendorPrefixes(canUseDom(), typeof window !== 'undefined' ? window : {});
var style = {};
if (canUseDom()) {
  var _document$createEleme = document.createElement('div');
  style = _document$createEleme.style;
}
var prefixedEventNames = {};
function getVendorPrefixedEventName(eventName) {
  if (prefixedEventNames[eventName]) {
    return prefixedEventNames[eventName];
  }
  var prefixMap = vendorPrefixes[eventName];
  if (prefixMap) {
    var stylePropList = Object.keys(prefixMap);
    var len = stylePropList.length;
    for (var i = 0; i < len; i += 1) {
      var styleProp = stylePropList[i];
      if (Object.prototype.hasOwnProperty.call(prefixMap, styleProp) && styleProp in style) {
        prefixedEventNames[eventName] = prefixMap[styleProp];
        return prefixedEventNames[eventName];
      }
    }
  }
  return '';
}
var internalAnimationEndName = getVendorPrefixedEventName('animationend');
var internalTransitionEndName = getVendorPrefixedEventName('transitionend');
var supportTransition = !!(internalAnimationEndName && internalTransitionEndName);
var animationEndName = internalAnimationEndName || 'animationend';
var transitionEndName = internalTransitionEndName || 'transitionend';
function getTransitionName(transitionName, transitionType) {
  if (!transitionName) return null;
  if (_typeof(transitionName) === 'object') {
    var type = transitionType.replace(/-\w/g, function (match) {
      return match[1].toUpperCase();
    });
    return transitionName[type];
  }
  return "".concat(transitionName, "-").concat(transitionType);
}
;// CONCATENATED MODULE: ./node_modules/_rc-motion@2.6.3@rc-motion/es/interface.js
var STATUS_NONE = 'none';
var STATUS_APPEAR = 'appear';
var STATUS_ENTER = 'enter';
var STATUS_LEAVE = 'leave';
var STEP_NONE = 'none';
var STEP_PREPARE = 'prepare';
var STEP_START = 'start';
var STEP_ACTIVE = 'active';
var STEP_ACTIVATED = 'end';
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/hooks/useState.js


/**
 * Same as React.useState but `setState` accept `ignoreDestroy` param to not to setState after destroyed.
 * We do not make this auto is to avoid real memory leak.
 * Developer should confirm it's safe to ignore themselves.
 */
function useSafeState(defaultValue) {
  var destroyRef = _react_18_2_0_react.useRef(false);
  var _React$useState = _react_18_2_0_react.useState(defaultValue),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 2),
    value = _React$useState2[0],
    setValue = _React$useState2[1];
  _react_18_2_0_react.useEffect(function () {
    destroyRef.current = false;
    return function () {
      destroyRef.current = true;
    };
  }, []);
  function safeSetState(updater, ignoreDestroy) {
    if (ignoreDestroy && destroyRef.current) {
      return;
    }
    setValue(updater);
  }
  return [value, safeSetState];
}
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/raf.js
var raf = function raf(callback) {
  return +setTimeout(callback, 16);
};
var caf = function caf(num) {
  return clearTimeout(num);
};
if (typeof window !== 'undefined' && 'requestAnimationFrame' in window) {
  raf = function raf(callback) {
    return window.requestAnimationFrame(callback);
  };
  caf = function caf(handle) {
    return window.cancelAnimationFrame(handle);
  };
}
var rafUUID = 0;
var rafIds = new Map();
function cleanup(id) {
  rafIds.delete(id);
}
var wrapperRaf = function wrapperRaf(callback) {
  var times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
  rafUUID += 1;
  var id = rafUUID;
  function callRef(leftTimes) {
    if (leftTimes === 0) {
      // Clean up
      cleanup(id);

      // Trigger
      callback();
    } else {
      // Next raf
      var realId = raf(function () {
        callRef(leftTimes - 1);
      });

      // Bind real raf id
      rafIds.set(id, realId);
    }
  }
  callRef(times);
  return id;
};
wrapperRaf.cancel = function (id) {
  var realId = rafIds.get(id);
  cleanup(realId);
  return caf(realId);
};
/* harmony default export */ var es_raf = (wrapperRaf);
;// CONCATENATED MODULE: ./node_modules/_rc-motion@2.6.3@rc-motion/es/hooks/useNextFrame.js


/* harmony default export */ var useNextFrame = (function () {
  var nextFrameRef = _react_18_2_0_react.useRef(null);
  function cancelNextFrame() {
    es_raf.cancel(nextFrameRef.current);
  }
  function nextFrame(callback) {
    var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
    cancelNextFrame();
    var nextFrameId = es_raf(function () {
      if (delay <= 1) {
        callback({
          isCanceled: function isCanceled() {
            return nextFrameId !== nextFrameRef.current;
          }
        });
      } else {
        nextFrame(callback, delay - 1);
      }
    });
    nextFrameRef.current = nextFrameId;
  }
  _react_18_2_0_react.useEffect(function () {
    return function () {
      cancelNextFrame();
    };
  }, []);
  return [nextFrame, cancelNextFrame];
});
;// CONCATENATED MODULE: ./node_modules/_rc-motion@2.6.3@rc-motion/es/hooks/useIsomorphicLayoutEffect.js

 // It's safe to use `useLayoutEffect` but the warning is annoying

var useIsomorphicLayoutEffect = canUseDom() ? _react_18_2_0_react.useLayoutEffect : _react_18_2_0_react.useEffect;
/* harmony default export */ var hooks_useIsomorphicLayoutEffect = (useIsomorphicLayoutEffect);
;// CONCATENATED MODULE: ./node_modules/_rc-motion@2.6.3@rc-motion/es/hooks/useStepQueue.js






var STEP_QUEUE = [STEP_PREPARE, STEP_START, STEP_ACTIVE, STEP_ACTIVATED];
/** Skip current step */

var SkipStep = false;
/** Current step should be update in */

var DoStep = true;
function isActive(step) {
  return step === STEP_ACTIVE || step === STEP_ACTIVATED;
}
/* harmony default export */ var useStepQueue = (function (status, callback) {
  var _useState = useSafeState(STEP_NONE),
    _useState2 = slicedToArray_slicedToArray(_useState, 2),
    step = _useState2[0],
    setStep = _useState2[1];
  var _useNextFrame = useNextFrame(),
    _useNextFrame2 = slicedToArray_slicedToArray(_useNextFrame, 2),
    nextFrame = _useNextFrame2[0],
    cancelNextFrame = _useNextFrame2[1];
  function startQueue() {
    setStep(STEP_PREPARE, true);
  }
  hooks_useIsomorphicLayoutEffect(function () {
    if (step !== STEP_NONE && step !== STEP_ACTIVATED) {
      var index = STEP_QUEUE.indexOf(step);
      var nextStep = STEP_QUEUE[index + 1];
      var result = callback(step);
      if (result === SkipStep) {
        // Skip when no needed
        setStep(nextStep, true);
      } else {
        // Do as frame for step update
        nextFrame(function (info) {
          function doNext() {
            // Skip since current queue is ood
            if (info.isCanceled()) return;
            setStep(nextStep, true);
          }
          if (result === true) {
            doNext();
          } else {
            // Only promise should be async
            Promise.resolve(result).then(doNext);
          }
        });
      }
    }
  }, [status, step]);
  _react_18_2_0_react.useEffect(function () {
    return function () {
      cancelNextFrame();
    };
  }, []);
  return [startQueue, step];
});
;// CONCATENATED MODULE: ./node_modules/_rc-motion@2.6.3@rc-motion/es/hooks/useDomMotionEvents.js



/* harmony default export */ var useDomMotionEvents = (function (callback) {
  var cacheElementRef = (0,_react_18_2_0_react.useRef)(); // Cache callback

  var callbackRef = (0,_react_18_2_0_react.useRef)(callback);
  callbackRef.current = callback; // Internal motion event handler

  var onInternalMotionEnd = _react_18_2_0_react.useCallback(function (event) {
    callbackRef.current(event);
  }, []); // Remove events

  function removeMotionEvents(element) {
    if (element) {
      element.removeEventListener(transitionEndName, onInternalMotionEnd);
      element.removeEventListener(animationEndName, onInternalMotionEnd);
    }
  } // Patch events

  function patchMotionEvents(element) {
    if (cacheElementRef.current && cacheElementRef.current !== element) {
      removeMotionEvents(cacheElementRef.current);
    }
    if (element && element !== cacheElementRef.current) {
      element.addEventListener(transitionEndName, onInternalMotionEnd);
      element.addEventListener(animationEndName, onInternalMotionEnd); // Save as cache in case dom removed trigger by `motionDeadline`

      cacheElementRef.current = element;
    }
  } // Clean up when removed

  _react_18_2_0_react.useEffect(function () {
    return function () {
      removeMotionEvents(cacheElementRef.current);
    };
  }, []);
  return [patchMotionEvents, removeMotionEvents];
});
;// CONCATENATED MODULE: ./node_modules/_rc-motion@2.6.3@rc-motion/es/hooks/useStatus.js










function useStatus(supportMotion, visible, getElement, _ref) {
  var _ref$motionEnter = _ref.motionEnter,
    motionEnter = _ref$motionEnter === void 0 ? true : _ref$motionEnter,
    _ref$motionAppear = _ref.motionAppear,
    motionAppear = _ref$motionAppear === void 0 ? true : _ref$motionAppear,
    _ref$motionLeave = _ref.motionLeave,
    motionLeave = _ref$motionLeave === void 0 ? true : _ref$motionLeave,
    motionDeadline = _ref.motionDeadline,
    motionLeaveImmediately = _ref.motionLeaveImmediately,
    onAppearPrepare = _ref.onAppearPrepare,
    onEnterPrepare = _ref.onEnterPrepare,
    onLeavePrepare = _ref.onLeavePrepare,
    onAppearStart = _ref.onAppearStart,
    onEnterStart = _ref.onEnterStart,
    onLeaveStart = _ref.onLeaveStart,
    onAppearActive = _ref.onAppearActive,
    onEnterActive = _ref.onEnterActive,
    onLeaveActive = _ref.onLeaveActive,
    onAppearEnd = _ref.onAppearEnd,
    onEnterEnd = _ref.onEnterEnd,
    onLeaveEnd = _ref.onLeaveEnd,
    onVisibleChanged = _ref.onVisibleChanged;

  // Used for outer render usage to avoid `visible: false & status: none` to render nothing
  var _useState = useSafeState(),
    _useState2 = slicedToArray_slicedToArray(_useState, 2),
    asyncVisible = _useState2[0],
    setAsyncVisible = _useState2[1];
  var _useState3 = useSafeState(STATUS_NONE),
    _useState4 = slicedToArray_slicedToArray(_useState3, 2),
    status = _useState4[0],
    setStatus = _useState4[1];
  var _useState5 = useSafeState(null),
    _useState6 = slicedToArray_slicedToArray(_useState5, 2),
    style = _useState6[0],
    setStyle = _useState6[1];
  var mountedRef = (0,_react_18_2_0_react.useRef)(false);
  var deadlineRef = (0,_react_18_2_0_react.useRef)(null); // =========================== Dom Node ===========================

  function getDomElement() {
    return getElement();
  } // ========================== Motion End ==========================

  var activeRef = (0,_react_18_2_0_react.useRef)(false);
  function onInternalMotionEnd(event) {
    var element = getDomElement();
    if (event && !event.deadline && event.target !== element) {
      // event exists
      // not initiated by deadline
      // transitionEnd not fired by inner elements
      return;
    }
    var currentActive = activeRef.current;
    var canEnd;
    if (status === STATUS_APPEAR && currentActive) {
      canEnd = onAppearEnd === null || onAppearEnd === void 0 ? void 0 : onAppearEnd(element, event);
    } else if (status === STATUS_ENTER && currentActive) {
      canEnd = onEnterEnd === null || onEnterEnd === void 0 ? void 0 : onEnterEnd(element, event);
    } else if (status === STATUS_LEAVE && currentActive) {
      canEnd = onLeaveEnd === null || onLeaveEnd === void 0 ? void 0 : onLeaveEnd(element, event);
    } // Only update status when `canEnd` and not destroyed

    if (status !== STATUS_NONE && currentActive && canEnd !== false) {
      setStatus(STATUS_NONE, true);
      setStyle(null, true);
    }
  }
  var _useDomMotionEvents = useDomMotionEvents(onInternalMotionEnd),
    _useDomMotionEvents2 = slicedToArray_slicedToArray(_useDomMotionEvents, 1),
    patchMotionEvents = _useDomMotionEvents2[0]; // ============================= Step =============================

  var eventHandlers = _react_18_2_0_react.useMemo(function () {
    var _ref2, _ref3, _ref4;
    switch (status) {
      case STATUS_APPEAR:
        return _ref2 = {}, defineProperty_defineProperty(_ref2, STEP_PREPARE, onAppearPrepare), defineProperty_defineProperty(_ref2, STEP_START, onAppearStart), defineProperty_defineProperty(_ref2, STEP_ACTIVE, onAppearActive), _ref2;
      case STATUS_ENTER:
        return _ref3 = {}, defineProperty_defineProperty(_ref3, STEP_PREPARE, onEnterPrepare), defineProperty_defineProperty(_ref3, STEP_START, onEnterStart), defineProperty_defineProperty(_ref3, STEP_ACTIVE, onEnterActive), _ref3;
      case STATUS_LEAVE:
        return _ref4 = {}, defineProperty_defineProperty(_ref4, STEP_PREPARE, onLeavePrepare), defineProperty_defineProperty(_ref4, STEP_START, onLeaveStart), defineProperty_defineProperty(_ref4, STEP_ACTIVE, onLeaveActive), _ref4;
      default:
        return {};
    }
  }, [status]);
  var _useStepQueue = useStepQueue(status, function (newStep) {
      // Only prepare step can be skip
      if (newStep === STEP_PREPARE) {
        var onPrepare = eventHandlers[STEP_PREPARE];
        if (!onPrepare) {
          return SkipStep;
        }
        return onPrepare(getDomElement());
      } // Rest step is sync update

      if (step in eventHandlers) {
        var _eventHandlers$step;
        setStyle(((_eventHandlers$step = eventHandlers[step]) === null || _eventHandlers$step === void 0 ? void 0 : _eventHandlers$step.call(eventHandlers, getDomElement(), null)) || null);
      }
      if (step === STEP_ACTIVE) {
        // Patch events when motion needed
        patchMotionEvents(getDomElement());
        if (motionDeadline > 0) {
          clearTimeout(deadlineRef.current);
          deadlineRef.current = setTimeout(function () {
            onInternalMotionEnd({
              deadline: true
            });
          }, motionDeadline);
        }
      }
      return DoStep;
    }),
    _useStepQueue2 = slicedToArray_slicedToArray(_useStepQueue, 2),
    startStep = _useStepQueue2[0],
    step = _useStepQueue2[1];
  var active = isActive(step);
  activeRef.current = active; // ============================ Status ============================
  // Update with new status

  hooks_useIsomorphicLayoutEffect(function () {
    setAsyncVisible(visible);
    var isMounted = mountedRef.current;
    mountedRef.current = true;
    if (!supportMotion) {
      return;
    }
    var nextStatus; // Appear

    if (!isMounted && visible && motionAppear) {
      nextStatus = STATUS_APPEAR;
    } // Enter

    if (isMounted && visible && motionEnter) {
      nextStatus = STATUS_ENTER;
    } // Leave

    if (isMounted && !visible && motionLeave || !isMounted && motionLeaveImmediately && !visible && motionLeave) {
      nextStatus = STATUS_LEAVE;
    } // Update to next status

    if (nextStatus) {
      setStatus(nextStatus);
      startStep();
    }
  }, [visible]); // ============================ Effect ============================
  // Reset when motion changed

  (0,_react_18_2_0_react.useEffect)(function () {
    if (
    // Cancel appear
    status === STATUS_APPEAR && !motionAppear ||
    // Cancel enter
    status === STATUS_ENTER && !motionEnter ||
    // Cancel leave
    status === STATUS_LEAVE && !motionLeave) {
      setStatus(STATUS_NONE);
    }
  }, [motionAppear, motionEnter, motionLeave]);
  (0,_react_18_2_0_react.useEffect)(function () {
    return function () {
      mountedRef.current = false;
      clearTimeout(deadlineRef.current);
    };
  }, []); // Trigger `onVisibleChanged`

  var firstMountChangeRef = _react_18_2_0_react.useRef(false);
  (0,_react_18_2_0_react.useEffect)(function () {
    // [visible & motion not end] => [!visible & motion end] still need trigger onVisibleChanged
    if (asyncVisible) {
      firstMountChangeRef.current = true;
    }
    if (asyncVisible !== undefined && status === STATUS_NONE) {
      // Skip first render is invisible since it's nothing changed
      if (firstMountChangeRef.current || asyncVisible) {
        onVisibleChanged === null || onVisibleChanged === void 0 ? void 0 : onVisibleChanged(asyncVisible);
      }
      firstMountChangeRef.current = true;
    }
  }, [asyncVisible, status]); // ============================ Styles ============================

  var mergedStyle = style;
  if (eventHandlers[STEP_PREPARE] && step === STEP_START) {
    mergedStyle = _objectSpread2({
      transition: 'none'
    }, mergedStyle);
  }
  return [status, step, mergedStyle, asyncVisible !== null && asyncVisible !== void 0 ? asyncVisible : visible];
}
;// CONCATENATED MODULE: ./node_modules/_rc-motion@2.6.3@rc-motion/es/DomWrapper.js





var DomWrapper = /*#__PURE__*/function (_React$Component) {
  _inherits(DomWrapper, _React$Component);
  var _super = _createSuper(DomWrapper);
  function DomWrapper() {
    _classCallCheck(this, DomWrapper);
    return _super.apply(this, arguments);
  }
  _createClass(DomWrapper, [{
    key: "render",
    value: function render() {
      return this.props.children;
    }
  }]);
  return DomWrapper;
}(_react_18_2_0_react.Component);
/* harmony default export */ var es_DomWrapper = (DomWrapper);
;// CONCATENATED MODULE: ./node_modules/_rc-motion@2.6.3@rc-motion/es/CSSMotion.js





/* eslint-disable react/default-props-match-prop-types, react/no-multi-comp, react/prop-types */











/**
 * `transitionSupport` is used for none transition test case.
 * Default we use browser transition event support check.
 */
function genCSSMotion(config) {
  var transitionSupport = config;
  if (_typeof(config) === 'object') {
    transitionSupport = config.transitionSupport;
  }
  function isSupportTransition(props) {
    return !!(props.motionName && transitionSupport);
  }
  var CSSMotion = /*#__PURE__*/_react_18_2_0_react.forwardRef(function (props, ref) {
    var _props$visible = props.visible,
      visible = _props$visible === void 0 ? true : _props$visible,
      _props$removeOnLeave = props.removeOnLeave,
      removeOnLeave = _props$removeOnLeave === void 0 ? true : _props$removeOnLeave,
      forceRender = props.forceRender,
      children = props.children,
      motionName = props.motionName,
      leavedClassName = props.leavedClassName,
      eventProps = props.eventProps;
    var supportMotion = isSupportTransition(props); // Ref to the react node, it may be a HTMLElement

    var nodeRef = (0,_react_18_2_0_react.useRef)(); // Ref to the dom wrapper in case ref can not pass to HTMLElement

    var wrapperNodeRef = (0,_react_18_2_0_react.useRef)();
    function getDomElement() {
      try {
        // Here we're avoiding call for findDOMNode since it's deprecated
        // in strict mode. We're calling it only when node ref is not
        // an instance of DOM HTMLElement. Otherwise use
        // findDOMNode as a final resort
        return nodeRef.current instanceof HTMLElement ? nodeRef.current : findDOMNode(wrapperNodeRef.current);
      } catch (e) {
        // Only happen when `motionDeadline` trigger but element removed.
        return null;
      }
    }
    var _useStatus = useStatus(supportMotion, visible, getDomElement, props),
      _useStatus2 = slicedToArray_slicedToArray(_useStatus, 4),
      status = _useStatus2[0],
      statusStep = _useStatus2[1],
      statusStyle = _useStatus2[2],
      mergedVisible = _useStatus2[3]; // Record whether content has rendered
    // Will return null for un-rendered even when `removeOnLeave={false}`

    var renderedRef = _react_18_2_0_react.useRef(mergedVisible);
    if (mergedVisible) {
      renderedRef.current = true;
    } // ====================== Refs ======================

    var setNodeRef = _react_18_2_0_react.useCallback(function (node) {
      nodeRef.current = node;
      fillRef(ref, node);
    }, [ref]); // ===================== Render =====================

    var motionChildren;
    var mergedProps = _objectSpread2(_objectSpread2({}, eventProps), {}, {
      visible: visible
    });
    if (!children) {
      // No children
      motionChildren = null;
    } else if (status === STATUS_NONE || !isSupportTransition(props)) {
      // Stable children
      if (mergedVisible) {
        motionChildren = children(_objectSpread2({}, mergedProps), setNodeRef);
      } else if (!removeOnLeave && renderedRef.current && leavedClassName) {
        motionChildren = children(_objectSpread2(_objectSpread2({}, mergedProps), {}, {
          className: leavedClassName
        }), setNodeRef);
      } else if (forceRender || !removeOnLeave && !leavedClassName) {
        motionChildren = children(_objectSpread2(_objectSpread2({}, mergedProps), {}, {
          style: {
            display: 'none'
          }
        }), setNodeRef);
      } else {
        motionChildren = null;
      }
    } else {
      var _classNames;

      // In motion
      var statusSuffix;
      if (statusStep === STEP_PREPARE) {
        statusSuffix = 'prepare';
      } else if (isActive(statusStep)) {
        statusSuffix = 'active';
      } else if (statusStep === STEP_START) {
        statusSuffix = 'start';
      }
      motionChildren = children(_objectSpread2(_objectSpread2({}, mergedProps), {}, {
        className: _classnames_2_3_2_classnames_default()(getTransitionName(motionName, status), (_classNames = {}, defineProperty_defineProperty(_classNames, getTransitionName(motionName, "".concat(status, "-").concat(statusSuffix)), statusSuffix), defineProperty_defineProperty(_classNames, motionName, typeof motionName === 'string'), _classNames)),
        style: statusStyle
      }), setNodeRef);
    } // Auto inject ref if child node not have `ref` props

    if ( /*#__PURE__*/_react_18_2_0_react.isValidElement(motionChildren) && supportRef(motionChildren)) {
      var _ref = motionChildren,
        originNodeRef = _ref.ref;
      if (!originNodeRef) {
        motionChildren = /*#__PURE__*/_react_18_2_0_react.cloneElement(motionChildren, {
          ref: setNodeRef
        });
      }
    }
    return /*#__PURE__*/_react_18_2_0_react.createElement(es_DomWrapper, {
      ref: wrapperNodeRef
    }, motionChildren);
  });
  CSSMotion.displayName = 'CSSMotion';
  return CSSMotion;
}
/* harmony default export */ var es_CSSMotion = (genCSSMotion(supportTransition));
;// CONCATENATED MODULE: ./node_modules/_rc-motion@2.6.3@rc-motion/es/util/diff.js


var STATUS_ADD = 'add';
var STATUS_KEEP = 'keep';
var STATUS_REMOVE = 'remove';
var STATUS_REMOVED = 'removed';
function wrapKeyToObject(key) {
  var keyObj;
  if (key && _typeof(key) === 'object' && 'key' in key) {
    keyObj = key;
  } else {
    keyObj = {
      key: key
    };
  }
  return _objectSpread2(_objectSpread2({}, keyObj), {}, {
    key: String(keyObj.key)
  });
}
function parseKeys() {
  var keys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
  return keys.map(wrapKeyToObject);
}
function diffKeys() {
  var prevKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
  var currentKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
  var list = [];
  var currentIndex = 0;
  var currentLen = currentKeys.length;
  var prevKeyObjects = parseKeys(prevKeys);
  var currentKeyObjects = parseKeys(currentKeys); // Check prev keys to insert or keep

  prevKeyObjects.forEach(function (keyObj) {
    var hit = false;
    for (var i = currentIndex; i < currentLen; i += 1) {
      var currentKeyObj = currentKeyObjects[i];
      if (currentKeyObj.key === keyObj.key) {
        // New added keys should add before current key
        if (currentIndex < i) {
          list = list.concat(currentKeyObjects.slice(currentIndex, i).map(function (obj) {
            return _objectSpread2(_objectSpread2({}, obj), {}, {
              status: STATUS_ADD
            });
          }));
          currentIndex = i;
        }
        list.push(_objectSpread2(_objectSpread2({}, currentKeyObj), {}, {
          status: STATUS_KEEP
        }));
        currentIndex += 1;
        hit = true;
        break;
      }
    } // If not hit, it means key is removed

    if (!hit) {
      list.push(_objectSpread2(_objectSpread2({}, keyObj), {}, {
        status: STATUS_REMOVE
      }));
    }
  }); // Add rest to the list

  if (currentIndex < currentLen) {
    list = list.concat(currentKeyObjects.slice(currentIndex).map(function (obj) {
      return _objectSpread2(_objectSpread2({}, obj), {}, {
        status: STATUS_ADD
      });
    }));
  }
  /**
   * Merge same key when it remove and add again:
   *    [1 - add, 2 - keep, 1 - remove] -> [1 - keep, 2 - keep]
   */

  var keys = {};
  list.forEach(function (_ref) {
    var key = _ref.key;
    keys[key] = (keys[key] || 0) + 1;
  });
  var duplicatedKeys = Object.keys(keys).filter(function (key) {
    return keys[key] > 1;
  });
  duplicatedKeys.forEach(function (matchKey) {
    // Remove `STATUS_REMOVE` node.
    list = list.filter(function (_ref2) {
      var key = _ref2.key,
        status = _ref2.status;
      return key !== matchKey || status !== STATUS_REMOVE;
    }); // Update `STATUS_ADD` to `STATUS_KEEP`

    list.forEach(function (node) {
      if (node.key === matchKey) {
        // eslint-disable-next-line no-param-reassign
        node.status = STATUS_KEEP;
      }
    });
  });
  return list;
}
;// CONCATENATED MODULE: ./node_modules/_rc-motion@2.6.3@rc-motion/es/CSSMotionList.js









var CSSMotionList_excluded = ["component", "children", "onVisibleChanged", "onAllRemoved"],
  _excluded2 = ["status"];

/* eslint react/prop-types: 0 */




var MOTION_PROP_NAMES = ['eventProps', 'visible', 'children', 'motionName', 'motionAppear', 'motionEnter', 'motionLeave', 'motionLeaveImmediately', 'motionDeadline', 'removeOnLeave', 'leavedClassName', 'onAppearStart', 'onAppearActive', 'onAppearEnd', 'onEnterStart', 'onEnterActive', 'onEnterEnd', 'onLeaveStart', 'onLeaveActive', 'onLeaveEnd'];

/**
 * Generate a CSSMotionList component with config
 * @param transitionSupport No need since CSSMotionList no longer depends on transition support
 * @param CSSMotion CSSMotion component
 */
function genCSSMotionList(transitionSupport) {
  var CSSMotion = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : es_CSSMotion;
  var CSSMotionList = /*#__PURE__*/function (_React$Component) {
    _inherits(CSSMotionList, _React$Component);
    var _super = _createSuper(CSSMotionList);
    function CSSMotionList() {
      var _this;
      _classCallCheck(this, CSSMotionList);
      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }
      _this = _super.call.apply(_super, [this].concat(args));
      defineProperty_defineProperty(_assertThisInitialized(_this), "state", {
        keyEntities: []
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "removeKey", function (removeKey) {
        var keyEntities = _this.state.keyEntities;
        var nextKeyEntities = keyEntities.map(function (entity) {
          if (entity.key !== removeKey) return entity;
          return _objectSpread2(_objectSpread2({}, entity), {}, {
            status: STATUS_REMOVED
          });
        });
        _this.setState({
          keyEntities: nextKeyEntities
        });
        return nextKeyEntities.filter(function (_ref) {
          var status = _ref.status;
          return status !== STATUS_REMOVED;
        }).length;
      });
      return _this;
    }
    _createClass(CSSMotionList, [{
      key: "render",
      value: function render() {
        var _this2 = this;
        var keyEntities = this.state.keyEntities;
        var _this$props = this.props,
          component = _this$props.component,
          children = _this$props.children,
          _onVisibleChanged = _this$props.onVisibleChanged,
          onAllRemoved = _this$props.onAllRemoved,
          restProps = _objectWithoutProperties(_this$props, CSSMotionList_excluded);
        var Component = component || _react_18_2_0_react.Fragment;
        var motionProps = {};
        MOTION_PROP_NAMES.forEach(function (prop) {
          motionProps[prop] = restProps[prop];
          delete restProps[prop];
        });
        delete restProps.keys;
        return /*#__PURE__*/_react_18_2_0_react.createElement(Component, restProps, keyEntities.map(function (_ref2) {
          var status = _ref2.status,
            eventProps = _objectWithoutProperties(_ref2, _excluded2);
          var visible = status === STATUS_ADD || status === STATUS_KEEP;
          return /*#__PURE__*/_react_18_2_0_react.createElement(CSSMotion, extends_extends({}, motionProps, {
            key: eventProps.key,
            visible: visible,
            eventProps: eventProps,
            onVisibleChanged: function onVisibleChanged(changedVisible) {
              _onVisibleChanged === null || _onVisibleChanged === void 0 ? void 0 : _onVisibleChanged(changedVisible, {
                key: eventProps.key
              });
              if (!changedVisible) {
                var restKeysCount = _this2.removeKey(eventProps.key);
                if (restKeysCount === 0 && onAllRemoved) {
                  onAllRemoved();
                }
              }
            }
          }), children);
        }));
      }
    }], [{
      key: "getDerivedStateFromProps",
      value: function getDerivedStateFromProps(_ref3, _ref4) {
        var keys = _ref3.keys;
        var keyEntities = _ref4.keyEntities;
        var parsedKeyObjects = parseKeys(keys);
        var mixedKeyEntities = diffKeys(keyEntities, parsedKeyObjects);
        return {
          keyEntities: mixedKeyEntities.filter(function (entity) {
            var prevEntity = keyEntities.find(function (_ref5) {
              var key = _ref5.key;
              return entity.key === key;
            }); // Remove if already mark as removed

            if (prevEntity && prevEntity.status === STATUS_REMOVED && entity.status === STATUS_REMOVE) {
              return false;
            }
            return true;
          })
        };
      } // ZombieJ: Return the count of rest keys. It's safe to refactor if need more info.
    }]);

    return CSSMotionList;
  }(_react_18_2_0_react.Component);
  defineProperty_defineProperty(CSSMotionList, "defaultProps", {
    component: 'div'
  });
  return CSSMotionList;
}
/* harmony default export */ var CSSMotionList = (genCSSMotionList(supportTransition));
;// CONCATENATED MODULE: ./node_modules/_rc-motion@2.6.3@rc-motion/es/index.js



/* harmony default export */ var _rc_motion_2_6_3_rc_motion_es = (es_CSSMotion);
;// CONCATENATED MODULE: ./node_modules/_rc-notification@4.6.1@rc-notification/es/Notice.js










var Notice = /*#__PURE__*/function (_Component) {
  _inherits(Notice, _Component);
  var _super = _createSuper(Notice);
  function Notice() {
    var _this;
    _classCallCheck(this, Notice);
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    _this = _super.call.apply(_super, [this].concat(args));
    _this.closeTimer = null;
    _this.close = function (e) {
      if (e) {
        e.stopPropagation();
      }
      _this.clearCloseTimer();
      var _this$props = _this.props,
        onClose = _this$props.onClose,
        noticeKey = _this$props.noticeKey;
      if (onClose) {
        onClose(noticeKey);
      }
    };
    _this.startCloseTimer = function () {
      if (_this.props.duration) {
        _this.closeTimer = window.setTimeout(function () {
          _this.close();
        }, _this.props.duration * 1000);
      }
    };
    _this.clearCloseTimer = function () {
      if (_this.closeTimer) {
        clearTimeout(_this.closeTimer);
        _this.closeTimer = null;
      }
    };
    return _this;
  }
  _createClass(Notice, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      this.startCloseTimer();
    }
  }, {
    key: "componentDidUpdate",
    value: function componentDidUpdate(prevProps) {
      if (this.props.duration !== prevProps.duration || this.props.updateMark !== prevProps.updateMark ||
      // Visible again need reset timer
      this.props.visible !== prevProps.visible && this.props.visible) {
        this.restartCloseTimer();
      }
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      this.clearCloseTimer();
    }
  }, {
    key: "restartCloseTimer",
    value: function restartCloseTimer() {
      this.clearCloseTimer();
      this.startCloseTimer();
    }
  }, {
    key: "render",
    value: function render() {
      var _this2 = this;
      var _this$props2 = this.props,
        prefixCls = _this$props2.prefixCls,
        className = _this$props2.className,
        closable = _this$props2.closable,
        closeIcon = _this$props2.closeIcon,
        style = _this$props2.style,
        onClick = _this$props2.onClick,
        children = _this$props2.children,
        holder = _this$props2.holder;
      var componentClass = "".concat(prefixCls, "-notice");
      var dataOrAriaAttributeProps = Object.keys(this.props).reduce(function (acc, key) {
        if (key.substr(0, 5) === 'data-' || key.substr(0, 5) === 'aria-' || key === 'role') {
          acc[key] = _this2.props[key];
        }
        return acc;
      }, {});
      var node = /*#__PURE__*/_react_18_2_0_react.createElement("div", extends_extends({
        className: _classnames_2_3_2_classnames_default()(componentClass, className, defineProperty_defineProperty({}, "".concat(componentClass, "-closable"), closable)),
        style: style,
        onMouseEnter: this.clearCloseTimer,
        onMouseLeave: this.startCloseTimer,
        onClick: onClick
      }, dataOrAriaAttributeProps), /*#__PURE__*/_react_18_2_0_react.createElement("div", {
        className: "".concat(componentClass, "-content")
      }, children), closable ? /*#__PURE__*/_react_18_2_0_react.createElement("a", {
        tabIndex: 0,
        onClick: this.close,
        className: "".concat(componentClass, "-close")
      }, closeIcon || /*#__PURE__*/_react_18_2_0_react.createElement("span", {
        className: "".concat(componentClass, "-close-x")
      })) : null);
      if (holder) {
        return /*#__PURE__*/_react_dom_18_2_0_react_dom.createPortal(node, holder);
      }
      return node;
    }
  }]);
  return Notice;
}(_react_18_2_0_react.Component);
Notice.defaultProps = {
  onClose: function onClose() {},
  duration: 1.5
};

;// CONCATENATED MODULE: ./node_modules/_rc-notification@4.6.1@rc-notification/es/useNotification.js





function useNotification_useNotification(notificationInstance) {
  var createdRef = _react_18_2_0_react.useRef({});
  var _React$useState = _react_18_2_0_react.useState([]),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 2),
    elements = _React$useState2[0],
    setElements = _React$useState2[1];
  function notify(noticeProps) {
    var firstMount = true;
    notificationInstance.add(noticeProps, function (div, props) {
      var key = props.key;
      if (div && (!createdRef.current[key] || firstMount)) {
        var noticeEle = /*#__PURE__*/_react_18_2_0_react.createElement(Notice, extends_extends({}, props, {
          holder: div
        }));
        createdRef.current[key] = noticeEle;
        setElements(function (originElements) {
          var index = originElements.findIndex(function (ele) {
            return ele.key === props.key;
          });
          if (index === -1) {
            return [].concat(_toConsumableArray(originElements), [noticeEle]);
          }
          var cloneList = _toConsumableArray(originElements);
          cloneList[index] = noticeEle;
          return cloneList;
        });
      }
      firstMount = false;
    });
  }
  return [notify, /*#__PURE__*/_react_18_2_0_react.createElement(_react_18_2_0_react.Fragment, null, elements)];
}
;// CONCATENATED MODULE: ./node_modules/_rc-notification@4.6.1@rc-notification/es/Notification.js







var Notification_excluded = ["getContainer"];







var seed = 0;
var now = Date.now();
function getUuid() {
  var id = seed;
  seed += 1;
  return "rcNotification_".concat(now, "_").concat(id);
}
var Notification = /*#__PURE__*/function (_Component) {
  _inherits(Notification, _Component);
  var _super = _createSuper(Notification);
  function Notification() {
    var _this;
    _classCallCheck(this, Notification);
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    _this = _super.call.apply(_super, [this].concat(args));
    _this.state = {
      notices: []
    };
    _this.hookRefs = new Map();
    _this.add = function (originNotice, holderCallback) {
      var _originNotice$key;
      var key = (_originNotice$key = originNotice.key) !== null && _originNotice$key !== void 0 ? _originNotice$key : getUuid();
      var notice = _objectSpread2(_objectSpread2({}, originNotice), {}, {
        key: key
      });
      var maxCount = _this.props.maxCount;
      _this.setState(function (previousState) {
        var notices = previousState.notices;
        var noticeIndex = notices.map(function (v) {
          return v.notice.key;
        }).indexOf(key);
        var updatedNotices = notices.concat();
        if (noticeIndex !== -1) {
          updatedNotices.splice(noticeIndex, 1, {
            notice: notice,
            holderCallback: holderCallback
          });
        } else {
          if (maxCount && notices.length >= maxCount) {
            // XXX, use key of first item to update new added (let React to move exsiting
            // instead of remove and mount). Same key was used before for both a) external
            // manual control and b) internal react 'key' prop , which is not that good.
            // eslint-disable-next-line no-param-reassign
            // zombieJ: Not know why use `updateKey`. This makes Notice infinite loop in jest.
            // Change to `updateMark` for compare instead.
            // https://github.com/react-component/notification/commit/32299e6be396f94040bfa82517eea940db947ece
            notice.key = updatedNotices[0].notice.key;
            notice.updateMark = getUuid();
            // zombieJ: That's why. User may close by key directly.
            // We need record this but not re-render to avoid upper issue
            // https://github.com/react-component/notification/issues/129
            notice.userPassKey = key;
            updatedNotices.shift();
          }
          updatedNotices.push({
            notice: notice,
            holderCallback: holderCallback
          });
        }
        return {
          notices: updatedNotices
        };
      });
    };
    _this.remove = function (removeKey) {
      _this.setState(function (_ref) {
        var notices = _ref.notices;
        return {
          notices: notices.filter(function (_ref2) {
            var _ref2$notice = _ref2.notice,
              key = _ref2$notice.key,
              userPassKey = _ref2$notice.userPassKey;
            var mergedKey = userPassKey !== null && userPassKey !== void 0 ? userPassKey : key;
            return mergedKey !== removeKey;
          })
        };
      });
    };
    _this.noticePropsMap = {};
    return _this;
  }
  _createClass(Notification, [{
    key: "getTransitionName",
    value: function getTransitionName() {
      var _this$props = this.props,
        prefixCls = _this$props.prefixCls,
        animation = _this$props.animation;
      var transitionName = this.props.transitionName;
      if (!transitionName && animation) {
        transitionName = "".concat(prefixCls, "-").concat(animation);
      }
      return transitionName;
    }
  }, {
    key: "render",
    value: function render() {
      var _this2 = this;
      var notices = this.state.notices;
      var _this$props2 = this.props,
        prefixCls = _this$props2.prefixCls,
        className = _this$props2.className,
        closeIcon = _this$props2.closeIcon,
        style = _this$props2.style;
      var noticeKeys = [];
      notices.forEach(function (_ref3, index) {
        var notice = _ref3.notice,
          holderCallback = _ref3.holderCallback;
        var updateMark = index === notices.length - 1 ? notice.updateMark : undefined;
        var key = notice.key,
          userPassKey = notice.userPassKey;
        var noticeProps = _objectSpread2(_objectSpread2(_objectSpread2({
          prefixCls: prefixCls,
          closeIcon: closeIcon
        }, notice), notice.props), {}, {
          key: key,
          noticeKey: userPassKey || key,
          updateMark: updateMark,
          onClose: function onClose(noticeKey) {
            var _notice$onClose;
            _this2.remove(noticeKey);
            (_notice$onClose = notice.onClose) === null || _notice$onClose === void 0 ? void 0 : _notice$onClose.call(notice);
          },
          onClick: notice.onClick,
          children: notice.content
        });
        // Give to motion
        noticeKeys.push(key);
        _this2.noticePropsMap[key] = {
          props: noticeProps,
          holderCallback: holderCallback
        };
      });
      return /*#__PURE__*/_react_18_2_0_react.createElement("div", {
        className: _classnames_2_3_2_classnames_default()(prefixCls, className),
        style: style
      }, /*#__PURE__*/_react_18_2_0_react.createElement(CSSMotionList, {
        keys: noticeKeys,
        motionName: this.getTransitionName(),
        onVisibleChanged: function onVisibleChanged(changedVisible, _ref4) {
          var key = _ref4.key;
          if (!changedVisible) {
            delete _this2.noticePropsMap[key];
          }
        }
      }, function (_ref5) {
        var key = _ref5.key,
          motionClassName = _ref5.className,
          motionStyle = _ref5.style,
          visible = _ref5.visible;
        var _this2$noticePropsMap = _this2.noticePropsMap[key],
          noticeProps = _this2$noticePropsMap.props,
          holderCallback = _this2$noticePropsMap.holderCallback;
        if (holderCallback) {
          return /*#__PURE__*/_react_18_2_0_react.createElement("div", {
            key: key,
            className: _classnames_2_3_2_classnames_default()(motionClassName, "".concat(prefixCls, "-hook-holder")),
            style: _objectSpread2({}, motionStyle),
            ref: function ref(div) {
              if (typeof key === 'undefined') {
                return;
              }
              if (div) {
                _this2.hookRefs.set(key, div);
                holderCallback(div, noticeProps);
              } else {
                _this2.hookRefs.delete(key);
              }
            }
          });
        }
        return /*#__PURE__*/_react_18_2_0_react.createElement(Notice, extends_extends({}, noticeProps, {
          className: _classnames_2_3_2_classnames_default()(motionClassName, noticeProps === null || noticeProps === void 0 ? void 0 : noticeProps.className),
          style: _objectSpread2(_objectSpread2({}, motionStyle), noticeProps === null || noticeProps === void 0 ? void 0 : noticeProps.style),
          visible: visible
        }));
      }));
    }
  }]);
  return Notification;
}(_react_18_2_0_react.Component);
Notification.newInstance = void 0;
Notification.defaultProps = {
  prefixCls: 'rc-notification',
  animation: 'fade',
  style: {
    top: 65,
    left: '50%'
  }
};
Notification.newInstance = function newNotificationInstance(properties, callback) {
  var _ref6 = properties || {},
    getContainer = _ref6.getContainer,
    props = _objectWithoutProperties(_ref6, Notification_excluded);
  var div = document.createElement('div');
  if (getContainer) {
    var root = getContainer();
    root.appendChild(div);
  } else {
    document.body.appendChild(div);
  }
  var called = false;
  function ref(notification) {
    if (called) {
      return;
    }
    called = true;
    callback({
      notice: function notice(noticeProps) {
        notification.add(noticeProps);
      },
      removeNotice: function removeNotice(key) {
        notification.remove(key);
      },
      component: notification,
      destroy: function destroy() {
        unmount(div);
        if (div.parentNode) {
          div.parentNode.removeChild(div);
        }
      },
      // Hooks
      useNotification: function useNotification() {
        return useNotification_useNotification(notification);
      }
    });
  }
  // Only used for test case usage
  if (false) {}
  render_render( /*#__PURE__*/_react_18_2_0_react.createElement(Notification, extends_extends({}, props, {
    ref: ref
  })), div);
};
/* harmony default export */ var es_Notification = (Notification);
;// CONCATENATED MODULE: ./node_modules/_rc-notification@4.6.1@rc-notification/es/index.js

/* harmony default export */ var _rc_notification_4_6_1_rc_notification_es = (es_Notification);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/config-provider/context.js


var defaultGetPrefixCls = function defaultGetPrefixCls(suffixCls, customizePrefixCls) {
  if (customizePrefixCls) return customizePrefixCls;
  return suffixCls ? "ant-".concat(suffixCls) : 'ant';
};
// zombieJ: 🚨 Do not pass `defaultRenderEmpty` here since it will case circular dependency.
var context_ConfigContext = /*#__PURE__*/_react_18_2_0_react.createContext({
  // We provide a default function for Context without provider
  getPrefixCls: defaultGetPrefixCls
});
var ConfigConsumer = context_ConfigContext.Consumer;
/** @deprecated Use hooks instead. This is a legacy function */
function withConfigConsumer(config) {
  return function withConfigConsumerFunc(Component) {
    // Wrap with ConfigConsumer. Since we need compatible with react 15, be care when using ref methods
    var SFC = function SFC(props) {
      return /*#__PURE__*/React.createElement(ConfigConsumer, null, function (configProps) {
        var basicPrefixCls = config.prefixCls;
        var getPrefixCls = configProps.getPrefixCls;
        var customizePrefixCls = props.prefixCls;
        var prefixCls = getPrefixCls(basicPrefixCls, customizePrefixCls);
        return /*#__PURE__*/React.createElement(Component, _extends({}, configProps, props, {
          prefixCls: prefixCls
        }));
      });
    };
    var cons = Component.constructor;
    var name = cons && cons.displayName || Component.name || 'Component';
    if (false) {}
    return SFC;
  };
}
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/message/hooks/useMessage.js






function createUseMessage(getRcNotificationInstance, getRCNoticeProps) {
  var useMessage = function useMessage() {
    // We can only get content by render
    var getPrefixCls;
    var getPopupContainer;
    // We create a proxy to handle delay created instance
    var innerInstance = null;
    var proxy = {
      add: function add(noticeProps, holderCallback) {
        innerInstance === null || innerInstance === void 0 ? void 0 : innerInstance.component.add(noticeProps, holderCallback);
      }
    };
    var _useRCNotification = useNotification_useNotification(proxy),
      _useRCNotification2 = slicedToArray_slicedToArray(_useRCNotification, 2),
      hookNotify = _useRCNotification2[0],
      holder = _useRCNotification2[1];
    function notify(args) {
      var customizePrefixCls = args.prefixCls;
      var mergedPrefixCls = getPrefixCls('message', customizePrefixCls);
      var rootPrefixCls = getPrefixCls();
      var target = args.key || getKeyThenIncreaseKey();
      var closePromise = new Promise(function (resolve) {
        var callback = function callback() {
          if (typeof args.onClose === 'function') {
            args.onClose();
          }
          return resolve(true);
        };
        getRcNotificationInstance(extends_extends(extends_extends({}, args), {
          prefixCls: mergedPrefixCls,
          rootPrefixCls: rootPrefixCls,
          getPopupContainer: getPopupContainer
        }), function (_ref) {
          var prefixCls = _ref.prefixCls,
            instance = _ref.instance;
          innerInstance = instance;
          hookNotify(getRCNoticeProps(extends_extends(extends_extends({}, args), {
            key: target,
            onClose: callback
          }), prefixCls));
        });
      });
      var result = function result() {
        if (innerInstance) {
          innerInstance.removeNotice(target);
        }
      };
      result.then = function (filled, rejected) {
        return closePromise.then(filled, rejected);
      };
      result.promise = closePromise;
      return result;
    }
    // Fill functions
    var hookApiRef = _react_18_2_0_react.useRef({});
    hookApiRef.current.open = notify;
    typeList.forEach(function (type) {
      return attachTypeApi(hookApiRef.current, type);
    });
    return [hookApiRef.current, /*#__PURE__*/_react_18_2_0_react.createElement(ConfigConsumer, {
      key: "holder"
    }, function (context) {
      getPrefixCls = context.getPrefixCls;
      getPopupContainer = context.getPopupContainer;
      return holder;
    })];
  };
  return useMessage;
}
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/message/index.js












var messageInstance;
var defaultDuration = 3;
var defaultTop;
var key = 1;
var localPrefixCls = '';
var transitionName = 'move-up';
var hasTransitionName = false;
var message_getContainer;
var maxCount;
var rtl = false;
function getKeyThenIncreaseKey() {
  return key++;
}
function setMessageConfig(options) {
  if (options.top !== undefined) {
    defaultTop = options.top;
    messageInstance = null; // delete messageInstance for new defaultTop
  }

  if (options.duration !== undefined) {
    defaultDuration = options.duration;
  }
  if (options.prefixCls !== undefined) {
    localPrefixCls = options.prefixCls;
  }
  if (options.getContainer !== undefined) {
    message_getContainer = options.getContainer;
    messageInstance = null; // delete messageInstance for new getContainer
  }

  if (options.transitionName !== undefined) {
    transitionName = options.transitionName;
    messageInstance = null; // delete messageInstance for new transitionName
    hasTransitionName = true;
  }
  if (options.maxCount !== undefined) {
    maxCount = options.maxCount;
    messageInstance = null;
  }
  if (options.rtl !== undefined) {
    rtl = options.rtl;
  }
}
function getRCNotificationInstance(args, callback) {
  var customizePrefixCls = args.prefixCls,
    getContextPopupContainer = args.getPopupContainer;
  var _globalConfig = globalConfig(),
    getPrefixCls = _globalConfig.getPrefixCls,
    getRootPrefixCls = _globalConfig.getRootPrefixCls,
    getIconPrefixCls = _globalConfig.getIconPrefixCls;
  var prefixCls = getPrefixCls('message', customizePrefixCls || localPrefixCls);
  var rootPrefixCls = getRootPrefixCls(args.rootPrefixCls, prefixCls);
  var iconPrefixCls = getIconPrefixCls();
  if (messageInstance) {
    callback({
      prefixCls: prefixCls,
      rootPrefixCls: rootPrefixCls,
      iconPrefixCls: iconPrefixCls,
      instance: messageInstance
    });
    return;
  }
  var instanceConfig = {
    prefixCls: prefixCls,
    transitionName: hasTransitionName ? transitionName : "".concat(rootPrefixCls, "-").concat(transitionName),
    style: {
      top: defaultTop
    },
    getContainer: message_getContainer || getContextPopupContainer,
    maxCount: maxCount
  };
  _rc_notification_4_6_1_rc_notification_es.newInstance(instanceConfig, function (instance) {
    if (messageInstance) {
      callback({
        prefixCls: prefixCls,
        rootPrefixCls: rootPrefixCls,
        iconPrefixCls: iconPrefixCls,
        instance: messageInstance
      });
      return;
    }
    messageInstance = instance;
    if (false) {}
    callback({
      prefixCls: prefixCls,
      rootPrefixCls: rootPrefixCls,
      iconPrefixCls: iconPrefixCls,
      instance: instance
    });
  });
}
var typeToIcon = {
  info: icons_InfoCircleFilled,
  success: icons_CheckCircleFilled,
  error: icons_CloseCircleFilled,
  warning: icons_ExclamationCircleFilled,
  loading: icons_LoadingOutlined
};
var typeList = Object.keys(typeToIcon);
function getRCNoticeProps(args, prefixCls, iconPrefixCls) {
  var _classNames;
  var duration = args.duration !== undefined ? args.duration : defaultDuration;
  var IconComponent = typeToIcon[args.type];
  var messageClass = _classnames_2_3_2_classnames_default()("".concat(prefixCls, "-custom-content"), (_classNames = {}, defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-").concat(args.type), args.type), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-rtl"), rtl === true), _classNames));
  return {
    key: args.key,
    duration: duration,
    style: args.style || {},
    className: args.className,
    content: /*#__PURE__*/_react_18_2_0_react.createElement(config_provider, {
      iconPrefixCls: iconPrefixCls
    }, /*#__PURE__*/_react_18_2_0_react.createElement("div", {
      className: messageClass
    }, args.icon || IconComponent && /*#__PURE__*/_react_18_2_0_react.createElement(IconComponent, null), /*#__PURE__*/_react_18_2_0_react.createElement("span", null, args.content))),
    onClose: args.onClose,
    onClick: args.onClick
  };
}
function notice(args) {
  var target = args.key || getKeyThenIncreaseKey();
  var closePromise = new Promise(function (resolve) {
    var callback = function callback() {
      if (typeof args.onClose === 'function') {
        args.onClose();
      }
      return resolve(true);
    };
    getRCNotificationInstance(args, function (_ref) {
      var prefixCls = _ref.prefixCls,
        iconPrefixCls = _ref.iconPrefixCls,
        instance = _ref.instance;
      instance.notice(getRCNoticeProps(extends_extends(extends_extends({}, args), {
        key: target,
        onClose: callback
      }), prefixCls, iconPrefixCls));
    });
  });
  var result = function result() {
    var _a;
    if (messageInstance) {
      messageInstance.removeNotice(target);
      (_a = args.onClose) === null || _a === void 0 ? void 0 : _a.call(args);
    }
  };
  result.then = function (filled, rejected) {
    return closePromise.then(filled, rejected);
  };
  result.promise = closePromise;
  return result;
}
function isArgsProps(content) {
  return Object.prototype.toString.call(content) === '[object Object]' && !!content.content;
}
var api = {
  open: notice,
  config: setMessageConfig,
  destroy: function destroy(messageKey) {
    if (messageInstance) {
      if (messageKey) {
        var _messageInstance = messageInstance,
          removeNotice = _messageInstance.removeNotice;
        removeNotice(messageKey);
      } else {
        var _messageInstance2 = messageInstance,
          destroy = _messageInstance2.destroy;
        destroy();
        messageInstance = null;
      }
    }
  }
};
function attachTypeApi(originalApi, type) {
  originalApi[type] = function (content, duration, onClose) {
    if (isArgsProps(content)) {
      return originalApi.open(extends_extends(extends_extends({}, content), {
        type: type
      }));
    }
    if (typeof duration === 'function') {
      onClose = duration;
      duration = undefined;
    }
    return originalApi.open({
      content: content,
      duration: duration,
      type: type,
      onClose: onClose
    });
  };
}
typeList.forEach(function (type) {
  return attachTypeApi(api, type);
});
api.warn = api.warning;
api.useMessage = createUseMessage(getRCNotificationInstance, getRCNoticeProps);
/** @internal test Only function. Not work on production */
var getInstance = function getInstance() {
  return  false ? 0 : null;
};
/* harmony default export */ var es_message = (api);
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons-svg@4.2.1@@ant-design/icons-svg/es/asn/CloseOutlined.js
// This icon file is generated automatically.
var CloseOutlined = {
  "icon": {
    "tag": "svg",
    "attrs": {
      "viewBox": "64 64 896 896",
      "focusable": "false"
    },
    "children": [{
      "tag": "path",
      "attrs": {
        "d": "M563.8 512l262.5-312.9c4.4-5.2.7-13.1-6.1-13.1h-79.8c-4.7 0-9.2 2.1-12.3 5.7L511.6 449.8 295.1 191.7c-3-3.6-7.5-5.7-12.3-5.7H203c-6.8 0-10.5 7.9-6.1 13.1L459.4 512 196.9 824.9A7.95 7.95 0 00203 838h79.8c4.7 0 9.2-2.1 12.3-5.7l216.5-258.1 216.5 258.1c3 3.6 7.5 5.7 12.3 5.7h79.8c6.8 0 10.5-7.9 6.1-13.1L563.8 512z"
      }
    }]
  },
  "name": "close",
  "theme": "outlined"
};
/* harmony default export */ var asn_CloseOutlined = (CloseOutlined);
;// CONCATENATED MODULE: ./node_modules/_@ant-design_icons@4.8.0@@ant-design/icons/es/icons/CloseOutlined.js

// GENERATE BY ./scripts/generate.ts
// DON NOT EDIT IT MANUALLY



var CloseOutlined_CloseOutlined = function CloseOutlined(props, ref) {
  return /*#__PURE__*/_react_18_2_0_react.createElement(AntdIcon, _objectSpread2(_objectSpread2({}, props), {}, {
    ref: ref,
    icon: asn_CloseOutlined
  }));
};
CloseOutlined_CloseOutlined.displayName = 'CloseOutlined';
/* harmony default export */ var icons_CloseOutlined = (/*#__PURE__*/_react_18_2_0_react.forwardRef(CloseOutlined_CloseOutlined));
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/notification/hooks/useNotification.js





function createUseNotification(getNotificationInstance, getRCNoticeProps) {
  var useNotification = function useNotification() {
    // We can only get content by render
    var getPrefixCls;
    // We create a proxy to handle delay created instance
    var innerInstance = null;
    var proxy = {
      add: function add(noticeProps, holderCallback) {
        innerInstance === null || innerInstance === void 0 ? void 0 : innerInstance.component.add(noticeProps, holderCallback);
      }
    };
    var _useRCNotification = useNotification_useNotification(proxy),
      _useRCNotification2 = slicedToArray_slicedToArray(_useRCNotification, 2),
      hookNotify = _useRCNotification2[0],
      holder = _useRCNotification2[1];
    function notify(args) {
      var customizePrefixCls = args.prefixCls;
      var mergedPrefixCls = getPrefixCls('notification', customizePrefixCls);
      getNotificationInstance(extends_extends(extends_extends({}, args), {
        prefixCls: mergedPrefixCls
      }), function (_ref) {
        var prefixCls = _ref.prefixCls,
          instance = _ref.instance;
        innerInstance = instance;
        hookNotify(getRCNoticeProps(args, prefixCls));
      });
    }
    // Fill functions
    var hookApiRef = _react_18_2_0_react.useRef({});
    hookApiRef.current.open = notify;
    ['success', 'info', 'warning', 'error'].forEach(function (type) {
      hookApiRef.current[type] = function (args) {
        return hookApiRef.current.open(extends_extends(extends_extends({}, args), {
          type: type
        }));
      };
    });
    return [hookApiRef.current, /*#__PURE__*/_react_18_2_0_react.createElement(ConfigConsumer, {
      key: "holder"
    }, function (context) {
      getPrefixCls = context.getPrefixCls;
      return holder;
    })];
  };
  return useNotification;
}
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/notification/index.js



var __awaiter = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
  function adopt(value) {
    return value instanceof P ? value : new P(function (resolve) {
      resolve(value);
    });
  }
  return new (P || (P = Promise))(function (resolve, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }
    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }
    function step(result) {
      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
    }
    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
};










var notificationInstance = {};
var notification_defaultDuration = 4.5;
var notification_defaultTop = 24;
var defaultBottom = 24;
var defaultPrefixCls = '';
var defaultPlacement = 'topRight';
var defaultGetContainer;
var defaultCloseIcon;
var notification_rtl = false;
var notification_maxCount;
function setNotificationConfig(options) {
  var duration = options.duration,
    placement = options.placement,
    bottom = options.bottom,
    top = options.top,
    getContainer = options.getContainer,
    closeIcon = options.closeIcon,
    prefixCls = options.prefixCls;
  if (prefixCls !== undefined) {
    defaultPrefixCls = prefixCls;
  }
  if (duration !== undefined) {
    notification_defaultDuration = duration;
  }
  if (placement !== undefined) {
    defaultPlacement = placement;
  } else if (options.rtl) {
    defaultPlacement = 'topLeft';
  }
  if (bottom !== undefined) {
    defaultBottom = bottom;
  }
  if (top !== undefined) {
    notification_defaultTop = top;
  }
  if (getContainer !== undefined) {
    defaultGetContainer = getContainer;
  }
  if (closeIcon !== undefined) {
    defaultCloseIcon = closeIcon;
  }
  if (options.rtl !== undefined) {
    notification_rtl = options.rtl;
  }
  if (options.maxCount !== undefined) {
    notification_maxCount = options.maxCount;
  }
}
function getPlacementStyle(placement) {
  var top = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : notification_defaultTop;
  var bottom = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultBottom;
  var style;
  switch (placement) {
    case 'top':
      style = {
        left: '50%',
        transform: 'translateX(-50%)',
        right: 'auto',
        top: top,
        bottom: 'auto'
      };
      break;
    case 'topLeft':
      style = {
        left: 0,
        top: top,
        bottom: 'auto'
      };
      break;
    case 'topRight':
      style = {
        right: 0,
        top: top,
        bottom: 'auto'
      };
      break;
    case 'bottom':
      style = {
        left: '50%',
        transform: 'translateX(-50%)',
        right: 'auto',
        top: 'auto',
        bottom: bottom
      };
      break;
    case 'bottomLeft':
      style = {
        left: 0,
        top: 'auto',
        bottom: bottom
      };
      break;
    default:
      style = {
        right: 0,
        top: 'auto',
        bottom: bottom
      };
      break;
  }
  return style;
}
function getNotificationInstance(args, callback) {
  var _args$placement = args.placement,
    placement = _args$placement === void 0 ? defaultPlacement : _args$placement,
    top = args.top,
    bottom = args.bottom,
    _args$getContainer = args.getContainer,
    getContainer = _args$getContainer === void 0 ? defaultGetContainer : _args$getContainer,
    customizePrefixCls = args.prefixCls;
  var _globalConfig = globalConfig(),
    getPrefixCls = _globalConfig.getPrefixCls,
    getIconPrefixCls = _globalConfig.getIconPrefixCls;
  var prefixCls = getPrefixCls('notification', customizePrefixCls || defaultPrefixCls);
  var iconPrefixCls = getIconPrefixCls();
  var cacheKey = "".concat(prefixCls, "-").concat(placement);
  var cacheInstance = notificationInstance[cacheKey];
  if (cacheInstance) {
    Promise.resolve(cacheInstance).then(function (instance) {
      callback({
        prefixCls: "".concat(prefixCls, "-notice"),
        iconPrefixCls: iconPrefixCls,
        instance: instance
      });
    });
    return;
  }
  var notificationClass = _classnames_2_3_2_classnames_default()("".concat(prefixCls, "-").concat(placement), defineProperty_defineProperty({}, "".concat(prefixCls, "-rtl"), notification_rtl === true));
  notificationInstance[cacheKey] = new Promise(function (resolve) {
    _rc_notification_4_6_1_rc_notification_es.newInstance({
      prefixCls: prefixCls,
      className: notificationClass,
      style: getPlacementStyle(placement, top, bottom),
      getContainer: getContainer,
      maxCount: notification_maxCount
    }, function (notification) {
      resolve(notification);
      callback({
        prefixCls: "".concat(prefixCls, "-notice"),
        iconPrefixCls: iconPrefixCls,
        instance: notification
      });
    });
  });
}
var notification_typeToIcon = {
  success: icons_CheckCircleOutlined,
  info: icons_InfoCircleOutlined,
  error: icons_CloseCircleOutlined,
  warning: icons_ExclamationCircleOutlined
};
function notification_getRCNoticeProps(args, prefixCls, iconPrefixCls) {
  var durationArg = args.duration,
    icon = args.icon,
    type = args.type,
    description = args.description,
    message = args.message,
    btn = args.btn,
    onClose = args.onClose,
    onClick = args.onClick,
    key = args.key,
    style = args.style,
    className = args.className,
    _args$closeIcon = args.closeIcon,
    closeIcon = _args$closeIcon === void 0 ? defaultCloseIcon : _args$closeIcon,
    props = args.props;
  var duration = durationArg === undefined ? notification_defaultDuration : durationArg;
  var iconNode = null;
  if (icon) {
    iconNode = /*#__PURE__*/_react_18_2_0_react.createElement("span", {
      className: "".concat(prefixCls, "-icon")
    }, args.icon);
  } else if (type) {
    iconNode = /*#__PURE__*/_react_18_2_0_react.createElement(notification_typeToIcon[type] || null, {
      className: "".concat(prefixCls, "-icon ").concat(prefixCls, "-icon-").concat(type)
    });
  }
  var closeIconToRender = /*#__PURE__*/_react_18_2_0_react.createElement("span", {
    className: "".concat(prefixCls, "-close-x")
  }, closeIcon || /*#__PURE__*/_react_18_2_0_react.createElement(icons_CloseOutlined, {
    className: "".concat(prefixCls, "-close-icon")
  }));
  var autoMarginTag = !description && iconNode ? /*#__PURE__*/_react_18_2_0_react.createElement("span", {
    className: "".concat(prefixCls, "-message-single-line-auto-margin")
  }) : null;
  return {
    content: /*#__PURE__*/_react_18_2_0_react.createElement(config_provider, {
      iconPrefixCls: iconPrefixCls
    }, /*#__PURE__*/_react_18_2_0_react.createElement("div", {
      className: iconNode ? "".concat(prefixCls, "-with-icon") : '',
      role: "alert"
    }, iconNode, /*#__PURE__*/_react_18_2_0_react.createElement("div", {
      className: "".concat(prefixCls, "-message")
    }, autoMarginTag, message), /*#__PURE__*/_react_18_2_0_react.createElement("div", {
      className: "".concat(prefixCls, "-description")
    }, description), btn ? /*#__PURE__*/_react_18_2_0_react.createElement("span", {
      className: "".concat(prefixCls, "-btn")
    }, btn) : null)),
    duration: duration,
    closable: true,
    closeIcon: closeIconToRender,
    onClose: onClose,
    onClick: onClick,
    key: key,
    style: style || {},
    className: _classnames_2_3_2_classnames_default()(className, defineProperty_defineProperty({}, "".concat(prefixCls, "-").concat(type), !!type)),
    props: props
  };
}
function notification_notice(args) {
  getNotificationInstance(args, function (_ref) {
    var prefixCls = _ref.prefixCls,
      iconPrefixCls = _ref.iconPrefixCls,
      instance = _ref.instance;
    instance.notice(notification_getRCNoticeProps(args, prefixCls, iconPrefixCls));
  });
}
var notification_api = {
  open: notification_notice,
  close: function close(key) {
    Object.keys(notificationInstance).forEach(function (cacheKey) {
      return Promise.resolve(notificationInstance[cacheKey]).then(function (instance) {
        instance.removeNotice(key);
      });
    });
  },
  config: setNotificationConfig,
  destroy: function destroy() {
    Object.keys(notificationInstance).forEach(function (cacheKey) {
      Promise.resolve(notificationInstance[cacheKey]).then(function (instance) {
        instance.destroy();
      });
      delete notificationInstance[cacheKey]; // lgtm[js/missing-await]
    });
  }
};

['success', 'info', 'warning', 'error'].forEach(function (type) {
  notification_api[type] = function (args) {
    return notification_api.open(extends_extends(extends_extends({}, args), {
      type: type
    }));
  };
});
notification_api.warn = notification_api.warning;
notification_api.useNotification = createUseNotification(getNotificationInstance, notification_getRCNoticeProps);
/** @internal test Only function. Not work on production */
var notification_getInstance = function getInstance(cacheKey) {
  return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
    return _regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          return _context.abrupt("return",  false ? 0 : null);
        case 1:
        case "end":
          return _context.stop();
      }
    }, _callee);
  }));
};
/* harmony default export */ var notification = (notification_api);
;// CONCATENATED MODULE: ./node_modules/_@ctrl_tinycolor@3.6.0@@ctrl/tinycolor/dist/module/index.js




var TinyColor = /** @class */function () {
  function TinyColor(color, opts) {
    if (color === void 0) {
      color = '';
    }
    if (opts === void 0) {
      opts = {};
    }
    var _a;
    // If input is already a tinycolor, return itself
    if (color instanceof TinyColor) {
      // eslint-disable-next-line no-constructor-return
      return color;
    }
    if (typeof color === 'number') {
      color = numberInputToObject(color);
    }
    this.originalInput = color;
    var rgb = inputToRGB(color);
    this.originalInput = color;
    this.r = rgb.r;
    this.g = rgb.g;
    this.b = rgb.b;
    this.a = rgb.a;
    this.roundA = Math.round(100 * this.a) / 100;
    this.format = (_a = opts.format) !== null && _a !== void 0 ? _a : rgb.format;
    this.gradientType = opts.gradientType;
    // Don't let the range of [0,255] come back in [0,1].
    // Potentially lose a little bit of precision here, but will fix issues where
    // .5 gets interpreted as half of the total, instead of half of 1
    // If it was supposed to be 128, this was already taken care of by `inputToRgb`
    if (this.r < 1) {
      this.r = Math.round(this.r);
    }
    if (this.g < 1) {
      this.g = Math.round(this.g);
    }
    if (this.b < 1) {
      this.b = Math.round(this.b);
    }
    this.isValid = rgb.ok;
  }
  TinyColor.prototype.isDark = function () {
    return this.getBrightness() < 128;
  };
  TinyColor.prototype.isLight = function () {
    return !this.isDark();
  };
  /**
   * Returns the perceived brightness of the color, from 0-255.
   */
  TinyColor.prototype.getBrightness = function () {
    // http://www.w3.org/TR/AERT#color-contrast
    var rgb = this.toRgb();
    return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;
  };
  /**
   * Returns the perceived luminance of a color, from 0-1.
   */
  TinyColor.prototype.getLuminance = function () {
    // http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
    var rgb = this.toRgb();
    var R;
    var G;
    var B;
    var RsRGB = rgb.r / 255;
    var GsRGB = rgb.g / 255;
    var BsRGB = rgb.b / 255;
    if (RsRGB <= 0.03928) {
      R = RsRGB / 12.92;
    } else {
      // eslint-disable-next-line prefer-exponentiation-operator
      R = Math.pow((RsRGB + 0.055) / 1.055, 2.4);
    }
    if (GsRGB <= 0.03928) {
      G = GsRGB / 12.92;
    } else {
      // eslint-disable-next-line prefer-exponentiation-operator
      G = Math.pow((GsRGB + 0.055) / 1.055, 2.4);
    }
    if (BsRGB <= 0.03928) {
      B = BsRGB / 12.92;
    } else {
      // eslint-disable-next-line prefer-exponentiation-operator
      B = Math.pow((BsRGB + 0.055) / 1.055, 2.4);
    }
    return 0.2126 * R + 0.7152 * G + 0.0722 * B;
  };
  /**
   * Returns the alpha value of a color, from 0-1.
   */
  TinyColor.prototype.getAlpha = function () {
    return this.a;
  };
  /**
   * Sets the alpha value on the current color.
   *
   * @param alpha - The new alpha value. The accepted range is 0-1.
   */
  TinyColor.prototype.setAlpha = function (alpha) {
    this.a = boundAlpha(alpha);
    this.roundA = Math.round(100 * this.a) / 100;
    return this;
  };
  /**
   * Returns whether the color is monochrome.
   */
  TinyColor.prototype.isMonochrome = function () {
    var s = this.toHsl().s;
    return s === 0;
  };
  /**
   * Returns the object as a HSVA object.
   */
  TinyColor.prototype.toHsv = function () {
    var hsv = rgbToHsv(this.r, this.g, this.b);
    return {
      h: hsv.h * 360,
      s: hsv.s,
      v: hsv.v,
      a: this.a
    };
  };
  /**
   * Returns the hsva values interpolated into a string with the following format:
   * "hsva(xxx, xxx, xxx, xx)".
   */
  TinyColor.prototype.toHsvString = function () {
    var hsv = rgbToHsv(this.r, this.g, this.b);
    var h = Math.round(hsv.h * 360);
    var s = Math.round(hsv.s * 100);
    var v = Math.round(hsv.v * 100);
    return this.a === 1 ? "hsv(".concat(h, ", ").concat(s, "%, ").concat(v, "%)") : "hsva(".concat(h, ", ").concat(s, "%, ").concat(v, "%, ").concat(this.roundA, ")");
  };
  /**
   * Returns the object as a HSLA object.
   */
  TinyColor.prototype.toHsl = function () {
    var hsl = rgbToHsl(this.r, this.g, this.b);
    return {
      h: hsl.h * 360,
      s: hsl.s,
      l: hsl.l,
      a: this.a
    };
  };
  /**
   * Returns the hsla values interpolated into a string with the following format:
   * "hsla(xxx, xxx, xxx, xx)".
   */
  TinyColor.prototype.toHslString = function () {
    var hsl = rgbToHsl(this.r, this.g, this.b);
    var h = Math.round(hsl.h * 360);
    var s = Math.round(hsl.s * 100);
    var l = Math.round(hsl.l * 100);
    return this.a === 1 ? "hsl(".concat(h, ", ").concat(s, "%, ").concat(l, "%)") : "hsla(".concat(h, ", ").concat(s, "%, ").concat(l, "%, ").concat(this.roundA, ")");
  };
  /**
   * Returns the hex value of the color.
   * @param allow3Char will shorten hex value to 3 char if possible
   */
  TinyColor.prototype.toHex = function (allow3Char) {
    if (allow3Char === void 0) {
      allow3Char = false;
    }
    return rgbToHex(this.r, this.g, this.b, allow3Char);
  };
  /**
   * Returns the hex value of the color -with a # prefixed.
   * @param allow3Char will shorten hex value to 3 char if possible
   */
  TinyColor.prototype.toHexString = function (allow3Char) {
    if (allow3Char === void 0) {
      allow3Char = false;
    }
    return '#' + this.toHex(allow3Char);
  };
  /**
   * Returns the hex 8 value of the color.
   * @param allow4Char will shorten hex value to 4 char if possible
   */
  TinyColor.prototype.toHex8 = function (allow4Char) {
    if (allow4Char === void 0) {
      allow4Char = false;
    }
    return rgbaToHex(this.r, this.g, this.b, this.a, allow4Char);
  };
  /**
   * Returns the hex 8 value of the color -with a # prefixed.
   * @param allow4Char will shorten hex value to 4 char if possible
   */
  TinyColor.prototype.toHex8String = function (allow4Char) {
    if (allow4Char === void 0) {
      allow4Char = false;
    }
    return '#' + this.toHex8(allow4Char);
  };
  /**
   * Returns the shorter hex value of the color depends on its alpha -with a # prefixed.
   * @param allowShortChar will shorten hex value to 3 or 4 char if possible
   */
  TinyColor.prototype.toHexShortString = function (allowShortChar) {
    if (allowShortChar === void 0) {
      allowShortChar = false;
    }
    return this.a === 1 ? this.toHexString(allowShortChar) : this.toHex8String(allowShortChar);
  };
  /**
   * Returns the object as a RGBA object.
   */
  TinyColor.prototype.toRgb = function () {
    return {
      r: Math.round(this.r),
      g: Math.round(this.g),
      b: Math.round(this.b),
      a: this.a
    };
  };
  /**
   * Returns the RGBA values interpolated into a string with the following format:
   * "RGBA(xxx, xxx, xxx, xx)".
   */
  TinyColor.prototype.toRgbString = function () {
    var r = Math.round(this.r);
    var g = Math.round(this.g);
    var b = Math.round(this.b);
    return this.a === 1 ? "rgb(".concat(r, ", ").concat(g, ", ").concat(b, ")") : "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(this.roundA, ")");
  };
  /**
   * Returns the object as a RGBA object.
   */
  TinyColor.prototype.toPercentageRgb = function () {
    var fmt = function fmt(x) {
      return "".concat(Math.round(bound01(x, 255) * 100), "%");
    };
    return {
      r: fmt(this.r),
      g: fmt(this.g),
      b: fmt(this.b),
      a: this.a
    };
  };
  /**
   * Returns the RGBA relative values interpolated into a string
   */
  TinyColor.prototype.toPercentageRgbString = function () {
    var rnd = function rnd(x) {
      return Math.round(bound01(x, 255) * 100);
    };
    return this.a === 1 ? "rgb(".concat(rnd(this.r), "%, ").concat(rnd(this.g), "%, ").concat(rnd(this.b), "%)") : "rgba(".concat(rnd(this.r), "%, ").concat(rnd(this.g), "%, ").concat(rnd(this.b), "%, ").concat(this.roundA, ")");
  };
  /**
   * The 'real' name of the color -if there is one.
   */
  TinyColor.prototype.toName = function () {
    if (this.a === 0) {
      return 'transparent';
    }
    if (this.a < 1) {
      return false;
    }
    var hex = '#' + rgbToHex(this.r, this.g, this.b, false);
    for (var _i = 0, _a = Object.entries(names); _i < _a.length; _i++) {
      var _b = _a[_i],
        key = _b[0],
        value = _b[1];
      if (hex === value) {
        return key;
      }
    }
    return false;
  };
  TinyColor.prototype.toString = function (format) {
    var formatSet = Boolean(format);
    format = format !== null && format !== void 0 ? format : this.format;
    var formattedString = false;
    var hasAlpha = this.a < 1 && this.a >= 0;
    var needsAlphaFormat = !formatSet && hasAlpha && (format.startsWith('hex') || format === 'name');
    if (needsAlphaFormat) {
      // Special case for "transparent", all other non-alpha formats
      // will return rgba when there is transparency.
      if (format === 'name' && this.a === 0) {
        return this.toName();
      }
      return this.toRgbString();
    }
    if (format === 'rgb') {
      formattedString = this.toRgbString();
    }
    if (format === 'prgb') {
      formattedString = this.toPercentageRgbString();
    }
    if (format === 'hex' || format === 'hex6') {
      formattedString = this.toHexString();
    }
    if (format === 'hex3') {
      formattedString = this.toHexString(true);
    }
    if (format === 'hex4') {
      formattedString = this.toHex8String(true);
    }
    if (format === 'hex8') {
      formattedString = this.toHex8String();
    }
    if (format === 'name') {
      formattedString = this.toName();
    }
    if (format === 'hsl') {
      formattedString = this.toHslString();
    }
    if (format === 'hsv') {
      formattedString = this.toHsvString();
    }
    return formattedString || this.toHexString();
  };
  TinyColor.prototype.toNumber = function () {
    return (Math.round(this.r) << 16) + (Math.round(this.g) << 8) + Math.round(this.b);
  };
  TinyColor.prototype.clone = function () {
    return new TinyColor(this.toString());
  };
  /**
   * Lighten the color a given amount. Providing 100 will always return white.
   * @param amount - valid between 1-100
   */
  TinyColor.prototype.lighten = function (amount) {
    if (amount === void 0) {
      amount = 10;
    }
    var hsl = this.toHsl();
    hsl.l += amount / 100;
    hsl.l = clamp01(hsl.l);
    return new TinyColor(hsl);
  };
  /**
   * Brighten the color a given amount, from 0 to 100.
   * @param amount - valid between 1-100
   */
  TinyColor.prototype.brighten = function (amount) {
    if (amount === void 0) {
      amount = 10;
    }
    var rgb = this.toRgb();
    rgb.r = Math.max(0, Math.min(255, rgb.r - Math.round(255 * -(amount / 100))));
    rgb.g = Math.max(0, Math.min(255, rgb.g - Math.round(255 * -(amount / 100))));
    rgb.b = Math.max(0, Math.min(255, rgb.b - Math.round(255 * -(amount / 100))));
    return new TinyColor(rgb);
  };
  /**
   * Darken the color a given amount, from 0 to 100.
   * Providing 100 will always return black.
   * @param amount - valid between 1-100
   */
  TinyColor.prototype.darken = function (amount) {
    if (amount === void 0) {
      amount = 10;
    }
    var hsl = this.toHsl();
    hsl.l -= amount / 100;
    hsl.l = clamp01(hsl.l);
    return new TinyColor(hsl);
  };
  /**
   * Mix the color with pure white, from 0 to 100.
   * Providing 0 will do nothing, providing 100 will always return white.
   * @param amount - valid between 1-100
   */
  TinyColor.prototype.tint = function (amount) {
    if (amount === void 0) {
      amount = 10;
    }
    return this.mix('white', amount);
  };
  /**
   * Mix the color with pure black, from 0 to 100.
   * Providing 0 will do nothing, providing 100 will always return black.
   * @param amount - valid between 1-100
   */
  TinyColor.prototype.shade = function (amount) {
    if (amount === void 0) {
      amount = 10;
    }
    return this.mix('black', amount);
  };
  /**
   * Desaturate the color a given amount, from 0 to 100.
   * Providing 100 will is the same as calling greyscale
   * @param amount - valid between 1-100
   */
  TinyColor.prototype.desaturate = function (amount) {
    if (amount === void 0) {
      amount = 10;
    }
    var hsl = this.toHsl();
    hsl.s -= amount / 100;
    hsl.s = clamp01(hsl.s);
    return new TinyColor(hsl);
  };
  /**
   * Saturate the color a given amount, from 0 to 100.
   * @param amount - valid between 1-100
   */
  TinyColor.prototype.saturate = function (amount) {
    if (amount === void 0) {
      amount = 10;
    }
    var hsl = this.toHsl();
    hsl.s += amount / 100;
    hsl.s = clamp01(hsl.s);
    return new TinyColor(hsl);
  };
  /**
   * Completely desaturates a color into greyscale.
   * Same as calling `desaturate(100)`
   */
  TinyColor.prototype.greyscale = function () {
    return this.desaturate(100);
  };
  /**
   * Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.
   * Values outside of this range will be wrapped into this range.
   */
  TinyColor.prototype.spin = function (amount) {
    var hsl = this.toHsl();
    var hue = (hsl.h + amount) % 360;
    hsl.h = hue < 0 ? 360 + hue : hue;
    return new TinyColor(hsl);
  };
  /**
   * Mix the current color a given amount with another color, from 0 to 100.
   * 0 means no mixing (return current color).
   */
  TinyColor.prototype.mix = function (color, amount) {
    if (amount === void 0) {
      amount = 50;
    }
    var rgb1 = this.toRgb();
    var rgb2 = new TinyColor(color).toRgb();
    var p = amount / 100;
    var rgba = {
      r: (rgb2.r - rgb1.r) * p + rgb1.r,
      g: (rgb2.g - rgb1.g) * p + rgb1.g,
      b: (rgb2.b - rgb1.b) * p + rgb1.b,
      a: (rgb2.a - rgb1.a) * p + rgb1.a
    };
    return new TinyColor(rgba);
  };
  TinyColor.prototype.analogous = function (results, slices) {
    if (results === void 0) {
      results = 6;
    }
    if (slices === void 0) {
      slices = 30;
    }
    var hsl = this.toHsl();
    var part = 360 / slices;
    var ret = [this];
    for (hsl.h = (hsl.h - (part * results >> 1) + 720) % 360; --results;) {
      hsl.h = (hsl.h + part) % 360;
      ret.push(new TinyColor(hsl));
    }
    return ret;
  };
  /**
   * taken from https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js
   */
  TinyColor.prototype.complement = function () {
    var hsl = this.toHsl();
    hsl.h = (hsl.h + 180) % 360;
    return new TinyColor(hsl);
  };
  TinyColor.prototype.monochromatic = function (results) {
    if (results === void 0) {
      results = 6;
    }
    var hsv = this.toHsv();
    var h = hsv.h;
    var s = hsv.s;
    var v = hsv.v;
    var res = [];
    var modification = 1 / results;
    while (results--) {
      res.push(new TinyColor({
        h: h,
        s: s,
        v: v
      }));
      v = (v + modification) % 1;
    }
    return res;
  };
  TinyColor.prototype.splitcomplement = function () {
    var hsl = this.toHsl();
    var h = hsl.h;
    return [this, new TinyColor({
      h: (h + 72) % 360,
      s: hsl.s,
      l: hsl.l
    }), new TinyColor({
      h: (h + 216) % 360,
      s: hsl.s,
      l: hsl.l
    })];
  };
  /**
   * Compute how the color would appear on a background
   */
  TinyColor.prototype.onBackground = function (background) {
    var fg = this.toRgb();
    var bg = new TinyColor(background).toRgb();
    var alpha = fg.a + bg.a * (1 - fg.a);
    return new TinyColor({
      r: (fg.r * fg.a + bg.r * bg.a * (1 - fg.a)) / alpha,
      g: (fg.g * fg.a + bg.g * bg.a * (1 - fg.a)) / alpha,
      b: (fg.b * fg.a + bg.b * bg.a * (1 - fg.a)) / alpha,
      a: alpha
    });
  };
  /**
   * Alias for `polyad(3)`
   */
  TinyColor.prototype.triad = function () {
    return this.polyad(3);
  };
  /**
   * Alias for `polyad(4)`
   */
  TinyColor.prototype.tetrad = function () {
    return this.polyad(4);
  };
  /**
   * Get polyad colors, like (for 1, 2, 3, 4, 5, 6, 7, 8, etc...)
   * monad, dyad, triad, tetrad, pentad, hexad, heptad, octad, etc...
   */
  TinyColor.prototype.polyad = function (n) {
    var hsl = this.toHsl();
    var h = hsl.h;
    var result = [this];
    var increment = 360 / n;
    for (var i = 1; i < n; i++) {
      result.push(new TinyColor({
        h: (h + i * increment) % 360,
        s: hsl.s,
        l: hsl.l
      }));
    }
    return result;
  };
  /**
   * compare color vs current color
   */
  TinyColor.prototype.equals = function (color) {
    return this.toRgbString() === new TinyColor(color).toRgbString();
  };
  return TinyColor;
}();

// kept for backwards compatability with v1
function tinycolor(color, opts) {
  if (color === void 0) {
    color = '';
  }
  if (opts === void 0) {
    opts = {};
  }
  return new TinyColor(color, opts);
}
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/config-provider/cssVariables.js
/* eslint-disable import/prefer-default-export, prefer-destructuring */





var dynamicStyleMark = "-ant-".concat(Date.now(), "-").concat(Math.random());
function getStyle(globalPrefixCls, theme) {
  var variables = {};
  var formatColor = function formatColor(color, updater) {
    var clone = color.clone();
    clone = (updater === null || updater === void 0 ? void 0 : updater(clone)) || clone;
    return clone.toRgbString();
  };
  var fillColor = function fillColor(colorVal, type) {
    var baseColor = new TinyColor(colorVal);
    var colorPalettes = generate(baseColor.toRgbString());
    variables["".concat(type, "-color")] = formatColor(baseColor);
    variables["".concat(type, "-color-disabled")] = colorPalettes[1];
    variables["".concat(type, "-color-hover")] = colorPalettes[4];
    variables["".concat(type, "-color-active")] = colorPalettes[6];
    variables["".concat(type, "-color-outline")] = baseColor.clone().setAlpha(0.2).toRgbString();
    variables["".concat(type, "-color-deprecated-bg")] = colorPalettes[0];
    variables["".concat(type, "-color-deprecated-border")] = colorPalettes[2];
  };
  // ================ Primary Color ================
  if (theme.primaryColor) {
    fillColor(theme.primaryColor, 'primary');
    var primaryColor = new TinyColor(theme.primaryColor);
    var primaryColors = generate(primaryColor.toRgbString());
    // Legacy - We should use semantic naming standard
    primaryColors.forEach(function (color, index) {
      variables["primary-".concat(index + 1)] = color;
    });
    // Deprecated
    variables['primary-color-deprecated-l-35'] = formatColor(primaryColor, function (c) {
      return c.lighten(35);
    });
    variables['primary-color-deprecated-l-20'] = formatColor(primaryColor, function (c) {
      return c.lighten(20);
    });
    variables['primary-color-deprecated-t-20'] = formatColor(primaryColor, function (c) {
      return c.tint(20);
    });
    variables['primary-color-deprecated-t-50'] = formatColor(primaryColor, function (c) {
      return c.tint(50);
    });
    variables['primary-color-deprecated-f-12'] = formatColor(primaryColor, function (c) {
      return c.setAlpha(c.getAlpha() * 0.12);
    });
    var primaryActiveColor = new TinyColor(primaryColors[0]);
    variables['primary-color-active-deprecated-f-30'] = formatColor(primaryActiveColor, function (c) {
      return c.setAlpha(c.getAlpha() * 0.3);
    });
    variables['primary-color-active-deprecated-d-02'] = formatColor(primaryActiveColor, function (c) {
      return c.darken(2);
    });
  }
  // ================ Success Color ================
  if (theme.successColor) {
    fillColor(theme.successColor, 'success');
  }
  // ================ Warning Color ================
  if (theme.warningColor) {
    fillColor(theme.warningColor, 'warning');
  }
  // ================= Error Color =================
  if (theme.errorColor) {
    fillColor(theme.errorColor, 'error');
  }
  // ================= Info Color ==================
  if (theme.infoColor) {
    fillColor(theme.infoColor, 'info');
  }
  // Convert to css variables
  var cssList = Object.keys(variables).map(function (key) {
    return "--".concat(globalPrefixCls, "-").concat(key, ": ").concat(variables[key], ";");
  });
  return "\n  :root {\n    ".concat(cssList.join('\n'), "\n  }\n  ").trim();
}
function registerTheme(globalPrefixCls, theme) {
  var style = getStyle(globalPrefixCls, theme);
  if (canUseDom()) {
    updateCSS(style, "".concat(dynamicStyleMark, "-dynamic-theme"));
  } else {
     false ? 0 : void 0;
  }
}
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/config-provider/DisabledContext.js

var DisabledContext = /*#__PURE__*/_react_18_2_0_react.createContext(false);
var DisabledContextProvider = function DisabledContextProvider(_ref) {
  var children = _ref.children,
    disabled = _ref.disabled;
  var originDisabled = _react_18_2_0_react.useContext(DisabledContext);
  return /*#__PURE__*/_react_18_2_0_react.createElement(DisabledContext.Provider, {
    value: disabled !== null && disabled !== void 0 ? disabled : originDisabled
  }, children);
};
/* harmony default export */ var config_provider_DisabledContext = (DisabledContext);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/config-provider/SizeContext.js

var SizeContext = /*#__PURE__*/_react_18_2_0_react.createContext(undefined);
var SizeContextProvider = function SizeContextProvider(_ref) {
  var children = _ref.children,
    size = _ref.size;
  return /*#__PURE__*/_react_18_2_0_react.createElement(SizeContext.Consumer, null, function (originSize) {
    return /*#__PURE__*/_react_18_2_0_react.createElement(SizeContext.Provider, {
      value: size || originSize
    }, children);
  });
};
/* harmony default export */ var config_provider_SizeContext = (SizeContext);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/config-provider/index.js















var configConsumerProps = (/* unused pure expression or super */ null && (['getTargetContainer', 'getPopupContainer', 'rootPrefixCls', 'getPrefixCls', 'renderEmpty', 'csp', 'autoInsertSpaceInButton', 'locale', 'pageHeader']));
// These props is used by `useContext` directly in sub component
var PASSED_PROPS = ['getTargetContainer', 'getPopupContainer', 'renderEmpty', 'pageHeader', 'input', 'pagination', 'form'];
var config_provider_defaultPrefixCls = 'ant';
var defaultIconPrefixCls = 'anticon';
var globalPrefixCls;
var globalIconPrefixCls;
function getGlobalPrefixCls() {
  return globalPrefixCls || config_provider_defaultPrefixCls;
}
function getGlobalIconPrefixCls() {
  return globalIconPrefixCls || defaultIconPrefixCls;
}
var setGlobalConfig = function setGlobalConfig(_ref) {
  var prefixCls = _ref.prefixCls,
    iconPrefixCls = _ref.iconPrefixCls,
    theme = _ref.theme;
  if (prefixCls !== undefined) {
    globalPrefixCls = prefixCls;
  }
  if (iconPrefixCls !== undefined) {
    globalIconPrefixCls = iconPrefixCls;
  }
  if (theme) {
    registerTheme(getGlobalPrefixCls(), theme);
  }
};
var globalConfig = function globalConfig() {
  return {
    getPrefixCls: function getPrefixCls(suffixCls, customizePrefixCls) {
      if (customizePrefixCls) return customizePrefixCls;
      return suffixCls ? "".concat(getGlobalPrefixCls(), "-").concat(suffixCls) : getGlobalPrefixCls();
    },
    getIconPrefixCls: getGlobalIconPrefixCls,
    getRootPrefixCls: function getRootPrefixCls(rootPrefixCls, customizePrefixCls) {
      // Customize rootPrefixCls is first priority
      if (rootPrefixCls) {
        return rootPrefixCls;
      }
      // If Global prefixCls provided, use this
      if (globalPrefixCls) {
        return globalPrefixCls;
      }
      // [Legacy] If customize prefixCls provided, we cut it to get the prefixCls
      if (customizePrefixCls && customizePrefixCls.includes('-')) {
        return customizePrefixCls.replace(/^(.*)-[^-]*$/, '$1');
      }
      // Fallback to default prefixCls
      return getGlobalPrefixCls();
    }
  };
};
var ProviderChildren = function ProviderChildren(props) {
  var _a, _b;
  var children = props.children,
    csp = props.csp,
    autoInsertSpaceInButton = props.autoInsertSpaceInButton,
    form = props.form,
    locale = props.locale,
    componentSize = props.componentSize,
    direction = props.direction,
    space = props.space,
    virtual = props.virtual,
    dropdownMatchSelectWidth = props.dropdownMatchSelectWidth,
    legacyLocale = props.legacyLocale,
    parentContext = props.parentContext,
    iconPrefixCls = props.iconPrefixCls,
    componentDisabled = props.componentDisabled;
  var getPrefixCls = _react_18_2_0_react.useCallback(function (suffixCls, customizePrefixCls) {
    var prefixCls = props.prefixCls;
    if (customizePrefixCls) return customizePrefixCls;
    var mergedPrefixCls = prefixCls || parentContext.getPrefixCls('');
    return suffixCls ? "".concat(mergedPrefixCls, "-").concat(suffixCls) : mergedPrefixCls;
  }, [parentContext.getPrefixCls, props.prefixCls]);
  var config = extends_extends(extends_extends({}, parentContext), {
    csp: csp,
    autoInsertSpaceInButton: autoInsertSpaceInButton,
    locale: locale || legacyLocale,
    direction: direction,
    space: space,
    virtual: virtual,
    dropdownMatchSelectWidth: dropdownMatchSelectWidth,
    getPrefixCls: getPrefixCls
  });
  // Pass the props used by `useContext` directly with child component.
  // These props should merged into `config`.
  PASSED_PROPS.forEach(function (propName) {
    var propValue = props[propName];
    if (propValue) {
      config[propName] = propValue;
    }
  });
  // https://github.com/ant-design/ant-design/issues/27617
  var memoedConfig = useMemo_useMemo(function () {
    return config;
  }, config, function (prevConfig, currentConfig) {
    var prevKeys = Object.keys(prevConfig);
    var currentKeys = Object.keys(currentConfig);
    return prevKeys.length !== currentKeys.length || prevKeys.some(function (key) {
      return prevConfig[key] !== currentConfig[key];
    });
  });
  var memoIconContextValue = _react_18_2_0_react.useMemo(function () {
    return {
      prefixCls: iconPrefixCls,
      csp: csp
    };
  }, [iconPrefixCls, csp]);
  var childNode = children;
  // Additional Form provider
  var validateMessages = {};
  if (locale) {
    validateMessages = ((_a = locale.Form) === null || _a === void 0 ? void 0 : _a.defaultValidateMessages) || ((_b = locale_default.Form) === null || _b === void 0 ? void 0 : _b.defaultValidateMessages) || {};
  }
  if (form && form.validateMessages) {
    validateMessages = extends_extends(extends_extends({}, validateMessages), form.validateMessages);
  }
  if (Object.keys(validateMessages).length > 0) {
    childNode = /*#__PURE__*/_react_18_2_0_react.createElement(FormProvider, {
      validateMessages: validateMessages
    }, children);
  }
  if (locale) {
    childNode = /*#__PURE__*/_react_18_2_0_react.createElement(locale_provider, {
      locale: locale,
      _ANT_MARK__: ANT_MARK
    }, childNode);
  }
  if (iconPrefixCls || csp) {
    childNode = /*#__PURE__*/_react_18_2_0_react.createElement(Context.Provider, {
      value: memoIconContextValue
    }, childNode);
  }
  if (componentSize) {
    childNode = /*#__PURE__*/_react_18_2_0_react.createElement(SizeContextProvider, {
      size: componentSize
    }, childNode);
  }
  if (componentDisabled !== undefined) {
    childNode = /*#__PURE__*/_react_18_2_0_react.createElement(DisabledContextProvider, {
      disabled: componentDisabled
    }, childNode);
  }
  return /*#__PURE__*/_react_18_2_0_react.createElement(context_ConfigContext.Provider, {
    value: memoedConfig
  }, childNode);
};
var config_provider_ConfigProvider = function ConfigProvider(props) {
  _react_18_2_0_react.useEffect(function () {
    if (props.direction) {
      es_message.config({
        rtl: props.direction === 'rtl'
      });
      notification.config({
        rtl: props.direction === 'rtl'
      });
    }
  }, [props.direction]);
  return /*#__PURE__*/_react_18_2_0_react.createElement(locale_provider_LocaleReceiver, null, function (_, __, legacyLocale) {
    return /*#__PURE__*/_react_18_2_0_react.createElement(ConfigConsumer, null, function (context) {
      return /*#__PURE__*/_react_18_2_0_react.createElement(ProviderChildren, extends_extends({
        parentContext: context,
        legacyLocale: legacyLocale
      }, props));
    });
  });
};
/** @private internal Usage. do not use in your production */
config_provider_ConfigProvider.ConfigContext = context_ConfigContext;
config_provider_ConfigProvider.SizeContext = config_provider_SizeContext;
config_provider_ConfigProvider.config = setGlobalConfig;
/* harmony default export */ var config_provider = (config_provider_ConfigProvider);
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/omit.js

function omit_omit(obj, fields) {
  var clone = _objectSpread2({}, obj);
  if (Array.isArray(fields)) {
    fields.forEach(function (key) {
      delete clone[key];
    });
  }
  return clone;
}
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/space/Compact.js


var __rest = undefined && undefined.__rest || function (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;
};




var SpaceCompactItemContext = /*#__PURE__*/_react_18_2_0_react.createContext(null);
var useCompactItemContext = function useCompactItemContext(prefixCls, direction) {
  var compactItemContext = _react_18_2_0_react.useContext(SpaceCompactItemContext);
  var compactItemClassnames = _react_18_2_0_react.useMemo(function () {
    var _classNames;
    if (!compactItemContext) return '';
    var compactDirection = compactItemContext.compactDirection,
      isFirstItem = compactItemContext.isFirstItem,
      isLastItem = compactItemContext.isLastItem;
    var separator = compactDirection === 'vertical' ? '-vertical-' : '-';
    return _classnames_2_3_2_classnames_default()((_classNames = {}, defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-compact").concat(separator, "item"), true), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-compact").concat(separator, "first-item"), isFirstItem), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-compact").concat(separator, "last-item"), isLastItem), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-compact").concat(separator, "item-rtl"), direction === 'rtl'), _classNames));
  }, [prefixCls, direction, compactItemContext]);
  return {
    compactSize: compactItemContext === null || compactItemContext === void 0 ? void 0 : compactItemContext.compactSize,
    compactDirection: compactItemContext === null || compactItemContext === void 0 ? void 0 : compactItemContext.compactDirection,
    compactItemClassnames: compactItemClassnames
  };
};
var NoCompactStyle = function NoCompactStyle(_ref) {
  var children = _ref.children;
  return /*#__PURE__*/_react_18_2_0_react.createElement(SpaceCompactItemContext.Provider, {
    value: null
  }, children);
};
var CompactItem = function CompactItem(_a) {
  var children = _a.children,
    otherProps = __rest(_a, ["children"]);
  return /*#__PURE__*/React.createElement(SpaceCompactItemContext.Provider, {
    value: otherProps
  }, children);
};
var Compact = function Compact(props) {
  var _classNames2;
  var _React$useContext = React.useContext(ConfigContext),
    getPrefixCls = _React$useContext.getPrefixCls,
    directionConfig = _React$useContext.direction;
  var _props$size = props.size,
    size = _props$size === void 0 ? 'middle' : _props$size,
    direction = props.direction,
    block = props.block,
    customizePrefixCls = props.prefixCls,
    className = props.className,
    children = props.children,
    restProps = __rest(props, ["size", "direction", "block", "prefixCls", "className", "children"]);
  var prefixCls = getPrefixCls('space-compact', customizePrefixCls);
  var clx = classNames(prefixCls, (_classNames2 = {}, _defineProperty(_classNames2, "".concat(prefixCls, "-rtl"), directionConfig === 'rtl'), _defineProperty(_classNames2, "".concat(prefixCls, "-block"), block), _defineProperty(_classNames2, "".concat(prefixCls, "-vertical"), direction === 'vertical'), _classNames2), className);
  var compactItemContext = React.useContext(SpaceCompactItemContext);
  var childNodes = toArray(children);
  var nodes = React.useMemo(function () {
    return childNodes.map(function (child, i) {
      var key = child && child.key || "".concat(prefixCls, "-item-").concat(i);
      return /*#__PURE__*/React.createElement(CompactItem, {
        key: key,
        compactSize: size,
        compactDirection: direction,
        isFirstItem: i === 0 && (!compactItemContext || (compactItemContext === null || compactItemContext === void 0 ? void 0 : compactItemContext.isFirstItem)),
        isLastItem: i === childNodes.length - 1 && (!compactItemContext || (compactItemContext === null || compactItemContext === void 0 ? void 0 : compactItemContext.isLastItem))
      }, child);
    });
  }, [size, childNodes, compactItemContext]);
  // =========================== Render ===========================
  if (childNodes.length === 0) {
    return null;
  }
  return /*#__PURE__*/React.createElement("div", _extends({
    className: clx
  }, restProps), nodes);
};
/* harmony default export */ var space_Compact = ((/* unused pure expression or super */ null && (Compact)));
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/_util/reactNode.js

var isValidElement = _react_18_2_0_react.isValidElement;

function isFragment(child) {
  return child && isValidElement(child) && child.type === _react_18_2_0_react.Fragment;
}
function replaceElement(element, replacement, props) {
  if (!isValidElement(element)) {
    return replacement;
  }
  return /*#__PURE__*/_react_18_2_0_react.cloneElement(element, typeof props === 'function' ? props(element.props || {}) : props);
}
function cloneElement(element, props) {
  return replaceElement(element, element, props);
}
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/_util/type.js
// https://stackoverflow.com/questions/46176165/ways-to-get-string-literal-type-of-array-values-without-enum-overhead
var tuple = function tuple() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }
  return args;
};
var tupleNum = function tupleNum() {
  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
    args[_key2] = arguments[_key2];
  }
  return args;
};
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/_util/raf.js

var id = 0;
var ids = {};
// Support call raf with delay specified frame
function raf_wrapperRaf(callback) {
  var delayFrames = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
  var myId = id++;
  var restFrames = delayFrames;
  function internalCallback() {
    restFrames -= 1;
    if (restFrames <= 0) {
      callback();
      delete ids[myId];
    } else {
      ids[myId] = es_raf(internalCallback);
    }
  }
  ids[myId] = es_raf(internalCallback);
  return myId;
}
raf_wrapperRaf.cancel = function cancel(pid) {
  if (pid === undefined) return;
  es_raf.cancel(ids[pid]);
  delete ids[pid];
};
raf_wrapperRaf.ids = ids; // export this for test usage
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/_util/wave.js











var styleForPseudo;
// Where el is the DOM element you'd like to test for visibility
function isHidden(element) {
  if (false) {}
  return !element || element.offsetParent === null || element.hidden;
}
function getValidateContainer(nodeRoot) {
  if (nodeRoot instanceof Document) {
    return nodeRoot.body;
  }
  return Array.from(nodeRoot.childNodes).find(function (ele) {
    return (ele === null || ele === void 0 ? void 0 : ele.nodeType) === Node.ELEMENT_NODE;
  });
}
function isNotGrey(color) {
  // eslint-disable-next-line no-useless-escape
  var match = (color || '').match(/rgba?\((\d*), (\d*), (\d*)(, [\d.]*)?\)/);
  if (match && match[1] && match[2] && match[3]) {
    return !(match[1] === match[2] && match[2] === match[3]);
  }
  return true;
}
var Wave = /*#__PURE__*/function (_React$Component) {
  _inherits(Wave, _React$Component);
  var _super = _createSuper(Wave);
  function Wave() {
    var _this;
    _classCallCheck(this, Wave);
    _this = _super.apply(this, arguments);
    _this.containerRef = /*#__PURE__*/_react_18_2_0_react.createRef();
    _this.animationStart = false;
    _this.destroyed = false;
    _this.onClick = function (node, waveColor) {
      var _a, _b;
      var _this$props = _this.props,
        insertExtraNode = _this$props.insertExtraNode,
        disabled = _this$props.disabled;
      if (disabled || !node || isHidden(node) || node.className.includes('-leave')) {
        return;
      }
      _this.extraNode = document.createElement('div');
      var _assertThisInitialize = _assertThisInitialized(_this),
        extraNode = _assertThisInitialize.extraNode;
      var getPrefixCls = _this.context.getPrefixCls;
      extraNode.className = "".concat(getPrefixCls(''), "-click-animating-node");
      var attributeName = _this.getAttributeName();
      node.setAttribute(attributeName, 'true');
      // Not white or transparent or grey
      if (waveColor && waveColor !== '#fff' && waveColor !== '#ffffff' && waveColor !== 'rgb(255, 255, 255)' && waveColor !== 'rgba(255, 255, 255, 1)' && isNotGrey(waveColor) && !/rgba\((?:\d*, ){3}0\)/.test(waveColor) &&
      // any transparent rgba color
      waveColor !== 'transparent') {
        extraNode.style.borderColor = waveColor;
        var nodeRoot = ((_a = node.getRootNode) === null || _a === void 0 ? void 0 : _a.call(node)) || node.ownerDocument;
        var nodeBody = (_b = getValidateContainer(nodeRoot)) !== null && _b !== void 0 ? _b : nodeRoot;
        styleForPseudo = updateCSS("\n      [".concat(getPrefixCls(''), "-click-animating-without-extra-node='true']::after, .").concat(getPrefixCls(''), "-click-animating-node {\n        --antd-wave-shadow-color: ").concat(waveColor, ";\n      }"), 'antd-wave', {
          csp: _this.csp,
          attachTo: nodeBody
        });
      }
      if (insertExtraNode) {
        node.appendChild(extraNode);
      }
      ['transition', 'animation'].forEach(function (name) {
        node.addEventListener("".concat(name, "start"), _this.onTransitionStart);
        node.addEventListener("".concat(name, "end"), _this.onTransitionEnd);
      });
    };
    _this.onTransitionStart = function (e) {
      if (_this.destroyed) {
        return;
      }
      var node = _this.containerRef.current;
      if (!e || e.target !== node || _this.animationStart) {
        return;
      }
      _this.resetEffect(node);
    };
    _this.onTransitionEnd = function (e) {
      if (!e || e.animationName !== 'fadeEffect') {
        return;
      }
      _this.resetEffect(e.target);
    };
    _this.bindAnimationEvent = function (node) {
      if (!node || !node.getAttribute || node.getAttribute('disabled') || node.className.includes('disabled')) {
        return;
      }
      var onClick = function onClick(e) {
        // Fix radio button click twice
        if (e.target.tagName === 'INPUT' || isHidden(e.target)) {
          return;
        }
        _this.resetEffect(node);
        // Get wave color from target
        var waveColor = getComputedStyle(node).getPropertyValue('border-top-color') ||
        // Firefox Compatible
        getComputedStyle(node).getPropertyValue('border-color') || getComputedStyle(node).getPropertyValue('background-color');
        _this.clickWaveTimeoutId = window.setTimeout(function () {
          return _this.onClick(node, waveColor);
        }, 0);
        raf_wrapperRaf.cancel(_this.animationStartId);
        _this.animationStart = true;
        // Render to trigger transition event cost 3 frames. Let's delay 10 frames to reset this.
        _this.animationStartId = raf_wrapperRaf(function () {
          _this.animationStart = false;
        }, 10);
      };
      node.addEventListener('click', onClick, true);
      return {
        cancel: function cancel() {
          node.removeEventListener('click', onClick, true);
        }
      };
    };
    _this.renderWave = function (_ref) {
      var csp = _ref.csp;
      var children = _this.props.children;
      _this.csp = csp;
      if (! /*#__PURE__*/_react_18_2_0_react.isValidElement(children)) return children;
      var ref = _this.containerRef;
      if (supportRef(children)) {
        ref = composeRef(children.ref, _this.containerRef);
      }
      return cloneElement(children, {
        ref: ref
      });
    };
    return _this;
  }
  _createClass(Wave, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      this.destroyed = false;
      var node = this.containerRef.current;
      if (!node || node.nodeType !== 1) {
        return;
      }
      this.instance = this.bindAnimationEvent(node);
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      if (this.instance) {
        this.instance.cancel();
      }
      if (this.clickWaveTimeoutId) {
        clearTimeout(this.clickWaveTimeoutId);
      }
      this.destroyed = true;
    }
  }, {
    key: "getAttributeName",
    value: function getAttributeName() {
      var getPrefixCls = this.context.getPrefixCls;
      var insertExtraNode = this.props.insertExtraNode;
      return insertExtraNode ? "".concat(getPrefixCls(''), "-click-animating") : "".concat(getPrefixCls(''), "-click-animating-without-extra-node");
    }
  }, {
    key: "resetEffect",
    value: function resetEffect(node) {
      var _this2 = this;
      if (!node || node === this.extraNode || !(node instanceof Element)) {
        return;
      }
      var insertExtraNode = this.props.insertExtraNode;
      var attributeName = this.getAttributeName();
      node.setAttribute(attributeName, 'false'); // edge has bug on `removeAttribute` #14466
      if (styleForPseudo) {
        styleForPseudo.innerHTML = '';
      }
      if (insertExtraNode && this.extraNode && node.contains(this.extraNode)) {
        node.removeChild(this.extraNode);
      }
      ['transition', 'animation'].forEach(function (name) {
        node.removeEventListener("".concat(name, "start"), _this2.onTransitionStart);
        node.removeEventListener("".concat(name, "end"), _this2.onTransitionEnd);
      });
    }
  }, {
    key: "render",
    value: function render() {
      return /*#__PURE__*/_react_18_2_0_react.createElement(ConfigConsumer, null, this.renderWave);
    }
  }]);
  return Wave;
}(_react_18_2_0_react.Component);
Wave.contextType = context_ConfigContext;
/* harmony default export */ var wave = (Wave);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/button/button-group.js


var button_group_rest = undefined && undefined.__rest || function (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;
};




var GroupSizeContext = /*#__PURE__*/_react_18_2_0_react.createContext(undefined);
var ButtonGroup = function ButtonGroup(props) {
  var _classNames;
  var _React$useContext = _react_18_2_0_react.useContext(context_ConfigContext),
    getPrefixCls = _React$useContext.getPrefixCls,
    direction = _React$useContext.direction;
  var customizePrefixCls = props.prefixCls,
    size = props.size,
    className = props.className,
    others = button_group_rest(props, ["prefixCls", "size", "className"]);
  var prefixCls = getPrefixCls('btn-group', customizePrefixCls);
  // large => lg
  // small => sm
  var sizeCls = '';
  switch (size) {
    case 'large':
      sizeCls = 'lg';
      break;
    case 'small':
      sizeCls = 'sm';
      break;
    case 'middle':
    case undefined:
      break;
    default:
       false ? 0 : void 0;
  }
  var classes = _classnames_2_3_2_classnames_default()(prefixCls, (_classNames = {}, defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-").concat(sizeCls), sizeCls), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-rtl"), direction === 'rtl'), _classNames), className);
  return /*#__PURE__*/_react_18_2_0_react.createElement(GroupSizeContext.Provider, {
    value: size
  }, /*#__PURE__*/_react_18_2_0_react.createElement("div", extends_extends({}, others, {
    className: classes
  })));
};
/* harmony default export */ var button_group = (ButtonGroup);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/button/LoadingIcon.js



var getCollapsedWidth = function getCollapsedWidth() {
  return {
    width: 0,
    opacity: 0,
    transform: 'scale(0)'
  };
};
var getRealWidth = function getRealWidth(node) {
  return {
    width: node.scrollWidth,
    opacity: 1,
    transform: 'scale(1)'
  };
};
var LoadingIcon = function LoadingIcon(_ref) {
  var prefixCls = _ref.prefixCls,
    loading = _ref.loading,
    existIcon = _ref.existIcon;
  var visible = !!loading;
  if (existIcon) {
    return /*#__PURE__*/_react_18_2_0_react.createElement("span", {
      className: "".concat(prefixCls, "-loading-icon")
    }, /*#__PURE__*/_react_18_2_0_react.createElement(icons_LoadingOutlined, null));
  }
  return /*#__PURE__*/_react_18_2_0_react.createElement(_rc_motion_2_6_3_rc_motion_es, {
    visible: visible,
    // We do not really use this motionName
    motionName: "".concat(prefixCls, "-loading-icon-motion"),
    removeOnLeave: true,
    onAppearStart: getCollapsedWidth,
    onAppearActive: getRealWidth,
    onEnterStart: getCollapsedWidth,
    onEnterActive: getRealWidth,
    onLeaveStart: getRealWidth,
    onLeaveActive: getCollapsedWidth
  }, function (_ref2, ref) {
    var className = _ref2.className,
      style = _ref2.style;
    return /*#__PURE__*/_react_18_2_0_react.createElement("span", {
      className: "".concat(prefixCls, "-loading-icon"),
      style: style,
      ref: ref
    }, /*#__PURE__*/_react_18_2_0_react.createElement(icons_LoadingOutlined, {
      className: className
    }));
  });
};
/* harmony default export */ var button_LoadingIcon = (LoadingIcon);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/button/button.js




var button_rest = undefined && undefined.__rest || function (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;
};
/* eslint-disable react/button-has-type */













var rxTwoCNChar = /^[\u4e00-\u9fa5]{2}$/;
var isTwoCNChar = rxTwoCNChar.test.bind(rxTwoCNChar);
function isString(str) {
  return typeof str === 'string';
}
function isUnBorderedButtonType(type) {
  return type === 'text' || type === 'link';
}
// Insert one space between two chinese characters automatically.
function insertSpace(child, needInserted) {
  // Check the child if is undefined or null.
  if (child === null || child === undefined) {
    return;
  }
  var SPACE = needInserted ? ' ' : '';
  // strictNullChecks oops.
  if (typeof child !== 'string' && typeof child !== 'number' && isString(child.type) && isTwoCNChar(child.props.children)) {
    return cloneElement(child, {
      children: child.props.children.split('').join(SPACE)
    });
  }
  if (typeof child === 'string') {
    return isTwoCNChar(child) ? /*#__PURE__*/_react_18_2_0_react.createElement("span", null, child.split('').join(SPACE)) : /*#__PURE__*/_react_18_2_0_react.createElement("span", null, child);
  }
  if (isFragment(child)) {
    return /*#__PURE__*/_react_18_2_0_react.createElement("span", null, child);
  }
  return child;
}
function spaceChildren(children, needInserted) {
  var isPrevChildPure = false;
  var childList = [];
  _react_18_2_0_react.Children.forEach(children, function (child) {
    var type = _typeof(child);
    var isCurrentChildPure = type === 'string' || type === 'number';
    if (isPrevChildPure && isCurrentChildPure) {
      var lastIndex = childList.length - 1;
      var lastChild = childList[lastIndex];
      childList[lastIndex] = "".concat(lastChild).concat(child);
    } else {
      childList.push(child);
    }
    isPrevChildPure = isCurrentChildPure;
  });
  // Pass to React.Children.map to auto fill key
  return _react_18_2_0_react.Children.map(childList, function (child) {
    return insertSpace(child, needInserted);
  });
}
var ButtonTypes = tuple('default', 'primary', 'ghost', 'dashed', 'link', 'text');
var ButtonShapes = tuple('default', 'circle', 'round');
var ButtonHTMLTypes = tuple('submit', 'button', 'reset');
function convertLegacyProps(type) {
  if (type === 'danger') {
    return {
      danger: true
    };
  }
  return {
    type: type
  };
}
var InternalButton = function InternalButton(props, ref) {
  var _classNames;
  var _props$loading = props.loading,
    loading = _props$loading === void 0 ? false : _props$loading,
    customizePrefixCls = props.prefixCls,
    _props$type = props.type,
    type = _props$type === void 0 ? 'default' : _props$type,
    danger = props.danger,
    _props$shape = props.shape,
    shape = _props$shape === void 0 ? 'default' : _props$shape,
    customizeSize = props.size,
    customDisabled = props.disabled,
    className = props.className,
    children = props.children,
    icon = props.icon,
    _props$ghost = props.ghost,
    ghost = _props$ghost === void 0 ? false : _props$ghost,
    _props$block = props.block,
    block = _props$block === void 0 ? false : _props$block,
    _props$htmlType = props.htmlType,
    htmlType = _props$htmlType === void 0 ? 'button' : _props$htmlType,
    rest = button_rest(props, ["loading", "prefixCls", "type", "danger", "shape", "size", "disabled", "className", "children", "icon", "ghost", "block", "htmlType"]);
  var size = _react_18_2_0_react.useContext(config_provider_SizeContext);
  // ===================== Disabled =====================
  var disabled = _react_18_2_0_react.useContext(config_provider_DisabledContext);
  var mergedDisabled = customDisabled !== null && customDisabled !== void 0 ? customDisabled : disabled;
  var groupSize = _react_18_2_0_react.useContext(GroupSizeContext);
  var _React$useState = _react_18_2_0_react.useState(!!loading),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 2),
    innerLoading = _React$useState2[0],
    setLoading = _React$useState2[1];
  var _React$useState3 = _react_18_2_0_react.useState(false),
    _React$useState4 = slicedToArray_slicedToArray(_React$useState3, 2),
    hasTwoCNChar = _React$useState4[0],
    setHasTwoCNChar = _React$useState4[1];
  var _React$useContext = _react_18_2_0_react.useContext(context_ConfigContext),
    getPrefixCls = _React$useContext.getPrefixCls,
    autoInsertSpaceInButton = _React$useContext.autoInsertSpaceInButton,
    direction = _React$useContext.direction;
  var buttonRef = ref || /*#__PURE__*/_react_18_2_0_react.createRef();
  var isNeedInserted = function isNeedInserted() {
    return _react_18_2_0_react.Children.count(children) === 1 && !icon && !isUnBorderedButtonType(type);
  };
  var fixTwoCNChar = function fixTwoCNChar() {
    // Fix for HOC usage like <FormatMessage />
    if (!buttonRef || !buttonRef.current || autoInsertSpaceInButton === false) {
      return;
    }
    var buttonText = buttonRef.current.textContent;
    if (isNeedInserted() && isTwoCNChar(buttonText)) {
      if (!hasTwoCNChar) {
        setHasTwoCNChar(true);
      }
    } else if (hasTwoCNChar) {
      setHasTwoCNChar(false);
    }
  };
  // =============== Update Loading ===============
  var loadingOrDelay = typeof loading === 'boolean' ? loading : (loading === null || loading === void 0 ? void 0 : loading.delay) || true;
  _react_18_2_0_react.useEffect(function () {
    var delayTimer = null;
    if (typeof loadingOrDelay === 'number') {
      delayTimer = window.setTimeout(function () {
        delayTimer = null;
        setLoading(loadingOrDelay);
      }, loadingOrDelay);
    } else {
      setLoading(loadingOrDelay);
    }
    return function () {
      if (delayTimer) {
        // in order to not perform a React state update on an unmounted component
        // and clear timer after 'loadingOrDelay' updated.
        window.clearTimeout(delayTimer);
        delayTimer = null;
      }
    };
  }, [loadingOrDelay]);
  _react_18_2_0_react.useEffect(fixTwoCNChar, [buttonRef]);
  var handleClick = function handleClick(e) {
    var onClick = props.onClick;
    // https://github.com/ant-design/ant-design/issues/30207
    if (innerLoading || mergedDisabled) {
      e.preventDefault();
      return;
    }
    onClick === null || onClick === void 0 ? void 0 : onClick(e);
  };
   false ? 0 : void 0;
   false ? 0 : void 0;
  var prefixCls = getPrefixCls('btn', customizePrefixCls);
  var autoInsertSpace = autoInsertSpaceInButton !== false;
  var _useCompactItemContex = useCompactItemContext(prefixCls, direction),
    compactSize = _useCompactItemContex.compactSize,
    compactItemClassnames = _useCompactItemContex.compactItemClassnames;
  var sizeClassNameMap = {
    large: 'lg',
    small: 'sm',
    middle: undefined
  };
  var sizeFullname = compactSize || groupSize || customizeSize || size;
  var sizeCls = sizeFullname ? sizeClassNameMap[sizeFullname] || '' : '';
  var iconType = innerLoading ? 'loading' : icon;
  var linkButtonRestProps = omit_omit(rest, ['navigate']);
  var classes = _classnames_2_3_2_classnames_default()(prefixCls, (_classNames = {}, defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-").concat(shape), shape !== 'default' && shape), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-").concat(type), type), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-").concat(sizeCls), sizeCls), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-icon-only"), !children && children !== 0 && !!iconType), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-background-ghost"), ghost && !isUnBorderedButtonType(type)), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-loading"), innerLoading), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-two-chinese-chars"), hasTwoCNChar && autoInsertSpace && !innerLoading), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-block"), block), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-dangerous"), !!danger), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-rtl"), direction === 'rtl'), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-disabled"), linkButtonRestProps.href !== undefined && mergedDisabled), _classNames), compactItemClassnames, className);
  var iconNode = icon && !innerLoading ? icon : /*#__PURE__*/_react_18_2_0_react.createElement(button_LoadingIcon, {
    existIcon: !!icon,
    prefixCls: prefixCls,
    loading: !!innerLoading
  });
  var kids = children || children === 0 ? spaceChildren(children, isNeedInserted() && autoInsertSpace) : null;
  if (linkButtonRestProps.href !== undefined) {
    return /*#__PURE__*/_react_18_2_0_react.createElement("a", extends_extends({}, linkButtonRestProps, {
      className: classes,
      onClick: handleClick,
      ref: buttonRef
    }), iconNode, kids);
  }
  var buttonNode = /*#__PURE__*/_react_18_2_0_react.createElement("button", extends_extends({}, rest, {
    type: htmlType,
    className: classes,
    onClick: handleClick,
    disabled: mergedDisabled,
    ref: buttonRef
  }), iconNode, kids);
  if (isUnBorderedButtonType(type)) {
    return buttonNode;
  }
  return /*#__PURE__*/_react_18_2_0_react.createElement(wave, {
    disabled: !!innerLoading
  }, buttonNode);
};
var button_Button = /*#__PURE__*/_react_18_2_0_react.forwardRef(InternalButton);
if (false) {}
button_Button.Group = button_group;
button_Button.__ANT_BUTTON = true;
/* harmony default export */ var button_button = (button_Button);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/button/index.js

/* harmony default export */ var es_button = (button_button);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/_util/ActionButton.js






function isThenable(thing) {
  return !!(thing && !!thing.then);
}
var ActionButton = function ActionButton(props) {
  var clickedRef = _react_18_2_0_react.useRef(false);
  var ref = _react_18_2_0_react.useRef(null);
  var _useState = useSafeState(false),
    _useState2 = slicedToArray_slicedToArray(_useState, 2),
    loading = _useState2[0],
    setLoading = _useState2[1];
  var close = props.close;
  var onInternalClose = function onInternalClose() {
    close === null || close === void 0 ? void 0 : close.apply(void 0, arguments);
  };
  _react_18_2_0_react.useEffect(function () {
    var timeoutId = null;
    if (props.autoFocus) {
      timeoutId = setTimeout(function () {
        var _a;
        (_a = ref.current) === null || _a === void 0 ? void 0 : _a.focus();
      });
    }
    return function () {
      if (timeoutId) {
        clearTimeout(timeoutId);
      }
    };
  }, []);
  var handlePromiseOnOk = function handlePromiseOnOk(returnValueOfOnOk) {
    if (!isThenable(returnValueOfOnOk)) {
      return;
    }
    setLoading(true);
    returnValueOfOnOk.then(function () {
      setLoading(false, true);
      onInternalClose.apply(void 0, arguments);
      clickedRef.current = false;
    }, function (e) {
      // Emit error when catch promise reject
      // eslint-disable-next-line no-console
      console.error(e);
      // See: https://github.com/ant-design/ant-design/issues/6183
      setLoading(false, true);
      clickedRef.current = false;
    });
  };
  var onClick = function onClick(e) {
    var actionFn = props.actionFn;
    if (clickedRef.current) {
      return;
    }
    clickedRef.current = true;
    if (!actionFn) {
      onInternalClose();
      return;
    }
    var returnValueOfOnOk;
    if (props.emitEvent) {
      returnValueOfOnOk = actionFn(e);
      if (props.quitOnNullishReturnValue && !isThenable(returnValueOfOnOk)) {
        clickedRef.current = false;
        onInternalClose(e);
        return;
      }
    } else if (actionFn.length) {
      returnValueOfOnOk = actionFn(close);
      // https://github.com/ant-design/ant-design/issues/23358
      clickedRef.current = false;
    } else {
      returnValueOfOnOk = actionFn();
      if (!returnValueOfOnOk) {
        onInternalClose();
        return;
      }
    }
    handlePromiseOnOk(returnValueOfOnOk);
  };
  var type = props.type,
    children = props.children,
    prefixCls = props.prefixCls,
    buttonProps = props.buttonProps;
  return /*#__PURE__*/_react_18_2_0_react.createElement(es_button, extends_extends({}, convertLegacyProps(type), {
    onClick: onClick,
    loading: loading,
    prefixCls: prefixCls
  }, buttonProps, {
    ref: ref
  }), children);
};
/* harmony default export */ var _util_ActionButton = (ActionButton);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/_util/motion.js

// ================== Collapse Motion ==================
var getCollapsedHeight = function getCollapsedHeight() {
  return {
    height: 0,
    opacity: 0
  };
};
var getRealHeight = function getRealHeight(node) {
  var scrollHeight = node.scrollHeight;
  return {
    height: scrollHeight,
    opacity: 1
  };
};
var getCurrentHeight = function getCurrentHeight(node) {
  return {
    height: node ? node.offsetHeight : 0
  };
};
var skipOpacityTransition = function skipOpacityTransition(_, event) {
  return (event === null || event === void 0 ? void 0 : event.deadline) === true || event.propertyName === 'height';
};
var collapseMotion = {
  motionName: 'ant-motion-collapse',
  onAppearStart: getCollapsedHeight,
  onEnterStart: getCollapsedHeight,
  onAppearActive: getRealHeight,
  onEnterActive: getRealHeight,
  onLeaveStart: getCurrentHeight,
  onLeaveActive: getCollapsedHeight,
  onAppearEnd: skipOpacityTransition,
  onEnterEnd: skipOpacityTransition,
  onLeaveEnd: skipOpacityTransition,
  motionDeadline: 500
};
var SelectPlacements = tuple('bottomLeft', 'bottomRight', 'topLeft', 'topRight');
var getTransitionDirection = function getTransitionDirection(placement) {
  if (placement !== undefined && (placement === 'topLeft' || placement === 'topRight')) {
    return "slide-down";
  }
  return "slide-up";
};
var motion_getTransitionName = function getTransitionName(rootPrefixCls, motion, transitionName) {
  if (transitionName !== undefined) {
    return transitionName;
  }
  return "".concat(rootPrefixCls, "-").concat(motion);
};

/* harmony default export */ var motion = ((/* unused pure expression or super */ null && (collapseMotion)));
;// CONCATENATED MODULE: ./node_modules/_@rc-component_portal@1.1.0@@rc-component/portal/es/Context.js

var OrderContext = /*#__PURE__*/_react_18_2_0_react.createContext(null);
/* harmony default export */ var es_Context = (OrderContext);
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/hooks/useLayoutEffect.js



/**
 * Wrap `React.useLayoutEffect` which will not throw warning message in test env
 */
var useLayoutEffect =  true && canUseDom() ? _react_18_2_0_react.useLayoutEffect : _react_18_2_0_react.useEffect;
/* harmony default export */ var hooks_useLayoutEffect = (useLayoutEffect);
var useLayoutUpdateEffect = function useLayoutUpdateEffect(callback, deps) {
  var firstMountRef = _react_18_2_0_react.useRef(true);
  useLayoutEffect(function () {
    if (!firstMountRef.current) {
      return callback();
    }
  }, deps);

  // We tell react that first mount has passed
  useLayoutEffect(function () {
    firstMountRef.current = false;
    return function () {
      firstMountRef.current = true;
    };
  }, []);
};
;// CONCATENATED MODULE: ./node_modules/_@rc-component_portal@1.1.0@@rc-component/portal/es/useDom.js






var EMPTY_LIST = [];
/**
 * Will add `div` to document. Nest call will keep order
 * @param render Render DOM in document
 */

function useDom(render, debug) {
  var _React$useState = _react_18_2_0_react.useState(function () {
      if (!canUseDom()) {
        return null;
      }
      var defaultEle = document.createElement('div');
      if (false) {}
      return defaultEle;
    }),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 1),
    ele = _React$useState2[0]; // ========================== Order ==========================

  var appendedRef = _react_18_2_0_react.useRef(false);
  var queueCreate = _react_18_2_0_react.useContext(es_Context);
  var _React$useState3 = _react_18_2_0_react.useState(EMPTY_LIST),
    _React$useState4 = slicedToArray_slicedToArray(_React$useState3, 2),
    queue = _React$useState4[0],
    setQueue = _React$useState4[1];
  var mergedQueueCreate = queueCreate || (appendedRef.current ? undefined : function (appendFn) {
    setQueue(function (origin) {
      var newQueue = [appendFn].concat(_toConsumableArray(origin));
      return newQueue;
    });
  }); // =========================== DOM ===========================

  function append() {
    if (!ele.parentElement) {
      document.body.appendChild(ele);
    }
    appendedRef.current = true;
  }
  function cleanup() {
    var _ele$parentElement;
    (_ele$parentElement = ele.parentElement) === null || _ele$parentElement === void 0 ? void 0 : _ele$parentElement.removeChild(ele);
    appendedRef.current = false;
  }
  hooks_useLayoutEffect(function () {
    if (render) {
      if (queueCreate) {
        queueCreate(append);
      } else {
        append();
      }
    } else {
      cleanup();
    }
    return cleanup;
  }, [render]);
  hooks_useLayoutEffect(function () {
    if (queue.length) {
      queue.forEach(function (appendFn) {
        return appendFn();
      });
      setQueue(EMPTY_LIST);
    }
  }, [queue]);
  return [ele, mergedQueueCreate];
}
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/getScrollBarSize.js
/* eslint-disable no-param-reassign */

var cached;
function getScrollBarSize(fresh) {
  if (typeof document === 'undefined') {
    return 0;
  }
  if (fresh || cached === undefined) {
    var inner = document.createElement('div');
    inner.style.width = '100%';
    inner.style.height = '200px';
    var outer = document.createElement('div');
    var outerStyle = outer.style;
    outerStyle.position = 'absolute';
    outerStyle.top = '0';
    outerStyle.left = '0';
    outerStyle.pointerEvents = 'none';
    outerStyle.visibility = 'hidden';
    outerStyle.width = '200px';
    outerStyle.height = '150px';
    outerStyle.overflow = 'hidden';
    outer.appendChild(inner);
    document.body.appendChild(outer);
    var widthContained = inner.offsetWidth;
    outer.style.overflow = 'scroll';
    var widthScroll = inner.offsetWidth;
    if (widthContained === widthScroll) {
      widthScroll = outer.clientWidth;
    }
    document.body.removeChild(outer);
    cached = widthContained - widthScroll;
  }
  return cached;
}
function ensureSize(str) {
  var match = str.match(/^(.*)px$/);
  var value = Number(match === null || match === void 0 ? void 0 : match[1]);
  return Number.isNaN(value) ? getScrollBarSize() : value;
}
function getTargetScrollBarSize(target) {
  if (typeof document === 'undefined' || !target || !(target instanceof Element)) {
    return {
      width: 0,
      height: 0
    };
  }
  var _getComputedStyle = getComputedStyle(target, '::-webkit-scrollbar'),
    width = _getComputedStyle.width,
    height = _getComputedStyle.height;
  return {
    width: ensureSize(width),
    height: ensureSize(height)
  };
}
;// CONCATENATED MODULE: ./node_modules/_@rc-component_portal@1.1.0@@rc-component/portal/es/util.js
/**
 * Test usage export. Do not use in your production
 */
function isBodyOverflowing() {
  return document.body.scrollHeight > (window.innerHeight || document.documentElement.clientHeight) && window.innerWidth > document.body.offsetWidth;
}
;// CONCATENATED MODULE: ./node_modules/_@rc-component_portal@1.1.0@@rc-component/portal/es/useScrollLocker.js






var UNIQUE_ID = "rc-util-locker-".concat(Date.now());
var uuid = 0;
function useScrollLocker(lock) {
  var mergedLock = !!lock;
  var _React$useState = _react_18_2_0_react.useState(function () {
      uuid += 1;
      return "".concat(UNIQUE_ID, "_").concat(uuid);
    }),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 1),
    id = _React$useState2[0];
  hooks_useLayoutEffect(function () {
    if (mergedLock) {
      var scrollbarSize = getScrollBarSize();
      var isOverflow = isBodyOverflowing();
      updateCSS("\nhtml body {\n  overflow-y: hidden;\n  ".concat(isOverflow ? "width: calc(100% - ".concat(scrollbarSize, "px);") : '', "\n}"), id);
    } else {
      removeCSS(id);
    }
    return function () {
      removeCSS(id);
    };
  }, [mergedLock, id]);
}
;// CONCATENATED MODULE: ./node_modules/_@rc-component_portal@1.1.0@@rc-component/portal/es/mock.js
var inline = false;
function inlineMock(nextInline) {
  if (typeof nextInline === 'boolean') {
    inline = nextInline;
  }
  return inline;
}
;// CONCATENATED MODULE: ./node_modules/_@rc-component_portal@1.1.0@@rc-component/portal/es/Portal.js









var getPortalContainer = function getPortalContainer(getContainer) {
  if (getContainer === false) {
    return false;
  }
  if (!canUseDom() || !getContainer) {
    return null;
  }
  if (typeof getContainer === 'string') {
    return document.querySelector(getContainer);
  }
  if (typeof getContainer === 'function') {
    return getContainer();
  }
  return getContainer;
};
var Portal = /*#__PURE__*/_react_18_2_0_react.forwardRef(function (props, ref) {
  var open = props.open,
    autoLock = props.autoLock,
    getContainer = props.getContainer,
    debug = props.debug,
    _props$autoDestroy = props.autoDestroy,
    autoDestroy = _props$autoDestroy === void 0 ? true : _props$autoDestroy,
    children = props.children;
  var _React$useState = _react_18_2_0_react.useState(open),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 2),
    shouldRender = _React$useState2[0],
    setShouldRender = _React$useState2[1];
  var mergedRender = shouldRender || open; // ====================== Should Render ======================

  _react_18_2_0_react.useEffect(function () {
    if (autoDestroy || open) {
      setShouldRender(open);
    }
  }, [open, autoDestroy]); // ======================== Container ========================

  var _React$useState3 = _react_18_2_0_react.useState(function () {
      return getPortalContainer(getContainer);
    }),
    _React$useState4 = slicedToArray_slicedToArray(_React$useState3, 2),
    innerContainer = _React$useState4[0],
    setInnerContainer = _React$useState4[1];
  _react_18_2_0_react.useEffect(function () {
    var customizeContainer = getPortalContainer(getContainer); // Tell component that we check this in effect which is safe to be `null`

    setInnerContainer(customizeContainer !== null && customizeContainer !== void 0 ? customizeContainer : null);
  });
  var _useDom = useDom(mergedRender && !innerContainer, debug),
    _useDom2 = slicedToArray_slicedToArray(_useDom, 2),
    defaultContainer = _useDom2[0],
    queueCreate = _useDom2[1];
  var mergedContainer = innerContainer !== null && innerContainer !== void 0 ? innerContainer : defaultContainer; // ========================= Locker ==========================

  useScrollLocker(autoLock && open && canUseDom() && (mergedContainer === defaultContainer || mergedContainer === document.body)); // =========================== Ref ===========================

  var childRef = null;
  if (children && supportRef(children) && ref) {
    var _ref = children;
    childRef = _ref.ref;
  }
  var mergedRef = useComposeRef(childRef, ref); // ========================= Render ==========================
  // Do not render when nothing need render
  // When innerContainer is `undefined`, it may not ready since user use ref in the same render

  if (!mergedRender || !canUseDom() || innerContainer === undefined) {
    return null;
  } // Render inline

  var renderInline = mergedContainer === false || inlineMock();
  var reffedChildren = children;
  if (ref) {
    reffedChildren = /*#__PURE__*/_react_18_2_0_react.cloneElement(children, {
      ref: mergedRef
    });
  }
  return /*#__PURE__*/_react_18_2_0_react.createElement(es_Context.Provider, {
    value: queueCreate
  }, renderInline ? reffedChildren : /*#__PURE__*/(0,_react_dom_18_2_0_react_dom.createPortal)(reffedChildren, mergedContainer));
});
if (false) {}
/* harmony default export */ var es_Portal = (Portal);
;// CONCATENATED MODULE: ./node_modules/_@rc-component_portal@1.1.0@@rc-component/portal/es/index.js



/* harmony default export */ var portal_es = (es_Portal);
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/KeyCode.js
/**
 * @ignore
 * some key-codes definition and utils from closure-library
 * @author yiminghe@gmail.com
 */

var KeyCode = {
  /**
   * MAC_ENTER
   */
  MAC_ENTER: 3,
  /**
   * BACKSPACE
   */
  BACKSPACE: 8,
  /**
   * TAB
   */
  TAB: 9,
  /**
   * NUMLOCK on FF/Safari Mac
   */
  NUM_CENTER: 12,
  // NUMLOCK on FF/Safari Mac
  /**
   * ENTER
   */
  ENTER: 13,
  /**
   * SHIFT
   */
  SHIFT: 16,
  /**
   * CTRL
   */
  CTRL: 17,
  /**
   * ALT
   */
  ALT: 18,
  /**
   * PAUSE
   */
  PAUSE: 19,
  /**
   * CAPS_LOCK
   */
  CAPS_LOCK: 20,
  /**
   * ESC
   */
  ESC: 27,
  /**
   * SPACE
   */
  SPACE: 32,
  /**
   * PAGE_UP
   */
  PAGE_UP: 33,
  // also NUM_NORTH_EAST
  /**
   * PAGE_DOWN
   */
  PAGE_DOWN: 34,
  // also NUM_SOUTH_EAST
  /**
   * END
   */
  END: 35,
  // also NUM_SOUTH_WEST
  /**
   * HOME
   */
  HOME: 36,
  // also NUM_NORTH_WEST
  /**
   * LEFT
   */
  LEFT: 37,
  // also NUM_WEST
  /**
   * UP
   */
  UP: 38,
  // also NUM_NORTH
  /**
   * RIGHT
   */
  RIGHT: 39,
  // also NUM_EAST
  /**
   * DOWN
   */
  DOWN: 40,
  // also NUM_SOUTH
  /**
   * PRINT_SCREEN
   */
  PRINT_SCREEN: 44,
  /**
   * INSERT
   */
  INSERT: 45,
  // also NUM_INSERT
  /**
   * DELETE
   */
  DELETE: 46,
  // also NUM_DELETE
  /**
   * ZERO
   */
  ZERO: 48,
  /**
   * ONE
   */
  ONE: 49,
  /**
   * TWO
   */
  TWO: 50,
  /**
   * THREE
   */
  THREE: 51,
  /**
   * FOUR
   */
  FOUR: 52,
  /**
   * FIVE
   */
  FIVE: 53,
  /**
   * SIX
   */
  SIX: 54,
  /**
   * SEVEN
   */
  SEVEN: 55,
  /**
   * EIGHT
   */
  EIGHT: 56,
  /**
   * NINE
   */
  NINE: 57,
  /**
   * QUESTION_MARK
   */
  QUESTION_MARK: 63,
  // needs localization
  /**
   * A
   */
  A: 65,
  /**
   * B
   */
  B: 66,
  /**
   * C
   */
  C: 67,
  /**
   * D
   */
  D: 68,
  /**
   * E
   */
  E: 69,
  /**
   * F
   */
  F: 70,
  /**
   * G
   */
  G: 71,
  /**
   * H
   */
  H: 72,
  /**
   * I
   */
  I: 73,
  /**
   * J
   */
  J: 74,
  /**
   * K
   */
  K: 75,
  /**
   * L
   */
  L: 76,
  /**
   * M
   */
  M: 77,
  /**
   * N
   */
  N: 78,
  /**
   * O
   */
  O: 79,
  /**
   * P
   */
  P: 80,
  /**
   * Q
   */
  Q: 81,
  /**
   * R
   */
  R: 82,
  /**
   * S
   */
  S: 83,
  /**
   * T
   */
  T: 84,
  /**
   * U
   */
  U: 85,
  /**
   * V
   */
  V: 86,
  /**
   * W
   */
  W: 87,
  /**
   * X
   */
  X: 88,
  /**
   * Y
   */
  Y: 89,
  /**
   * Z
   */
  Z: 90,
  /**
   * META
   */
  META: 91,
  // WIN_KEY_LEFT
  /**
   * WIN_KEY_RIGHT
   */
  WIN_KEY_RIGHT: 92,
  /**
   * CONTEXT_MENU
   */
  CONTEXT_MENU: 93,
  /**
   * NUM_ZERO
   */
  NUM_ZERO: 96,
  /**
   * NUM_ONE
   */
  NUM_ONE: 97,
  /**
   * NUM_TWO
   */
  NUM_TWO: 98,
  /**
   * NUM_THREE
   */
  NUM_THREE: 99,
  /**
   * NUM_FOUR
   */
  NUM_FOUR: 100,
  /**
   * NUM_FIVE
   */
  NUM_FIVE: 101,
  /**
   * NUM_SIX
   */
  NUM_SIX: 102,
  /**
   * NUM_SEVEN
   */
  NUM_SEVEN: 103,
  /**
   * NUM_EIGHT
   */
  NUM_EIGHT: 104,
  /**
   * NUM_NINE
   */
  NUM_NINE: 105,
  /**
   * NUM_MULTIPLY
   */
  NUM_MULTIPLY: 106,
  /**
   * NUM_PLUS
   */
  NUM_PLUS: 107,
  /**
   * NUM_MINUS
   */
  NUM_MINUS: 109,
  /**
   * NUM_PERIOD
   */
  NUM_PERIOD: 110,
  /**
   * NUM_DIVISION
   */
  NUM_DIVISION: 111,
  /**
   * F1
   */
  F1: 112,
  /**
   * F2
   */
  F2: 113,
  /**
   * F3
   */
  F3: 114,
  /**
   * F4
   */
  F4: 115,
  /**
   * F5
   */
  F5: 116,
  /**
   * F6
   */
  F6: 117,
  /**
   * F7
   */
  F7: 118,
  /**
   * F8
   */
  F8: 119,
  /**
   * F9
   */
  F9: 120,
  /**
   * F10
   */
  F10: 121,
  /**
   * F11
   */
  F11: 122,
  /**
   * F12
   */
  F12: 123,
  /**
   * NUMLOCK
   */
  NUMLOCK: 144,
  /**
   * SEMICOLON
   */
  SEMICOLON: 186,
  // needs localization
  /**
   * DASH
   */
  DASH: 189,
  // needs localization
  /**
   * EQUALS
   */
  EQUALS: 187,
  // needs localization
  /**
   * COMMA
   */
  COMMA: 188,
  // needs localization
  /**
   * PERIOD
   */
  PERIOD: 190,
  // needs localization
  /**
   * SLASH
   */
  SLASH: 191,
  // needs localization
  /**
   * APOSTROPHE
   */
  APOSTROPHE: 192,
  // needs localization
  /**
   * SINGLE_QUOTE
   */
  SINGLE_QUOTE: 222,
  // needs localization
  /**
   * OPEN_SQUARE_BRACKET
   */
  OPEN_SQUARE_BRACKET: 219,
  // needs localization
  /**
   * BACKSLASH
   */
  BACKSLASH: 220,
  // needs localization
  /**
   * CLOSE_SQUARE_BRACKET
   */
  CLOSE_SQUARE_BRACKET: 221,
  // needs localization
  /**
   * WIN_KEY
   */
  WIN_KEY: 224,
  /**
   * MAC_FF_META
   */
  MAC_FF_META: 224,
  // Firefox (Gecko) fires this for the meta key instead of 91
  /**
   * WIN_IME
   */
  WIN_IME: 229,
  // ======================== Function ========================
  /**
   * whether text and modified key is entered at the same time.
   */
  isTextModifyingKeyEvent: function isTextModifyingKeyEvent(e) {
    var keyCode = e.keyCode;
    if (e.altKey && !e.ctrlKey || e.metaKey ||
    // Function keys don't generate text
    keyCode >= KeyCode.F1 && keyCode <= KeyCode.F12) {
      return false;
    }

    // The following keys are quite harmless, even in combination with
    // CTRL, ALT or SHIFT.
    switch (keyCode) {
      case KeyCode.ALT:
      case KeyCode.CAPS_LOCK:
      case KeyCode.CONTEXT_MENU:
      case KeyCode.CTRL:
      case KeyCode.DOWN:
      case KeyCode.END:
      case KeyCode.ESC:
      case KeyCode.HOME:
      case KeyCode.INSERT:
      case KeyCode.LEFT:
      case KeyCode.MAC_FF_META:
      case KeyCode.META:
      case KeyCode.NUMLOCK:
      case KeyCode.NUM_CENTER:
      case KeyCode.PAGE_DOWN:
      case KeyCode.PAGE_UP:
      case KeyCode.PAUSE:
      case KeyCode.PRINT_SCREEN:
      case KeyCode.RIGHT:
      case KeyCode.SHIFT:
      case KeyCode.UP:
      case KeyCode.WIN_KEY:
      case KeyCode.WIN_KEY_RIGHT:
        return false;
      default:
        return true;
    }
  },
  /**
   * whether character is entered.
   */
  isCharacterKey: function isCharacterKey(keyCode) {
    if (keyCode >= KeyCode.ZERO && keyCode <= KeyCode.NINE) {
      return true;
    }
    if (keyCode >= KeyCode.NUM_ZERO && keyCode <= KeyCode.NUM_MULTIPLY) {
      return true;
    }
    if (keyCode >= KeyCode.A && keyCode <= KeyCode.Z) {
      return true;
    }

    // Safari sends zero key code for non-latin characters.
    if (window.navigator.userAgent.indexOf('WebKit') !== -1 && keyCode === 0) {
      return true;
    }
    switch (keyCode) {
      case KeyCode.SPACE:
      case KeyCode.QUESTION_MARK:
      case KeyCode.NUM_PLUS:
      case KeyCode.NUM_MINUS:
      case KeyCode.NUM_PERIOD:
      case KeyCode.NUM_DIVISION:
      case KeyCode.SEMICOLON:
      case KeyCode.DASH:
      case KeyCode.EQUALS:
      case KeyCode.COMMA:
      case KeyCode.PERIOD:
      case KeyCode.SLASH:
      case KeyCode.APOSTROPHE:
      case KeyCode.SINGLE_QUOTE:
      case KeyCode.OPEN_SQUARE_BRACKET:
      case KeyCode.BACKSLASH:
      case KeyCode.CLOSE_SQUARE_BRACKET:
        return true;
      default:
        return false;
    }
  }
};
/* harmony default export */ var es_KeyCode = (KeyCode);
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/hooks/useId.js



function getUseId() {
  // We need fully clone React function here to avoid webpack warning React 17 do not export `useId`
  var fullClone = _objectSpread2({}, _react_18_2_0_react_namespaceObject);
  return fullClone.useId;
}
var useId_uuid = 0;

/** @private Note only worked in develop env. Not work in production. */
function resetUuid() {
  if (false) {}
}
function useId(id) {
  // Inner id for accessibility usage. Only work in client side
  var _React$useState = _react_18_2_0_react.useState('ssr-id'),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 2),
    innerId = _React$useState2[0],
    setInnerId = _React$useState2[1];
  var useOriginId = getUseId();
  var reactNativeId = useOriginId === null || useOriginId === void 0 ? void 0 : useOriginId();
  _react_18_2_0_react.useEffect(function () {
    if (!useOriginId) {
      var nextId = useId_uuid;
      useId_uuid += 1;
      setInnerId("rc_unique_".concat(nextId));
    }
  }, []);

  // Developer passed id is single source of truth
  if (id) {
    return id;
  }

  // Test env always return mock id
  if (false) {}

  // Return react native id or inner id
  return reactNativeId || innerId;
}
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/pickAttrs.js

var attributes = "accept acceptCharset accessKey action allowFullScreen allowTransparency\n    alt async autoComplete autoFocus autoPlay capture cellPadding cellSpacing challenge\n    charSet checked classID className colSpan cols content contentEditable contextMenu\n    controls coords crossOrigin data dateTime default defer dir disabled download draggable\n    encType form formAction formEncType formMethod formNoValidate formTarget frameBorder\n    headers height hidden high href hrefLang htmlFor httpEquiv icon id inputMode integrity\n    is keyParams keyType kind label lang list loop low manifest marginHeight marginWidth max maxLength media\n    mediaGroup method min minLength multiple muted name noValidate nonce open\n    optimum pattern placeholder poster preload radioGroup readOnly rel required\n    reversed role rowSpan rows sandbox scope scoped scrolling seamless selected\n    shape size sizes span spellCheck src srcDoc srcLang srcSet start step style\n    summary tabIndex target title type useMap value width wmode wrap";
var eventsName = "onCopy onCut onPaste onCompositionEnd onCompositionStart onCompositionUpdate onKeyDown\n    onKeyPress onKeyUp onFocus onBlur onChange onInput onSubmit onClick onContextMenu onDoubleClick\n    onDrag onDragEnd onDragEnter onDragExit onDragLeave onDragOver onDragStart onDrop onMouseDown\n    onMouseEnter onMouseLeave onMouseMove onMouseOut onMouseOver onMouseUp onSelect onTouchCancel\n    onTouchEnd onTouchMove onTouchStart onScroll onWheel onAbort onCanPlay onCanPlayThrough\n    onDurationChange onEmptied onEncrypted onEnded onError onLoadedData onLoadedMetadata\n    onLoadStart onPause onPlay onPlaying onProgress onRateChange onSeeked onSeeking onStalled onSuspend onTimeUpdate onVolumeChange onWaiting onLoad onError";
var propList = "".concat(attributes, " ").concat(eventsName).split(/[\s\n]+/);

/* eslint-enable max-len */
var ariaPrefix = 'aria-';
var dataPrefix = 'data-';
function match(key, prefix) {
  return key.indexOf(prefix) === 0;
}
/**
 * Picker props from exist props with filter
 * @param props Passed props
 * @param ariaOnly boolean | { aria?: boolean; data?: boolean; attr?: boolean; } filter config
 */
function pickAttrs(props) {
  var ariaOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  var mergedConfig;
  if (ariaOnly === false) {
    mergedConfig = {
      aria: true,
      data: true,
      attr: true
    };
  } else if (ariaOnly === true) {
    mergedConfig = {
      aria: true
    };
  } else {
    mergedConfig = _objectSpread2({}, ariaOnly);
  }
  var attrs = {};
  Object.keys(props).forEach(function (key) {
    if (
    // Aria
    mergedConfig.aria && (key === 'role' || match(key, ariaPrefix)) ||
    // Data
    mergedConfig.data && match(key, dataPrefix) ||
    // Attr
    mergedConfig.attr && propList.includes(key)) {
      attrs[key] = props[key];
    }
  });
  return attrs;
}
;// CONCATENATED MODULE: ./node_modules/_rc-dialog@9.0.2@rc-dialog/es/Dialog/Mask.js





function Mask(props) {
  var prefixCls = props.prefixCls,
    style = props.style,
    visible = props.visible,
    maskProps = props.maskProps,
    motionName = props.motionName;
  return /*#__PURE__*/_react_18_2_0_react.createElement(_rc_motion_2_6_3_rc_motion_es, {
    key: "mask",
    visible: visible,
    motionName: motionName,
    leavedClassName: "".concat(prefixCls, "-mask-hidden")
  }, function (_ref, ref) {
    var motionClassName = _ref.className,
      motionStyle = _ref.style;
    return /*#__PURE__*/_react_18_2_0_react.createElement("div", extends_extends({
      ref: ref,
      style: _objectSpread2(_objectSpread2({}, motionStyle), style),
      className: _classnames_2_3_2_classnames_default()("".concat(prefixCls, "-mask"), motionClassName)
    }, maskProps));
  });
}
;// CONCATENATED MODULE: ./node_modules/_rc-dialog@9.0.2@rc-dialog/es/util.js
// =============================== Motion ===============================
function getMotionName(prefixCls, transitionName, animationName) {
  var motionName = transitionName;
  if (!motionName && animationName) {
    motionName = "".concat(prefixCls, "-").concat(animationName);
  }
  return motionName;
}
// =============================== Offset ===============================
function getScroll(w, top) {
  var ret = w["page".concat(top ? 'Y' : 'X', "Offset")];
  var method = "scroll".concat(top ? 'Top' : 'Left');
  if (typeof ret !== 'number') {
    var d = w.document;
    ret = d.documentElement[method];
    if (typeof ret !== 'number') {
      ret = d.body[method];
    }
  }
  return ret;
}
function offset(el) {
  var rect = el.getBoundingClientRect();
  var pos = {
    left: rect.left,
    top: rect.top
  };
  var doc = el.ownerDocument;
  var w = doc.defaultView || doc.parentWindow;
  pos.left += getScroll(w);
  pos.top += getScroll(w, true);
  return pos;
}
;// CONCATENATED MODULE: ./node_modules/_rc-dialog@9.0.2@rc-dialog/es/Dialog/Content/MemoChildren.js

/* harmony default export */ var MemoChildren = (/*#__PURE__*/_react_18_2_0_react.memo(function (_ref) {
  var children = _ref.children;
  return children;
}, function (_, _ref2) {
  var shouldUpdate = _ref2.shouldUpdate;
  return !shouldUpdate;
}));
;// CONCATENATED MODULE: ./node_modules/_rc-dialog@9.0.2@rc-dialog/es/Dialog/Content/Panel.js





var sentinelStyle = {
  width: 0,
  height: 0,
  overflow: 'hidden',
  outline: 'none'
};
var Panel_Panel = /*#__PURE__*/_react_18_2_0_react.forwardRef(function (props, ref) {
  var prefixCls = props.prefixCls,
    className = props.className,
    style = props.style,
    title = props.title,
    ariaId = props.ariaId,
    footer = props.footer,
    closable = props.closable,
    closeIcon = props.closeIcon,
    onClose = props.onClose,
    children = props.children,
    bodyStyle = props.bodyStyle,
    bodyProps = props.bodyProps,
    modalRender = props.modalRender,
    onMouseDown = props.onMouseDown,
    onMouseUp = props.onMouseUp,
    holderRef = props.holderRef,
    visible = props.visible,
    forceRender = props.forceRender,
    width = props.width,
    height = props.height;
  // ================================= Refs =================================
  var sentinelStartRef = (0,_react_18_2_0_react.useRef)();
  var sentinelEndRef = (0,_react_18_2_0_react.useRef)();
  _react_18_2_0_react.useImperativeHandle(ref, function () {
    return {
      focus: function focus() {
        var _sentinelStartRef$cur;
        (_sentinelStartRef$cur = sentinelStartRef.current) === null || _sentinelStartRef$cur === void 0 ? void 0 : _sentinelStartRef$cur.focus();
      },
      changeActive: function changeActive(next) {
        var _document = document,
          activeElement = _document.activeElement;
        if (next && activeElement === sentinelEndRef.current) {
          sentinelStartRef.current.focus();
        } else if (!next && activeElement === sentinelStartRef.current) {
          sentinelEndRef.current.focus();
        }
      }
    };
  });
  // ================================ Style =================================
  var contentStyle = {};
  if (width !== undefined) {
    contentStyle.width = width;
  }
  if (height !== undefined) {
    contentStyle.height = height;
  }
  // ================================ Render ================================
  var footerNode;
  if (footer) {
    footerNode = /*#__PURE__*/_react_18_2_0_react.createElement("div", {
      className: "".concat(prefixCls, "-footer")
    }, footer);
  }
  var headerNode;
  if (title) {
    headerNode = /*#__PURE__*/_react_18_2_0_react.createElement("div", {
      className: "".concat(prefixCls, "-header")
    }, /*#__PURE__*/_react_18_2_0_react.createElement("div", {
      className: "".concat(prefixCls, "-title"),
      id: ariaId
    }, title));
  }
  var closer;
  if (closable) {
    closer = /*#__PURE__*/_react_18_2_0_react.createElement("button", {
      type: "button",
      onClick: onClose,
      "aria-label": "Close",
      className: "".concat(prefixCls, "-close")
    }, closeIcon || /*#__PURE__*/_react_18_2_0_react.createElement("span", {
      className: "".concat(prefixCls, "-close-x")
    }));
  }
  var content = /*#__PURE__*/_react_18_2_0_react.createElement("div", {
    className: "".concat(prefixCls, "-content")
  }, closer, headerNode, /*#__PURE__*/_react_18_2_0_react.createElement("div", extends_extends({
    className: "".concat(prefixCls, "-body"),
    style: bodyStyle
  }, bodyProps), children), footerNode);
  return /*#__PURE__*/_react_18_2_0_react.createElement("div", {
    key: "dialog-element",
    role: "dialog",
    "aria-labelledby": title ? ariaId : null,
    "aria-modal": "true",
    ref: holderRef,
    style: _objectSpread2(_objectSpread2({}, style), contentStyle),
    className: _classnames_2_3_2_classnames_default()(prefixCls, className),
    onMouseDown: onMouseDown,
    onMouseUp: onMouseUp
  }, /*#__PURE__*/_react_18_2_0_react.createElement("div", {
    tabIndex: 0,
    ref: sentinelStartRef,
    style: sentinelStyle,
    "aria-hidden": "true"
  }), /*#__PURE__*/_react_18_2_0_react.createElement(MemoChildren, {
    shouldUpdate: visible || forceRender
  }, modalRender ? modalRender(content) : content), /*#__PURE__*/_react_18_2_0_react.createElement("div", {
    tabIndex: 0,
    ref: sentinelEndRef,
    style: sentinelStyle,
    "aria-hidden": "true"
  }));
});
if (false) {}
/* harmony default export */ var Content_Panel = (Panel_Panel);
;// CONCATENATED MODULE: ./node_modules/_rc-dialog@9.0.2@rc-dialog/es/Dialog/Content/index.js









var Content_Content = /*#__PURE__*/_react_18_2_0_react.forwardRef(function (props, ref) {
  var prefixCls = props.prefixCls,
    title = props.title,
    style = props.style,
    className = props.className,
    visible = props.visible,
    forceRender = props.forceRender,
    destroyOnClose = props.destroyOnClose,
    motionName = props.motionName,
    ariaId = props.ariaId,
    onVisibleChanged = props.onVisibleChanged,
    mousePosition = props.mousePosition;
  var dialogRef = (0,_react_18_2_0_react.useRef)();
  // ============================= Style ==============================
  var _React$useState = _react_18_2_0_react.useState(),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 2),
    transformOrigin = _React$useState2[0],
    setTransformOrigin = _React$useState2[1];
  var contentStyle = {};
  if (transformOrigin) {
    contentStyle.transformOrigin = transformOrigin;
  }
  function onPrepare() {
    var elementOffset = offset(dialogRef.current);
    setTransformOrigin(mousePosition ? "".concat(mousePosition.x - elementOffset.left, "px ").concat(mousePosition.y - elementOffset.top, "px") : '');
  }
  // ============================= Render =============================
  return /*#__PURE__*/_react_18_2_0_react.createElement(_rc_motion_2_6_3_rc_motion_es, {
    visible: visible,
    onVisibleChanged: onVisibleChanged,
    onAppearPrepare: onPrepare,
    onEnterPrepare: onPrepare,
    forceRender: forceRender,
    motionName: motionName,
    removeOnLeave: destroyOnClose,
    ref: dialogRef
  }, function (_ref, motionRef) {
    var motionClassName = _ref.className,
      motionStyle = _ref.style;
    return /*#__PURE__*/_react_18_2_0_react.createElement(Content_Panel, extends_extends({}, props, {
      ref: ref,
      title: title,
      ariaId: ariaId,
      prefixCls: prefixCls,
      holderRef: motionRef,
      style: _objectSpread2(_objectSpread2(_objectSpread2({}, motionStyle), style), contentStyle),
      className: _classnames_2_3_2_classnames_default()(className, motionClassName)
    }));
  });
});
Content_Content.displayName = 'Content';
/* harmony default export */ var Dialog_Content = (Content_Content);
;// CONCATENATED MODULE: ./node_modules/_rc-dialog@9.0.2@rc-dialog/es/Dialog/index.js













function Dialog(props) {
  var _props$prefixCls = props.prefixCls,
    prefixCls = _props$prefixCls === void 0 ? 'rc-dialog' : _props$prefixCls,
    zIndex = props.zIndex,
    _props$visible = props.visible,
    visible = _props$visible === void 0 ? false : _props$visible,
    _props$keyboard = props.keyboard,
    keyboard = _props$keyboard === void 0 ? true : _props$keyboard,
    _props$focusTriggerAf = props.focusTriggerAfterClose,
    focusTriggerAfterClose = _props$focusTriggerAf === void 0 ? true : _props$focusTriggerAf,
    wrapStyle = props.wrapStyle,
    wrapClassName = props.wrapClassName,
    wrapProps = props.wrapProps,
    onClose = props.onClose,
    afterClose = props.afterClose,
    transitionName = props.transitionName,
    animation = props.animation,
    _props$closable = props.closable,
    closable = _props$closable === void 0 ? true : _props$closable,
    _props$mask = props.mask,
    mask = _props$mask === void 0 ? true : _props$mask,
    maskTransitionName = props.maskTransitionName,
    maskAnimation = props.maskAnimation,
    _props$maskClosable = props.maskClosable,
    maskClosable = _props$maskClosable === void 0 ? true : _props$maskClosable,
    maskStyle = props.maskStyle,
    maskProps = props.maskProps,
    rootClassName = props.rootClassName;
  var lastOutSideActiveElementRef = (0,_react_18_2_0_react.useRef)();
  var wrapperRef = (0,_react_18_2_0_react.useRef)();
  var contentRef = (0,_react_18_2_0_react.useRef)();
  var _React$useState = _react_18_2_0_react.useState(visible),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 2),
    animatedVisible = _React$useState2[0],
    setAnimatedVisible = _React$useState2[1];
  // ========================== Init ==========================
  var ariaId = useId();
  function saveLastOutSideActiveElementRef() {
    if (!contains(wrapperRef.current, document.activeElement)) {
      lastOutSideActiveElementRef.current = document.activeElement;
    }
  }
  function focusDialogContent() {
    if (!contains(wrapperRef.current, document.activeElement)) {
      var _contentRef$current;
      (_contentRef$current = contentRef.current) === null || _contentRef$current === void 0 ? void 0 : _contentRef$current.focus();
    }
  }
  // ========================= Events =========================
  function onDialogVisibleChanged(newVisible) {
    // Try to focus
    if (newVisible) {
      focusDialogContent();
    } else {
      // Clean up scroll bar & focus back
      setAnimatedVisible(false);
      if (mask && lastOutSideActiveElementRef.current && focusTriggerAfterClose) {
        try {
          lastOutSideActiveElementRef.current.focus({
            preventScroll: true
          });
        } catch (e) {
          // Do nothing
        }
        lastOutSideActiveElementRef.current = null;
      }
      // Trigger afterClose only when change visible from true to false
      if (animatedVisible) {
        afterClose === null || afterClose === void 0 ? void 0 : afterClose();
      }
    }
  }
  function onInternalClose(e) {
    onClose === null || onClose === void 0 ? void 0 : onClose(e);
  }
  // >>> Content
  var contentClickRef = (0,_react_18_2_0_react.useRef)(false);
  var contentTimeoutRef = (0,_react_18_2_0_react.useRef)();
  // We need record content click incase content popup out of dialog
  var onContentMouseDown = function onContentMouseDown() {
    clearTimeout(contentTimeoutRef.current);
    contentClickRef.current = true;
  };
  var onContentMouseUp = function onContentMouseUp() {
    contentTimeoutRef.current = setTimeout(function () {
      contentClickRef.current = false;
    });
  };
  // >>> Wrapper
  // Close only when element not on dialog
  var onWrapperClick = null;
  if (maskClosable) {
    onWrapperClick = function onWrapperClick(e) {
      if (contentClickRef.current) {
        contentClickRef.current = false;
      } else if (wrapperRef.current === e.target) {
        onInternalClose(e);
      }
    };
  }
  function onWrapperKeyDown(e) {
    if (keyboard && e.keyCode === es_KeyCode.ESC) {
      e.stopPropagation();
      onInternalClose(e);
      return;
    }
    // keep focus inside dialog
    if (visible) {
      if (e.keyCode === es_KeyCode.TAB) {
        contentRef.current.changeActive(!e.shiftKey);
      }
    }
  }
  // ========================= Effect =========================
  (0,_react_18_2_0_react.useEffect)(function () {
    if (visible) {
      setAnimatedVisible(true);
      saveLastOutSideActiveElementRef();
    }
  }, [visible]);
  // Remove direct should also check the scroll bar update
  (0,_react_18_2_0_react.useEffect)(function () {
    return function () {
      clearTimeout(contentTimeoutRef.current);
    };
  }, []);
  // ========================= Render =========================
  return /*#__PURE__*/_react_18_2_0_react.createElement("div", extends_extends({
    className: _classnames_2_3_2_classnames_default()("".concat(prefixCls, "-root"), rootClassName)
  }, pickAttrs(props, {
    data: true
  })), /*#__PURE__*/_react_18_2_0_react.createElement(Mask, {
    prefixCls: prefixCls,
    visible: mask && visible,
    motionName: getMotionName(prefixCls, maskTransitionName, maskAnimation),
    style: _objectSpread2({
      zIndex: zIndex
    }, maskStyle),
    maskProps: maskProps
  }), /*#__PURE__*/_react_18_2_0_react.createElement("div", extends_extends({
    tabIndex: -1,
    onKeyDown: onWrapperKeyDown,
    className: _classnames_2_3_2_classnames_default()("".concat(prefixCls, "-wrap"), wrapClassName),
    ref: wrapperRef,
    onClick: onWrapperClick,
    style: _objectSpread2(_objectSpread2({
      zIndex: zIndex
    }, wrapStyle), {}, {
      display: !animatedVisible ? 'none' : null
    })
  }, wrapProps), /*#__PURE__*/_react_18_2_0_react.createElement(Dialog_Content, extends_extends({}, props, {
    onMouseDown: onContentMouseDown,
    onMouseUp: onContentMouseUp,
    ref: contentRef,
    closable: closable,
    ariaId: ariaId,
    prefixCls: prefixCls,
    visible: visible && animatedVisible,
    onClose: onInternalClose,
    onVisibleChanged: onDialogVisibleChanged,
    motionName: getMotionName(prefixCls, transitionName, animation)
  }))));
}
;// CONCATENATED MODULE: ./node_modules/_rc-dialog@9.0.2@rc-dialog/es/DialogWrap.js





// fix issue #10656
/*
 * getContainer remarks
 * Custom container should not be return, because in the Portal component, it will remove the
 * return container element here, if the custom container is the only child of it's component,
 * like issue #10656, It will has a conflict with removeChild method in react-dom.
 * So here should add a child (div element) to custom container.
 * */
var DialogWrap = function DialogWrap(props) {
  var visible = props.visible,
    getContainer = props.getContainer,
    forceRender = props.forceRender,
    _props$destroyOnClose = props.destroyOnClose,
    destroyOnClose = _props$destroyOnClose === void 0 ? false : _props$destroyOnClose,
    _afterClose = props.afterClose;
  var _React$useState = _react_18_2_0_react.useState(visible),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 2),
    animatedVisible = _React$useState2[0],
    setAnimatedVisible = _React$useState2[1];
  _react_18_2_0_react.useEffect(function () {
    if (visible) {
      setAnimatedVisible(true);
    }
  }, [visible]);
  // // 渲染在当前 dom 里；
  // if (getContainer === false) {
  //   return (
  //     <Dialog
  //       {...props}
  //       getOpenCount={() => 2} // 不对 body 做任何操作。。
  //     />
  //   );
  // }
  // Destroy on close will remove wrapped div
  if (!forceRender && destroyOnClose && !animatedVisible) {
    return null;
  }
  return /*#__PURE__*/_react_18_2_0_react.createElement(portal_es, {
    open: visible || forceRender || animatedVisible,
    autoDestroy: false,
    getContainer: getContainer,
    autoLock: visible || animatedVisible
  }, /*#__PURE__*/_react_18_2_0_react.createElement(Dialog, extends_extends({}, props, {
    destroyOnClose: destroyOnClose,
    afterClose: function afterClose() {
      _afterClose === null || _afterClose === void 0 ? void 0 : _afterClose();
      setAnimatedVisible(false);
    }
  })));
};
DialogWrap.displayName = 'Dialog';
/* harmony default export */ var es_DialogWrap = (DialogWrap);
;// CONCATENATED MODULE: ./node_modules/_rc-dialog@9.0.2@rc-dialog/es/index.js



/* harmony default export */ var _rc_dialog_9_0_2_rc_dialog_es = (es_DialogWrap);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/form/context.js





var context_FormContext = /*#__PURE__*/_react_18_2_0_react.createContext({
  labelAlign: 'right',
  vertical: false,
  itemRef: function itemRef() {}
});
var NoStyleItemContext = /*#__PURE__*/(/* unused pure expression or super */ null && (React.createContext(null)));
var context_FormProvider = function FormProvider(props) {
  var providerProps = omit(props, ['prefixCls']);
  return /*#__PURE__*/React.createElement(RcFormProvider, _extends({}, providerProps));
};
var FormItemPrefixContext = /*#__PURE__*/_react_18_2_0_react.createContext({
  prefixCls: ''
});
var FormItemInputContext = /*#__PURE__*/_react_18_2_0_react.createContext({});
var NoFormStyle = function NoFormStyle(_ref) {
  var children = _ref.children,
    status = _ref.status,
    override = _ref.override;
  var formItemInputContext = (0,_react_18_2_0_react.useContext)(FormItemInputContext);
  var newFormItemInputContext = (0,_react_18_2_0_react.useMemo)(function () {
    var newContext = extends_extends({}, formItemInputContext);
    if (override) {
      delete newContext.isFormItemInput;
    }
    if (status) {
      delete newContext.status;
      delete newContext.hasFeedback;
      delete newContext.feedbackIcon;
    }
    return newContext;
  }, [status, override, formItemInputContext]);
  return /*#__PURE__*/_react_18_2_0_react.createElement(FormItemInputContext.Provider, {
    value: newFormItemInputContext
  }, children);
};
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/_util/styleChecker.js


var canUseDocElement = function canUseDocElement() {
  return canUseDom() && window.document.documentElement;
};

var flexGapSupported;
var detectFlexGapSupported = function detectFlexGapSupported() {
  if (!canUseDocElement()) {
    return false;
  }
  if (flexGapSupported !== undefined) {
    return flexGapSupported;
  }
  // create flex container with row-gap set
  var flex = document.createElement('div');
  flex.style.display = 'flex';
  flex.style.flexDirection = 'column';
  flex.style.rowGap = '1px';
  // create two, elements inside it
  flex.appendChild(document.createElement('div'));
  flex.appendChild(document.createElement('div'));
  // append to the DOM (needed to obtain scrollHeight)
  document.body.appendChild(flex);
  flexGapSupported = flex.scrollHeight === 1; // flex container should be 1px high from the row-gap
  document.body.removeChild(flex);
  return flexGapSupported;
};
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/modal/Modal.js


var Modal_rest = undefined && undefined.__rest || function (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;
};














var mousePosition;
// ref: https://github.com/ant-design/ant-design/issues/15795
var getClickPosition = function getClickPosition(e) {
  mousePosition = {
    x: e.pageX,
    y: e.pageY
  };
  // 100ms 内发生过点击事件，则从点击位置动画展示
  // 否则直接 zoom 展示
  // 这样可以兼容非点击方式展开
  setTimeout(function () {
    mousePosition = null;
  }, 100);
};
// 只有点击事件支持从鼠标位置动画展开
if (canUseDocElement()) {
  document.documentElement.addEventListener('click', getClickPosition, true);
}
var Modal_Modal = function Modal(props) {
  var _classNames;
  var _a;
  var _React$useContext = _react_18_2_0_react.useContext(context_ConfigContext),
    getContextPopupContainer = _React$useContext.getPopupContainer,
    getPrefixCls = _React$useContext.getPrefixCls,
    direction = _React$useContext.direction;
  var handleCancel = function handleCancel(e) {
    var onCancel = props.onCancel;
    onCancel === null || onCancel === void 0 ? void 0 : onCancel(e);
  };
  var handleOk = function handleOk(e) {
    var onOk = props.onOk;
    onOk === null || onOk === void 0 ? void 0 : onOk(e);
  };
   false ? 0 : void 0;
  var customizePrefixCls = props.prefixCls,
    footer = props.footer,
    visible = props.visible,
    _props$open = props.open,
    open = _props$open === void 0 ? false : _props$open,
    wrapClassName = props.wrapClassName,
    centered = props.centered,
    getContainer = props.getContainer,
    closeIcon = props.closeIcon,
    _props$focusTriggerAf = props.focusTriggerAfterClose,
    focusTriggerAfterClose = _props$focusTriggerAf === void 0 ? true : _props$focusTriggerAf,
    _props$width = props.width,
    width = _props$width === void 0 ? 520 : _props$width,
    restProps = Modal_rest(props, ["prefixCls", "footer", "visible", "open", "wrapClassName", "centered", "getContainer", "closeIcon", "focusTriggerAfterClose", "width"]);
  var prefixCls = getPrefixCls('modal', customizePrefixCls);
  var rootPrefixCls = getPrefixCls();
  var defaultFooter = /*#__PURE__*/_react_18_2_0_react.createElement(locale_provider_LocaleReceiver, {
    componentName: "Modal",
    defaultLocale: getConfirmLocale()
  }, function (contextLocale) {
    var okText = props.okText,
      _props$okType = props.okType,
      okType = _props$okType === void 0 ? 'primary' : _props$okType,
      cancelText = props.cancelText,
      _props$confirmLoading = props.confirmLoading,
      confirmLoading = _props$confirmLoading === void 0 ? false : _props$confirmLoading;
    return /*#__PURE__*/_react_18_2_0_react.createElement(_react_18_2_0_react.Fragment, null, /*#__PURE__*/_react_18_2_0_react.createElement(es_button, extends_extends({
      onClick: handleCancel
    }, props.cancelButtonProps), cancelText || contextLocale.cancelText), /*#__PURE__*/_react_18_2_0_react.createElement(es_button, extends_extends({}, convertLegacyProps(okType), {
      loading: confirmLoading,
      onClick: handleOk
    }, props.okButtonProps), okText !== null && okText !== void 0 ? okText : contextLocale.okText));
  });
  var closeIconToRender = /*#__PURE__*/_react_18_2_0_react.createElement("span", {
    className: "".concat(prefixCls, "-close-x")
  }, closeIcon || /*#__PURE__*/_react_18_2_0_react.createElement(icons_CloseOutlined, {
    className: "".concat(prefixCls, "-close-icon")
  }));
  var wrapClassNameExtended = _classnames_2_3_2_classnames_default()(wrapClassName, (_classNames = {}, defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-centered"), !!centered), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-wrap-rtl"), direction === 'rtl'), _classNames));
  return /*#__PURE__*/_react_18_2_0_react.createElement(NoCompactStyle, null, /*#__PURE__*/_react_18_2_0_react.createElement(NoFormStyle, {
    status: true,
    override: true
  }, /*#__PURE__*/_react_18_2_0_react.createElement(_rc_dialog_9_0_2_rc_dialog_es, extends_extends({
    width: width
  }, restProps, {
    getContainer: getContainer === undefined ? getContextPopupContainer : getContainer,
    prefixCls: prefixCls,
    wrapClassName: wrapClassNameExtended,
    footer: footer === undefined ? defaultFooter : footer,
    visible: open || visible,
    mousePosition: (_a = restProps.mousePosition) !== null && _a !== void 0 ? _a : mousePosition,
    onClose: handleCancel,
    closeIcon: closeIconToRender,
    focusTriggerAfterClose: focusTriggerAfterClose,
    transitionName: motion_getTransitionName(rootPrefixCls, 'zoom', props.transitionName),
    maskTransitionName: motion_getTransitionName(rootPrefixCls, 'fade', props.maskTransitionName)
  }))));
};
/* harmony default export */ var modal_Modal = (Modal_Modal);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/modal/ConfirmDialog.js








var ConfirmDialog = function ConfirmDialog(props) {
  var icon = props.icon,
    onCancel = props.onCancel,
    onOk = props.onOk,
    close = props.close,
    zIndex = props.zIndex,
    afterClose = props.afterClose,
    visible = props.visible,
    open = props.open,
    keyboard = props.keyboard,
    centered = props.centered,
    getContainer = props.getContainer,
    maskStyle = props.maskStyle,
    okText = props.okText,
    okButtonProps = props.okButtonProps,
    cancelText = props.cancelText,
    cancelButtonProps = props.cancelButtonProps,
    direction = props.direction,
    prefixCls = props.prefixCls,
    wrapClassName = props.wrapClassName,
    rootPrefixCls = props.rootPrefixCls,
    iconPrefixCls = props.iconPrefixCls,
    bodyStyle = props.bodyStyle,
    _props$closable = props.closable,
    closable = _props$closable === void 0 ? false : _props$closable,
    closeIcon = props.closeIcon,
    modalRender = props.modalRender,
    focusTriggerAfterClose = props.focusTriggerAfterClose;
  if (false) {}
  // 支持传入{ icon: null }来隐藏`Modal.confirm`默认的Icon
  var okType = props.okType || 'primary';
  var contentPrefixCls = "".concat(prefixCls, "-confirm");
  // 默认为 true，保持向下兼容
  var okCancel = 'okCancel' in props ? props.okCancel : true;
  var width = props.width || 416;
  var style = props.style || {};
  var mask = props.mask === undefined ? true : props.mask;
  // 默认为 false，保持旧版默认行为
  var maskClosable = props.maskClosable === undefined ? false : props.maskClosable;
  var autoFocusButton = props.autoFocusButton === null ? false : props.autoFocusButton || 'ok';
  var classString = _classnames_2_3_2_classnames_default()(contentPrefixCls, "".concat(contentPrefixCls, "-").concat(props.type), defineProperty_defineProperty({}, "".concat(contentPrefixCls, "-rtl"), direction === 'rtl'), props.className);
  var cancelButton = okCancel && /*#__PURE__*/_react_18_2_0_react.createElement(_util_ActionButton, {
    actionFn: onCancel,
    close: close,
    autoFocus: autoFocusButton === 'cancel',
    buttonProps: cancelButtonProps,
    prefixCls: "".concat(rootPrefixCls, "-btn")
  }, cancelText);
  return /*#__PURE__*/_react_18_2_0_react.createElement(config_provider, {
    prefixCls: rootPrefixCls,
    iconPrefixCls: iconPrefixCls,
    direction: direction
  }, /*#__PURE__*/_react_18_2_0_react.createElement(modal_Modal, {
    prefixCls: prefixCls,
    className: classString,
    wrapClassName: _classnames_2_3_2_classnames_default()(defineProperty_defineProperty({}, "".concat(contentPrefixCls, "-centered"), !!props.centered), wrapClassName),
    onCancel: function onCancel() {
      return close === null || close === void 0 ? void 0 : close({
        triggerCancel: true
      });
    },
    open: open || visible,
    title: "",
    footer: "",
    transitionName: motion_getTransitionName(rootPrefixCls, 'zoom', props.transitionName),
    maskTransitionName: motion_getTransitionName(rootPrefixCls, 'fade', props.maskTransitionName),
    mask: mask,
    maskClosable: maskClosable,
    maskStyle: maskStyle,
    style: style,
    bodyStyle: bodyStyle,
    width: width,
    zIndex: zIndex,
    afterClose: afterClose,
    keyboard: keyboard,
    centered: centered,
    getContainer: getContainer,
    closable: closable,
    closeIcon: closeIcon,
    modalRender: modalRender,
    focusTriggerAfterClose: focusTriggerAfterClose
  }, /*#__PURE__*/_react_18_2_0_react.createElement("div", {
    className: "".concat(contentPrefixCls, "-body-wrapper")
  }, /*#__PURE__*/_react_18_2_0_react.createElement("div", {
    className: "".concat(contentPrefixCls, "-body")
  }, icon, props.title === undefined ? null : /*#__PURE__*/_react_18_2_0_react.createElement("span", {
    className: "".concat(contentPrefixCls, "-title")
  }, props.title), /*#__PURE__*/_react_18_2_0_react.createElement("div", {
    className: "".concat(contentPrefixCls, "-content")
  }, props.content)), /*#__PURE__*/_react_18_2_0_react.createElement("div", {
    className: "".concat(contentPrefixCls, "-btns")
  }, cancelButton, /*#__PURE__*/_react_18_2_0_react.createElement(_util_ActionButton, {
    type: okType,
    actionFn: onOk,
    close: close,
    autoFocus: autoFocusButton === 'ok',
    buttonProps: okButtonProps,
    prefixCls: "".concat(rootPrefixCls, "-btn")
  }, okText)))));
};
/* harmony default export */ var modal_ConfirmDialog = (ConfirmDialog);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/modal/destroyFns.js
var destroyFns = [];
/* harmony default export */ var modal_destroyFns = (destroyFns);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/modal/confirm.js


var confirm_rest = undefined && undefined.__rest || function (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;
};











var defaultRootPrefixCls = '';
function getRootPrefixCls() {
  return defaultRootPrefixCls;
}
function confirm_confirm(config) {
  var container = document.createDocumentFragment();
  // eslint-disable-next-line @typescript-eslint/no-use-before-define
  var currentConfig = extends_extends(extends_extends({}, config), {
    close: close,
    open: true
  });
  var timeoutId;
  function destroy() {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    var triggerCancel = args.some(function (param) {
      return param && param.triggerCancel;
    });
    if (config.onCancel && triggerCancel) {
      config.onCancel.apply(config, [function () {}].concat(_toConsumableArray(args.slice(1))));
    }
    for (var i = 0; i < modal_destroyFns.length; i++) {
      var fn = modal_destroyFns[i];
      // eslint-disable-next-line @typescript-eslint/no-use-before-define
      if (fn === close) {
        modal_destroyFns.splice(i, 1);
        break;
      }
    }
    unmount(container);
  }
  function render(_a) {
    var okText = _a.okText,
      cancelText = _a.cancelText,
      customizePrefixCls = _a.prefixCls,
      props = confirm_rest(_a, ["okText", "cancelText", "prefixCls"]);
    clearTimeout(timeoutId);
    /**
     * https://github.com/ant-design/ant-design/issues/23623
     *
     * Sync render blocks React event. Let's make this async.
     */
    timeoutId = setTimeout(function () {
      var runtimeLocale = getConfirmLocale();
      var _globalConfig = globalConfig(),
        getPrefixCls = _globalConfig.getPrefixCls,
        getIconPrefixCls = _globalConfig.getIconPrefixCls;
      // because Modal.config  set rootPrefixCls, which is different from other components
      var rootPrefixCls = getPrefixCls(undefined, getRootPrefixCls());
      var prefixCls = customizePrefixCls || "".concat(rootPrefixCls, "-modal");
      var iconPrefixCls = getIconPrefixCls();
      render_render( /*#__PURE__*/_react_18_2_0_react.createElement(modal_ConfirmDialog, extends_extends({}, props, {
        prefixCls: prefixCls,
        rootPrefixCls: rootPrefixCls,
        iconPrefixCls: iconPrefixCls,
        okText: okText || (props.okCancel ? runtimeLocale.okText : runtimeLocale.justOkText),
        cancelText: cancelText || runtimeLocale.cancelText
      })), container);
    });
  }
  function close() {
    var _this = this;
    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }
    currentConfig = extends_extends(extends_extends({}, currentConfig), {
      open: false,
      afterClose: function afterClose() {
        if (typeof config.afterClose === 'function') {
          config.afterClose();
        }
        destroy.apply(_this, args);
      }
    });
    // Legacy support
    if (currentConfig.visible) {
      delete currentConfig.visible;
    }
    render(currentConfig);
  }
  function update(configUpdate) {
    if (typeof configUpdate === 'function') {
      currentConfig = configUpdate(currentConfig);
    } else {
      currentConfig = extends_extends(extends_extends({}, currentConfig), configUpdate);
    }
    render(currentConfig);
  }
  render(currentConfig);
  modal_destroyFns.push(close);
  return {
    destroy: close,
    update: update
  };
}
function withWarn(props) {
  return extends_extends(extends_extends({
    icon: /*#__PURE__*/_react_18_2_0_react.createElement(icons_ExclamationCircleOutlined, null),
    okCancel: false
  }, props), {
    type: 'warning'
  });
}
function withInfo(props) {
  return extends_extends(extends_extends({
    icon: /*#__PURE__*/_react_18_2_0_react.createElement(icons_InfoCircleOutlined, null),
    okCancel: false
  }, props), {
    type: 'info'
  });
}
function withSuccess(props) {
  return extends_extends(extends_extends({
    icon: /*#__PURE__*/_react_18_2_0_react.createElement(icons_CheckCircleOutlined, null),
    okCancel: false
  }, props), {
    type: 'success'
  });
}
function withError(props) {
  return extends_extends(extends_extends({
    icon: /*#__PURE__*/_react_18_2_0_react.createElement(icons_CloseCircleOutlined, null),
    okCancel: false
  }, props), {
    type: 'error'
  });
}
function withConfirm(props) {
  return extends_extends(extends_extends({
    icon: /*#__PURE__*/_react_18_2_0_react.createElement(icons_ExclamationCircleOutlined, null),
    okCancel: true
  }, props), {
    type: 'confirm'
  });
}
function modalGlobalConfig(_ref) {
  var rootPrefixCls = _ref.rootPrefixCls;
   false ? 0 : void 0;
  defaultRootPrefixCls = rootPrefixCls;
}
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/_util/hooks/usePatchElement.js



function usePatchElement() {
  var _React$useState = _react_18_2_0_react.useState([]),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 2),
    elements = _React$useState2[0],
    setElements = _React$useState2[1];
  var patchElement = _react_18_2_0_react.useCallback(function (element) {
    // append a new element to elements (and create a new ref)
    setElements(function (originElements) {
      return [].concat(_toConsumableArray(originElements), [element]);
    });
    // return a function that removes the new element out of elements (and create a new ref)
    // it works a little like useEffect
    return function () {
      setElements(function (originElements) {
        return originElements.filter(function (ele) {
          return ele !== element;
        });
      });
    };
  }, []);
  return [elements, patchElement];
}
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/modal/useModal/HookModal.js








var HookModal = function HookModal(_ref, ref) {
  var afterClose = _ref.afterClose,
    config = _ref.config;
  var _React$useState = _react_18_2_0_react.useState(true),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 2),
    open = _React$useState2[0],
    setOpen = _React$useState2[1];
  var _React$useState3 = _react_18_2_0_react.useState(config),
    _React$useState4 = slicedToArray_slicedToArray(_React$useState3, 2),
    innerConfig = _React$useState4[0],
    setInnerConfig = _React$useState4[1];
  var _React$useContext = _react_18_2_0_react.useContext(context_ConfigContext),
    direction = _React$useContext.direction,
    getPrefixCls = _React$useContext.getPrefixCls;
  var prefixCls = getPrefixCls('modal');
  var rootPrefixCls = getPrefixCls();
  var close = function close() {
    setOpen(false);
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    var triggerCancel = args.some(function (param) {
      return param && param.triggerCancel;
    });
    if (innerConfig.onCancel && triggerCancel) {
      innerConfig.onCancel.apply(innerConfig, [function () {}].concat(_toConsumableArray(args.slice(1))));
    }
  };
  _react_18_2_0_react.useImperativeHandle(ref, function () {
    return {
      destroy: close,
      update: function update(newConfig) {
        setInnerConfig(function (originConfig) {
          return extends_extends(extends_extends({}, originConfig), newConfig);
        });
      }
    };
  });
  return /*#__PURE__*/_react_18_2_0_react.createElement(locale_provider_LocaleReceiver, {
    componentName: "Modal",
    defaultLocale: locale_default.Modal
  }, function (contextLocale) {
    return /*#__PURE__*/_react_18_2_0_react.createElement(modal_ConfirmDialog, extends_extends({
      prefixCls: prefixCls,
      rootPrefixCls: rootPrefixCls
    }, innerConfig, {
      close: close,
      open: open,
      afterClose: afterClose,
      okText: innerConfig.okText || (innerConfig.okCancel ? contextLocale.okText : contextLocale.justOkText),
      direction: direction,
      cancelText: innerConfig.cancelText || contextLocale.cancelText
    }));
  });
};
/* harmony default export */ var useModal_HookModal = (/*#__PURE__*/_react_18_2_0_react.forwardRef(HookModal));
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/modal/useModal/index.js






var useModal_uuid = 0;
var ElementsHolder = /*#__PURE__*/_react_18_2_0_react.memo( /*#__PURE__*/_react_18_2_0_react.forwardRef(function (_props, ref) {
  var _usePatchElement = usePatchElement(),
    _usePatchElement2 = slicedToArray_slicedToArray(_usePatchElement, 2),
    elements = _usePatchElement2[0],
    patchElement = _usePatchElement2[1];
  _react_18_2_0_react.useImperativeHandle(ref, function () {
    return {
      patchElement: patchElement
    };
  }, []);
  // eslint-disable-next-line react/jsx-no-useless-fragment
  return /*#__PURE__*/_react_18_2_0_react.createElement(_react_18_2_0_react.Fragment, null, elements);
}));
function useModal() {
  var holderRef = _react_18_2_0_react.useRef(null);
  // ========================== Effect ==========================
  var _React$useState = _react_18_2_0_react.useState([]),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 2),
    actionQueue = _React$useState2[0],
    setActionQueue = _React$useState2[1];
  _react_18_2_0_react.useEffect(function () {
    if (actionQueue.length) {
      var cloneQueue = _toConsumableArray(actionQueue);
      cloneQueue.forEach(function (action) {
        action();
      });
      setActionQueue([]);
    }
  }, [actionQueue]);
  // =========================== Hook ===========================
  var getConfirmFunc = _react_18_2_0_react.useCallback(function (withFunc) {
    return function hookConfirm(config) {
      var _a;
      useModal_uuid += 1;
      var modalRef = /*#__PURE__*/_react_18_2_0_react.createRef();
      var closeFunc;
      var modal = /*#__PURE__*/_react_18_2_0_react.createElement(useModal_HookModal, {
        key: "modal-".concat(useModal_uuid),
        config: withFunc(config),
        ref: modalRef,
        afterClose: function afterClose() {
          closeFunc === null || closeFunc === void 0 ? void 0 : closeFunc();
        }
      });
      closeFunc = (_a = holderRef.current) === null || _a === void 0 ? void 0 : _a.patchElement(modal);
      return {
        destroy: function destroy() {
          function destroyAction() {
            var _a;
            (_a = modalRef.current) === null || _a === void 0 ? void 0 : _a.destroy();
          }
          if (modalRef.current) {
            destroyAction();
          } else {
            setActionQueue(function (prev) {
              return [].concat(_toConsumableArray(prev), [destroyAction]);
            });
          }
        },
        update: function update(newConfig) {
          function updateAction() {
            var _a;
            (_a = modalRef.current) === null || _a === void 0 ? void 0 : _a.update(newConfig);
          }
          if (modalRef.current) {
            updateAction();
          } else {
            setActionQueue(function (prev) {
              return [].concat(_toConsumableArray(prev), [updateAction]);
            });
          }
        }
      };
    };
  }, []);
  var fns = _react_18_2_0_react.useMemo(function () {
    return {
      info: getConfirmFunc(withInfo),
      success: getConfirmFunc(withSuccess),
      error: getConfirmFunc(withError),
      warning: getConfirmFunc(withWarn),
      confirm: getConfirmFunc(withConfirm)
    };
  }, []);
  // eslint-disable-next-line react/jsx-key
  return [fns, /*#__PURE__*/_react_18_2_0_react.createElement(ElementsHolder, {
    ref: holderRef
  })];
}
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/modal/index.js




function modalWarn(props) {
  return confirm_confirm(withWarn(props));
}
var es_modal_Modal = modal_Modal;
es_modal_Modal.useModal = useModal;
es_modal_Modal.info = function infoFn(props) {
  return confirm_confirm(withInfo(props));
};
es_modal_Modal.success = function successFn(props) {
  return confirm_confirm(withSuccess(props));
};
es_modal_Modal.error = function errorFn(props) {
  return confirm_confirm(withError(props));
};
es_modal_Modal.warning = modalWarn;
es_modal_Modal.warn = modalWarn;
es_modal_Modal.confirm = function confirmFn(props) {
  return confirm_confirm(withConfirm(props));
};
es_modal_Modal.destroyAll = function destroyAllFn() {
  while (modal_destroyFns.length) {
    var close = modal_destroyFns.pop();
    if (close) {
      close();
    }
  }
};
es_modal_Modal.config = modalGlobalConfig;
/* harmony default export */ var modal = (es_modal_Modal);
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/objectDestructuringEmpty.js
function _objectDestructuringEmpty(obj) {
  if (obj == null) throw new TypeError("Cannot destructure " + obj);
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/isNativeFunction.js
function isNativeFunction_isNativeFunction(fn) {
  return Function.toString.call(fn).indexOf("[native code]") !== -1;
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/construct.js


function construct_construct(Parent, args, Class) {
  if (_isNativeReflectConstruct()) {
    construct_construct = Reflect.construct.bind();
  } else {
    construct_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_construct.apply(null, arguments);
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/wrapNativeSuper.js




function wrapNativeSuper_wrapNativeSuper(Class) {
  var _cache = typeof Map === "function" ? new Map() : undefined;
  wrapNativeSuper_wrapNativeSuper = function _wrapNativeSuper(Class) {
    if (Class === null || !isNativeFunction_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_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_wrapNativeSuper(Class);
}
;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/createForOfIteratorHelper.js

function _createForOfIteratorHelper(o, allowArrayLike) {
  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
  if (!it) {
    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
      if (it) o = it;
      var i = 0;
      var F = function F() {};
      return {
        s: F,
        n: function n() {
          if (i >= o.length) return {
            done: true
          };
          return {
            done: false,
            value: o[i++]
          };
        },
        e: function e(_e) {
          throw _e;
        },
        f: F
      };
    }
    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }
  var normalCompletion = true,
    didErr = false,
    err;
  return {
    s: function s() {
      it = it.call(o);
    },
    n: function n() {
      var step = it.next();
      normalCompletion = step.done;
      return step;
    },
    e: function e(_e2) {
      didErr = true;
      err = _e2;
    },
    f: function f() {
      try {
        if (!normalCompletion && it["return"] != null) it["return"]();
      } finally {
        if (didErr) throw err;
      }
    }
  };
}
;// CONCATENATED MODULE: ./node_modules/_recoil@0.7.7@recoil/es/index.js















var es_excluded = ["override"],
  es_excluded2 = ["cachePolicyForParams_UNSTABLE"];
var _marked = /*#__PURE__*/regeneratorRuntime_regeneratorRuntime().mark(filterIterable),
  _marked2 = /*#__PURE__*/regeneratorRuntime_regeneratorRuntime().mark(concatIterables);



/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */

function err(message) {
  var error = new Error(message); // In V8, Error objects keep the closure scope chain alive until the
  // err.stack property is accessed.

  if (error.stack === undefined) {
    // IE sets the stack only if error is thrown
    try {
      throw error;
    } catch (_) {} // eslint-disable-line fb-www/no-unused-catch-bindings, no-empty
  }

  return error;
}
var err_1 = err;

// @oss-only

var Recoil_err = err_1;

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */

// Split declaration and implementation to allow this function to pretend to
// check for actual instance of Promise instead of something with a `then`
// method.
// eslint-disable-next-line no-redeclare
function isPromise(p) {
  return !!p && typeof p.then === 'function';
}
var Recoil_isPromise = isPromise;
function nullthrows(x, message) {
  if (x != null) {
    return x;
  }
  throw Recoil_err(message !== null && message !== void 0 ? message : 'Got unexpected null or undefined');
}
var Recoil_nullthrows = nullthrows;
function es_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;
}
var BaseLoadable = /*#__PURE__*/function () {
  function BaseLoadable() {
    _classCallCheck(this, BaseLoadable);
  }
  _createClass(BaseLoadable, [{
    key: "getValue",
    value: function getValue() {
      throw Recoil_err('BaseLoadable');
    }
  }, {
    key: "toPromise",
    value: function toPromise() {
      throw Recoil_err('BaseLoadable');
    }
  }, {
    key: "valueMaybe",
    value: function valueMaybe() {
      throw Recoil_err('BaseLoadable');
    }
  }, {
    key: "valueOrThrow",
    value: function valueOrThrow() {
      // $FlowFixMe[prop-missing]
      throw Recoil_err("Loadable expected value, but in \"".concat(this.state, "\" state"));
    }
  }, {
    key: "promiseMaybe",
    value: function promiseMaybe() {
      throw Recoil_err('BaseLoadable');
    }
  }, {
    key: "promiseOrThrow",
    value: function promiseOrThrow() {
      // $FlowFixMe[prop-missing]
      throw Recoil_err("Loadable expected promise, but in \"".concat(this.state, "\" state"));
    }
  }, {
    key: "errorMaybe",
    value: function errorMaybe() {
      throw Recoil_err('BaseLoadable');
    }
  }, {
    key: "errorOrThrow",
    value: function errorOrThrow() {
      // $FlowFixMe[prop-missing]
      throw Recoil_err("Loadable expected error, but in \"".concat(this.state, "\" state"));
    }
  }, {
    key: "is",
    value: function is(other) {
      // $FlowFixMe[prop-missing]
      return other.state === this.state && other.contents === this.contents;
    }
  }, {
    key: "map",
    value: function map(_map) {
      throw Recoil_err('BaseLoadable');
    }
  }]);
  return BaseLoadable;
}();
var ValueLoadable = /*#__PURE__*/function (_BaseLoadable) {
  _inherits(ValueLoadable, _BaseLoadable);
  var _super = _createSuper(ValueLoadable);
  function ValueLoadable(value) {
    var _this;
    _classCallCheck(this, ValueLoadable);
    _this = _super.call(this);
    es_defineProperty(_assertThisInitialized(_this), "state", 'hasValue');
    es_defineProperty(_assertThisInitialized(_this), "contents", void 0);
    _this.contents = value;
    return _this;
  }
  _createClass(ValueLoadable, [{
    key: "getValue",
    value: function getValue() {
      return this.contents;
    }
  }, {
    key: "toPromise",
    value: function toPromise() {
      return Promise.resolve(this.contents);
    }
  }, {
    key: "valueMaybe",
    value: function valueMaybe() {
      return this.contents;
    }
  }, {
    key: "valueOrThrow",
    value: function valueOrThrow() {
      return this.contents;
    }
  }, {
    key: "promiseMaybe",
    value: function promiseMaybe() {
      return undefined;
    }
  }, {
    key: "errorMaybe",
    value: function errorMaybe() {
      return undefined;
    }
  }, {
    key: "map",
    value: function map(_map2) {
      var _this2 = this;
      try {
        var next = _map2(this.contents);
        return Recoil_isPromise(next) ? loadableWithPromise(next) : isLoadable(next) ? next : loadableWithValue(next);
      } catch (e) {
        return Recoil_isPromise(e) ?
        // If we "suspended", then try again.
        // errors and subsequent retries will be handled in 'loading' case
        // $FlowFixMe[prop-missing]
        loadableWithPromise(e.next(function () {
          return _this2.map(_map2);
        })) : loadableWithError(e);
      }
    }
  }]);
  return ValueLoadable;
}(BaseLoadable);
var ErrorLoadable = /*#__PURE__*/function (_BaseLoadable2) {
  _inherits(ErrorLoadable, _BaseLoadable2);
  var _super2 = _createSuper(ErrorLoadable);
  function ErrorLoadable(error) {
    var _this3;
    _classCallCheck(this, ErrorLoadable);
    _this3 = _super2.call(this);
    es_defineProperty(_assertThisInitialized(_this3), "state", 'hasError');
    es_defineProperty(_assertThisInitialized(_this3), "contents", void 0);
    _this3.contents = error;
    return _this3;
  }
  _createClass(ErrorLoadable, [{
    key: "getValue",
    value: function getValue() {
      throw this.contents;
    }
  }, {
    key: "toPromise",
    value: function toPromise() {
      return Promise.reject(this.contents);
    }
  }, {
    key: "valueMaybe",
    value: function valueMaybe() {
      return undefined;
    }
  }, {
    key: "promiseMaybe",
    value: function promiseMaybe() {
      return undefined;
    }
  }, {
    key: "errorMaybe",
    value: function errorMaybe() {
      return this.contents;
    }
  }, {
    key: "errorOrThrow",
    value: function errorOrThrow() {
      return this.contents;
    }
  }, {
    key: "map",
    value: function map(_map) {
      // $FlowIssue[incompatible-return]
      return this;
    }
  }]);
  return ErrorLoadable;
}(BaseLoadable);
var LoadingLoadable = /*#__PURE__*/function (_BaseLoadable3) {
  _inherits(LoadingLoadable, _BaseLoadable3);
  var _super3 = _createSuper(LoadingLoadable);
  function LoadingLoadable(promise) {
    var _this4;
    _classCallCheck(this, LoadingLoadable);
    _this4 = _super3.call(this);
    es_defineProperty(_assertThisInitialized(_this4), "state", 'loading');
    es_defineProperty(_assertThisInitialized(_this4), "contents", void 0);
    _this4.contents = promise;
    return _this4;
  }
  _createClass(LoadingLoadable, [{
    key: "getValue",
    value: function getValue() {
      throw this.contents;
    }
  }, {
    key: "toPromise",
    value: function toPromise() {
      return this.contents;
    }
  }, {
    key: "valueMaybe",
    value: function valueMaybe() {
      return undefined;
    }
  }, {
    key: "promiseMaybe",
    value: function promiseMaybe() {
      return this.contents;
    }
  }, {
    key: "promiseOrThrow",
    value: function promiseOrThrow() {
      return this.contents;
    }
  }, {
    key: "errorMaybe",
    value: function errorMaybe() {
      return undefined;
    }
  }, {
    key: "map",
    value: function map(_map3) {
      var _this5 = this;
      return loadableWithPromise(this.contents.then(function (value) {
        var next = _map3(value);
        if (isLoadable(next)) {
          var nextLoadable = next;
          switch (nextLoadable.state) {
            case 'hasValue':
              return nextLoadable.contents;
            case 'hasError':
              throw nextLoadable.contents;
            case 'loading':
              return nextLoadable.contents;
          }
        } // $FlowIssue[incompatible-return]

        return next;
      }) // $FlowFixMe[incompatible-call]
      .catch(function (e) {
        if (Recoil_isPromise(e)) {
          // we were "suspended," try again
          return e.then(function () {
            return _this5.map(_map3).contents;
          });
        }
        throw e;
      }));
    }
  }]);
  return LoadingLoadable;
}(BaseLoadable);
function loadableWithValue(value) {
  return Object.freeze(new ValueLoadable(value));
}
function loadableWithError(error) {
  return Object.freeze(new ErrorLoadable(error));
}
function loadableWithPromise(promise) {
  return Object.freeze(new LoadingLoadable(promise));
}
function loadableLoading() {
  return Object.freeze(new LoadingLoadable(new Promise(function () {})));
}
function loadableAllArray(inputs) {
  return inputs.every(function (i) {
    return i.state === 'hasValue';
  }) ? loadableWithValue(inputs.map(function (i) {
    return i.contents;
  })) : inputs.some(function (i) {
    return i.state === 'hasError';
  }) ? loadableWithError(Recoil_nullthrows(inputs.find(function (i) {
    return i.state === 'hasError';
  }), 'Invalid loadable passed to loadableAll').contents) : loadableWithPromise(Promise.all(inputs.map(function (i) {
    return i.contents;
  })));
}
function loadableAll(inputs) {
  var unwrapedInputs = Array.isArray(inputs) ? inputs : Object.getOwnPropertyNames(inputs).map(function (key) {
    return inputs[key];
  });
  var normalizedInputs = unwrapedInputs.map(function (x) {
    return isLoadable(x) ? x : Recoil_isPromise(x) ? loadableWithPromise(x) : loadableWithValue(x);
  });
  var output = loadableAllArray(normalizedInputs);
  return Array.isArray(inputs) ?
  // $FlowIssue[incompatible-return]
  output :
  // Object.getOwnPropertyNames() has consistent key ordering with ES6
  // $FlowIssue[incompatible-call]
  output.map(function (outputs) {
    return Object.getOwnPropertyNames(inputs).reduce(
    // $FlowFixMe[invalid-computed-prop]
    function (out, key, idx) {
      return _objectSpread2(_objectSpread2({}, out), {}, defineProperty_defineProperty({}, key, outputs[idx]));
    }, {});
  });
}
function isLoadable(x) {
  return x instanceof BaseLoadable;
}
var LoadableStaticInterface = {
  of: function of(value) {
    return Recoil_isPromise(value) ? loadableWithPromise(value) : isLoadable(value) ? value : loadableWithValue(value);
  },
  error: function error(_error) {
    return loadableWithError(_error);
  },
  // $FlowIssue[incompatible-return]
  loading: function loading() {
    return loadableLoading();
  },
  // $FlowIssue[unclear-type]
  all: loadableAll,
  isLoadable: isLoadable
};
var Recoil_Loadable = {
  loadableWithValue: loadableWithValue,
  loadableWithError: loadableWithError,
  loadableWithPromise: loadableWithPromise,
  loadableLoading: loadableLoading,
  loadableAll: loadableAll,
  isLoadable: isLoadable,
  RecoilLoadable: LoadableStaticInterface
};
var Recoil_Loadable_1 = Recoil_Loadable.loadableWithValue;
var Recoil_Loadable_2 = Recoil_Loadable.loadableWithError;
var Recoil_Loadable_3 = Recoil_Loadable.loadableWithPromise;
var Recoil_Loadable_4 = Recoil_Loadable.loadableLoading;
var Recoil_Loadable_5 = Recoil_Loadable.loadableAll;
var Recoil_Loadable_6 = Recoil_Loadable.isLoadable;
var Recoil_Loadable_7 = Recoil_Loadable.RecoilLoadable;
var Recoil_Loadable$1 = /*#__PURE__*/Object.freeze({
  __proto__: null,
  loadableWithValue: Recoil_Loadable_1,
  loadableWithError: Recoil_Loadable_2,
  loadableWithPromise: Recoil_Loadable_3,
  loadableLoading: Recoil_Loadable_4,
  loadableAll: Recoil_Loadable_5,
  isLoadable: Recoil_Loadable_6,
  RecoilLoadable: Recoil_Loadable_7
});
var env = {
  RECOIL_DUPLICATE_ATOM_KEY_CHECKING_ENABLED: true,
  // Note: RECOIL_GKS_ENABLED settings will only be honored in OSS builds of Recoil
  RECOIL_GKS_ENABLED: new Set(['recoil_hamt_2020', 'recoil_sync_external_store', 'recoil_suppress_rerender_in_callback', 'recoil_memory_managament_2020'])
};
function readProcessEnvBooleanFlag(name, set) {
  var _process$env$name, _process$env$name$toL;
  var sanitizedValue = (_process$env$name = ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"})[name]) === null || _process$env$name === void 0 ? void 0 : (_process$env$name$toL = _process$env$name.toLowerCase()) === null || _process$env$name$toL === void 0 ? void 0 : _process$env$name$toL.trim();
  if (sanitizedValue == null || sanitizedValue === '') {
    return;
  }
  var allowedValues = ['true', 'false'];
  if (!allowedValues.includes(sanitizedValue)) {
    throw Recoil_err("process.env.".concat(name, " value must be 'true', 'false', or empty: ").concat(sanitizedValue));
  }
  set(sanitizedValue === 'true');
}
function readProcessEnvStringArrayFlag(name, set) {
  var _process$env$name2;
  var sanitizedValue = (_process$env$name2 = ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"})[name]) === null || _process$env$name2 === void 0 ? void 0 : _process$env$name2.trim();
  if (sanitizedValue == null || sanitizedValue === '') {
    return;
  }
  set(sanitizedValue.split(/\s*,\s*|\s+/));
}
/**
 * Allow NodeJS/NextJS/etc to set the initial state through process.env variable
 * Note:  we don't assume 'process' is available in all runtime environments
 *
 * @see https://github.com/facebookexperimental/Recoil/issues/733
 */

function applyProcessEnvFlagOverrides() {
  var _process;

  // note: this check is needed in addition to the check below, runtime error will occur without it!
  // eslint-disable-next-line fb-www/typeof-undefined
  if (typeof process === 'undefined') {
    return;
  }
  if (((_process = process) === null || _process === void 0 ? void 0 : ({"NODE_ENV":"production","PUBLIC_URL":"","WDS_SOCKET_HOST":undefined,"WDS_SOCKET_PATH":undefined,"WDS_SOCKET_PORT":undefined,"FAST_REFRESH":true,"REACT_APP_SERVER_ENV":"prod","REACT_APP_INSTALL_MODE":"developer","REACT_APP_PUBLISH_NAME":"publicServer"})) == null) {
    return;
  }
  readProcessEnvBooleanFlag('RECOIL_DUPLICATE_ATOM_KEY_CHECKING_ENABLED', function (value) {
    env.RECOIL_DUPLICATE_ATOM_KEY_CHECKING_ENABLED = value;
  });
  readProcessEnvStringArrayFlag('RECOIL_GKS_ENABLED', function (value) {
    value.forEach(function (gk) {
      env.RECOIL_GKS_ENABLED.add(gk);
    });
  });
}
applyProcessEnvFlagOverrides();
var Recoil_RecoilEnv = env;
function Recoil_gkx_OSS(gk) {
  return Recoil_RecoilEnv.RECOIL_GKS_ENABLED.has(gk);
}
Recoil_gkx_OSS.setPass = function (gk) {
  Recoil_RecoilEnv.RECOIL_GKS_ENABLED.add(gk);
};
Recoil_gkx_OSS.setFail = function (gk) {
  Recoil_RecoilEnv.RECOIL_GKS_ENABLED.delete(gk);
};
Recoil_gkx_OSS.clear = function () {
  Recoil_RecoilEnv.RECOIL_GKS_ENABLED.clear();
};
var Recoil_gkx = Recoil_gkx_OSS; // @oss-only

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */

function recoverableViolation(message, _projectName) {
  var _ref2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
    error = _ref2.error;
  if (false) {}
  return null;
}
var recoverableViolation_1 = recoverableViolation;

// @oss-only

var Recoil_recoverableViolation = recoverableViolation_1;
var _createMutableSource, _useMutableSource, _useSyncExternalStore;
var createMutableSource =
// flowlint-next-line unclear-type:off
(_createMutableSource = _react_18_2_0_react.createMutableSource) !== null && _createMutableSource !== void 0 ? _createMutableSource : _react_18_2_0_react.unstable_createMutableSource;
var useMutableSource =
// flowlint-next-line unclear-type:off
(_useMutableSource = _react_18_2_0_react.useMutableSource) !== null && _useMutableSource !== void 0 ? _useMutableSource : _react_18_2_0_react.unstable_useMutableSource; // https://github.com/reactwg/react-18/discussions/86

var useSyncExternalStore =
// flowlint-next-line unclear-type:off
(_useSyncExternalStore = _react_18_2_0_react.useSyncExternalStore) !== null && _useSyncExternalStore !== void 0 ? _useSyncExternalStore :
// flowlint-next-line unclear-type:off
_react_18_2_0_react.unstable_useSyncExternalStore;
var ReactRendererVersionMismatchWarnOnce = false; // Check if the current renderer supports `useSyncExternalStore()`.
// Since React goes through a proxy dispatcher and the current renderer can
// change we can't simply check if `React.useSyncExternalStore()` is defined.

function currentRendererSupportsUseSyncExternalStore() {
  var _ReactCurrentDispatch;

  // $FlowFixMe[incompatible-use]
  var _react$__SECRET_INTER =
    /* $FlowFixMe[prop-missing] This workaround was approved as a safer mechanism
     * to detect if the current renderer supports useSyncExternalStore()
     * https://fb.workplace.com/groups/reactjs/posts/9558682330846963/ */
    _react_18_2_0_react.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
    ReactCurrentDispatcher = _react$__SECRET_INTER.ReactCurrentDispatcher,
    ReactCurrentOwner = _react$__SECRET_INTER.ReactCurrentOwner;
  var dispatcher = (_ReactCurrentDispatch = ReactCurrentDispatcher === null || ReactCurrentDispatcher === void 0 ? void 0 : ReactCurrentDispatcher.current) !== null && _ReactCurrentDispatch !== void 0 ? _ReactCurrentDispatch : ReactCurrentOwner.currentDispatcher;
  var isUseSyncExternalStoreSupported = dispatcher.useSyncExternalStore != null;
  if (useSyncExternalStore && !isUseSyncExternalStoreSupported && !ReactRendererVersionMismatchWarnOnce) {
    ReactRendererVersionMismatchWarnOnce = true;
    Recoil_recoverableViolation('A React renderer without React 18+ API support is being used with React 18+.');
  }
  return isUseSyncExternalStoreSupported;
}

/**
 * mode: The React API and approach to use for syncing state with React
 * early: Re-renders from Recoil updates occur:
 *    1) earlier
 *    2) in sync with React updates in the same batch
 *    3) before transaction observers instead of after.
 * concurrent: Is the current mode compatible with Concurrent Mode and useTransition()
 */
function reactMode() {
  // NOTE: This mode is currently broken with some Suspense cases
  // see Recoil_selector-test.js
  if (Recoil_gkx('recoil_transition_support')) {
    return {
      mode: 'TRANSITION_SUPPORT',
      early: true,
      concurrent: true
    };
  }
  if (Recoil_gkx('recoil_sync_external_store') && useSyncExternalStore != null) {
    return {
      mode: 'SYNC_EXTERNAL_STORE',
      early: true,
      concurrent: false
    };
  }
  if (Recoil_gkx('recoil_mutable_source') && useMutableSource != null && typeof window !== 'undefined' && !window.$disableRecoilValueMutableSource_TEMP_HACK_DO_NOT_USE) {
    return Recoil_gkx('recoil_suppress_rerender_in_callback') ? {
      mode: 'MUTABLE_SOURCE',
      early: true,
      concurrent: true
    } : {
      mode: 'MUTABLE_SOURCE',
      early: false,
      concurrent: false
    };
  }
  return Recoil_gkx('recoil_suppress_rerender_in_callback') ? {
    mode: 'LEGACY',
    early: true,
    concurrent: false
  } : {
    mode: 'LEGACY',
    early: false,
    concurrent: false
  };
} // TODO Need to figure out if there is a standard/open-source equivalent to see if hot module replacement is happening:

function isFastRefreshEnabled() {
  // @fb-only: const {isAcceptingUpdate} = require('__debug');
  // @fb-only: return typeof isAcceptingUpdate === 'function' && isAcceptingUpdate();
  return false; // @oss-only
}

var Recoil_ReactMode = {
  createMutableSource: createMutableSource,
  useMutableSource: useMutableSource,
  useSyncExternalStore: useSyncExternalStore,
  currentRendererSupportsUseSyncExternalStore: currentRendererSupportsUseSyncExternalStore,
  reactMode: reactMode,
  isFastRefreshEnabled: isFastRefreshEnabled
};

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */

// eslint-disable-next-line no-unused-vars
var AbstractRecoilValue = /*#__PURE__*/function () {
  function AbstractRecoilValue(newKey) {
    _classCallCheck(this, AbstractRecoilValue);
    es_defineProperty(this, "key", void 0);
    this.key = newKey;
  }
  _createClass(AbstractRecoilValue, [{
    key: "toJSON",
    value: function toJSON() {
      return {
        key: this.key
      };
    }
  }]);
  return AbstractRecoilValue;
}();
var RecoilState = /*#__PURE__*/function (_AbstractRecoilValue) {
  _inherits(RecoilState, _AbstractRecoilValue);
  var _super4 = _createSuper(RecoilState);
  function RecoilState() {
    _classCallCheck(this, RecoilState);
    return _super4.apply(this, arguments);
  }
  return _createClass(RecoilState);
}(AbstractRecoilValue);
var RecoilValueReadOnly = /*#__PURE__*/function (_AbstractRecoilValue2) {
  _inherits(RecoilValueReadOnly, _AbstractRecoilValue2);
  var _super5 = _createSuper(RecoilValueReadOnly);
  function RecoilValueReadOnly() {
    _classCallCheck(this, RecoilValueReadOnly);
    return _super5.apply(this, arguments);
  }
  return _createClass(RecoilValueReadOnly);
}(AbstractRecoilValue);
function isRecoilValue(x) {
  return x instanceof RecoilState || x instanceof RecoilValueReadOnly;
}
var Recoil_RecoilValue = {
  AbstractRecoilValue: AbstractRecoilValue,
  RecoilState: RecoilState,
  RecoilValueReadOnly: RecoilValueReadOnly,
  isRecoilValue: isRecoilValue
};
var Recoil_RecoilValue_1 = Recoil_RecoilValue.AbstractRecoilValue;
var Recoil_RecoilValue_2 = Recoil_RecoilValue.RecoilState;
var Recoil_RecoilValue_3 = Recoil_RecoilValue.RecoilValueReadOnly;
var Recoil_RecoilValue_4 = Recoil_RecoilValue.isRecoilValue;
var Recoil_RecoilValue$1 = /*#__PURE__*/Object.freeze({
  __proto__: null,
  AbstractRecoilValue: Recoil_RecoilValue_1,
  RecoilState: Recoil_RecoilValue_2,
  RecoilValueReadOnly: Recoil_RecoilValue_3,
  isRecoilValue: Recoil_RecoilValue_4
});

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */

function sprintf(format) {
  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    args[_key - 1] = arguments[_key];
  }
  var index = 0;
  return format.replace(/%s/g, function () {
    return String(args[index++]);
  });
}
var sprintf_1 = (/* unused pure expression or super */ null && (sprintf));
function expectationViolation(format) {
  if (false) { var error, message, _len2, args, _key2; }
}
var expectationViolation_1 = expectationViolation;

// @oss-only

var Recoil_expectationViolation = expectationViolation_1;

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
/**
 * Creates a new iterable whose output is generated by passing the input
 * iterable's values through the mapper function.
 */

function mapIterable(iterable, callback) {
  // Use generator to create iterable/iterator
  return /*#__PURE__*/regeneratorRuntime_regeneratorRuntime().mark(function _callee() {
    var index, _iterator, _step, value;
    return regeneratorRuntime_regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          index = 0;
          _iterator = _createForOfIteratorHelper(iterable);
          _context.prev = 2;
          _iterator.s();
        case 4:
          if ((_step = _iterator.n()).done) {
            _context.next = 10;
            break;
          }
          value = _step.value;
          _context.next = 8;
          return callback(value, index++);
        case 8:
          _context.next = 4;
          break;
        case 10:
          _context.next = 15;
          break;
        case 12:
          _context.prev = 12;
          _context.t0 = _context["catch"](2);
          _iterator.e(_context.t0);
        case 15:
          _context.prev = 15;
          _iterator.f();
          return _context.finish(15);
        case 18:
        case "end":
          return _context.stop();
      }
    }, _callee, null, [[2, 12, 15, 18]]);
  })();
}
var Recoil_mapIterable = mapIterable;
var isFastRefreshEnabled$1 = Recoil_ReactMode.isFastRefreshEnabled;
var DefaultValue = /*#__PURE__*/_createClass(function DefaultValue() {
  _classCallCheck(this, DefaultValue);
});
var DEFAULT_VALUE = new DefaultValue();
// flowlint-next-line unclear-type:off
var nodes = new Map(); // flowlint-next-line unclear-type:off

var recoilValues = new Map();
/* eslint-disable no-redeclare */

function recoilValuesForKeys(keys) {
  return Recoil_mapIterable(keys, function (key) {
    return Recoil_nullthrows(recoilValues.get(key));
  });
}
function checkForDuplicateAtomKey(key) {
  if (nodes.has(key)) {
    var message = "Duplicate atom key \"".concat(key, "\". This is a FATAL ERROR in\n      production. But it is safe to ignore this warning if it occurred because of\n      hot module replacement.");
    if (false) {} else {
      // @fb-only: recoverableViolation(message, 'recoil');
      console.warn(message); // @oss-only
    }
  }
}

function registerNode(node) {
  if (Recoil_RecoilEnv.RECOIL_DUPLICATE_ATOM_KEY_CHECKING_ENABLED) {
    checkForDuplicateAtomKey(node.key);
  }
  nodes.set(node.key, node);
  var recoilValue = node.set == null ? new Recoil_RecoilValue$1.RecoilValueReadOnly(node.key) : new Recoil_RecoilValue$1.RecoilState(node.key);
  recoilValues.set(node.key, recoilValue);
  return recoilValue;
}
/* eslint-enable no-redeclare */
var NodeMissingError = /*#__PURE__*/function (_Error) {
  _inherits(NodeMissingError, _Error);
  var _super6 = _createSuper(NodeMissingError);
  function NodeMissingError() {
    _classCallCheck(this, NodeMissingError);
    return _super6.apply(this, arguments);
  }
  return _createClass(NodeMissingError);
}( /*#__PURE__*/wrapNativeSuper_wrapNativeSuper(Error)); // flowlint-next-line unclear-type:off
function getNode(key) {
  var node = nodes.get(key);
  if (node == null) {
    throw new NodeMissingError("Missing definition for RecoilValue: \"".concat(key, "\"\""));
  }
  return node;
} // flowlint-next-line unclear-type:off

function getNodeMaybe(key) {
  return nodes.get(key);
}
var configDeletionHandlers = new Map();
function deleteNodeConfigIfPossible(key) {
  var _node$shouldDeleteCon;
  if (!Recoil_gkx('recoil_memory_managament_2020')) {
    return;
  }
  var node = nodes.get(key);
  if (node !== null && node !== void 0 && (_node$shouldDeleteCon = node.shouldDeleteConfigOnRelease) !== null && _node$shouldDeleteCon !== void 0 && _node$shouldDeleteCon.call(node)) {
    var _getConfigDeletionHan;
    nodes.delete(key);
    (_getConfigDeletionHan = getConfigDeletionHandler(key)) === null || _getConfigDeletionHan === void 0 ? void 0 : _getConfigDeletionHan();
    configDeletionHandlers.delete(key);
  }
}
function setConfigDeletionHandler(key, fn) {
  if (!Recoil_gkx('recoil_memory_managament_2020')) {
    return;
  }
  if (fn === undefined) {
    configDeletionHandlers.delete(key);
  } else {
    configDeletionHandlers.set(key, fn);
  }
}
function getConfigDeletionHandler(key) {
  return configDeletionHandlers.get(key);
}
var Recoil_Node = {
  nodes: nodes,
  recoilValues: recoilValues,
  registerNode: registerNode,
  getNode: getNode,
  getNodeMaybe: getNodeMaybe,
  deleteNodeConfigIfPossible: deleteNodeConfigIfPossible,
  setConfigDeletionHandler: setConfigDeletionHandler,
  getConfigDeletionHandler: getConfigDeletionHandler,
  recoilValuesForKeys: recoilValuesForKeys,
  NodeMissingError: NodeMissingError,
  DefaultValue: DefaultValue,
  DEFAULT_VALUE: DEFAULT_VALUE
};

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */

function enqueueExecution(s, f) {
  f();
}
var Recoil_Queue = {
  enqueueExecution: enqueueExecution
};
function createCommonjsModule(fn, module) {
  return module = {
    exports: {}
  }, fn(module, module.exports), module.exports;
}
var hamt_1 = createCommonjsModule(function (module) {
  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
    return typeof obj;
  } : function (obj) {
    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
  };
  /**
      @fileOverview Hash Array Mapped Trie.
  
      Code based on: https://github.com/exclipy/pdata
  */

  var hamt = {}; // export

  /* Configuration
   ******************************************************************************/

  var SIZE = 5;
  var BUCKET_SIZE = Math.pow(2, SIZE);
  var MASK = BUCKET_SIZE - 1;
  var MAX_INDEX_NODE = BUCKET_SIZE / 2;
  var MIN_ARRAY_NODE = BUCKET_SIZE / 4;
  /*
   ******************************************************************************/

  var nothing = {};
  var constant = function constant(x) {
    return function () {
      return x;
    };
  };
  /**
      Get 32 bit hash of string.
  
      Based on:
      http://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript-jquery
  */

  var hash = hamt.hash = function (str) {
    var type = typeof str === 'undefined' ? 'undefined' : _typeof(str);
    if (type === 'number') return str;
    if (type !== 'string') str += '';
    var hash = 0;
    for (var i = 0, len = str.length; i < len; ++i) {
      var c = str.charCodeAt(i);
      hash = (hash << 5) - hash + c | 0;
    }
    return hash;
  };
  /* Bit Ops
   ******************************************************************************/

  /**
      Hamming weight.
  
      Taken from: http://jsperf.com/hamming-weight
  */

  var popcount = function popcount(x) {
    x -= x >> 1 & 0x55555555;
    x = (x & 0x33333333) + (x >> 2 & 0x33333333);
    x = x + (x >> 4) & 0x0f0f0f0f;
    x += x >> 8;
    x += x >> 16;
    return x & 0x7f;
  };
  var hashFragment = function hashFragment(shift, h) {
    return h >>> shift & MASK;
  };
  var toBitmap = function toBitmap(x) {
    return 1 << x;
  };
  var fromBitmap = function fromBitmap(bitmap, bit) {
    return popcount(bitmap & bit - 1);
  };
  /* Array Ops
   ******************************************************************************/

  /**
      Set a value in an array.
  
      @param mutate Should the input array be mutated?
      @param at Index to change.
      @param v New value
      @param arr Array.
  */

  var arrayUpdate = function arrayUpdate(mutate, at, v, arr) {
    var out = arr;
    if (!mutate) {
      var len = arr.length;
      out = new Array(len);
      for (var i = 0; i < len; ++i) {
        out[i] = arr[i];
      }
    }
    out[at] = v;
    return out;
  };
  /**
      Remove a value from an array.
  
      @param mutate Should the input array be mutated?
      @param at Index to remove.
      @param arr Array.
  */

  var arraySpliceOut = function arraySpliceOut(mutate, at, arr) {
    var newLen = arr.length - 1;
    var i = 0;
    var g = 0;
    var out = arr;
    if (mutate) {
      i = g = at;
    } else {
      out = new Array(newLen);
      while (i < at) {
        out[g++] = arr[i++];
      }
    }
    ++i;
    while (i <= newLen) {
      out[g++] = arr[i++];
    }
    if (mutate) {
      out.length = newLen;
    }
    return out;
  };
  /**
      Insert a value into an array.
  
      @param mutate Should the input array be mutated?
      @param at Index to insert at.
      @param v Value to insert,
      @param arr Array.
  */

  var arraySpliceIn = function arraySpliceIn(mutate, at, v, arr) {
    var len = arr.length;
    if (mutate) {
      var _i = len;
      while (_i >= at) {
        arr[_i--] = arr[_i];
      }
      arr[at] = v;
      return arr;
    }
    var i = 0,
      g = 0;
    var out = new Array(len + 1);
    while (i < at) {
      out[g++] = arr[i++];
    }
    out[at] = v;
    while (i < len) {
      out[++g] = arr[i++];
    }
    return out;
  };
  /* Node Structures
   ******************************************************************************/

  var LEAF = 1;
  var COLLISION = 2;
  var INDEX = 3;
  var ARRAY = 4;
  /**
      Empty node.
  */

  var empty = {
    __hamt_isEmpty: true
  };
  var isEmptyNode = function isEmptyNode(x) {
    return x === empty || x && x.__hamt_isEmpty;
  };
  /**
      Leaf holding a value.
  
      @member edit Edit of the node.
      @member hash Hash of key.
      @member key Key.
      @member value Value stored.
  */

  var Leaf = function Leaf(edit, hash, key, value) {
    return {
      type: LEAF,
      edit: edit,
      hash: hash,
      key: key,
      value: value,
      _modify: Leaf__modify
    };
  };
  /**
      Leaf holding multiple values with the same hash but different keys.
  
      @member edit Edit of the node.
      @member hash Hash of key.
      @member children Array of collision children node.
  */

  var Collision = function Collision(edit, hash, children) {
    return {
      type: COLLISION,
      edit: edit,
      hash: hash,
      children: children,
      _modify: Collision__modify
    };
  };
  /**
      Internal node with a sparse set of children.
  
      Uses a bitmap and array to pack children.
  
    @member edit Edit of the node.
      @member mask Bitmap that encode the positions of children in the array.
      @member children Array of child nodes.
  */

  var IndexedNode = function IndexedNode(edit, mask, children) {
    return {
      type: INDEX,
      edit: edit,
      mask: mask,
      children: children,
      _modify: IndexedNode__modify
    };
  };
  /**
      Internal node with many children.
  
      @member edit Edit of the node.
      @member size Number of children.
      @member children Array of child nodes.
  */

  var ArrayNode = function ArrayNode(edit, size, children) {
    return {
      type: ARRAY,
      edit: edit,
      size: size,
      children: children,
      _modify: ArrayNode__modify
    };
  };
  /**
      Is `node` a leaf node?
  */

  var isLeaf = function isLeaf(node) {
    return node === empty || node.type === LEAF || node.type === COLLISION;
  };
  /* Internal node operations.
   ******************************************************************************/

  /**
      Expand an indexed node into an array node.
  
    @param edit Current edit.
      @param frag Index of added child.
      @param child Added child.
      @param mask Index node mask before child added.
      @param subNodes Index node children before child added.
  */

  var expand = function expand(edit, frag, child, bitmap, subNodes) {
    var arr = [];
    var bit = bitmap;
    var count = 0;
    for (var i = 0; bit; ++i) {
      if (bit & 1) arr[i] = subNodes[count++];
      bit >>>= 1;
    }
    arr[frag] = child;
    return ArrayNode(edit, count + 1, arr);
  };
  /**
      Collapse an array node into a indexed node.
  
    @param edit Current edit.
      @param count Number of elements in new array.
      @param removed Index of removed element.
      @param elements Array node children before remove.
  */

  var pack = function pack(edit, count, removed, elements) {
    var children = new Array(count - 1);
    var g = 0;
    var bitmap = 0;
    for (var i = 0, len = elements.length; i < len; ++i) {
      if (i !== removed) {
        var elem = elements[i];
        if (elem && !isEmptyNode(elem)) {
          children[g++] = elem;
          bitmap |= 1 << i;
        }
      }
    }
    return IndexedNode(edit, bitmap, children);
  };
  /**
      Merge two leaf nodes.
  
      @param shift Current shift.
      @param h1 Node 1 hash.
      @param n1 Node 1.
      @param h2 Node 2 hash.
      @param n2 Node 2.
  */

  var mergeLeaves = function mergeLeaves(edit, shift, h1, n1, h2, n2) {
    if (h1 === h2) return Collision(edit, h1, [n2, n1]);
    var subH1 = hashFragment(shift, h1);
    var subH2 = hashFragment(shift, h2);
    return IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), subH1 === subH2 ? [mergeLeaves(edit, shift + SIZE, h1, n1, h2, n2)] : subH1 < subH2 ? [n1, n2] : [n2, n1]);
  };
  /**
      Update an entry in a collision list.
  
      @param mutate Should mutation be used?
      @param edit Current edit.
      @param keyEq Key compare function.
      @param hash Hash of collision.
      @param list Collision list.
      @param f Update function.
      @param k Key to update.
      @param size Size ref.
  */

  var updateCollisionList = function updateCollisionList(mutate, edit, keyEq, h, list, f, k, size) {
    var len = list.length;
    for (var i = 0; i < len; ++i) {
      var child = list[i];
      if (keyEq(k, child.key)) {
        var value = child.value;
        var _newValue = f(value);
        if (_newValue === value) return list;
        if (_newValue === nothing) {
          --size.value;
          return arraySpliceOut(mutate, i, list);
        }
        return arrayUpdate(mutate, i, Leaf(edit, h, k, _newValue), list);
      }
    }
    var newValue = f();
    if (newValue === nothing) return list;
    ++size.value;
    return arrayUpdate(mutate, len, Leaf(edit, h, k, newValue), list);
  };
  var canEditNode = function canEditNode(edit, node) {
    return edit === node.edit;
  };
  /* Editing
   ******************************************************************************/

  var Leaf__modify = function Leaf__modify(edit, keyEq, shift, f, h, k, size) {
    if (keyEq(k, this.key)) {
      var _v = f(this.value);
      if (_v === this.value) return this;else if (_v === nothing) {
        --size.value;
        return empty;
      }
      if (canEditNode(edit, this)) {
        this.value = _v;
        return this;
      }
      return Leaf(edit, h, k, _v);
    }
    var v = f();
    if (v === nothing) return this;
    ++size.value;
    return mergeLeaves(edit, shift, this.hash, this, h, Leaf(edit, h, k, v));
  };
  var Collision__modify = function Collision__modify(edit, keyEq, shift, f, h, k, size) {
    if (h === this.hash) {
      var canEdit = canEditNode(edit, this);
      var list = updateCollisionList(canEdit, edit, keyEq, this.hash, this.children, f, k, size);
      if (list === this.children) return this;
      return list.length > 1 ? Collision(edit, this.hash, list) : list[0]; // collapse single element collision list
    }

    var v = f();
    if (v === nothing) return this;
    ++size.value;
    return mergeLeaves(edit, shift, this.hash, this, h, Leaf(edit, h, k, v));
  };
  var IndexedNode__modify = function IndexedNode__modify(edit, keyEq, shift, f, h, k, size) {
    var mask = this.mask;
    var children = this.children;
    var frag = hashFragment(shift, h);
    var bit = toBitmap(frag);
    var indx = fromBitmap(mask, bit);
    var exists = mask & bit;
    var current = exists ? children[indx] : empty;
    var child = current._modify(edit, keyEq, shift + SIZE, f, h, k, size);
    if (current === child) return this;
    var canEdit = canEditNode(edit, this);
    var bitmap = mask;
    var newChildren = void 0;
    if (exists && isEmptyNode(child)) {
      // remove
      bitmap &= ~bit;
      if (!bitmap) return empty;
      if (children.length <= 2 && isLeaf(children[indx ^ 1])) return children[indx ^ 1]; // collapse

      newChildren = arraySpliceOut(canEdit, indx, children);
    } else if (!exists && !isEmptyNode(child)) {
      // add
      if (children.length >= MAX_INDEX_NODE) return expand(edit, frag, child, mask, children);
      bitmap |= bit;
      newChildren = arraySpliceIn(canEdit, indx, child, children);
    } else {
      // modify
      newChildren = arrayUpdate(canEdit, indx, child, children);
    }
    if (canEdit) {
      this.mask = bitmap;
      this.children = newChildren;
      return this;
    }
    return IndexedNode(edit, bitmap, newChildren);
  };
  var ArrayNode__modify = function ArrayNode__modify(edit, keyEq, shift, f, h, k, size) {
    var count = this.size;
    var children = this.children;
    var frag = hashFragment(shift, h);
    var child = children[frag];
    var newChild = (child || empty)._modify(edit, keyEq, shift + SIZE, f, h, k, size);
    if (child === newChild) return this;
    var canEdit = canEditNode(edit, this);
    var newChildren = void 0;
    if (isEmptyNode(child) && !isEmptyNode(newChild)) {
      // add
      ++count;
      newChildren = arrayUpdate(canEdit, frag, newChild, children);
    } else if (!isEmptyNode(child) && isEmptyNode(newChild)) {
      // remove
      --count;
      if (count <= MIN_ARRAY_NODE) return pack(edit, count, frag, children);
      newChildren = arrayUpdate(canEdit, frag, empty, children);
    } else {
      // modify
      newChildren = arrayUpdate(canEdit, frag, newChild, children);
    }
    if (canEdit) {
      this.size = count;
      this.children = newChildren;
      return this;
    }
    return ArrayNode(edit, count, newChildren);
  };
  empty._modify = function (edit, keyEq, shift, f, h, k, size) {
    var v = f();
    if (v === nothing) return empty;
    ++size.value;
    return Leaf(edit, h, k, v);
  };
  /*
   ******************************************************************************/

  function Map(editable, edit, config, root, size) {
    this._editable = editable;
    this._edit = edit;
    this._config = config;
    this._root = root;
    this._size = size;
  }
  Map.prototype.setTree = function (newRoot, newSize) {
    if (this._editable) {
      this._root = newRoot;
      this._size = newSize;
      return this;
    }
    return newRoot === this._root ? this : new Map(this._editable, this._edit, this._config, newRoot, newSize);
  };
  /* Queries
   ******************************************************************************/

  /**
      Lookup the value for `key` in `map` using a custom `hash`.
  
      Returns the value or `alt` if none.
  */

  var tryGetHash = hamt.tryGetHash = function (alt, hash, key, map) {
    var node = map._root;
    var shift = 0;
    var keyEq = map._config.keyEq;
    while (true) {
      switch (node.type) {
        case LEAF:
          {
            return keyEq(key, node.key) ? node.value : alt;
          }
        case COLLISION:
          {
            if (hash === node.hash) {
              var children = node.children;
              for (var i = 0, len = children.length; i < len; ++i) {
                var child = children[i];
                if (keyEq(key, child.key)) return child.value;
              }
            }
            return alt;
          }
        case INDEX:
          {
            var frag = hashFragment(shift, hash);
            var bit = toBitmap(frag);
            if (node.mask & bit) {
              node = node.children[fromBitmap(node.mask, bit)];
              shift += SIZE;
              break;
            }
            return alt;
          }
        case ARRAY:
          {
            node = node.children[hashFragment(shift, hash)];
            if (node) {
              shift += SIZE;
              break;
            }
            return alt;
          }
        default:
          return alt;
      }
    }
  };
  Map.prototype.tryGetHash = function (alt, hash, key) {
    return tryGetHash(alt, hash, key, this);
  };
  /**
      Lookup the value for `key` in `map` using internal hash function.
  
      @see `tryGetHash`
  */

  var tryGet = hamt.tryGet = function (alt, key, map) {
    return tryGetHash(alt, map._config.hash(key), key, map);
  };
  Map.prototype.tryGet = function (alt, key) {
    return tryGet(alt, key, this);
  };
  /**
      Lookup the value for `key` in `map` using a custom `hash`.
  
      Returns the value or `undefined` if none.
  */

  var getHash = hamt.getHash = function (hash, key, map) {
    return tryGetHash(undefined, hash, key, map);
  };
  Map.prototype.getHash = function (hash, key) {
    return getHash(hash, key, this);
  };
  /**
      Lookup the value for `key` in `map` using internal hash function.
  
      @see `get`
  */

  var get = hamt.get = function (key, map) {
    return tryGetHash(undefined, map._config.hash(key), key, map);
  };
  Map.prototype.get = function (key, alt) {
    return tryGet(alt, key, this);
  };
  /**
      Does an entry exist for `key` in `map`? Uses custom `hash`.
  */

  var hasHash = hamt.has = function (hash, key, map) {
    return tryGetHash(nothing, hash, key, map) !== nothing;
  };
  Map.prototype.hasHash = function (hash, key) {
    return hasHash(hash, key, this);
  };
  /**
      Does an entry exist for `key` in `map`? Uses internal hash function.
  */

  var has = hamt.has = function (key, map) {
    return hasHash(map._config.hash(key), key, map);
  };
  Map.prototype.has = function (key) {
    return has(key, this);
  };
  var defKeyCompare = function defKeyCompare(x, y) {
    return x === y;
  };
  /**
      Create an empty map.
  
      @param config Configuration.
  */

  hamt.make = function (config) {
    return new Map(0, 0, {
      keyEq: config && config.keyEq || defKeyCompare,
      hash: config && config.hash || hash
    }, empty, 0);
  };
  /**
      Empty map.
  */

  hamt.empty = hamt.make();
  /**
      Does `map` contain any elements?
  */

  var isEmpty = hamt.isEmpty = function (map) {
    return map && !!isEmptyNode(map._root);
  };
  Map.prototype.isEmpty = function () {
    return isEmpty(this);
  };
  /* Updates
   ******************************************************************************/

  /**
      Alter the value stored for `key` in `map` using function `f` using
      custom hash.
  
      `f` is invoked with the current value for `k` if it exists,
      or no arguments if no such value exists. `modify` will always either
      update or insert a value into the map.
  
      Returns a map with the modified value. Does not alter `map`.
  */

  var modifyHash = hamt.modifyHash = function (f, hash, key, map) {
    var size = {
      value: map._size
    };
    var newRoot = map._root._modify(map._editable ? map._edit : NaN, map._config.keyEq, 0, f, hash, key, size);
    return map.setTree(newRoot, size.value);
  };
  Map.prototype.modifyHash = function (hash, key, f) {
    return modifyHash(f, hash, key, this);
  };
  /**
      Alter the value stored for `key` in `map` using function `f` using
      internal hash function.
  
      @see `modifyHash`
  */

  var modify = hamt.modify = function (f, key, map) {
    return modifyHash(f, map._config.hash(key), key, map);
  };
  Map.prototype.modify = function (key, f) {
    return modify(f, key, this);
  };
  /**
      Store `value` for `key` in `map` using custom `hash`.
  
      Returns a map with the modified value. Does not alter `map`.
  */

  var setHash = hamt.setHash = function (hash, key, value, map) {
    return modifyHash(constant(value), hash, key, map);
  };
  Map.prototype.setHash = function (hash, key, value) {
    return setHash(hash, key, value, this);
  };
  /**
      Store `value` for `key` in `map` using internal hash function.
  
      @see `setHash`
  */

  var set = hamt.set = function (key, value, map) {
    return setHash(map._config.hash(key), key, value, map);
  };
  Map.prototype.set = function (key, value) {
    return set(key, value, this);
  };
  /**
      Remove the entry for `key` in `map`.
  
      Returns a map with the value removed. Does not alter `map`.
  */

  var del = constant(nothing);
  var removeHash = hamt.removeHash = function (hash, key, map) {
    return modifyHash(del, hash, key, map);
  };
  Map.prototype.removeHash = Map.prototype.deleteHash = function (hash, key) {
    return removeHash(hash, key, this);
  };
  /**
      Remove the entry for `key` in `map` using internal hash function.
  
      @see `removeHash`
  */

  var remove = hamt.remove = function (key, map) {
    return removeHash(map._config.hash(key), key, map);
  };
  Map.prototype.remove = Map.prototype.delete = function (key) {
    return remove(key, this);
  };
  /* Mutation
   ******************************************************************************/

  /**
      Mark `map` as mutable.
   */

  var beginMutation = hamt.beginMutation = function (map) {
    return new Map(map._editable + 1, map._edit + 1, map._config, map._root, map._size);
  };
  Map.prototype.beginMutation = function () {
    return beginMutation(this);
  };
  /**
      Mark `map` as immutable.
   */

  var endMutation = hamt.endMutation = function (map) {
    map._editable = map._editable && map._editable - 1;
    return map;
  };
  Map.prototype.endMutation = function () {
    return endMutation(this);
  };
  /**
      Mutate `map` within the context of `f`.
      @param f
      @param map HAMT
  */

  var mutate = hamt.mutate = function (f, map) {
    var transient = beginMutation(map);
    f(transient);
    return endMutation(transient);
  };
  Map.prototype.mutate = function (f) {
    return mutate(f, this);
  };
  /* Traversal
   ******************************************************************************/

  /**
      Apply a continuation.
  */

  var appk = function appk(k) {
    return k && lazyVisitChildren(k[0], k[1], k[2], k[3], k[4]);
  };
  /**
      Recursively visit all values stored in an array of nodes lazily.
  */

  var lazyVisitChildren = function lazyVisitChildren(len, children, i, f, k) {
    while (i < len) {
      var child = children[i++];
      if (child && !isEmptyNode(child)) return lazyVisit(child, f, [len, children, i, f, k]);
    }
    return appk(k);
  };
  /**
      Recursively visit all values stored in `node` lazily.
  */

  var lazyVisit = function lazyVisit(node, f, k) {
    switch (node.type) {
      case LEAF:
        return {
          value: f(node),
          rest: k
        };
      case COLLISION:
      case ARRAY:
      case INDEX:
        var children = node.children;
        return lazyVisitChildren(children.length, children, 0, f, k);
      default:
        return appk(k);
    }
  };
  var DONE = {
    done: true
  };
  /**
      Javascript iterator over a map.
  */

  function MapIterator(v) {
    this.v = v;
  }
  MapIterator.prototype.next = function () {
    if (!this.v) return DONE;
    var v0 = this.v;
    this.v = appk(v0.rest);
    return v0;
  };
  MapIterator.prototype[Symbol.iterator] = function () {
    return this;
  };
  /**
      Lazily visit each value in map with function `f`.
  */

  var visit = function visit(map, f) {
    return new MapIterator(lazyVisit(map._root, f));
  };
  /**
      Get a Javascsript iterator of `map`.
  
      Iterates over `[key, value]` arrays.
  */

  var buildPairs = function buildPairs(x) {
    return [x.key, x.value];
  };
  var entries = hamt.entries = function (map) {
    return visit(map, buildPairs);
  };
  Map.prototype.entries = Map.prototype[Symbol.iterator] = function () {
    return entries(this);
  };
  /**
      Get array of all keys in `map`.
  
      Order is not guaranteed.
  */

  var buildKeys = function buildKeys(x) {
    return x.key;
  };
  var keys = hamt.keys = function (map) {
    return visit(map, buildKeys);
  };
  Map.prototype.keys = function () {
    return keys(this);
  };
  /**
      Get array of all values in `map`.
  
      Order is not guaranteed, duplicates are preserved.
  */

  var buildValues = function buildValues(x) {
    return x.value;
  };
  var values = hamt.values = Map.prototype.values = function (map) {
    return visit(map, buildValues);
  };
  Map.prototype.values = function () {
    return values(this);
  };
  /* Fold
   ******************************************************************************/

  /**
      Visit every entry in the map, aggregating data.
  
      Order of nodes is not guaranteed.
  
      @param f Function mapping accumulated value, value, and key to new value.
      @param z Starting value.
      @param m HAMT
  */

  var fold = hamt.fold = function (f, z, m) {
    var root = m._root;
    if (root.type === LEAF) return f(z, root.value, root.key);
    var toVisit = [root.children];
    var children = void 0;
    while (children = toVisit.pop()) {
      for (var i = 0, len = children.length; i < len;) {
        var child = children[i++];
        if (child && child.type) {
          if (child.type === LEAF) z = f(z, child.value, child.key);else toVisit.push(child.children);
        }
      }
    }
    return z;
  };
  Map.prototype.fold = function (f, z) {
    return fold(f, z, this);
  };
  /**
      Visit every entry in the map, aggregating data.
  
      Order of nodes is not guaranteed.
  
      @param f Function invoked with value and key
      @param map HAMT
  */

  var forEach = hamt.forEach = function (f, map) {
    return fold(function (_, value, key) {
      return f(value, key, map);
    }, null, map);
  };
  Map.prototype.forEach = function (f) {
    return forEach(f, this);
  };
  /* Aggregate
   ******************************************************************************/

  /**
      Get the number of entries in `map`.
  */

  var count = hamt.count = function (map) {
    return map._size;
  };
  Map.prototype.count = function () {
    return count(this);
  };
  Object.defineProperty(Map.prototype, 'size', {
    get: Map.prototype.count
  });
  /* Export
   ******************************************************************************/

  if (module.exports) {
    module.exports = hamt;
  } else {
    undefined.hamt = hamt;
  }
});
var BuiltInMap = /*#__PURE__*/function () {
  function BuiltInMap(existing) {
    _classCallCheck(this, BuiltInMap);
    es_defineProperty(this, "_map", void 0);
    this._map = new Map(existing === null || existing === void 0 ? void 0 : existing.entries());
  }
  _createClass(BuiltInMap, [{
    key: "keys",
    value: function keys() {
      return this._map.keys();
    }
  }, {
    key: "entries",
    value: function entries() {
      return this._map.entries();
    }
  }, {
    key: "get",
    value: function get(k) {
      return this._map.get(k);
    }
  }, {
    key: "has",
    value: function has(k) {
      return this._map.has(k);
    }
  }, {
    key: "set",
    value: function set(k, v) {
      this._map.set(k, v);
      return this;
    }
  }, {
    key: "delete",
    value: function _delete(k) {
      this._map.delete(k);
      return this;
    }
  }, {
    key: "clone",
    value: function clone() {
      return persistentMap(this);
    }
  }, {
    key: "toMap",
    value: function toMap() {
      return new Map(this._map);
    }
  }]);
  return BuiltInMap;
}();
var HashArrayMappedTrieMap = /*#__PURE__*/function () {
  // Because hamt.empty is not a function there is no way to introduce type
  // parameters on it, so empty is typed as HAMTPlusMap<string, mixed>.
  // $FlowIssue
  function HashArrayMappedTrieMap(existing) {
    _classCallCheck(this, HashArrayMappedTrieMap);
    es_defineProperty(this, "_hamt", hamt_1.empty.beginMutation());
    if (existing instanceof HashArrayMappedTrieMap) {
      var h = existing._hamt.endMutation();
      existing._hamt = h.beginMutation();
      this._hamt = h.beginMutation();
    } else if (existing) {
      var _iterator2 = _createForOfIteratorHelper(existing.entries()),
        _step2;
      try {
        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
          var _step2$value = slicedToArray_slicedToArray(_step2.value, 2),
            k = _step2$value[0],
            v = _step2$value[1];
          this._hamt.set(k, v);
        }
      } catch (err) {
        _iterator2.e(err);
      } finally {
        _iterator2.f();
      }
    }
  }
  _createClass(HashArrayMappedTrieMap, [{
    key: "keys",
    value: function keys() {
      return this._hamt.keys();
    }
  }, {
    key: "entries",
    value: function entries() {
      return this._hamt.entries();
    }
  }, {
    key: "get",
    value: function get(k) {
      return this._hamt.get(k);
    }
  }, {
    key: "has",
    value: function has(k) {
      return this._hamt.has(k);
    }
  }, {
    key: "set",
    value: function set(k, v) {
      this._hamt.set(k, v);
      return this;
    }
  }, {
    key: "delete",
    value: function _delete(k) {
      this._hamt.delete(k);
      return this;
    }
  }, {
    key: "clone",
    value: function clone() {
      return persistentMap(this);
    }
  }, {
    key: "toMap",
    value: function toMap() {
      return new Map(this._hamt);
    }
  }]);
  return HashArrayMappedTrieMap;
}();
function persistentMap(existing) {
  if (Recoil_gkx('recoil_hamt_2020')) {
    return new HashArrayMappedTrieMap(existing);
  } else {
    return new BuiltInMap(existing);
  }
}
var Recoil_PersistentMap = {
  persistentMap: persistentMap
};
var Recoil_PersistentMap_1 = Recoil_PersistentMap.persistentMap;
var Recoil_PersistentMap$1 = /*#__PURE__*/Object.freeze({
  __proto__: null,
  persistentMap: Recoil_PersistentMap_1
});

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
/**
 * Returns a set containing all of the values from the first set that are not
 * present in any of the subsequent sets.
 *
 * Note: this is written procedurally (i.e., without filterSet) for performant
 * use in tight loops.
 */

function differenceSets(set) {
  var ret = new Set();
  for (var _len3 = arguments.length, setsWithValuesToRemove = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
    setsWithValuesToRemove[_key3 - 1] = arguments[_key3];
  }
  var _iterator3 = _createForOfIteratorHelper(set),
    _step3;
  try {
    FIRST: for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
      var value = _step3.value;
      var _iterator4 = _createForOfIteratorHelper(setsWithValuesToRemove),
        _step4;
      try {
        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
          var otherSet = _step4.value;
          if (otherSet.has(value)) {
            continue FIRST;
          }
        }
      } catch (err) {
        _iterator4.e(err);
      } finally {
        _iterator4.f();
      }
      ret.add(value);
    }
  } catch (err) {
    _iterator3.e(err);
  } finally {
    _iterator3.f();
  }
  return ret;
}
var Recoil_differenceSets = differenceSets;

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
/**
 * Returns a new Map object with the same keys as the original, but with the
 * values replaced with the output of the given callback function.
 */

function mapMap(map, callback) {
  var result = new Map();
  map.forEach(function (value, key) {
    result.set(key, callback(value, key));
  });
  return result;
}
var Recoil_mapMap = mapMap;
function makeGraph() {
  return {
    nodeDeps: new Map(),
    nodeToNodeSubscriptions: new Map()
  };
}
function cloneGraph(graph) {
  return {
    nodeDeps: Recoil_mapMap(graph.nodeDeps, function (s) {
      return new Set(s);
    }),
    nodeToNodeSubscriptions: Recoil_mapMap(graph.nodeToNodeSubscriptions, function (s) {
      return new Set(s);
    })
  };
} // Note that this overwrites the deps of existing nodes, rather than unioning
// the new deps with the old deps.

function mergeDepsIntoGraph(key, newDeps, graph,
// If olderGraph is given then we will not overwrite changes made to the given
// graph compared with olderGraph:
olderGraph) {
  var nodeDeps = graph.nodeDeps,
    nodeToNodeSubscriptions = graph.nodeToNodeSubscriptions;
  var oldDeps = nodeDeps.get(key);
  if (oldDeps && olderGraph && oldDeps !== olderGraph.nodeDeps.get(key)) {
    return;
  } // Update nodeDeps:

  nodeDeps.set(key, newDeps); // Add new deps to nodeToNodeSubscriptions:

  var addedDeps = oldDeps == null ? newDeps : Recoil_differenceSets(newDeps, oldDeps);
  var _iterator5 = _createForOfIteratorHelper(addedDeps),
    _step5;
  try {
    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
      var _dep = _step5.value;
      if (!nodeToNodeSubscriptions.has(_dep)) {
        nodeToNodeSubscriptions.set(_dep, new Set());
      }
      var _existing = Recoil_nullthrows(nodeToNodeSubscriptions.get(_dep));
      _existing.add(key);
    } // Remove removed deps from nodeToNodeSubscriptions:
  } catch (err) {
    _iterator5.e(err);
  } finally {
    _iterator5.f();
  }
  if (oldDeps) {
    var removedDeps = Recoil_differenceSets(oldDeps, newDeps);
    var _iterator6 = _createForOfIteratorHelper(removedDeps),
      _step6;
    try {
      for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
        var dep = _step6.value;
        if (!nodeToNodeSubscriptions.has(dep)) {
          return;
        }
        var existing = Recoil_nullthrows(nodeToNodeSubscriptions.get(dep));
        existing.delete(key);
        if (existing.size === 0) {
          nodeToNodeSubscriptions.delete(dep);
        }
      }
    } catch (err) {
      _iterator6.e(err);
    } finally {
      _iterator6.f();
    }
  }
}
function saveDepsToStore(key, deps, store, version) {
  var _storeState$nextTree, _storeState$previousT, _storeState$previousT2, _storeState$previousT3;
  var storeState = store.getState();
  if (!(version === storeState.currentTree.version || version === ((_storeState$nextTree = storeState.nextTree) === null || _storeState$nextTree === void 0 ? void 0 : _storeState$nextTree.version) || version === ((_storeState$previousT = storeState.previousTree) === null || _storeState$previousT === void 0 ? void 0 : _storeState$previousT.version))) {
    Recoil_recoverableViolation('Tried to save dependencies to a discarded tree');
  } // Merge the dependencies discovered into the store's dependency map
  // for the version that was read:

  var graph = store.getGraph(version);
  mergeDepsIntoGraph(key, deps, graph); // If this version is not the latest version, also write these dependencies
  // into later versions if they don't already have their own:

  if (version === ((_storeState$previousT2 = storeState.previousTree) === null || _storeState$previousT2 === void 0 ? void 0 : _storeState$previousT2.version)) {
    var currentGraph = store.getGraph(storeState.currentTree.version);
    mergeDepsIntoGraph(key, deps, currentGraph, graph);
  }
  if (version === ((_storeState$previousT3 = storeState.previousTree) === null || _storeState$previousT3 === void 0 ? void 0 : _storeState$previousT3.version) || version === storeState.currentTree.version) {
    var _storeState$nextTree2;
    var nextVersion = (_storeState$nextTree2 = storeState.nextTree) === null || _storeState$nextTree2 === void 0 ? void 0 : _storeState$nextTree2.version;
    if (nextVersion !== undefined) {
      var nextGraph = store.getGraph(nextVersion);
      mergeDepsIntoGraph(key, deps, nextGraph, graph);
    }
  }
}
var Recoil_Graph = {
  cloneGraph: cloneGraph,
  graph: makeGraph,
  saveDepsToStore: saveDepsToStore
};

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */

var nextTreeStateVersion = 0;
var getNextTreeStateVersion = function getNextTreeStateVersion() {
  return nextTreeStateVersion++;
};
var nextStoreID = 0;
var getNextStoreID = function getNextStoreID() {
  return nextStoreID++;
};
var nextComponentID = 0;
var getNextComponentID = function getNextComponentID() {
  return nextComponentID++;
};
var Recoil_Keys = {
  getNextTreeStateVersion: getNextTreeStateVersion,
  getNextStoreID: getNextStoreID,
  getNextComponentID: getNextComponentID
};
var persistentMap$1 = Recoil_PersistentMap$1.persistentMap;
var graph = Recoil_Graph.graph;
var getNextTreeStateVersion$1 = Recoil_Keys.getNextTreeStateVersion;
function makeEmptyTreeState() {
  var version = getNextTreeStateVersion$1();
  return {
    version: version,
    stateID: version,
    transactionMetadata: {},
    dirtyAtoms: new Set(),
    atomValues: persistentMap$1(),
    nonvalidatedAtoms: persistentMap$1()
  };
}
function makeEmptyStoreState() {
  var currentTree = makeEmptyTreeState();
  return {
    currentTree: currentTree,
    nextTree: null,
    previousTree: null,
    commitDepth: 0,
    knownAtoms: new Set(),
    knownSelectors: new Set(),
    transactionSubscriptions: new Map(),
    nodeTransactionSubscriptions: new Map(),
    nodeToComponentSubscriptions: new Map(),
    queuedComponentCallbacks_DEPRECATED: [],
    suspendedComponentResolvers: new Set(),
    graphsByVersion: new Map().set(currentTree.version, graph()),
    retention: {
      referenceCounts: new Map(),
      nodesRetainedByZone: new Map(),
      retainablesToCheckForRelease: new Set()
    },
    nodeCleanupFunctions: new Map()
  };
}
var Recoil_State = {
  makeEmptyTreeState: makeEmptyTreeState,
  makeEmptyStoreState: makeEmptyStoreState,
  getNextTreeStateVersion: getNextTreeStateVersion$1
};

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
var RetentionZone = /*#__PURE__*/_createClass(function RetentionZone() {
  _classCallCheck(this, RetentionZone);
});
function retentionZone() {
  return new RetentionZone();
}
var Recoil_RetentionZone = {
  RetentionZone: RetentionZone,
  retentionZone: retentionZone
};

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * Utilities for working with built-in Maps and Sets without mutating them.
 *
 * 
 * @format
 * @oncall recoil
 */

function setByAddingToSet(set, v) {
  var next = new Set(set);
  next.add(v);
  return next;
}
function setByDeletingFromSet(set, v) {
  var next = new Set(set);
  next.delete(v);
  return next;
}
function mapBySettingInMap(map, k, v) {
  var next = new Map(map);
  next.set(k, v);
  return next;
}
function mapByUpdatingInMap(map, k, updater) {
  var next = new Map(map);
  next.set(k, updater(next.get(k)));
  return next;
}
function mapByDeletingFromMap(map, k) {
  var next = new Map(map);
  next.delete(k);
  return next;
}
function mapByDeletingMultipleFromMap(map, ks) {
  var next = new Map(map);
  ks.forEach(function (k) {
    return next.delete(k);
  });
  return next;
}
var Recoil_CopyOnWrite = {
  setByAddingToSet: setByAddingToSet,
  setByDeletingFromSet: setByDeletingFromSet,
  mapBySettingInMap: mapBySettingInMap,
  mapByUpdatingInMap: mapByUpdatingInMap,
  mapByDeletingFromMap: mapByDeletingFromMap,
  mapByDeletingMultipleFromMap: mapByDeletingMultipleFromMap
};

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
/**
 * Creates a new iterable whose output is generated by passing the input
 * iterable's values through the filter function.
 */

function filterIterable(iterable, predicate) {
  var index, _iterator7, _step7, value;
  return regeneratorRuntime_regeneratorRuntime().wrap(function filterIterable$(_context2) {
    while (1) switch (_context2.prev = _context2.next) {
      case 0:
        // Use generator to create iterable/iterator
        index = 0;
        _iterator7 = _createForOfIteratorHelper(iterable);
        _context2.prev = 2;
        _iterator7.s();
      case 4:
        if ((_step7 = _iterator7.n()).done) {
          _context2.next = 11;
          break;
        }
        value = _step7.value;
        if (!predicate(value, index++)) {
          _context2.next = 9;
          break;
        }
        _context2.next = 9;
        return value;
      case 9:
        _context2.next = 4;
        break;
      case 11:
        _context2.next = 16;
        break;
      case 13:
        _context2.prev = 13;
        _context2.t0 = _context2["catch"](2);
        _iterator7.e(_context2.t0);
      case 16:
        _context2.prev = 16;
        _iterator7.f();
        return _context2.finish(16);
      case 19:
      case "end":
        return _context2.stop();
    }
  }, _marked, null, [[2, 13, 16, 19]]);
}
var Recoil_filterIterable = filterIterable;

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
/**
 * Return a proxy object based on the provided base and factories objects.
 * The proxy will include all properties of the base object as-is.
 * The factories object contains callbacks to obtain the values of the properies
 * for its keys.
 *
 * This is useful for providing users an object where some properties may be
 * lazily computed only on first access.
 */
// $FlowIssue[unclear-type]

function lazyProxy(base, factories) {
  var proxy = new Proxy(base, {
    // Compute and cache lazy property if not already done.
    get: function get(target, prop) {
      if (!(prop in target) && prop in factories) {
        target[prop] = factories[prop]();
      }
      return target[prop];
    },
    // This method allows user to iterate keys as normal
    ownKeys: function ownKeys(target) {
      return Object.keys(target);
    }
  }); // $FlowIssue[incompatible-return]

  return proxy;
}
var Recoil_lazyProxy = lazyProxy;
var getNode$1 = Recoil_Node.getNode,
  getNodeMaybe$1 = Recoil_Node.getNodeMaybe,
  recoilValuesForKeys$1 = Recoil_Node.recoilValuesForKeys;
var RetentionZone$1 = Recoil_RetentionZone.RetentionZone;
var setByAddingToSet$1 = Recoil_CopyOnWrite.setByAddingToSet;

// flowlint-next-line unclear-type:off

var emptySet = Object.freeze(new Set());
var ReadOnlyRecoilValueError = /*#__PURE__*/function (_Error2) {
  _inherits(ReadOnlyRecoilValueError, _Error2);
  var _super7 = _createSuper(ReadOnlyRecoilValueError);
  function ReadOnlyRecoilValueError() {
    _classCallCheck(this, ReadOnlyRecoilValueError);
    return _super7.apply(this, arguments);
  }
  return _createClass(ReadOnlyRecoilValueError);
}( /*#__PURE__*/wrapNativeSuper_wrapNativeSuper(Error));
function initializeRetentionForNode(store, nodeKey, retainedBy) {
  if (!Recoil_gkx('recoil_memory_managament_2020')) {
    return function () {
      return undefined;
    };
  }
  var nodesRetainedByZone = store.getState().retention.nodesRetainedByZone;
  function addToZone(zone) {
    var set = nodesRetainedByZone.get(zone);
    if (!set) {
      nodesRetainedByZone.set(zone, set = new Set());
    }
    set.add(nodeKey);
  }
  if (retainedBy instanceof RetentionZone$1) {
    addToZone(retainedBy);
  } else if (Array.isArray(retainedBy)) {
    var _iterator8 = _createForOfIteratorHelper(retainedBy),
      _step8;
    try {
      for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
        var zone = _step8.value;
        addToZone(zone);
      }
    } catch (err) {
      _iterator8.e(err);
    } finally {
      _iterator8.f();
    }
  }
  return function () {
    if (!Recoil_gkx('recoil_memory_managament_2020')) {
      return;
    }
    var _store$getState4 = store.getState(),
      retention = _store$getState4.retention;
    function deleteFromZone(zone) {
      var set = retention.nodesRetainedByZone.get(zone);
      set === null || set === void 0 ? void 0 : set.delete(nodeKey);
      if (set && set.size === 0) {
        retention.nodesRetainedByZone.delete(zone);
      }
    }
    if (retainedBy instanceof RetentionZone$1) {
      deleteFromZone(retainedBy);
    } else if (Array.isArray(retainedBy)) {
      var _iterator9 = _createForOfIteratorHelper(retainedBy),
        _step9;
      try {
        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
          var _zone = _step9.value;
          deleteFromZone(_zone);
        }
      } catch (err) {
        _iterator9.e(err);
      } finally {
        _iterator9.f();
      }
    }
  };
}
function initializeNodeIfNewToStore(store, treeState, key, trigger) {
  var storeState = store.getState();
  if (storeState.nodeCleanupFunctions.has(key)) {
    return;
  }
  var node = getNode$1(key);
  var retentionCleanup = initializeRetentionForNode(store, key, node.retainedBy);
  var nodeCleanup = node.init(store, treeState, trigger);
  storeState.nodeCleanupFunctions.set(key, function () {
    nodeCleanup();
    retentionCleanup();
  });
}
function initializeNode(store, key, trigger) {
  initializeNodeIfNewToStore(store, store.getState().currentTree, key, trigger);
}
function cleanUpNode(store, key) {
  var _state$nodeCleanupFun;
  var state = store.getState();
  (_state$nodeCleanupFun = state.nodeCleanupFunctions.get(key)) === null || _state$nodeCleanupFun === void 0 ? void 0 : _state$nodeCleanupFun();
  state.nodeCleanupFunctions.delete(key);
} // Get the current value loadable of a node and update the state.
// Update dependencies and subscriptions for selectors.
// Update saved value validation for atoms.

function getNodeLoadable(store, state, key) {
  initializeNodeIfNewToStore(store, state, key, 'get');
  return getNode$1(key).get(store, state);
} // Peek at the current value loadable for a node without any evaluation or state change

function peekNodeLoadable(store, state, key) {
  return getNode$1(key).peek(store, state);
} // Write value directly to state bypassing the Node interface as the node
// definitions may not have been loaded yet when processing the initial snapshot.

function setUnvalidatedAtomValue_DEPRECATED(state, key, newValue) {
  var _node$invalidate;
  var node = getNodeMaybe$1(key);
  node === null || node === void 0 ? void 0 : (_node$invalidate = node.invalidate) === null || _node$invalidate === void 0 ? void 0 : _node$invalidate.call(node, state);
  return _objectSpread2(_objectSpread2({}, state), {}, {
    atomValues: state.atomValues.clone().delete(key),
    nonvalidatedAtoms: state.nonvalidatedAtoms.clone().set(key, newValue),
    dirtyAtoms: setByAddingToSet$1(state.dirtyAtoms, key)
  });
} // Return the discovered dependencies and values to be written by setting
// a node value. (Multiple values may be written due to selectors getting to
// set upstreams; deps may be discovered because of reads in updater functions.)

function setNodeValue(store, state, key, newValue) {
  var node = getNode$1(key);
  if (node.set == null) {
    throw new ReadOnlyRecoilValueError("Attempt to set read-only RecoilValue: ".concat(key));
  }
  var set = node.set; // so flow doesn't lose the above refinement.

  initializeNodeIfNewToStore(store, state, key, 'set');
  return set(store, state, newValue);
}
function peekNodeInfo(store, state, key) {
  var storeState = store.getState();
  var graph = store.getGraph(state.version);
  var type = getNode$1(key).nodeType;
  return Recoil_lazyProxy({
    type: type
  }, {
    // $FlowFixMe[underconstrained-implicit-instantiation]
    loadable: function loadable() {
      return peekNodeLoadable(store, state, key);
    },
    isActive: function isActive() {
      return storeState.knownAtoms.has(key) || storeState.knownSelectors.has(key);
    },
    isSet: function isSet() {
      return type === 'selector' ? false : state.atomValues.has(key);
    },
    isModified: function isModified() {
      return state.dirtyAtoms.has(key);
    },
    // Report current dependencies.  If the node hasn't been evaluated, then
    // dependencies may be missing based on the current state.
    deps: function deps() {
      var _graph$nodeDeps$get;
      return recoilValuesForKeys$1((_graph$nodeDeps$get = graph.nodeDeps.get(key)) !== null && _graph$nodeDeps$get !== void 0 ? _graph$nodeDeps$get : []);
    },
    // Reports all "current" subscribers.  Evaluating other nodes or
    // previous in-progress async evaluations may introduce new subscribers.
    subscribers: function subscribers() {
      var _storeState$nodeToCom, _storeState$nodeToCom2;
      return {
        nodes: recoilValuesForKeys$1(Recoil_filterIterable(getDownstreamNodes(store, state, new Set([key])), function (nodeKey) {
          return nodeKey !== key;
        })),
        components: Recoil_mapIterable((_storeState$nodeToCom = (_storeState$nodeToCom2 = storeState.nodeToComponentSubscriptions.get(key)) === null || _storeState$nodeToCom2 === void 0 ? void 0 : _storeState$nodeToCom2.values()) !== null && _storeState$nodeToCom !== void 0 ? _storeState$nodeToCom : [], function (_ref3) {
          var _ref4 = slicedToArray_slicedToArray(_ref3, 1),
            name = _ref4[0];
          return {
            name: name
          };
        })
      };
    }
  });
} // Find all of the recursively dependent nodes

function getDownstreamNodes(store, state, keys) {
  var visitedNodes = new Set();
  var visitingNodes = Array.from(keys);
  var graph = store.getGraph(state.version);
  for (var key = visitingNodes.pop(); key; key = visitingNodes.pop()) {
    var _graph$nodeToNodeSubs;
    visitedNodes.add(key);
    var subscribedNodes = (_graph$nodeToNodeSubs = graph.nodeToNodeSubscriptions.get(key)) !== null && _graph$nodeToNodeSubs !== void 0 ? _graph$nodeToNodeSubs : emptySet;
    var _iterator10 = _createForOfIteratorHelper(subscribedNodes),
      _step10;
    try {
      for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
        var downstreamNode = _step10.value;
        if (!visitedNodes.has(downstreamNode)) {
          visitingNodes.push(downstreamNode);
        }
      }
    } catch (err) {
      _iterator10.e(err);
    } finally {
      _iterator10.f();
    }
  }
  return visitedNodes;
}
var Recoil_FunctionalCore = {
  getNodeLoadable: getNodeLoadable,
  peekNodeLoadable: peekNodeLoadable,
  setNodeValue: setNodeValue,
  initializeNode: initializeNode,
  cleanUpNode: cleanUpNode,
  setUnvalidatedAtomValue_DEPRECATED: setUnvalidatedAtomValue_DEPRECATED,
  peekNodeInfo: peekNodeInfo,
  getDownstreamNodes: getDownstreamNodes
};

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */

var _invalidateMemoizedSnapshot = null;
function setInvalidateMemoizedSnapshot(invalidate) {
  _invalidateMemoizedSnapshot = invalidate;
}
function invalidateMemoizedSnapshot() {
  var _invalidateMemoizedSn;
  (_invalidateMemoizedSn = _invalidateMemoizedSnapshot) === null || _invalidateMemoizedSn === void 0 ? void 0 : _invalidateMemoizedSn();
}
var Recoil_SnapshotCache = {
  setInvalidateMemoizedSnapshot: setInvalidateMemoizedSnapshot,
  invalidateMemoizedSnapshot: invalidateMemoizedSnapshot
};
var getDownstreamNodes$1 = Recoil_FunctionalCore.getDownstreamNodes,
  getNodeLoadable$1 = Recoil_FunctionalCore.getNodeLoadable,
  setNodeValue$1 = Recoil_FunctionalCore.setNodeValue;
var getNextComponentID$1 = Recoil_Keys.getNextComponentID;
var getNode$2 = Recoil_Node.getNode,
  getNodeMaybe$2 = Recoil_Node.getNodeMaybe;
var DefaultValue$1 = Recoil_Node.DefaultValue;
var reactMode$1 = Recoil_ReactMode.reactMode;
var AbstractRecoilValue$1 = Recoil_RecoilValue$1.AbstractRecoilValue,
  RecoilState$1 = Recoil_RecoilValue$1.RecoilState,
  RecoilValueReadOnly$1 = Recoil_RecoilValue$1.RecoilValueReadOnly,
  isRecoilValue$1 = Recoil_RecoilValue$1.isRecoilValue;
var invalidateMemoizedSnapshot$1 = Recoil_SnapshotCache.invalidateMemoizedSnapshot;
function getRecoilValueAsLoadable(store, _ref5) {
  var key = _ref5.key;
  var treeState = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : store.getState().currentTree;
  var _storeState$nextTree, _storeState$previousT;

  // Reading from an older tree can cause bugs because the dependencies that we
  // discover during the read are lost.
  var storeState = store.getState();
  if (!(treeState.version === storeState.currentTree.version || treeState.version === ((_storeState$nextTree = storeState.nextTree) === null || _storeState$nextTree === void 0 ? void 0 : _storeState$nextTree.version) || treeState.version === ((_storeState$previousT = storeState.previousTree) === null || _storeState$previousT === void 0 ? void 0 : _storeState$previousT.version))) {
    Recoil_recoverableViolation('Tried to read from a discarded tree');
  }
  var loadable = getNodeLoadable$1(store, treeState, key);
  if (loadable.state === 'loading') {
    loadable.contents.catch(function () {
      /**
       * HACK: intercept thrown error here to prevent an uncaught promise exception. Ideally this would happen closer to selector
       * execution (perhaps introducing a new ERROR class to be resolved by async selectors that are in an error state)
       */
      return;
    });
  }
  return loadable;
}
function applyAtomValueWrites(atomValues, writes) {
  var result = atomValues.clone();
  writes.forEach(function (v, k) {
    if (v.state === 'hasValue' && v.contents instanceof DefaultValue$1) {
      result.delete(k);
    } else {
      result.set(k, v);
    }
  });
  return result;
}
function valueFromValueOrUpdater(store, state, _ref6, valueOrUpdater) {
  var key = _ref6.key;
  if (typeof valueOrUpdater === 'function') {
    // Updater form: pass in the current value. Throw if the current value
    // is unavailable (namely when updating an async selector that's
    // pending or errored):
    var current = getNodeLoadable$1(store, state, key);
    if (current.state === 'loading') {
      var msg = "Tried to set atom or selector \"".concat(key, "\" using an updater function while the current state is pending, this is not currently supported.");
      Recoil_recoverableViolation(msg);
      throw Recoil_err(msg);
    } else if (current.state === 'hasError') {
      throw current.contents;
    } // T itself may be a function, so our refinement is not sufficient:

    return valueOrUpdater(current.contents); // flowlint-line unclear-type:off
  } else {
    return valueOrUpdater;
  }
}
function applyAction(store, state, action) {
  if (action.type === 'set') {
    var recoilValue = action.recoilValue,
      valueOrUpdater = action.valueOrUpdater;
    var newValue = valueFromValueOrUpdater(store, state, recoilValue, valueOrUpdater);
    var writes = setNodeValue$1(store, state, recoilValue.key, newValue);
    var _iterator11 = _createForOfIteratorHelper(writes.entries()),
      _step11;
    try {
      for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
        var _step11$value = slicedToArray_slicedToArray(_step11.value, 2),
          key = _step11$value[0],
          loadable = _step11$value[1];
        writeLoadableToTreeState(state, key, loadable);
      }
    } catch (err) {
      _iterator11.e(err);
    } finally {
      _iterator11.f();
    }
  } else if (action.type === 'setLoadable') {
    var _key4 = action.recoilValue.key,
      _loadable = action.loadable;
    writeLoadableToTreeState(state, _key4, _loadable);
  } else if (action.type === 'markModified') {
    var _key5 = action.recoilValue.key;
    state.dirtyAtoms.add(_key5);
  } else if (action.type === 'setUnvalidated') {
    var _node$invalidate;

    // Write value directly to state bypassing the Node interface as the node
    // definitions may not have been loaded yet when processing the initial snapshot.
    var _key6 = action.recoilValue.key,
      unvalidatedValue = action.unvalidatedValue;
    var node = getNodeMaybe$2(_key6);
    node === null || node === void 0 ? void 0 : (_node$invalidate = node.invalidate) === null || _node$invalidate === void 0 ? void 0 : _node$invalidate.call(node, state);
    state.atomValues.delete(_key6);
    state.nonvalidatedAtoms.set(_key6, unvalidatedValue);
    state.dirtyAtoms.add(_key6);
  } else {
    Recoil_recoverableViolation("Unknown action ".concat(action.type));
  }
}
function writeLoadableToTreeState(state, key, loadable) {
  if (loadable.state === 'hasValue' && loadable.contents instanceof DefaultValue$1) {
    state.atomValues.delete(key);
  } else {
    state.atomValues.set(key, loadable);
  }
  state.dirtyAtoms.add(key);
  state.nonvalidatedAtoms.delete(key);
}
function applyActionsToStore(store, actions) {
  store.replaceState(function (state) {
    var newState = copyTreeState(state);
    var _iterator12 = _createForOfIteratorHelper(actions),
      _step12;
    try {
      for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
        var action = _step12.value;
        applyAction(store, newState, action);
      }
    } catch (err) {
      _iterator12.e(err);
    } finally {
      _iterator12.f();
    }
    invalidateDownstreams(store, newState);
    invalidateMemoizedSnapshot$1();
    return newState;
  });
}
function queueOrPerformStateUpdate(store, action) {
  if (batchStack.length) {
    var actionsByStore = batchStack[batchStack.length - 1];
    var actions = actionsByStore.get(store);
    if (!actions) {
      actionsByStore.set(store, actions = []);
    }
    actions.push(action);
  } else {
    applyActionsToStore(store, [action]);
  }
}
var batchStack = [];
function batchStart() {
  var actionsByStore = new Map();
  batchStack.push(actionsByStore);
  return function () {
    var _iterator13 = _createForOfIteratorHelper(actionsByStore),
      _step13;
    try {
      for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
        var _step13$value = slicedToArray_slicedToArray(_step13.value, 2),
          store = _step13$value[0],
          actions = _step13$value[1];
        applyActionsToStore(store, actions);
      }
    } catch (err) {
      _iterator13.e(err);
    } finally {
      _iterator13.f();
    }
    var popped = batchStack.pop();
    if (popped !== actionsByStore) {
      Recoil_recoverableViolation('Incorrect order of batch popping');
    }
  };
}
function copyTreeState(state) {
  return _objectSpread2(_objectSpread2({}, state), {}, {
    atomValues: state.atomValues.clone(),
    nonvalidatedAtoms: state.nonvalidatedAtoms.clone(),
    dirtyAtoms: new Set(state.dirtyAtoms)
  });
}
function invalidateDownstreams(store, state) {
  // Inform any nodes that were changed or downstream of changes so that they
  // can clear out any caches as needed due to the update:
  var downstreams = getDownstreamNodes$1(store, state, state.dirtyAtoms);
  var _iterator14 = _createForOfIteratorHelper(downstreams),
    _step14;
  try {
    for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
      var key = _step14.value;
      var _getNodeMaybe, _getNodeMaybe$invalid;
      (_getNodeMaybe = getNodeMaybe$2(key)) === null || _getNodeMaybe === void 0 ? void 0 : (_getNodeMaybe$invalid = _getNodeMaybe.invalidate) === null || _getNodeMaybe$invalid === void 0 ? void 0 : _getNodeMaybe$invalid.call(_getNodeMaybe, state);
    }
  } catch (err) {
    _iterator14.e(err);
  } finally {
    _iterator14.f();
  }
}
function setRecoilValue(store, recoilValue, valueOrUpdater) {
  queueOrPerformStateUpdate(store, {
    type: 'set',
    recoilValue: recoilValue,
    valueOrUpdater: valueOrUpdater
  });
}
function setRecoilValueLoadable(store, recoilValue, loadable) {
  if (loadable instanceof DefaultValue$1) {
    return setRecoilValue(store, recoilValue, loadable);
  }
  queueOrPerformStateUpdate(store, {
    type: 'setLoadable',
    recoilValue: recoilValue,
    loadable: loadable
  });
}
function markRecoilValueModified(store, recoilValue) {
  queueOrPerformStateUpdate(store, {
    type: 'markModified',
    recoilValue: recoilValue
  });
}
function setUnvalidatedRecoilValue(store, recoilValue, unvalidatedValue) {
  queueOrPerformStateUpdate(store, {
    type: 'setUnvalidated',
    recoilValue: recoilValue,
    unvalidatedValue: unvalidatedValue
  });
}
function subscribeToRecoilValue(store, _ref7, callback) {
  var key = _ref7.key;
  var componentDebugName = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  var subID = getNextComponentID$1();
  var storeState = store.getState();
  if (!storeState.nodeToComponentSubscriptions.has(key)) {
    storeState.nodeToComponentSubscriptions.set(key, new Map());
  }
  Recoil_nullthrows(storeState.nodeToComponentSubscriptions.get(key)).set(subID, [componentDebugName !== null && componentDebugName !== void 0 ? componentDebugName : '<not captured>', callback]); // Handle the case that, during the same tick that we are subscribing, an atom
  // has been updated by some effect handler. Otherwise we will miss the update.

  var mode = reactMode$1();
  if (mode.early && (mode.mode === 'LEGACY' || mode.mode === 'MUTABLE_SOURCE')) {
    var nextTree = store.getState().nextTree;
    if (nextTree && nextTree.dirtyAtoms.has(key)) {
      callback(nextTree);
    }
  }
  return {
    release: function release() {
      var releaseStoreState = store.getState();
      var subs = releaseStoreState.nodeToComponentSubscriptions.get(key);
      if (subs === undefined || !subs.has(subID)) {
        Recoil_recoverableViolation("Subscription missing at release time for atom ".concat(key, ". This is a bug in Recoil."));
        return;
      }
      subs.delete(subID);
      if (subs.size === 0) {
        releaseStoreState.nodeToComponentSubscriptions.delete(key);
      }
    }
  };
}
function refreshRecoilValue(store, recoilValue) {
  var _node$clearCache;
  var _store$getState5 = store.getState(),
    currentTree = _store$getState5.currentTree;
  var node = getNode$2(recoilValue.key);
  (_node$clearCache = node.clearCache) === null || _node$clearCache === void 0 ? void 0 : _node$clearCache.call(node, store, currentTree);
}
var Recoil_RecoilValueInterface = {
  RecoilValueReadOnly: RecoilValueReadOnly$1,
  AbstractRecoilValue: AbstractRecoilValue$1,
  RecoilState: RecoilState$1,
  getRecoilValueAsLoadable: getRecoilValueAsLoadable,
  setRecoilValue: setRecoilValue,
  setRecoilValueLoadable: setRecoilValueLoadable,
  markRecoilValueModified: markRecoilValueModified,
  setUnvalidatedRecoilValue: setUnvalidatedRecoilValue,
  subscribeToRecoilValue: subscribeToRecoilValue,
  isRecoilValue: isRecoilValue$1,
  applyAtomValueWrites: applyAtomValueWrites,
  // TODO Remove export when deprecating initialStoreState_DEPRECATED in RecoilRoot
  batchStart: batchStart,
  writeLoadableToTreeState: writeLoadableToTreeState,
  invalidateDownstreams: invalidateDownstreams,
  copyTreeState: copyTreeState,
  refreshRecoilValue: refreshRecoilValue
};

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
/**
 * The someSet() method tests whether some elements in the given Set pass the
 * test implemented by the provided function.
 */

function someSet(set, callback, context) {
  var iterator = set.entries();
  var current = iterator.next();
  while (!current.done) {
    var entry = current.value;
    if (callback.call(context, entry[1], entry[0], set)) {
      return true;
    }
    current = iterator.next();
  }
  return false;
}
var Recoil_someSet = someSet;
var cleanUpNode$1 = Recoil_FunctionalCore.cleanUpNode;
var deleteNodeConfigIfPossible$1 = Recoil_Node.deleteNodeConfigIfPossible,
  getNode$3 = Recoil_Node.getNode;
var RetentionZone$2 = Recoil_RetentionZone.RetentionZone;

// Components that aren't mounted after suspending for this long will be assumed
// to be discarded and their resources released.

var SUSPENSE_TIMEOUT_MS = 120000;
var emptySet$1 = new Set();
function releaseRetainablesNowOnCurrentTree(store, retainables) {
  var storeState = store.getState();
  var treeState = storeState.currentTree;
  if (storeState.nextTree) {
    Recoil_recoverableViolation('releaseNodesNowOnCurrentTree should only be called at the end of a batch');
    return; // leak memory rather than erase something that's about to be used.
  }

  var nodes = new Set();
  var _iterator15 = _createForOfIteratorHelper(retainables),
    _step15;
  try {
    for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
      var r = _step15.value;
      if (r instanceof RetentionZone$2) {
        var _iterator17 = _createForOfIteratorHelper(nodesRetainedByZone(storeState, r)),
          _step17;
        try {
          for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
            var n = _step17.value;
            nodes.add(n);
          }
        } catch (err) {
          _iterator17.e(err);
        } finally {
          _iterator17.f();
        }
      } else {
        nodes.add(r);
      }
    }
  } catch (err) {
    _iterator15.e(err);
  } finally {
    _iterator15.f();
  }
  var releasableNodes = findReleasableNodes(store, nodes);
  var _iterator16 = _createForOfIteratorHelper(releasableNodes),
    _step16;
  try {
    for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
      var node = _step16.value;
      releaseNode(store, treeState, node);
    }
  } catch (err) {
    _iterator16.e(err);
  } finally {
    _iterator16.f();
  }
}
function findReleasableNodes(store, searchFromNodes) {
  var storeState = store.getState();
  var treeState = storeState.currentTree;
  var graph = store.getGraph(treeState.version);
  var releasableNodes = new Set(); // mutated to collect answer

  var nonReleasableNodes = new Set();
  findReleasableNodesInner(searchFromNodes);
  return releasableNodes;
  function findReleasableNodesInner(searchFromNodes) {
    var releasableNodesFoundThisIteration = new Set();
    var downstreams = getDownstreamNodesInTopologicalOrder(store, treeState, searchFromNodes, releasableNodes,
    // don't descend into these
    nonReleasableNodes // don't descend into these
    ); // Find which of the downstream nodes are releasable and which are not:
    var _iterator18 = _createForOfIteratorHelper(downstreams),
      _step18;
    try {
      for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
        var node = _step18.value;
        var _storeState$retention;

        // Not releasable if configured to be retained forever:
        if (getNode$3(node).retainedBy === 'recoilRoot') {
          nonReleasableNodes.add(node);
          continue;
        } // Not releasable if retained directly by a component:

        if (((_storeState$retention = storeState.retention.referenceCounts.get(node)) !== null && _storeState$retention !== void 0 ? _storeState$retention : 0) > 0) {
          nonReleasableNodes.add(node);
          continue;
        } // Not releasable if retained by a zone:

        if (zonesThatCouldRetainNode(node).some(function (z) {
          return storeState.retention.referenceCounts.get(z);
        })) {
          nonReleasableNodes.add(node);
          continue;
        } // Not releasable if it has a non-releasable child (which will already be in
        // nonReleasableNodes because we are going in topological order):

        var nodeChildren = graph.nodeToNodeSubscriptions.get(node);
        if (nodeChildren && Recoil_someSet(nodeChildren, function (child) {
          return nonReleasableNodes.has(child);
        })) {
          nonReleasableNodes.add(node);
          continue;
        }
        releasableNodes.add(node);
        releasableNodesFoundThisIteration.add(node);
      } // If we found any releasable nodes, we need to walk UP from those nodes to
      // find whether their parents can now be released as well:
    } catch (err) {
      _iterator18.e(err);
    } finally {
      _iterator18.f();
    }
    var parents = new Set();
    var _iterator19 = _createForOfIteratorHelper(releasableNodesFoundThisIteration),
      _step19;
    try {
      for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
        var _node5 = _step19.value;
        var _iterator20 = _createForOfIteratorHelper((_graph$nodeDeps$get = graph.nodeDeps.get(_node5)) !== null && _graph$nodeDeps$get !== void 0 ? _graph$nodeDeps$get : emptySet$1),
          _step20;
        try {
          for (_iterator20.s(); !(_step20 = _iterator20.n()).done;) {
            var parent = _step20.value;
            var _graph$nodeDeps$get;
            if (!releasableNodes.has(parent)) {
              parents.add(parent);
            }
          }
        } catch (err) {
          _iterator20.e(err);
        } finally {
          _iterator20.f();
        }
      }
    } catch (err) {
      _iterator19.e(err);
    } finally {
      _iterator19.f();
    }
    if (parents.size) {
      findReleasableNodesInner(parents);
    }
  }
} // Children before parents

function getDownstreamNodesInTopologicalOrder(store, treeState, nodes,
// Mutable set is destroyed in place
doNotDescendInto1, doNotDescendInto2) {
  var graph = store.getGraph(treeState.version);
  var answer = [];
  var visited = new Set();
  while (nodes.size > 0) {
    visit(Recoil_nullthrows(nodes.values().next().value));
  }
  return answer;
  function visit(node) {
    if (doNotDescendInto1.has(node) || doNotDescendInto2.has(node)) {
      nodes.delete(node);
      return;
    }
    if (visited.has(node)) {
      return;
    }
    var children = graph.nodeToNodeSubscriptions.get(node);
    if (children) {
      var _iterator21 = _createForOfIteratorHelper(children),
        _step21;
      try {
        for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {
          var child = _step21.value;
          visit(child);
        }
      } catch (err) {
        _iterator21.e(err);
      } finally {
        _iterator21.f();
      }
    }
    visited.add(node);
    nodes.delete(node);
    answer.push(node);
  }
}
function releaseNode(store, treeState, node) {
  if (!Recoil_gkx('recoil_memory_managament_2020')) {
    return;
  } // Atom effects, in-closure caches, etc.:

  cleanUpNode$1(store, node); // Delete from store state:

  var storeState = store.getState();
  storeState.knownAtoms.delete(node);
  storeState.knownSelectors.delete(node);
  storeState.nodeTransactionSubscriptions.delete(node);
  storeState.retention.referenceCounts.delete(node);
  var zones = zonesThatCouldRetainNode(node);
  var _iterator22 = _createForOfIteratorHelper(zones),
    _step22;
  try {
    for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {
      var zone = _step22.value;
      var _storeState$retention2;
      (_storeState$retention2 = storeState.retention.nodesRetainedByZone.get(zone)) === null || _storeState$retention2 === void 0 ? void 0 : _storeState$retention2.delete(node);
    } // Note that we DO NOT delete from nodeToComponentSubscriptions because this
    // already happens when the last component that was retaining the node unmounts,
    // and this could happen either before or after that.
    // Delete from TreeState and dep graph:
  } catch (err) {
    _iterator22.e(err);
  } finally {
    _iterator22.f();
  }
  treeState.atomValues.delete(node);
  treeState.dirtyAtoms.delete(node);
  treeState.nonvalidatedAtoms.delete(node);
  var graph = storeState.graphsByVersion.get(treeState.version);
  if (graph) {
    var deps = graph.nodeDeps.get(node);
    if (deps !== undefined) {
      graph.nodeDeps.delete(node);
      var _iterator23 = _createForOfIteratorHelper(deps),
        _step23;
      try {
        for (_iterator23.s(); !(_step23 = _iterator23.n()).done;) {
          var dep = _step23.value;
          var _graph$nodeToNodeSubs;
          (_graph$nodeToNodeSubs = graph.nodeToNodeSubscriptions.get(dep)) === null || _graph$nodeToNodeSubs === void 0 ? void 0 : _graph$nodeToNodeSubs.delete(node);
        }
      } catch (err) {
        _iterator23.e(err);
      } finally {
        _iterator23.f();
      }
    } // No need to delete sub's deps as there should be no subs at this point.
    // But an invariant would require deleting nodes in topological order.

    graph.nodeToNodeSubscriptions.delete(node);
  } // Node config (for family members only as their configs can be recreated, and
  // only if they are not retained within any other Stores):

  deleteNodeConfigIfPossible$1(node);
}
function nodesRetainedByZone(storeState, zone) {
  var _storeState$retention3;
  return (_storeState$retention3 = storeState.retention.nodesRetainedByZone.get(zone)) !== null && _storeState$retention3 !== void 0 ? _storeState$retention3 : emptySet$1;
}
function zonesThatCouldRetainNode(node) {
  var retainedBy = getNode$3(node).retainedBy;
  if (retainedBy === undefined || retainedBy === 'components' || retainedBy === 'recoilRoot') {
    return [];
  } else if (retainedBy instanceof RetentionZone$2) {
    return [retainedBy];
  } else {
    return retainedBy; // it's an array of zones
  }
}

function scheduleOrPerformPossibleReleaseOfRetainable(store, retainable) {
  var state = store.getState();
  if (state.nextTree) {
    state.retention.retainablesToCheckForRelease.add(retainable);
  } else {
    releaseRetainablesNowOnCurrentTree(store, new Set([retainable]));
  }
}
function updateRetainCount(store, retainable, delta) {
  var _map$get;
  if (!Recoil_gkx('recoil_memory_managament_2020')) {
    return;
  }
  var map = store.getState().retention.referenceCounts;
  var newCount = ((_map$get = map.get(retainable)) !== null && _map$get !== void 0 ? _map$get : 0) + delta;
  if (newCount === 0) {
    updateRetainCountToZero(store, retainable);
  } else {
    map.set(retainable, newCount);
  }
}
function updateRetainCountToZero(store, retainable) {
  if (!Recoil_gkx('recoil_memory_managament_2020')) {
    return;
  }
  var map = store.getState().retention.referenceCounts;
  map.delete(retainable);
  scheduleOrPerformPossibleReleaseOfRetainable(store, retainable);
}
function releaseScheduledRetainablesNow(store) {
  if (!Recoil_gkx('recoil_memory_managament_2020')) {
    return;
  }
  var state = store.getState();
  releaseRetainablesNowOnCurrentTree(store, state.retention.retainablesToCheckForRelease);
  state.retention.retainablesToCheckForRelease.clear();
}
function retainedByOptionWithDefault(r) {
  // The default will change from 'recoilRoot' to 'components' in the future.
  return r === undefined ? 'recoilRoot' : r;
}
var Recoil_Retention = {
  SUSPENSE_TIMEOUT_MS: SUSPENSE_TIMEOUT_MS,
  updateRetainCount: updateRetainCount,
  updateRetainCountToZero: updateRetainCountToZero,
  releaseScheduledRetainablesNow: releaseScheduledRetainablesNow,
  retainedByOptionWithDefault: retainedByOptionWithDefault
};

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * This is to export esstiential functions from react-dom
 * for our web build
 *
 * 
 * @format
 * @oncall recoil
 */
var unstable_batchedUpdates = _react_dom_18_2_0_react_dom.unstable_batchedUpdates;
var ReactBatchedUpdates = {
  unstable_batchedUpdates: unstable_batchedUpdates
};

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * This is to export esstiential functions from react-dom
 * for our web build
 *
 * 
 * @format
 * @oncall recoil
 */
// @fb-only: const {unstable_batchedUpdates} = require('ReactDOMComet');
// prettier-ignore
var unstable_batchedUpdates$1 = ReactBatchedUpdates.unstable_batchedUpdates; // @oss-only

var Recoil_ReactBatchedUpdates = {
  unstable_batchedUpdates: unstable_batchedUpdates$1
};

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
var batchStart$1 = Recoil_RecoilValueInterface.batchStart;
var unstable_batchedUpdates$2 = Recoil_ReactBatchedUpdates.unstable_batchedUpdates; // flowlint-next-line unclear-type:off

/*
 * During SSR, unstable_batchedUpdates may be undefined so this
 * falls back to a basic function that executes the batch
 */
var batcher = unstable_batchedUpdates$2 || function (batchFn) {
  return batchFn();
};
/**
 * Sets the provided batcher function as the batcher function used by Recoil.
 *
 * Set the batcher to a custom batcher for your renderer,
 * if you use a renderer other than React DOM or React Native.
 */

var setBatcher = function setBatcher(newBatcher) {
  batcher = newBatcher;
};
/**
 * Returns the current batcher function.
 */

var getBatcher = function getBatcher() {
  return batcher;
};
/**
 * Calls the current batcher function and passes the
 * provided callback function.
 */

var batchUpdates = function batchUpdates(callback) {
  batcher(function () {
    var batchEnd = function batchEnd() {
      return undefined;
    };
    try {
      batchEnd = batchStart$1();
      callback();
    } finally {
      batchEnd();
    }
  });
};
var Recoil_Batching = {
  getBatcher: getBatcher,
  setBatcher: setBatcher,
  batchUpdates: batchUpdates
};

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
/**
 * Combines multiple Iterables into a single Iterable.
 * Traverses the input Iterables in the order provided and maintains the order
 * of their elements.
 *
 * Example:
 * ```
 * const r = Array.from(concatIterables(['a', 'b'], ['c'], ['d', 'e', 'f']));
 * r == ['a', 'b', 'c', 'd', 'e', 'f'];
 * ```
 */

function concatIterables(iters) {
  var _iterator24, _step24, iter, _iterator25, _step25, val;
  return regeneratorRuntime_regeneratorRuntime().wrap(function concatIterables$(_context3) {
    while (1) switch (_context3.prev = _context3.next) {
      case 0:
        _iterator24 = _createForOfIteratorHelper(iters);
        _context3.prev = 1;
        _iterator24.s();
      case 3:
        if ((_step24 = _iterator24.n()).done) {
          _context3.next = 24;
          break;
        }
        iter = _step24.value;
        _iterator25 = _createForOfIteratorHelper(iter);
        _context3.prev = 6;
        _iterator25.s();
      case 8:
        if ((_step25 = _iterator25.n()).done) {
          _context3.next = 14;
          break;
        }
        val = _step25.value;
        _context3.next = 12;
        return val;
      case 12:
        _context3.next = 8;
        break;
      case 14:
        _context3.next = 19;
        break;
      case 16:
        _context3.prev = 16;
        _context3.t0 = _context3["catch"](6);
        _iterator25.e(_context3.t0);
      case 19:
        _context3.prev = 19;
        _iterator25.f();
        return _context3.finish(19);
      case 22:
        _context3.next = 3;
        break;
      case 24:
        _context3.next = 29;
        break;
      case 26:
        _context3.prev = 26;
        _context3.t1 = _context3["catch"](1);
        _iterator24.e(_context3.t1);
      case 29:
        _context3.prev = 29;
        _iterator24.f();
        return _context3.finish(29);
      case 32:
      case "end":
        return _context3.stop();
    }
  }, _marked2, null, [[1, 26, 29, 32], [6, 16, 19, 22]]);
}
var Recoil_concatIterables = concatIterables;

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
/* eslint-disable fb-www/typeof-undefined */

var isSSR =
// $FlowFixMe(site=recoil) Window does not have a FlowType definition https://github.com/facebook/flow/issues/6709
typeof Window === 'undefined' || typeof window === 'undefined';
/* eslint-enable fb-www/typeof-undefined */

var isWindow = function isWindow(value) {
  return !isSSR && (
  // $FlowFixMe(site=recoil) Window does not have a FlowType definition https://github.com/facebook/flow/issues/6709
  value === window || value instanceof Window);
};
var isReactNative = typeof navigator !== 'undefined' && navigator.product === 'ReactNative'; // eslint-disable-line fb-www/typeof-undefined

var Recoil_Environment = {
  isSSR: isSSR,
  isReactNative: isReactNative,
  isWindow: isWindow
};

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
/**
 * Caches a function's results based on the key returned by the passed
 * hashFunction.
 */

function memoizeWithArgsHash(fn, hashFunction) {
  var cache;
  return function () {
    if (!cache) {
      cache = {};
    }
    var key = hashFunction.apply(void 0, arguments);
    if (!Object.hasOwnProperty.call(cache, key)) {
      cache[key] = fn.apply(void 0, arguments);
    }
    return cache[key];
  };
}
/**
 * Caches a function's results based on a comparison of the arguments.
 * Only caches the last return of the function.
 * Defaults to reference equality
 */

function memoizeOneWithArgsHash(fn, hashFunction) {
  var lastKey;
  var lastResult; // breaking cache when arguments change

  return function () {
    var key = hashFunction.apply(void 0, arguments);
    if (lastKey === key) {
      return lastResult;
    }
    lastKey = key;
    lastResult = fn.apply(void 0, arguments);
    return lastResult;
  };
}
/**
 * Caches a function's results based on a comparison of the arguments.
 * Only caches the last return of the function.
 * Defaults to reference equality
 */

function memoizeOneWithArgsHashAndInvalidation(fn, hashFunction) {
  var lastKey;
  var lastResult; // breaking cache when arguments change

  var memoizedFn = function memoizedFn() {
    var key = hashFunction.apply(void 0, arguments);
    if (lastKey === key) {
      return lastResult;
    }
    lastKey = key;
    lastResult = fn.apply(void 0, arguments);
    return lastResult;
  };
  var invalidate = function invalidate() {
    lastKey = null;
  };
  return [memoizedFn, invalidate];
}
var Recoil_Memoize = {
  memoizeWithArgsHash: memoizeWithArgsHash,
  memoizeOneWithArgsHash: memoizeOneWithArgsHash,
  memoizeOneWithArgsHashAndInvalidation: memoizeOneWithArgsHashAndInvalidation
};
var batchUpdates$1 = Recoil_Batching.batchUpdates;
var initializeNode$1 = Recoil_FunctionalCore.initializeNode,
  peekNodeInfo$1 = Recoil_FunctionalCore.peekNodeInfo;
var graph$1 = Recoil_Graph.graph;
var getNextStoreID$1 = Recoil_Keys.getNextStoreID;
var DEFAULT_VALUE$1 = Recoil_Node.DEFAULT_VALUE,
  recoilValues$1 = Recoil_Node.recoilValues,
  recoilValuesForKeys$2 = Recoil_Node.recoilValuesForKeys;
var AbstractRecoilValue$2 = Recoil_RecoilValueInterface.AbstractRecoilValue,
  getRecoilValueAsLoadable$1 = Recoil_RecoilValueInterface.getRecoilValueAsLoadable,
  setRecoilValue$1 = Recoil_RecoilValueInterface.setRecoilValue,
  setUnvalidatedRecoilValue$1 = Recoil_RecoilValueInterface.setUnvalidatedRecoilValue;
var updateRetainCount$1 = Recoil_Retention.updateRetainCount;
var setInvalidateMemoizedSnapshot$1 = Recoil_SnapshotCache.setInvalidateMemoizedSnapshot;
var getNextTreeStateVersion$2 = Recoil_State.getNextTreeStateVersion,
  makeEmptyStoreState$1 = Recoil_State.makeEmptyStoreState;
var isSSR$1 = Recoil_Environment.isSSR;
var memoizeOneWithArgsHashAndInvalidation$1 = Recoil_Memoize.memoizeOneWithArgsHashAndInvalidation;

// Opaque at this surface because it's part of the public API from here.

var retainWarning = "\nRecoil Snapshots only last for the duration of the callback they are provided to. To keep a Snapshot longer, do this:\n\n  const release = snapshot.retain();\n  try {\n    await doSomethingWithSnapshot(snapshot);\n  } finally {\n    release();\n  }\n\nThis is currently a DEV-only warning but will become a thrown exception in the next release of Recoil.\n"; // A "Snapshot" is "read-only" and captures a specific set of values of atoms.
// However, the data-flow-graph and selector values may evolve as selector
// evaluation functions are executed and async selectors resolve.
var Snapshot = /*#__PURE__*/function () {
  // eslint-disable-next-line fb-www/no-uninitialized-properties
  function Snapshot(storeState, parentStoreID) {
    var _this6 = this;
    _classCallCheck(this, Snapshot);
    es_defineProperty(this, "_store", void 0);
    es_defineProperty(this, "_refCount", 1);
    es_defineProperty(this, "getLoadable", function (recoilValue) {
      _this6.checkRefCount_INTERNAL();
      return getRecoilValueAsLoadable$1(_this6._store, recoilValue);
    });
    es_defineProperty(this, "getPromise", function (recoilValue) {
      _this6.checkRefCount_INTERNAL();
      return _this6.getLoadable(recoilValue).toPromise();
    });
    es_defineProperty(this, "getNodes_UNSTABLE", function (opt) {
      _this6.checkRefCount_INTERNAL(); // TODO Deal with modified selectors

      if ((opt === null || opt === void 0 ? void 0 : opt.isModified) === true) {
        if ((opt === null || opt === void 0 ? void 0 : opt.isInitialized) === false) {
          return [];
        }
        var state = _this6._store.getState().currentTree;
        return recoilValuesForKeys$2(state.dirtyAtoms);
      }
      var knownAtoms = _this6._store.getState().knownAtoms;
      var knownSelectors = _this6._store.getState().knownSelectors;
      return (opt === null || opt === void 0 ? void 0 : opt.isInitialized) == null ? recoilValues$1.values() : opt.isInitialized === true ? recoilValuesForKeys$2(Recoil_concatIterables([knownAtoms, knownSelectors])) : Recoil_filterIterable(recoilValues$1.values(), function (_ref8) {
        var key = _ref8.key;
        return !knownAtoms.has(key) && !knownSelectors.has(key);
      });
    });
    es_defineProperty(this, "getInfo_UNSTABLE", function (_ref9) {
      var key = _ref9.key;
      _this6.checkRefCount_INTERNAL();
      return peekNodeInfo$1(_this6._store, _this6._store.getState().currentTree, key);
    });
    es_defineProperty(this, "map", function (mapper) {
      _this6.checkRefCount_INTERNAL();
      var mutableSnapshot = new MutableSnapshot(_this6, batchUpdates$1);
      mapper(mutableSnapshot); // if removing batchUpdates from `set` add it here

      return mutableSnapshot;
    });
    es_defineProperty(this, "asyncMap", /*#__PURE__*/function () {
      var _ref10 = asyncToGenerator_asyncToGenerator( /*#__PURE__*/regeneratorRuntime_regeneratorRuntime().mark(function _callee2(mapper) {
        var mutableSnapshot;
        return regeneratorRuntime_regeneratorRuntime().wrap(function _callee2$(_context4) {
          while (1) switch (_context4.prev = _context4.next) {
            case 0:
              _this6.checkRefCount_INTERNAL();
              mutableSnapshot = new MutableSnapshot(_this6, batchUpdates$1);
              mutableSnapshot.retain(); // Retain new snapshot during async mapper
              _context4.next = 5;
              return mapper(mutableSnapshot);
            case 5:
              // Continue to retain the new snapshot for the user, but auto-release it
              // after the next tick, the same as a new synchronous snapshot.

              mutableSnapshot.autoRelease_INTERNAL();
              return _context4.abrupt("return", mutableSnapshot);
            case 7:
            case "end":
              return _context4.stop();
          }
        }, _callee2);
      }));
      return function (_x) {
        return _ref10.apply(this, arguments);
      };
    }());
    this._store = {
      storeID: getNextStoreID$1(),
      parentStoreID: parentStoreID,
      getState: function getState() {
        return storeState;
      },
      replaceState: function replaceState(replacer) {
        // no batching, so nextTree is never active
        storeState.currentTree = replacer(storeState.currentTree);
      },
      getGraph: function getGraph(version) {
        var graphs = storeState.graphsByVersion;
        if (graphs.has(version)) {
          return Recoil_nullthrows(graphs.get(version));
        }
        var newGraph = graph$1();
        graphs.set(version, newGraph);
        return newGraph;
      },
      subscribeToTransactions: function subscribeToTransactions() {
        return {
          release: function release() {}
        };
      },
      addTransactionMetadata: function addTransactionMetadata() {
        throw Recoil_err('Cannot subscribe to Snapshots');
      }
    }; // Initialize any nodes that are live in the parent store (primarily so that
    // this snapshot gets counted towards the node's live stores count).
    // TODO Optimize this when cloning snapshots for callbacks
    var _iterator26 = _createForOfIteratorHelper(this._store.getState().knownAtoms),
      _step26;
    try {
      for (_iterator26.s(); !(_step26 = _iterator26.n()).done;) {
        var nodeKey = _step26.value;
        initializeNode$1(this._store, nodeKey, 'get');
        updateRetainCount$1(this._store, nodeKey, 1);
      }
    } catch (err) {
      _iterator26.e(err);
    } finally {
      _iterator26.f();
    }
    this.autoRelease_INTERNAL();
  }
  _createClass(Snapshot, [{
    key: "retain",
    value: function retain() {
      var _this7 = this;
      if (this._refCount <= 0) {
        if (false) {} else {
          Recoil_recoverableViolation('Attempt to retain() Snapshot that was already released.');
        }
      }
      this._refCount++;
      var released = false;
      return function () {
        if (!released) {
          released = true;
          _this7._release();
        }
      };
    }
    /**
     * Release the snapshot on the next tick.  This means the snapshot is retained
     * during the execution of the current function using it.
     */
  }, {
    key: "autoRelease_INTERNAL",
    value: function autoRelease_INTERNAL() {
      var _this8 = this;
      if (!isSSR$1) {
        // Use timeout of 10 to workaround Firefox issue: https://github.com/facebookexperimental/Recoil/issues/1936
        window.setTimeout(function () {
          return _this8._release();
        }, 10);
      }
    }
  }, {
    key: "_release",
    value: function _release() {
      this._refCount--;
      if (this._refCount === 0) {
        this._store.getState().nodeCleanupFunctions.forEach(function (cleanup) {
          return cleanup();
        });
        this._store.getState().nodeCleanupFunctions.clear();
        if (!Recoil_gkx('recoil_memory_managament_2020')) {
          return;
        } // Temporarily nerfing this to allow us to find broken call sites without
        // actually breaking anybody yet.
        // for (const k of this._store.getState().knownAtoms) {
        //   updateRetainCountToZero(this._store, k);
        // }
      } else if (this._refCount < 0) {
        if (false) {}
      }
    }
  }, {
    key: "isRetained",
    value: function isRetained() {
      return this._refCount > 0;
    }
  }, {
    key: "checkRefCount_INTERNAL",
    value: function checkRefCount_INTERNAL() {
      if (Recoil_gkx('recoil_memory_managament_2020') && this._refCount <= 0) {
        if (false) {} // What we will ship later:
        // throw err(retainWarning);
      }
    }
  }, {
    key: "getStore_INTERNAL",
    value: function getStore_INTERNAL() {
      this.checkRefCount_INTERNAL();
      return this._store;
    }
  }, {
    key: "getID",
    value: function getID() {
      this.checkRefCount_INTERNAL();
      return this._store.getState().currentTree.stateID;
    }
  }, {
    key: "getStoreID",
    value: function getStoreID() {
      this.checkRefCount_INTERNAL();
      return this._store.storeID;
    } // We want to allow the methods to be destructured and used as accessors

    /* eslint-disable fb-www/extra-arrow-initializer */

    /* eslint-enable fb-www/extra-arrow-initializer */
  }]);
  return Snapshot;
}();
function cloneStoreState(store, treeState) {
  var bumpVersion = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
  var storeState = store.getState();
  var version = bumpVersion ? getNextTreeStateVersion$2() : treeState.version;
  return {
    // Always clone the TreeState to isolate stores from accidental mutations.
    // For example, reading a selector from a cloned snapshot shouldn't cache
    // in the original treestate which may cause the original to skip
    // initialization of upstream atoms.
    currentTree: {
      // TODO snapshots shouldn't really have versions because a new version number
      // is always assigned when the snapshot is gone to.
      version: bumpVersion ? version : treeState.version,
      stateID: bumpVersion ? version : treeState.stateID,
      transactionMetadata: _objectSpread2({}, treeState.transactionMetadata),
      dirtyAtoms: new Set(treeState.dirtyAtoms),
      atomValues: treeState.atomValues.clone(),
      nonvalidatedAtoms: treeState.nonvalidatedAtoms.clone()
    },
    commitDepth: 0,
    nextTree: null,
    previousTree: null,
    knownAtoms: new Set(storeState.knownAtoms),
    // FIXME here's a copy
    knownSelectors: new Set(storeState.knownSelectors),
    // FIXME here's a copy
    transactionSubscriptions: new Map(),
    nodeTransactionSubscriptions: new Map(),
    nodeToComponentSubscriptions: new Map(),
    queuedComponentCallbacks_DEPRECATED: [],
    suspendedComponentResolvers: new Set(),
    graphsByVersion: new Map().set(version, store.getGraph(treeState.version)),
    retention: {
      referenceCounts: new Map(),
      nodesRetainedByZone: new Map(),
      retainablesToCheckForRelease: new Set()
    },
    // FIXME here's a copy
    // Create blank cleanup handlers for atoms so snapshots don't re-run
    // atom effects.
    nodeCleanupFunctions: new Map(Recoil_mapIterable(storeState.nodeCleanupFunctions.entries(), function (_ref11) {
      var _ref12 = slicedToArray_slicedToArray(_ref11, 1),
        key = _ref12[0];
      return [key, function () {}];
    }))
  };
} // Factory to build a fresh snapshot

function freshSnapshot(initializeState) {
  var snapshot = new Snapshot(makeEmptyStoreState$1());
  return initializeState != null ? snapshot.map(initializeState) : snapshot;
} // Factory to clone a snapshot state

var _memoizeOneWithArgsHa = memoizeOneWithArgsHashAndInvalidation$1(
  // $FlowFixMe[missing-local-annot]
  function (store, version) {
    var _storeState$nextTree;
    var storeState = store.getState();
    var treeState = version === 'latest' ? (_storeState$nextTree = storeState.nextTree) !== null && _storeState$nextTree !== void 0 ? _storeState$nextTree : storeState.currentTree : Recoil_nullthrows(storeState.previousTree);
    return new Snapshot(cloneStoreState(store, treeState), store.storeID);
  }, function (store, version) {
    var _store$getState$nextT, _store$getState$previ;
    return String(version) + String(store.storeID) + String((_store$getState$nextT = store.getState().nextTree) === null || _store$getState$nextT === void 0 ? void 0 : _store$getState$nextT.version) + String(store.getState().currentTree.version) + String((_store$getState$previ = store.getState().previousTree) === null || _store$getState$previ === void 0 ? void 0 : _store$getState$previ.version);
  }),
  _memoizeOneWithArgsHa2 = slicedToArray_slicedToArray(_memoizeOneWithArgsHa, 2),
  memoizedCloneSnapshot = _memoizeOneWithArgsHa2[0],
  invalidateMemoizedSnapshot$2 = _memoizeOneWithArgsHa2[1]; // Avoid circular dependencies

setInvalidateMemoizedSnapshot$1(invalidateMemoizedSnapshot$2);
function cloneSnapshot(store) {
  var version = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'latest';
  var snapshot = memoizedCloneSnapshot(store, version);
  if (!snapshot.isRetained()) {
    invalidateMemoizedSnapshot$2();
    return memoizedCloneSnapshot(store, version);
  }
  return snapshot;
}
var MutableSnapshot = /*#__PURE__*/function (_Snapshot) {
  _inherits(MutableSnapshot, _Snapshot);
  var _super8 = _createSuper(MutableSnapshot);
  function MutableSnapshot(snapshot, batch) {
    var _this9;
    _classCallCheck(this, MutableSnapshot);
    _this9 = _super8.call(this, cloneStoreState(snapshot.getStore_INTERNAL(), snapshot.getStore_INTERNAL().getState().currentTree, true), snapshot.getStoreID());
    es_defineProperty(_assertThisInitialized(_this9), "_batch", void 0);
    es_defineProperty(_assertThisInitialized(_this9), "set", function (recoilState, newValueOrUpdater) {
      _this9.checkRefCount_INTERNAL();
      var store = _this9.getStore_INTERNAL(); // This batchUpdates ensures this `set` is applied immediately and you can
      // read the written value after calling `set`. I would like to remove this
      // behavior and only batch in `Snapshot.map`, but this would be a breaking
      // change potentially.

      _this9._batch(function () {
        updateRetainCount$1(store, recoilState.key, 1);
        setRecoilValue$1(_this9.getStore_INTERNAL(), recoilState, newValueOrUpdater);
      });
    });
    es_defineProperty(_assertThisInitialized(_this9), "reset", function (recoilState) {
      _this9.checkRefCount_INTERNAL();
      var store = _this9.getStore_INTERNAL(); // See note at `set` about batched updates.

      _this9._batch(function () {
        updateRetainCount$1(store, recoilState.key, 1);
        setRecoilValue$1(_this9.getStore_INTERNAL(), recoilState, DEFAULT_VALUE$1);
      });
    });
    es_defineProperty(_assertThisInitialized(_this9), "setUnvalidatedAtomValues_DEPRECATED", function (values) {
      _this9.checkRefCount_INTERNAL();
      var store = _this9.getStore_INTERNAL(); // See note at `set` about batched updates.

      batchUpdates$1(function () {
        var _iterator27 = _createForOfIteratorHelper(values.entries()),
          _step27;
        try {
          for (_iterator27.s(); !(_step27 = _iterator27.n()).done;) {
            var _step27$value = slicedToArray_slicedToArray(_step27.value, 2),
              k = _step27$value[0],
              v = _step27$value[1];
            updateRetainCount$1(store, k, 1);
            setUnvalidatedRecoilValue$1(store, new AbstractRecoilValue$2(k), v);
          }
        } catch (err) {
          _iterator27.e(err);
        } finally {
          _iterator27.f();
        }
      });
    });
    _this9._batch = batch;
    return _this9;
  }
  return _createClass(MutableSnapshot);
}(Snapshot);
var Recoil_Snapshot = {
  Snapshot: Snapshot,
  MutableSnapshot: MutableSnapshot,
  freshSnapshot: freshSnapshot,
  cloneSnapshot: cloneSnapshot
};
var Recoil_Snapshot_1 = Recoil_Snapshot.Snapshot;
var Recoil_Snapshot_2 = Recoil_Snapshot.MutableSnapshot;
var Recoil_Snapshot_3 = Recoil_Snapshot.freshSnapshot;
var Recoil_Snapshot_4 = Recoil_Snapshot.cloneSnapshot;
var Recoil_Snapshot$1 = /*#__PURE__*/Object.freeze({
  __proto__: null,
  Snapshot: Recoil_Snapshot_1,
  MutableSnapshot: Recoil_Snapshot_2,
  freshSnapshot: Recoil_Snapshot_3,
  cloneSnapshot: Recoil_Snapshot_4
});

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */

function unionSets() {
  var result = new Set();
  for (var _len4 = arguments.length, sets = new Array(_len4), _key7 = 0; _key7 < _len4; _key7++) {
    sets[_key7] = arguments[_key7];
  }
  for (var _i2 = 0, _sets = sets; _i2 < _sets.length; _i2++) {
    var set = _sets[_i2];
    var _iterator28 = _createForOfIteratorHelper(set),
      _step28;
    try {
      for (_iterator28.s(); !(_step28 = _iterator28.n()).done;) {
        var value = _step28.value;
        result.add(value);
      }
    } catch (err) {
      _iterator28.e(err);
    } finally {
      _iterator28.f();
    }
  }
  return result;
}
var Recoil_unionSets = unionSets;
var es_useRef = _react_18_2_0_react.useRef;
/**
 * The same as `useRef()` except that if a function is specified then it will
 * call that function to get the value to initialize the reference with.
 * This is similar to how `useState()` behaves when given a function.  It allows
 * the user to avoid generating the initial value for subsequent renders.
 * The tradeoff is that to set the reference to a function itself you need to
 * nest it: useRefInitOnce(() => () => {...});
 */

function useRefInitOnce(initialValue) {
  // $FlowExpectedError[incompatible-call]
  var ref = es_useRef(initialValue);
  if (ref.current === initialValue && typeof initialValue === 'function') {
    // $FlowExpectedError[incompatible-use]
    ref.current = initialValue();
  }
  return ref;
}
var Recoil_useRefInitOnce = useRefInitOnce;

// @fb-only: const RecoilusagelogEvent = require('RecoilusagelogEvent');
// @fb-only: const RecoilUsageLogFalcoEvent = require('RecoilUsageLogFalcoEvent');
// @fb-only: const URI = require('URI');

var getNextTreeStateVersion$3 = Recoil_State.getNextTreeStateVersion,
  makeEmptyStoreState$2 = Recoil_State.makeEmptyStoreState;
var cleanUpNode$2 = Recoil_FunctionalCore.cleanUpNode,
  getDownstreamNodes$2 = Recoil_FunctionalCore.getDownstreamNodes,
  initializeNode$2 = Recoil_FunctionalCore.initializeNode,
  setNodeValue$2 = Recoil_FunctionalCore.setNodeValue,
  setUnvalidatedAtomValue_DEPRECATED$1 = Recoil_FunctionalCore.setUnvalidatedAtomValue_DEPRECATED;
var graph$2 = Recoil_Graph.graph;
var cloneGraph$1 = Recoil_Graph.cloneGraph;
var getNextStoreID$2 = Recoil_Keys.getNextStoreID;
var createMutableSource$1 = Recoil_ReactMode.createMutableSource,
  reactMode$2 = Recoil_ReactMode.reactMode;
var applyAtomValueWrites$1 = Recoil_RecoilValueInterface.applyAtomValueWrites;
var releaseScheduledRetainablesNow$1 = Recoil_Retention.releaseScheduledRetainablesNow;
var freshSnapshot$1 = Recoil_Snapshot$1.freshSnapshot;
var es_useCallback = _react_18_2_0_react.useCallback,
  useContext = _react_18_2_0_react.useContext,
  es_useEffect = _react_18_2_0_react.useEffect,
  es_useMemo = _react_18_2_0_react.useMemo,
  useRef$1 = _react_18_2_0_react.useRef,
  es_useState = _react_18_2_0_react.useState;
function notInAContext() {
  throw Recoil_err('This component must be used inside a <RecoilRoot> component.');
}
var defaultStore = Object.freeze({
  storeID: getNextStoreID$2(),
  getState: notInAContext,
  replaceState: notInAContext,
  getGraph: notInAContext,
  subscribeToTransactions: notInAContext,
  addTransactionMetadata: notInAContext
});
var stateReplacerIsBeingExecuted = false;
function startNextTreeIfNeeded(store) {
  if (stateReplacerIsBeingExecuted) {
    throw Recoil_err('An atom update was triggered within the execution of a state updater function. State updater functions provided to Recoil must be pure functions.');
  }
  var storeState = store.getState();
  if (storeState.nextTree === null) {
    if (Recoil_gkx('recoil_memory_managament_2020') && Recoil_gkx('recoil_release_on_cascading_update_killswitch_2021')) {
      // If this is a cascading update (that is, rendering due to one state change
      // invokes a second state change), we won't have cleaned up retainables yet
      // because this normally happens after notifying components. Do it before
      // proceeding with the cascading update so that it remains predictable:
      if (storeState.commitDepth > 0) {
        releaseScheduledRetainablesNow$1(store);
      }
    }
    var version = storeState.currentTree.version;
    var nextVersion = getNextTreeStateVersion$3();
    storeState.nextTree = _objectSpread2(_objectSpread2({}, storeState.currentTree), {}, {
      version: nextVersion,
      stateID: nextVersion,
      dirtyAtoms: new Set(),
      transactionMetadata: {}
    });
    storeState.graphsByVersion.set(nextVersion, cloneGraph$1(Recoil_nullthrows(storeState.graphsByVersion.get(version))));
  }
}
var AppContext = _react_18_2_0_react.createContext({
  current: defaultStore
});
var useStoreRef = function useStoreRef() {
  return useContext(AppContext);
}; // $FlowExpectedError[incompatible-call]

var MutableSourceContext = _react_18_2_0_react.createContext(null);
function useRecoilMutableSource() {
  var mutableSource = useContext(MutableSourceContext);
  if (mutableSource == null) {
    Recoil_expectationViolation('Attempted to use a Recoil hook outside of a <RecoilRoot>. ' + '<RecoilRoot> must be an ancestor of any component that uses ' + 'Recoil hooks.');
  }
  return mutableSource;
}
function notifyComponents(store, storeState, treeState) {
  var dependentNodes = getDownstreamNodes$2(store, treeState, treeState.dirtyAtoms);
  var _iterator29 = _createForOfIteratorHelper(dependentNodes),
    _step29;
  try {
    for (_iterator29.s(); !(_step29 = _iterator29.n()).done;) {
      var key = _step29.value;
      var comps = storeState.nodeToComponentSubscriptions.get(key);
      if (comps) {
        var _iterator30 = _createForOfIteratorHelper(comps),
          _step30;
        try {
          for (_iterator30.s(); !(_step30 = _iterator30.n()).done;) {
            var _step30$value = slicedToArray_slicedToArray(_step30.value, 2),
              _subID = _step30$value[0],
              _step30$value$ = slicedToArray_slicedToArray(_step30$value[1], 2),
              _debugName = _step30$value$[0],
              callback = _step30$value$[1];
            callback(treeState);
          }
        } catch (err) {
          _iterator30.e(err);
        } finally {
          _iterator30.f();
        }
      }
    }
  } catch (err) {
    _iterator29.e(err);
  } finally {
    _iterator29.f();
  }
}
function sendEndOfBatchNotifications(store) {
  var storeState = store.getState();
  var treeState = storeState.currentTree; // Inform transaction subscribers of the transaction:

  var dirtyAtoms = treeState.dirtyAtoms;
  if (dirtyAtoms.size) {
    // Execute Node-specific subscribers before global subscribers
    var _iterator31 = _createForOfIteratorHelper(storeState.nodeTransactionSubscriptions),
      _step31;
    try {
      for (_iterator31.s(); !(_step31 = _iterator31.n()).done;) {
        var _step31$value = slicedToArray_slicedToArray(_step31.value, 2),
          key = _step31$value[0],
          subscriptions = _step31$value[1];
        if (dirtyAtoms.has(key)) {
          var _iterator33 = _createForOfIteratorHelper(subscriptions),
            _step33;
          try {
            for (_iterator33.s(); !(_step33 = _iterator33.n()).done;) {
              var _step33$value = slicedToArray_slicedToArray(_step33.value, 2),
                _ = _step33$value[0],
                subscription = _step33$value[1];
              subscription(store);
            }
          } catch (err) {
            _iterator33.e(err);
          } finally {
            _iterator33.f();
          }
        }
      }
    } catch (err) {
      _iterator31.e(err);
    } finally {
      _iterator31.f();
    }
    var _iterator32 = _createForOfIteratorHelper(storeState.transactionSubscriptions),
      _step32;
    try {
      for (_iterator32.s(); !(_step32 = _iterator32.n()).done;) {
        var _step32$value = slicedToArray_slicedToArray(_step32.value, 2),
          _2 = _step32$value[0],
          _subscription = _step32$value[1];
        _subscription(store);
      }
    } catch (err) {
      _iterator32.e(err);
    } finally {
      _iterator32.f();
    }
    if (!reactMode$2().early || storeState.suspendedComponentResolvers.size > 0) {
      // Notifying components is needed to wake from suspense, even when using
      // early rendering.
      notifyComponents(store, storeState, treeState); // Wake all suspended components so the right one(s) can try to re-render.
      // We need to wake up components not just when some asynchronous selector
      // resolved, but also when changing synchronous values because this may cause
      // a selector to change from asynchronous to synchronous, in which case there
      // would be no follow-up asynchronous resolution to wake us up.
      // TODO OPTIMIZATION Only wake up related downstream components

      storeState.suspendedComponentResolvers.forEach(function (cb) {
        return cb();
      });
      storeState.suspendedComponentResolvers.clear();
    }
  } // Special behavior ONLY invoked by useInterface.
  // FIXME delete queuedComponentCallbacks_DEPRECATED when deleting useInterface.

  storeState.queuedComponentCallbacks_DEPRECATED.forEach(function (cb) {
    return cb(treeState);
  });
  storeState.queuedComponentCallbacks_DEPRECATED.splice(0, storeState.queuedComponentCallbacks_DEPRECATED.length);
}
function endBatch(store) {
  var storeState = store.getState();
  storeState.commitDepth++;
  try {
    var nextTree = storeState.nextTree; // Ignore commits that are not because of Recoil transactions -- namely,
    // because something above RecoilRoot re-rendered:

    if (nextTree == null) {
      return;
    } // nextTree is now committed -- note that copying and reset occurs when
    // a transaction begins, in startNextTreeIfNeeded:

    storeState.previousTree = storeState.currentTree;
    storeState.currentTree = nextTree;
    storeState.nextTree = null;
    sendEndOfBatchNotifications(store);
    if (storeState.previousTree != null) {
      storeState.graphsByVersion.delete(storeState.previousTree.version);
    } else {
      Recoil_recoverableViolation('Ended batch with no previous state, which is unexpected', 'recoil');
    }
    storeState.previousTree = null;
    if (Recoil_gkx('recoil_memory_managament_2020')) {
      // Only release retainables if there were no writes during the end of the
      // batch.  This avoids releasing something we might be about to use.
      if (nextTree == null) {
        releaseScheduledRetainablesNow$1(store);
      }
    }
  } finally {
    storeState.commitDepth--;
  }
}
/*
 * The purpose of the Batcher is to observe when React batches end so that
 * Recoil state changes can be batched. Whenever Recoil state changes, we call
 * setState on the batcher. Then we wait for that change to be committed, which
 * signifies the end of the batch. That's when we respond to the Recoil change.
 */

function Batcher(_ref13) {
  var setNotifyBatcherOfChange = _ref13.setNotifyBatcherOfChange;
  var storeRef = useStoreRef();
  var _useState = es_useState([]),
    _useState2 = slicedToArray_slicedToArray(_useState, 2),
    setState = _useState2[1]; // $FlowFixMe[incompatible-call]

  setNotifyBatcherOfChange(function () {
    return setState({});
  });
  es_useEffect(function () {
    // $FlowFixMe[incompatible-call]
    setNotifyBatcherOfChange(function () {
      return setState({});
    }); // If an asynchronous selector resolves after the Batcher is unmounted,
    // notifyBatcherOfChange will still be called. An error gets thrown whenever
    // setState is called after a component is already unmounted, so this sets
    // notifyBatcherOfChange to be a no-op.

    return function () {
      setNotifyBatcherOfChange(function () {});
    };
  }, [setNotifyBatcherOfChange]);
  es_useEffect(function () {
    // enqueueExecution runs this function immediately; it is only used to
    // manipulate the order of useEffects during tests, since React seems to
    // call useEffect in an unpredictable order sometimes.
    Recoil_Queue.enqueueExecution('Batcher', function () {
      endBatch(storeRef.current);
    });
  });
  return null;
}
if (false) {} // When removing this deprecated function, remove stateBySettingRecoilValue
// which will no longer be needed.

function initialStoreState_DEPRECATED(store, initializeState) {
  var initial = makeEmptyStoreState$2();
  initializeState({
    set: function set(atom, value) {
      var state = initial.currentTree;
      var writes = setNodeValue$2(store, state, atom.key, value);
      var writtenNodes = new Set(writes.keys());
      var nonvalidatedAtoms = state.nonvalidatedAtoms.clone();
      var _iterator34 = _createForOfIteratorHelper(writtenNodes),
        _step34;
      try {
        for (_iterator34.s(); !(_step34 = _iterator34.n()).done;) {
          var n = _step34.value;
          nonvalidatedAtoms.delete(n);
        }
      } catch (err) {
        _iterator34.e(err);
      } finally {
        _iterator34.f();
      }
      initial.currentTree = _objectSpread2(_objectSpread2({}, state), {}, {
        dirtyAtoms: Recoil_unionSets(state.dirtyAtoms, writtenNodes),
        atomValues: applyAtomValueWrites$1(state.atomValues, writes),
        // NB: PLEASE un-export applyAtomValueWrites when deleting this code
        nonvalidatedAtoms: nonvalidatedAtoms
      });
    },
    setUnvalidatedAtomValues: function setUnvalidatedAtomValues(atomValues) {
      // FIXME replace this with a mutative loop
      atomValues.forEach(function (v, k) {
        initial.currentTree = setUnvalidatedAtomValue_DEPRECATED$1(initial.currentTree, k, v);
      });
    }
  });
  return initial;
} // Initialize state snapshot for <RecoilRoot> for the initializeState prop.
// Atom effect initialization takes precedence over this prop.
// Any atom effects will be run before initialization, but then cleaned up,
// they are then re-run when used as part of rendering.  These semantics are
// compatible with React StrictMode where effects may be re-run multiple times
// but state initialization only happens once the first time.

function initialStoreState(initializeState) {
  // Initialize a snapshot and get its store
  var snapshot = freshSnapshot$1(initializeState);
  var storeState = snapshot.getStore_INTERNAL().getState(); // Counteract the snapshot auto-release

  snapshot.retain(); // Cleanup any effects run during initialization and clear the handlers so
  // they will re-initialize if used during rendering.  This allows atom effect
  // initialization to take precedence over initializeState and be compatible
  // with StrictMode semantics.

  storeState.nodeCleanupFunctions.forEach(function (cleanup) {
    return cleanup();
  });
  storeState.nodeCleanupFunctions.clear();
  return storeState;
}
var nextID = 0;
function RecoilRoot_INTERNAL(_ref14) {
  var initializeState_DEPRECATED = _ref14.initializeState_DEPRECATED,
    initializeState = _ref14.initializeState,
    storeProp = _ref14.store_INTERNAL,
    children = _ref14.children;
  // prettier-ignore
  // @fb-only: useEffect(() => {
  // @fb-only: if (gkx('recoil_usage_logging')) {
  // @fb-only: try {
  // @fb-only: RecoilUsageLogFalcoEvent.log(() => ({
  // @fb-only: type: RecoilusagelogEvent.RECOIL_ROOT_MOUNTED,
  // @fb-only: path: URI.getRequestURI().getPath(),
  // @fb-only: }));
  // @fb-only: } catch {
  // @fb-only: recoverableViolation(
  // @fb-only: 'Error when logging Recoil Usage event',
  // @fb-only: 'recoil',
  // @fb-only: );
  // @fb-only: }
  // @fb-only: }
  // @fb-only: }, []);
  var storeStateRef; // eslint-disable-line prefer-const

  var getGraph = function getGraph(version) {
    var graphs = storeStateRef.current.graphsByVersion;
    if (graphs.has(version)) {
      return Recoil_nullthrows(graphs.get(version));
    }
    var newGraph = graph$2();
    graphs.set(version, newGraph);
    return newGraph;
  };
  var subscribeToTransactions = function subscribeToTransactions(callback, key) {
    if (key == null) {
      // Global transaction subscriptions
      var _storeRef$current$get = storeRef.current.getState(),
        transactionSubscriptions = _storeRef$current$get.transactionSubscriptions;
      var id = nextID++;
      transactionSubscriptions.set(id, callback);
      return {
        release: function release() {
          transactionSubscriptions.delete(id);
        }
      };
    } else {
      // Node-specific transaction subscriptions:
      var _storeRef$current$get2 = storeRef.current.getState(),
        nodeTransactionSubscriptions = _storeRef$current$get2.nodeTransactionSubscriptions;
      if (!nodeTransactionSubscriptions.has(key)) {
        nodeTransactionSubscriptions.set(key, new Map());
      }
      var _id2 = nextID++;
      Recoil_nullthrows(nodeTransactionSubscriptions.get(key)).set(_id2, callback);
      return {
        release: function release() {
          var subs = nodeTransactionSubscriptions.get(key);
          if (subs) {
            subs.delete(_id2);
            if (subs.size === 0) {
              nodeTransactionSubscriptions.delete(key);
            }
          }
        }
      };
    }
  };
  var addTransactionMetadata = function addTransactionMetadata(metadata) {
    startNextTreeIfNeeded(storeRef.current);
    for (var _i3 = 0, _Object$keys = Object.keys(metadata); _i3 < _Object$keys.length; _i3++) {
      var k = _Object$keys[_i3];
      Recoil_nullthrows(storeRef.current.getState().nextTree).transactionMetadata[k] = metadata[k];
    }
  };
  var replaceState = function replaceState(replacer) {
    startNextTreeIfNeeded(storeRef.current); // Use replacer to get the next state:

    var nextTree = Recoil_nullthrows(storeStateRef.current.nextTree);
    var replaced;
    try {
      stateReplacerIsBeingExecuted = true;
      replaced = replacer(nextTree);
    } finally {
      stateReplacerIsBeingExecuted = false;
    }
    if (replaced === nextTree) {
      return;
    }
    if (false) {} // Save changes to nextTree and schedule a React update:

    storeStateRef.current.nextTree = replaced;
    if (reactMode$2().early) {
      notifyComponents(storeRef.current, storeStateRef.current, replaced);
    }
    Recoil_nullthrows(notifyBatcherOfChange.current)();
  };
  var notifyBatcherOfChange = useRef$1(null);
  var setNotifyBatcherOfChange = es_useCallback(function (x) {
    notifyBatcherOfChange.current = x;
  }, [notifyBatcherOfChange]);
  var storeRef = Recoil_useRefInitOnce(function () {
    return storeProp !== null && storeProp !== void 0 ? storeProp : {
      storeID: getNextStoreID$2(),
      getState: function getState() {
        return storeStateRef.current;
      },
      replaceState: replaceState,
      getGraph: getGraph,
      subscribeToTransactions: subscribeToTransactions,
      addTransactionMetadata: addTransactionMetadata
    };
  });
  if (storeProp != null) {
    storeRef.current = storeProp;
  }
  storeStateRef = Recoil_useRefInitOnce(function () {
    return initializeState_DEPRECATED != null ? initialStoreState_DEPRECATED(storeRef.current, initializeState_DEPRECATED) : initializeState != null ? initialStoreState(initializeState) : makeEmptyStoreState$2();
  });
  var mutableSource = es_useMemo(function () {
    return createMutableSource$1 === null || createMutableSource$1 === void 0 ? void 0 : createMutableSource$1(storeStateRef, function () {
      return storeStateRef.current.currentTree.version;
    });
  }, [storeStateRef]); // Cleanup when the <RecoilRoot> is unmounted

  es_useEffect(function () {
    // React is free to call effect cleanup handlers and effects at will, the
    // deps array is only an optimization.  For example, React strict mode
    // will execute each effect twice for testing.  Therefore, we need symmetry
    // to re-initialize all known atoms after they were cleaned up.
    var store = storeRef.current;
    var _iterator35 = _createForOfIteratorHelper(new Set(store.getState().knownAtoms)),
      _step35;
    try {
      for (_iterator35.s(); !(_step35 = _iterator35.n()).done;) {
        var atomKey = _step35.value;
        initializeNode$2(store, atomKey, 'get');
      }
    } catch (err) {
      _iterator35.e(err);
    } finally {
      _iterator35.f();
    }
    return function () {
      var _iterator36 = _createForOfIteratorHelper(store.getState().knownAtoms),
        _step36;
      try {
        for (_iterator36.s(); !(_step36 = _iterator36.n()).done;) {
          var atomKey = _step36.value;
          cleanUpNode$2(store, atomKey);
        }
      } catch (err) {
        _iterator36.e(err);
      } finally {
        _iterator36.f();
      }
    };
  }, [storeRef]);
  return /*#__PURE__*/_react_18_2_0_react.createElement(AppContext.Provider, {
    value: storeRef
  }, /*#__PURE__*/_react_18_2_0_react.createElement(MutableSourceContext.Provider, {
    value: mutableSource
  }, /*#__PURE__*/_react_18_2_0_react.createElement(Batcher, {
    setNotifyBatcherOfChange: setNotifyBatcherOfChange
  }), children));
}
function es_RecoilRoot(props) {
  var override = props.override,
    propsExceptOverride = _objectWithoutProperties(props, es_excluded);
  var ancestorStoreRef = useStoreRef();
  if (override === false && ancestorStoreRef.current !== defaultStore) {
    // If ancestorStoreRef.current !== defaultStore, it means that this
    // RecoilRoot is not nested within another.
    return props.children;
  }
  return /*#__PURE__*/_react_18_2_0_react.createElement(RecoilRoot_INTERNAL, propsExceptOverride);
}
function useRecoilStoreID() {
  return useStoreRef().current.storeID;
}
var Recoil_RecoilRoot = {
  RecoilRoot: es_RecoilRoot,
  useStoreRef: useStoreRef,
  useRecoilMutableSource: useRecoilMutableSource,
  useRecoilStoreID: useRecoilStoreID,
  notifyComponents_FOR_TESTING: notifyComponents,
  sendEndOfBatchNotifications_FOR_TESTING: sendEndOfBatchNotifications
};

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */

function shallowArrayEqual(a, b) {
  if (a === b) {
    return true;
  }
  if (a.length !== b.length) {
    return false;
  }
  for (var i = 0, l = a.length; i < l; i++) {
    if (a[i] !== b[i]) {
      return false;
    }
  }
  return true;
}
var Recoil_shallowArrayEqual = shallowArrayEqual;
var useEffect$1 = _react_18_2_0_react.useEffect,
  useRef$2 = _react_18_2_0_react.useRef;
function usePrevious(value) {
  var ref = useRef$2();
  useEffect$1(function () {
    // $FlowFixMe[incompatible-type]
    ref.current = value;
  });
  return ref.current;
}
var Recoil_usePrevious = usePrevious;
var useStoreRef$1 = Recoil_RecoilRoot.useStoreRef;
var SUSPENSE_TIMEOUT_MS$1 = Recoil_Retention.SUSPENSE_TIMEOUT_MS;
var updateRetainCount$2 = Recoil_Retention.updateRetainCount;
var RetentionZone$3 = Recoil_RetentionZone.RetentionZone;
var useEffect$2 = _react_18_2_0_react.useEffect,
  useRef$3 = _react_18_2_0_react.useRef;
var isSSR$2 = Recoil_Environment.isSSR;

// I don't see a way to avoid the any type here because we want to accept readable
// and writable values with any type parameter, but normally with writable ones
// RecoilState<SomeT> is not a subtype of RecoilState<mixed>.

// flowlint-line unclear-type:off
function useRetain(toRetain) {
  if (!Recoil_gkx('recoil_memory_managament_2020')) {
    return;
  } // eslint-disable-next-line fb-www/react-hooks

  return useRetain_ACTUAL(toRetain);
}
function useRetain_ACTUAL(toRetain) {
  var array = Array.isArray(toRetain) ? toRetain : [toRetain];
  var retainables = array.map(function (a) {
    return a instanceof RetentionZone$3 ? a : a.key;
  });
  var storeRef = useStoreRef$1();
  useEffect$2(function () {
    if (!Recoil_gkx('recoil_memory_managament_2020')) {
      return;
    }
    var store = storeRef.current;
    if (timeoutID.current && !isSSR$2) {
      // Already performed a temporary retain on render, simply cancel the release
      // of that temporary retain.
      window.clearTimeout(timeoutID.current);
      timeoutID.current = null;
    } else {
      var _iterator37 = _createForOfIteratorHelper(retainables),
        _step37;
      try {
        for (_iterator37.s(); !(_step37 = _iterator37.n()).done;) {
          var r = _step37.value;
          updateRetainCount$2(store, r, 1);
        }
      } catch (err) {
        _iterator37.e(err);
      } finally {
        _iterator37.f();
      }
    }
    return function () {
      var _iterator38 = _createForOfIteratorHelper(retainables),
        _step38;
      try {
        for (_iterator38.s(); !(_step38 = _iterator38.n()).done;) {
          var _r = _step38.value;
          updateRetainCount$2(store, _r, -1);
        }
      } catch (err) {
        _iterator38.e(err);
      } finally {
        _iterator38.f();
      }
    }; // eslint-disable-next-line fb-www/react-hooks-deps
  }, [storeRef].concat(_toConsumableArray(retainables))); // We want to retain if the component suspends. This is terrible but the Suspense
  // API affords us no better option. If we suspend and never commit after some
  // seconds, then release. The 'actual' retain/release in the effect above
  // cancels this.

  var timeoutID = useRef$3();
  var previousRetainables = Recoil_usePrevious(retainables);
  if (!isSSR$2 && (previousRetainables === undefined || !Recoil_shallowArrayEqual(previousRetainables, retainables))) {
    var store = storeRef.current;
    var _iterator39 = _createForOfIteratorHelper(retainables),
      _step39;
    try {
      for (_iterator39.s(); !(_step39 = _iterator39.n()).done;) {
        var _r3 = _step39.value;
        updateRetainCount$2(store, _r3, 1);
      }
    } catch (err) {
      _iterator39.e(err);
    } finally {
      _iterator39.f();
    }
    if (previousRetainables) {
      var _iterator40 = _createForOfIteratorHelper(previousRetainables),
        _step40;
      try {
        for (_iterator40.s(); !(_step40 = _iterator40.n()).done;) {
          var r = _step40.value;
          updateRetainCount$2(store, r, -1);
        }
      } catch (err) {
        _iterator40.e(err);
      } finally {
        _iterator40.f();
      }
    }
    if (timeoutID.current) {
      window.clearTimeout(timeoutID.current);
    }
    timeoutID.current = window.setTimeout(function () {
      timeoutID.current = null;
      var _iterator41 = _createForOfIteratorHelper(retainables),
        _step41;
      try {
        for (_iterator41.s(); !(_step41 = _iterator41.n()).done;) {
          var _r2 = _step41.value;
          updateRetainCount$2(store, _r2, -1);
        }
      } catch (err) {
        _iterator41.e(err);
      } finally {
        _iterator41.f();
      }
    }, SUSPENSE_TIMEOUT_MS$1);
  }
}
var Recoil_useRetain = useRetain;

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
/**
 * THIS CODE HAS BEEN COMMENTED OUT INTENTIONALLY
 *
 * This technique of getting the component name is imperfect, since it both only
 * works in a non-minified code base, and more importantly introduces performance
 * problems since it relies in throwing errors which is an expensive operation.
 *
 * At some point we may want to reevaluate this technique hence why we have commented
 * this code out, rather than delete it all together.
 */
// const {useRef} = require('react');
// const gkx = require('recoil-shared/util/Recoil_gkx');
// const stackTraceParser = require('recoil-shared/util/Recoil_stackTraceParser');

function useComponentName() {
  // const nameRef = useRef();
  // if (__DEV__) {
  //   if (gkx('recoil_infer_component_names')) {
  //     if (nameRef.current === undefined) {
  //       // There is no blessed way to determine the calling React component from
  //       // within a hook. This hack uses the fact that hooks must start with 'use'
  //       // and that hooks are either called by React Components or other hooks. It
  //       // follows therefore, that to find the calling component, you simply need
  //       // to look down the stack and find the first function which doesn't start
  //       // with 'use'. We are only enabling this in dev for now, since once the
  //       // codebase is minified, the naming assumptions no longer hold true.
  //       // eslint-disable-next-line fb-www/no-new-error
  //       const frames = stackTraceParser(new Error().stack);
  //       for (const {methodName} of frames) {
  //         // I observed cases where the frame was of the form 'Object.useXXX'
  //         // hence why I'm searching for hooks following a word boundary
  //         if (!methodName.match(/\buse[^\b]+$/)) {
  //           return (nameRef.current = methodName);
  //         }
  //       }
  //       nameRef.current = null;
  //     }
  //     return nameRef.current ?? '<unable to determine component name>';
  //   }
  // }
  // @fb-only: return "<component name only available when both in dev mode and when passing GK 'recoil_infer_component_names'>";
  return '<component name not available>'; // @oss-only
}

var Recoil_useComponentName = useComponentName;
var batchUpdates$2 = Recoil_Batching.batchUpdates;
var DEFAULT_VALUE$2 = Recoil_Node.DEFAULT_VALUE;
var currentRendererSupportsUseSyncExternalStore$1 = Recoil_ReactMode.currentRendererSupportsUseSyncExternalStore,
  reactMode$3 = Recoil_ReactMode.reactMode,
  useMutableSource$1 = Recoil_ReactMode.useMutableSource,
  useSyncExternalStore$1 = Recoil_ReactMode.useSyncExternalStore;
var useRecoilMutableSource$1 = Recoil_RecoilRoot.useRecoilMutableSource,
  useStoreRef$2 = Recoil_RecoilRoot.useStoreRef;
var isRecoilValue$2 = Recoil_RecoilValue$1.isRecoilValue;
var AbstractRecoilValue$3 = Recoil_RecoilValueInterface.AbstractRecoilValue,
  getRecoilValueAsLoadable$2 = Recoil_RecoilValueInterface.getRecoilValueAsLoadable,
  setRecoilValue$2 = Recoil_RecoilValueInterface.setRecoilValue,
  setUnvalidatedRecoilValue$2 = Recoil_RecoilValueInterface.setUnvalidatedRecoilValue,
  subscribeToRecoilValue$1 = Recoil_RecoilValueInterface.subscribeToRecoilValue;
var useCallback$1 = _react_18_2_0_react.useCallback,
  useEffect$3 = _react_18_2_0_react.useEffect,
  useMemo$1 = _react_18_2_0_react.useMemo,
  useRef$4 = _react_18_2_0_react.useRef,
  useState$1 = _react_18_2_0_react.useState;
var setByAddingToSet$2 = Recoil_CopyOnWrite.setByAddingToSet;
var isSSR$3 = Recoil_Environment.isSSR;
function handleLoadable(loadable, recoilValue, storeRef) {
  // We can't just throw the promise we are waiting on to Suspense.  If the
  // upstream dependencies change it may produce a state in which the component
  // can render, but it would still be suspended on a Promise that may never resolve.
  if (loadable.state === 'hasValue') {
    return loadable.contents;
  } else if (loadable.state === 'loading') {
    var promise = new Promise(function (resolve) {
      var suspendedComponentResolvers = storeRef.current.getState().suspendedComponentResolvers;
      suspendedComponentResolvers.add(resolve); // SSR should clear out the wake-up resolver if the Promise is resolved
      // to avoid infinite loops.  (See https://github.com/facebookexperimental/Recoil/pull/2073)

      if (isSSR$3 && Recoil_isPromise(loadable.contents)) {
        loadable.contents.finally(function () {
          suspendedComponentResolvers.delete(resolve);
        });
      }
    }); // $FlowExpectedError Flow(prop-missing) for integrating with tools that inspect thrown promises @fb-only
    // @fb-only: promise.displayName = `Recoil State: ${recoilValue.key}`;

    throw promise;
  } else if (loadable.state === 'hasError') {
    throw loadable.contents;
  } else {
    throw Recoil_err("Invalid value of loadable atom \"".concat(recoilValue.key, "\""));
  }
}
function validateRecoilValue(recoilValue, hookName // $FlowFixMe[missing-local-annot]
) {
  if (!isRecoilValue$2(recoilValue)) {
    throw Recoil_err("Invalid argument to ".concat(hookName, ": expected an atom or selector but got ").concat(String(recoilValue)));
  }
}

/**
 * Various things are broken with useRecoilInterface, particularly concurrent
 * mode, React strict mode, and memory management. They will not be fixed.
 * */
function useRecoilInterface_DEPRECATED() {
  var componentName = Recoil_useComponentName();
  var storeRef = useStoreRef$2(); // eslint-disable-next-line fb-www/react-no-unused-state-hook

  var _useState$ = useState$1([]),
    _useState$2 = slicedToArray_slicedToArray(_useState$, 2),
    forceUpdate = _useState$2[1];
  var recoilValuesUsed = useRef$4(new Set());
  recoilValuesUsed.current = new Set(); // Track the RecoilValues used just during this render

  var previousSubscriptions = useRef$4(new Set());
  var subscriptions = useRef$4(new Map());
  var unsubscribeFrom = useCallback$1(function (key) {
    var sub = subscriptions.current.get(key);
    if (sub) {
      sub.release();
      subscriptions.current.delete(key);
    }
  }, [subscriptions]);
  var updateState = useCallback$1(function (_state, key) {
    if (subscriptions.current.has(key)) {
      forceUpdate([]);
    }
  }, []); // Effect to add/remove subscriptions as nodes are used

  useEffect$3(function () {
    var store = storeRef.current;
    Recoil_differenceSets(recoilValuesUsed.current, previousSubscriptions.current).forEach(function (key) {
      if (subscriptions.current.has(key)) {
        Recoil_expectationViolation("Double subscription to RecoilValue \"".concat(key, "\""));
        return;
      }
      var sub = subscribeToRecoilValue$1(store, new AbstractRecoilValue$3(key), function (state) {
        return updateState(state, key);
      }, componentName);
      subscriptions.current.set(key, sub);
      /**
       * Since we're subscribing in an effect we need to update to the latest
       * value of the atom since it may have changed since we rendered. We can
       * go ahead and do that now, unless we're in the middle of a batch --
       * in which case we should do it at the end of the batch, due to the
       * following edge case: Suppose an atom is updated in another useEffect
       * of this same component. Then the following sequence of events occur:
       * 1. Atom is updated and subs fired (but we may not be subscribed
       *    yet depending on order of effects, so we miss this) Updated value
       *    is now in nextTree, but not currentTree.
       * 2. This effect happens. We subscribe and update.
       * 3. From the update we re-render and read currentTree, with old value.
       * 4. Batcher's effect sets currentTree to nextTree.
       * In this sequence we miss the update. To avoid that, add the update
       * to queuedComponentCallback if a batch is in progress.
       */
      // FIXME delete queuedComponentCallbacks_DEPRECATED when deleting useInterface.

      var state = store.getState();
      if (state.nextTree) {
        store.getState().queuedComponentCallbacks_DEPRECATED.push(function () {
          updateState(store.getState(), key);
        });
      } else {
        updateState(store.getState(), key);
      }
    });
    Recoil_differenceSets(previousSubscriptions.current, recoilValuesUsed.current).forEach(function (key) {
      unsubscribeFrom(key);
    });
    previousSubscriptions.current = recoilValuesUsed.current;
  }); // Effect to unsubscribe from all when unmounting

  useEffect$3(function () {
    var currentSubscriptions = subscriptions.current; // Restore subscriptions that were cleared due to StrictMode running this effect twice

    Recoil_differenceSets(recoilValuesUsed.current, new Set(currentSubscriptions.keys())).forEach(function (key) {
      var sub = subscribeToRecoilValue$1(storeRef.current, new AbstractRecoilValue$3(key), function (state) {
        return updateState(state, key);
      }, componentName);
      currentSubscriptions.set(key, sub);
    });
    return function () {
      return currentSubscriptions.forEach(function (_, key) {
        return unsubscribeFrom(key);
      });
    };
  }, [componentName, storeRef, unsubscribeFrom, updateState]);
  return useMemo$1(function () {
    // eslint-disable-next-line no-shadow
    function useSetRecoilState(recoilState) {
      if (false) {}
      return function (newValueOrUpdater) {
        setRecoilValue$2(storeRef.current, recoilState, newValueOrUpdater);
      };
    } // eslint-disable-next-line no-shadow

    function useResetRecoilState(recoilState) {
      if (false) {}
      return function () {
        return setRecoilValue$2(storeRef.current, recoilState, DEFAULT_VALUE$2);
      };
    } // eslint-disable-next-line no-shadow

    function useRecoilValueLoadable(recoilValue) {
      var _storeState$nextTree;
      if (false) {}
      if (!recoilValuesUsed.current.has(recoilValue.key)) {
        recoilValuesUsed.current = setByAddingToSet$2(recoilValuesUsed.current, recoilValue.key);
      } // TODO Restore optimization to memoize lookup

      var storeState = storeRef.current.getState();
      return getRecoilValueAsLoadable$2(storeRef.current, recoilValue, reactMode$3().early ? (_storeState$nextTree = storeState.nextTree) !== null && _storeState$nextTree !== void 0 ? _storeState$nextTree : storeState.currentTree : storeState.currentTree);
    } // eslint-disable-next-line no-shadow

    function useRecoilValue(recoilValue) {
      if (false) {}
      var loadable = useRecoilValueLoadable(recoilValue);
      return handleLoadable(loadable, recoilValue, storeRef);
    } // eslint-disable-next-line no-shadow

    function useRecoilState(recoilState) {
      if (false) {}
      return [useRecoilValue(recoilState), useSetRecoilState(recoilState)];
    } // eslint-disable-next-line no-shadow

    function useRecoilStateLoadable(recoilState) {
      if (false) {}
      return [useRecoilValueLoadable(recoilState), useSetRecoilState(recoilState)];
    }
    return {
      getRecoilValue: useRecoilValue,
      getRecoilValueLoadable: useRecoilValueLoadable,
      getRecoilState: useRecoilState,
      getRecoilStateLoadable: useRecoilStateLoadable,
      getSetRecoilState: useSetRecoilState,
      getResetRecoilState: useResetRecoilState
    };
  }, [recoilValuesUsed, storeRef]);
}
var recoilComponentGetRecoilValueCount_FOR_TESTING = {
  current: 0
};
function useRecoilValueLoadable_SYNC_EXTERNAL_STORE(recoilValue) {
  var storeRef = useStoreRef$2();
  var componentName = Recoil_useComponentName();
  var getSnapshot = useCallback$1(function () {
    var _storeState$nextTree2;
    if (false) {}
    var store = storeRef.current;
    var storeState = store.getState();
    var treeState = reactMode$3().early ? (_storeState$nextTree2 = storeState.nextTree) !== null && _storeState$nextTree2 !== void 0 ? _storeState$nextTree2 : storeState.currentTree : storeState.currentTree;
    var loadable = getRecoilValueAsLoadable$2(store, recoilValue, treeState);
    return {
      loadable: loadable,
      key: recoilValue.key
    };
  }, [storeRef, recoilValue]); // Memoize the state to avoid unnecessary rerenders

  var memoizePreviousSnapshot = useCallback$1(function (getState) {
    var prevState;
    return function () {
      var _prevState, _prevState2;
      var nextState = getState();
      if ((_prevState = prevState) !== null && _prevState !== void 0 && _prevState.loadable.is(nextState.loadable) && ((_prevState2 = prevState) === null || _prevState2 === void 0 ? void 0 : _prevState2.key) === nextState.key) {
        return prevState;
      }
      prevState = nextState;
      return nextState;
    };
  }, []);
  var getMemoizedSnapshot = useMemo$1(function () {
    return memoizePreviousSnapshot(getSnapshot);
  }, [getSnapshot, memoizePreviousSnapshot]);
  var subscribe = useCallback$1(function (notify) {
    var store = storeRef.current;
    var subscription = subscribeToRecoilValue$1(store, recoilValue, notify, componentName);
    return subscription.release;
  }, [storeRef, recoilValue, componentName]);
  return useSyncExternalStore$1(subscribe, getMemoizedSnapshot,
  // getSnapshot()
  getMemoizedSnapshot // getServerSnapshot() for SSR support
  ).loadable;
}
function useRecoilValueLoadable_MUTABLE_SOURCE(recoilValue) {
  var storeRef = useStoreRef$2();
  var getLoadable = useCallback$1(function () {
    var _storeState$nextTree3;
    var store = storeRef.current;
    var storeState = store.getState();
    var treeState = reactMode$3().early ? (_storeState$nextTree3 = storeState.nextTree) !== null && _storeState$nextTree3 !== void 0 ? _storeState$nextTree3 : storeState.currentTree : storeState.currentTree;
    return getRecoilValueAsLoadable$2(store, recoilValue, treeState);
  }, [storeRef, recoilValue]);
  var getLoadableWithTesting = useCallback$1(function () {
    if (false) {}
    return getLoadable();
  }, [getLoadable]);
  var componentName = Recoil_useComponentName();
  var subscribe = useCallback$1(function (_storeState, notify) {
    var store = storeRef.current;
    var subscription = subscribeToRecoilValue$1(store, recoilValue, function () {
      if (!Recoil_gkx('recoil_suppress_rerender_in_callback')) {
        return notify();
      } // Only re-render if the value has changed.
      // This will evaluate the atom/selector now as well as when the
      // component renders, but that may help with prefetching.

      var newLoadable = getLoadable();
      if (!prevLoadableRef.current.is(newLoadable)) {
        notify();
      } // If the component is suspended then the effect setting prevLoadableRef
      // will not run.  So, set the previous value here when its subscription
      // is fired to wake it up.  We can't just rely on this, though, because
      // this only executes when an atom/selector is dirty and the atom/selector
      // passed to the hook can dynamically change.

      prevLoadableRef.current = newLoadable;
    }, componentName);
    return subscription.release;
  }, [storeRef, recoilValue, componentName, getLoadable]);
  var source = useRecoilMutableSource$1();
  if (source == null) {
    throw Recoil_err('Recoil hooks must be used in components contained within a <RecoilRoot> component.');
  }
  var loadable = useMutableSource$1(source, getLoadableWithTesting, subscribe);
  var prevLoadableRef = useRef$4(loadable);
  useEffect$3(function () {
    prevLoadableRef.current = loadable;
  });
  return loadable;
}
function useRecoilValueLoadable_TRANSITION_SUPPORT(recoilValue) {
  var storeRef = useStoreRef$2();
  var componentName = Recoil_useComponentName(); // Accessors to get the current state

  var getLoadable = useCallback$1(function () {
    var _storeState$nextTree4;
    if (false) {}
    var store = storeRef.current;
    var storeState = store.getState();
    var treeState = reactMode$3().early ? (_storeState$nextTree4 = storeState.nextTree) !== null && _storeState$nextTree4 !== void 0 ? _storeState$nextTree4 : storeState.currentTree : storeState.currentTree;
    return getRecoilValueAsLoadable$2(store, recoilValue, treeState);
  }, [storeRef, recoilValue]);
  var getState = useCallback$1(function () {
    return {
      loadable: getLoadable(),
      key: recoilValue.key
    };
  }, [getLoadable, recoilValue.key]); // Memoize state snapshots

  var updateState = useCallback$1(function (prevState) {
    var nextState = getState();
    return prevState.loadable.is(nextState.loadable) && prevState.key === nextState.key ? prevState : nextState;
  }, [getState]); // Subscribe to Recoil state changes

  useEffect$3(function () {
    var subscription = subscribeToRecoilValue$1(storeRef.current, recoilValue, function (_state) {
      setState(updateState);
    }, componentName); // Update state in case we are using a different key

    setState(updateState);
    return subscription.release;
  }, [componentName, recoilValue, storeRef, updateState]); // Get the current state

  var _useState$3 = useState$1(getState),
    _useState$4 = slicedToArray_slicedToArray(_useState$3, 2),
    state = _useState$4[0],
    setState = _useState$4[1]; // If we changed keys, then return the state for the new key.
  // This is important in case the old key would cause the component to suspend.
  // We don't have to set the new state here since the subscribing effect above
  // will do that.

  return state.key !== recoilValue.key ? getState().loadable : state.loadable;
}
function useRecoilValueLoadable_LEGACY(recoilValue) {
  var storeRef = useStoreRef$2(); // eslint-disable-next-line fb-www/react-no-unused-state-hook

  var _useState$5 = useState$1([]),
    _useState$6 = slicedToArray_slicedToArray(_useState$5, 2),
    forceUpdate = _useState$6[1];
  var componentName = Recoil_useComponentName();
  var getLoadable = useCallback$1(function () {
    var _storeState$nextTree5;
    if (false) {}
    var store = storeRef.current;
    var storeState = store.getState();
    var treeState = reactMode$3().early ? (_storeState$nextTree5 = storeState.nextTree) !== null && _storeState$nextTree5 !== void 0 ? _storeState$nextTree5 : storeState.currentTree : storeState.currentTree;
    return getRecoilValueAsLoadable$2(store, recoilValue, treeState);
  }, [storeRef, recoilValue]);
  var loadable = getLoadable();
  var prevLoadableRef = useRef$4(loadable);
  useEffect$3(function () {
    prevLoadableRef.current = loadable;
  });
  useEffect$3(function () {
    var store = storeRef.current;
    var storeState = store.getState();
    var subscription = subscribeToRecoilValue$1(store, recoilValue, function (_state) {
      var _prevLoadableRef$curr;
      if (!Recoil_gkx('recoil_suppress_rerender_in_callback')) {
        return forceUpdate([]);
      }
      var newLoadable = getLoadable();
      if (!((_prevLoadableRef$curr = prevLoadableRef.current) !== null && _prevLoadableRef$curr !== void 0 && _prevLoadableRef$curr.is(newLoadable))) {
        // $FlowFixMe[incompatible-call]
        forceUpdate(newLoadable);
      }
      prevLoadableRef.current = newLoadable;
    }, componentName);
    /**
     * Since we're subscribing in an effect we need to update to the latest
     * value of the atom since it may have changed since we rendered. We can
     * go ahead and do that now, unless we're in the middle of a batch --
     * in which case we should do it at the end of the batch, due to the
     * following edge case: Suppose an atom is updated in another useEffect
     * of this same component. Then the following sequence of events occur:
     * 1. Atom is updated and subs fired (but we may not be subscribed
     *    yet depending on order of effects, so we miss this) Updated value
     *    is now in nextTree, but not currentTree.
     * 2. This effect happens. We subscribe and update.
     * 3. From the update we re-render and read currentTree, with old value.
     * 4. Batcher's effect sets currentTree to nextTree.
     * In this sequence we miss the update. To avoid that, add the update
     * to queuedComponentCallback if a batch is in progress.
     */

    if (storeState.nextTree) {
      store.getState().queuedComponentCallbacks_DEPRECATED.push(function () {
        // $FlowFixMe[incompatible-type]
        prevLoadableRef.current = null;
        forceUpdate([]);
      });
    } else {
      var _prevLoadableRef$curr2;
      if (!Recoil_gkx('recoil_suppress_rerender_in_callback')) {
        return forceUpdate([]);
      }
      var newLoadable = getLoadable();
      if (!((_prevLoadableRef$curr2 = prevLoadableRef.current) !== null && _prevLoadableRef$curr2 !== void 0 && _prevLoadableRef$curr2.is(newLoadable))) {
        // $FlowFixMe[incompatible-call]
        forceUpdate(newLoadable);
      }
      prevLoadableRef.current = newLoadable;
    }
    return subscription.release;
  }, [componentName, getLoadable, recoilValue, storeRef]);
  return loadable;
}
/**
  Like useRecoilValue(), but either returns the value if available or
  just undefined if not available for any reason, such as pending or error.
*/

function useRecoilValueLoadable(recoilValue) {
  if (false) {}
  if (Recoil_gkx('recoil_memory_managament_2020')) {
    // eslint-disable-next-line fb-www/react-hooks
    Recoil_useRetain(recoilValue);
  }
  return {
    TRANSITION_SUPPORT: useRecoilValueLoadable_TRANSITION_SUPPORT,
    // Recoil will attemp to detect if `useSyncExternalStore()` is supported with
    // `reactMode()` before calling it.  However, sometimes the host React
    // environment supports it but uses additional React renderers (such as with
    // `react-three-fiber`) which do not.  While this is technically a user issue
    // by using a renderer with React 18+ that doesn't fully support React 18 we
    // don't want to break users if it can be avoided. As the current renderer can
    // change at runtime, we need to dynamically check and fallback if necessary.
    SYNC_EXTERNAL_STORE: currentRendererSupportsUseSyncExternalStore$1() ? useRecoilValueLoadable_SYNC_EXTERNAL_STORE : useRecoilValueLoadable_TRANSITION_SUPPORT,
    MUTABLE_SOURCE: useRecoilValueLoadable_MUTABLE_SOURCE,
    LEGACY: useRecoilValueLoadable_LEGACY
  }[reactMode$3().mode](recoilValue);
}
/**
  Returns the value represented by the RecoilValue.
  If the value is pending, it will throw a Promise to suspend the component,
  if the value is an error it will throw it for the nearest React error boundary.
  This will also subscribe the component for any updates in the value.
  */

function es_useRecoilValue(recoilValue) {
  if (false) {}
  var storeRef = useStoreRef$2();
  var loadable = useRecoilValueLoadable(recoilValue);
  return handleLoadable(loadable, recoilValue, storeRef);
}
/**
  Returns a function that allows the value of a RecoilState to be updated, but does
  not subscribe the component to changes to that RecoilState.
*/

function es_useSetRecoilState(recoilState) {
  if (false) {}
  var storeRef = useStoreRef$2();
  return useCallback$1(function (newValueOrUpdater) {
    setRecoilValue$2(storeRef.current, recoilState, newValueOrUpdater);
  }, [storeRef, recoilState]);
}
/**
  Returns a function that will reset the value of a RecoilState to its default
*/

function useResetRecoilState(recoilState) {
  if (false) {}
  var storeRef = useStoreRef$2();
  return useCallback$1(function () {
    setRecoilValue$2(storeRef.current, recoilState, DEFAULT_VALUE$2);
  }, [storeRef, recoilState]);
}
/**
  Equivalent to useState(). Allows the value of the RecoilState to be read and written.
  Subsequent updates to the RecoilState will cause the component to re-render. If the
  RecoilState is pending, this will suspend the component and initiate the
  retrieval of the value. If evaluating the RecoilState resulted in an error, this will
  throw the error so that the nearest React error boundary can catch it.
*/

function es_useRecoilState(recoilState) {
  if (false) {}
  return [es_useRecoilValue(recoilState), es_useSetRecoilState(recoilState)];
}
/**
  Like useRecoilState(), but does not cause Suspense or React error handling. Returns
  an object that indicates whether the RecoilState is available, pending, or
  unavailable due to an error.
*/

function useRecoilStateLoadable(recoilState) {
  if (false) {}
  return [useRecoilValueLoadable(recoilState), es_useSetRecoilState(recoilState)];
}
function useSetUnvalidatedAtomValues() {
  var storeRef = useStoreRef$2();
  return function (values) {
    var transactionMetadata = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    batchUpdates$2(function () {
      storeRef.current.addTransactionMetadata(transactionMetadata);
      values.forEach(function (value, key) {
        return setUnvalidatedRecoilValue$2(storeRef.current, new AbstractRecoilValue$3(key), value);
      });
    });
  };
}
/**
 * Experimental variants of hooks with support for useTransition()
 */

function useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE(recoilValue) {
  if (false) {}
  if (Recoil_gkx('recoil_memory_managament_2020')) {
    // eslint-disable-next-line fb-www/react-hooks
    Recoil_useRetain(recoilValue);
  }
  return useRecoilValueLoadable_TRANSITION_SUPPORT(recoilValue);
}
function useRecoilValue_TRANSITION_SUPPORT_UNSTABLE(recoilValue) {
  if (false) {}
  var storeRef = useStoreRef$2();
  var loadable = useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE(recoilValue);
  return handleLoadable(loadable, recoilValue, storeRef);
}
function useRecoilState_TRANSITION_SUPPORT_UNSTABLE(recoilState) {
  if (false) {}
  return [useRecoilValue_TRANSITION_SUPPORT_UNSTABLE(recoilState), es_useSetRecoilState(recoilState)];
}
var Recoil_Hooks = {
  recoilComponentGetRecoilValueCount_FOR_TESTING: recoilComponentGetRecoilValueCount_FOR_TESTING,
  useRecoilInterface: useRecoilInterface_DEPRECATED,
  useRecoilState: es_useRecoilState,
  useRecoilStateLoadable: useRecoilStateLoadable,
  useRecoilValue: es_useRecoilValue,
  useRecoilValueLoadable: useRecoilValueLoadable,
  useResetRecoilState: useResetRecoilState,
  useSetRecoilState: es_useSetRecoilState,
  useSetUnvalidatedAtomValues: useSetUnvalidatedAtomValues,
  useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE: useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE,
  useRecoilValue_TRANSITION_SUPPORT_UNSTABLE: useRecoilValue_TRANSITION_SUPPORT_UNSTABLE,
  useRecoilState_TRANSITION_SUPPORT_UNSTABLE: useRecoilState_TRANSITION_SUPPORT_UNSTABLE
};

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
/**
 * Returns a map containing all of the keys + values from the original map where
 * the given callback returned true.
 */

function filterMap(map, callback) {
  var result = new Map();
  var _iterator42 = _createForOfIteratorHelper(map),
    _step42;
  try {
    for (_iterator42.s(); !(_step42 = _iterator42.n()).done;) {
      var _step42$value = slicedToArray_slicedToArray(_step42.value, 2),
        key = _step42$value[0],
        value = _step42$value[1];
      if (callback(value, key)) {
        result.set(key, value);
      }
    }
  } catch (err) {
    _iterator42.e(err);
  } finally {
    _iterator42.f();
  }
  return result;
}
var Recoil_filterMap = filterMap;

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
/**
 * Returns a set containing all of the values from the original set where
 * the given callback returned true.
 */

function filterSet(set, callback) {
  var result = new Set();
  var _iterator43 = _createForOfIteratorHelper(set),
    _step43;
  try {
    for (_iterator43.s(); !(_step43 = _iterator43.n()).done;) {
      var value = _step43.value;
      if (callback(value)) {
        result.add(value);
      }
    }
  } catch (err) {
    _iterator43.e(err);
  } finally {
    _iterator43.f();
  }
  return result;
}
var Recoil_filterSet = filterSet;

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */

function mergeMaps() {
  var result = new Map();
  for (var _len5 = arguments.length, maps = new Array(_len5), _key8 = 0; _key8 < _len5; _key8++) {
    maps[_key8] = arguments[_key8];
  }
  for (var i = 0; i < maps.length; i++) {
    var iterator = maps[i].keys();
    var nextKey = void 0;
    while (!(nextKey = iterator.next()).done) {
      // $FlowIssue[incompatible-call] - map/iterator knows nothing about flow types
      result.set(nextKey.value, maps[i].get(nextKey.value));
    }
  }
  return result;
}
var Recoil_mergeMaps = mergeMaps;
var batchUpdates$3 = Recoil_Batching.batchUpdates;
var DEFAULT_VALUE$3 = Recoil_Node.DEFAULT_VALUE,
  getNode$4 = Recoil_Node.getNode,
  nodes$1 = Recoil_Node.nodes;
var useStoreRef$3 = Recoil_RecoilRoot.useStoreRef;
var AbstractRecoilValue$4 = Recoil_RecoilValueInterface.AbstractRecoilValue,
  setRecoilValueLoadable$1 = Recoil_RecoilValueInterface.setRecoilValueLoadable;
var SUSPENSE_TIMEOUT_MS$2 = Recoil_Retention.SUSPENSE_TIMEOUT_MS;
var cloneSnapshot$1 = Recoil_Snapshot$1.cloneSnapshot;
var useCallback$2 = _react_18_2_0_react.useCallback,
  useEffect$4 = _react_18_2_0_react.useEffect,
  useRef$5 = _react_18_2_0_react.useRef,
  useState$2 = _react_18_2_0_react.useState;
var isSSR$4 = Recoil_Environment.isSSR;
function useTransactionSubscription(callback) {
  var storeRef = useStoreRef$3();
  useEffect$4(function () {
    var sub = storeRef.current.subscribeToTransactions(callback);
    return sub.release;
  }, [callback, storeRef]);
}
function externallyVisibleAtomValuesInState(state) {
  var atomValues = state.atomValues.toMap();
  var persistedAtomContentsValues = Recoil_mapMap(Recoil_filterMap(atomValues, function (v, k) {
    var node = getNode$4(k);
    var persistence = node.persistence_UNSTABLE;
    return persistence != null && persistence.type !== 'none' && v.state === 'hasValue';
  }), function (v) {
    return v.contents;
  }); // Merge in nonvalidated atoms; we may not have defs for them but they will
  // all have persistence on or they wouldn't be there in the first place.

  return Recoil_mergeMaps(state.nonvalidatedAtoms.toMap(), persistedAtomContentsValues);
}

/**
  Calls the given callback after any atoms have been modified and the consequent
  component re-renders have been committed. This is intended for persisting
  the values of the atoms to storage. The stored values can then be restored
  using the useSetUnvalidatedAtomValues hook.

  The callback receives the following info:

  atomValues: The current value of every atom that is both persistable (persistence
              type not set to 'none') and whose value is available (not in an
              error or loading state).

  previousAtomValues: The value of every persistable and available atom before
               the transaction began.

  atomInfo: A map containing the persistence settings for each atom. Every key
            that exists in atomValues will also exist in atomInfo.

  modifiedAtoms: The set of atoms that were written to during the transaction.

  transactionMetadata: Arbitrary information that was added via the
          useSetUnvalidatedAtomValues hook. Useful for ignoring the useSetUnvalidatedAtomValues
          transaction, to avoid loops.
*/
function useTransactionObservation_DEPRECATED(callback) {
  useTransactionSubscription(useCallback$2(function (store) {
    var previousTree = store.getState().previousTree;
    var currentTree = store.getState().currentTree;
    if (!previousTree) {
      Recoil_recoverableViolation('Transaction subscribers notified without a previous tree being present -- this is a bug in Recoil');
      previousTree = store.getState().currentTree; // attempt to trundle on
    }

    var atomValues = externallyVisibleAtomValuesInState(currentTree);
    var previousAtomValues = externallyVisibleAtomValuesInState(previousTree);
    var atomInfo = Recoil_mapMap(nodes$1, function (node) {
      var _node$persistence_UNS, _node$persistence_UNS2, _node$persistence_UNS3, _node$persistence_UNS4;
      return {
        persistence_UNSTABLE: {
          type: (_node$persistence_UNS = (_node$persistence_UNS2 = node.persistence_UNSTABLE) === null || _node$persistence_UNS2 === void 0 ? void 0 : _node$persistence_UNS2.type) !== null && _node$persistence_UNS !== void 0 ? _node$persistence_UNS : 'none',
          backButton: (_node$persistence_UNS3 = (_node$persistence_UNS4 = node.persistence_UNSTABLE) === null || _node$persistence_UNS4 === void 0 ? void 0 : _node$persistence_UNS4.backButton) !== null && _node$persistence_UNS3 !== void 0 ? _node$persistence_UNS3 : false
        }
      };
    }); // Filter on existance in atomValues so that externally-visible rules
    // are also applied to modified atoms (specifically exclude selectors):

    var modifiedAtoms = Recoil_filterSet(currentTree.dirtyAtoms, function (k) {
      return atomValues.has(k) || previousAtomValues.has(k);
    });
    callback({
      atomValues: atomValues,
      previousAtomValues: previousAtomValues,
      atomInfo: atomInfo,
      modifiedAtoms: modifiedAtoms,
      transactionMetadata: _objectSpread2({}, currentTree.transactionMetadata)
    });
  }, [callback]));
}
function useRecoilTransactionObserver(callback) {
  useTransactionSubscription(useCallback$2(function (store) {
    var snapshot = cloneSnapshot$1(store, 'latest');
    var previousSnapshot = cloneSnapshot$1(store, 'previous');
    callback({
      snapshot: snapshot,
      previousSnapshot: previousSnapshot
    });
  }, [callback]));
} // Return a snapshot of the current state and subscribe to all state changes

function useRecoilSnapshot() {
  var storeRef = useStoreRef$3();
  var _useState$7 = useState$2(function () {
      return cloneSnapshot$1(storeRef.current);
    }),
    _useState$8 = slicedToArray_slicedToArray(_useState$7, 2),
    snapshot = _useState$8[0],
    setSnapshot = _useState$8[1];
  var previousSnapshot = Recoil_usePrevious(snapshot);
  var timeoutID = useRef$5();
  var releaseRef = useRef$5();
  useTransactionSubscription(useCallback$2(function (store) {
    return setSnapshot(cloneSnapshot$1(store));
  }, [])); // Retain snapshot for duration component is mounted

  useEffect$4(function () {
    var release = snapshot.retain(); // Release the retain from the rendering call

    if (timeoutID.current && !isSSR$4) {
      var _releaseRef$current;
      window.clearTimeout(timeoutID.current);
      timeoutID.current = null;
      (_releaseRef$current = releaseRef.current) === null || _releaseRef$current === void 0 ? void 0 : _releaseRef$current.call(releaseRef);
      releaseRef.current = null;
    }
    return function () {
      // Defer the release.  If "Fast Refresh"" is used then the component may
      // re-render with the same state.  The previous cleanup will then run and
      // then the new effect will run. We don't want the snapshot to be released
      // by that cleanup before the new effect has a chance to retain it again.
      // Use timeout of 10 to workaround Firefox issue: https://github.com/facebookexperimental/Recoil/issues/1936
      window.setTimeout(release, 10);
    };
  }, [snapshot]); // Retain snapshot until above effect is run.
  // Release after a threshold in case component is suspended.

  if (previousSnapshot !== snapshot && !isSSR$4) {
    // Release the previous snapshot
    if (timeoutID.current) {
      var _releaseRef$current2;
      window.clearTimeout(timeoutID.current);
      timeoutID.current = null;
      (_releaseRef$current2 = releaseRef.current) === null || _releaseRef$current2 === void 0 ? void 0 : _releaseRef$current2.call(releaseRef);
      releaseRef.current = null;
    }
    releaseRef.current = snapshot.retain();
    timeoutID.current = window.setTimeout(function () {
      var _releaseRef$current3;
      timeoutID.current = null;
      (_releaseRef$current3 = releaseRef.current) === null || _releaseRef$current3 === void 0 ? void 0 : _releaseRef$current3.call(releaseRef);
      releaseRef.current = null;
    }, SUSPENSE_TIMEOUT_MS$2);
  }
  return snapshot;
}
function gotoSnapshot(store, snapshot) {
  var _storeState$nextTree;
  var storeState = store.getState();
  var prev = (_storeState$nextTree = storeState.nextTree) !== null && _storeState$nextTree !== void 0 ? _storeState$nextTree : storeState.currentTree;
  var next = snapshot.getStore_INTERNAL().getState().currentTree;
  batchUpdates$3(function () {
    var keysToUpdate = new Set();
    for (var _i4 = 0, _arr = [prev.atomValues.keys(), next.atomValues.keys()]; _i4 < _arr.length; _i4++) {
      var keys = _arr[_i4];
      var _iterator44 = _createForOfIteratorHelper(keys),
        _step44;
      try {
        for (_iterator44.s(); !(_step44 = _iterator44.n()).done;) {
          var key = _step44.value;
          var _prev$atomValues$get, _next$atomValues$get;
          if (((_prev$atomValues$get = prev.atomValues.get(key)) === null || _prev$atomValues$get === void 0 ? void 0 : _prev$atomValues$get.contents) !== ((_next$atomValues$get = next.atomValues.get(key)) === null || _next$atomValues$get === void 0 ? void 0 : _next$atomValues$get.contents) && getNode$4(key).shouldRestoreFromSnapshots) {
            keysToUpdate.add(key);
          }
        }
      } catch (err) {
        _iterator44.e(err);
      } finally {
        _iterator44.f();
      }
    }
    keysToUpdate.forEach(function (key) {
      setRecoilValueLoadable$1(store, new AbstractRecoilValue$4(key), next.atomValues.has(key) ? Recoil_nullthrows(next.atomValues.get(key)) : DEFAULT_VALUE$3);
    });
    store.replaceState(function (state) {
      return _objectSpread2(_objectSpread2({}, state), {}, {
        stateID: snapshot.getID()
      });
    });
  });
}
function useGotoRecoilSnapshot() {
  var storeRef = useStoreRef$3();
  return useCallback$2(function (snapshot) {
    return gotoSnapshot(storeRef.current, snapshot);
  }, [storeRef]);
}
var Recoil_SnapshotHooks = {
  useRecoilSnapshot: useRecoilSnapshot,
  gotoSnapshot: gotoSnapshot,
  useGotoRecoilSnapshot: useGotoRecoilSnapshot,
  useRecoilTransactionObserver: useRecoilTransactionObserver,
  useTransactionObservation_DEPRECATED: useTransactionObservation_DEPRECATED,
  useTransactionSubscription_DEPRECATED: useTransactionSubscription
};
var peekNodeInfo$2 = Recoil_FunctionalCore.peekNodeInfo;
var useStoreRef$4 = Recoil_RecoilRoot.useStoreRef;
function useGetRecoilValueInfo() {
  var storeRef = useStoreRef$4(); // $FlowFixMe[incompatible-return]

  return function (_ref15) {
    var key = _ref15.key;
    return peekNodeInfo$2(storeRef.current, storeRef.current.getState().currentTree, key);
  };
}
var Recoil_useGetRecoilValueInfo = useGetRecoilValueInfo;
var reactMode$4 = Recoil_ReactMode.reactMode;
var RecoilRoot$1 = Recoil_RecoilRoot.RecoilRoot,
  useStoreRef$5 = Recoil_RecoilRoot.useStoreRef;
var useMemo$2 = _react_18_2_0_react.useMemo;
function useRecoilBridgeAcrossReactRoots() {
  // The test fails when using useMutableSource(), but only if act() is used
  // for the nested root.  So, this may only be a testing environment issue.
  if (reactMode$4().mode === 'MUTABLE_SOURCE') {
    // eslint-disable-next-line fb-www/no-console
    console.warn('Warning: There are known issues using useRecoilBridgeAcrossReactRoots() in recoil_mutable_source rendering mode.  Please consider upgrading to recoil_sync_external_store mode.');
  }
  var store = useStoreRef$5().current;
  return useMemo$2(function () {
    // eslint-disable-next-line no-shadow
    function RecoilBridge(_ref16) {
      var children = _ref16.children;
      return /*#__PURE__*/_react_18_2_0_react.createElement(RecoilRoot$1, {
        store_INTERNAL: store
      }, children);
    }
    return RecoilBridge;
  }, [store]);
}
var Recoil_useRecoilBridgeAcrossReactRoots = useRecoilBridgeAcrossReactRoots;
var loadableWithValue$1 = Recoil_Loadable$1.loadableWithValue;
var initializeNode$3 = Recoil_FunctionalCore.initializeNode;
var DEFAULT_VALUE$4 = Recoil_Node.DEFAULT_VALUE,
  getNode$5 = Recoil_Node.getNode;
var copyTreeState$1 = Recoil_RecoilValueInterface.copyTreeState,
  getRecoilValueAsLoadable$3 = Recoil_RecoilValueInterface.getRecoilValueAsLoadable,
  invalidateDownstreams$1 = Recoil_RecoilValueInterface.invalidateDownstreams,
  writeLoadableToTreeState$1 = Recoil_RecoilValueInterface.writeLoadableToTreeState;
function isAtom(recoilValue) {
  return getNode$5(recoilValue.key).nodeType === 'atom';
}
var TransactionInterfaceImpl = /*#__PURE__*/function () {
  function TransactionInterfaceImpl(store, treeState) {
    var _this10 = this;
    _classCallCheck(this, TransactionInterfaceImpl);
    es_defineProperty(this, "_store", void 0);
    es_defineProperty(this, "_treeState", void 0);
    es_defineProperty(this, "_changes", void 0);
    es_defineProperty(this, "get", function (recoilValue) {
      if (_this10._changes.has(recoilValue.key)) {
        // $FlowIssue[incompatible-return]
        return _this10._changes.get(recoilValue.key);
      }
      if (!isAtom(recoilValue)) {
        throw Recoil_err('Reading selectors within atomicUpdate is not supported');
      }
      var loadable = getRecoilValueAsLoadable$3(_this10._store, recoilValue, _this10._treeState);
      if (loadable.state === 'hasValue') {
        return loadable.contents;
      } else if (loadable.state === 'hasError') {
        throw loadable.contents;
      } else {
        throw Recoil_err("Expected Recoil atom ".concat(recoilValue.key, " to have a value, but it is in a loading state."));
      }
    });
    es_defineProperty(this, "set", function (recoilState, valueOrUpdater) {
      if (!isAtom(recoilState)) {
        throw Recoil_err('Setting selectors within atomicUpdate is not supported');
      }
      if (typeof valueOrUpdater === 'function') {
        var current = _this10.get(recoilState);
        _this10._changes.set(recoilState.key, valueOrUpdater(current)); // flowlint-line unclear-type:off
      } else {
        // Initialize atom and run effects if not initialized yet
        initializeNode$3(_this10._store, recoilState.key, 'set');
        _this10._changes.set(recoilState.key, valueOrUpdater);
      }
    });
    es_defineProperty(this, "reset", function (recoilState) {
      _this10.set(recoilState, DEFAULT_VALUE$4);
    });
    this._store = store;
    this._treeState = treeState;
    this._changes = new Map();
  } // Allow destructing
  // eslint-disable-next-line fb-www/extra-arrow-initializer
  _createClass(TransactionInterfaceImpl, [{
    key: "newTreeState_INTERNAL",
    value: function newTreeState_INTERNAL() {
      if (this._changes.size === 0) {
        return this._treeState;
      }
      var newState = copyTreeState$1(this._treeState);
      var _iterator45 = _createForOfIteratorHelper(this._changes),
        _step45;
      try {
        for (_iterator45.s(); !(_step45 = _iterator45.n()).done;) {
          var _step45$value = slicedToArray_slicedToArray(_step45.value, 2),
            k = _step45$value[0],
            v = _step45$value[1];
          writeLoadableToTreeState$1(newState, k, loadableWithValue$1(v));
        }
      } catch (err) {
        _iterator45.e(err);
      } finally {
        _iterator45.f();
      }
      invalidateDownstreams$1(this._store, newState);
      return newState;
    }
  }]);
  return TransactionInterfaceImpl;
}();
function atomicUpdater(store) {
  return function (fn) {
    store.replaceState(function (treeState) {
      var changeset = new TransactionInterfaceImpl(store, treeState);
      fn(changeset);
      return changeset.newTreeState_INTERNAL();
    });
  };
}
var Recoil_AtomicUpdates = {
  atomicUpdater: atomicUpdater
};
var Recoil_AtomicUpdates_1 = Recoil_AtomicUpdates.atomicUpdater;
var Recoil_AtomicUpdates$1 = /*#__PURE__*/Object.freeze({
  __proto__: null,
  atomicUpdater: Recoil_AtomicUpdates_1
});

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */

function invariant(condition, message) {
  if (!condition) {
    throw new Error(message);
  }
}
var invariant_1 = invariant;

// @oss-only

var Recoil_invariant = invariant_1;
var atomicUpdater$1 = Recoil_AtomicUpdates$1.atomicUpdater;
var batchUpdates$4 = Recoil_Batching.batchUpdates;
var DEFAULT_VALUE$5 = Recoil_Node.DEFAULT_VALUE;
var useStoreRef$6 = Recoil_RecoilRoot.useStoreRef;
var refreshRecoilValue$1 = Recoil_RecoilValueInterface.refreshRecoilValue,
  setRecoilValue$3 = Recoil_RecoilValueInterface.setRecoilValue;
var cloneSnapshot$2 = Recoil_Snapshot$1.cloneSnapshot;
var gotoSnapshot$1 = Recoil_SnapshotHooks.gotoSnapshot;
var useCallback$3 = _react_18_2_0_react.useCallback;
var Sentinel = /*#__PURE__*/_createClass(function Sentinel() {
  _classCallCheck(this, Sentinel);
});
var SENTINEL = new Sentinel();
function recoilCallback(store, fn, args, extraInterface) {
  var ret = SENTINEL;
  var releaseSnapshot;
  batchUpdates$4(function () {
    var errMsg = 'useRecoilCallback() expects a function that returns a function: ' + 'it accepts a function of the type (RecoilInterface) => (Args) => ReturnType ' + 'and returns a callback function (Args) => ReturnType, where RecoilInterface is ' + 'an object {snapshot, set, ...} and Args and ReturnType are the argument and return ' + 'types of the callback you want to create.  Please see the docs ' + 'at recoiljs.org for details.';
    if (typeof fn !== 'function') {
      throw Recoil_err(errMsg);
    } // Clone the snapshot lazily to avoid overhead if the callback does not use it.
    // Note that this means the snapshot may represent later state from when
    // the callback was called if it first accesses the snapshot asynchronously.

    var callbackInterface = Recoil_lazyProxy(_objectSpread2(_objectSpread2({}, extraInterface !== null && extraInterface !== void 0 ? extraInterface : {}), {}, {
      // flowlint-line unclear-type:off
      // $FlowFixMe[missing-local-annot]
      set: function set(node, newValue) {
        return setRecoilValue$3(store, node, newValue);
      },
      // $FlowFixMe[missing-local-annot]
      reset: function reset(node) {
        return setRecoilValue$3(store, node, DEFAULT_VALUE$5);
      },
      // $FlowFixMe[missing-local-annot]
      refresh: function refresh(node) {
        return refreshRecoilValue$1(store, node);
      },
      gotoSnapshot: function gotoSnapshot(snapshot) {
        return gotoSnapshot$1(store, snapshot);
      },
      transact_UNSTABLE: function transact_UNSTABLE(transaction) {
        return atomicUpdater$1(store)(transaction);
      }
    }), {
      snapshot: function snapshot() {
        var snapshot = cloneSnapshot$2(store);
        releaseSnapshot = snapshot.retain();
        return snapshot;
      }
    });
    var callback = fn(callbackInterface);
    if (typeof callback !== 'function') {
      throw Recoil_err(errMsg);
    }
    ret = callback.apply(void 0, _toConsumableArray(args));
  });
  !!(ret instanceof Sentinel) ?  false ? 0 : Recoil_invariant(false) : void 0;
  if (Recoil_isPromise(ret)) {
    ret = ret.finally(function () {
      var _releaseSnapshot;
      (_releaseSnapshot = releaseSnapshot) === null || _releaseSnapshot === void 0 ? void 0 : _releaseSnapshot();
    });
  } else {
    var _releaseSnapshot2;
    (_releaseSnapshot2 = releaseSnapshot) === null || _releaseSnapshot2 === void 0 ? void 0 : _releaseSnapshot2();
  }
  return ret;
}
function es_useRecoilCallback(fn, deps) {
  var storeRef = useStoreRef$6();
  return useCallback$3(
  // $FlowIssue[incompatible-call]
  function () {
    for (var _len6 = arguments.length, args = new Array(_len6), _key9 = 0; _key9 < _len6; _key9++) {
      args[_key9] = arguments[_key9];
    }
    return recoilCallback(storeRef.current, fn, args);
  }, deps != null ? [].concat(_toConsumableArray(deps), [storeRef]) : undefined // eslint-disable-line fb-www/react-hooks-deps
  );
}

var Recoil_useRecoilCallback = {
  recoilCallback: recoilCallback,
  useRecoilCallback: es_useRecoilCallback
};
var useStoreRef$7 = Recoil_RecoilRoot.useStoreRef;
var refreshRecoilValue$2 = Recoil_RecoilValueInterface.refreshRecoilValue;
var useCallback$4 = _react_18_2_0_react.useCallback;
function useRecoilRefresher(recoilValue) {
  var storeRef = useStoreRef$7();
  return useCallback$4(function () {
    var store = storeRef.current;
    refreshRecoilValue$2(store, recoilValue);
  }, [recoilValue, storeRef]);
}
var Recoil_useRecoilRefresher = useRecoilRefresher;
var atomicUpdater$2 = Recoil_AtomicUpdates$1.atomicUpdater;
var useStoreRef$8 = Recoil_RecoilRoot.useStoreRef;
var useMemo$3 = _react_18_2_0_react.useMemo;
function useRecoilTransaction(fn, deps) {
  var storeRef = useStoreRef$8();
  return useMemo$3(function () {
    return function () {
      for (var _len7 = arguments.length, args = new Array(_len7), _key10 = 0; _key10 < _len7; _key10++) {
        args[_key10] = arguments[_key10];
      }
      var atomicUpdate = atomicUpdater$2(storeRef.current);
      atomicUpdate(function (transactionInterface) {
        fn(transactionInterface).apply(void 0, args);
      });
    };
  }, deps != null ? [].concat(_toConsumableArray(deps), [storeRef]) : undefined // eslint-disable-line fb-www/react-hooks-deps
  );
}

var Recoil_useRecoilTransaction = useRecoilTransaction;

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
var WrappedValue = /*#__PURE__*/_createClass(function WrappedValue(value) {
  _classCallCheck(this, WrappedValue);
  es_defineProperty(this, "value", void 0);
  this.value = value;
});
var Recoil_Wrapper = {
  WrappedValue: WrappedValue
};
var Recoil_Wrapper_1 = Recoil_Wrapper.WrappedValue;
var Recoil_Wrapper$1 = /*#__PURE__*/Object.freeze({
  __proto__: null,
  WrappedValue: Recoil_Wrapper_1
});
var isFastRefreshEnabled$2 = Recoil_ReactMode.isFastRefreshEnabled;
var ChangedPathError = /*#__PURE__*/function (_Error3) {
  _inherits(ChangedPathError, _Error3);
  var _super9 = _createSuper(ChangedPathError);
  function ChangedPathError() {
    _classCallCheck(this, ChangedPathError);
    return _super9.apply(this, arguments);
  }
  return _createClass(ChangedPathError);
}( /*#__PURE__*/wrapNativeSuper_wrapNativeSuper(Error));
var TreeCache = /*#__PURE__*/function () {
  // $FlowIssue[unclear-type]
  function TreeCache(options) {
    _classCallCheck(this, TreeCache);
    var _options$onHit, _options$onSet, _options$mapNodeValue;
    es_defineProperty(this, "_name", void 0);
    es_defineProperty(this, "_numLeafs", void 0);
    es_defineProperty(this, "_root", void 0);
    es_defineProperty(this, "_onHit", void 0);
    es_defineProperty(this, "_onSet", void 0);
    es_defineProperty(this, "_mapNodeValue", void 0);
    this._name = options === null || options === void 0 ? void 0 : options.name;
    this._numLeafs = 0;
    this._root = null;
    this._onHit = (_options$onHit = options === null || options === void 0 ? void 0 : options.onHit) !== null && _options$onHit !== void 0 ? _options$onHit : function () {};
    this._onSet = (_options$onSet = options === null || options === void 0 ? void 0 : options.onSet) !== null && _options$onSet !== void 0 ? _options$onSet : function () {};
    this._mapNodeValue = (_options$mapNodeValue = options === null || options === void 0 ? void 0 : options.mapNodeValue) !== null && _options$mapNodeValue !== void 0 ? _options$mapNodeValue : function (val) {
      return val;
    };
  }
  _createClass(TreeCache, [{
    key: "size",
    value: function size() {
      return this._numLeafs;
    } // $FlowIssue[unclear-type]
  }, {
    key: "root",
    value: function root() {
      return this._root;
    }
  }, {
    key: "get",
    value: function get(getNodeValue, handlers) {
      var _this$getLeafNode;
      return (_this$getLeafNode = this.getLeafNode(getNodeValue, handlers)) === null || _this$getLeafNode === void 0 ? void 0 : _this$getLeafNode.value;
    }
  }, {
    key: "getLeafNode",
    value: function getLeafNode(getNodeValue, handlers) {
      if (this._root == null) {
        return undefined;
      } // Iterate down the tree based on the current node values until we hit a leaf
      // $FlowIssue[unclear-type]

      var node = this._root;
      while (node) {
        handlers === null || handlers === void 0 ? void 0 : handlers.onNodeVisit(node);
        if (node.type === 'leaf') {
          this._onHit(node);
          return node;
        }
        var nodeValue = this._mapNodeValue(getNodeValue(node.nodeKey));
        node = node.branches.get(nodeValue);
      }
      return undefined;
    }
  }, {
    key: "set",
    value: function set(route, value, handlers) {
      var _this11 = this;
      var addLeaf = function addLeaf() {
        var _node2, _node3, _this$_root2, _handlers$onNodeVisit2;

        // First, setup the branch nodes for the route:
        // Iterate down the tree to find or add branch nodes following the route
        var node;
        var branchKey;
        var _iterator46 = _createForOfIteratorHelper(route),
          _step46;
        try {
          for (_iterator46.s(); !(_step46 = _iterator46.n()).done;) {
            var _step46$value = slicedToArray_slicedToArray(_step46.value, 2),
              nodeKey = _step46$value[0],
              nodeValue = _step46$value[1];
            var _node, _handlers$onNodeVisit, _this$_root;

            // If the previous root was a leaf, while we not have a get(), it means
            // the selector has inconsistent values or implementation changed.
            var root = _this11._root;
            if ((root === null || root === void 0 ? void 0 : root.type) === 'leaf') {
              throw _this11.invalidCacheError();
            } // node now refers to the next node down in the tree

            var parent = node; // $FlowFixMe[prop-missing]
            // $FlowFixMe[incompatible-type]

            node = parent ? parent.branches.get(branchKey) : root; // $FlowFixMe[prop-missing]
            // $FlowFixMe[incompatible-type]

            node = (_node = node) !== null && _node !== void 0 ? _node : {
              type: 'branch',
              nodeKey: nodeKey,
              parent: parent,
              branches: new Map(),
              branchKey: branchKey
            }; // If we found an existing node, confirm it has a consistent value

            if (node.type !== 'branch' || node.nodeKey !== nodeKey) {
              throw _this11.invalidCacheError();
            } // Add the branch node to the tree

            parent === null || parent === void 0 ? void 0 : parent.branches.set(branchKey, node);
            handlers === null || handlers === void 0 ? void 0 : (_handlers$onNodeVisit = handlers.onNodeVisit) === null || _handlers$onNodeVisit === void 0 ? void 0 : _handlers$onNodeVisit.call(handlers, node); // Prepare for next iteration and install root if it is new.

            branchKey = _this11._mapNodeValue(nodeValue);
            _this11._root = (_this$_root = _this11._root) !== null && _this$_root !== void 0 ? _this$_root : node;
          } // Second, setup the leaf node:
          // If there is an existing leaf for this route confirm it is consistent
        } catch (err) {
          _iterator46.e(err);
        } finally {
          _iterator46.f();
        }
        var oldLeaf = node ? (_node2 = node) === null || _node2 === void 0 ? void 0 : _node2.branches.get(branchKey) : _this11._root;
        if (oldLeaf != null && (oldLeaf.type !== 'leaf' || oldLeaf.branchKey !== branchKey)) {
          throw _this11.invalidCacheError();
        } // Create a new or replacement leaf.

        var leafNode = {
          type: 'leaf',
          value: value,
          parent: node,
          branchKey: branchKey
        }; // Install the leaf and call handlers

        (_node3 = node) === null || _node3 === void 0 ? void 0 : _node3.branches.set(branchKey, leafNode);
        _this11._root = (_this$_root2 = _this11._root) !== null && _this$_root2 !== void 0 ? _this$_root2 : leafNode;
        _this11._numLeafs++;
        _this11._onSet(leafNode);
        handlers === null || handlers === void 0 ? void 0 : (_handlers$onNodeVisit2 = handlers.onNodeVisit) === null || _handlers$onNodeVisit2 === void 0 ? void 0 : _handlers$onNodeVisit2.call(handlers, leafNode);
      };
      try {
        addLeaf();
      } catch (error) {
        // If the cache was stale or observed inconsistent values, such as with
        // Fast Refresh, then clear it and rebuild with the new values.
        if (error instanceof ChangedPathError) {
          this.clear();
          addLeaf();
        } else {
          throw error;
        }
      }
    } // Returns true if leaf was actually deleted from the tree
  }, {
    key: "delete",
    value: function _delete(leaf) {
      var root = this.root();
      if (!root) {
        return false;
      }
      if (leaf === root) {
        this._root = null;
        this._numLeafs = 0;
        return true;
      } // Iterate up from the leaf deleteing it from it's parent's branches.

      var node = leaf.parent;
      var branchKey = leaf.branchKey;
      while (node) {
        var _node4;
        node.branches.delete(branchKey); // Stop iterating if we hit the root.

        if (node === root) {
          if (node.branches.size === 0) {
            this._root = null;
            this._numLeafs = 0;
          } else {
            this._numLeafs--;
          }
          return true;
        } // Stop iterating if there are other branches since we don't need to
        // remove any more nodes.

        if (node.branches.size > 0) {
          break;
        } // Iterate up to our parent

        branchKey = (_node4 = node) === null || _node4 === void 0 ? void 0 : _node4.branchKey;
        node = node.parent;
      } // Confirm that the leaf we are deleting is actually attached to our tree

      for (; node !== root; node = node.parent) {
        if (node == null) {
          return false;
        }
      }
      this._numLeafs--;
      return true;
    }
  }, {
    key: "clear",
    value: function clear() {
      this._numLeafs = 0;
      this._root = null;
    }
  }, {
    key: "invalidCacheError",
    value: function invalidCacheError() {
      var CHANGED_PATH_ERROR_MESSAGE = isFastRefreshEnabled$2() ? 'Possible Fast Refresh module reload detected.  ' + 'This may also be caused by an selector returning inconsistent values. ' + 'Resetting cache.' : 'Invalid cache values.  This happens when selectors do not return ' + 'consistent values for the same input dependency values.  That may also ' + 'be caused when using Fast Refresh to change a selector implementation.  ' + 'Resetting cache.';
      Recoil_recoverableViolation(CHANGED_PATH_ERROR_MESSAGE + (this._name != null ? " - ".concat(this._name) : ''));
      throw new ChangedPathError();
    }
  }]);
  return TreeCache;
}();
var Recoil_TreeCache = {
  TreeCache: TreeCache
};
var Recoil_TreeCache_1 = Recoil_TreeCache.TreeCache;
var Recoil_TreeCache$1 = /*#__PURE__*/Object.freeze({
  __proto__: null,
  TreeCache: Recoil_TreeCache_1
});
var LRUCache = /*#__PURE__*/function () {
  function LRUCache(options) {
    _classCallCheck(this, LRUCache);
    var _options$mapKey;
    es_defineProperty(this, "_maxSize", void 0);
    es_defineProperty(this, "_size", void 0);
    es_defineProperty(this, "_head", void 0);
    es_defineProperty(this, "_tail", void 0);
    es_defineProperty(this, "_map", void 0);
    es_defineProperty(this, "_keyMapper", void 0);
    this._maxSize = options.maxSize;
    this._size = 0;
    this._head = null;
    this._tail = null;
    this._map = new Map();
    this._keyMapper = (_options$mapKey = options.mapKey) !== null && _options$mapKey !== void 0 ? _options$mapKey : function (v) {
      return v;
    };
  }
  _createClass(LRUCache, [{
    key: "head",
    value: function head() {
      return this._head;
    }
  }, {
    key: "tail",
    value: function tail() {
      return this._tail;
    }
  }, {
    key: "size",
    value: function size() {
      return this._size;
    }
  }, {
    key: "maxSize",
    value: function maxSize() {
      return this._maxSize;
    }
  }, {
    key: "has",
    value: function has(key) {
      return this._map.has(this._keyMapper(key));
    }
  }, {
    key: "get",
    value: function get(key) {
      var mappedKey = this._keyMapper(key);
      var node = this._map.get(mappedKey);
      if (!node) {
        return undefined;
      }
      this.set(key, node.value);
      return node.value;
    }
  }, {
    key: "set",
    value: function set(key, val) {
      var mappedKey = this._keyMapper(key);
      var existingNode = this._map.get(mappedKey);
      if (existingNode) {
        this.delete(key);
      }
      var head = this.head();
      var node = {
        key: key,
        right: head,
        left: null,
        value: val
      };
      if (head) {
        head.left = node;
      } else {
        this._tail = node;
      }
      this._map.set(mappedKey, node);
      this._head = node;
      this._size++;
      this._maybeDeleteLRU();
    }
  }, {
    key: "_maybeDeleteLRU",
    value: function _maybeDeleteLRU() {
      if (this.size() > this.maxSize()) {
        this.deleteLru();
      }
    }
  }, {
    key: "deleteLru",
    value: function deleteLru() {
      var tail = this.tail();
      if (tail) {
        this.delete(tail.key);
      }
    }
  }, {
    key: "delete",
    value: function _delete(key) {
      var mappedKey = this._keyMapper(key);
      if (!this._size || !this._map.has(mappedKey)) {
        return;
      }
      var node = Recoil_nullthrows(this._map.get(mappedKey));
      var right = node.right;
      var left = node.left;
      if (right) {
        right.left = node.left;
      }
      if (left) {
        left.right = node.right;
      }
      if (node === this.head()) {
        this._head = right;
      }
      if (node === this.tail()) {
        this._tail = left;
      }
      this._map.delete(mappedKey);
      this._size--;
    }
  }, {
    key: "clear",
    value: function clear() {
      this._size = 0;
      this._head = null;
      this._tail = null;
      this._map = new Map();
    }
  }]);
  return LRUCache;
}();
var Recoil_LRUCache = {
  LRUCache: LRUCache
};
var Recoil_LRUCache_1 = Recoil_LRUCache.LRUCache;
var Recoil_LRUCache$1 = /*#__PURE__*/Object.freeze({
  __proto__: null,
  LRUCache: Recoil_LRUCache_1
});
var LRUCache$1 = Recoil_LRUCache$1.LRUCache;
var TreeCache$1 = Recoil_TreeCache$1.TreeCache;
function treeCacheLRU(_ref17) {
  var name = _ref17.name,
    maxSize = _ref17.maxSize,
    _ref17$mapNodeValue = _ref17.mapNodeValue,
    mapNodeValue = _ref17$mapNodeValue === void 0 ? function (v) {
      return v;
    } : _ref17$mapNodeValue;
  var lruCache = new LRUCache$1({
    maxSize: maxSize
  });
  var cache = new TreeCache$1({
    name: name,
    mapNodeValue: mapNodeValue,
    onHit: function onHit(node) {
      lruCache.set(node, true);
    },
    onSet: function onSet(node) {
      var lruNode = lruCache.tail();
      lruCache.set(node, true);
      if (lruNode && cache.size() > maxSize) {
        // $FlowFixMe[incompatible-call]
        cache.delete(lruNode.key);
      }
    }
  });
  return cache;
}
var Recoil_treeCacheLRU = treeCacheLRU;
var TIME_WARNING_THRESHOLD_MS = 15;
function es_stringify(x, opt, key) {
  // A optimization to avoid the more expensive JSON.stringify() for simple strings
  // This may lose protection for u2028 and u2029, though.
  if (typeof x === 'string' && !x.includes('"') && !x.includes('\\')) {
    return "\"".concat(x, "\"");
  } // Handle primitive types

  switch (typeof x) {
    case 'undefined':
      return '';
    // JSON.stringify(undefined) returns undefined, but we always want to return a string

    case 'boolean':
      return x ? 'true' : 'false';
    case 'number':
    case 'symbol':
      // case 'bigint': // BigInt is not supported in www
      return String(x);
    case 'string':
      // Add surrounding quotes and escape internal quotes
      return JSON.stringify(x);
    case 'function':
      if ((opt === null || opt === void 0 ? void 0 : opt.allowFunctions) !== true) {
        throw Recoil_err('Attempt to serialize function in a Recoil cache key');
      }
      return "__FUNCTION(".concat(x.name, ")__");
  }
  if (x === null) {
    return 'null';
  } // Fallback case for unknown types

  if (typeof x !== 'object') {
    var _JSON$stringify;
    return (_JSON$stringify = JSON.stringify(x)) !== null && _JSON$stringify !== void 0 ? _JSON$stringify : '';
  } // Deal with all promises as equivalent for now.

  if (Recoil_isPromise(x)) {
    return '__PROMISE__';
  } // Arrays handle recursive stringification

  if (Array.isArray(x)) {
    // $FlowFixMe[missing-local-annot]
    return "[".concat(x.map(function (v, i) {
      return es_stringify(v, opt, i.toString());
    }), "]");
  } // If an object defines a toJSON() method, then use that to override the
  // serialization.  This matches the behavior of JSON.stringify().
  // Pass the key for compatibility.
  // Immutable.js collections define this method to allow us to serialize them.

  if (typeof x.toJSON === 'function') {
    // flowlint-next-line unclear-type: off
    return es_stringify(x.toJSON(key), opt, key);
  } // For built-in Maps, sort the keys in a stable order instead of the
  // default insertion order.  Support non-string keys.

  if (x instanceof Map) {
    var obj = {};
    var _iterator47 = _createForOfIteratorHelper(x),
      _step47;
    try {
      for (_iterator47.s(); !(_step47 = _iterator47.n()).done;) {
        var _step47$value = slicedToArray_slicedToArray(_step47.value, 2),
          k = _step47$value[0],
          v = _step47$value[1];
        // Stringify will escape any nested quotes
        obj[typeof k === 'string' ? k : es_stringify(k, opt)] = v;
      }
    } catch (err) {
      _iterator47.e(err);
    } finally {
      _iterator47.f();
    }
    return es_stringify(obj, opt, key);
  } // For built-in Sets, sort the keys in a stable order instead of the
  // default insertion order.

  if (x instanceof Set) {
    return es_stringify(
    // $FlowFixMe[missing-local-annot]
    Array.from(x).sort(function (a, b) {
      return es_stringify(a, opt).localeCompare(es_stringify(b, opt));
    }), opt, key);
  } // Anything else that is iterable serialize as an Array.

  if (Symbol !== undefined && x[Symbol.iterator] != null && typeof x[Symbol.iterator] === 'function') {
    // flowlint-next-line unclear-type: off
    return es_stringify(Array.from(x), opt, key);
  } // For all other Objects, sort the keys in a stable order.

  return "{".concat(Object.keys(x).filter(function (k) {
    return x[k] !== undefined;
  }).sort() // stringify the key to add quotes and escape any nested slashes or quotes.
  .map(function (k) {
    return "".concat(es_stringify(k, opt), ":").concat(es_stringify(x[k], opt, k));
  }).join(','), "}");
} // Utility similar to JSON.stringify() except:
// * Serialize built-in Sets as an Array
// * Serialize built-in Maps as an Object.  Supports non-string keys.
// * Serialize other iterables as arrays
// * Sort the keys of Objects and Maps to have a stable order based on string conversion.
//    This overrides their default insertion order.
// * Still uses toJSON() of any object to override serialization
// * Support Symbols (though don't guarantee uniqueness)
// * We could support BigInt, but Flow doesn't seem to like it.
// See Recoil_stableStringify-test.js for examples

function stableStringify(x) {
  var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
    allowFunctions: false
  };
  if (false) { var endTime, str, startTime; }
  return es_stringify(x, opt);
}
var Recoil_stableStringify = stableStringify;
var TreeCache$2 = Recoil_TreeCache$1.TreeCache;
var defaultPolicy = {
  equality: 'reference',
  eviction: 'keep-all',
  maxSize: Infinity
};
function treeCacheFromPolicy() {
  var _ref18 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultPolicy,
    _ref18$equality = _ref18.equality,
    equality = _ref18$equality === void 0 ? defaultPolicy.equality : _ref18$equality,
    _ref18$eviction = _ref18.eviction,
    eviction = _ref18$eviction === void 0 ? defaultPolicy.eviction : _ref18$eviction,
    _ref18$maxSize = _ref18.maxSize,
    maxSize = _ref18$maxSize === void 0 ? defaultPolicy.maxSize : _ref18$maxSize;
  var name = arguments.length > 1 ? arguments[1] : undefined;
  var valueMapper = getValueMapper(equality);
  return getTreeCache(eviction, maxSize, valueMapper, name);
}
function getValueMapper(equality) {
  switch (equality) {
    case 'reference':
      return function (val) {
        return val;
      };
    case 'value':
      return function (val) {
        return Recoil_stableStringify(val);
      };
  }
  throw Recoil_err("Unrecognized equality policy ".concat(equality));
}
function getTreeCache(eviction, maxSize, mapNodeValue, name) {
  switch (eviction) {
    case 'keep-all':
      return new TreeCache$2({
        name: name,
        mapNodeValue: mapNodeValue
      });
    case 'lru':
      return Recoil_treeCacheLRU({
        name: name,
        maxSize: Recoil_nullthrows(maxSize),
        mapNodeValue: mapNodeValue
      });
    case 'most-recent':
      return Recoil_treeCacheLRU({
        name: name,
        maxSize: 1,
        mapNodeValue: mapNodeValue
      });
  }
  throw Recoil_err("Unrecognized eviction policy ".concat(eviction));
}
var Recoil_treeCacheFromPolicy = treeCacheFromPolicy;

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */

function isNode(object) {
  var _ownerDocument, _doc$defaultView;
  if (typeof window === 'undefined') {
    return false;
  }
  var doc = object != null ? (_ownerDocument = object.ownerDocument) !== null && _ownerDocument !== void 0 ? _ownerDocument : object : document;
  var defaultView = (_doc$defaultView = doc.defaultView) !== null && _doc$defaultView !== void 0 ? _doc$defaultView : window;
  return !!(object != null && (typeof defaultView.Node === 'function' ? object instanceof defaultView.Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string'));
}
var Recoil_isNode = (/* unused pure expression or super */ null && (isNode));
var isReactNative$1 = Recoil_Environment.isReactNative,
  isWindow$1 = Recoil_Environment.isWindow;
function shouldNotBeFrozen(value) {
  // Primitives and functions:
  if (value === null || typeof value !== 'object') {
    return true;
  } // React elements:

  switch (typeof value.$$typeof) {
    case 'symbol':
      return true;
    case 'number':
      return true;
  } // Immutable structures:

  if (value['@@__IMMUTABLE_ITERABLE__@@'] != null || value['@@__IMMUTABLE_KEYED__@@'] != null || value['@@__IMMUTABLE_INDEXED__@@'] != null || value['@@__IMMUTABLE_ORDERED__@@'] != null || value['@@__IMMUTABLE_RECORD__@@'] != null) {
    return true;
  } // DOM nodes:

  if (Recoil_isNode(value)) {
    return true;
  }
  if (Recoil_isPromise(value)) {
    return true;
  }
  if (value instanceof Error) {
    return true;
  }
  if (ArrayBuffer.isView(value)) {
    return true;
  } // Some environments, just as Jest, don't work with the instanceof check

  if (!isReactNative$1 && isWindow$1(value)) {
    return true;
  }
  return false;
} // Recursively freeze a value to enforce it is read-only.
// This may also have minimal performance improvements for enumerating
// objects (based on browser implementations, of course)

function deepFreezeValue(value) {
  if (typeof value !== 'object' || shouldNotBeFrozen(value)) {
    return;
  }
  Object.freeze(value); // Make all properties read-only

  for (var key in value) {
    // $FlowIssue[method-unbinding] added when improving typing for this parameters
    if (Object.prototype.hasOwnProperty.call(value, key)) {
      var prop = value[key]; // Prevent infinite recurssion for circular references.

      if (typeof prop === 'object' && prop != null && !Object.isFrozen(prop)) {
        deepFreezeValue(prop);
      }
    }
  }
  Object.seal(value); // This also makes existing properties non-configurable.
}

var Recoil_deepFreezeValue = (/* unused pure expression or super */ null && (deepFreezeValue));

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * This is a stub for some integration into FB internal stuff
 *
 * 
 * @format
 * @oncall recoil
 */
function startPerfBlock(_id) {
  return function () {
    return null;
  };
}
var Recoil_PerformanceTimings = {
  startPerfBlock: startPerfBlock
};
var isLoadable$1 = Recoil_Loadable$1.isLoadable,
  loadableWithError$1 = Recoil_Loadable$1.loadableWithError,
  loadableWithPromise$1 = Recoil_Loadable$1.loadableWithPromise,
  loadableWithValue$2 = Recoil_Loadable$1.loadableWithValue;
var WrappedValue$1 = Recoil_Wrapper$1.WrappedValue;
var getNodeLoadable$2 = Recoil_FunctionalCore.getNodeLoadable,
  peekNodeLoadable$1 = Recoil_FunctionalCore.peekNodeLoadable,
  setNodeValue$3 = Recoil_FunctionalCore.setNodeValue;
var saveDepsToStore$1 = Recoil_Graph.saveDepsToStore;
var DEFAULT_VALUE$6 = Recoil_Node.DEFAULT_VALUE,
  getConfigDeletionHandler$1 = Recoil_Node.getConfigDeletionHandler,
  getNode$6 = Recoil_Node.getNode,
  registerNode$1 = Recoil_Node.registerNode;
var isRecoilValue$3 = Recoil_RecoilValue$1.isRecoilValue;
var markRecoilValueModified$1 = Recoil_RecoilValueInterface.markRecoilValueModified;
var retainedByOptionWithDefault$1 = Recoil_Retention.retainedByOptionWithDefault;
var recoilCallback$1 = Recoil_useRecoilCallback.recoilCallback;
var startPerfBlock$1 = Recoil_PerformanceTimings.startPerfBlock;
var Canceled = /*#__PURE__*/_createClass(function Canceled() {
  _classCallCheck(this, Canceled);
});
var CANCELED = new Canceled();
/**
 * An ExecutionID is an arbitrary ID that lets us distinguish executions from
 * each other. This is necessary as we need a way of solving this problem:
 * "given 3 async executions, only update state for the 'latest' execution when
 * it finishes running regardless of when the other 2 finish". ExecutionIDs
 * provide a convenient way of identifying executions so that we can track and
 * manage them over time.
 */

var dependencyStack = []; // for detecting circular dependencies.

var waitingStores = new Map();
var getNewExecutionID = function () {
  var executionID = 0;
  return function () {
    return executionID++;
  };
}();
/* eslint-disable no-redeclare */

function selector(options) {
  var recoilValue = null;
  var key = options.key,
    get = options.get,
    cachePolicy = options.cachePolicy_UNSTABLE;
  var set = options.set != null ? options.set : undefined; // flow

  if (false) {} // This is every discovered dependency across all executions

  var discoveredDependencyNodeKeys = new Set();
  var cache = Recoil_treeCacheFromPolicy(cachePolicy !== null && cachePolicy !== void 0 ? cachePolicy : {
    equality: 'reference',
    eviction: 'keep-all'
  }, key);
  var retainedBy = retainedByOptionWithDefault$1(options.retainedBy_UNSTABLE);
  var executionInfoMap = new Map();
  var liveStoresCount = 0;
  function selectorIsLive() {
    return !Recoil_gkx('recoil_memory_managament_2020') || liveStoresCount > 0;
  }
  function selectorInit(store) {
    store.getState().knownSelectors.add(key);
    liveStoresCount++;
    return function () {
      liveStoresCount--;
    };
  }
  function selectorShouldDeleteConfigOnRelease() {
    return getConfigDeletionHandler$1(key) !== undefined && !selectorIsLive();
  }
  function resolveAsync(store, state, executionID, loadable, depValues) {
    setCache(state, loadable, depValues);
    notifyStoresOfResolvedAsync(store, executionID);
  }
  function notifyStoresOfResolvedAsync(store, executionID) {
    if (isLatestExecution(store, executionID)) {
      clearExecutionInfo(store);
    }
    notifyWaitingStores(executionID, true);
  }
  /**
   * Notify stores to pull the selector again if a new async dep was discovered.
   * 1) Async selector adds a new dep but doesn't resolve yet.
   *    Note that deps for an async selector are based on the state when the
   *    evaluation started, in order to provide a consistent picture of state.
   * 2) But, new value of dep based on the current state might cause the selector
   *    to resolve or resolve differently.
   * 3) Therefore, this notification will pull the selector based on the current
   *    state for the components
   */

  function notifyStoresOfNewAsyncDep(store, executionID) {
    if (isLatestExecution(store, executionID)) {
      var executionInfo = Recoil_nullthrows(getExecutionInfo(store));
      executionInfo.stateVersions.clear();
      notifyWaitingStores(executionID, false);
    }
  }
  function notifyWaitingStores(executionID, clearWaitlist) {
    var stores = waitingStores.get(executionID);
    if (stores != null) {
      var _iterator48 = _createForOfIteratorHelper(stores),
        _step48;
      try {
        for (_iterator48.s(); !(_step48 = _iterator48.n()).done;) {
          var waitingStore = _step48.value;
          markRecoilValueModified$1(waitingStore, Recoil_nullthrows(recoilValue));
        }
      } catch (err) {
        _iterator48.e(err);
      } finally {
        _iterator48.f();
      }
      if (clearWaitlist) {
        waitingStores.delete(executionID);
      }
    }
  }
  function markStoreWaitingForResolvedAsync(store, executionID) {
    var stores = waitingStores.get(executionID);
    if (stores == null) {
      waitingStores.set(executionID, stores = new Set());
    }
    stores.add(store);
  }
  /**
   * This function attaches a then() and a catch() to a promise that was
   * returned from a selector's get() (either explicitly or implicitly by
   * running a function that uses the "async" keyword). If a selector's get()
   * returns a promise, we have two possibilities:
   *
   * 1. The promise will resolve, in which case it will have completely finished
   *    executing without any remaining pending dependencies. No more retries
   *    are needed and we can proceed with updating the cache and notifying
   *    subscribers (if it is the latest execution, otherwise only the cache
   *    will be updated and subscriptions will not be fired). This is the case
   *    handled by the attached then() handler.
   *
   * 2. The promise will throw because it either has an error or it came across
   *    an async dependency that has not yet resolved, in which case we will
   *    call wrapDepdencyPromise(), whose responsibility is to handle dependency
   *    promises. This case is handled by the attached catch() handler.
   *
   * Both branches will eventually resolve to the final result of the selector
   * (or an error if a real error occurred).
   *
   * The execution will run to completion even if it is stale, and its value
   * will be cached. But stale executions will not update global state or update
   * executionInfo as that is the responsibility of the 'latest' execution.
   *
   * Note this function should not be passed a promise that was thrown--AKA a
   * dependency promise. Dependency promises should be passed to
   * wrapPendingDependencyPromise()).
   */

  function wrapResultPromise(store, promise, state, depValues, executionID, loadingDepsState) {
    return promise.then(function (value) {
      if (!selectorIsLive()) {
        // The selector was released since the request began; ignore the response.
        clearExecutionInfo(store);
        throw CANCELED;
      }
      var loadable = loadableWithValue$2(value);
      resolveAsync(store, state, executionID, loadable, depValues);
      return value;
    }).catch(function (errorOrPromise) {
      if (!selectorIsLive()) {
        // The selector was released since the request began; ignore the response.
        clearExecutionInfo(store);
        throw CANCELED;
      }
      if (Recoil_isPromise(errorOrPromise)) {
        return wrapPendingDependencyPromise(store, errorOrPromise, state, depValues, executionID, loadingDepsState);
      }
      var loadable = loadableWithError$1(errorOrPromise);
      resolveAsync(store, state, executionID, loadable, depValues);
      throw errorOrPromise;
    });
  }
  /**
   * This function attaches a then() and a catch() to a promise that was
   * thrown from a selector's get(). If a selector's get() throws a promise,
   * we have two possibilities:
   *
   * 1. The promise will resolve, meaning one of our selector's dependencies is
   *    now available and we should "retry" our get() by running it again. This
   *    is the case handled by the attached then() handler.
   *
   * 2. The promise will throw because something went wrong with the dependency
   *    promise (in other words a real error occurred). This case is handled by
   *    the attached catch() handler. If the dependency promise throws, it is
   *    _always_ a real error and not another dependency promise (any dependency
   *    promises would have been handled upstream).
   *
   * The then() branch will eventually resolve to the final result of the
   * selector (or an error if a real error occurs), and the catch() will always
   * resolve to an error because the dependency promise is a promise that was
   * wrapped upstream, meaning it will only resolve to its real value or to a
   * real error.
   *
   * The execution will run to completion even if it is stale, and its value
   * will be cached. But stale executions will not update global state or update
   * executionInfo as that is the responsibility of the 'latest' execution.
   *
   * Note this function should not be passed a promise that was returned from
   * get(). The intention is that this function is only passed promises that
   * were thrown due to a pending dependency. Promises returned by get() should
   * be passed to wrapResultPromise() instead.
   */

  function wrapPendingDependencyPromise(store, promise, state, existingDeps, executionID, loadingDepsState) {
    return promise.then(function (resolvedDep) {
      if (!selectorIsLive()) {
        // The selector was released since the request began; ignore the response.
        clearExecutionInfo(store);
        throw CANCELED;
      } // Check if we are handling a pending Recoil dependency or if the user
      // threw their own Promise to "suspend" a selector evaluation.  We need
      // to check that the loadingDepPromise actually matches the promise that
      // we caught in case the selector happened to catch the promise we threw
      // for a pending Recoil dependency from `getRecoilValue()` and threw
      // their own promise instead.

      if (loadingDepsState.loadingDepKey != null && loadingDepsState.loadingDepPromise === promise) {
        /**
         * Note for async atoms, this means we are changing the atom's value
         * in the store for the given version. This should be alright because
         * the version of state is now stale and a new version will have
         * already been triggered by the atom being resolved (see this logic
         * in Recoil_atom.js)
         */
        state.atomValues.set(loadingDepsState.loadingDepKey, loadableWithValue$2(resolvedDep));
      } else {
        /**
         * If resolvedDepKey is not defined, the promise was a user-thrown
         * promise. User-thrown promises are an advanced feature and they
         * should be avoided in almost all cases. Using `loadable.map()` inside
         * of selectors for loading loadables and then throwing that mapped
         * loadable's promise is an example of a user-thrown promise.
         *
         * When we hit a user-thrown promise, we have to bail out of an optimization
         * where we bypass calculating selector cache keys for selectors that
         * have been previously seen for a given state (these selectors are saved in
         * state.atomValues) to avoid stale state as we have no way of knowing
         * what state changes happened (if any) in result to the promise resolving.
         *
         * Ideally we would only bail out selectors that are in the chain of
         * dependencies for this selector, but there's currently no way to get
         * a full list of a selector's downstream nodes because the state that
         * is executing may be a discarded tree (so store.getGraph(state.version)
         * will be empty), and the full dep tree may not be in the selector
         * caches in the case where the selector's cache was cleared. To solve
         * for this we would have to keep track of all running selector
         * executions and their downstream deps. Because this only covers edge
         * cases, that complexity might not be justifyable.
         */
        store.getState().knownSelectors.forEach(function (nodeKey) {
          state.atomValues.delete(nodeKey);
        });
      }
      /**
       * Optimization: Now that the dependency has resolved, let's try hitting
       * the cache in case the dep resolved to a value we have previously seen.
       *
       * TODO:
       * Note this optimization is not perfect because it only prevents re-executions
       * _after_ the point where an async dependency is found. Any code leading
       * up to the async dependency may have run unnecessarily. The ideal case
       * would be to wait for the async dependency to resolve first, check the
       * cache, and prevent _any_ execution of the selector if the resulting
       * value of the dependency leads to a path that is found in the cache.
       * The ideal case is more difficult to implement as it would require that
       * we capture and wait for the the async dependency right after checking
       * the cache. The current approach takes advantage of the fact that running
       * the selector already has a code path that lets us exit early when
       * an async dep resolves.
       */

      var cachedLoadable = getLoadableFromCacheAndUpdateDeps(store, state);
      if (cachedLoadable && cachedLoadable.state !== 'loading') {
        /**
         * This has to notify stores of a resolved async, even if there is no
         * current pending execution for the following case:
         * 1) A component renders with this pending loadable.
         * 2) The upstream dependency resolves.
         * 3) While processing some other selector it reads this one, such as
         *    while traversing its dependencies.  At this point it gets the
         *    new resolved value synchronously and clears the current
         *    execution ID.  The component wasn't getting the value itself,
         *    though, so it still has the pending loadable.
         * 4) When this code executes the current execution id was cleared
         *    and it wouldn't notify the component of the new value.
         *
         * I think this is only an issue with "early" rendering since the
         * components got their value using the in-progress execution.
         * We don't have a unit test for this case yet.  I'm not sure it is
         * necessary with recoil_transition_support mode.
         */
        if (isLatestExecution(store, executionID) || getExecutionInfo(store) == null) {
          notifyStoresOfResolvedAsync(store, executionID);
        }
        if (cachedLoadable.state === 'hasValue') {
          return cachedLoadable.contents;
        } else {
          throw cachedLoadable.contents;
        }
      }
      /**
       * If this execution is stale, let's check to see if there is some in
       * progress execution with a matching state. If we find a match, then
       * we can take the value from that in-progress execution. Note this may
       * sound like an edge case, but may be very common in cases where a
       * loading dependency resolves from loading to having a value (thus
       * possibly triggering a re-render), and React re-renders before the
       * chained .then() functions run, thus starting a new execution as the
       * dep has changed value. Without this check we will run the selector
       * twice (once in the new execution and once again in this .then(), so
       * this check is necessary to keep unnecessary re-executions to a
       * minimum).
       *
       * Also note this code does not check across all executions that may be
       * running. It only optimizes for the _latest_ execution per store as
       * we currently do not maintain a list of all currently running executions.
       * This means in some cases we may run selectors more than strictly
       * necessary when there are multiple executions running for the same
       * selector. This may be a valid tradeoff as checking for dep changes
       * across all in-progress executions may take longer than just
       * re-running the selector. This will be app-dependent, and maybe in the
       * future we can make the behavior configurable. An ideal fix may be
       * to extend the tree cache to support caching loading states.
       */

      if (!isLatestExecution(store, executionID)) {
        var executionInfo = getInProgressExecutionInfo(store, state);
        if (executionInfo != null) {
          /**
           * Returning promise here without wrapping as the wrapper logic was
           * already done upstream when this promise was generated.
           */
          return executionInfo.loadingLoadable.contents;
        }
      } // Retry the selector evaluation now that the dependency has resolved

      var _evaluateSelectorGett = evaluateSelectorGetter(store, state, executionID),
        _evaluateSelectorGett2 = slicedToArray_slicedToArray(_evaluateSelectorGett, 2),
        loadable = _evaluateSelectorGett2[0],
        depValues = _evaluateSelectorGett2[1];
      if (loadable.state !== 'loading') {
        resolveAsync(store, state, executionID, loadable, depValues);
      }
      if (loadable.state === 'hasError') {
        throw loadable.contents;
      }
      return loadable.contents;
    }).catch(function (error) {
      // The selector was released since the request began; ignore the response.
      if (error instanceof Canceled) {
        throw CANCELED;
      }
      if (!selectorIsLive()) {
        clearExecutionInfo(store);
        throw CANCELED;
      }
      var loadable = loadableWithError$1(error);
      resolveAsync(store, state, executionID, loadable, existingDeps);
      throw error;
    });
  }
  function updateDeps(store, state, deps, executionID) {
    var _store$getState, _store$getState$curre, _store$getState2, _store$getState2$next;
    if (isLatestExecution(store, executionID) || state.version === ((_store$getState = store.getState()) === null || _store$getState === void 0 ? void 0 : (_store$getState$curre = _store$getState.currentTree) === null || _store$getState$curre === void 0 ? void 0 : _store$getState$curre.version) || state.version === ((_store$getState2 = store.getState()) === null || _store$getState2 === void 0 ? void 0 : (_store$getState2$next = _store$getState2.nextTree) === null || _store$getState2$next === void 0 ? void 0 : _store$getState2$next.version)) {
      var _store$getState$nextT, _store$getState3, _store$getState3$next;
      saveDepsToStore$1(key, deps, store, (_store$getState$nextT = (_store$getState3 = store.getState()) === null || _store$getState3 === void 0 ? void 0 : (_store$getState3$next = _store$getState3.nextTree) === null || _store$getState3$next === void 0 ? void 0 : _store$getState3$next.version) !== null && _store$getState$nextT !== void 0 ? _store$getState$nextT : store.getState().currentTree.version);
    }
    var _iterator49 = _createForOfIteratorHelper(deps),
      _step49;
    try {
      for (_iterator49.s(); !(_step49 = _iterator49.n()).done;) {
        var nodeKey = _step49.value;
        discoveredDependencyNodeKeys.add(nodeKey);
      }
    } catch (err) {
      _iterator49.e(err);
    } finally {
      _iterator49.f();
    }
  }
  function evaluateSelectorGetter(store, state, executionID) {
    var endPerfBlock = startPerfBlock$1(key); // TODO T63965866: use execution ID here

    var duringSynchronousExecution = true;
    var duringAsynchronousExecution = true;
    var finishEvaluation = function finishEvaluation() {
      endPerfBlock();
      duringAsynchronousExecution = false;
    };
    var result;
    var resultIsError = false;
    var loadable;
    var loadingDepsState = {
      loadingDepKey: null,
      loadingDepPromise: null
    };
    /**
     * Starting a fresh set of deps that we'll be using to update state. We're
     * starting a new set versus adding it in existing state deps because
     * the version of state that we update deps for may be a more recent version
     * than the version the selector was called with. This is because the latest
     * execution will update the deps of the current/latest version of state
     * (This is safe to do because the fact that the selector is the latest
     * execution means the deps we discover below are our best guess at the
     * deps for the current/latest state in the store)
     */

    var depValues = new Map();
    function getRecoilValue(_ref19) {
      var depKey = _ref19.key;
      var depLoadable = getNodeLoadable$2(store, state, depKey);
      depValues.set(depKey, depLoadable); // We need to update asynchronous dependencies as we go so the selector
      // knows if it has to restart evaluation if one of them is updated before
      // the asynchronous selector completely resolves.

      if (!duringSynchronousExecution) {
        updateDeps(store, state, new Set(depValues.keys()), executionID);
        notifyStoresOfNewAsyncDep(store, executionID);
      }
      switch (depLoadable.state) {
        case 'hasValue':
          return depLoadable.contents;
        case 'hasError':
          throw depLoadable.contents;
        case 'loading':
          loadingDepsState.loadingDepKey = depKey;
          loadingDepsState.loadingDepPromise = depLoadable.contents;
          throw depLoadable.contents;
      }
      throw Recoil_err('Invalid Loadable state');
    }
    var getCallback = function getCallback(fn) {
      return function () {
        if (duringAsynchronousExecution) {
          throw Recoil_err('Callbacks from getCallback() should only be called asynchronously after the selector is evalutated.  It can be used for selectors to return objects with callbacks that can work with Recoil state without a subscription.');
        }
        !(recoilValue != null) ?  false ? 0 : Recoil_invariant(false) : void 0;
        for (var _len8 = arguments.length, args = new Array(_len8), _key11 = 0; _key11 < _len8; _key11++) {
          args[_key11] = arguments[_key11];
        }
        return recoilCallback$1(store, fn, args, {
          node: recoilValue
        } // flowlint-line unclear-type:off
        );
      };
    };

    try {
      result = get({
        get: getRecoilValue,
        getCallback: getCallback
      });
      result = isRecoilValue$3(result) ? getRecoilValue(result) : result;
      if (isLoadable$1(result)) {
        if (result.state === 'hasError') {
          resultIsError = true;
        }
        result = result.contents;
      }
      if (Recoil_isPromise(result)) {
        result = wrapResultPromise(store, result, state, depValues, executionID, loadingDepsState).finally(finishEvaluation);
      } else {
        finishEvaluation();
      }
      result = result instanceof WrappedValue$1 ? result.value : result;
    } catch (errorOrDepPromise) {
      result = errorOrDepPromise;
      if (Recoil_isPromise(result)) {
        result = wrapPendingDependencyPromise(store, result, state, depValues, executionID, loadingDepsState).finally(finishEvaluation);
      } else {
        resultIsError = true;
        finishEvaluation();
      }
    }
    if (resultIsError) {
      loadable = loadableWithError$1(result);
    } else if (Recoil_isPromise(result)) {
      loadable = loadableWithPromise$1(result);
    } else {
      loadable = loadableWithValue$2(result);
    }
    duringSynchronousExecution = false;
    updateExecutionInfoDepValues(store, executionID, depValues);
    updateDeps(store, state, new Set(depValues.keys()), executionID);
    return [loadable, depValues];
  }
  function getLoadableFromCacheAndUpdateDeps(store, state) {
    // First, look up in the state cache
    // If it's here, then the deps in the store should already be valid.
    var cachedLoadable = state.atomValues.get(key);
    if (cachedLoadable != null) {
      return cachedLoadable;
    } // Second, look up in the selector cache and update the deps in the store

    var depsAfterCacheLookup = new Set();
    try {
      cachedLoadable = cache.get(function (nodeKey) {
        !(typeof nodeKey === 'string') ?  false ? 0 : Recoil_invariant(false) : void 0;
        return getNodeLoadable$2(store, state, nodeKey).contents;
      }, {
        onNodeVisit: function onNodeVisit(node) {
          if (node.type === 'branch' && node.nodeKey !== key) {
            depsAfterCacheLookup.add(node.nodeKey);
          }
        }
      });
    } catch (error) {
      throw Recoil_err("Problem with cache lookup for selector \"".concat(key, "\": ").concat(error.message));
    }
    if (cachedLoadable) {
      var _getExecutionInfo;

      // Cache the results in the state to allow for cheaper lookup than
      // iterating the tree cache of dependencies.
      state.atomValues.set(key, cachedLoadable);
      /**
       * Ensure store contains correct dependencies if we hit the cache so that
       * the store deps and cache are in sync for a given state. This is important
       * because store deps are normally updated when new executions are created,
       * but cache hits don't trigger new executions but they still _may_ signify
       * a change in deps in the store if the store deps for this state are empty
       * or stale.
       */

      updateDeps(store, state, depsAfterCacheLookup, (_getExecutionInfo = getExecutionInfo(store)) === null || _getExecutionInfo === void 0 ? void 0 : _getExecutionInfo.executionID);
    }
    return cachedLoadable;
  }
  /**
   * Given a tree state, this function returns a Loadable of the current state.
   *
   * The selector's get() function will only be re-evaluated if _both_ of the
   * following statements are true:
   *
   * 1. The current dep values from the given state produced a cache key that
   *    was not found in the cache.
   * 2. There is no currently running async execution OR there is an
   *    async execution that is running, but after comparing the dep values in
   *    the given state with the dep values that the execution has discovered so
   *    far we find that at least one dep value has changed, in which case we
   *    start a new execution (the previously running execution will continue to
   *    run to completion, but only the new execution will be deemed the
   *    'latest' execution, meaning it will be the only execution that will
   *    update global state when it is finished. Any non-latest executions will
   *    run to completion and update the selector cache but not global state).
   */

  function getSelectorLoadableAndUpdateDeps(store, state) {
    // First, see if our current state is cached
    var cachedVal = getLoadableFromCacheAndUpdateDeps(store, state);
    if (cachedVal != null) {
      clearExecutionInfo(store);
      return cachedVal;
    } // Second, check if there is already an ongoing execution based on the current state

    var inProgressExecutionInfo = getInProgressExecutionInfo(store, state);
    if (inProgressExecutionInfo != null) {
      var _inProgressExecutionI;
      if (((_inProgressExecutionI = inProgressExecutionInfo.loadingLoadable) === null || _inProgressExecutionI === void 0 ? void 0 : _inProgressExecutionI.state) === 'loading') {
        markStoreWaitingForResolvedAsync(store, inProgressExecutionInfo.executionID);
      } // FIXME: check after the fact to see if we made the right choice by waiting

      return inProgressExecutionInfo.loadingLoadable;
    } // Third, start a new evaluation of the selector

    var newExecutionID = getNewExecutionID();
    var _evaluateSelectorGett3 = evaluateSelectorGetter(store, state, newExecutionID),
      _evaluateSelectorGett4 = slicedToArray_slicedToArray(_evaluateSelectorGett3, 2),
      loadable = _evaluateSelectorGett4[0],
      newDepValues = _evaluateSelectorGett4[1];
    /**
     * Conditionally updates the cache with a given loadable.
     *
     * We only cache loadables that are not loading because our cache keys are
     * based on dep values, which are in an unfinished state for loadables that
     * have a 'loading' state (new deps may be discovered while the selector
     * runs its async code). We never want to cache partial dependencies b/c it
     * could lead to errors, such as prematurely returning the result based on a
     * partial list of deps-- we need the full list of deps to ensure that we
     * are returning the correct result from cache.
     */

    if (loadable.state === 'loading') {
      setExecutionInfo(store, newExecutionID, loadable, newDepValues, state);
      markStoreWaitingForResolvedAsync(store, newExecutionID);
    } else {
      clearExecutionInfo(store);
      setCache(state, loadable, newDepValues);
    }
    return loadable;
  }
  /**
   * Searches execution info across all stores to see if there is an in-progress
   * execution whose dependency values match the values of the requesting store.
   */

  function getInProgressExecutionInfo(store, state) {
    // Sort the pending executions so that our current store is checked first.
    var pendingExecutions = Recoil_concatIterables([executionInfoMap.has(store) ? [Recoil_nullthrows(executionInfoMap.get(store))] : [], Recoil_mapIterable(Recoil_filterIterable(executionInfoMap, function (_ref20) {
      var _ref21 = slicedToArray_slicedToArray(_ref20, 1),
        s = _ref21[0];
      return s !== store;
    }), function (_ref22) {
      var _ref23 = slicedToArray_slicedToArray(_ref22, 2),
        execInfo = _ref23[1];
      return execInfo;
    })]);
    function anyDepChanged(execDepValues) {
      var _iterator50 = _createForOfIteratorHelper(execDepValues),
        _step50;
      try {
        for (_iterator50.s(); !(_step50 = _iterator50.n()).done;) {
          var _step50$value = slicedToArray_slicedToArray(_step50.value, 2),
            depKey = _step50$value[0],
            execLoadable = _step50$value[1];
          if (!getNodeLoadable$2(store, state, depKey).is(execLoadable)) {
            return true;
          }
        }
      } catch (err) {
        _iterator50.e(err);
      } finally {
        _iterator50.f();
      }
      return false;
    }
    var _iterator51 = _createForOfIteratorHelper(pendingExecutions),
      _step51;
    try {
      for (_iterator51.s(); !(_step51 = _iterator51.n()).done;) {
        var execInfo = _step51.value;
        if (
        // If this execution was already checked to be valid with this version
        // of state, then let's use it!
        execInfo.stateVersions.get(state.version) ||
        // If the deps for the execution match our current state, then it's valid
        !anyDepChanged(execInfo.depValuesDiscoveredSoFarDuringAsyncWork)) {
          execInfo.stateVersions.set(state.version, true);
          return execInfo;
        } else {
          execInfo.stateVersions.set(state.version, false);
        }
      }
    } catch (err) {
      _iterator51.e(err);
    } finally {
      _iterator51.f();
    }
    return undefined;
  }
  function getExecutionInfo(store) {
    return executionInfoMap.get(store);
  }
  /**
   * This function will update the selector's execution info when the selector
   * has either finished running an execution or has started a new execution. If
   * the given loadable is in a 'loading' state, the intention is that a new
   * execution has started. Otherwise, the intention is that an execution has
   * just finished.
   */

  function setExecutionInfo(store, newExecutionID, loadable, depValues, state) {
    executionInfoMap.set(store, {
      depValuesDiscoveredSoFarDuringAsyncWork: depValues,
      executionID: newExecutionID,
      loadingLoadable: loadable,
      stateVersions: new Map([[state.version, true]])
    });
  }
  function updateExecutionInfoDepValues(store, executionID, depValues) {
    // We only need to bother updating the deps for the latest execution because
    // that's all getInProgressExecutionInfo() will be looking for.
    if (isLatestExecution(store, executionID)) {
      var executionInfo = getExecutionInfo(store);
      if (executionInfo != null) {
        executionInfo.depValuesDiscoveredSoFarDuringAsyncWork = depValues;
      }
    }
  }
  function clearExecutionInfo(store) {
    executionInfoMap.delete(store);
  }
  function isLatestExecution(store, executionID) {
    var _getExecutionInfo2;
    return executionID === ((_getExecutionInfo2 = getExecutionInfo(store)) === null || _getExecutionInfo2 === void 0 ? void 0 : _getExecutionInfo2.executionID);
  }
  /**
   * FIXME: dep keys should take into account the state of the loadable to
   * prevent the edge case where a loadable with an error and a loadable with
   * an error as a value are treated as the same thing incorrectly. For example
   * these two should be treated differently:
   *
   * selector({key: '', get: () => new Error('hi')});
   * selector({key: '', get () => {throw new Error('hi')}});
   *
   * With current implementation they are treated the same
   */

  function depValuesToDepRoute(depValues) {
    return Array.from(depValues.entries()).map(function (_ref24) {
      var _ref25 = slicedToArray_slicedToArray(_ref24, 2),
        depKey = _ref25[0],
        valLoadable = _ref25[1];
      return [depKey, valLoadable.contents];
    });
  }
  function setCache(state, loadable, depValues) {
    if (false) {}
    state.atomValues.set(key, loadable);
    try {
      cache.set(depValuesToDepRoute(depValues), loadable);
    } catch (error) {
      throw Recoil_err("Problem with setting cache for selector \"".concat(key, "\": ").concat(error.message));
    }
  }
  function detectCircularDependencies(fn) {
    if (dependencyStack.includes(key)) {
      var message = "Recoil selector has circular dependencies: ".concat(dependencyStack.slice(dependencyStack.indexOf(key)).join(" \u2192 "));
      return loadableWithError$1(Recoil_err(message));
    }
    dependencyStack.push(key);
    try {
      return fn();
    } finally {
      dependencyStack.pop();
    }
  }
  function selectorPeek(store, state) {
    var cachedLoadable = state.atomValues.get(key);
    if (cachedLoadable != null) {
      return cachedLoadable;
    }
    return cache.get(function (nodeKey) {
      var _peekNodeLoadable;
      !(typeof nodeKey === 'string') ?  false ? 0 : Recoil_invariant(false) : void 0;
      return (_peekNodeLoadable = peekNodeLoadable$1(store, state, nodeKey)) === null || _peekNodeLoadable === void 0 ? void 0 : _peekNodeLoadable.contents;
    });
  }
  function selectorGet(store, state) {
    return detectCircularDependencies(function () {
      return getSelectorLoadableAndUpdateDeps(store, state);
    });
  }
  function invalidateSelector(state) {
    state.atomValues.delete(key);
  }
  function clearSelectorCache(store, treeState) {
    !(recoilValue != null) ?  false ? 0 : Recoil_invariant(false) : void 0;
    var _iterator52 = _createForOfIteratorHelper(discoveredDependencyNodeKeys),
      _step52;
    try {
      for (_iterator52.s(); !(_step52 = _iterator52.n()).done;) {
        var nodeKey = _step52.value;
        var _node$clearCache;
        var node = getNode$6(nodeKey);
        (_node$clearCache = node.clearCache) === null || _node$clearCache === void 0 ? void 0 : _node$clearCache.call(node, store, treeState);
      }
    } catch (err) {
      _iterator52.e(err);
    } finally {
      _iterator52.f();
    }
    discoveredDependencyNodeKeys.clear();
    invalidateSelector(treeState);
    cache.clear();
    markRecoilValueModified$1(store, recoilValue);
  }
  if (set != null) {
    /**
     * ES5 strict mode prohibits defining non-top-level function declarations,
     * so don't use function declaration syntax here
     */
    var selectorSet = function selectorSet(store, state, newValue) {
      var syncSelectorSetFinished = false;
      var writes = new Map();
      function getRecoilValue(_ref26) {
        var depKey = _ref26.key;
        if (syncSelectorSetFinished) {
          throw Recoil_err('Recoil: Async selector sets are not currently supported.');
        }
        var loadable = getNodeLoadable$2(store, state, depKey);
        if (loadable.state === 'hasValue') {
          return loadable.contents;
        } else if (loadable.state === 'loading') {
          var msg = "Getting value of asynchronous atom or selector \"".concat(depKey, "\" in a pending state while setting selector \"").concat(key, "\" is not yet supported.");
          Recoil_recoverableViolation(msg);
          throw Recoil_err(msg);
        } else {
          throw loadable.contents;
        }
      }
      function setRecoilState(recoilState, valueOrUpdater // $FlowFixMe[missing-local-annot]
      ) {
        if (syncSelectorSetFinished) {
          var msg = 'Recoil: Async selector sets are not currently supported.';
          Recoil_recoverableViolation(msg);
          throw Recoil_err(msg);
        }
        var setValue = typeof valueOrUpdater === 'function' ?
        // cast to any because we can't restrict type S from being a function itself without losing support for opaque types
        // flowlint-next-line unclear-type:off
        valueOrUpdater(getRecoilValue(recoilState)) : valueOrUpdater;
        var upstreamWrites = setNodeValue$3(store, state, recoilState.key, setValue);
        upstreamWrites.forEach(function (v, k) {
          return writes.set(k, v);
        });
      }
      function resetRecoilState(recoilState) {
        setRecoilState(recoilState, DEFAULT_VALUE$6);
      }
      var ret = set({
        set: setRecoilState,
        get: getRecoilValue,
        reset: resetRecoilState
      }, newValue); // set should be a void method, but if the user makes it `async`, then it
      // will return a Promise, which we don't currently support.

      if (ret !== undefined) {
        throw Recoil_isPromise(ret) ? Recoil_err('Recoil: Async selector sets are not currently supported.') : Recoil_err('Recoil: selector set should be a void function.');
      }
      syncSelectorSetFinished = true;
      return writes;
    };
    return recoilValue = registerNode$1({
      key: key,
      nodeType: 'selector',
      peek: selectorPeek,
      get: selectorGet,
      set: selectorSet,
      init: selectorInit,
      invalidate: invalidateSelector,
      clearCache: clearSelectorCache,
      shouldDeleteConfigOnRelease: selectorShouldDeleteConfigOnRelease,
      dangerouslyAllowMutability: options.dangerouslyAllowMutability,
      shouldRestoreFromSnapshots: false,
      retainedBy: retainedBy
    });
  } else {
    return recoilValue = registerNode$1({
      key: key,
      nodeType: 'selector',
      peek: selectorPeek,
      get: selectorGet,
      init: selectorInit,
      invalidate: invalidateSelector,
      clearCache: clearSelectorCache,
      shouldDeleteConfigOnRelease: selectorShouldDeleteConfigOnRelease,
      dangerouslyAllowMutability: options.dangerouslyAllowMutability,
      shouldRestoreFromSnapshots: false,
      retainedBy: retainedBy
    });
  }
}
/* eslint-enable no-redeclare */
// $FlowIssue[incompatible-use]
// $FlowFixMe[missing-local-annot]

selector.value = function (value) {
  return new WrappedValue$1(value);
};
var Recoil_selector = selector;

// @fb-only: import type {ScopeRules} from 'Recoil_ScopedAtom';
// @fb-only: const {scopedAtom} = require('Recoil_ScopedAtom');
var isLoadable$2 = Recoil_Loadable$1.isLoadable,
  loadableWithError$2 = Recoil_Loadable$1.loadableWithError,
  loadableWithPromise$2 = Recoil_Loadable$1.loadableWithPromise,
  loadableWithValue$3 = Recoil_Loadable$1.loadableWithValue;
var WrappedValue$2 = Recoil_Wrapper$1.WrappedValue;
var peekNodeInfo$3 = Recoil_FunctionalCore.peekNodeInfo;
var DEFAULT_VALUE$7 = Recoil_Node.DEFAULT_VALUE,
  DefaultValue$2 = Recoil_Node.DefaultValue,
  getConfigDeletionHandler$2 = Recoil_Node.getConfigDeletionHandler,
  registerNode$2 = Recoil_Node.registerNode,
  setConfigDeletionHandler$1 = Recoil_Node.setConfigDeletionHandler;
var isRecoilValue$4 = Recoil_RecoilValue$1.isRecoilValue;
var getRecoilValueAsLoadable$4 = Recoil_RecoilValueInterface.getRecoilValueAsLoadable,
  markRecoilValueModified$2 = Recoil_RecoilValueInterface.markRecoilValueModified,
  setRecoilValue$4 = Recoil_RecoilValueInterface.setRecoilValue,
  setRecoilValueLoadable$2 = Recoil_RecoilValueInterface.setRecoilValueLoadable;
var retainedByOptionWithDefault$2 = Recoil_Retention.retainedByOptionWithDefault;
var unwrap = function unwrap(x) {
  return x instanceof WrappedValue$2 ? x.value : x;
};
function baseAtom(options) {
  var key = options.key,
    persistence = options.persistence_UNSTABLE;
  var retainedBy = retainedByOptionWithDefault$2(options.retainedBy_UNSTABLE);
  var liveStoresCount = 0;
  function unwrapPromise(promise) {
    return loadableWithPromise$2(promise.then(function (value) {
      defaultLoadable = loadableWithValue$3(value);
      return value;
    }).catch(function (error) {
      defaultLoadable = loadableWithError$2(error);
      throw error;
    }));
  }
  var defaultLoadable = Recoil_isPromise(options.default) ? unwrapPromise(options.default) : isLoadable$2(options.default) ? options.default.state === 'loading' ? unwrapPromise(options.default.contents) : options.default :
  // $FlowFixMe[incompatible-call]
  loadableWithValue$3(unwrap(options.default));
  maybeFreezeValueOrPromise(defaultLoadable.contents);
  var cachedAnswerForUnvalidatedValue = undefined; // Cleanup handlers for this atom
  // Rely on stable reference equality of the store to use it as a key per <RecoilRoot>

  var cleanupEffectsByStore = new Map();
  function maybeFreezeValueOrPromise(valueOrPromise) {
    if (false) {}
    return valueOrPromise;
  }
  function wrapPendingPromise(store, promise) {
    var wrappedPromise = promise.then(function (value) {
      var _store$getState$nextT, _state$atomValues$get;
      var state = (_store$getState$nextT = store.getState().nextTree) !== null && _store$getState$nextT !== void 0 ? _store$getState$nextT : store.getState().currentTree;
      if (((_state$atomValues$get = state.atomValues.get(key)) === null || _state$atomValues$get === void 0 ? void 0 : _state$atomValues$get.contents) === wrappedPromise) {
        setRecoilValue$4(store, node, value);
      }
      return value;
    }).catch(function (error) {
      var _store$getState$nextT2, _state$atomValues$get2;
      var state = (_store$getState$nextT2 = store.getState().nextTree) !== null && _store$getState$nextT2 !== void 0 ? _store$getState$nextT2 : store.getState().currentTree;
      if (((_state$atomValues$get2 = state.atomValues.get(key)) === null || _state$atomValues$get2 === void 0 ? void 0 : _state$atomValues$get2.contents) === wrappedPromise) {
        setRecoilValueLoadable$2(store, node, loadableWithError$2(error));
      }
      throw error;
    });
    return wrappedPromise;
  }
  function initAtom(store, initState, trigger) {
    var _options$effects;
    liveStoresCount++;
    var cleanupAtom = function cleanupAtom() {
      var _cleanupEffectsByStor;
      liveStoresCount--;
      (_cleanupEffectsByStor = cleanupEffectsByStore.get(store)) === null || _cleanupEffectsByStor === void 0 ? void 0 : _cleanupEffectsByStor.forEach(function (cleanup) {
        return cleanup();
      });
      cleanupEffectsByStore.delete(store);
    };
    store.getState().knownAtoms.add(key); // Setup async defaults to notify subscribers when they resolve

    if (defaultLoadable.state === 'loading') {
      var notifyDefaultSubscribers = function notifyDefaultSubscribers() {
        var _store$getState$nextT3;
        var state = (_store$getState$nextT3 = store.getState().nextTree) !== null && _store$getState$nextT3 !== void 0 ? _store$getState$nextT3 : store.getState().currentTree;
        if (!state.atomValues.has(key)) {
          markRecoilValueModified$2(store, node);
        }
      };
      defaultLoadable.contents.finally(notifyDefaultSubscribers);
    } ///////////////////
    // Run Atom Effects
    ///////////////////

    var effects = (_options$effects = options.effects) !== null && _options$effects !== void 0 ? _options$effects : options.effects_UNSTABLE;
    if (effects != null) {
      var getLoadable = function getLoadable(recoilValue) {
        // Normally we can just get the current value of another atom.
        // But for our own value we need to check if there is a pending
        // initialized value or get the fallback default value.
        if (isDuringInit && recoilValue.key === key) {
          // Cast T to S
          var retValue = initValue; // flowlint-line unclear-type:off

          return retValue instanceof DefaultValue$2 ? peekAtom(store, initState) // flowlint-line unclear-type:off
          : Recoil_isPromise(retValue) ? loadableWithPromise$2(retValue.then(function (v) {
            return v instanceof DefaultValue$2 ?
            // Cast T to S
            defaultLoadable.toPromise() // flowlint-line unclear-type:off
            : v;
          })) :
          // $FlowFixMe[incompatible-call]
          loadableWithValue$3(retValue);
        }
        return getRecoilValueAsLoadable$4(store, recoilValue);
      };
      var getPromise = function getPromise(recoilValue) {
        return getLoadable(recoilValue).toPromise();
      };
      var getInfo_UNSTABLE = function getInfo_UNSTABLE(recoilValue) {
        var _store$getState$nextT4;
        var info = peekNodeInfo$3(store, (_store$getState$nextT4 = store.getState().nextTree) !== null && _store$getState$nextT4 !== void 0 ? _store$getState$nextT4 : store.getState().currentTree, recoilValue.key);
        return isDuringInit && recoilValue.key === key && !(initValue instanceof DefaultValue$2) ? _objectSpread2(_objectSpread2({}, info), {}, {
          isSet: true,
          loadable: getLoadable(recoilValue)
        }) : info;
      };
      // This state is scoped by Store, since this is in the initAtom() closure
      var initValue = DEFAULT_VALUE$7;
      var isDuringInit = true;
      var isInitError = false;
      var pendingSetSelf = null;
      var setSelf = function setSelf(effect) {
        return function (valueOrUpdater) {
          if (isDuringInit) {
            var currentLoadable = getLoadable(node);
            var currentValue = currentLoadable.state === 'hasValue' ? currentLoadable.contents : DEFAULT_VALUE$7;
            initValue = typeof valueOrUpdater === 'function' ?
            // cast to any because we can't restrict T from being a function without losing support for opaque types
            valueOrUpdater(currentValue) // flowlint-line unclear-type:off
            : valueOrUpdater;
            if (Recoil_isPromise(initValue)) {
              initValue = initValue.then(function (value) {
                // Avoid calling onSet() when setSelf() initializes with a Promise
                pendingSetSelf = {
                  effect: effect,
                  value: value
                };
                return value;
              });
            }
          } else {
            if (Recoil_isPromise(valueOrUpdater)) {
              throw Recoil_err('Setting atoms to async values is not implemented.');
            }
            if (typeof valueOrUpdater !== 'function') {
              pendingSetSelf = {
                effect: effect,
                value: unwrap(valueOrUpdater)
              };
            }
            setRecoilValue$4(store, node, typeof valueOrUpdater === 'function' ? function (currentValue) {
              var newValue = unwrap(
              // cast to any because we can't restrict T from being a function without losing support for opaque types
              valueOrUpdater(currentValue) // flowlint-line unclear-type:off
              ); // $FlowFixMe[incompatible-type]

              pendingSetSelf = {
                effect: effect,
                value: newValue
              };
              return newValue;
            } : unwrap(valueOrUpdater));
          }
        };
      };
      var resetSelf = function resetSelf(effect) {
        return function () {
          return setSelf(effect)(DEFAULT_VALUE$7);
        };
      };
      var onSet = function onSet(effect) {
        return function (handler) {
          var _cleanupEffectsByStor2;
          var _store$subscribeToTra = store.subscribeToTransactions(function (currentStore) {
              var _currentTree$atomValu;

              // eslint-disable-next-line prefer-const
              var _currentStore$getStat = currentStore.getState(),
                currentTree = _currentStore$getStat.currentTree,
                previousTree = _currentStore$getStat.previousTree;
              if (!previousTree) {
                Recoil_recoverableViolation('Transaction subscribers notified without a next tree being present -- this is a bug in Recoil');
                previousTree = currentTree; // attempt to trundle on
              }

              var newLoadable = (_currentTree$atomValu = currentTree.atomValues.get(key)) !== null && _currentTree$atomValu !== void 0 ? _currentTree$atomValu : defaultLoadable;
              if (newLoadable.state === 'hasValue') {
                var _previousTree$atomVal, _pendingSetSelf, _pendingSetSelf2, _pendingSetSelf3;
                var newValue = newLoadable.contents;
                var oldLoadable = (_previousTree$atomVal = previousTree.atomValues.get(key)) !== null && _previousTree$atomVal !== void 0 ? _previousTree$atomVal : defaultLoadable;
                var oldValue = oldLoadable.state === 'hasValue' ? oldLoadable.contents : DEFAULT_VALUE$7; // TODO This isn't actually valid, use as a placeholder for now.
                // Ignore atom value changes that were set via setSelf() in the same effect.
                // We will still properly call the handler if there was a subsequent
                // set from something other than an atom effect which was batched
                // with the `setSelf()` call.  However, we may incorrectly ignore
                // the handler if the subsequent batched call happens to set the
                // atom to the exact same value as the `setSelf()`.   But, in that
                // case, it was kind of a noop, so the semantics are debatable..

                if (((_pendingSetSelf = pendingSetSelf) === null || _pendingSetSelf === void 0 ? void 0 : _pendingSetSelf.effect) !== effect || ((_pendingSetSelf2 = pendingSetSelf) === null || _pendingSetSelf2 === void 0 ? void 0 : _pendingSetSelf2.value) !== newValue) {
                  handler(newValue, oldValue, !currentTree.atomValues.has(key));
                } else if (((_pendingSetSelf3 = pendingSetSelf) === null || _pendingSetSelf3 === void 0 ? void 0 : _pendingSetSelf3.effect) === effect) {
                  pendingSetSelf = null;
                }
              }
            }, key),
            release = _store$subscribeToTra.release;
          cleanupEffectsByStore.set(store, [].concat(_toConsumableArray((_cleanupEffectsByStor2 = cleanupEffectsByStore.get(store)) !== null && _cleanupEffectsByStor2 !== void 0 ? _cleanupEffectsByStor2 : []), [release]));
        };
      };
      var _iterator53 = _createForOfIteratorHelper(effects),
        _step53;
      try {
        for (_iterator53.s(); !(_step53 = _iterator53.n()).done;) {
          var effect = _step53.value;
          try {
            var cleanup = effect({
              node: node,
              storeID: store.storeID,
              parentStoreID_UNSTABLE: store.parentStoreID,
              trigger: trigger,
              setSelf: setSelf(effect),
              resetSelf: resetSelf(effect),
              onSet: onSet(effect),
              getPromise: getPromise,
              getLoadable: getLoadable,
              getInfo_UNSTABLE: getInfo_UNSTABLE
            });
            if (cleanup != null) {
              var _cleanupEffectsByStor3;
              cleanupEffectsByStore.set(store, [].concat(_toConsumableArray((_cleanupEffectsByStor3 = cleanupEffectsByStore.get(store)) !== null && _cleanupEffectsByStor3 !== void 0 ? _cleanupEffectsByStor3 : []), [cleanup]));
            }
          } catch (error) {
            initValue = error;
            isInitError = true;
          }
        }
      } catch (err) {
        _iterator53.e(err);
      } finally {
        _iterator53.f();
      }
      isDuringInit = false; // Mutate initial state in place since we know there are no other subscribers
      // since we are the ones initializing on first use.

      if (!(initValue instanceof DefaultValue$2)) {
        var _store$getState$nextT5;
        var initLoadable = isInitError ? loadableWithError$2(initValue) : Recoil_isPromise(initValue) ? loadableWithPromise$2(wrapPendingPromise(store, initValue)) : loadableWithValue$3(unwrap(initValue));
        maybeFreezeValueOrPromise(initLoadable.contents);
        initState.atomValues.set(key, initLoadable); // If there is a pending transaction, then also mutate the next state tree.
        // This could happen if the atom was first initialized in an action that
        // also updated some other atom's state.

        (_store$getState$nextT5 = store.getState().nextTree) === null || _store$getState$nextT5 === void 0 ? void 0 : _store$getState$nextT5.atomValues.set(key, initLoadable);
      }
    }
    return cleanupAtom;
  }
  function peekAtom(_store, state) {
    var _ref, _state$atomValues$get3;
    return (_ref = (_state$atomValues$get3 = state.atomValues.get(key)) !== null && _state$atomValues$get3 !== void 0 ? _state$atomValues$get3 : cachedAnswerForUnvalidatedValue) !== null && _ref !== void 0 ? _ref : defaultLoadable;
  }
  function getAtom(_store, state) {
    if (state.atomValues.has(key)) {
      // Atom value is stored in state:
      return Recoil_nullthrows(state.atomValues.get(key));
    } else if (state.nonvalidatedAtoms.has(key)) {
      // Atom value is stored but needs validation before use.
      // We might have already validated it and have a cached validated value:
      if (cachedAnswerForUnvalidatedValue != null) {
        return cachedAnswerForUnvalidatedValue;
      }
      if (persistence == null) {
        Recoil_expectationViolation("Tried to restore a persisted value for atom ".concat(key, " but it has no persistence settings."));
        return defaultLoadable;
      }
      var nonvalidatedValue = state.nonvalidatedAtoms.get(key);
      var validatorResult = persistence.validator(nonvalidatedValue, DEFAULT_VALUE$7);
      var validatedValueLoadable = validatorResult instanceof DefaultValue$2 ? defaultLoadable : loadableWithValue$3(validatorResult);
      cachedAnswerForUnvalidatedValue = validatedValueLoadable;
      return cachedAnswerForUnvalidatedValue;
    } else {
      return defaultLoadable;
    }
  }
  function invalidateAtom() {
    cachedAnswerForUnvalidatedValue = undefined;
  }
  function setAtom(_store, state, newValue) {
    // Bail out if we're being set to the existing value, or if we're being
    // reset but have no stored value (validated or unvalidated) to reset from:
    if (state.atomValues.has(key)) {
      var existing = Recoil_nullthrows(state.atomValues.get(key));
      if (existing.state === 'hasValue' && newValue === existing.contents) {
        return new Map();
      }
    } else if (!state.nonvalidatedAtoms.has(key) && newValue instanceof DefaultValue$2) {
      return new Map();
    }
    maybeFreezeValueOrPromise(newValue);
    cachedAnswerForUnvalidatedValue = undefined; // can be released now if it was previously in use

    return new Map().set(key, loadableWithValue$3(newValue));
  }
  function shouldDeleteConfigOnReleaseAtom() {
    return getConfigDeletionHandler$2(key) !== undefined && liveStoresCount <= 0;
  }
  var node = registerNode$2({
    key: key,
    nodeType: 'atom',
    peek: peekAtom,
    get: getAtom,
    set: setAtom,
    init: initAtom,
    invalidate: invalidateAtom,
    shouldDeleteConfigOnRelease: shouldDeleteConfigOnReleaseAtom,
    dangerouslyAllowMutability: options.dangerouslyAllowMutability,
    persistence_UNSTABLE: options.persistence_UNSTABLE ? {
      type: options.persistence_UNSTABLE.type,
      backButton: options.persistence_UNSTABLE.backButton
    } : undefined,
    shouldRestoreFromSnapshots: true,
    retainedBy: retainedBy
  });
  return node;
} // prettier-ignore

function atom(options) {
  if (false) {}
  var restOptions = Object.assign({}, (_objectDestructuringEmpty(options), options));
  var optionsDefault = 'default' in options ?
  // $FlowIssue[incompatible-type] No way to refine in Flow that property is not defined
  options.default : new Promise(function () {});
  if (isRecoilValue$4(optionsDefault) // Continue to use atomWithFallback for promise defaults for scoped atoms
  // for now, since scoped atoms don't support async defaults
  // @fb-only: || (isPromise(optionsDefault) && scopeRules_APPEND_ONLY_READ_THE_DOCS)
  // @fb-only: || (isLoadable(optionsDefault) && scopeRules_APPEND_ONLY_READ_THE_DOCS)
  ) {
    return atomWithFallback(_objectSpread2(_objectSpread2({}, restOptions), {}, {
      default: optionsDefault // @fb-only: scopeRules_APPEND_ONLY_READ_THE_DOCS,
    })); // @fb-only: } else if (scopeRules_APPEND_ONLY_READ_THE_DOCS
    // @fb-only: && !isPromise(optionsDefault)
    // @fb-only: && !isLoadable(optionsDefault)
    // @fb-only: ) {
    // @fb-only: return scopedAtom<T>({
    // @fb-only: ...restOptions,
    // @fb-only: default: unwrap<T>(optionsDefault),
    // @fb-only: scopeRules_APPEND_ONLY_READ_THE_DOCS,
    // @fb-only: });
  } else {
    return baseAtom(_objectSpread2(_objectSpread2({}, restOptions), {}, {
      default: optionsDefault
    }));
  }
}
function atomWithFallback(options) {
  var base = atom(_objectSpread2(_objectSpread2({}, options), {}, {
    default: DEFAULT_VALUE$7,
    persistence_UNSTABLE: options.persistence_UNSTABLE === undefined ? undefined : _objectSpread2(_objectSpread2({}, options.persistence_UNSTABLE), {}, {
      validator: function validator(storedValue) {
        return storedValue instanceof DefaultValue$2 ? storedValue : Recoil_nullthrows(options.persistence_UNSTABLE).validator(storedValue, DEFAULT_VALUE$7);
      }
    }),
    // TODO Hack for now.
    effects: options.effects,
    // flowlint-line unclear-type: off
    effects_UNSTABLE: options.effects_UNSTABLE // flowlint-line unclear-type: off
  })); // $FlowFixMe[incompatible-call]

  var sel = Recoil_selector({
    key: "".concat(options.key, "__withFallback"),
    get: function get(_ref27) {
      var _get = _ref27.get;
      var baseValue = _get(base);
      return baseValue instanceof DefaultValue$2 ? options.default : baseValue;
    },
    // $FlowFixMe[incompatible-call]
    set: function set(_ref28, newValue) {
      var _set = _ref28.set;
      return _set(base, newValue);
    },
    // This selector does not need to cache as it is a wrapper selector
    // and the selector within the wrapper selector will have a cache
    // option by default
    cachePolicy_UNSTABLE: {
      eviction: 'most-recent'
    },
    dangerouslyAllowMutability: options.dangerouslyAllowMutability
  });
  setConfigDeletionHandler$1(sel.key, getConfigDeletionHandler$2(options.key));
  return sel;
} // $FlowFixMe[missing-local-annot]

atom.value = function (value) {
  return new WrappedValue$2(value);
};
var Recoil_atom = atom;

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 * @format
 * @oncall recoil
 */
var MapCache = /*#__PURE__*/function () {
  function MapCache(options) {
    _classCallCheck(this, MapCache);
    var _options$mapKey;
    es_defineProperty(this, "_map", void 0);
    es_defineProperty(this, "_keyMapper", void 0);
    this._map = new Map();
    this._keyMapper = (_options$mapKey = options === null || options === void 0 ? void 0 : options.mapKey) !== null && _options$mapKey !== void 0 ? _options$mapKey : function (v) {
      return v;
    };
  }
  _createClass(MapCache, [{
    key: "size",
    value: function size() {
      return this._map.size;
    }
  }, {
    key: "has",
    value: function has(key) {
      return this._map.has(this._keyMapper(key));
    }
  }, {
    key: "get",
    value: function get(key) {
      return this._map.get(this._keyMapper(key));
    }
  }, {
    key: "set",
    value: function set(key, val) {
      this._map.set(this._keyMapper(key), val);
    }
  }, {
    key: "delete",
    value: function _delete(key) {
      this._map.delete(this._keyMapper(key));
    }
  }, {
    key: "clear",
    value: function clear() {
      this._map.clear();
    }
  }]);
  return MapCache;
}();
var Recoil_MapCache = {
  MapCache: MapCache
};
var Recoil_MapCache_1 = Recoil_MapCache.MapCache;
var Recoil_MapCache$1 = /*#__PURE__*/Object.freeze({
  __proto__: null,
  MapCache: Recoil_MapCache_1
});
var LRUCache$2 = Recoil_LRUCache$1.LRUCache;
var MapCache$1 = Recoil_MapCache$1.MapCache;
var defaultPolicy$1 = {
  equality: 'reference',
  eviction: 'none',
  maxSize: Infinity
};
function cacheFromPolicy() {
  var _ref29 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultPolicy$1,
    _ref29$equality = _ref29.equality,
    equality = _ref29$equality === void 0 ? defaultPolicy$1.equality : _ref29$equality,
    _ref29$eviction = _ref29.eviction,
    eviction = _ref29$eviction === void 0 ? defaultPolicy$1.eviction : _ref29$eviction,
    _ref29$maxSize = _ref29.maxSize,
    maxSize = _ref29$maxSize === void 0 ? defaultPolicy$1.maxSize : _ref29$maxSize;
  var valueMapper = getValueMapper$1(equality);
  var cache = getCache(eviction, maxSize, valueMapper);
  return cache;
}
function getValueMapper$1(equality) {
  switch (equality) {
    case 'reference':
      return function (val) {
        return val;
      };
    case 'value':
      return function (val) {
        return Recoil_stableStringify(val);
      };
  }
  throw Recoil_err("Unrecognized equality policy ".concat(equality));
}
function getCache(eviction, maxSize, mapKey) {
  switch (eviction) {
    case 'keep-all':
      return new MapCache$1({
        mapKey: mapKey
      });
    case 'lru':
      return new LRUCache$2({
        mapKey: mapKey,
        maxSize: Recoil_nullthrows(maxSize)
      });
    case 'most-recent':
      return new LRUCache$2({
        mapKey: mapKey,
        maxSize: 1
      });
  }
  throw Recoil_err("Unrecognized eviction policy ".concat(eviction));
}
var Recoil_cacheFromPolicy = cacheFromPolicy;

// @fb-only: import type {ScopeRules} from 'Recoil_ScopedAtom';

var setConfigDeletionHandler$2 = Recoil_Node.setConfigDeletionHandler;

// Process scopeRules to handle any entries which are functions taking parameters
// prettier-ignore
// @fb-only: function mapScopeRules<P>(
// @fb-only: scopeRules?: ParameterizedScopeRules<P>,
// @fb-only: param: P,
// @fb-only: ): ScopeRules | void {
// @fb-only: return scopeRules?.map(rule =>
// @fb-only: Array.isArray(rule)
// @fb-only: ? rule.map(entry => (typeof entry === 'function' ? entry(param) : entry))
// @fb-only: : rule,
// @fb-only: );
// @fb-only: }

/*
A function which returns an atom based on the input parameter.

Each unique parameter returns a unique atom. E.g.,

  const f = atomFamily(...);
  f({a: 1}) => an atom
  f({a: 2}) => a different atom

This allows components to persist local, private state using atoms.  Each
instance of the component may have a different key, which it uses as the
parameter for a family of atoms; in this way, each component will have
its own atom not shared by other instances.  These state keys may be composed
into children's state keys as well.
*/
function atomFamily(options) {
  var _options$cachePolicyF, _options$cachePolicyF2;
  var atomCache = Recoil_cacheFromPolicy({
    equality: (_options$cachePolicyF = (_options$cachePolicyF2 = options.cachePolicyForParams_UNSTABLE) === null || _options$cachePolicyF2 === void 0 ? void 0 : _options$cachePolicyF2.equality) !== null && _options$cachePolicyF !== void 0 ? _options$cachePolicyF : 'value',
    eviction: 'keep-all'
  }); // Simple atomFamily implementation to cache individual atoms based
  // on the parameter value equality.

  return function (params) {
    var _stableStringify, _options$effects;
    var cachedAtom = atomCache.get(params);
    if (cachedAtom != null) {
      return cachedAtom;
    }
    var cachePolicyForParams_UNSTABLE = options.cachePolicyForParams_UNSTABLE,
      atomOptions = _objectWithoutProperties(options, es_excluded2);
    var optionsDefault = 'default' in options ?
    // $FlowIssue[incompatible-type] No way to refine in Flow that property is not defined
    options.default : new Promise(function () {});
    var newAtom = Recoil_atom(_objectSpread2(_objectSpread2({}, atomOptions), {}, {
      key: "".concat(options.key, "__").concat((_stableStringify = Recoil_stableStringify(params)) !== null && _stableStringify !== void 0 ? _stableStringify : 'void'),
      default: typeof optionsDefault === 'function' ?
      // The default was parameterized
      // Flow doesn't know that T isn't a function, so we need to case to any
      // $FlowIssue[incompatible-use]
      optionsDefault(params) :
      // Default may be a static value, promise, or RecoilValue
      optionsDefault,
      retainedBy_UNSTABLE: typeof options.retainedBy_UNSTABLE === 'function' ? options.retainedBy_UNSTABLE(params) : options.retainedBy_UNSTABLE,
      effects: typeof options.effects === 'function' ? options.effects(params) : typeof options.effects_UNSTABLE === 'function' ? options.effects_UNSTABLE(params) : (_options$effects = options.effects) !== null && _options$effects !== void 0 ? _options$effects : options.effects_UNSTABLE // prettier-ignore
      // @fb-only: scopeRules_APPEND_ONLY_READ_THE_DOCS: mapScopeRules(
      // @fb-only: options.scopeRules_APPEND_ONLY_READ_THE_DOCS,
      // @fb-only: params,
      // @fb-only: ),
    }));

    atomCache.set(params, newAtom);
    setConfigDeletionHandler$2(newAtom.key, function () {
      atomCache.delete(params);
    });
    return newAtom;
  };
}
var Recoil_atomFamily = atomFamily;
var setConfigDeletionHandler$3 = Recoil_Node.setConfigDeletionHandler;

// Keep in mind the parameter needs to be serializable as a cahche key
// using Recoil_stableStringify

// Add a unique index to each selector in case the cache implementation allows
// duplicate keys based on equivalent stringified parameters
var nextIndex = 0;
/* eslint-disable no-redeclare */

// Return a function that returns members of a family of selectors of the same type
// E.g.,
//
// const s = selectorFamily(...);
// s({a: 1}) => a selector
// s({a: 2}) => a different selector
//
// By default, the selectors are distinguished by distinct values of the
// parameter based on value equality, not reference equality.  This allows using
// object literals or other equivalent objects at callsites to not create
// duplicate cache entries.  This behavior may be overridden with the
// cacheImplementationForParams option.
function selectorFamily(options) {
  var _options$cachePolicyF, _options$cachePolicyF2;
  var selectorCache = Recoil_cacheFromPolicy({
    equality: (_options$cachePolicyF = (_options$cachePolicyF2 = options.cachePolicyForParams_UNSTABLE) === null || _options$cachePolicyF2 === void 0 ? void 0 : _options$cachePolicyF2.equality) !== null && _options$cachePolicyF !== void 0 ? _options$cachePolicyF : 'value',
    eviction: 'keep-all'
  });
  return function (params) {
    var _stableStringify;

    // Throw an error with selector key so that it is clear which
    // selector is causing an error
    var cachedSelector;
    try {
      cachedSelector = selectorCache.get(params);
    } catch (error) {
      throw Recoil_err("Problem with cache lookup for selector ".concat(options.key, ": ").concat(error.message));
    }
    if (cachedSelector != null) {
      return cachedSelector;
    }
    var myKey = "".concat(options.key, "__selectorFamily/").concat((_stableStringify = Recoil_stableStringify(params, {
      // It is possible to use functions in parameters if the user uses
      // a cache with reference equality thanks to the incrementing index.
      allowFunctions: true
    })) !== null && _stableStringify !== void 0 ? _stableStringify : 'void', "/").concat(nextIndex++); // Append index in case values serialize to the same key string

    var myGet = function myGet(callbacks) {
      return options.get(params)(callbacks);
    };
    var myCachePolicy = options.cachePolicy_UNSTABLE;
    var retainedBy = typeof options.retainedBy_UNSTABLE === 'function' ? options.retainedBy_UNSTABLE(params) : options.retainedBy_UNSTABLE;
    var newSelector;
    if (options.set != null) {
      var set = options.set;
      var mySet = function mySet(callbacks, newValue) {
        return set(params)(callbacks, newValue);
      };
      newSelector = Recoil_selector({
        key: myKey,
        get: myGet,
        set: mySet,
        cachePolicy_UNSTABLE: myCachePolicy,
        dangerouslyAllowMutability: options.dangerouslyAllowMutability,
        retainedBy_UNSTABLE: retainedBy
      });
    } else {
      newSelector = Recoil_selector({
        key: myKey,
        get: myGet,
        cachePolicy_UNSTABLE: myCachePolicy,
        dangerouslyAllowMutability: options.dangerouslyAllowMutability,
        retainedBy_UNSTABLE: retainedBy
      });
    }
    selectorCache.set(params, newSelector);
    setConfigDeletionHandler$3(newSelector.key, function () {
      selectorCache.delete(params);
    });
    return newSelector;
  };
}
/* eslint-enable no-redeclare */

var Recoil_selectorFamily = selectorFamily;

// flowlint-next-line unclear-type:off

var constantSelector = Recoil_selectorFamily({
  key: '__constant',
  get: function get(constant) {
    return function () {
      return constant;
    };
  },
  cachePolicyForParams_UNSTABLE: {
    equality: 'reference'
  }
}); // Function that returns a selector which always produces the
// same constant value.  It may be called multiple times with the
// same value, based on reference equality, and will provide the
// same selector.

function constSelector(constant) {
  return constantSelector(constant);
}
var Recoil_constSelector = constSelector;

// flowlint-next-line unclear-type:off

var throwingSelector = Recoil_selectorFamily({
  key: '__error',
  get: function get(message) {
    return function () {
      throw Recoil_err(message);
    };
  },
  // TODO Why?
  cachePolicyForParams_UNSTABLE: {
    equality: 'reference'
  }
}); // Function that returns a selector which always throws an error
// with the provided message.

function errorSelector(message) {
  return throwingSelector(message);
}
var Recoil_errorSelector = errorSelector;

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * Wraps another recoil value and prevents writing to it.
 *
 * 
 * @format
 * @oncall recoil
 */

function readOnlySelector(atom) {
  // flowlint-next-line unclear-type: off
  return atom;
}
var Recoil_readOnlySelector = readOnlySelector;
var loadableWithError$3 = Recoil_Loadable$1.loadableWithError,
  loadableWithPromise$3 = Recoil_Loadable$1.loadableWithPromise,
  loadableWithValue$4 = Recoil_Loadable$1.loadableWithValue;

/////////////////
//  TRUTH TABLE
/////////////////
// Dependencies        waitForNone         waitForAny        waitForAll       waitForAllSettled
//  [loading, loading]  [Promise, Promise]  Promise           Promise         Promise
//  [value, loading]    [value, Promise]    [value, Promise]  Promise         Promise
//  [value, value]      [value, value]      [value, value]    [value, value]  [value, value]
//
//  [error, loading]    [Error, Promise]    [Error, Promise]  Error           Promise
//  [error, error]      [Error, Error]      [Error, Error]    Error           [error, error]
//  [value, error]      [value, Error]      [value, Error]    Error           [value, error]
// Issue parallel requests for all dependencies and return the current
// status if they have results, have some error, or are still pending.

function concurrentRequests(getRecoilValue, deps) {
  var results = Array(deps.length).fill(undefined);
  var exceptions = Array(deps.length).fill(undefined);
  var _iterator54 = _createForOfIteratorHelper(deps.entries()),
    _step54;
  try {
    for (_iterator54.s(); !(_step54 = _iterator54.n()).done;) {
      var _step54$value = slicedToArray_slicedToArray(_step54.value, 2),
        i = _step54$value[0],
        dep = _step54$value[1];
      try {
        results[i] = getRecoilValue(dep);
      } catch (e) {
        // exceptions can either be Promises of pending results or real errors
        exceptions[i] = e;
      }
    }
  } catch (err) {
    _iterator54.e(err);
  } finally {
    _iterator54.f();
  }
  return [results, exceptions];
}
function isError(exp) {
  return exp != null && !Recoil_isPromise(exp);
}
function unwrapDependencies(dependencies) {
  return Array.isArray(dependencies) ? dependencies : Object.getOwnPropertyNames(dependencies).map(function (key) {
    return dependencies[key];
  });
}
function wrapResults(dependencies,
/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
 * LTI update could not be added via codemod */
results) {
  return Array.isArray(dependencies) ? results :
  // Object.getOwnPropertyNames() has consistent key ordering with ES6
  Object.getOwnPropertyNames(dependencies).reduce(function (out, key, idx) {
    return _objectSpread2(_objectSpread2({}, out), {}, defineProperty_defineProperty({}, key, results[idx]));
  }, {});
}
function wrapLoadables(dependencies, results, exceptions) {
  var output = exceptions.map(function (exception, idx) {
    return exception == null ? loadableWithValue$4(results[idx]) : Recoil_isPromise(exception) ? loadableWithPromise$3(exception) : loadableWithError$3(exception);
  });
  return wrapResults(dependencies, output);
}
function combineAsyncResultsWithSyncResults(syncResults, asyncResults) {
  return asyncResults.map(function (result, idx) {
    return (
      /**
       * it's important we use === undefined as opposed to == null, because the
       * resolved value of the async promise could be `null`, in which case we
       * don't want to use syncResults[idx], which would be undefined. If async
       * promise resolves to `undefined`, that's ok because `syncResults[idx]`
       * will also be `undefined`. That's a little hacky, but it works.
       */
      result === undefined ? syncResults[idx] : result
    );
  });
} // Selector that requests all dependencies in parallel and immediately returns
// current results without waiting.

var waitForNone = Recoil_selectorFamily({
  key: '__waitForNone',
  get: function get(dependencies) {
    return function (_ref30) {
      var get = _ref30.get;
      // Issue requests for all dependencies in parallel.
      var deps = unwrapDependencies(dependencies);
      var _concurrentRequests = concurrentRequests(get, deps),
        _concurrentRequests2 = slicedToArray_slicedToArray(_concurrentRequests, 2),
        results = _concurrentRequests2[0],
        exceptions = _concurrentRequests2[1]; // Always return the current status of the results; never block.

      return wrapLoadables(dependencies, results, exceptions);
    };
  },
  dangerouslyAllowMutability: true
}); // Selector that requests all dependencies in parallel and waits for at least
// one to be available before returning results.  It will only error if all
// dependencies have errors.

var waitForAny = Recoil_selectorFamily({
  key: '__waitForAny',
  get: function get(dependencies) {
    return function (_ref31) {
      var get = _ref31.get;
      // Issue requests for all dependencies in parallel.
      // Exceptions can either be Promises of pending results or real errors
      var deps = unwrapDependencies(dependencies);
      var _concurrentRequests3 = concurrentRequests(get, deps),
        _concurrentRequests4 = slicedToArray_slicedToArray(_concurrentRequests3, 2),
        results = _concurrentRequests4[0],
        exceptions = _concurrentRequests4[1]; // If any results are available, value or error, return the current status

      if (exceptions.some(function (exp) {
        return !Recoil_isPromise(exp);
      })) {
        return wrapLoadables(dependencies, results, exceptions);
      } // Otherwise, return a promise that will resolve when the next result is
      // available, whichever one happens to be next.  But, if all pending
      // dependencies end up with errors, then reject the promise.

      return new Promise(function (resolve) {
        var _iterator55 = _createForOfIteratorHelper(exceptions.entries()),
          _step55;
        try {
          var _loop = function _loop() {
            var _step55$value = slicedToArray_slicedToArray(_step55.value, 2),
              i = _step55$value[0],
              exp = _step55$value[1];
            if (Recoil_isPromise(exp)) {
              exp.then(function (result) {
                results[i] = result;
                exceptions[i] = undefined;
                resolve(wrapLoadables(dependencies, results, exceptions));
              }).catch(function (error) {
                exceptions[i] = error;
                resolve(wrapLoadables(dependencies, results, exceptions));
              });
            }
          };
          for (_iterator55.s(); !(_step55 = _iterator55.n()).done;) {
            _loop();
          }
        } catch (err) {
          _iterator55.e(err);
        } finally {
          _iterator55.f();
        }
      });
    };
  },
  dangerouslyAllowMutability: true
}); // Selector that requests all dependencies in parallel and waits for all to be
// available before returning a value.  It will error if any dependencies error.

var waitForAll = Recoil_selectorFamily({
  key: '__waitForAll',
  get: function get(dependencies) {
    return function (_ref32) {
      var get = _ref32.get;
      // Issue requests for all dependencies in parallel.
      // Exceptions can either be Promises of pending results or real errors
      var deps = unwrapDependencies(dependencies);
      var _concurrentRequests5 = concurrentRequests(get, deps),
        _concurrentRequests6 = slicedToArray_slicedToArray(_concurrentRequests5, 2),
        results = _concurrentRequests6[0],
        exceptions = _concurrentRequests6[1]; // If all results are available, return the results

      if (exceptions.every(function (exp) {
        return exp == null;
      })) {
        return wrapResults(dependencies, results);
      } // If we have any errors, throw the first error

      var error = exceptions.find(isError);
      if (error != null) {
        throw error;
      } // Otherwise, return a promise that will resolve when all results are available

      return Promise.all(exceptions).then(function (exceptionResults) {
        return wrapResults(dependencies, combineAsyncResultsWithSyncResults(results, exceptionResults));
      });
    };
  },
  dangerouslyAllowMutability: true
});
var waitForAllSettled = Recoil_selectorFamily({
  key: '__waitForAllSettled',
  get: function get(dependencies) {
    return function (_ref33) {
      var get = _ref33.get;
      // Issue requests for all dependencies in parallel.
      // Exceptions can either be Promises of pending results or real errors
      var deps = unwrapDependencies(dependencies);
      var _concurrentRequests7 = concurrentRequests(get, deps),
        _concurrentRequests8 = slicedToArray_slicedToArray(_concurrentRequests7, 2),
        results = _concurrentRequests8[0],
        exceptions = _concurrentRequests8[1]; // If all results are available, return the results

      if (exceptions.every(function (exp) {
        return !Recoil_isPromise(exp);
      })) {
        return wrapLoadables(dependencies, results, exceptions);
      } // Wait for all results to settle

      return Promise.all(exceptions.map(function (exp, i) {
        return Recoil_isPromise(exp) ? exp.then(function (result) {
          results[i] = result;
          exceptions[i] = undefined;
        }).catch(function (error) {
          results[i] = undefined;
          exceptions[i] = error;
        }) : null;
      })) // Then wrap them as loadables
      .then(function () {
        return wrapLoadables(dependencies, results, exceptions);
      });
    };
  },
  dangerouslyAllowMutability: true
});
var noWait = Recoil_selectorFamily({
  key: '__noWait',
  get: function get(dependency) {
    return function (_ref34) {
      var get = _ref34.get;
      try {
        return Recoil_selector.value(loadableWithValue$4(get(dependency)));
      } catch (exception) {
        return Recoil_selector.value(Recoil_isPromise(exception) ? loadableWithPromise$3(exception) : loadableWithError$3(exception));
      }
    };
  },
  dangerouslyAllowMutability: true
});
var Recoil_WaitFor = {
  waitForNone: waitForNone,
  waitForAny: waitForAny,
  waitForAll: waitForAll,
  waitForAllSettled: waitForAllSettled,
  noWait: noWait
};
var RecoilLoadable = Recoil_Loadable$1.RecoilLoadable;
var DefaultValue$3 = Recoil_Node.DefaultValue;
var RecoilRoot$2 = Recoil_RecoilRoot.RecoilRoot,
  useRecoilStoreID$1 = Recoil_RecoilRoot.useRecoilStoreID;
var isRecoilValue$5 = Recoil_RecoilValue$1.isRecoilValue;
var retentionZone$1 = Recoil_RetentionZone.retentionZone;
var freshSnapshot$2 = Recoil_Snapshot$1.freshSnapshot;
var useRecoilState$1 = Recoil_Hooks.useRecoilState,
  useRecoilState_TRANSITION_SUPPORT_UNSTABLE$1 = Recoil_Hooks.useRecoilState_TRANSITION_SUPPORT_UNSTABLE,
  useRecoilStateLoadable$1 = Recoil_Hooks.useRecoilStateLoadable,
  useRecoilValue$1 = Recoil_Hooks.useRecoilValue,
  useRecoilValue_TRANSITION_SUPPORT_UNSTABLE$1 = Recoil_Hooks.useRecoilValue_TRANSITION_SUPPORT_UNSTABLE,
  useRecoilValueLoadable$1 = Recoil_Hooks.useRecoilValueLoadable,
  useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE$1 = Recoil_Hooks.useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE,
  useResetRecoilState$1 = Recoil_Hooks.useResetRecoilState,
  useSetRecoilState$1 = Recoil_Hooks.useSetRecoilState;
var useGotoRecoilSnapshot$1 = Recoil_SnapshotHooks.useGotoRecoilSnapshot,
  useRecoilSnapshot$1 = Recoil_SnapshotHooks.useRecoilSnapshot,
  useRecoilTransactionObserver$1 = Recoil_SnapshotHooks.useRecoilTransactionObserver;
var useRecoilCallback$1 = Recoil_useRecoilCallback.useRecoilCallback;
var noWait$1 = Recoil_WaitFor.noWait,
  waitForAll$1 = Recoil_WaitFor.waitForAll,
  waitForAllSettled$1 = Recoil_WaitFor.waitForAllSettled,
  waitForAny$1 = Recoil_WaitFor.waitForAny,
  waitForNone$1 = Recoil_WaitFor.waitForNone;
var Recoil_index = {
  // Types
  DefaultValue: DefaultValue$3,
  isRecoilValue: isRecoilValue$5,
  RecoilLoadable: RecoilLoadable,
  // Global Recoil environment settiongs
  RecoilEnv: Recoil_RecoilEnv,
  // Recoil Root
  RecoilRoot: RecoilRoot$2,
  useRecoilStoreID: useRecoilStoreID$1,
  useRecoilBridgeAcrossReactRoots_UNSTABLE: Recoil_useRecoilBridgeAcrossReactRoots,
  // Atoms/Selectors
  atom: Recoil_atom,
  selector: Recoil_selector,
  // Convenience Atoms/Selectors
  atomFamily: Recoil_atomFamily,
  selectorFamily: Recoil_selectorFamily,
  constSelector: Recoil_constSelector,
  errorSelector: Recoil_errorSelector,
  readOnlySelector: Recoil_readOnlySelector,
  // Concurrency Helpers for Atoms/Selectors
  noWait: noWait$1,
  waitForNone: waitForNone$1,
  waitForAny: waitForAny$1,
  waitForAll: waitForAll$1,
  waitForAllSettled: waitForAllSettled$1,
  // Hooks for Atoms/Selectors
  useRecoilValue: useRecoilValue$1,
  useRecoilValueLoadable: useRecoilValueLoadable$1,
  useRecoilState: useRecoilState$1,
  useRecoilStateLoadable: useRecoilStateLoadable$1,
  useSetRecoilState: useSetRecoilState$1,
  useResetRecoilState: useResetRecoilState$1,
  useGetRecoilValueInfo_UNSTABLE: Recoil_useGetRecoilValueInfo,
  useRecoilRefresher_UNSTABLE: Recoil_useRecoilRefresher,
  useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE: useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE$1,
  useRecoilValue_TRANSITION_SUPPORT_UNSTABLE: useRecoilValue_TRANSITION_SUPPORT_UNSTABLE$1,
  useRecoilState_TRANSITION_SUPPORT_UNSTABLE: useRecoilState_TRANSITION_SUPPORT_UNSTABLE$1,
  // Hooks for complex operations
  useRecoilCallback: useRecoilCallback$1,
  useRecoilTransaction_UNSTABLE: Recoil_useRecoilTransaction,
  // Snapshots
  useGotoRecoilSnapshot: useGotoRecoilSnapshot$1,
  useRecoilSnapshot: useRecoilSnapshot$1,
  useRecoilTransactionObserver_UNSTABLE: useRecoilTransactionObserver$1,
  snapshot_UNSTABLE: freshSnapshot$2,
  // Memory Management
  useRetain: Recoil_useRetain,
  retentionZone: retentionZone$1
};
var Recoil_index_1 = Recoil_index.DefaultValue;
var Recoil_index_2 = Recoil_index.isRecoilValue;
var Recoil_index_3 = Recoil_index.RecoilLoadable;
var Recoil_index_4 = Recoil_index.RecoilEnv;
var Recoil_index_5 = Recoil_index.RecoilRoot;
var Recoil_index_6 = Recoil_index.useRecoilStoreID;
var Recoil_index_7 = Recoil_index.useRecoilBridgeAcrossReactRoots_UNSTABLE;
var Recoil_index_8 = Recoil_index.atom;
var Recoil_index_9 = Recoil_index.selector;
var Recoil_index_10 = Recoil_index.atomFamily;
var Recoil_index_11 = Recoil_index.selectorFamily;
var Recoil_index_12 = Recoil_index.constSelector;
var Recoil_index_13 = Recoil_index.errorSelector;
var Recoil_index_14 = Recoil_index.readOnlySelector;
var Recoil_index_15 = Recoil_index.noWait;
var Recoil_index_16 = Recoil_index.waitForNone;
var Recoil_index_17 = Recoil_index.waitForAny;
var Recoil_index_18 = Recoil_index.waitForAll;
var Recoil_index_19 = Recoil_index.waitForAllSettled;
var Recoil_index_20 = Recoil_index.useRecoilValue;
var Recoil_index_21 = Recoil_index.useRecoilValueLoadable;
var Recoil_index_22 = Recoil_index.useRecoilState;
var Recoil_index_23 = Recoil_index.useRecoilStateLoadable;
var Recoil_index_24 = Recoil_index.useSetRecoilState;
var Recoil_index_25 = Recoil_index.useResetRecoilState;
var Recoil_index_26 = Recoil_index.useGetRecoilValueInfo_UNSTABLE;
var Recoil_index_27 = Recoil_index.useRecoilRefresher_UNSTABLE;
var Recoil_index_28 = Recoil_index.useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE;
var Recoil_index_29 = Recoil_index.useRecoilValue_TRANSITION_SUPPORT_UNSTABLE;
var Recoil_index_30 = Recoil_index.useRecoilState_TRANSITION_SUPPORT_UNSTABLE;
var Recoil_index_31 = Recoil_index.useRecoilCallback;
var Recoil_index_32 = Recoil_index.useRecoilTransaction_UNSTABLE;
var Recoil_index_33 = Recoil_index.useGotoRecoilSnapshot;
var Recoil_index_34 = Recoil_index.useRecoilSnapshot;
var Recoil_index_35 = Recoil_index.useRecoilTransactionObserver_UNSTABLE;
var Recoil_index_36 = Recoil_index.snapshot_UNSTABLE;
var Recoil_index_37 = Recoil_index.useRetain;
var Recoil_index_38 = Recoil_index.retentionZone;
/* harmony default export */ var _recoil_0_7_7_recoil_es = ((/* unused pure expression or super */ null && (Recoil_index)));

;// CONCATENATED MODULE: ./src/models/folder.ts
var folder_foldersState=Recoil_index_8({key:'folder/folders',default:[]});var folderLoadedState=Recoil_index_8({key:'folder/isFolderLoaded',default:false});var folder_useFolder=function useFolder(){var fetchFolders=useRecoilCallback(function(_ref){var set=_ref.set;return/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(){var result;return _regeneratorRuntime().wrap(function _callee$(_context){while(1)switch(_context.prev=_context.next){case 0:_context.prev=0;_context.next=3;return service.getDirList();case 3:result=_context.sent;set(folder_foldersState,result.data);set(folderLoadedState,true);_context.next=11;break;case 8:_context.prev=8;_context.t0=_context["catch"](0);set(folderLoadedState,false);case 11:_context.prev=11;set(appReadyState,true);return _context.finish(11);case 14:case"end":return _context.stop();}},_callee,null,[[0,8,11,14]]);}));},[]);return{fetchFolders:fetchFolders};};
;// CONCATENATED MODULE: ./src/models/app.ts
var app_appReadyState=Recoil_index_8({key:'app/appReady',default:false});var mainPanelVisibleState=Recoil_index_8({key:'app/mainPanelVisible',default:true});var captionVisibleState=Recoil_index_8({key:'app/captionVisible',default:false});var app_isLoginState=Recoil_index_9({key:'app/isLogin',get:function get(_ref){var _get=_ref.get;return _get(folderLoadedState);}});var app_isShowAppState=Recoil_index_8({key:'app/showApp',default:true});var app_panelHeightState=Recoil_index_8({key:'app/panelHeight',default:window.innerHeight-24<480?window.innerHeight-24:480});var app_panelPositionState=Recoil_index_8({key:'app/panelPosition',default:{x:0,y:0}});var app_usePanelVisible=function usePanelVisible(){var _useRecoilState=useRecoilState(mainPanelVisibleState),_useRecoilState2=_slicedToArray(_useRecoilState,2),mainPanelVisible=_useRecoilState2[0],setMainPanelVisible=_useRecoilState2[1];var _useRecoilState3=useRecoilState(captionVisibleState),_useRecoilState4=_slicedToArray(_useRecoilState3,2),captionVisible=_useRecoilState4[0],setCaptionVisible=_useRecoilState4[1];var showCaption=useCallback(function(){setCaptionVisible(true);setMainPanelVisible(false);},[]);var showMainPanel=useCallback(function(){setMainPanelVisible(true);setCaptionVisible(false);},[]);return{mainPanelVisible:mainPanelVisible,setMainPanelVisible:setMainPanelVisible,captionVisible:captionVisible,setCaptionVisible:setCaptionVisible,showCaption:showCaption,showMainPanel:showMainPanel};};
;// CONCATENATED MODULE: ./src/models/config.ts
var config_useConfig=function useConfig(){return createConfig_getGlobalConfig().getEnvInfo();};
;// CONCATENATED MODULE: ./src/models/record.ts
var record_isStartRecordState=Recoil_index_8({key:'record/isStartRecord',default:false});var record_isPauseRecordState=Recoil_index_8({key:'record/isPauseRecord',default:false});var record_isStopingState=Recoil_index_8({key:'record/isStoping',default:false});var record_isExpandState=Recoil_index_8({key:'record/isExpand',default:true});var record_secondState=Recoil_index_8({key:'record/second',default:0});var record_isNotifyUserTransFinishState=Recoil_index_8({key:'record/isNotifyUserTransFinish',default:false});// 翻译开关
var record_translateSwitchState=Recoil_index_8({key:'record/translateSwitch',default:false});// 源语言
var record_sourceLanguageState=Recoil_index_8({key:'record/sourceLanguage',default:'cn'});// 目标语言
var record_targetLanguageState=Recoil_index_8({key:'record/targetLanguage',default:'cn'});// 显示语言，默认1纯译文，2双语
var record_showLanguageState=Recoil_index_8({key:'record/showLanguage',default:1});// 会议Id
var record_transIdState=Recoil_index_8({key:'record/transId',default:''});var record_useRecord=function useRecord(){var _useRecoilState=useRecoilState(record_isStartRecordState),_useRecoilState2=_slicedToArray(_useRecoilState,1),isStartRecord=_useRecoilState2[0];var startRecord=useCallback(/*#__PURE__*/function(){var _ref=_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(enableMicphone,filename,dirId,sourceLanguage){return _regeneratorRuntime().wrap(function _callee$(_context){while(1)switch(_context.prev=_context.next){case 0:if(!isStartRecord){_context.next=2;break;}return _context.abrupt("return");case 2:_context.next=4;return chrome.runtime.sendMessage({type:'desktopCapture',payload:{enableMicphone:enableMicphone,filename:filename,dirId:dirId,sourceLanguage:sourceLanguage}});case 4:case"end":return _context.stop();}},_callee);}));return function(_x,_x2,_x3,_x4){return _ref.apply(this,arguments);};}(),[isStartRecord]);return{startRecord:startRecord};};
;// CONCATENATED MODULE: ./src/models/user.ts
var defaultUrl="".concat(chrome.runtime.getURL('defaultUrl.png'));var user_avatarUrlState=Recoil_index_8({key:'user/avatarUrl',default:defaultUrl});var user_userNameState=Recoil_index_8({key:"user/userName",default:''});var user_userIdState=Recoil_index_8({key:"user/userId",default:''});// 标记引导弹窗，默认0展示，1不展示
var user_marksGuideState=Recoil_index_8({key:"user/marksGuide",default:0});var user_useUser=function useUser(){var fetchUser=useRecoilCallback(function(_ref){var set=_ref.set;return/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(){var result;return _regeneratorRuntime().wrap(function _callee$(_context){while(1)switch(_context.prev=_context.next){case 0:_context.next=2;return service.getUserInfo();case 2:result=_context.sent;set(user_avatarUrlState,result.data.avatarUrl||defaultUrl);// todo：后端从登录获取showName，集团内部账户是花名，外包WB工号开头同学是空的。
set(user_userNameState,result.data.showName||'');set(user_userIdState,result.data.userId||'');case 6:case"end":return _context.stop();}},_callee);}));},[]);return{fetchUser:fetchUser};};var user_useMarksGuide=function useMarksGuide(){var fetchMarksGuide=useRecoilCallback(function(_ref3){var set=_ref3.set;return/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(){var result;return _regeneratorRuntime().wrap(function _callee2$(_context2){while(1)switch(_context2.prev=_context2.next){case 0:_context2.next=2;return service.getMarksGuideStatus();case 2:result=_context2.sent;set(user_marksGuideState,result.data.recordValue);case 4:case"end":return _context2.stop();}},_callee2);}));},[]);return{fetchMarksGuide:fetchMarksGuide};};
;// CONCATENATED MODULE: ./src/models/index.ts

// EXTERNAL MODULE: ./node_modules/_react@18.2.0@react/jsx-runtime.js
var jsx_runtime = __webpack_require__(9386);
;// CONCATENATED MODULE: ./src/components/updateVersionDailog/upfateVersionDialog.tsx
var upfateVersionDialog_templateObject,upfateVersionDialog_templateObject2;var upfateVersionDialog_CloseButton=styled_components_browser_esm.div(upfateVersionDialog_templateObject||(upfateVersionDialog_templateObject=_taggedTemplateLiteral(["\n  background-image: url(",");\n  background-size: contain;\n  background-repeat: no-repeat;\n  background-position: center center;\n  width: 20px;\n  height: 20px;\n  cursor: pointer;\n  &:hover {\n    background-image: url(",");\n  }\n"])),chrome.runtime.getURL("closeSmall.svg"),chrome.runtime.getURL("closeHoverSmall.svg"));var StorageNotificationBody=styled_components_browser_esm.div(upfateVersionDialog_templateObject2||(upfateVersionDialog_templateObject2=_taggedTemplateLiteral(["\n  position: absolute;\n  left: 0px;\n  width: 100%;\n  top: 44px;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  flex-direction: column;\n  .des {\n    height: 40px;\n    width: 172px;\n    font-family: PingFangSC;\n    font-weight: 400;\n    font-size: 12px;\n    color: rgba(39, 38, 77, 0.65);\n    letter-spacing: 0;\n    text-align: justify;\n    line-height: 20px;\n    display: block;\n  }\n  .StorageNotificationContent {\n    margin-top: 20px;\n  }\n"])));var semver=__webpack_require__(9383);var UpdateVersionDialog=/*#__PURE__*/(0,_react_18_2_0_react.memo)(function(props){var idName=props.idName,version=props.version;var _useRecoilState=Recoil_index_22(app_isShowAppState),_useRecoilState2=slicedToArray_slicedToArray(_useRecoilState,2),isShowApp=_useRecoilState2[0],setIsShowApp=_useRecoilState2[1];var _useConfig=config_useConfig(),tingwuUrl=_useConfig.tingwuUrl;(0,_react_18_2_0_react.useEffect)(function(){services_service.fetchDomainConfig().then(function(res){if(res.data&&res.data.chrome&&res.data.chrome.version&&semver.lt(version,res.data.chrome.version)){var u=res.data.chrome.updateUrl;toastContain(u);}});},[]);var toastContain=function toastContain(url){return modal.info({getContainer:function getContainer(){return document.getElementById(idName)||document.body;},centered:true,width:220,icon:null,className:"extensionDialog",bodyStyle:{height:184},closable:true,closeIcon:/*#__PURE__*/(0,jsx_runtime.jsx)("div",{style:{marginTop:"20px",marginLeft:"12px"},children:/*#__PURE__*/(0,jsx_runtime.jsx)(upfateVersionDialog_CloseButton,{})}),okButtonProps:{style:{marginTop:"48px",marginLeft:"39px",float:"left"}},okText:"立即下载",title:"版本更新",onOk:function onOk(){// 跳转链接
window.open(url);return Promise.reject();},onCancel:function onCancel(){setIsShowApp(false);},content:/*#__PURE__*/(0,jsx_runtime.jsx)(jsx_runtime.Fragment,{children:/*#__PURE__*/(0,jsx_runtime.jsx)(StorageNotificationBody,{children:/*#__PURE__*/(0,jsx_runtime.jsx)("div",{className:"StorageNotificationContent",children:/*#__PURE__*/(0,jsx_runtime.jsx)("span",{className:"des",children:"\u5F53\u524D\u7248\u672C\u63D2\u4EF6\u65E0\u6CD5\u6B63\u5E38\u4F7F\u7528\u542C\u609F\u63D0\u4F9B\u7684\u670D\u52A1\uFF0C\u8BF7\u66F4\u65B0\u81F3\u6700\u65B0\u7248\u672C"})})})})});};return/*#__PURE__*/(0,jsx_runtime.jsx)(jsx_runtime.Fragment,{});});
;// CONCATENATED MODULE: ./src/components/updateVersionDailog/index.ts

;// CONCATENATED MODULE: ./src/extends/extToDeveloper.tsx
// const UpgradeTip: React.FC<{
//   version: string;
// }> = (props) => {
//   const { version } = props;
//   return <div>{version}</div>;
// }
var extToDeveloper=atebBasicConfig.extensionWithStrategy({}).andDecorator(function(generator){return function(props){return generator(_objectSpread2(_objectSpread2({},props),{},{renderExtContent:function renderExtContent(){var idName=arguments.length>0&&arguments[0]!==undefined?arguments[0]:"";return[props.renderExtContent(),/*#__PURE__*/(0,jsx_runtime.jsx)(UpdateVersionDialog,{version:props.version,idName:idName})];},getTestInfo:function getTestInfo(){return props.getTestInfo()+"/developer";}}));};});
;// CONCATENATED MODULE: ./src/extends/createConfig.ts
var createConfig=function createConfig(){var publishName=arguments.length>0&&arguments[0]!==undefined?arguments[0]:'alibabaGroup';var serverEnv=arguments.length>1?arguments[1]:undefined;var installMode=arguments.length>2?arguments[2]:undefined;var extensions=[];switch(publishName){case'publicServer':{extensions.push(extPublicServerConfig);if(serverEnv==='pre'){extensions.push(extPrePublicServerConfig);}break;}case'alibabaGroup':default:{if(serverEnv==='pre'){extensions.push(extPreBasicConfig);}break;}}if(installMode==='developer'){extensions.push(extToDeveloper);}var result=extensions.reduce(function(current,next){return current.extendedBy(next);},atebBasicConfig).generate({});return result;};var publishName="publicServer"||0;var serverEnv="prod"||0;var installMode="developer"||0;var _config=createConfig(publishName,serverEnv,installMode);var createConfig_getGlobalConfig=function getGlobalConfig(){return _config;};
;// CONCATENATED MODULE: ./src/extends/index.ts

;// CONCATENATED MODULE: ./src/services/createRequestService.ts
var createRequestService=function createRequestService(){var instance=createAxiosInstance();var _getGlobalConfig$getE=createConfig_getGlobalConfig().getEnvInfo(),apiPrefix=_getGlobalConfig$getE.apiPrefix,env=_getGlobalConfig$getE.env;var config={apiPrefix:apiPrefix};var getUserInfoIsInAliUrl;if(env==="prod"){getUserInfoIsInAliUrl={apiPrefix:"https://tingwu.aliyuncs.com/api"};}else{getUserInfoIsInAliUrl={apiPrefix:"https://pre-tingwu.aliyuncs.com/api"};}return{getDirList:genGetDirList(instance,config),startMeeting:genStartMeeting(instance,config),stopMeeting:genStopMeeting(instance,config),saveMeetingDocResult:genSaveMeetingDocResult(instance,config),fetchDomainConfig:domainConfig(instance,config),getUserInfo:genGetUserInfo(instance,config),getUserInfoIsInAli:genGetUserInfo(instance,getUserInfoIsInAliUrl),getTranslates:genGetTranslates(instance,config),getRealtimeTranslate:genGetRealtimeTranslate(instance,config),getMeetingHistoryTranslate:getGetMeetingHistoryTranslate(instance,config),getSyncTransTag:genGetSyncTransTag(instance,config),setMarksGuideStatus:senMarksGuideStatus(instance,config),getMarksGuideStatus:genMarksGuideStatus(instance,config),isWhiteList:function(){var _isWhiteList=asyncToGenerator_asyncToGenerator(/*#__PURE__*/regeneratorRuntime_regeneratorRuntime().mark(function _callee(){var _Boolean,result;return regeneratorRuntime_regeneratorRuntime().wrap(function _callee$(_context){while(1)switch(_context.prev=_context.next){case 0:_context.prev=0;_context.next=3;return _axios_0_27_2_axios_default().get("https://alilang-intranet.alibaba-inc.com/is_white_list.json");case 3:result=_context.sent;return _context.abrupt("return",(_Boolean=Boolean(result===null||result===void 0?void 0:result.data.content))!==null&&_Boolean!==void 0?_Boolean:false);case 7:_context.prev=7;_context.t0=_context["catch"](0);return _context.abrupt("return",false);case 10:case"end":return _context.stop();}},_callee,null,[[0,7]]);}));function isWhiteList(){return _isWhiteList.apply(this,arguments);}return isWhiteList;}()};};
;// CONCATENATED MODULE: ./src/services/index.ts
var services_service=createRequestService();
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/hooks/useEvent.js

function useEvent(callback) {
  var fnRef = _react_18_2_0_react.useRef();
  fnRef.current = callback;
  var memoFn = _react_18_2_0_react.useCallback(function () {
    var _fnRef$current;
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    return (_fnRef$current = fnRef.current) === null || _fnRef$current === void 0 ? void 0 : _fnRef$current.call.apply(_fnRef$current, [fnRef].concat(args));
  }, []);
  return memoFn;
}
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/hooks/useMergedState.js




/** We only think `undefined` is empty */
function hasValue(value) {
  return value !== undefined;
}

/**
 * Similar to `useState` but will use props value if provided.
 * Note that internal use rc-util `useState` hook.
 */
function useMergedState(defaultStateValue, option) {
  var _ref = option || {},
    defaultValue = _ref.defaultValue,
    value = _ref.value,
    onChange = _ref.onChange,
    postState = _ref.postState;

  // ======================= Init =======================
  var _useState = useSafeState(function () {
      if (hasValue(value)) {
        return value;
      } else if (hasValue(defaultValue)) {
        return typeof defaultValue === 'function' ? defaultValue() : defaultValue;
      } else {
        return typeof defaultStateValue === 'function' ? defaultStateValue() : defaultStateValue;
      }
    }),
    _useState2 = slicedToArray_slicedToArray(_useState, 2),
    innerValue = _useState2[0],
    setInnerValue = _useState2[1];
  var mergedValue = value !== undefined ? value : innerValue;
  var postMergedValue = postState ? postState(mergedValue) : mergedValue;

  // ====================== Change ======================
  var onChangeFn = useEvent(onChange);
  var _useState3 = useSafeState([mergedValue]),
    _useState4 = slicedToArray_slicedToArray(_useState3, 2),
    prevValue = _useState4[0],
    setPrevValue = _useState4[1];
  useLayoutUpdateEffect(function () {
    var prev = prevValue[0];
    if (innerValue !== prev) {
      onChangeFn(innerValue, prev);
    }
  }, [prevValue]);

  // Sync value back to `undefined` when it from control to un-control
  useLayoutUpdateEffect(function () {
    if (!hasValue(value)) {
      setInnerValue(value);
    }
  }, [value]);

  // ====================== Update ======================
  var triggerChange = useEvent(function (updater, ignoreDestroy) {
    setInnerValue(updater, ignoreDestroy);
    setPrevValue([mergedValue], ignoreDestroy);
  });
  return [postMergedValue, triggerChange];
}
;// CONCATENATED MODULE: ./node_modules/_rc-switch@3.2.2@rc-switch/es/index.js







var es_Switch = _react_18_2_0_react.forwardRef(function (_ref, ref) {
  var _classNames;
  var _ref$prefixCls = _ref.prefixCls,
    prefixCls = _ref$prefixCls === void 0 ? 'rc-switch' : _ref$prefixCls,
    className = _ref.className,
    checked = _ref.checked,
    defaultChecked = _ref.defaultChecked,
    disabled = _ref.disabled,
    loadingIcon = _ref.loadingIcon,
    checkedChildren = _ref.checkedChildren,
    unCheckedChildren = _ref.unCheckedChildren,
    onClick = _ref.onClick,
    onChange = _ref.onChange,
    onKeyDown = _ref.onKeyDown,
    restProps = _objectWithoutProperties(_ref, ["prefixCls", "className", "checked", "defaultChecked", "disabled", "loadingIcon", "checkedChildren", "unCheckedChildren", "onClick", "onChange", "onKeyDown"]);
  var _useMergedState = useMergedState(false, {
      value: checked,
      defaultValue: defaultChecked
    }),
    _useMergedState2 = slicedToArray_slicedToArray(_useMergedState, 2),
    innerChecked = _useMergedState2[0],
    setInnerChecked = _useMergedState2[1];
  function triggerChange(newChecked, event) {
    var mergedChecked = innerChecked;
    if (!disabled) {
      mergedChecked = newChecked;
      setInnerChecked(mergedChecked);
      onChange === null || onChange === void 0 ? void 0 : onChange(mergedChecked, event);
    }
    return mergedChecked;
  }
  function onInternalKeyDown(e) {
    if (e.which === es_KeyCode.LEFT) {
      triggerChange(false, e);
    } else if (e.which === es_KeyCode.RIGHT) {
      triggerChange(true, e);
    }
    onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(e);
  }
  function onInternalClick(e) {
    var ret = triggerChange(!innerChecked, e); // [Legacy] trigger onClick with value

    onClick === null || onClick === void 0 ? void 0 : onClick(ret, e);
  }
  var switchClassName = _classnames_2_3_2_classnames_default()(prefixCls, className, (_classNames = {}, defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-checked"), innerChecked), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-disabled"), disabled), _classNames));
  return _react_18_2_0_react.createElement("button", Object.assign({}, restProps, {
    type: "button",
    role: "switch",
    "aria-checked": innerChecked,
    disabled: disabled,
    className: switchClassName,
    ref: ref,
    onKeyDown: onInternalKeyDown,
    onClick: onInternalClick
  }), loadingIcon, _react_18_2_0_react.createElement("span", {
    className: "".concat(prefixCls, "-inner")
  }, innerChecked ? checkedChildren : unCheckedChildren));
});
es_Switch.displayName = 'Switch';
/* harmony default export */ var _rc_switch_3_2_2_rc_switch_es = (es_Switch);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/switch/index.js


var switch_rest = undefined && undefined.__rest || function (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;
};









var switch_Switch = /*#__PURE__*/_react_18_2_0_react.forwardRef(function (_a, ref) {
  var _classNames;
  var customizePrefixCls = _a.prefixCls,
    customizeSize = _a.size,
    customDisabled = _a.disabled,
    loading = _a.loading,
    _a$className = _a.className,
    className = _a$className === void 0 ? '' : _a$className,
    props = switch_rest(_a, ["prefixCls", "size", "disabled", "loading", "className"]);
   false ? 0 : void 0;
  var _React$useContext = _react_18_2_0_react.useContext(context_ConfigContext),
    getPrefixCls = _React$useContext.getPrefixCls,
    direction = _React$useContext.direction;
  var size = _react_18_2_0_react.useContext(config_provider_SizeContext);
  // ===================== Disabled =====================
  var disabled = _react_18_2_0_react.useContext(config_provider_DisabledContext);
  var mergedDisabled = (customDisabled !== null && customDisabled !== void 0 ? customDisabled : disabled) || loading;
  var prefixCls = getPrefixCls('switch', customizePrefixCls);
  var loadingIcon = /*#__PURE__*/_react_18_2_0_react.createElement("div", {
    className: "".concat(prefixCls, "-handle")
  }, loading && /*#__PURE__*/_react_18_2_0_react.createElement(icons_LoadingOutlined, {
    className: "".concat(prefixCls, "-loading-icon")
  }));
  var classes = _classnames_2_3_2_classnames_default()((_classNames = {}, defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-small"), (customizeSize || size) === 'small'), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-loading"), loading), defineProperty_defineProperty(_classNames, "".concat(prefixCls, "-rtl"), direction === 'rtl'), _classNames), className);
  return /*#__PURE__*/_react_18_2_0_react.createElement(wave, {
    insertExtraNode: true
  }, /*#__PURE__*/_react_18_2_0_react.createElement(_rc_switch_3_2_2_rc_switch_es, extends_extends({}, props, {
    prefixCls: prefixCls,
    className: classes,
    disabled: mergedDisabled,
    ref: ref,
    loadingIcon: loadingIcon
  })));
});
switch_Switch.__ANT_SWITCH = true;
if (false) {}
/* harmony default export */ var es_switch = (switch_Switch);
;// CONCATENATED MODULE: ./src/components/popup/popup.tsx
var Popup=/*#__PURE__*/(0,_react_18_2_0_react.memo)(function(props){var addElement=props.addElement,startRecord=props.startRecord;var _useState=(0,_react_18_2_0_react.useState)(true),_useState2=slicedToArray_slicedToArray(_useState,2),enableMicphone=_useState2[0],setEnableMicphone=_useState2[1];var _useState3=(0,_react_18_2_0_react.useState)([]),_useState4=slicedToArray_slicedToArray(_useState3,2),folders=_useState4[0],setFolders=_useState4[1];(0,_react_18_2_0_react.useEffect)(function(){asyncToGenerator_asyncToGenerator(/*#__PURE__*/regeneratorRuntime_regeneratorRuntime().mark(function _callee(){var response;return regeneratorRuntime_regeneratorRuntime().wrap(function _callee$(_context){while(1)switch(_context.prev=_context.next){case 0:_context.next=2;return services_service.getDirList();case 2:response=_context.sent;setFolders(response.data||[]);case 4:case"end":return _context.stop();}},_callee);}))();},[]);var handleStartRecord=(0,_react_18_2_0_react.useCallback)(function(){startRecord(enableMicphone);},[startRecord,enableMicphone]);return/*#__PURE__*/(0,jsx_runtime.jsxs)(Wrapper,{children:[/*#__PURE__*/(0,jsx_runtime.jsxs)("div",{children:["\u5F00\u542F\u9EA6\u514B\u98CE ",/*#__PURE__*/(0,jsx_runtime.jsx)(es_switch,{checked:enableMicphone,onChange:setEnableMicphone})]}),/*#__PURE__*/(0,jsx_runtime.jsx)("div",{style:{cursor:'pointer'},onClick:addElement,children:"\u63D2\u5165\u5143\u7D20"}),/*#__PURE__*/(0,jsx_runtime.jsx)("div",{children:"\u4FDD\u5B58\u81F3\uFF1A"}),folders.map(function(folder){return/*#__PURE__*/(0,jsx_runtime.jsxs)("div",{children:["\u6587\u4EF6\u5939\uFF1A",folder.dirName]});}),/*#__PURE__*/(0,jsx_runtime.jsx)("div",{onClick:function onClick(){chrome.windows.create({focused:true,url:'https://www.baidu.com',type:"panel",width:400,height:800});},children:"test"}),/*#__PURE__*/(0,jsx_runtime.jsx)("div",{style:{cursor:'pointer'},onClick:handleStartRecord,children:"\u5F00\u542F\u5B9E\u65F6\u8BB0\u5F55"})]});});
;// CONCATENATED MODULE: ./src/components/popup/index.ts

;// CONCATENATED MODULE: ./node_modules/_@babel_runtime@7.21.0@@babel/runtime/helpers/esm/inheritsLoose.js

function inheritsLoose_inheritsLoose(subClass, superClass) {
  subClass.prototype = Object.create(superClass.prototype);
  subClass.prototype.constructor = subClass;
  _setPrototypeOf(subClass, superClass);
}
;// CONCATENATED MODULE: ./node_modules/_@ali_tingwu-core@0.3.9@@ali/tingwu-core/dist-web/controller/translateController.js



var translateController_TranslateMode;
(function (TranslateMode) {
  TranslateMode[TranslateMode["OriginAndTranslate"] = 0] = "OriginAndTranslate";
  TranslateMode[TranslateMode["TranslateOnly"] = 1] = "TranslateOnly";
  TranslateMode[TranslateMode["Disabled"] = 2] = "Disabled";
})(translateController_TranslateMode || (translateController_TranslateMode = {}));
var TranslateController = /*#__PURE__*/(/* unused pure expression or super */ null && (function (_AbstractCmdControlle) {
  _inheritsLoose(TranslateController, _AbstractCmdControlle);
  function TranslateController() {
    var _this;
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    _this = _AbstractCmdControlle.call.apply(_AbstractCmdControlle, [this].concat(args)) || this;
    _this.fixParagraphTranslate = {};
    _this.unfixParagraphTranslate = {
      fixContentTranslate: [],
      unfixContentTranslate: ''
    };
    _this.translateMode = translateController_TranslateMode.Disabled;
    return _this;
  }
  var _proto = TranslateController.prototype;
  _proto.setTranslateMode = function setTranslateMode(translateMode) {
    var oldTranslateMode = this.translateMode;
    this.translateMode = translateMode;
    var livingMode = this.controller.getLivingMode();
    if (livingMode && oldTranslateMode === translateController_TranslateMode.Disabled && translateMode !== translateController_TranslateMode.Disabled) {
      // 当开启翻译时，触发一次unfixContentChange，为了能够触发一次翻译
      this.controller.emitUnfixContentChange();
    }
    this.controller.emit('translateModeChange', {
      translateMode: translateMode
    });
  };
  _proto.getTranslateMode = function getTranslateMode(_pid) {
    return this.translateMode;
  };
  _proto.setTranslating = function setTranslating(pid, isTranslating) {
    var translate = this.fixParagraphTranslate[pid];
    if (translate && translate.isTranslating === isTranslating && !translate.isTranslateError) {
      return;
    }
    if (translate == null) {
      this.fixParagraphTranslate[pid] = {
        translateResult: [],
        pid: pid,
        isTranslating: isTranslating,
        isTranslateError: false
      };
    } else {
      translate.isTranslating = true;
      translate.isTranslateError = false;
    }
    this.controller.emit('fixParagraphTranslateChange', {
      pid: pid,
      translate: this.fixParagraphTranslate[pid]
    });
  };
  _proto.isTranslateError = function isTranslateError(words) {
    return words.map(function (word) {
      return word.text;
    }).join('').length === 0;
  } //
  // return isSuccessful
  ;

  _proto.setTranslate = function setTranslate(pid, translate) {
    return this.setTranslateByWords(pid, getWordsBySces(translate));
  } //
  // return isSuccessful
  ;

  _proto.setTranslateByWords = function setTranslateByWords(pid, translate) {
    var isHasContent = this.controller.getTextContent(pid);
    var isError = isHasContent && this.isTranslateError(translate);
    if (!this.fixParagraphTranslate[pid]) {
      this.fixParagraphTranslate[pid] = {
        pid: pid,
        translateResult: []
      };
    }
    this.fixParagraphTranslate[pid].isTranslating = false;
    if (isError) {
      this.fixParagraphTranslate[pid].isTranslateError = true;
    } else {
      this.fixParagraphTranslate[pid].isTranslateError = false;
      this.fixParagraphTranslate[pid].translateResult = translate;
    }
    this.controller.emit('fixParagraphTranslateChange', {
      pid: pid,
      translate: this.fixParagraphTranslate[pid]
    });
    return !isError;
  };
  _proto.getTranslate = function getTranslate(pid) {
    return this.fixParagraphTranslate[pid];
  };
  _proto.setUnfixTranslate = function setUnfixTranslate(pid, unfixContentTranslate, fixContentTranslate) {
    this.setUnfixTranslateByWords(pid, unfixContentTranslate, getWordsBySces(fixContentTranslate));
  };
  _proto.setUnfixTranslateByWords = function setUnfixTranslateByWords(pid, unfixContentTranslate, fixContentTranslate) {
    this.unfixParagraphTranslate = {
      pid: pid,
      unfixContentTranslate: unfixContentTranslate,
      fixContentTranslate: fixContentTranslate
    };
    this.controller.emit('unfixParagraphTranslateChange', this.unfixParagraphTranslate);
  };
  _proto.getUnfixTranslate = function getUnfixTranslate() {
    return this.unfixParagraphTranslate;
  };
  _proto.setUnfixToFixed = function setUnfixToFixed(newUnfixPid) {
    var _this$getUnfixTransla = this.getUnfixTranslate(),
      pid = _this$getUnfixTransla.pid,
      fixContentTranslate = _this$getUnfixTransla.fixContentTranslate;
    if (pid) {
      this.setUnfixTranslate(newUnfixPid, '', []);
      this.setTranslateByWords(pid, fixContentTranslate);
    }
  };
  _proto.reset = function reset() {
    this.fixParagraphTranslate = {};
    this.unfixParagraphTranslate = {
      fixContentTranslate: [],
      unfixContentTranslate: ''
    };
  };
  return TranslateController;
}(AbstractCmdController)));
;// CONCATENATED MODULE: ./node_modules/_@ali_tingwu-component-react@0.3.9@@ali/tingwu-component-react/dist-web/extensions/baseExtension.js
var BaseExtension = function BaseExtension() {};
;// CONCATENATED MODULE: ./node_modules/_@ali_tingwu-component-react@0.3.9@@ali/tingwu-component-react/dist-web/components/tagControlBar/styled.js

var styled_Wrapper = /*#__PURE__*/styled_components_browser_esm.div(["display:flex;align-items:center;z-index:1;"]);
var Title = /*#__PURE__*/styled_components_browser_esm.div(["font-size:12px;color:rgba(39,38,77,0.65);line-height:20px;white-space:nowrap;cursor:default;"]);
var styled_Content = /*#__PURE__*/styled_components_browser_esm.div(["display:flex;align-items:center;"]);
var BaseButton = /*#__PURE__*/(/* unused pure expression or super */ null && (styled.div(["width:16px;height:16px;cursor:pointer;"])));
var NailButton = /*#__PURE__*/(/* unused pure expression or super */ null && (styled(BaseButton)(["background:url('https://img.alicdn.com/imgextra/i2/O1CN014J4tmL1IydoI9zCMb_!!6000000000962-2-tps-200-200.png') 0 0 no-repeat;background-size:contain;width:16px;height:16px;"])));
var QuestionButton = /*#__PURE__*/(/* unused pure expression or super */ null && (styled(BaseButton)(["background:url('https://img.alicdn.com/imgextra/i3/O1CN01kn6xGP27kwMhrpPqo_!!6000000007836-2-tps-200-200.png') 0 0 no-repeat;background-size:contain;width:16px;height:16px;"])));
var TodoButton = /*#__PURE__*/(/* unused pure expression or super */ null && (styled(BaseButton)(["background:url('https://img.alicdn.com/imgextra/i4/O1CN01DO5d6820cyA2dZeQp_!!6000000006871-2-tps-200-200.png') 0 0 no-repeat;background-size:contain;width:16px;height:16px;"])));
var ResetButton = /*#__PURE__*/(/* unused pure expression or super */ null && (styled(BaseButton)(["background:url('https://img.alicdn.com/imgextra/i2/O1CN01p3JzB01h8IwbBRomW_!!6000000004232-2-tps-200-200.png') 0 0 no-repeat;width:16px;height:16px;background-size:contain;"])));
var TagControlBarUseHoverContainer = /*#__PURE__*/styled_components_browser_esm.div(["display:flex;cursor:pointer;&:hover{transform:scale(1.2);}"]);
;// CONCATENATED MODULE: ./node_modules/_@ali_tingwu-component-react@0.3.9@@ali/tingwu-component-react/dist-web/components/tagControlBar/tagControlBarUseHover.js

var _createElement = /*#__PURE__*/_react_18_2_0_react.createElement;

var TagControlBarUseHover = function TagControlBarUseHover(_ref) {
  var tagControlBar = _ref.tagControlBar;
  return /*#__PURE__*/_createElement(TagControlBarUseHoverContainer, null, tagControlBar);
};
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/Dom/addEventListener.js

function addEventListenerWrap(target, eventType, cb, option) {
  /* eslint camelcase: 2 */
  var callback = _react_dom_18_2_0_react_dom.unstable_batchedUpdates ? function run(e) {
    _react_dom_18_2_0_react_dom.unstable_batchedUpdates(cb, e);
  } : cb;
  if (target.addEventListener) {
    target.addEventListener(eventType, callback, option);
  }
  return {
    remove: function remove() {
      if (target.removeEventListener) {
        target.removeEventListener(eventType, callback, option);
      }
    }
  };
}
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/Portal.js



var Portal_Portal = /*#__PURE__*/(0,_react_18_2_0_react.forwardRef)(function (props, ref) {
  var didUpdate = props.didUpdate,
    getContainer = props.getContainer,
    children = props.children;
  var parentRef = (0,_react_18_2_0_react.useRef)();
  var containerRef = (0,_react_18_2_0_react.useRef)();

  // Ref return nothing, only for wrapper check exist
  (0,_react_18_2_0_react.useImperativeHandle)(ref, function () {
    return {};
  });

  // Create container in client side with sync to avoid useEffect not get ref
  var initRef = (0,_react_18_2_0_react.useRef)(false);
  if (!initRef.current && canUseDom()) {
    containerRef.current = getContainer();
    parentRef.current = containerRef.current.parentNode;
    initRef.current = true;
  }

  // [Legacy] Used by `rc-trigger`
  (0,_react_18_2_0_react.useEffect)(function () {
    didUpdate === null || didUpdate === void 0 ? void 0 : didUpdate(props);
  });
  (0,_react_18_2_0_react.useEffect)(function () {
    // Restore container to original place
    // React 18 StrictMode will unmount first and mount back for effect test:
    // https://reactjs.org/blog/2022/03/29/react-v18.html#new-strict-mode-behaviors
    if (containerRef.current.parentNode === null && parentRef.current !== null) {
      parentRef.current.appendChild(containerRef.current);
    }
    return function () {
      var _containerRef$current, _containerRef$current2;
      // [Legacy] This should not be handle by Portal but parent PortalWrapper instead.
      // Since some component use `Portal` directly, we have to keep the logic here.
      (_containerRef$current = containerRef.current) === null || _containerRef$current === void 0 ? void 0 : (_containerRef$current2 = _containerRef$current.parentNode) === null || _containerRef$current2 === void 0 ? void 0 : _containerRef$current2.removeChild(containerRef.current);
    };
  }, []);
  return containerRef.current ? /*#__PURE__*/_react_dom_18_2_0_react_dom.createPortal(children, containerRef.current) : null;
});
/* harmony default export */ var _rc_util_5_29_2_rc_util_es_Portal = (Portal_Portal);
;// CONCATENATED MODULE: ./node_modules/_rc-trigger@5.3.4@rc-trigger/es/utils/alignUtil.js

function isPointsEq(a1, a2, isAlignPoint) {
  if (isAlignPoint) {
    return a1[0] === a2[0];
  }
  return a1[0] === a2[0] && a1[1] === a2[1];
}
function getAlignFromPlacement(builtinPlacements, placementStr, align) {
  var baseAlign = builtinPlacements[placementStr] || {};
  return _objectSpread2(_objectSpread2({}, baseAlign), align);
}
function getAlignPopupClassName(builtinPlacements, prefixCls, align, isAlignPoint) {
  var points = align.points;
  var placements = Object.keys(builtinPlacements);
  for (var i = 0; i < placements.length; i += 1) {
    var placement = placements[i];
    if (isPointsEq(builtinPlacements[placement].points, points, isAlignPoint)) {
      return "".concat(prefixCls, "-placement-").concat(placement);
    }
  }
  return '';
}
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/isMobile.js
/* harmony default export */ var isMobile = (function () {
  if (typeof navigator === 'undefined' || typeof window === 'undefined') {
    return false;
  }
  var agent = navigator.userAgent || navigator.vendor || window.opera;
  return /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i.test(agent) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw-(n|u)|c55\/|capi|ccwa|cdm-|cell|chtm|cldc|cmd-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc-s|devi|dica|dmob|do(c|p)o|ds(12|-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(-|_)|g1 u|g560|gene|gf-5|g-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd-(m|p|t)|hei-|hi(pt|ta)|hp( i|ip)|hs-c|ht(c(-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i-(20|go|ma)|i230|iac( |-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|-[a-w])|libw|lynx|m1-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|-([1-8]|c))|phil|pire|pl(ay|uc)|pn-2|po(ck|rt|se)|prox|psio|pt-g|qa-a|qc(07|12|21|32|60|-[2-7]|i-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h-|oo|p-)|sdk\/|se(c(-|0|1)|47|mc|nd|ri)|sgh-|shar|sie(-|m)|sk-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h-|v-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl-|tdg-|tel(i|m)|tim-|t-mo|to(pl|sh)|ts(70|m-|m3|m5)|tx-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas-|your|zeto|zte-/i.test(agent === null || agent === void 0 ? void 0 : agent.substr(0, 4));
});
;// CONCATENATED MODULE: ./node_modules/_rc-trigger@5.3.4@rc-trigger/es/utils/legacyUtil.js
function getMotion(_ref) {
  var prefixCls = _ref.prefixCls,
    motion = _ref.motion,
    animation = _ref.animation,
    transitionName = _ref.transitionName;
  if (motion) {
    return motion;
  }
  if (animation) {
    return {
      motionName: "".concat(prefixCls, "-").concat(animation)
    };
  }
  if (transitionName) {
    return {
      motionName: transitionName
    };
  }
  return null;
}
;// CONCATENATED MODULE: ./node_modules/_rc-trigger@5.3.4@rc-trigger/es/Popup/Mask.js






function Mask_Mask(props) {
  var prefixCls = props.prefixCls,
    visible = props.visible,
    zIndex = props.zIndex,
    mask = props.mask,
    maskMotion = props.maskMotion,
    maskAnimation = props.maskAnimation,
    maskTransitionName = props.maskTransitionName;
  if (!mask) {
    return null;
  }
  var motion = {};
  if (maskMotion || maskTransitionName || maskAnimation) {
    motion = _objectSpread2({
      motionAppear: true
    }, getMotion({
      motion: maskMotion,
      prefixCls: prefixCls,
      transitionName: maskTransitionName,
      animation: maskAnimation
    }));
  }
  return /*#__PURE__*/_react_18_2_0_react.createElement(_rc_motion_2_6_3_rc_motion_es, extends_extends({}, motion, {
    visible: visible,
    removeOnLeave: true
  }), function (_ref) {
    var className = _ref.className;
    return /*#__PURE__*/_react_18_2_0_react.createElement("div", {
      style: {
        zIndex: zIndex
      },
      className: _classnames_2_3_2_classnames_default()("".concat(prefixCls, "-mask"), className)
    });
  });
}
;// CONCATENATED MODULE: ./node_modules/_dom-align@1.12.4@dom-align/dist-web/index.js
function dist_web_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 dist_web_objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = null != arguments[i] ? arguments[i] : {};
    i % 2 ? dist_web_ownKeys(Object(source), !0).forEach(function (key) {
      dist_web_defineProperty(target, key, source[key]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : dist_web_ownKeys(Object(source)).forEach(function (key) {
      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
    });
  }
  return target;
}
function dist_web_typeof(obj) {
  "@babel/helpers - typeof";

  return dist_web_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;
  }, dist_web_typeof(obj);
}
function dist_web_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;
}
var vendorPrefix;
var jsCssMap = {
  Webkit: '-webkit-',
  Moz: '-moz-',
  // IE did it wrong again ...
  ms: '-ms-',
  O: '-o-'
};
function getVendorPrefix() {
  if (vendorPrefix !== undefined) {
    return vendorPrefix;
  }
  vendorPrefix = '';
  var style = document.createElement('p').style;
  var testProp = 'Transform';
  for (var key in jsCssMap) {
    if (key + testProp in style) {
      vendorPrefix = key;
    }
  }
  return vendorPrefix;
}
function dist_web_getTransitionName() {
  return getVendorPrefix() ? "".concat(getVendorPrefix(), "TransitionProperty") : 'transitionProperty';
}
function getTransformName() {
  return getVendorPrefix() ? "".concat(getVendorPrefix(), "Transform") : 'transform';
}
function setTransitionProperty(node, value) {
  var name = dist_web_getTransitionName();
  if (name) {
    node.style[name] = value;
    if (name !== 'transitionProperty') {
      node.style.transitionProperty = value;
    }
  }
}
function setTransform(node, value) {
  var name = getTransformName();
  if (name) {
    node.style[name] = value;
    if (name !== 'transform') {
      node.style.transform = value;
    }
  }
}
function getTransitionProperty(node) {
  return node.style.transitionProperty || node.style[dist_web_getTransitionName()];
}
function getTransformXY(node) {
  var style = window.getComputedStyle(node, null);
  var transform = style.getPropertyValue('transform') || style.getPropertyValue(getTransformName());
  if (transform && transform !== 'none') {
    var matrix = transform.replace(/[^0-9\-.,]/g, '').split(',');
    return {
      x: parseFloat(matrix[12] || matrix[4], 0),
      y: parseFloat(matrix[13] || matrix[5], 0)
    };
  }
  return {
    x: 0,
    y: 0
  };
}
var matrix2d = /matrix\((.*)\)/;
var matrix3d = /matrix3d\((.*)\)/;
function setTransformXY(node, xy) {
  var style = window.getComputedStyle(node, null);
  var transform = style.getPropertyValue('transform') || style.getPropertyValue(getTransformName());
  if (transform && transform !== 'none') {
    var arr;
    var match2d = transform.match(matrix2d);
    if (match2d) {
      match2d = match2d[1];
      arr = match2d.split(',').map(function (item) {
        return parseFloat(item, 10);
      });
      arr[4] = xy.x;
      arr[5] = xy.y;
      setTransform(node, "matrix(".concat(arr.join(','), ")"));
    } else {
      var match3d = transform.match(matrix3d)[1];
      arr = match3d.split(',').map(function (item) {
        return parseFloat(item, 10);
      });
      arr[12] = xy.x;
      arr[13] = xy.y;
      setTransform(node, "matrix3d(".concat(arr.join(','), ")"));
    }
  } else {
    setTransform(node, "translateX(".concat(xy.x, "px) translateY(").concat(xy.y, "px) translateZ(0)"));
  }
}
var RE_NUM = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source;
var getComputedStyleX;

// https://stackoverflow.com/a/3485654/3040605
function forceRelayout(elem) {
  var originalStyle = elem.style.display;
  elem.style.display = 'none';
  elem.offsetHeight; // eslint-disable-line
  elem.style.display = originalStyle;
}
function css(el, name, v) {
  var value = v;
  if (dist_web_typeof(name) === 'object') {
    for (var i in name) {
      if (name.hasOwnProperty(i)) {
        css(el, i, name[i]);
      }
    }
    return undefined;
  }
  if (typeof value !== 'undefined') {
    if (typeof value === 'number') {
      value = "".concat(value, "px");
    }
    el.style[name] = value;
    return undefined;
  }
  return getComputedStyleX(el, name);
}
function getClientPosition(elem) {
  var box;
  var x;
  var y;
  var doc = elem.ownerDocument;
  var body = doc.body;
  var docElem = doc && doc.documentElement;
  // 根据 GBS 最新数据，A-Grade Browsers 都已支持 getBoundingClientRect 方法，不用再考虑传统的实现方式
  box = elem.getBoundingClientRect();

  // 注：jQuery 还考虑减去 docElem.clientLeft/clientTop
  // 但测试发现，这样反而会导致当 html 和 body 有边距/边框样式时，获取的值不正确
  // 此外，ie6 会忽略 html 的 margin 值，幸运地是没有谁会去设置 html 的 margin

  x = Math.floor(box.left);
  y = Math.floor(box.top);

  // In IE, most of the time, 2 extra pixels are added to the top and left
  // due to the implicit 2-pixel inset border.  In IE6/7 quirks mode and
  // IE6 standards mode, this border can be overridden by setting the
  // document element's border to zero -- thus, we cannot rely on the
  // offset always being 2 pixels.

  // In quirks mode, the offset can be determined by querying the body's
  // clientLeft/clientTop, but in standards mode, it is found by querying
  // the document element's clientLeft/clientTop.  Since we already called
  // getClientBoundingRect we have already forced a reflow, so it is not
  // too expensive just to query them all.

  // ie 下应该减去窗口的边框吧，毕竟默认 absolute 都是相对窗口定位的
  // 窗口边框标准是设 documentElement ,quirks 时设置 body
  // 最好禁止在 body 和 html 上边框 ，但 ie < 9 html 默认有 2px ，减去
  // 但是非 ie 不可能设置窗口边框，body html 也不是窗口 ,ie 可以通过 html,body 设置
  // 标准 ie 下 docElem.clientTop 就是 border-top
  // ie7 html 即窗口边框改变不了。永远为 2
  // 但标准 firefox/chrome/ie9 下 docElem.clientTop 是窗口边框，即使设了 border-top 也为 0

  x -= docElem.clientLeft || body.clientLeft || 0;
  y -= docElem.clientTop || body.clientTop || 0;
  return {
    left: x,
    top: y
  };
}
function dist_web_getScroll(w, top) {
  var ret = w["page".concat(top ? 'Y' : 'X', "Offset")];
  var method = "scroll".concat(top ? 'Top' : 'Left');
  if (typeof ret !== 'number') {
    var d = w.document;
    // ie6,7,8 standard mode
    ret = d.documentElement[method];
    if (typeof ret !== 'number') {
      // quirks mode
      ret = d.body[method];
    }
  }
  return ret;
}
function getScrollLeft(w) {
  return dist_web_getScroll(w);
}
function getScrollTop(w) {
  return dist_web_getScroll(w, true);
}
function getOffset(el) {
  var pos = getClientPosition(el);
  var doc = el.ownerDocument;
  var w = doc.defaultView || doc.parentWindow;
  pos.left += getScrollLeft(w);
  pos.top += getScrollTop(w);
  return pos;
}

/**
 * A crude way of determining if an object is a window
 * @member util
 */
function dist_web_isWindow(obj) {
  // must use == for ie8
  /* eslint eqeqeq:0 */
  return obj !== null && obj !== undefined && obj == obj.window;
}
function getDocument(node) {
  if (dist_web_isWindow(node)) {
    return node.document;
  }
  if (node.nodeType === 9) {
    return node;
  }
  return node.ownerDocument;
}
function _getComputedStyle(elem, name, cs) {
  var computedStyle = cs;
  var val = '';
  var d = getDocument(elem);
  computedStyle = computedStyle || d.defaultView.getComputedStyle(elem, null);

  // https://github.com/kissyteam/kissy/issues/61
  if (computedStyle) {
    val = computedStyle.getPropertyValue(name) || computedStyle[name];
  }
  return val;
}
var _RE_NUM_NO_PX = new RegExp("^(".concat(RE_NUM, ")(?!px)[a-z%]+$"), 'i');
var RE_POS = /^(top|right|bottom|left)$/;
var CURRENT_STYLE = 'currentStyle';
var RUNTIME_STYLE = 'runtimeStyle';
var LEFT = 'left';
var PX = 'px';
function _getComputedStyleIE(elem, name) {
  // currentStyle maybe null
  // http://msdn.microsoft.com/en-us/library/ms535231.aspx
  var ret = elem[CURRENT_STYLE] && elem[CURRENT_STYLE][name];

  // 当 width/height 设置为百分比时，通过 pixelLeft 方式转换的 width/height 值
  // 一开始就处理了! CUSTOM_STYLE.height,CUSTOM_STYLE.width ,cssHook 解决@2011-08-19
  // 在 ie 下不对，需要直接用 offset 方式
  // borderWidth 等值也有问题，但考虑到 borderWidth 设为百分比的概率很小，这里就不考虑了

  // From the awesome hack by Dean Edwards
  // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
  // If we're not dealing with a regular pixel number
  // but a number that has a weird ending, we need to convert it to pixels
  // exclude left right for relativity
  if (_RE_NUM_NO_PX.test(ret) && !RE_POS.test(name)) {
    // Remember the original values
    var style = elem.style;
    var left = style[LEFT];
    var rsLeft = elem[RUNTIME_STYLE][LEFT];

    // prevent flashing of content
    elem[RUNTIME_STYLE][LEFT] = elem[CURRENT_STYLE][LEFT];

    // Put in the new values to get a computed value out
    style[LEFT] = name === 'fontSize' ? '1em' : ret || 0;
    ret = style.pixelLeft + PX;

    // Revert the changed values
    style[LEFT] = left;
    elem[RUNTIME_STYLE][LEFT] = rsLeft;
  }
  return ret === '' ? 'auto' : ret;
}
if (typeof window !== 'undefined') {
  getComputedStyleX = window.getComputedStyle ? _getComputedStyle : _getComputedStyleIE;
}
function getOffsetDirection(dir, option) {
  if (dir === 'left') {
    return option.useCssRight ? 'right' : dir;
  }
  return option.useCssBottom ? 'bottom' : dir;
}
function oppositeOffsetDirection(dir) {
  if (dir === 'left') {
    return 'right';
  } else if (dir === 'right') {
    return 'left';
  } else if (dir === 'top') {
    return 'bottom';
  } else if (dir === 'bottom') {
    return 'top';
  }
}

// 设置 elem 相对 elem.ownerDocument 的坐标
function setLeftTop(elem, offset, option) {
  // set position first, in-case top/left are set even on static elem
  if (css(elem, 'position') === 'static') {
    elem.style.position = 'relative';
  }
  var presetH = -999;
  var presetV = -999;
  var horizontalProperty = getOffsetDirection('left', option);
  var verticalProperty = getOffsetDirection('top', option);
  var oppositeHorizontalProperty = oppositeOffsetDirection(horizontalProperty);
  var oppositeVerticalProperty = oppositeOffsetDirection(verticalProperty);
  if (horizontalProperty !== 'left') {
    presetH = 999;
  }
  if (verticalProperty !== 'top') {
    presetV = 999;
  }
  var originalTransition = '';
  var originalOffset = getOffset(elem);
  if ('left' in offset || 'top' in offset) {
    originalTransition = getTransitionProperty(elem) || '';
    setTransitionProperty(elem, 'none');
  }
  if ('left' in offset) {
    elem.style[oppositeHorizontalProperty] = '';
    elem.style[horizontalProperty] = "".concat(presetH, "px");
  }
  if ('top' in offset) {
    elem.style[oppositeVerticalProperty] = '';
    elem.style[verticalProperty] = "".concat(presetV, "px");
  }
  // force relayout
  forceRelayout(elem);
  var old = getOffset(elem);
  var originalStyle = {};
  for (var key in offset) {
    if (offset.hasOwnProperty(key)) {
      var dir = getOffsetDirection(key, option);
      var preset = key === 'left' ? presetH : presetV;
      var off = originalOffset[key] - old[key];
      if (dir === key) {
        originalStyle[dir] = preset + off;
      } else {
        originalStyle[dir] = preset - off;
      }
    }
  }
  css(elem, originalStyle);
  // force relayout
  forceRelayout(elem);
  if ('left' in offset || 'top' in offset) {
    setTransitionProperty(elem, originalTransition);
  }
  var ret = {};
  for (var _key in offset) {
    if (offset.hasOwnProperty(_key)) {
      var _dir = getOffsetDirection(_key, option);
      var _off = offset[_key] - originalOffset[_key];
      if (_key === _dir) {
        ret[_dir] = originalStyle[_dir] + _off;
      } else {
        ret[_dir] = originalStyle[_dir] - _off;
      }
    }
  }
  css(elem, ret);
}
function setTransform$1(elem, offset) {
  var originalOffset = getOffset(elem);
  var originalXY = getTransformXY(elem);
  var resultXY = {
    x: originalXY.x,
    y: originalXY.y
  };
  if ('left' in offset) {
    resultXY.x = originalXY.x + offset.left - originalOffset.left;
  }
  if ('top' in offset) {
    resultXY.y = originalXY.y + offset.top - originalOffset.top;
  }
  setTransformXY(elem, resultXY);
}
function setOffset(elem, offset, option) {
  if (option.ignoreShake) {
    var oriOffset = getOffset(elem);
    var oLeft = oriOffset.left.toFixed(0);
    var oTop = oriOffset.top.toFixed(0);
    var tLeft = offset.left.toFixed(0);
    var tTop = offset.top.toFixed(0);
    if (oLeft === tLeft && oTop === tTop) {
      return;
    }
  }
  if (option.useCssRight || option.useCssBottom) {
    setLeftTop(elem, offset, option);
  } else if (option.useCssTransform && getTransformName() in document.body.style) {
    setTransform$1(elem, offset);
  } else {
    setLeftTop(elem, offset, option);
  }
}
function each(arr, fn) {
  for (var i = 0; i < arr.length; i++) {
    fn(arr[i]);
  }
}
function isBorderBoxFn(elem) {
  return getComputedStyleX(elem, 'boxSizing') === 'border-box';
}
var BOX_MODELS = ['margin', 'border', 'padding'];
var CONTENT_INDEX = -1;
var PADDING_INDEX = 2;
var BORDER_INDEX = 1;
var MARGIN_INDEX = 0;
function swap(elem, options, callback) {
  var old = {};
  var style = elem.style;
  var name;

  // Remember the old values, and insert the new ones
  for (name in options) {
    if (options.hasOwnProperty(name)) {
      old[name] = style[name];
      style[name] = options[name];
    }
  }
  callback.call(elem);

  // Revert the old values
  for (name in options) {
    if (options.hasOwnProperty(name)) {
      style[name] = old[name];
    }
  }
}
function getPBMWidth(elem, props, which) {
  var value = 0;
  var prop;
  var j;
  var i;
  for (j = 0; j < props.length; j++) {
    prop = props[j];
    if (prop) {
      for (i = 0; i < which.length; i++) {
        var cssProp = void 0;
        if (prop === 'border') {
          cssProp = "".concat(prop).concat(which[i], "Width");
        } else {
          cssProp = prop + which[i];
        }
        value += parseFloat(getComputedStyleX(elem, cssProp)) || 0;
      }
    }
  }
  return value;
}
var domUtils = {
  getParent: function getParent(element) {
    var parent = element;
    do {
      if (parent.nodeType === 11 && parent.host) {
        parent = parent.host;
      } else {
        parent = parent.parentNode;
      }
    } while (parent && parent.nodeType !== 1 && parent.nodeType !== 9);
    return parent;
  }
};
each(['Width', 'Height'], function (name) {
  domUtils["doc".concat(name)] = function (refWin) {
    var d = refWin.document;
    return Math.max(
    // firefox chrome documentElement.scrollHeight< body.scrollHeight
    // ie standard mode : documentElement.scrollHeight> body.scrollHeight
    d.documentElement["scroll".concat(name)],
    // quirks : documentElement.scrollHeight 最大等于可视窗口多一点？
    d.body["scroll".concat(name)], domUtils["viewport".concat(name)](d));
  };
  domUtils["viewport".concat(name)] = function (win) {
    // pc browser includes scrollbar in window.innerWidth
    var prop = "client".concat(name);
    var doc = win.document;
    var body = doc.body;
    var documentElement = doc.documentElement;
    var documentElementProp = documentElement[prop];
    // 标准模式取 documentElement
    // backcompat 取 body
    return doc.compatMode === 'CSS1Compat' && documentElementProp || body && body[prop] || documentElementProp;
  };
});

/*
 得到元素的大小信息
 @param elem
 @param name
 @param {String} [extra]  'padding' : (css width) + padding
 'border' : (css width) + padding + border
 'margin' : (css width) + padding + border + margin
 */
function getWH(elem, name, ex) {
  var extra = ex;
  if (dist_web_isWindow(elem)) {
    return name === 'width' ? domUtils.viewportWidth(elem) : domUtils.viewportHeight(elem);
  } else if (elem.nodeType === 9) {
    return name === 'width' ? domUtils.docWidth(elem) : domUtils.docHeight(elem);
  }
  var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
  var borderBoxValue = name === 'width' ? Math.floor(elem.getBoundingClientRect().width) : Math.floor(elem.getBoundingClientRect().height);
  var isBorderBox = isBorderBoxFn(elem);
  var cssBoxValue = 0;
  if (borderBoxValue === null || borderBoxValue === undefined || borderBoxValue <= 0) {
    borderBoxValue = undefined;
    // Fall back to computed then un computed css if necessary
    cssBoxValue = getComputedStyleX(elem, name);
    if (cssBoxValue === null || cssBoxValue === undefined || Number(cssBoxValue) < 0) {
      cssBoxValue = elem.style[name] || 0;
    }
    // Normalize '', auto, and prepare for extra
    cssBoxValue = Math.floor(parseFloat(cssBoxValue)) || 0;
  }
  if (extra === undefined) {
    extra = isBorderBox ? BORDER_INDEX : CONTENT_INDEX;
  }
  var borderBoxValueOrIsBorderBox = borderBoxValue !== undefined || isBorderBox;
  var val = borderBoxValue || cssBoxValue;
  if (extra === CONTENT_INDEX) {
    if (borderBoxValueOrIsBorderBox) {
      return val - getPBMWidth(elem, ['border', 'padding'], which);
    }
    return cssBoxValue;
  } else if (borderBoxValueOrIsBorderBox) {
    if (extra === BORDER_INDEX) {
      return val;
    }
    return val + (extra === PADDING_INDEX ? -getPBMWidth(elem, ['border'], which) : getPBMWidth(elem, ['margin'], which));
  }
  return cssBoxValue + getPBMWidth(elem, BOX_MODELS.slice(extra), which);
}
var cssShow = {
  position: 'absolute',
  visibility: 'hidden',
  display: 'block'
};

// fix #119 : https://github.com/kissyteam/kissy/issues/119
function getWHIgnoreDisplay() {
  for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
    args[_key2] = arguments[_key2];
  }
  var val;
  var elem = args[0];
  // in case elem is window
  // elem.offsetWidth === undefined
  if (elem.offsetWidth !== 0) {
    val = getWH.apply(undefined, args);
  } else {
    swap(elem, cssShow, function () {
      val = getWH.apply(undefined, args);
    });
  }
  return val;
}
each(['width', 'height'], function (name) {
  var first = name.charAt(0).toUpperCase() + name.slice(1);
  domUtils["outer".concat(first)] = function (el, includeMargin) {
    return el && getWHIgnoreDisplay(el, name, includeMargin ? MARGIN_INDEX : BORDER_INDEX);
  };
  var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
  domUtils[name] = function (elem, v) {
    var val = v;
    if (val !== undefined) {
      if (elem) {
        var isBorderBox = isBorderBoxFn(elem);
        if (isBorderBox) {
          val += getPBMWidth(elem, ['padding', 'border'], which);
        }
        return css(elem, name, val);
      }
      return undefined;
    }
    return elem && getWHIgnoreDisplay(elem, name, CONTENT_INDEX);
  };
});
function dist_web_mix(to, from) {
  for (var i in from) {
    if (from.hasOwnProperty(i)) {
      to[i] = from[i];
    }
  }
  return to;
}
var utils = {
  getWindow: function getWindow(node) {
    if (node && node.document && node.setTimeout) {
      return node;
    }
    var doc = node.ownerDocument || node;
    return doc.defaultView || doc.parentWindow;
  },
  getDocument: getDocument,
  offset: function offset(el, value, option) {
    if (typeof value !== 'undefined') {
      setOffset(el, value, option || {});
    } else {
      return getOffset(el);
    }
  },
  isWindow: dist_web_isWindow,
  each: each,
  css: css,
  clone: function clone(obj) {
    var i;
    var ret = {};
    for (i in obj) {
      if (obj.hasOwnProperty(i)) {
        ret[i] = obj[i];
      }
    }
    var overflow = obj.overflow;
    if (overflow) {
      for (i in obj) {
        if (obj.hasOwnProperty(i)) {
          ret.overflow[i] = obj.overflow[i];
        }
      }
    }
    return ret;
  },
  mix: dist_web_mix,
  getWindowScrollLeft: function getWindowScrollLeft(w) {
    return getScrollLeft(w);
  },
  getWindowScrollTop: function getWindowScrollTop(w) {
    return getScrollTop(w);
  },
  merge: function merge() {
    var ret = {};
    for (var i = 0; i < arguments.length; i++) {
      utils.mix(ret, i < 0 || arguments.length <= i ? undefined : arguments[i]);
    }
    return ret;
  },
  viewportWidth: 0,
  viewportHeight: 0
};
dist_web_mix(utils, domUtils);

/**
 * 得到会导致元素显示不全的祖先元素
 */
var getParent = utils.getParent;
function getOffsetParent(element) {
  if (utils.isWindow(element) || element.nodeType === 9) {
    return null;
  }
  // ie 这个也不是完全可行
  /*
   <div style="width: 50px;height: 100px;overflow: hidden">
   <div style="width: 50px;height: 100px;position: relative;" id="d6">
   元素 6 高 100px 宽 50px<br/>
   </div>
   </div>
   */
  // element.offsetParent does the right thing in ie7 and below. Return parent with layout!
  //  In other browsers it only includes elements with position absolute, relative or
  // fixed, not elements with overflow set to auto or scroll.
  //        if (UA.ie && ieMode < 8) {
  //            return element.offsetParent;
  //        }
  // 统一的 offsetParent 方法
  var doc = utils.getDocument(element);
  var body = doc.body;
  var parent;
  var positionStyle = utils.css(element, 'position');
  var skipStatic = positionStyle === 'fixed' || positionStyle === 'absolute';
  if (!skipStatic) {
    return element.nodeName.toLowerCase() === 'html' ? null : getParent(element);
  }
  for (parent = getParent(element); parent && parent !== body && parent.nodeType !== 9; parent = getParent(parent)) {
    positionStyle = utils.css(parent, 'position');
    if (positionStyle !== 'static') {
      return parent;
    }
  }
  return null;
}
var getParent$1 = utils.getParent;
function isAncestorFixed(element) {
  if (utils.isWindow(element) || element.nodeType === 9) {
    return false;
  }
  var doc = utils.getDocument(element);
  var body = doc.body;
  var parent = null;
  for (parent = getParent$1(element);
  // 修复元素位于 document.documentElement 下导致崩溃问题
  parent && parent !== body && parent !== doc; parent = getParent$1(parent)) {
    var positionStyle = utils.css(parent, 'position');
    if (positionStyle === 'fixed') {
      return true;
    }
  }
  return false;
}

/**
 * 获得元素的显示部分的区域
 */
function getVisibleRectForElement(element, alwaysByViewport) {
  var visibleRect = {
    left: 0,
    right: Infinity,
    top: 0,
    bottom: Infinity
  };
  var el = getOffsetParent(element);
  var doc = utils.getDocument(element);
  var win = doc.defaultView || doc.parentWindow;
  var body = doc.body;
  var documentElement = doc.documentElement;

  // Determine the size of the visible rect by climbing the dom accounting for
  // all scrollable containers.
  while (el) {
    // clientWidth is zero for inline block elements in ie.
    if ((navigator.userAgent.indexOf('MSIE') === -1 || el.clientWidth !== 0) &&
    // body may have overflow set on it, yet we still get the entire
    // viewport. In some browsers, el.offsetParent may be
    // document.documentElement, so check for that too.
    el !== body && el !== documentElement && utils.css(el, 'overflow') !== 'visible') {
      var pos = utils.offset(el);
      // add border
      pos.left += el.clientLeft;
      pos.top += el.clientTop;
      visibleRect.top = Math.max(visibleRect.top, pos.top);
      visibleRect.right = Math.min(visibleRect.right,
      // consider area without scrollBar
      pos.left + el.clientWidth);
      visibleRect.bottom = Math.min(visibleRect.bottom, pos.top + el.clientHeight);
      visibleRect.left = Math.max(visibleRect.left, pos.left);
    } else if (el === body || el === documentElement) {
      break;
    }
    el = getOffsetParent(el);
  }

  // Set element position to fixed
  // make sure absolute element itself don't affect it's visible area
  // https://github.com/ant-design/ant-design/issues/7601
  var originalPosition = null;
  if (!utils.isWindow(element) && element.nodeType !== 9) {
    originalPosition = element.style.position;
    var position = utils.css(element, 'position');
    if (position === 'absolute') {
      element.style.position = 'fixed';
    }
  }
  var scrollX = utils.getWindowScrollLeft(win);
  var scrollY = utils.getWindowScrollTop(win);
  var viewportWidth = utils.viewportWidth(win);
  var viewportHeight = utils.viewportHeight(win);
  var documentWidth = documentElement.scrollWidth;
  var documentHeight = documentElement.scrollHeight;

  // scrollXXX on html is sync with body which means overflow: hidden on body gets wrong scrollXXX.
  // We should cut this ourself.
  var bodyStyle = window.getComputedStyle(body);
  if (bodyStyle.overflowX === 'hidden') {
    documentWidth = win.innerWidth;
  }
  if (bodyStyle.overflowY === 'hidden') {
    documentHeight = win.innerHeight;
  }

  // Reset element position after calculate the visible area
  if (element.style) {
    element.style.position = originalPosition;
  }
  if (alwaysByViewport || isAncestorFixed(element)) {
    // Clip by viewport's size.
    visibleRect.left = Math.max(visibleRect.left, scrollX);
    visibleRect.top = Math.max(visibleRect.top, scrollY);
    visibleRect.right = Math.min(visibleRect.right, scrollX + viewportWidth);
    visibleRect.bottom = Math.min(visibleRect.bottom, scrollY + viewportHeight);
  } else {
    // Clip by document's size.
    var maxVisibleWidth = Math.max(documentWidth, scrollX + viewportWidth);
    visibleRect.right = Math.min(visibleRect.right, maxVisibleWidth);
    var maxVisibleHeight = Math.max(documentHeight, scrollY + viewportHeight);
    visibleRect.bottom = Math.min(visibleRect.bottom, maxVisibleHeight);
  }
  return visibleRect.top >= 0 && visibleRect.left >= 0 && visibleRect.bottom > visibleRect.top && visibleRect.right > visibleRect.left ? visibleRect : null;
}
function adjustForViewport(elFuturePos, elRegion, visibleRect, overflow) {
  var pos = utils.clone(elFuturePos);
  var size = {
    width: elRegion.width,
    height: elRegion.height
  };
  if (overflow.adjustX && pos.left < visibleRect.left) {
    pos.left = visibleRect.left;
  }

  // Left edge inside and right edge outside viewport, try to resize it.
  if (overflow.resizeWidth && pos.left >= visibleRect.left && pos.left + size.width > visibleRect.right) {
    size.width -= pos.left + size.width - visibleRect.right;
  }

  // Right edge outside viewport, try to move it.
  if (overflow.adjustX && pos.left + size.width > visibleRect.right) {
    // 保证左边界和可视区域左边界对齐
    pos.left = Math.max(visibleRect.right - size.width, visibleRect.left);
  }

  // Top edge outside viewport, try to move it.
  if (overflow.adjustY && pos.top < visibleRect.top) {
    pos.top = visibleRect.top;
  }

  // Top edge inside and bottom edge outside viewport, try to resize it.
  if (overflow.resizeHeight && pos.top >= visibleRect.top && pos.top + size.height > visibleRect.bottom) {
    size.height -= pos.top + size.height - visibleRect.bottom;
  }

  // Bottom edge outside viewport, try to move it.
  if (overflow.adjustY && pos.top + size.height > visibleRect.bottom) {
    // 保证上边界和可视区域上边界对齐
    pos.top = Math.max(visibleRect.bottom - size.height, visibleRect.top);
  }
  return utils.mix(pos, size);
}
function getRegion(node) {
  var offset;
  var w;
  var h;
  if (!utils.isWindow(node) && node.nodeType !== 9) {
    offset = utils.offset(node);
    w = utils.outerWidth(node);
    h = utils.outerHeight(node);
  } else {
    var win = utils.getWindow(node);
    offset = {
      left: utils.getWindowScrollLeft(win),
      top: utils.getWindowScrollTop(win)
    };
    w = utils.viewportWidth(win);
    h = utils.viewportHeight(win);
  }
  offset.width = w;
  offset.height = h;
  return offset;
}

/**
 * 获取 node 上的 align 对齐点 相对于页面的坐标
 */

function getAlignOffset(region, align) {
  var V = align.charAt(0);
  var H = align.charAt(1);
  var w = region.width;
  var h = region.height;
  var x = region.left;
  var y = region.top;
  if (V === 'c') {
    y += h / 2;
  } else if (V === 'b') {
    y += h;
  }
  if (H === 'c') {
    x += w / 2;
  } else if (H === 'r') {
    x += w;
  }
  return {
    left: x,
    top: y
  };
}
function getElFuturePos(elRegion, refNodeRegion, points, offset, targetOffset) {
  var p1 = getAlignOffset(refNodeRegion, points[1]);
  var p2 = getAlignOffset(elRegion, points[0]);
  var diff = [p2.left - p1.left, p2.top - p1.top];
  return {
    left: Math.round(elRegion.left - diff[0] + offset[0] - targetOffset[0]),
    top: Math.round(elRegion.top - diff[1] + offset[1] - targetOffset[1])
  };
}

/**
 * align dom node flexibly
 * @author yiminghe@gmail.com
 */

// http://yiminghe.iteye.com/blog/1124720

function isFailX(elFuturePos, elRegion, visibleRect) {
  return elFuturePos.left < visibleRect.left || elFuturePos.left + elRegion.width > visibleRect.right;
}
function isFailY(elFuturePos, elRegion, visibleRect) {
  return elFuturePos.top < visibleRect.top || elFuturePos.top + elRegion.height > visibleRect.bottom;
}
function isCompleteFailX(elFuturePos, elRegion, visibleRect) {
  return elFuturePos.left > visibleRect.right || elFuturePos.left + elRegion.width < visibleRect.left;
}
function isCompleteFailY(elFuturePos, elRegion, visibleRect) {
  return elFuturePos.top > visibleRect.bottom || elFuturePos.top + elRegion.height < visibleRect.top;
}
function flip(points, reg, map) {
  var ret = [];
  utils.each(points, function (p) {
    ret.push(p.replace(reg, function (m) {
      return map[m];
    }));
  });
  return ret;
}
function flipOffset(offset, index) {
  offset[index] = -offset[index];
  return offset;
}
function convertOffset(str, offsetLen) {
  var n;
  if (/%$/.test(str)) {
    n = parseInt(str.substring(0, str.length - 1), 10) / 100 * offsetLen;
  } else {
    n = parseInt(str, 10);
  }
  return n || 0;
}
function normalizeOffset(offset, el) {
  offset[0] = convertOffset(offset[0], el.width);
  offset[1] = convertOffset(offset[1], el.height);
}

/**
 * @param el
 * @param tgtRegion 参照节点所占的区域: { left, top, width, height }
 * @param align
 */
function doAlign(el, tgtRegion, align, isTgtRegionVisible) {
  var points = align.points;
  var offset = align.offset || [0, 0];
  var targetOffset = align.targetOffset || [0, 0];
  var overflow = align.overflow;
  var source = align.source || el;
  offset = [].concat(offset);
  targetOffset = [].concat(targetOffset);
  overflow = overflow || {};
  var newOverflowCfg = {};
  var fail = 0;
  var alwaysByViewport = !!(overflow && overflow.alwaysByViewport);
  // 当前节点可以被放置的显示区域
  var visibleRect = getVisibleRectForElement(source, alwaysByViewport);
  // 当前节点所占的区域, left/top/width/height
  var elRegion = getRegion(source);
  // 将 offset 转换成数值，支持百分比
  normalizeOffset(offset, elRegion);
  normalizeOffset(targetOffset, tgtRegion);
  // 当前节点将要被放置的位置
  var elFuturePos = getElFuturePos(elRegion, tgtRegion, points, offset, targetOffset);
  // 当前节点将要所处的区域
  var newElRegion = utils.merge(elRegion, elFuturePos);

  // 如果可视区域不能完全放置当前节点时允许调整
  if (visibleRect && (overflow.adjustX || overflow.adjustY) && isTgtRegionVisible) {
    if (overflow.adjustX) {
      // 如果横向不能放下
      if (isFailX(elFuturePos, elRegion, visibleRect)) {
        // 对齐位置反下
        var newPoints = flip(points, /[lr]/gi, {
          l: 'r',
          r: 'l'
        });
        // 偏移量也反下
        var newOffset = flipOffset(offset, 0);
        var newTargetOffset = flipOffset(targetOffset, 0);
        var newElFuturePos = getElFuturePos(elRegion, tgtRegion, newPoints, newOffset, newTargetOffset);
        if (!isCompleteFailX(newElFuturePos, elRegion, visibleRect)) {
          fail = 1;
          points = newPoints;
          offset = newOffset;
          targetOffset = newTargetOffset;
        }
      }
    }
    if (overflow.adjustY) {
      // 如果纵向不能放下
      if (isFailY(elFuturePos, elRegion, visibleRect)) {
        // 对齐位置反下
        var _newPoints = flip(points, /[tb]/gi, {
          t: 'b',
          b: 't'
        });
        // 偏移量也反下
        var _newOffset = flipOffset(offset, 1);
        var _newTargetOffset = flipOffset(targetOffset, 1);
        var _newElFuturePos = getElFuturePos(elRegion, tgtRegion, _newPoints, _newOffset, _newTargetOffset);
        if (!isCompleteFailY(_newElFuturePos, elRegion, visibleRect)) {
          fail = 1;
          points = _newPoints;
          offset = _newOffset;
          targetOffset = _newTargetOffset;
        }
      }
    }

    // 如果失败，重新计算当前节点将要被放置的位置
    if (fail) {
      elFuturePos = getElFuturePos(elRegion, tgtRegion, points, offset, targetOffset);
      utils.mix(newElRegion, elFuturePos);
    }
    var isStillFailX = isFailX(elFuturePos, elRegion, visibleRect);
    var isStillFailY = isFailY(elFuturePos, elRegion, visibleRect);
    // 检查反下后的位置是否可以放下了，如果仍然放不下：
    // 1. 复原修改过的定位参数
    if (isStillFailX || isStillFailY) {
      var _newPoints2 = points;

      // 重置对应部分的翻转逻辑
      if (isStillFailX) {
        _newPoints2 = flip(points, /[lr]/gi, {
          l: 'r',
          r: 'l'
        });
      }
      if (isStillFailY) {
        _newPoints2 = flip(points, /[tb]/gi, {
          t: 'b',
          b: 't'
        });
      }
      points = _newPoints2;
      offset = align.offset || [0, 0];
      targetOffset = align.targetOffset || [0, 0];
    }
    // 2. 只有指定了可以调整当前方向才调整
    newOverflowCfg.adjustX = overflow.adjustX && isStillFailX;
    newOverflowCfg.adjustY = overflow.adjustY && isStillFailY;

    // 确实要调整，甚至可能会调整高度宽度
    if (newOverflowCfg.adjustX || newOverflowCfg.adjustY) {
      newElRegion = adjustForViewport(elFuturePos, elRegion, visibleRect, newOverflowCfg);
    }
  }

  // need judge to in case set fixed with in css on height auto element
  if (newElRegion.width !== elRegion.width) {
    utils.css(source, 'width', utils.width(source) + newElRegion.width - elRegion.width);
  }
  if (newElRegion.height !== elRegion.height) {
    utils.css(source, 'height', utils.height(source) + newElRegion.height - elRegion.height);
  }

  // https://github.com/kissyteam/kissy/issues/190
  // 相对于屏幕位置没变，而 left/top 变了
  // 例如 <div 'relative'><el absolute></div>
  utils.offset(source, {
    left: newElRegion.left,
    top: newElRegion.top
  }, {
    useCssRight: align.useCssRight,
    useCssBottom: align.useCssBottom,
    useCssTransform: align.useCssTransform,
    ignoreShake: align.ignoreShake
  });
  return {
    points: points,
    offset: offset,
    targetOffset: targetOffset,
    overflow: newOverflowCfg
  };
}
/**
 *  2012-04-26 yiminghe@gmail.com
 *   - 优化智能对齐算法
 *   - 慎用 resizeXX
 *
 *  2011-07-13 yiminghe@gmail.com note:
 *   - 增加智能对齐，以及大小调整选项
 **/

function isOutOfVisibleRect(target, alwaysByViewport) {
  var visibleRect = getVisibleRectForElement(target, alwaysByViewport);
  var targetRegion = getRegion(target);
  return !visibleRect || targetRegion.left + targetRegion.width <= visibleRect.left || targetRegion.top + targetRegion.height <= visibleRect.top || targetRegion.left >= visibleRect.right || targetRegion.top >= visibleRect.bottom;
}
function alignElement(el, refNode, align) {
  var target = align.target || refNode;
  var refNodeRegion = getRegion(target);
  var isTargetNotOutOfVisible = !isOutOfVisibleRect(target, align.overflow && align.overflow.alwaysByViewport);
  return doAlign(el, refNodeRegion, align, isTargetNotOutOfVisible);
}
alignElement.__getOffsetParent = getOffsetParent;
alignElement.__getVisibleRectForElement = getVisibleRectForElement;

/**
 * `tgtPoint`: { pageX, pageY } or { clientX, clientY }.
 * If client position provided, will internal convert to page position.
 */

function alignPoint(el, tgtPoint, align) {
  var pageX;
  var pageY;
  var doc = utils.getDocument(el);
  var win = doc.defaultView || doc.parentWindow;
  var scrollX = utils.getWindowScrollLeft(win);
  var scrollY = utils.getWindowScrollTop(win);
  var viewportWidth = utils.viewportWidth(win);
  var viewportHeight = utils.viewportHeight(win);
  if ('pageX' in tgtPoint) {
    pageX = tgtPoint.pageX;
  } else {
    pageX = scrollX + tgtPoint.clientX;
  }
  if ('pageY' in tgtPoint) {
    pageY = tgtPoint.pageY;
  } else {
    pageY = scrollY + tgtPoint.clientY;
  }
  var tgtRegion = {
    left: pageX,
    top: pageY,
    width: 0,
    height: 0
  };
  var pointInView = pageX >= 0 && pageX <= scrollX + viewportWidth && pageY >= 0 && pageY <= scrollY + viewportHeight;

  // Provide default target point
  var points = [align.points[0], 'cc'];
  return doAlign(el, tgtRegion, dist_web_objectSpread2(dist_web_objectSpread2({}, align), {}, {
    points: points
  }), pointInView);
}
/* harmony default export */ var _dom_align_1_12_4_dom_align_dist_web = ((/* unused pure expression or super */ null && (alignElement)));

;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/isEqual.js



/**
 * Deeply compares two object literals.
 * @param obj1 object 1
 * @param obj2 object 2
 * @param shallow shallow compare
 * @returns
 */
function isEqual(obj1, obj2) {
  var shallow = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
  // https://github.com/mapbox/mapbox-gl-js/pull/5979/files#diff-fde7145050c47cc3a306856efd5f9c3016e86e859de9afbd02c879be5067e58f
  var refSet = new Set();
  function deepEqual(a, b) {
    var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
    var circular = refSet.has(a);
    es_warning(!circular, 'Warning: There may be circular references');
    if (circular) {
      return false;
    }
    if (a === b) {
      return true;
    }
    if (shallow && level > 1) {
      return false;
    }
    refSet.add(a);
    var newLevel = level + 1;
    if (Array.isArray(a)) {
      if (!Array.isArray(b) || a.length !== b.length) {
        return false;
      }
      for (var i = 0; i < a.length; i++) {
        if (!deepEqual(a[i], b[i], newLevel)) {
          return false;
        }
      }
      return true;
    }
    if (a && b && _typeof(a) === 'object' && _typeof(b) === 'object') {
      var keys = Object.keys(a);
      if (keys.length !== Object.keys(b).length) {
        return false;
      }
      return keys.every(function (key) {
        return deepEqual(a[key], b[key], newLevel);
      });
    }
    // other
    return false;
  }
  return deepEqual(obj1, obj2);
}
/* harmony default export */ var es_isEqual = (isEqual);
;// CONCATENATED MODULE: ./node_modules/_rc-util@5.29.2@rc-util/es/Dom/isVisible.js
/* harmony default export */ var isVisible = (function (element) {
  if (!element) {
    return false;
  }
  if (element instanceof Element) {
    if (element.offsetParent) {
      return true;
    }
    if (element.getBBox) {
      var _getBBox = element.getBBox(),
        width = _getBBox.width,
        height = _getBBox.height;
      if (width || height) {
        return true;
      }
    }
    if (element.getBoundingClientRect) {
      var _element$getBoundingC = element.getBoundingClientRect(),
        _width = _element$getBoundingC.width,
        _height = _element$getBoundingC.height;
      if (_width || _height) {
        return true;
      }
    }
  }
  return false;
});
;// CONCATENATED MODULE: ./node_modules/_rc-align@4.0.15@rc-align/es/hooks/useBuffer.js

/* harmony default export */ var useBuffer = (function (callback, buffer) {
  var calledRef = _react_18_2_0_react.useRef(false);
  var timeoutRef = _react_18_2_0_react.useRef(null);
  function cancelTrigger() {
    window.clearTimeout(timeoutRef.current);
  }
  function trigger(force) {
    cancelTrigger();
    if (!calledRef.current || force === true) {
      if (callback(force) === false) {
        // Not delay since callback cancelled self
        return;
      }
      calledRef.current = true;
      timeoutRef.current = window.setTimeout(function () {
        calledRef.current = false;
      }, buffer);
    } else {
      timeoutRef.current = window.setTimeout(function () {
        calledRef.current = false;
        trigger();
      }, buffer);
    }
  }
  return [trigger, function () {
    calledRef.current = false;
    cancelTrigger();
  }];
});
;// CONCATENATED MODULE: ./node_modules/_resize-observer-polyfill@1.5.1@resize-observer-polyfill/dist/ResizeObserver.es.js
/**
 * A collection of shims that provide minimal functionality of the ES6 collections.
 *
 * These implementations are not meant to be used outside of the ResizeObserver
 * modules as they cover only a limited range of use cases.
 */
/* eslint-disable require-jsdoc, valid-jsdoc */
var MapShim = function () {
  if (typeof Map !== 'undefined') {
    return Map;
  }
  /**
   * Returns index in provided array that matches the specified key.
   *
   * @param {Array<Array>} arr
   * @param {*} key
   * @returns {number}
   */
  function getIndex(arr, key) {
    var result = -1;
    arr.some(function (entry, index) {
      if (entry[0] === key) {
        result = index;
        return true;
      }
      return false;
    });
    return result;
  }
  return (/** @class */function () {
      function class_1() {
        this.__entries__ = [];
      }
      Object.defineProperty(class_1.prototype, "size", {
        /**
         * @returns {boolean}
         */
        get: function get() {
          return this.__entries__.length;
        },
        enumerable: true,
        configurable: true
      });
      /**
       * @param {*} key
       * @returns {*}
       */
      class_1.prototype.get = function (key) {
        var index = getIndex(this.__entries__, key);
        var entry = this.__entries__[index];
        return entry && entry[1];
      };
      /**
       * @param {*} key
       * @param {*} value
       * @returns {void}
       */
      class_1.prototype.set = function (key, value) {
        var index = getIndex(this.__entries__, key);
        if (~index) {
          this.__entries__[index][1] = value;
        } else {
          this.__entries__.push([key, value]);
        }
      };
      /**
       * @param {*} key
       * @returns {void}
       */
      class_1.prototype.delete = function (key) {
        var entries = this.__entries__;
        var index = getIndex(entries, key);
        if (~index) {
          entries.splice(index, 1);
        }
      };
      /**
       * @param {*} key
       * @returns {void}
       */
      class_1.prototype.has = function (key) {
        return !!~getIndex(this.__entries__, key);
      };
      /**
       * @returns {void}
       */
      class_1.prototype.clear = function () {
        this.__entries__.splice(0);
      };
      /**
       * @param {Function} callback
       * @param {*} [ctx=null]
       * @returns {void}
       */
      class_1.prototype.forEach = function (callback, ctx) {
        if (ctx === void 0) {
          ctx = null;
        }
        for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {
          var entry = _a[_i];
          callback.call(ctx, entry[1], entry[0]);
        }
      };
      return class_1;
    }()
  );
}();

/**
 * Detects whether window and document objects are available in current environment.
 */
var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document;

// Returns global object of a current environment.
var global$1 = function () {
  if (typeof __webpack_require__.g !== 'undefined' && __webpack_require__.g.Math === Math) {
    return __webpack_require__.g;
  }
  if (typeof self !== 'undefined' && self.Math === Math) {
    return self;
  }
  if (typeof window !== 'undefined' && window.Math === Math) {
    return window;
  }
  // eslint-disable-next-line no-new-func
  return Function('return this')();
}();

/**
 * A shim for the requestAnimationFrame which falls back to the setTimeout if
 * first one is not supported.
 *
 * @returns {number} Requests' identifier.
 */
var requestAnimationFrame$1 = function () {
  if (typeof requestAnimationFrame === 'function') {
    // It's required to use a bounded function because IE sometimes throws
    // an "Invalid calling object" error if rAF is invoked without the global
    // object on the left hand side.
    return requestAnimationFrame.bind(global$1);
  }
  return function (callback) {
    return setTimeout(function () {
      return callback(Date.now());
    }, 1000 / 60);
  };
}();

// Defines minimum timeout before adding a trailing call.
var trailingTimeout = 2;
/**
 * Creates a wrapper function which ensures that provided callback will be
 * invoked only once during the specified delay period.
 *
 * @param {Function} callback - Function to be invoked after the delay period.
 * @param {number} delay - Delay after which to invoke callback.
 * @returns {Function}
 */
function throttle(callback, delay) {
  var leadingCall = false,
    trailingCall = false,
    lastCallTime = 0;
  /**
   * Invokes the original callback function and schedules new invocation if
   * the "proxy" was called during current request.
   *
   * @returns {void}
   */
  function resolvePending() {
    if (leadingCall) {
      leadingCall = false;
      callback();
    }
    if (trailingCall) {
      proxy();
    }
  }
  /**
   * Callback invoked after the specified delay. It will further postpone
   * invocation of the original function delegating it to the
   * requestAnimationFrame.
   *
   * @returns {void}
   */
  function timeoutCallback() {
    requestAnimationFrame$1(resolvePending);
  }
  /**
   * Schedules invocation of the original function.
   *
   * @returns {void}
   */
  function proxy() {
    var timeStamp = Date.now();
    if (leadingCall) {
      // Reject immediately following calls.
      if (timeStamp - lastCallTime < trailingTimeout) {
        return;
      }
      // Schedule new call to be in invoked when the pending one is resolved.
      // This is important for "transitions" which never actually start
      // immediately so there is a chance that we might miss one if change
      // happens amids the pending invocation.
      trailingCall = true;
    } else {
      leadingCall = true;
      trailingCall = false;
      setTimeout(timeoutCallback, delay);
    }
    lastCallTime = timeStamp;
  }
  return proxy;
}

// Minimum delay before invoking the update of observers.
var REFRESH_DELAY = 20;
// A list of substrings of CSS properties used to find transition events that
// might affect dimensions of observed elements.
var transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];
// Check if MutationObserver is available.
var mutationObserverSupported = typeof MutationObserver !== 'undefined';
/**
 * Singleton controller class which handles updates of ResizeObserver instances.
 */
var ResizeObserverController = /** @class */function () {
  /**
   * Creates a new instance of ResizeObserverController.
   *
   * @private
   */
  function ResizeObserverController() {
    /**
     * Indicates whether DOM listeners have been added.
     *
     * @private {boolean}
     */
    this.connected_ = false;
    /**
     * Tells that controller has subscribed for Mutation Events.
     *
     * @private {boolean}
     */
    this.mutationEventsAdded_ = false;
    /**
     * Keeps reference to the instance of MutationObserver.
     *
     * @private {MutationObserver}
     */
    this.mutationsObserver_ = null;
    /**
     * A list of connected observers.
     *
     * @private {Array<ResizeObserverSPI>}
     */
    this.observers_ = [];
    this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);
    this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);
  }
  /**
   * Adds observer to observers list.
   *
   * @param {ResizeObserverSPI} observer - Observer to be added.
   * @returns {void}
   */
  ResizeObserverController.prototype.addObserver = function (observer) {
    if (!~this.observers_.indexOf(observer)) {
      this.observers_.push(observer);
    }
    // Add listeners if they haven't been added yet.
    if (!this.connected_) {
      this.connect_();
    }
  };
  /**
   * Removes observer from observers list.
   *
   * @param {ResizeObserverSPI} observer - Observer to be removed.
   * @returns {void}
   */
  ResizeObserverController.prototype.removeObserver = function (observer) {
    var observers = this.observers_;
    var index = observers.indexOf(observer);
    // Remove observer if it's present in registry.
    if (~index) {
      observers.splice(index, 1);
    }
    // Remove listeners if controller has no connected observers.
    if (!observers.length && this.connected_) {
      this.disconnect_();
    }
  };
  /**
   * Invokes the update of observers. It will continue running updates insofar
   * it detects changes.
   *
   * @returns {void}
   */
  ResizeObserverController.prototype.refresh = function () {
    var changesDetected = this.updateObservers_();
    // Continue running updates if changes have been detected as there might
    // be future ones caused by CSS transitions.
    if (changesDetected) {
      this.refresh();
    }
  };
  /**
   * Updates every observer from observers list and notifies them of queued
   * entries.
   *
   * @private
   * @returns {boolean} Returns "true" if any observer has detected changes in
   *      dimensions of it's elements.
   */
  ResizeObserverController.prototype.updateObservers_ = function () {
    // Collect observers that have active observations.
    var activeObservers = this.observers_.filter(function (observer) {
      return observer.gatherActive(), observer.hasActive();
    });
    // Deliver notifications in a separate cycle in order to avoid any
    // collisions between observers, e.g. when multiple instances of
    // ResizeObserver are tracking the same element and the callback of one
    // of them changes content dimensions of the observed target. Sometimes
    // this may result in notifications being blocked for the rest of observers.
    activeObservers.forEach(function (observer) {
      return observer.broadcastActive();
    });
    return activeObservers.length > 0;
  };
  /**
   * Initializes DOM listeners.
   *
   * @private
   * @returns {void}
   */
  ResizeObserverController.prototype.connect_ = function () {
    // Do nothing if running in a non-browser environment or if listeners
    // have been already added.
    if (!isBrowser || this.connected_) {
      return;
    }
    // Subscription to the "Transitionend" event is used as a workaround for
    // delayed transitions. This way it's possible to capture at least the
    // final state of an element.
    document.addEventListener('transitionend', this.onTransitionEnd_);
    window.addEventListener('resize', this.refresh);
    if (mutationObserverSupported) {
      this.mutationsObserver_ = new MutationObserver(this.refresh);
      this.mutationsObserver_.observe(document, {
        attributes: true,
        childList: true,
        characterData: true,
        subtree: true
      });
    } else {
      document.addEventListener('DOMSubtreeModified', this.refresh);
      this.mutationEventsAdded_ = true;
    }
    this.connected_ = true;
  };
  /**
   * Removes DOM listeners.
   *
   * @private
   * @returns {void}
   */
  ResizeObserverController.prototype.disconnect_ = function () {
    // Do nothing if running in a non-browser environment or if listeners
    // have been already removed.
    if (!isBrowser || !this.connected_) {
      return;
    }
    document.removeEventListener('transitionend', this.onTransitionEnd_);
    window.removeEventListener('resize', this.refresh);
    if (this.mutationsObserver_) {
      this.mutationsObserver_.disconnect();
    }
    if (this.mutationEventsAdded_) {
      document.removeEventListener('DOMSubtreeModified', this.refresh);
    }
    this.mutationsObserver_ = null;
    this.mutationEventsAdded_ = false;
    this.connected_ = false;
  };
  /**
   * "Transitionend" event handler.
   *
   * @private
   * @param {TransitionEvent} event
   * @returns {void}
   */
  ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {
    var _b = _a.propertyName,
      propertyName = _b === void 0 ? '' : _b;
    // Detect whether transition may affect dimensions of an element.
    var isReflowProperty = transitionKeys.some(function (key) {
      return !!~propertyName.indexOf(key);
    });
    if (isReflowProperty) {
      this.refresh();
    }
  };
  /**
   * Returns instance of the ResizeObserverController.
   *
   * @returns {ResizeObserverController}
   */
  ResizeObserverController.getInstance = function () {
    if (!this.instance_) {
      this.instance_ = new ResizeObserverController();
    }
    return this.instance_;
  };
  /**
   * Holds reference to the controller's instance.
   *
   * @private {ResizeObserverController}
   */
  ResizeObserverController.instance_ = null;
  return ResizeObserverController;
}();

/**
 * Defines non-writable/enumerable properties of the provided target object.
 *
 * @param {Object} target - Object for which to define properties.
 * @param {Object} props - Properties to be defined.
 * @returns {Object} Target object.
 */
var defineConfigurable = function defineConfigurable(target, props) {
  for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {
    var key = _a[_i];
    Object.defineProperty(target, key, {
      value: props[key],
      enumerable: false,
      writable: false,
      configurable: true
    });
  }
  return target;
};

/**
 * Returns the global object associated with provided element.
 *
 * @param {Object} target
 * @returns {Object}
 */
var getWindowOf = function getWindowOf(target) {
  // Assume that the element is an instance of Node, which means that it
  // has the "ownerDocument" property from which we can retrieve a
  // corresponding global object.
  var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;
  // Return the local global object if it's not possible extract one from
  // provided element.
  return ownerGlobal || global$1;
};

// Placeholder of an empty content rectangle.
var emptyRect = createRectInit(0, 0, 0, 0);
/**
 * Converts provided string to a number.
 *
 * @param {number|string} value
 * @returns {number}
 */
function toFloat(value) {
  return parseFloat(value) || 0;
}
/**
 * Extracts borders size from provided styles.
 *
 * @param {CSSStyleDeclaration} styles
 * @param {...string} positions - Borders positions (top, right, ...)
 * @returns {number}
 */
function getBordersSize(styles) {
  var positions = [];
  for (var _i = 1; _i < arguments.length; _i++) {
    positions[_i - 1] = arguments[_i];
  }
  return positions.reduce(function (size, position) {
    var value = styles['border-' + position + '-width'];
    return size + toFloat(value);
  }, 0);
}
/**
 * Extracts paddings sizes from provided styles.
 *
 * @param {CSSStyleDeclaration} styles
 * @returns {Object} Paddings box.
 */
function getPaddings(styles) {
  var positions = ['top', 'right', 'bottom', 'left'];
  var paddings = {};
  for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {
    var position = positions_1[_i];
    var value = styles['padding-' + position];
    paddings[position] = toFloat(value);
  }
  return paddings;
}
/**
 * Calculates content rectangle of provided SVG element.
 *
 * @param {SVGGraphicsElement} target - Element content rectangle of which needs
 *      to be calculated.
 * @returns {DOMRectInit}
 */
function getSVGContentRect(target) {
  var bbox = target.getBBox();
  return createRectInit(0, 0, bbox.width, bbox.height);
}
/**
 * Calculates content rectangle of provided HTMLElement.
 *
 * @param {HTMLElement} target - Element for which to calculate the content rectangle.
 * @returns {DOMRectInit}
 */
function getHTMLElementContentRect(target) {
  // Client width & height properties can't be
  // used exclusively as they provide rounded values.
  var clientWidth = target.clientWidth,
    clientHeight = target.clientHeight;
  // By this condition we can catch all non-replaced inline, hidden and
  // detached elements. Though elements with width & height properties less
  // than 0.5 will be discarded as well.
  //
  // Without it we would need to implement separate methods for each of
  // those cases and it's not possible to perform a precise and performance
  // effective test for hidden elements. E.g. even jQuery's ':visible' filter
  // gives wrong results for elements with width & height less than 0.5.
  if (!clientWidth && !clientHeight) {
    return emptyRect;
  }
  var styles = getWindowOf(target).getComputedStyle(target);
  var paddings = getPaddings(styles);
  var horizPad = paddings.left + paddings.right;
  var vertPad = paddings.top + paddings.bottom;
  // Computed styles of width & height are being used because they are the
  // only dimensions available to JS that contain non-rounded values. It could
  // be possible to utilize the getBoundingClientRect if only it's data wasn't
  // affected by CSS transformations let alone paddings, borders and scroll bars.
  var width = toFloat(styles.width),
    height = toFloat(styles.height);
  // Width & height include paddings and borders when the 'border-box' box
  // model is applied (except for IE).
  if (styles.boxSizing === 'border-box') {
    // Following conditions are required to handle Internet Explorer which
    // doesn't include paddings and borders to computed CSS dimensions.
    //
    // We can say that if CSS dimensions + paddings are equal to the "client"
    // properties then it's either IE, and thus we don't need to subtract
    // anything, or an element merely doesn't have paddings/borders styles.
    if (Math.round(width + horizPad) !== clientWidth) {
      width -= getBordersSize(styles, 'left', 'right') + horizPad;
    }
    if (Math.round(height + vertPad) !== clientHeight) {
      height -= getBordersSize(styles, 'top', 'bottom') + vertPad;
    }
  }
  // Following steps can't be applied to the document's root element as its
  // client[Width/Height] properties represent viewport area of the window.
  // Besides, it's as well not necessary as the <html> itself neither has
  // rendered scroll bars nor it can be clipped.
  if (!isDocumentElement(target)) {
    // In some browsers (only in Firefox, actually) CSS width & height
    // include scroll bars size which can be removed at this step as scroll
    // bars are the only difference between rounded dimensions + paddings
    // and "client" properties, though that is not always true in Chrome.
    var vertScrollbar = Math.round(width + horizPad) - clientWidth;
    var horizScrollbar = Math.round(height + vertPad) - clientHeight;
    // Chrome has a rather weird rounding of "client" properties.
    // E.g. for an element with content width of 314.2px it sometimes gives
    // the client width of 315px and for the width of 314.7px it may give
    // 314px. And it doesn't happen all the time. So just ignore this delta
    // as a non-relevant.
    if (Math.abs(vertScrollbar) !== 1) {
      width -= vertScrollbar;
    }
    if (Math.abs(horizScrollbar) !== 1) {
      height -= horizScrollbar;
    }
  }
  return createRectInit(paddings.left, paddings.top, width, height);
}
/**
 * Checks whether provided element is an instance of the SVGGraphicsElement.
 *
 * @param {Element} target - Element to be checked.
 * @returns {boolean}
 */
var isSVGGraphicsElement = function () {
  // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement
  // interface.
  if (typeof SVGGraphicsElement !== 'undefined') {
    return function (target) {
      return target instanceof getWindowOf(target).SVGGraphicsElement;
    };
  }
  // If it's so, then check that element is at least an instance of the
  // SVGElement and that it has the "getBBox" method.
  // eslint-disable-next-line no-extra-parens
  return function (target) {
    return target instanceof getWindowOf(target).SVGElement && typeof target.getBBox === 'function';
  };
}();
/**
 * Checks whether provided element is a document element (<html>).
 *
 * @param {Element} target - Element to be checked.
 * @returns {boolean}
 */
function isDocumentElement(target) {
  return target === getWindowOf(target).document.documentElement;
}
/**
 * Calculates an appropriate content rectangle for provided html or svg element.
 *
 * @param {Element} target - Element content rectangle of which needs to be calculated.
 * @returns {DOMRectInit}
 */
function getContentRect(target) {
  if (!isBrowser) {
    return emptyRect;
  }
  if (isSVGGraphicsElement(target)) {
    return getSVGContentRect(target);
  }
  return getHTMLElementContentRect(target);
}
/**
 * Creates rectangle with an interface of the DOMRectReadOnly.
 * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly
 *
 * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.
 * @returns {DOMRectReadOnly}
 */
function createReadOnlyRect(_a) {
  var x = _a.x,
    y = _a.y,
    width = _a.width,
    height = _a.height;
  // If DOMRectReadOnly is available use it as a prototype for the rectangle.
  var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;
  var rect = Object.create(Constr.prototype);
  // Rectangle's properties are not writable and non-enumerable.
  defineConfigurable(rect, {
    x: x,
    y: y,
    width: width,
    height: height,
    top: y,
    right: x + width,
    bottom: height + y,
    left: x
  });
  return rect;
}
/**
 * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.
 * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit
 *
 * @param {number} x - X coordinate.
 * @param {number} y - Y coordinate.
 * @param {number} width - Rectangle's width.
 * @param {number} height - Rectangle's height.
 * @returns {DOMRectInit}
 */
function createRectInit(x, y, width, height) {
  return {
    x: x,
    y: y,
    width: width,
    height: height
  };
}

/**
 * Class that is responsible for computations of the content rectangle of
 * provided DOM element and for keeping track of it's changes.
 */
var ResizeObservation = /** @class */function () {
  /**
   * Creates an instance of ResizeObservation.
   *
   * @param {Element} target - Element to be observed.
   */
  function ResizeObservation(target) {
    /**
     * Broadcasted width of content rectangle.
     *
     * @type {number}
     */
    this.broadcastWidth = 0;
    /**
     * Broadcasted height of content rectangle.
     *
     * @type {number}
     */
    this.broadcastHeight = 0;
    /**
     * Reference to the last observed content rectangle.
     *
     * @private {DOMRectInit}
     */
    this.contentRect_ = createRectInit(0, 0, 0, 0);
    this.target = target;
  }
  /**
   * Updates content rectangle and tells whether it's width or height properties
   * have changed since the last broadcast.
   *
   * @returns {boolean}
   */
  ResizeObservation.prototype.isActive = function () {
    var rect = getContentRect(this.target);
    this.contentRect_ = rect;
    return rect.width !== this.broadcastWidth || rect.height !== this.broadcastHeight;
  };
  /**
   * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data
   * from the corresponding properties of the last observed content rectangle.
   *
   * @returns {DOMRectInit} Last observed content rectangle.
   */
  ResizeObservation.prototype.broadcastRect = function () {
    var rect = this.contentRect_;
    this.broadcastWidth = rect.width;
    this.broadcastHeight = rect.height;
    return rect;
  };
  return ResizeObservation;
}();
var ResizeObserverEntry = /** @class */function () {
  /**
   * Creates an instance of ResizeObserverEntry.
   *
   * @param {Element} target - Element that is being observed.
   * @param {DOMRectInit} rectInit - Data of the element's content rectangle.
   */
  function ResizeObserverEntry(target, rectInit) {
    var contentRect = createReadOnlyRect(rectInit);
    // According to the specification following properties are not writable
    // and are also not enumerable in the native implementation.
    //
    // Property accessors are not being used as they'd require to define a
    // private WeakMap storage which may cause memory leaks in browsers that
    // don't support this type of collections.
    defineConfigurable(this, {
      target: target,
      contentRect: contentRect
    });
  }
  return ResizeObserverEntry;
}();
var ResizeObserverSPI = /** @class */function () {
  /**
   * Creates a new instance of ResizeObserver.
   *
   * @param {ResizeObserverCallback} callback - Callback function that is invoked
   *      when one of the observed elements changes it's content dimensions.
   * @param {ResizeObserverController} controller - Controller instance which
   *      is responsible for the updates of observer.
   * @param {ResizeObserver} callbackCtx - Reference to the public
   *      ResizeObserver instance which will be passed to callback function.
   */
  function ResizeObserverSPI(callback, controller, callbackCtx) {
    /**
     * Collection of resize observations that have detected changes in dimensions
     * of elements.
     *
     * @private {Array<ResizeObservation>}
     */
    this.activeObservations_ = [];
    /**
     * Registry of the ResizeObservation instances.
     *
     * @private {Map<Element, ResizeObservation>}
     */
    this.observations_ = new MapShim();
    if (typeof callback !== 'function') {
      throw new TypeError('The callback provided as parameter 1 is not a function.');
    }
    this.callback_ = callback;
    this.controller_ = controller;
    this.callbackCtx_ = callbackCtx;
  }
  /**
   * Starts observing provided element.
   *
   * @param {Element} target - Element to be observed.
   * @returns {void}
   */
  ResizeObserverSPI.prototype.observe = function (target) {
    if (!arguments.length) {
      throw new TypeError('1 argument required, but only 0 present.');
    }
    // Do nothing if current environment doesn't have the Element interface.
    if (typeof Element === 'undefined' || !(Element instanceof Object)) {
      return;
    }
    if (!(target instanceof getWindowOf(target).Element)) {
      throw new TypeError('parameter 1 is not of type "Element".');
    }
    var observations = this.observations_;
    // Do nothing if element is already being observed.
    if (observations.has(target)) {
      return;
    }
    observations.set(target, new ResizeObservation(target));
    this.controller_.addObserver(this);
    // Force the update of observations.
    this.controller_.refresh();
  };
  /**
   * Stops observing provided element.
   *
   * @param {Element} target - Element to stop observing.
   * @returns {void}
   */
  ResizeObserverSPI.prototype.unobserve = function (target) {
    if (!arguments.length) {
      throw new TypeError('1 argument required, but only 0 present.');
    }
    // Do nothing if current environment doesn't have the Element interface.
    if (typeof Element === 'undefined' || !(Element instanceof Object)) {
      return;
    }
    if (!(target instanceof getWindowOf(target).Element)) {
      throw new TypeError('parameter 1 is not of type "Element".');
    }
    var observations = this.observations_;
    // Do nothing if element is not being observed.
    if (!observations.has(target)) {
      return;
    }
    observations.delete(target);
    if (!observations.size) {
      this.controller_.removeObserver(this);
    }
  };
  /**
   * Stops observing all elements.
   *
   * @returns {void}
   */
  ResizeObserverSPI.prototype.disconnect = function () {
    this.clearActive();
    this.observations_.clear();
    this.controller_.removeObserver(this);
  };
  /**
   * Collects observation instances the associated element of which has changed
   * it's content rectangle.
   *
   * @returns {void}
   */
  ResizeObserverSPI.prototype.gatherActive = function () {
    var _this = this;
    this.clearActive();
    this.observations_.forEach(function (observation) {
      if (observation.isActive()) {
        _this.activeObservations_.push(observation);
      }
    });
  };
  /**
   * Invokes initial callback function with a list of ResizeObserverEntry
   * instances collected from active resize observations.
   *
   * @returns {void}
   */
  ResizeObserverSPI.prototype.broadcastActive = function () {
    // Do nothing if observer doesn't have active observations.
    if (!this.hasActive()) {
      return;
    }
    var ctx = this.callbackCtx_;
    // Create ResizeObserverEntry instance for every active observation.
    var entries = this.activeObservations_.map(function (observation) {
      return new ResizeObserverEntry(observation.target, observation.broadcastRect());
    });
    this.callback_.call(ctx, entries, ctx);
    this.clearActive();
  };
  /**
   * Clears the collection of active observations.
   *
   * @returns {void}
   */
  ResizeObserverSPI.prototype.clearActive = function () {
    this.activeObservations_.splice(0);
  };
  /**
   * Tells whether observer has active observations.
   *
   * @returns {boolean}
   */
  ResizeObserverSPI.prototype.hasActive = function () {
    return this.activeObservations_.length > 0;
  };
  return ResizeObserverSPI;
}();

// Registry of internal observers. If WeakMap is not available use current shim
// for the Map collection as it has all required methods and because WeakMap
// can't be fully polyfilled anyway.
var observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();
/**
 * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation
 * exposing only those methods and properties that are defined in the spec.
 */
var ResizeObserver = /** @class */function () {
  /**
   * Creates a new instance of ResizeObserver.
   *
   * @param {ResizeObserverCallback} callback - Callback that is invoked when
   *      dimensions of the observed elements change.
   */
  function ResizeObserver(callback) {
    if (!(this instanceof ResizeObserver)) {
      throw new TypeError('Cannot call a class as a function.');
    }
    if (!arguments.length) {
      throw new TypeError('1 argument required, but only 0 present.');
    }
    var controller = ResizeObserverController.getInstance();
    var observer = new ResizeObserverSPI(callback, controller, this);
    observers.set(this, observer);
  }
  return ResizeObserver;
}();
// Expose public methods of ResizeObserver.
['observe', 'unobserve', 'disconnect'].forEach(function (method) {
  ResizeObserver.prototype[method] = function () {
    var _a;
    return (_a = observers.get(this))[method].apply(_a, arguments);
  };
});
var ResizeObserver_es_index = function () {
  // Export existing implementation if available.
  if (typeof global$1.ResizeObserver !== 'undefined') {
    return global$1.ResizeObserver;
  }
  return ResizeObserver;
}();
/* harmony default export */ var ResizeObserver_es = (ResizeObserver_es_index);
;// CONCATENATED MODULE: ./node_modules/_rc-align@4.0.15@rc-align/es/util.js



function isSamePoint(prev, next) {
  if (prev === next) return true;
  if (!prev || !next) return false;
  if ('pageX' in next && 'pageY' in next) {
    return prev.pageX === next.pageX && prev.pageY === next.pageY;
  }
  if ('clientX' in next && 'clientY' in next) {
    return prev.clientX === next.clientX && prev.clientY === next.clientY;
  }
  return false;
}
function restoreFocus(activeElement, container) {
  // Focus back if is in the container
  if (activeElement !== document.activeElement && contains(container, activeElement) && typeof activeElement.focus === 'function') {
    activeElement.focus();
  }
}
function monitorResize(element, callback) {
  var prevWidth = null;
  var prevHeight = null;
  function onResize(_ref) {
    var _ref2 = slicedToArray_slicedToArray(_ref, 1),
      target = _ref2[0].target;
    if (!document.documentElement.contains(target)) return;
    var _target$getBoundingCl = target.getBoundingClientRect(),
      width = _target$getBoundingCl.width,
      height = _target$getBoundingCl.height;
    var fixedWidth = Math.floor(width);
    var fixedHeight = Math.floor(height);
    if (prevWidth !== fixedWidth || prevHeight !== fixedHeight) {
      // https://webkit.org/blog/9997/resizeobserver-in-webkit/
      Promise.resolve().then(function () {
        callback({
          width: fixedWidth,
          height: fixedHeight
        });
      });
    }
    prevWidth = fixedWidth;
    prevHeight = fixedHeight;
  }
  var resizeObserver = new ResizeObserver_es(onResize);
  if (element) {
    resizeObserver.observe(element);
  }
  return function () {
    resizeObserver.disconnect();
  };
}
;// CONCATENATED MODULE: ./node_modules/_rc-align@4.0.15@rc-align/es/Align.js



/**
 * Removed props:
 *  - childrenProps
 */









function getElement(func) {
  if (typeof func !== 'function') return null;
  return func();
}
function getPoint(point) {
  if (_typeof(point) !== 'object' || !point) return null;
  return point;
}
var Align = function Align(_ref, ref) {
  var children = _ref.children,
    disabled = _ref.disabled,
    target = _ref.target,
    align = _ref.align,
    onAlign = _ref.onAlign,
    monitorWindowResize = _ref.monitorWindowResize,
    _ref$monitorBufferTim = _ref.monitorBufferTime,
    monitorBufferTime = _ref$monitorBufferTim === void 0 ? 0 : _ref$monitorBufferTim;
  var cacheRef = _react_18_2_0_react.useRef({});
  /** Popup node ref */

  var nodeRef = _react_18_2_0_react.useRef();
  var childNode = _react_18_2_0_react.Children.only(children); // ===================== Align ======================
  // We save the props here to avoid closure makes props ood

  var forceAlignPropsRef = _react_18_2_0_react.useRef({});
  forceAlignPropsRef.current.disabled = disabled;
  forceAlignPropsRef.current.target = target;
  forceAlignPropsRef.current.align = align;
  forceAlignPropsRef.current.onAlign = onAlign;
  var _useBuffer = useBuffer(function () {
      var _forceAlignPropsRef$c = forceAlignPropsRef.current,
        latestDisabled = _forceAlignPropsRef$c.disabled,
        latestTarget = _forceAlignPropsRef$c.target,
        latestAlign = _forceAlignPropsRef$c.align,
        latestOnAlign = _forceAlignPropsRef$c.onAlign;
      var source = nodeRef.current;
      if (!latestDisabled && latestTarget && source) {
        var _result;
        var _element = getElement(latestTarget);
        var _point = getPoint(latestTarget);
        cacheRef.current.element = _element;
        cacheRef.current.point = _point;
        cacheRef.current.align = latestAlign; // IE lose focus after element realign
        // We should record activeElement and restore later

        var _document = document,
          activeElement = _document.activeElement; // We only align when element is visible

        if (_element && isVisible(_element)) {
          _result = alignElement(source, _element, latestAlign);
        } else if (_point) {
          _result = alignPoint(source, _point, latestAlign);
        }
        restoreFocus(activeElement, source);
        if (latestOnAlign && _result) {
          latestOnAlign(source, _result);
        }
        return true;
      }
      return false;
    }, monitorBufferTime),
    _useBuffer2 = slicedToArray_slicedToArray(_useBuffer, 2),
    _forceAlign = _useBuffer2[0],
    cancelForceAlign = _useBuffer2[1]; // ===================== Effect =====================
  // Handle props change

  var _React$useState = _react_18_2_0_react.useState(),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 2),
    element = _React$useState2[0],
    setElement = _React$useState2[1];
  var _React$useState3 = _react_18_2_0_react.useState(),
    _React$useState4 = slicedToArray_slicedToArray(_React$useState3, 2),
    point = _React$useState4[0],
    setPoint = _React$useState4[1];
  hooks_useLayoutEffect(function () {
    setElement(getElement(target));
    setPoint(getPoint(target));
  });
  _react_18_2_0_react.useEffect(function () {
    if (cacheRef.current.element !== element || !isSamePoint(cacheRef.current.point, point) || !es_isEqual(cacheRef.current.align, align)) {
      _forceAlign();
    }
  }); // Watch popup element resize

  _react_18_2_0_react.useEffect(function () {
    var cancelFn = monitorResize(nodeRef.current, _forceAlign);
    return cancelFn;
  }, [nodeRef.current]); // Watch target element resize

  _react_18_2_0_react.useEffect(function () {
    var cancelFn = monitorResize(element, _forceAlign);
    return cancelFn;
  }, [element]); // Listen for disabled change

  _react_18_2_0_react.useEffect(function () {
    if (!disabled) {
      _forceAlign();
    } else {
      cancelForceAlign();
    }
  }, [disabled]); // Listen for window resize

  _react_18_2_0_react.useEffect(function () {
    if (monitorWindowResize) {
      var cancelFn = addEventListenerWrap(window, 'resize', _forceAlign);
      return cancelFn.remove;
    }
  }, [monitorWindowResize]); // Clear all if unmount

  _react_18_2_0_react.useEffect(function () {
    return function () {
      cancelForceAlign();
    };
  }, []); // ====================== Ref =======================

  _react_18_2_0_react.useImperativeHandle(ref, function () {
    return {
      forceAlign: function forceAlign() {
        return _forceAlign(true);
      }
    };
  }); // ===================== Render =====================

  if ( /*#__PURE__*/_react_18_2_0_react.isValidElement(childNode)) {
    childNode = /*#__PURE__*/_react_18_2_0_react.cloneElement(childNode, {
      ref: composeRef(childNode.ref, nodeRef)
    });
  }
  return childNode;
};
var RcAlign = /*#__PURE__*/_react_18_2_0_react.forwardRef(Align);
RcAlign.displayName = 'Align';
/* harmony default export */ var es_Align = (RcAlign);
;// CONCATENATED MODULE: ./node_modules/_rc-align@4.0.15@rc-align/es/index.js
// export this package's api

/* harmony default export */ var _rc_align_4_0_15_rc_align_es = (es_Align);
;// CONCATENATED MODULE: ./node_modules/_rc-trigger@5.3.4@rc-trigger/es/Popup/useVisibleStatus.js






/**
 * Popup should follow the steps for each component work correctly:
 * measure - check for the current stretch size
 * align - let component align the position
 * aligned - re-align again in case additional className changed the size
 * afterAlign - choice next step is trigger motion or finished
 * beforeMotion - should reset motion to invisible so that CSSMotion can do normal motion
 * motion - play the motion
 * stable - everything is done
 */

var StatusQueue = ['measure', 'alignPre', 'align', null, 'motion'];
/* harmony default export */ var useVisibleStatus = (function (visible, doMeasure) {
  var _useState = useSafeState(null),
    _useState2 = slicedToArray_slicedToArray(_useState, 2),
    status = _useState2[0],
    setInternalStatus = _useState2[1];
  var rafRef = (0,_react_18_2_0_react.useRef)();
  function setStatus(nextStatus) {
    setInternalStatus(nextStatus, true);
  }
  function cancelRaf() {
    es_raf.cancel(rafRef.current);
  }
  function goNextStatus(callback) {
    cancelRaf();
    rafRef.current = es_raf(function () {
      // Only align should be manually trigger
      setStatus(function (prev) {
        switch (status) {
          case 'align':
            return 'motion';
          case 'motion':
            return 'stable';
          default:
        }
        return prev;
      });
      callback === null || callback === void 0 ? void 0 : callback();
    });
  } // Init status

  (0,_react_18_2_0_react.useEffect)(function () {
    setStatus('measure');
  }, [visible]); // Go next status

  (0,_react_18_2_0_react.useEffect)(function () {
    switch (status) {
      case 'measure':
        doMeasure();
        break;
      default:
    }
    if (status) {
      rafRef.current = es_raf( /*#__PURE__*/asyncToGenerator_asyncToGenerator( /*#__PURE__*/regeneratorRuntime_regeneratorRuntime().mark(function _callee() {
        var index, nextStatus;
        return regeneratorRuntime_regeneratorRuntime().wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                index = StatusQueue.indexOf(status);
                nextStatus = StatusQueue[index + 1];
                if (nextStatus && index !== -1) {
                  setStatus(nextStatus);
                }
              case 3:
              case "end":
                return _context.stop();
            }
          }
        }, _callee);
      })));
    }
  }, [status]);
  (0,_react_18_2_0_react.useEffect)(function () {
    return function () {
      cancelRaf();
    };
  }, []);
  return [status, goNextStatus];
});
;// CONCATENATED MODULE: ./node_modules/_rc-trigger@5.3.4@rc-trigger/es/Popup/useStretchStyle.js


/* harmony default export */ var useStretchStyle = (function (stretch) {
  var _React$useState = _react_18_2_0_react.useState({
      width: 0,
      height: 0
    }),
    _React$useState2 = slicedToArray_slicedToArray(_React$useState, 2),
    targetSize = _React$useState2[0],
    setTargetSize = _React$useState2[1];
  function measureStretch(element) {
    var tgtWidth = element.offsetWidth,
      tgtHeight = element.offsetHeight;
    var _element$getBoundingC = element.getBoundingClientRect(),
      width = _element$getBoundingC.width,
      height = _element$getBoundingC.height; // Rect is more accurate than offset, use if near

    if (Math.abs(tgtWidth - width) < 1 && Math.abs(tgtHeight - height) < 1) {
      tgtWidth = width;
      tgtHeight = height;
    }
    setTargetSize({
      width: tgtWidth,
      height: tgtHeight
    });
  } // Merge stretch style

  var style = _react_18_2_0_react.useMemo(function () {
    var sizeStyle = {};
    if (stretch) {
      var width = targetSize.width,
        height = targetSize.height; // Stretch with target

      if (stretch.indexOf('height') !== -1 && height) {
        sizeStyle.height = height;
      } else if (stretch.indexOf('minHeight') !== -1 && height) {
        sizeStyle.minHeight = height;
      }
      if (stretch.indexOf('width') !== -1 && width) {
        sizeStyle.width = width;
      } else if (stretch.indexOf('minWidth') !== -1 && width) {
        sizeStyle.minWidth = width;
      }
    }
    return sizeStyle;
  }, [stretch, targetSize]);
  return [style, measureStretch];
});
;// CONCATENATED MODULE: ./node_modules/_rc-trigger@5.3.4@rc-trigger/es/Popup/PopupInner.js












var PopupInner = /*#__PURE__*/_react_18_2_0_react.forwardRef(function (props, ref) {
  var visible = props.visible,
    prefixCls = props.prefixCls,
    className = props.className,
    style = props.style,
    children = props.children,
    zIndex = props.zIndex,
    stretch = props.stretch,
    destroyPopupOnHide = props.destroyPopupOnHide,
    forceRender = props.forceRender,
    align = props.align,
    point = props.point,
    getRootDomNode = props.getRootDomNode,
    getClassNameFromAlign = props.getClassNameFromAlign,
    onAlign = props.onAlign,
    onMouseEnter = props.onMouseEnter,
    onMouseLeave = props.onMouseLeave,
    onMouseDown = props.onMouseDown,
    onTouchStart = props.onTouchStart,
    onClick = props.onClick;
  var alignRef = (0,_react_18_2_0_react.useRef)();
  var elementRef = (0,_react_18_2_0_react.useRef)();
  var _useState = (0,_react_18_2_0_react.useState)(),
    _useState2 = slicedToArray_slicedToArray(_useState, 2),
    alignedClassName = _useState2[0],
    setAlignedClassName = _useState2[1]; // ======================= Measure ========================

  var _useStretchStyle = useStretchStyle(stretch),
    _useStretchStyle2 = slicedToArray_slicedToArray(_useStretchStyle, 2),
    stretchStyle = _useStretchStyle2[0],
    measureStretchStyle = _useStretchStyle2[1];
  function doMeasure() {
    if (stretch) {
      measureStretchStyle(getRootDomNode());
    }
  } // ======================== Status ========================

  var _useVisibleStatus = useVisibleStatus(visible, doMeasure),
    _useVisibleStatus2 = slicedToArray_slicedToArray(_useVisibleStatus, 2),
    status = _useVisibleStatus2[0],
    goNextStatus = _useVisibleStatus2[1]; // ======================== Aligns ========================

  /**
   * `alignedClassName` may modify `source` size,
   * which means one time align may not move to the correct position at once.
   *
   * We will reset `alignTimes` for each status switch to `alignPre`
   * and let `rc-align` to align for multiple times to ensure get final stable place.
   * Currently we mark `alignTimes < 2` repeat align, it will increase if user report for align issue.
   * 
   * Update:
   * In React 18. `rc-align` effect of align may faster than ref called trigger `forceAlign`.
   * We adjust this to `alignTimes < 2`.
   * We need refactor `rc-align` to support mark of `forceAlign` call if this still happen.
   */

  var _useState3 = (0,_react_18_2_0_react.useState)(0),
    _useState4 = slicedToArray_slicedToArray(_useState3, 2),
    alignTimes = _useState4[0],
    setAlignTimes = _useState4[1];
  var prepareResolveRef = (0,_react_18_2_0_react.useRef)();
  hooks_useLayoutEffect(function () {
    if (status === 'alignPre') {
      setAlignTimes(0);
    }
  }, [status]); // `target` on `rc-align` can accept as a function to get the bind element or a point.
  // ref: https://www.npmjs.com/package/rc-align

  function getAlignTarget() {
    if (point) {
      return point;
    }
    return getRootDomNode;
  }
  function forceAlign() {
    var _alignRef$current;
    (_alignRef$current = alignRef.current) === null || _alignRef$current === void 0 ? void 0 : _alignRef$current.forceAlign();
  }
  function onInternalAlign(popupDomNode, matchAlign) {
    var nextAlignedClassName = getClassNameFromAlign(matchAlign);
    if (alignedClassName !== nextAlignedClassName) {
      setAlignedClassName(nextAlignedClassName);
    } // We will retry multi times to make sure that the element has been align in the right position.

    setAlignTimes(function (val) {
      return val + 1;
    });
    if (status === 'align') {
      onAlign === null || onAlign === void 0 ? void 0 : onAlign(popupDomNode, matchAlign);
    }
  } // Delay to go to next status

  hooks_useLayoutEffect(function () {
    if (status === 'align') {
      // Repeat until not more align needed
      if (alignTimes < 3) {
        forceAlign();
      } else {
        goNextStatus(function () {
          var _prepareResolveRef$cu;
          (_prepareResolveRef$cu = prepareResolveRef.current) === null || _prepareResolveRef$cu === void 0 ? void 0 : _prepareResolveRef$cu.call(prepareResolveRef);
        });
      }
    }
  }, [alignTimes]); // ======================== Motion ========================

  var motion = _objectSpread2({}, getMotion(props));
  ['onAppearEnd', 'onEnterEnd', 'onLeaveEnd'].forEach(function (eventName) {
    var originHandler = motion[eventName];
    motion[eventName] = function (element, event) {
      goNextStatus();
      return originHandler === null || originHandler === void 0 ? void 0 : originHandler(element, event);
    };
  });
  function onShowPrepare() {
    return new Promise(function (resolve) {
      prepareResolveRef.current = resolve;
    });
  } // Go to stable directly when motion not provided

  _react_18_2_0_react.useEffect(function () {
    if (!motion.motionName && status === 'motion') {
      goNextStatus();
    }
  }, [motion.motionName, status]); // ========================= Refs =========================

  _react_18_2_0_react.useImperativeHandle(ref, function () {
    return {
      forceAlign: forceAlign,
      getElement: function getElement() {
        return elementRef.current;
      }
    };
  }); // ======================== Render ========================

  var mergedStyle = _objectSpread2(_objectSpread2({}, stretchStyle), {}, {
    zIndex: zIndex,
    opacity: status === 'motion' || status === 'stable' || !visible ? undefined : 0,
    // Cannot interact with disappearing elements
    // https://github.com/ant-design/ant-design/issues/35051#issuecomment-1101340714
    pointerEvents: !visible && status !== 'stable' ? 'none' : undefined
  }, style); // Align status

  var alignDisabled = true;
  if (align !== null && align !== void 0 && align.points && (status === 'align' || status === 'stable')) {
    alignDisabled = false;
  }
  var childNode = children; // Wrapper when multiple children

  if (_react_18_2_0_react.Children.count(children) > 1) {
    childNode = /*#__PURE__*/_react_18_2_0_react.createElement("div", {
      className: "".concat(prefixCls, "-content")
    }, children);
  }
  return /*#__PURE__*/_react_18_2_0_react.createElement(_rc_motion_2_6_3_rc_motion_es, extends_extends({
    visible: visible,
    ref: elementRef,
    leavedClassName: "".concat(prefixCls, "-hidden")
  }, motion, {
    onAppearPrepare: onShowPrepare,
    onEnterPrepare: onShowPrepare,
    removeOnLeave: destroyPopupOnHide,
    forceRender: forceRender
  }), function (_ref, motionRef) {
    var motionClassName = _ref.className,
      motionStyle = _ref.style;
    var mergedClassName = _classnames_2_3_2_classnames_default()(prefixCls, className, alignedClassName, motionClassName);
    return /*#__PURE__*/_react_18_2_0_react.createElement(_rc_align_4_0_15_rc_align_es, {
      target: getAlignTarget(),
      key: "popup",
      ref: alignRef,
      monitorWindowResize: true,
      disabled: alignDisabled,
      align: align,
      onAlign: onInternalAlign
    }, /*#__PURE__*/_react_18_2_0_react.createElement("div", {
      ref: motionRef,
      className: mergedClassName,
      onMouseEnter: onMouseEnter,
      onMouseLeave: onMouseLeave,
      onMouseDownCapture: onMouseDown,
      onTouchStartCapture: onTouchStart,
      onClick: onClick,
      style: _objectSpread2(_objectSpread2({}, motionStyle), mergedStyle)
    }, childNode));
  });
});
PopupInner.displayName = 'PopupInner';
/* harmony default export */ var Popup_PopupInner = (PopupInner);
;// CONCATENATED MODULE: ./node_modules/_rc-trigger@5.3.4@rc-trigger/es/Popup/MobilePopupInner.js





var MobilePopupInner = /*#__PURE__*/_react_18_2_0_react.forwardRef(function (props, ref) {
  var prefixCls = props.prefixCls,
    visible = props.visible,
    zIndex = props.zIndex,
    children = props.children,
    _props$mobile = props.mobile;
  _props$mobile = _props$mobile === void 0 ? {} : _props$mobile;
  var popupClassName = _props$mobile.popupClassName,
    popupStyle = _props$mobile.popupStyle,
    _props$mobile$popupMo = _props$mobile.popupMotion,
    popupMotion = _props$mobile$popupMo === void 0 ? {} : _props$mobile$popupMo,
    popupRender = _props$mobile.popupRender,
    onClick = props.onClick;
  var elementRef = _react_18_2_0_react.useRef(); // ========================= Refs =========================

  _react_18_2_0_react.useImperativeHandle(ref, function () {
    return {
      forceAlign: function forceAlign() {},
      getElement: function getElement() {
        return elementRef.current;
      }
    };
  }); // ======================== Render ========================

  var mergedStyle = _objectSpread2({
    zIndex: zIndex
  }, popupStyle);
  var childNode = children; // Wrapper when multiple children

  if (_react_18_2_0_react.Children.count(children) > 1) {
    childNode = /*#__PURE__*/_react_18_2_0_react.createElement("div", {
      className: "".concat(prefixCls, "-content")
    }, children);
  } // Mobile support additional render

  if (popupRender) {
    childNode = popupRender(childNode);
  }
  return /*#__PURE__*/_react_18_2_0_react.createElement(_rc_motion_2_6_3_rc_motion_es, extends_extends({
    visible: visible,
    ref: elementRef,
    removeOnLeave: true
  }, popupMotion), function (_ref, motionRef) {
    var motionClassName = _ref.className,
      motionStyle = _ref.style;
    var mergedClassName = _classnames_2_3_2_classnames_default()(prefixCls, popupClassName, motionClassName);
    return /*#__PURE__*/_react_18_2_0_react.createElement("div", {
      ref: motionRef,
      className: mergedClassName,
      onClick: onClick,
      style: _objectSpread2(_objectSpread2({}, motionStyle), mergedStyle)
    }, childNode);
  });
});
MobilePopupInner.displayName = 'MobilePopupInner';
/* harmony default export */ var Popup_MobilePopupInner = (MobilePopupInner);
;// CONCATENATED MODULE: ./node_modules/_rc-trigger@5.3.4@rc-trigger/es/Popup/index.js




var Popup_excluded = ["visible", "mobile"];






var Popup_Popup = /*#__PURE__*/_react_18_2_0_react.forwardRef(function (_ref, ref) {
  var visible = _ref.visible,
    mobile = _ref.mobile,
    props = _objectWithoutProperties(_ref, Popup_excluded);
  var _useState = (0,_react_18_2_0_react.useState)(visible),
    _useState2 = slicedToArray_slicedToArray(_useState, 2),
    innerVisible = _useState2[0],
    serInnerVisible = _useState2[1];
  var _useState3 = (0,_react_18_2_0_react.useState)(false),
    _useState4 = slicedToArray_slicedToArray(_useState3, 2),
    inMobile = _useState4[0],
    setInMobile = _useState4[1];
  var cloneProps = _objectSpread2(_objectSpread2({}, props), {}, {
    visible: innerVisible
  }); // We check mobile in visible changed here.
  // And this also delay set `innerVisible` to avoid popup component render flash

  (0,_react_18_2_0_react.useEffect)(function () {
    serInnerVisible(visible);
    if (visible && mobile) {
      setInMobile(isMobile());
    }
  }, [visible, mobile]);
  var popupNode = inMobile ? /*#__PURE__*/_react_18_2_0_react.createElement(Popup_MobilePopupInner, extends_extends({}, cloneProps, {
    mobile: mobile,
    ref: ref
  })) : /*#__PURE__*/_react_18_2_0_react.createElement(Popup_PopupInner, extends_extends({}, cloneProps, {
    ref: ref
  })); // We can use fragment directly but this may failed some selector usage. Keep as origin logic

  return /*#__PURE__*/_react_18_2_0_react.createElement("div", null, /*#__PURE__*/_react_18_2_0_react.createElement(Mask_Mask, cloneProps), popupNode);
});
Popup_Popup.displayName = 'Popup';
/* harmony default export */ var es_Popup = (Popup_Popup);
;// CONCATENATED MODULE: ./node_modules/_rc-trigger@5.3.4@rc-trigger/es/context.js

var TriggerContext = /*#__PURE__*/_react_18_2_0_react.createContext(null);
/* harmony default export */ var es_context = (TriggerContext);
;// CONCATENATED MODULE: ./node_modules/_rc-trigger@5.3.4@rc-trigger/es/index.js




















function noop() {}
function returnEmptyString() {
  return '';
}
function returnDocument(element) {
  if (element) {
    return element.ownerDocument;
  }
  return window.document;
}
var ALL_HANDLERS = ['onClick', 'onMouseDown', 'onTouchStart', 'onMouseEnter', 'onMouseLeave', 'onFocus', 'onBlur', 'onContextMenu'];

/**
 * Internal usage. Do not use in your code since this will be removed.
 */
function generateTrigger(PortalComponent) {
  var Trigger = /*#__PURE__*/function (_React$Component) {
    _inherits(Trigger, _React$Component);
    var _super = _createSuper(Trigger);

    // ensure `getContainer` will be called only once
    function Trigger(props) {
      var _this;
      _classCallCheck(this, Trigger);
      _this = _super.call(this, props);
      defineProperty_defineProperty(_assertThisInitialized(_this), "popupRef", /*#__PURE__*/_react_18_2_0_react.createRef());
      defineProperty_defineProperty(_assertThisInitialized(_this), "triggerRef", /*#__PURE__*/_react_18_2_0_react.createRef());
      defineProperty_defineProperty(_assertThisInitialized(_this), "portalContainer", void 0);
      defineProperty_defineProperty(_assertThisInitialized(_this), "attachId", void 0);
      defineProperty_defineProperty(_assertThisInitialized(_this), "clickOutsideHandler", void 0);
      defineProperty_defineProperty(_assertThisInitialized(_this), "touchOutsideHandler", void 0);
      defineProperty_defineProperty(_assertThisInitialized(_this), "contextMenuOutsideHandler1", void 0);
      defineProperty_defineProperty(_assertThisInitialized(_this), "contextMenuOutsideHandler2", void 0);
      defineProperty_defineProperty(_assertThisInitialized(_this), "mouseDownTimeout", void 0);
      defineProperty_defineProperty(_assertThisInitialized(_this), "focusTime", void 0);
      defineProperty_defineProperty(_assertThisInitialized(_this), "preClickTime", void 0);
      defineProperty_defineProperty(_assertThisInitialized(_this), "preTouchTime", void 0);
      defineProperty_defineProperty(_assertThisInitialized(_this), "delayTimer", void 0);
      defineProperty_defineProperty(_assertThisInitialized(_this), "hasPopupMouseDown", void 0);
      defineProperty_defineProperty(_assertThisInitialized(_this), "onMouseEnter", function (e) {
        var mouseEnterDelay = _this.props.mouseEnterDelay;
        _this.fireEvents('onMouseEnter', e);
        _this.delaySetPopupVisible(true, mouseEnterDelay, mouseEnterDelay ? null : e);
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "onMouseMove", function (e) {
        _this.fireEvents('onMouseMove', e);
        _this.setPoint(e);
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "onMouseLeave", function (e) {
        _this.fireEvents('onMouseLeave', e);
        _this.delaySetPopupVisible(false, _this.props.mouseLeaveDelay);
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "onPopupMouseEnter", function () {
        _this.clearDelayTimer();
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "onPopupMouseLeave", function (e) {
        var _this$popupRef$curren;

        // https://github.com/react-component/trigger/pull/13
        // react bug?
        if (e.relatedTarget && !e.relatedTarget.setTimeout && contains((_this$popupRef$curren = _this.popupRef.current) === null || _this$popupRef$curren === void 0 ? void 0 : _this$popupRef$curren.getElement(), e.relatedTarget)) {
          return;
        }
        _this.delaySetPopupVisible(false, _this.props.mouseLeaveDelay);
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "onFocus", function (e) {
        _this.fireEvents('onFocus', e); // incase focusin and focusout

        _this.clearDelayTimer();
        if (_this.isFocusToShow()) {
          _this.focusTime = Date.now();
          _this.delaySetPopupVisible(true, _this.props.focusDelay);
        }
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "onMouseDown", function (e) {
        _this.fireEvents('onMouseDown', e);
        _this.preClickTime = Date.now();
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "onTouchStart", function (e) {
        _this.fireEvents('onTouchStart', e);
        _this.preTouchTime = Date.now();
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "onBlur", function (e) {
        _this.fireEvents('onBlur', e);
        _this.clearDelayTimer();
        if (_this.isBlurToHide()) {
          _this.delaySetPopupVisible(false, _this.props.blurDelay);
        }
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "onContextMenu", function (e) {
        e.preventDefault();
        _this.fireEvents('onContextMenu', e);
        _this.setPopupVisible(true, e);
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "onContextMenuClose", function () {
        if (_this.isContextMenuToShow()) {
          _this.close();
        }
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "onClick", function (event) {
        _this.fireEvents('onClick', event); // focus will trigger click

        if (_this.focusTime) {
          var preTime;
          if (_this.preClickTime && _this.preTouchTime) {
            preTime = Math.min(_this.preClickTime, _this.preTouchTime);
          } else if (_this.preClickTime) {
            preTime = _this.preClickTime;
          } else if (_this.preTouchTime) {
            preTime = _this.preTouchTime;
          }
          if (Math.abs(preTime - _this.focusTime) < 20) {
            return;
          }
          _this.focusTime = 0;
        }
        _this.preClickTime = 0;
        _this.preTouchTime = 0; // Only prevent default when all the action is click.
        // https://github.com/ant-design/ant-design/issues/17043
        // https://github.com/ant-design/ant-design/issues/17291

        if (_this.isClickToShow() && (_this.isClickToHide() || _this.isBlurToHide()) && event && event.preventDefault) {
          event.preventDefault();
        }
        var nextVisible = !_this.state.popupVisible;
        if (_this.isClickToHide() && !nextVisible || nextVisible && _this.isClickToShow()) {
          _this.setPopupVisible(!_this.state.popupVisible, event);
        }
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "onPopupMouseDown", function () {
        _this.hasPopupMouseDown = true;
        clearTimeout(_this.mouseDownTimeout);
        _this.mouseDownTimeout = window.setTimeout(function () {
          _this.hasPopupMouseDown = false;
        }, 0);
        if (_this.context) {
          var _this$context;
          (_this$context = _this.context).onPopupMouseDown.apply(_this$context, arguments);
        }
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "onDocumentClick", function (event) {
        if (_this.props.mask && !_this.props.maskClosable) {
          return;
        }
        var target = event.target;
        var root = _this.getRootDomNode();
        var popupNode = _this.getPopupDomNode();
        if (
        // mousedown on the target should also close popup when action is contextMenu.
        // https://github.com/ant-design/ant-design/issues/29853
        (!contains(root, target) || _this.isContextMenuOnly()) && !contains(popupNode, target) && !_this.hasPopupMouseDown) {
          _this.close();
        }
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "getRootDomNode", function () {
        var getTriggerDOMNode = _this.props.getTriggerDOMNode;
        if (getTriggerDOMNode) {
          return getTriggerDOMNode(_this.triggerRef.current);
        }
        try {
          var domNode = findDOMNode(_this.triggerRef.current);
          if (domNode) {
            return domNode;
          }
        } catch (err) {// Do nothing
        }
        return _react_dom_18_2_0_react_dom.findDOMNode(_assertThisInitialized(_this));
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "getPopupClassNameFromAlign", function (align) {
        var className = [];
        var _this$props = _this.props,
          popupPlacement = _this$props.popupPlacement,
          builtinPlacements = _this$props.builtinPlacements,
          prefixCls = _this$props.prefixCls,
          alignPoint = _this$props.alignPoint,
          getPopupClassNameFromAlign = _this$props.getPopupClassNameFromAlign;
        if (popupPlacement && builtinPlacements) {
          className.push(getAlignPopupClassName(builtinPlacements, prefixCls, align, alignPoint));
        }
        if (getPopupClassNameFromAlign) {
          className.push(getPopupClassNameFromAlign(align));
        }
        return className.join(' ');
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "getComponent", function () {
        var _this$props2 = _this.props,
          prefixCls = _this$props2.prefixCls,
          destroyPopupOnHide = _this$props2.destroyPopupOnHide,
          popupClassName = _this$props2.popupClassName,
          onPopupAlign = _this$props2.onPopupAlign,
          popupMotion = _this$props2.popupMotion,
          popupAnimation = _this$props2.popupAnimation,
          popupTransitionName = _this$props2.popupTransitionName,
          popupStyle = _this$props2.popupStyle,
          mask = _this$props2.mask,
          maskAnimation = _this$props2.maskAnimation,
          maskTransitionName = _this$props2.maskTransitionName,
          maskMotion = _this$props2.maskMotion,
          zIndex = _this$props2.zIndex,
          popup = _this$props2.popup,
          stretch = _this$props2.stretch,
          alignPoint = _this$props2.alignPoint,
          mobile = _this$props2.mobile,
          forceRender = _this$props2.forceRender,
          onPopupClick = _this$props2.onPopupClick;
        var _this$state = _this.state,
          popupVisible = _this$state.popupVisible,
          point = _this$state.point;
        var align = _this.getPopupAlign();
        var mouseProps = {};
        if (_this.isMouseEnterToShow()) {
          mouseProps.onMouseEnter = _this.onPopupMouseEnter;
        }
        if (_this.isMouseLeaveToHide()) {
          mouseProps.onMouseLeave = _this.onPopupMouseLeave;
        }
        mouseProps.onMouseDown = _this.onPopupMouseDown;
        mouseProps.onTouchStart = _this.onPopupMouseDown;
        return /*#__PURE__*/_react_18_2_0_react.createElement(es_Popup, extends_extends({
          prefixCls: prefixCls,
          destroyPopupOnHide: destroyPopupOnHide,
          visible: popupVisible,
          point: alignPoint && point,
          className: popupClassName,
          align: align,
          onAlign: onPopupAlign,
          animation: popupAnimation,
          getClassNameFromAlign: _this.getPopupClassNameFromAlign
        }, mouseProps, {
          stretch: stretch,
          getRootDomNode: _this.getRootDomNode,
          style: popupStyle,
          mask: mask,
          zIndex: zIndex,
          transitionName: popupTransitionName,
          maskAnimation: maskAnimation,
          maskTransitionName: maskTransitionName,
          maskMotion: maskMotion,
          ref: _this.popupRef,
          motion: popupMotion,
          mobile: mobile,
          forceRender: forceRender,
          onClick: onPopupClick
        }), typeof popup === 'function' ? popup() : popup);
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "attachParent", function (popupContainer) {
        es_raf.cancel(_this.attachId);
        var _this$props3 = _this.props,
          getPopupContainer = _this$props3.getPopupContainer,
          getDocument = _this$props3.getDocument;
        var domNode = _this.getRootDomNode();
        var mountNode;
        if (!getPopupContainer) {
          mountNode = getDocument(_this.getRootDomNode()).body;
        } else if (domNode || getPopupContainer.length === 0) {
          // Compatible for legacy getPopupContainer with domNode argument.
          // If no need `domNode` argument, will call directly.
          // https://codesandbox.io/s/eloquent-mclean-ss93m?file=/src/App.js
          mountNode = getPopupContainer(domNode);
        }
        if (mountNode) {
          mountNode.appendChild(popupContainer);
        } else {
          // Retry after frame render in case parent not ready
          _this.attachId = es_raf(function () {
            _this.attachParent(popupContainer);
          });
        }
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "getContainer", function () {
        if (!_this.portalContainer) {
          // In React.StrictMode component will call render multiple time in first mount.
          // When you want to refactor with FC, useRef will also init multiple time and
          // point to different useRef instance which will create multiple element
          // (This multiple render will not trigger effect so you can not clean up this
          // in effect). But this is safe with class component since it always point to same class instance.
          var getDocument = _this.props.getDocument;
          var popupContainer = getDocument(_this.getRootDomNode()).createElement('div'); // Make sure default popup container will never cause scrollbar appearing
          // https://github.com/react-component/trigger/issues/41

          popupContainer.style.position = 'absolute';
          popupContainer.style.top = '0';
          popupContainer.style.left = '0';
          popupContainer.style.width = '100%';
          _this.portalContainer = popupContainer;
        }
        _this.attachParent(_this.portalContainer);
        return _this.portalContainer;
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "setPoint", function (point) {
        var alignPoint = _this.props.alignPoint;
        if (!alignPoint || !point) return;
        _this.setState({
          point: {
            pageX: point.pageX,
            pageY: point.pageY
          }
        });
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "handlePortalUpdate", function () {
        if (_this.state.prevPopupVisible !== _this.state.popupVisible) {
          _this.props.afterPopupVisibleChange(_this.state.popupVisible);
        }
      });
      defineProperty_defineProperty(_assertThisInitialized(_this), "triggerContextValue", {
        onPopupMouseDown: _this.onPopupMouseDown
      });
      var _popupVisible;
      if ('popupVisible' in props) {
        _popupVisible = !!props.popupVisible;
      } else {
        _popupVisible = !!props.defaultPopupVisible;
      }
      _this.state = {
        prevPopupVisible: _popupVisible,
        popupVisible: _popupVisible
      };
      ALL_HANDLERS.forEach(function (h) {
        _this["fire".concat(h)] = function (e) {
          _this.fireEvents(h, e);
        };
      });
      return _this;
    }
    _createClass(Trigger, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.componentDidUpdate();
      }
    }, {
      key: "componentDidUpdate",
      value: function componentDidUpdate() {
        var props = this.props;
        var state = this.state; // We must listen to `mousedown` or `touchstart`, edge case:
        // https://github.com/ant-design/ant-design/issues/5804
        // https://github.com/react-component/calendar/issues/250
        // https://github.com/react-component/trigger/issues/50

        if (state.popupVisible) {
          var currentDocument;
          if (!this.clickOutsideHandler && (this.isClickToHide() || this.isContextMenuToShow())) {
            currentDocument = props.getDocument(this.getRootDomNode());
            this.clickOutsideHandler = addEventListenerWrap(currentDocument, 'mousedown', this.onDocumentClick);
          } // always hide on mobile

          if (!this.touchOutsideHandler) {
            currentDocument = currentDocument || props.getDocument(this.getRootDomNode());
            this.touchOutsideHandler = addEventListenerWrap(currentDocument, 'touchstart', this.onDocumentClick);
          } // close popup when trigger type contains 'onContextMenu' and document is scrolling.

          if (!this.contextMenuOutsideHandler1 && this.isContextMenuToShow()) {
            currentDocument = currentDocument || props.getDocument(this.getRootDomNode());
            this.contextMenuOutsideHandler1 = addEventListenerWrap(currentDocument, 'scroll', this.onContextMenuClose);
          } // close popup when trigger type contains 'onContextMenu' and window is blur.

          if (!this.contextMenuOutsideHandler2 && this.isContextMenuToShow()) {
            this.contextMenuOutsideHandler2 = addEventListenerWrap(window, 'blur', this.onContextMenuClose);
          }
          return;
        }
        this.clearOutsideHandler();
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        this.clearDelayTimer();
        this.clearOutsideHandler();
        clearTimeout(this.mouseDownTimeout);
        es_raf.cancel(this.attachId);
      }
    }, {
      key: "getPopupDomNode",
      value: function getPopupDomNode() {
        var _this$popupRef$curren2;

        // for test
        return ((_this$popupRef$curren2 = this.popupRef.current) === null || _this$popupRef$curren2 === void 0 ? void 0 : _this$popupRef$curren2.getElement()) || null;
      }
    }, {
      key: "getPopupAlign",
      value: function getPopupAlign() {
        var props = this.props;
        var popupPlacement = props.popupPlacement,
          popupAlign = props.popupAlign,
          builtinPlacements = props.builtinPlacements;
        if (popupPlacement && builtinPlacements) {
          return getAlignFromPlacement(builtinPlacements, popupPlacement, popupAlign);
        }
        return popupAlign;
      }
    }, {
      key: "setPopupVisible",
      value:
      /**
       * @param popupVisible    Show or not the popup element
       * @param event           SyntheticEvent, used for `pointAlign`
       */
      function setPopupVisible(popupVisible, event) {
        var alignPoint = this.props.alignPoint;
        var prevPopupVisible = this.state.popupVisible;
        this.clearDelayTimer();
        if (prevPopupVisible !== popupVisible) {
          if (!('popupVisible' in this.props)) {
            this.setState({
              popupVisible: popupVisible,
              prevPopupVisible: prevPopupVisible
            });
          }
          this.props.onPopupVisibleChange(popupVisible);
        } // Always record the point position since mouseEnterDelay will delay the show

        if (alignPoint && event && popupVisible) {
          this.setPoint(event);
        }
      }
    }, {
      key: "delaySetPopupVisible",
      value: function delaySetPopupVisible(visible, delayS, event) {
        var _this2 = this;
        var delay = delayS * 1000;
        this.clearDelayTimer();
        if (delay) {
          var point = event ? {
            pageX: event.pageX,
            pageY: event.pageY
          } : null;
          this.delayTimer = window.setTimeout(function () {
            _this2.setPopupVisible(visible, point);
            _this2.clearDelayTimer();
          }, delay);
        } else {
          this.setPopupVisible(visible, event);
        }
      }
    }, {
      key: "clearDelayTimer",
      value: function clearDelayTimer() {
        if (this.delayTimer) {
          clearTimeout(this.delayTimer);
          this.delayTimer = null;
        }
      }
    }, {
      key: "clearOutsideHandler",
      value: function clearOutsideHandler() {
        if (this.clickOutsideHandler) {
          this.clickOutsideHandler.remove();
          this.clickOutsideHandler = null;
        }
        if (this.contextMenuOutsideHandler1) {
          this.contextMenuOutsideHandler1.remove();
          this.contextMenuOutsideHandler1 = null;
        }
        if (this.contextMenuOutsideHandler2) {
          this.contextMenuOutsideHandler2.remove();
          this.contextMenuOutsideHandler2 = null;
        }
        if (this.touchOutsideHandler) {
          this.touchOutsideHandler.remove();
          this.touchOutsideHandler = null;
        }
      }
    }, {
      key: "createTwoChains",
      value: function createTwoChains(event) {
        var childPros = this.props.children.props;
        var props = this.props;
        if (childPros[event] && props[event]) {
          return this["fire".concat(event)];
        }
        return childPros[event] || props[event];
      }
    }, {
      key: "isClickToShow",
      value: function isClickToShow() {
        var _this$props4 = this.props,
          action = _this$props4.action,
          showAction = _this$props4.showAction;
        return action.indexOf('click') !== -1 || showAction.indexOf('click') !== -1;
      }
    }, {
      key: "isContextMenuOnly",
      value: function isContextMenuOnly() {
        var action = this.props.action;
        return action === 'contextMenu' || action.length === 1 && action[0] === 'contextMenu';
      }
    }, {
      key: "isContextMenuToShow",
      value: function isContextMenuToShow() {
        var _this$props5 = this.props,
          action = _this$props5.action,
          showAction = _this$props5.showAction;
        return action.indexOf('contextMenu') !== -1 || showAction.indexOf('contextMenu') !== -1;
      }
    }, {
      key: "isClickToHide",
      value: function isClickToHide() {
        var _this$props6 = this.props,
          action = _this$props6.action,
          hideAction = _this$props6.hideAction;
        return action.indexOf('click') !== -1 || hideAction.indexOf('click') !== -1;
      }
    }, {
      key: "isMouseEnterToShow",
      value: function isMouseEnterToShow() {
        var _this$props7 = this.props,
          action = _this$props7.action,
          showAction = _this$props7.showAction;
        return action.indexOf('hover') !== -1 || showAction.indexOf('mouseEnter') !== -1;
      }
    }, {
      key: "isMouseLeaveToHide",
      value: function isMouseLeaveToHide() {
        var _this$props8 = this.props,
          action = _this$props8.action,
          hideAction = _this$props8.hideAction;
        return action.indexOf('hover') !== -1 || hideAction.indexOf('mouseLeave') !== -1;
      }
    }, {
      key: "isFocusToShow",
      value: function isFocusToShow() {
        var _this$props9 = this.props,
          action = _this$props9.action,
          showAction = _this$props9.showAction;
        return action.indexOf('focus') !== -1 || showAction.indexOf('focus') !== -1;
      }
    }, {
      key: "isBlurToHide",
      value: function isBlurToHide() {
        var _this$props10 = this.props,
          action = _this$props10.action,
          hideAction = _this$props10.hideAction;
        return action.indexOf('focus') !== -1 || hideAction.indexOf('blur') !== -1;
      }
    }, {
      key: "forcePopupAlign",
      value: function forcePopupAlign() {
        if (this.state.popupVisible) {
          var _this$popupRef$curren3;
          (_this$popupRef$curren3 = this.popupRef.current) === null || _this$popupRef$curren3 === void 0 ? void 0 : _this$popupRef$curren3.forceAlign();
        }
      }
    }, {
      key: "fireEvents",
      value: function fireEvents(type, e) {
        var childCallback = this.props.children.props[type];
        if (childCallback) {
          childCallback(e);
        }
        var callback = this.props[type];
        if (callback) {
          callback(e);
        }
      }
    }, {
      key: "close",
      value: function close() {
        this.setPopupVisible(false);
      }
    }, {
      key: "render",
      value: function render() {
        var popupVisible = this.state.popupVisible;
        var _this$props11 = this.props,
          children = _this$props11.children,
          forceRender = _this$props11.forceRender,
          alignPoint = _this$props11.alignPoint,
          className = _this$props11.className,
          autoDestroy = _this$props11.autoDestroy;
        var child = _react_18_2_0_react.Children.only(children);
        var newChildProps = {
          key: 'trigger'
        }; // ============================== Visible Handlers ==============================
        // >>> ContextMenu

        if (this.isContextMenuToShow()) {
          newChildProps.onContextMenu = this.onContextMenu;
        } else {
          newChildProps.onContextMenu = this.createTwoChains('onContextMenu');
        } // >>> Click

        if (this.isClickToHide() || this.isClickToShow()) {
          newChildProps.onClick = this.onClick;
          newChildProps.onMouseDown = this.onMouseDown;
          newChildProps.onTouchStart = this.onTouchStart;
        } else {
          newChildProps.onClick = this.createTwoChains('onClick');
          newChildProps.onMouseDown = this.createTwoChains('onMouseDown');
          newChildProps.onTouchStart = this.createTwoChains('onTouchStart');
        } // >>> Hover(enter)

        if (this.isMouseEnterToShow()) {
          newChildProps.onMouseEnter = this.onMouseEnter; // Point align

          if (alignPoint) {
            newChildProps.onMouseMove = this.onMouseMove;
          }
        } else {
          newChildProps.onMouseEnter = this.createTwoChains('onMouseEnter');
        } // >>> Hover(leave)

        if (this.isMouseLeaveToHide()) {
          newChildProps.onMouseLeave = this.onMouseLeave;
        } else {
          newChildProps.onMouseLeave = this.createTwoChains('onMouseLeave');
        } // >>> Focus

        if (this.isFocusToShow() || this.isBlurToHide()) {
          newChildProps.onFocus = this.onFocus;
          newChildProps.onBlur = this.onBlur;
        } else {
          newChildProps.onFocus = this.createTwoChains('onFocus');
          newChildProps.onBlur = this.createTwoChains('onBlur');
        } // =================================== Render ===================================

        var childrenClassName = _classnames_2_3_2_classnames_default()(child && child.props && child.props.className, className);
        if (childrenClassName) {
          newChildProps.className = childrenClassName;
        }
        var cloneProps = _objectSpread2({}, newChildProps);
        if (supportRef(child)) {
          cloneProps.ref = composeRef(this.triggerRef, child.ref);
        }
        var trigger = /*#__PURE__*/_react_18_2_0_react.cloneElement(child, cloneProps);
        var portal; // prevent unmounting after it's rendered

        if (popupVisible || this.popupRef.current || forceRender) {
          portal = /*#__PURE__*/_react_18_2_0_react.createElement(PortalComponent, {
            key: "portal",
            getContainer: this.getContainer,
            didUpdate: this.handlePortalUpdate
          }, this.getComponent());
        }
        if (!popupVisible && autoDestroy) {
          portal = null;
        }
        return /*#__PURE__*/_react_18_2_0_react.createElement(es_context.Provider, {
          value: this.triggerContextValue
        }, trigger, portal);
      }
    }], [{
      key: "getDerivedStateFromProps",
      value: function getDerivedStateFromProps(_ref, prevState) {
        var popupVisible = _ref.popupVisible;
        var newState = {};
        if (popupVisible !== undefined && prevState.popupVisible !== popupVisible) {
          newState.popupVisible = popupVisible;
          newState.prevPopupVisible = prevState.popupVisible;
        }
        return newState;
      }
    }]);
    return Trigger;
  }(_react_18_2_0_react.Component);
  defineProperty_defineProperty(Trigger, "contextType", es_context);
  defineProperty_defineProperty(Trigger, "defaultProps", {
    prefixCls: 'rc-trigger-popup',
    getPopupClassNameFromAlign: returnEmptyString,
    getDocument: returnDocument,
    onPopupVisibleChange: noop,
    afterPopupVisibleChange: noop,
    onPopupAlign: noop,
    popupClassName: '',
    mouseEnterDelay: 0,
    mouseLeaveDelay: 0.1,
    focusDelay: 0,
    blurDelay: 0.15,
    popupStyle: {},
    destroyPopupOnHide: false,
    popupAlign: {},
    defaultPopupVisible: false,
    mask: false,
    maskClosable: true,
    action: [],
    showAction: [],
    hideAction: [],
    autoDestroy: false
  });
  return Trigger;
}
/* harmony default export */ var _rc_trigger_5_3_4_rc_trigger_es = (generateTrigger(_rc_util_5_29_2_rc_util_es_Portal));
;// CONCATENATED MODULE: ./node_modules/_rc-tooltip@5.2.2@rc-tooltip/es/placements.js
var autoAdjustOverflow = {
  adjustX: 1,
  adjustY: 1
};
var targetOffset = [0, 0];
var placements = {
  left: {
    points: ['cr', 'cl'],
    overflow: autoAdjustOverflow,
    offset: [-4, 0],
    targetOffset: targetOffset
  },
  right: {
    points: ['cl', 'cr'],
    overflow: autoAdjustOverflow,
    offset: [4, 0],
    targetOffset: targetOffset
  },
  top: {
    points: ['bc', 'tc'],
    overflow: autoAdjustOverflow,
    offset: [0, -4],
    targetOffset: targetOffset
  },
  bottom: {
    points: ['tc', 'bc'],
    overflow: autoAdjustOverflow,
    offset: [0, 4],
    targetOffset: targetOffset
  },
  topLeft: {
    points: ['bl', 'tl'],
    overflow: autoAdjustOverflow,
    offset: [0, -4],
    targetOffset: targetOffset
  },
  leftTop: {
    points: ['tr', 'tl'],
    overflow: autoAdjustOverflow,
    offset: [-4, 0],
    targetOffset: targetOffset
  },
  topRight: {
    points: ['br', 'tr'],
    overflow: autoAdjustOverflow,
    offset: [0, -4],
    targetOffset: targetOffset
  },
  rightTop: {
    points: ['tl', 'tr'],
    overflow: autoAdjustOverflow,
    offset: [4, 0],
    targetOffset: targetOffset
  },
  bottomRight: {
    points: ['tr', 'br'],
    overflow: autoAdjustOverflow,
    offset: [0, 4],
    targetOffset: targetOffset
  },
  rightBottom: {
    points: ['bl', 'br'],
    overflow: autoAdjustOverflow,
    offset: [4, 0],
    targetOffset: targetOffset
  },
  bottomLeft: {
    points: ['tl', 'bl'],
    overflow: autoAdjustOverflow,
    offset: [0, 4],
    targetOffset: targetOffset
  },
  leftBottom: {
    points: ['br', 'bl'],
    overflow: autoAdjustOverflow,
    offset: [-4, 0],
    targetOffset: targetOffset
  }
};
/* harmony default export */ var es_placements = ((/* unused pure expression or super */ null && (placements)));
;// CONCATENATED MODULE: ./node_modules/_rc-tooltip@5.2.2@rc-tooltip/es/Popup.js


function es_Popup_Popup(props) {
  var showArrow = props.showArrow,
    arrowContent = props.arrowContent,
    children = props.children,
    prefixCls = props.prefixCls,
    id = props.id,
    overlayInnerStyle = props.overlayInnerStyle,
    className = props.className,
    style = props.style;
  return /*#__PURE__*/_react_18_2_0_react.createElement("div", {
    className: _classnames_2_3_2_classnames_default()("".concat(prefixCls, "-content"), className),
    style: style
  }, showArrow !== false && /*#__PURE__*/_react_18_2_0_react.createElement("div", {
    className: "".concat(prefixCls, "-arrow"),
    key: "arrow"
  }, arrowContent), /*#__PURE__*/_react_18_2_0_react.createElement("div", {
    className: "".concat(prefixCls, "-inner"),
    id: id,
    role: "tooltip",
    style: overlayInnerStyle
  }, typeof children === 'function' ? children() : children));
}
;// CONCATENATED MODULE: ./node_modules/_rc-tooltip@5.2.2@rc-tooltip/es/Tooltip.js









var Tooltip_Tooltip = function Tooltip(props, ref) {
  var overlayClassName = props.overlayClassName,
    _props$trigger = props.trigger,
    trigger = _props$trigger === void 0 ? ['hover'] : _props$trigger,
    _props$mouseEnterDela = props.mouseEnterDelay,
    mouseEnterDelay = _props$mouseEnterDela === void 0 ? 0 : _props$mouseEnterDela,
    _props$mouseLeaveDela = props.mouseLeaveDelay,
    mouseLeaveDelay = _props$mouseLeaveDela === void 0 ? 0.1 : _props$mouseLeaveDela,
    overlayStyle = props.overlayStyle,
    _props$prefixCls = props.prefixCls,
    prefixCls = _props$prefixCls === void 0 ? 'rc-tooltip' : _props$prefixCls,
    children = props.children,
    onVisibleChange = props.onVisibleChange,
    afterVisibleChange = props.afterVisibleChange,
    transitionName = props.transitionName,
    animation = props.animation,
    motion = props.motion,
    _props$placement = props.placement,
    placement = _props$placement === void 0 ? 'right' : _props$placement,
    _props$align = props.align,
    align = _props$align === void 0 ? {} : _props$align,
    _props$destroyTooltip = props.destroyTooltipOnHide,
    destroyTooltipOnHide = _props$destroyTooltip === void 0 ? false : _props$destroyTooltip,
    defaultVisible = props.defaultVisible,
    getTooltipContainer = props.getTooltipContainer,
    overlayInnerStyle = props.overlayInnerStyle,
    arrowContent = props.arrowContent,
    overlay = props.overlay,
    id = props.id,
    showArrow = props.showArrow,
    restProps = _objectWithoutProperties(props, ["overlayClassName", "trigger", "mouseEnterDelay", "mouseLeaveDelay", "overlayStyle", "prefixCls", "children", "onVisibleChange", "afterVisibleChange", "transitionName", "animation", "motion", "placement", "align", "destroyTooltipOnHide", "defaultVisible", "getTooltipContainer", "overlayInnerStyle", "arrowContent", "overlay", "id", "showArrow"]);
  var domRef = (0,_react_18_2_0_react.useRef)(null);
  (0,_react_18_2_0_react.useImperativeHandle)(ref, function () {
    return domRef.current;
  });
  var extraProps = _objectSpread2({}, restProps);
  if ('visible' in props) {
    extraProps.popupVisible = props.visible;
  }
  var getPopupElement = function getPopupElement() {
    return /*#__PURE__*/_react_18_2_0_react.createElement(es_Popup_Popup, {
      showArrow: showArrow,
      arrowContent: arrowContent,
      key: "content",
      prefixCls: prefixCls,
      id: id,
      overlayInnerStyle: overlayInnerStyle
    }, overlay);
  };
  var destroyTooltip = false;
  var autoDestroy = false;
  if (typeof destroyTooltipOnHide === 'boolean') {
    destroyTooltip = destroyTooltipOnHide;
  } else if (destroyTooltipOnHide && _typeof(destroyTooltipOnHide) === 'object') {
    var keepParent = destroyTooltipOnHide.keepParent;
    destroyTooltip = keepParent === true;
    autoDestroy = keepParent === false;
  }
  return /*#__PURE__*/_react_18_2_0_react.createElement(_rc_trigger_5_3_4_rc_trigger_es, extends_extends({
    popupClassName: overlayClassName,
    prefixCls: prefixCls,
    popup: getPopupElement,
    action: trigger,
    builtinPlacements: placements,
    popupPlacement: placement,
    ref: domRef,
    popupAlign: align,
    getPopupContainer: getTooltipContainer,
    onPopupVisibleChange: onVisibleChange,
    afterPopupVisibleChange: afterVisibleChange,
    popupTransitionName: transitionName,
    popupAnimation: animation,
    popupMotion: motion,
    defaultPopupVisible: defaultVisible,
    destroyPopupOnHide: destroyTooltip,
    autoDestroy: autoDestroy,
    mouseLeaveDelay: mouseLeaveDelay,
    popupStyle: overlayStyle,
    mouseEnterDelay: mouseEnterDelay
  }, extraProps), children);
};
/* harmony default export */ var es_Tooltip = (/*#__PURE__*/(0,_react_18_2_0_react.forwardRef)(Tooltip_Tooltip));
;// CONCATENATED MODULE: ./node_modules/_rc-tooltip@5.2.2@rc-tooltip/es/index.js



/* harmony default export */ var _rc_tooltip_5_2_2_rc_tooltip_es = (es_Tooltip);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/_util/colors.js

var PresetStatusColorTypes = tuple('success', 'processing', 'error', 'default', 'warning');
// eslint-disable-next-line import/prefer-default-export
var PresetColorTypes = tuple('pink', 'red', 'yellow', 'orange', 'cyan', 'green', 'blue', 'purple', 'geekblue', 'magenta', 'volcano', 'gold', 'lime');
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/_util/placements.js


var autoAdjustOverflowEnabled = {
  adjustX: 1,
  adjustY: 1
};
var autoAdjustOverflowDisabled = {
  adjustX: 0,
  adjustY: 0
};
var placements_targetOffset = [0, 0];
function getOverflowOptions(autoAdjustOverflow) {
  if (typeof autoAdjustOverflow === 'boolean') {
    return autoAdjustOverflow ? autoAdjustOverflowEnabled : autoAdjustOverflowDisabled;
  }
  return extends_extends(extends_extends({}, autoAdjustOverflowDisabled), autoAdjustOverflow);
}
function getPlacements(config) {
  var _config$arrowWidth = config.arrowWidth,
    arrowWidth = _config$arrowWidth === void 0 ? 4 : _config$arrowWidth,
    _config$horizontalArr = config.horizontalArrowShift,
    horizontalArrowShift = _config$horizontalArr === void 0 ? 16 : _config$horizontalArr,
    _config$verticalArrow = config.verticalArrowShift,
    verticalArrowShift = _config$verticalArrow === void 0 ? 8 : _config$verticalArrow,
    autoAdjustOverflow = config.autoAdjustOverflow,
    arrowPointAtCenter = config.arrowPointAtCenter;
  var placementMap = {
    left: {
      points: ['cr', 'cl'],
      offset: [-4, 0]
    },
    right: {
      points: ['cl', 'cr'],
      offset: [4, 0]
    },
    top: {
      points: ['bc', 'tc'],
      offset: [0, -4]
    },
    bottom: {
      points: ['tc', 'bc'],
      offset: [0, 4]
    },
    topLeft: {
      points: ['bl', 'tc'],
      offset: [-(horizontalArrowShift + arrowWidth), -4]
    },
    leftTop: {
      points: ['tr', 'cl'],
      offset: [-4, -(verticalArrowShift + arrowWidth)]
    },
    topRight: {
      points: ['br', 'tc'],
      offset: [horizontalArrowShift + arrowWidth, -4]
    },
    rightTop: {
      points: ['tl', 'cr'],
      offset: [4, -(verticalArrowShift + arrowWidth)]
    },
    bottomRight: {
      points: ['tr', 'bc'],
      offset: [horizontalArrowShift + arrowWidth, 4]
    },
    rightBottom: {
      points: ['bl', 'cr'],
      offset: [4, verticalArrowShift + arrowWidth]
    },
    bottomLeft: {
      points: ['tl', 'bc'],
      offset: [-(horizontalArrowShift + arrowWidth), 4]
    },
    leftBottom: {
      points: ['br', 'cl'],
      offset: [-4, verticalArrowShift + arrowWidth]
    }
  };
  Object.keys(placementMap).forEach(function (key) {
    placementMap[key] = arrowPointAtCenter ? extends_extends(extends_extends({}, placementMap[key]), {
      overflow: getOverflowOptions(autoAdjustOverflow),
      targetOffset: placements_targetOffset
    }) : extends_extends(extends_extends({}, placements[key]), {
      overflow: getOverflowOptions(autoAdjustOverflow)
    });
    placementMap[key].ignoreShake = true;
  });
  return placementMap;
}
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/es/tooltip/index.js



var tooltip_rest = undefined && undefined.__rest || function (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;
};










var splitObject = function splitObject(obj, keys) {
  var picked = {};
  var omitted = extends_extends({}, obj);
  keys.forEach(function (key) {
    if (obj && key in obj) {
      picked[key] = obj[key];
      delete omitted[key];
    }
  });
  return {
    picked: picked,
    omitted: omitted
  };
};
var PresetColorRegex = new RegExp("^(".concat(PresetColorTypes.join('|'), ")(-inverse)?$"));
// Fix Tooltip won't hide at disabled button
// mouse events don't trigger at disabled button in Chrome
// https://github.com/react-component/tooltip/issues/18
function getDisabledCompatibleChildren(element, prefixCls) {
  var elementType = element.type;
  if ((elementType.__ANT_BUTTON === true || element.type === 'button') && element.props.disabled || elementType.__ANT_SWITCH === true && (element.props.disabled || element.props.loading) || elementType.__ANT_RADIO === true && element.props.disabled) {
    // Pick some layout related style properties up to span
    // Prevent layout bugs like https://github.com/ant-design/ant-design/issues/5254
    var _splitObject = splitObject(element.props.style, ['position', 'left', 'right', 'top', 'bottom', 'float', 'display', 'zIndex']),
      picked = _splitObject.picked,
      omitted = _splitObject.omitted;
    var spanStyle = extends_extends(extends_extends({
      display: 'inline-block'
    }, picked), {
      cursor: 'not-allowed',
      width: element.props.block ? '100%' : undefined
    });
    var buttonStyle = extends_extends(extends_extends({}, omitted), {
      pointerEvents: 'none'
    });
    var child = cloneElement(element, {
      style: buttonStyle,
      className: null
    });
    return /*#__PURE__*/_react_18_2_0_react.createElement("span", {
      style: spanStyle,
      className: _classnames_2_3_2_classnames_default()(element.props.className, "".concat(prefixCls, "-disabled-compatible-wrapper"))
    }, child);
  }
  return element;
}
var tooltip_Tooltip = /*#__PURE__*/_react_18_2_0_react.forwardRef(function (props, ref) {
  var _classNames2;
  var _React$useContext = _react_18_2_0_react.useContext(context_ConfigContext),
    getContextPopupContainer = _React$useContext.getPopupContainer,
    getPrefixCls = _React$useContext.getPrefixCls,
    direction = _React$useContext.direction;
  // Warning for deprecated usage
  if (false) {}
  var _useMergedState = useMergedState(false, {
      value: props.open !== undefined ? props.open : props.visible,
      defaultValue: props.defaultOpen !== undefined ? props.defaultOpen : props.defaultVisible
    }),
    _useMergedState2 = slicedToArray_slicedToArray(_useMergedState, 2),
    open = _useMergedState2[0],
    setOpen = _useMergedState2[1];
  var isNoTitle = function isNoTitle() {
    var title = props.title,
      overlay = props.overlay;
    return !title && !overlay && title !== 0; // overlay for old version compatibility
  };

  var onOpenChange = function onOpenChange(vis) {
    var _a, _b;
    setOpen(isNoTitle() ? false : vis);
    if (!isNoTitle()) {
      (_a = props.onOpenChange) === null || _a === void 0 ? void 0 : _a.call(props, vis);
      (_b = props.onVisibleChange) === null || _b === void 0 ? void 0 : _b.call(props, vis);
    }
  };
  var getTooltipPlacements = function getTooltipPlacements() {
    var builtinPlacements = props.builtinPlacements,
      _props$arrowPointAtCe = props.arrowPointAtCenter,
      arrowPointAtCenter = _props$arrowPointAtCe === void 0 ? false : _props$arrowPointAtCe,
      _props$autoAdjustOver = props.autoAdjustOverflow,
      autoAdjustOverflow = _props$autoAdjustOver === void 0 ? true : _props$autoAdjustOver;
    return builtinPlacements || getPlacements({
      arrowPointAtCenter: arrowPointAtCenter,
      autoAdjustOverflow: autoAdjustOverflow
    });
  };
  // 动态设置动画点
  var onPopupAlign = function onPopupAlign(domNode, align) {
    var placements = getTooltipPlacements();
    // 当前返回的位置
    var placement = Object.keys(placements).find(function (key) {
      var _a, _b;
      return placements[key].points[0] === ((_a = align.points) === null || _a === void 0 ? void 0 : _a[0]) && placements[key].points[1] === ((_b = align.points) === null || _b === void 0 ? void 0 : _b[1]);
    });
    if (!placement) {
      return;
    }
    // 根据当前坐标设置动画点
    var rect = domNode.getBoundingClientRect();
    var transformOrigin = {
      top: '50%',
      left: '50%'
    };
    if (/top|Bottom/.test(placement)) {
      transformOrigin.top = "".concat(rect.height - align.offset[1], "px");
    } else if (/Top|bottom/.test(placement)) {
      transformOrigin.top = "".concat(-align.offset[1], "px");
    }
    if (/left|Right/.test(placement)) {
      transformOrigin.left = "".concat(rect.width - align.offset[0], "px");
    } else if (/right|Left/.test(placement)) {
      transformOrigin.left = "".concat(-align.offset[0], "px");
    }
    domNode.style.transformOrigin = "".concat(transformOrigin.left, " ").concat(transformOrigin.top);
  };
  var getOverlay = function getOverlay() {
    var title = props.title,
      overlay = props.overlay;
    if (title === 0) {
      return title;
    }
    return overlay || title || '';
  };
  var getPopupContainer = props.getPopupContainer,
    _props$placement = props.placement,
    placement = _props$placement === void 0 ? 'top' : _props$placement,
    _props$mouseEnterDela = props.mouseEnterDelay,
    mouseEnterDelay = _props$mouseEnterDela === void 0 ? 0.1 : _props$mouseEnterDela,
    _props$mouseLeaveDela = props.mouseLeaveDelay,
    mouseLeaveDelay = _props$mouseLeaveDela === void 0 ? 0.1 : _props$mouseLeaveDela,
    otherProps = tooltip_rest(props, ["getPopupContainer", "placement", "mouseEnterDelay", "mouseLeaveDelay"]);
  var customizePrefixCls = props.prefixCls,
    openClassName = props.openClassName,
    getTooltipContainer = props.getTooltipContainer,
    overlayClassName = props.overlayClassName,
    color = props.color,
    overlayInnerStyle = props.overlayInnerStyle,
    children = props.children;
  var prefixCls = getPrefixCls('tooltip', customizePrefixCls);
  var rootPrefixCls = getPrefixCls();
  var tempOpen = open;
  // Hide tooltip when there is no title
  if (!('open' in props) && !('visible' in props) && isNoTitle()) {
    tempOpen = false;
  }
  var child = getDisabledCompatibleChildren(isValidElement(children) && !isFragment(children) ? children : /*#__PURE__*/_react_18_2_0_react.createElement("span", null, children), prefixCls);
  var childProps = child.props;
  var childCls = !childProps.className || typeof childProps.className === 'string' ? _classnames_2_3_2_classnames_default()(childProps.className, defineProperty_defineProperty({}, openClassName || "".concat(prefixCls, "-open"), true)) : childProps.className;
  var customOverlayClassName = _classnames_2_3_2_classnames_default()(overlayClassName, (_classNames2 = {}, defineProperty_defineProperty(_classNames2, "".concat(prefixCls, "-rtl"), direction === 'rtl'), defineProperty_defineProperty(_classNames2, "".concat(prefixCls, "-").concat(color), color && PresetColorRegex.test(color)), _classNames2));
  var formattedOverlayInnerStyle = overlayInnerStyle;
  var arrowContentStyle = {};
  if (color && !PresetColorRegex.test(color)) {
    formattedOverlayInnerStyle = extends_extends(extends_extends({}, overlayInnerStyle), {
      background: color
    });
    // @ts-ignore
    arrowContentStyle = {
      '--antd-arrow-background-color': color
    };
  }
  return /*#__PURE__*/_react_18_2_0_react.createElement(_rc_tooltip_5_2_2_rc_tooltip_es, extends_extends({}, otherProps, {
    placement: placement,
    mouseEnterDelay: mouseEnterDelay,
    mouseLeaveDelay: mouseLeaveDelay,
    prefixCls: prefixCls,
    overlayClassName: customOverlayClassName,
    getTooltipContainer: getPopupContainer || getTooltipContainer || getContextPopupContainer,
    ref: ref,
    builtinPlacements: getTooltipPlacements(),
    overlay: getOverlay(),
    visible: tempOpen,
    onVisibleChange: onOpenChange,
    onPopupAlign: onPopupAlign,
    overlayInnerStyle: formattedOverlayInnerStyle,
    arrowContent: /*#__PURE__*/_react_18_2_0_react.createElement("span", {
      className: "".concat(prefixCls, "-arrow-content"),
      style: arrowContentStyle
    }),
    motion: {
      motionName: motion_getTransitionName(rootPrefixCls, 'zoom-big-fast', props.transitionName),
      motionDeadline: 1000
    }
  }), tempOpen ? cloneElement(child, {
    className: childCls
  }) : child);
});
if (false) {}
/* harmony default export */ var tooltip = (tooltip_Tooltip);
;// CONCATENATED MODULE: ./node_modules/_@ali_tingwu-icon@0.3.9@@ali/tingwu-icon/dist-web/styled.js

var loadingCircle = /*#__PURE__*/Ue(["100%{transform:rotate(360deg);}"]);
var IconContainer = /*#__PURE__*/styled_components_browser_esm.span(["display:inline-flex;width:", ";height:", ";.tingwu-icon-spin{animation:", " 1s infinite linear;}"], function (_ref) {
  var size = _ref.size;
  return size ? size + "px" : '16px';
}, function (_ref2) {
  var size = _ref2.size;
  return size ? size + "px" : '16px';
}, loadingCircle);
var IconSvg = /*#__PURE__*/styled_components_browser_esm.svg(["width:100%;height:100%;transform:", ";"], function (_ref3) {
  var rotate = _ref3.rotate;
  return "rotate(" + rotate + "deg)";
});
;// CONCATENATED MODULE: ./node_modules/_@ali_tingwu-icon@0.3.9@@ali/tingwu-icon/dist-web/iconfont.js
var isLoaded = false;
var loadIcon = function loadIcon() {
  if (isLoaded) return;
  isLoaded = true;
  /* eslint-disable */

  /* @ts-ignore */

  window._iconfont_svg_string_3888402 = '<svg><symbol id="tingwu-good" viewBox="0 0 1024 1024"><path d="M880 28.8A112 112 0 0 1 992 140.8v748a112 112 0 0 1-112 112h-736a112 112 0 0 1-112-112V140.8A112 112 0 0 1 144 28.8h736z m-311.168 226.816c-44.48 0.544-71.072 27.552-70.976 86.144 0.096 56.896-52.544 115.968-113.856 115.424h-13.088l-2.112 0.064a28.64 28.64 0 0 0-28 28.8l0.544 259.296c0.096 15.84 12.8 28.64 28.448 28.64l285.12-0.256c38.144 0 74.08-30.464 80.768-68.608l30.784-175.168c9.824-55.808-28.48-101.856-84.48-101.44l-5.856 0.064a8171.2 8171.2 0 0 1-45.376 0.288c5.472-23.104 9.824-54.592 9.664-72.544-0.48-60.48-30.08-101.216-71.584-100.704z m-270.528 201.44h-28a14.08 14.08 0 0 0-10.112 4.192 14.464 14.464 0 0 0-4.16 10.24L256 759.552c0 3.84 1.504 7.552 4.192 10.24a14.144 14.144 0 0 0 10.176 4.192h28.16a14.112 14.112 0 0 0 10.176-4.16 14.496 14.496 0 0 0 4.192-10.24l-0.32-288.096a14.432 14.432 0 0 0-14.272-14.432z"  ></path></symbol><symbol id="tingwu-light" viewBox="0 0 1024 1024"><path d="M904.533333 0A119.466667 119.466667 0 0 1 1024 119.466667v785.066666a119.466667 119.466667 0 0 1-119.466667 119.466667h-785.066666A119.466667 119.466667 0 0 1 0 904.533333v-785.066666A119.466667 119.466667 0 0 1 119.466667 0h785.066666z m-337.237333 731.716267h-56.285867c-19.387733 0-39.150933 0-58.504533 0.4096-13.687467 0-22.4256 9.216-22.801067 23.005866-0.4096 11.127467-0.4096 22.254933 0 33.348267 0.750933 31.061333 23.9616 58.6752 54.6816 62.907733 15.633067 2.116267 31.402667 2.491733 47.104 1.160534A64.512 64.512 0 0 0 590.506667 797.696c1.877333-13.448533 1.501867-27.2384 1.501866-41.0624 0-16.110933-8.738133-24.917333-24.6784-24.917333z m-246.5792-47.172267c-2.628267 1.160533-8.362667 2.730667-11.3664 6.144-13.7216 12.663467-26.624 25.668267-39.150933 39.150933-8.362667 8.8064-7.236267 21.845333 0.785066 30.276267 7.918933 8.055467 20.855467 9.591467 29.252267 1.501867 13.653333-13.0048 27.3408-26.487467 40.209067-40.618667 6.109867-6.519467 6.485333-14.9504 2.696533-23.381333-4.1984-8.465067-11.025067-12.288-22.4256-13.073067z m383.317333 0c-11.776 0.785067-18.978133 5.0176-23.176533 13.448533-4.096 8.192-2.389333 18.1248 4.1984 24.507734l36.488533 36.829866c9.454933 9.216 22.766933 9.557333 31.470934 0.785067 9.147733-8.840533 9.147733-22.254933-0.375467-32.221867-11.810133-11.912533-23.517867-24.132267-35.703467-35.669333-3.7888-3.7888-9.8304-5.7344-12.9024-7.68zM475.716267 321.3312c-79.7696 15.36-140.9024 77.073067-157.252267 158.378667-15.223467 76.6976 19.012267 157.627733 85.8112 201.728 4.983467 3.413333 11.810133 5.393067 17.851733 5.393066 29.252267 0.375467 58.914133 0.375467 88.1664 0.375467 29.252267 0 58.914133 0.341333 88.098134 0 5.7344 0 12.219733-1.160533 16.725333-4.232533 65.7408-44.8512 96.529067-106.973867 89.7024-186.368-9.966933-114.619733-117.76-196.334933-229.102933-175.274667z m-232.106667 172.987733h-50.176c-13.243733 0-22.766933 9.557333-22.766933 22.254934 0 12.288 9.898667 21.504 22.766933 21.879466h25.463467c8.3968 0 16.725333 0 24.712533 0.375467 13.312-0.375467 23.176533-9.591467 23.176533-22.254933 0-12.629333-9.864533-22.254933-23.176533-22.254934z m561.493333-0.648533l-25.463466 0.273067a22.254933 22.254933 0 1 0 0 44.509866h50.926933c13.243733-0.375467 22.766933-9.9328 22.766933-22.6304 0-12.288-9.898667-21.879467-22.766933-21.879466-17.134933-0.341333-33.860267-0.341333-50.926933 0zM735.573333 265.4208c-2.628267 1.092267-7.9872 2.286933-11.400533 5.7344-13.653333 13.0048-26.965333 26.4192-39.901867 40.277333-7.953067 8.430933-6.826667 21.060267 1.1264 29.4912 7.2704 7.68 20.514133 9.6256 28.4672 1.9456 14.506667-13.448533 28.16-27.204267 41.472-41.813333 6.075733-6.5536 6.075733-15.325867 1.877334-23.415467-3.7888-8.055467-10.615467-11.502933-21.640534-12.219733z m-449.2288 0a21.504 21.504 0 0 0-15.36 6.485333 21.7088 21.7088 0 0 0-0.4096 31.061334c12.253867 12.834133 24.7808 25.361067 37.614934 37.546666 4.164267 3.8912 9.898667 5.393067 12.9024 6.9632 11.400533-0.785067 18.2272-4.983467 21.640533-13.073066 4.1984-9.181867 3.037867-17.646933-3.7888-24.4736a1099.434667 1099.434667 0 0 0-37.239467-38.024534 21.504 21.504 0 0 0-15.36-6.485333zM511.863467 170.666667c-12.526933 0.375467-21.674667 9.9328-21.674667 23.790933v24.917333c0 8.430933 0 16.861867-0.375467 24.917334 0.375467 13.789867 9.5232 23.790933 22.050134 23.790933s22.016-9.591467 22.016-23.415467V194.082133c0-13.824-9.489067-23.415467-22.016-23.415466z"  ></path></symbol><symbol id="tingwu-upgrade" viewBox="0 0 1024 1024"><path d="M904.533333 0A119.466667 119.466667 0 0 1 1024 119.466667v785.066666a119.466667 119.466667 0 0 1-119.466667 119.466667h-785.066666A119.466667 119.466667 0 0 1 0 904.533333v-785.066666A119.466667 119.466667 0 0 1 119.466667 0h785.066666z m-224.290133 238.933333l-324.266667 128.136534 154.385067 80.110933S375.876267 758.5792 170.666667 767.522133c0 0 302.353067 117.589333 494.114133-256.273066L819.2 591.325867 680.2432 238.933333z"  ></path></symbol><symbol id="tingwu-love" viewBox="0 0 1024 1024"><path d="M904.533333 0A119.466667 119.466667 0 0 1 1024 119.466667v785.066666a119.466667 119.466667 0 0 1-119.466667 119.466667h-785.066666A119.466667 119.466667 0 0 1 0 904.533333v-785.066666A119.466667 119.466667 0 0 1 119.466667 0h785.066666z m-236.066133 307.2a150.869333 150.869333 0 0 0-131.106133 76.117333 2.184533 2.184533 0 0 1-3.822934 0A150.698667 150.698667 0 0 0 402.432 307.2a150.596267 150.596267 0 0 0-150.7328 150.4256c0 186.948267 283.7504 327.441067 283.7504 327.441067S819.2 644.027733 819.2 457.6256A150.596267 150.596267 0 0 0 668.4672 307.2z"  ></path></symbol><symbol id="tingwu-arrow-btn" viewBox="0 0 1024 1024"><path d="M1024 530.432L560.872727 64.139636l-90.763636 92.811637 315.298909 316.043636-95.418182-10.984727H0l1.582545 135.261091h688.407273l95.418182-10.24L470.109091 903.074909l90.763636 91.973818z"  ></path></symbol><symbol id="tingwu-search1" viewBox="0 0 1024 1024"><path d="M1010.092614 941.340375l-190.533724-186.733281a449.329241 449.329241 0 0 0-23.533509-621.153094 473.593605 473.593605 0 0 0-659.230605 0 449.475412 449.475412 0 0 0 0 645.7098 474.689887 474.689887 0 0 0 611.067305 39.393048l192.580115 188.779673a51.232888 51.232888 0 0 0 32.81536 15.859539 51.232888 51.232888 0 0 0 34.788666-13.813147 48.090215 48.090215 0 0 0 2.046392-68.042538zM98.424924 456.345443a364.477054 364.477054 0 0 1 368.277496-358.118621 364.477054 364.477054 0 0 1 367.765899 358.118621 364.477054 364.477054 0 0 1-367.765899 358.118621 364.477054 364.477054 0 0 1-368.350581-358.118621z"  ></path></symbol><symbol id="tingwu-next4" viewBox="0 0 1024 1024"><path d="M504.6256 9.088l190.336 132.544 2.24 1.92 1.92 2.304c7.04 9.28 5.12 22.4-4.16 29.376l-190.336 132.48V199.488l-4.16 0.128a362.688 362.688 0 1 0 285.248 125.248l-27.904-32.256 64.512-55.808 27.904 32.256 6.528 7.68 6.336 7.872a448 448 0 1 1-358.528-170.432V9.088z m51.584 389.44v362.496h-72.96V510.976H398.0016v-48.448c22.464-1.024 38.208-2.56 47.232-4.48 14.336-3.2 25.984-9.6 35.008-19.072a62.528 62.528 0 0 0 14.016-25.984 59.712 59.712 0 0 0 2.752-14.464h59.2z"  ></path></symbol><symbol id="tingwu-yingyongxiazai" viewBox="0 0 1024 1024"><path d="M102.4 102.4h358.4v358.4H102.4zM102.4 537.6h358.4v358.4H256a153.6 153.6 0 0 1-153.6-153.6v-204.8zM537.6 102.4h358.4v358.4h-358.4zM537.6 537.6h358.4v358.4h-358.4z"  ></path></symbol><symbol id="tingwu-huazhonghua" viewBox="0 0 1024 1024"><path d="M372.693333 201.813333v85.333334H170.794667v426.666666c0 40.746667 28.629333 75.093333 66.218666 83.370667l6.357334 1.152 6.485333 0.64 6.272 0.170667h576v-210.944h85.333333v296.277333H254.890667l-8.746667-0.256a170.666667 170.666667 0 0 1-160.426667-161.706667l-0.256-8.704v-512h287.232z"  ></path><path d="M948.736 204.245333v213.333334a64 64 0 0 1-64 64h-327.125333a64 64 0 0 1-64-64v-213.333334a64 64 0 0 1 64-64h327.125333a64 64 0 0 1 64 64z"  ></path></symbol><symbol id="tingwu-tuichuhuazhonghua" viewBox="0 0 1024 1024"><path d="M888.96 144.32l-0.128 285.568h-85.312V229.632H142.272v426.688c0 40.704 28.608 75.008 66.176 83.328l6.4 1.152 6.4 0.64 6.336 0.192H398.72v85.312H226.368l-8.768-0.256a170.688 170.688 0 0 1-160.448-161.664l-0.256-8.704v-512h832z"  ></path><path d="M221.248 295.04l253.44 36.224L257.408 548.48z"  ></path><path d="M463.936 492.8l-45.248 45.248L310.08 429.44l45.248-45.248zM961.408 636.864v149.376a96 96 0 0 1-96 96h-263.04a96 96 0 0 1-96-96V636.8a96 96 0 0 1 96-96h263.04a96 96 0 0 1 96 96z"  ></path></symbol><symbol id="tingwu-wechat" viewBox="0 0 1024 1024"><path d="M513.137778 30.606222a483.555556 483.555556 0 1 1 0 967.111111 483.555556 483.555556 0 0 1 0-967.111111z m120.490666 399.36c-101.831111 0-181.987556 68.494222-181.987555 152.462222 0 84.195556 80.213333 152.462222 181.987555 152.462223 21.276444 0 42.780444-5.233778 64.170667-10.524445l58.709333 31.573334-16.099555-52.508445c42.951111-31.630222 74.922667-73.614222 74.922667-121.002667 0-83.968-85.617778-152.462222-181.703112-152.462222z m-208.782222-157.582222c-117.646222 0-213.959111 78.734222-213.959111 178.688 0 57.685333 32.085333 105.073778 85.617778 141.824l-21.390222 63.203556 74.752-36.807112c26.737778 5.176889 48.241778 10.524444 74.979555 10.524445 6.712889 0 13.312-0.284444 19.911111-0.853333a153.656889 153.656889 0 0 1-6.599111-43.975112c0-91.818667 80.270222-166.286222 181.930667-166.286222 6.940444 0 13.767111 0.512 20.593778 1.194667-18.545778-84.593778-110.648889-147.512889-215.836445-147.512889z m149.788445 241.777778c16.156444 0 26.737778 10.524444 26.737777 20.992 0 10.581333-10.581333 21.048889-26.737777 21.048889-10.638222 0-21.390222-10.467556-21.390223-21.048889 0-10.467556 10.752-21.048889 21.390223-21.048889z m117.646222 0c16.042667 0 26.737778 10.524444 26.737778 20.992 0 10.581333-10.695111 21.048889-26.737778 21.048889-10.581333 0-21.219556-10.467556-21.219556-21.048889 0-10.467556 10.638222-21.048889 21.219556-21.048889z m-187.221333-152.462222c16.099556 0 26.737778 10.410667 26.737777 26.225777 0 15.758222-10.638222 26.339556-26.737777 26.339556-16.042667 0-32.142222-10.581333-32.142223-26.339556 0-15.815111 16.099556-26.168889 32.142223-26.168889z m-149.731556 0c16.042667 0 26.737778 10.410667 26.737778 26.225777 0 15.758222-10.695111 26.339556-26.737778 26.339556s-32.199111-10.581333-32.199111-26.339556c0-15.815111 16.156444-26.168889 32.199111-26.168889z"  ></path></symbol><symbol id="tingwu-cancel1" viewBox="0 0 1024 1024"><path d="M512 0a512 512 0 1 1 0 1024A512 512 0 0 1 512 0z m43.456 227.712a198.4 198.4 0 0 0-198.4 198.4v212.288L286.72 568.192l-54.336 54.272 162.944 162.944 162.88-162.944-54.272-54.272-70.144 70.08V426.112l0.32-9.536a121.6 121.6 0 0 1 242.88 9.536v352h76.8v-352l-0.32-11.264a198.4 198.4 0 0 0-198.08-187.136z"  ></path></symbol><symbol id="tingwu-todo" viewBox="0 0 1024 1024"><path d="M512 0a512 512 0 1 1 0 1024A512 512 0 0 1 512 0z m12.928 224.192H263.04a38.4 38.4 0 0 0-38.4 38.4v371.2a166.4 166.4 0 0 0 166.4 166.4h371.2l6.208-0.448a38.4 38.4 0 0 0 32.192-37.888V545.088h-76.8v178.304h-332.8a89.6 89.6 0 0 1-89.6-89.6v-332.8h223.488v-76.8z m202.88 57.024L502.08 499.072l-84.48-87.424-55.232 53.312 137.856 142.72 280.832-271.168-53.376-55.296z"  ></path></symbol><symbol id="tingwu-important" viewBox="0 0 1024 1024"><path d="M512 0a512 512 0 1 1 0 1024A512 512 0 0 1 512 0z m-58.816 207.232A101.568 101.568 0 0 0 357.888 344.96l22.272 63.808-99.2 151.424c-9.344 14.208-14.336 30.72-14.464 47.68l0.448 8.96c4.16 44.48 41.408 79.36 87.04 79.68l119.04 0.832v174.016h76.8l-0.064-173.44 127.104 0.832 7.68-0.32c15.232-1.536 27.904-5.824 39.104-12.736l7.04-4.8c35.84-27.072 45.76-77.44 21.76-116.48L657.472 410.24l22.72-69.376 2.176-8a101.952 101.952 0 0 0-97.664-125.44z m-0.32 76.8l131.2 0.32a25.024 25.024 0 0 1 23.808 30.4l-1.216 4.224-27.648 84.48a38.4 38.4 0 0 0 3.84 32l104.192 169.28a11.328 11.328 0 0 1-8.384 17.28l-3.456 0.064-320.704-2.304a11.264 11.264 0 0 1-9.28-17.536l109.632-167.168a38.4 38.4 0 0 0 4.16-33.792l-28.992-82.688a24.96 24.96 0 0 1 22.848-34.56z"  ></path></symbol><symbol id="tingwu-person-unknown" viewBox="0 0 1024 1024"><path d="M512 1024A512 512 0 1 0 512 0a512 512 0 0 0 0 1024zM343.808 518.144c31.36 20.224 67.2 36.928 107.392 50.048-12.736 29.632-19.84 62.336-19.84 96.64 0 72.576 31.552 137.792 81.728 182.656-16.256 0.64-32.832 0.896-49.664 0.896-129.408 0-244.928-16.768-320.64-78.976 25.92-115.328 101.888-208.832 201.024-251.264z m119.68-412.8c90.688 0 164.224 88.32 164.224 197.12 0 52.864-17.28 100.864-45.568 136.32-31.104 12.8-58.88 32-81.92 55.872a137.216 137.216 0 0 1-36.8 4.992c-90.688 0-164.288-88.32-164.288-197.12 0-108.928 73.6-197.12 164.288-197.12z m212.928 358.4a201.152 201.152 0 1 1 0 402.24 201.152 201.152 0 0 1 0-402.24z m-4.672 281.6a28.992 28.992 0 1 0 0 57.984 28.992 28.992 0 0 0 0-57.984z m4.928-208.256c-24.832 0-44.608 7.808-58.816 23.424-12.16 12.8-18.944 29.568-20.352 50.048l-0.256 7.616 0.256 3.008 1.024 3.776 1.408 2.944a20.608 20.608 0 0 0 18.048 10.752c10.88 0 19.84-8.448 20.672-19.328l0.192-5.952 0.512-5.312 0.832-4.736a38.336 38.336 0 0 1 7.04-15.424c5.952-8.256 14.976-12.16 28.16-12.16 11.328 0 19.328 2.816 24.704 8.32 5.504 5.568 8.32 13.312 8.32 23.424a30.592 30.592 0 0 1-7.552 19.52l-2.944 3.392-7.168 7.232-5.312 4.8-5.76 5.568c-11.072 10.88-18.368 20.16-22.144 28.288a67.2 67.2 0 0 0-6.208 24.128l-0.256 6.4 0.32 3.584 0.896 3.392 1.344 3.072a20.736 20.736 0 0 0 18.368 11.136c11.52 0 20.864-9.344 20.864-20.928 0-7.04 1.536-13.12 4.8-18.56a51.584 51.584 0 0 1 9.6-12.096l15.552-14.08 8.576-8.192 3.904-4.032 1.536-1.728 3.776-5.376 3.136-5.632c4.736-9.472 7.04-19.84 7.04-31.168 0-20.928-6.784-37.952-20.224-50.304-13.632-12.608-31.552-18.816-53.888-18.816z"  ></path></symbol><symbol id="tingwu-success-filled" viewBox="0 0 1024 1024"><path d="M487.905882 6.023529a481.882353 481.882353 0 1 1 0 963.764706 481.882353 481.882353 0 0 1 0-963.764706z m219.617883 323.885177a45.176471 45.176471 0 0 0-54.211765-0.361412l-5.059765 4.457412-223.653647 223.593412-95.774117-95.834353-4.638118-4.035765a45.176471 45.176471 0 0 0-63.668706 62.825412l4.397177 5.12 127.759058 127.698823 4.638118 4.096a45.176471 45.176471 0 0 0 54.151529 0.361412l5.12-4.397176 255.578353-255.578353 4.035765-4.638118a45.176471 45.176471 0 0 0 0.361412-54.151529l-4.397177-5.059765-4.638117-4.096z"  ></path></symbol><symbol id="tingwu-upload-default" viewBox="0 0 1024 1024"><path d="M0 0h1024v1024H0z" fill="#D8D8D8" fill-opacity="0" ></path><path d="M85.333 512a426.667 426.667 0 1 0 853.334 0 426.667 426.667 0 1 0-853.334 0z" fill="#605CE5" opacity=".2" ></path><path d="M647.765 562.347l-89.642-89.856v284.842h-95.83V472.491l-89.685 89.856-67.755-68.054 205.355-206.336 205.355 206.336" fill="#605CE5" ></path></symbol><symbol id="tingwu-upload-waiting" viewBox="0 0 1024 1024"><path d="M0 0h1024v1024H0z" fill="#D8D8D8" fill-opacity="0" ></path><path d="M85.333 512a426.667 426.667 0 1 0 853.334 0 426.667 426.667 0 1 0-853.334 0z" fill="#605CE5" opacity=".2" ></path><path d="M554.667 323.115v384h-85.334v-384h85.334zM384 408.448v213.333h-85.333V408.448H384z m341.333 0v213.333H640V408.448h85.333z" fill="#605CE5" ></path></symbol><symbol id="tingwu-error" viewBox="0 0 1024 1024"><path d="M509.23921533 27.35686233a481.882353 481.882353 0 1 1 0 963.764706 481.882353 481.882353 0 0 1 0-963.764706zM411.65803933 347.32674533a45.176471 45.176471 0 0 0-63.247059 63.247059l4.397177 5.059764 95.834352 95.774118-95.774117 95.894588-4.397177 5.059765A45.176471 45.176471 0 0 0 411.65803933 675.48862733l5.059765-4.397176 95.774117-95.834353 95.894588 95.834353 5.059765 4.397176a45.176471 45.176471 0 0 0 63.247059-63.247059l-4.397176-4.999529-95.894589-95.894588 95.894589-95.774118 4.336941-5.12A45.176471 45.176471 0 0 0 613.44627433 347.26650933l-5.059765 4.397177-95.894588 95.774118-95.774117-95.774118-5.059765-4.397177v0.060236z"  ></path></symbol><symbol id="tingwu-tip" viewBox="0 0 1024 1024"><path d="M506.240693 0.033278a511.967042 511.967042 0 1 1 11.519258 1023.934084 511.967042 511.967042 0 0 1-11.519258-1023.934084z m80.826797 431.076249H371.529365v107.833059H479.362423v269.422655h107.769063V431.173523z m0-215.538124H479.362423v107.833058h107.769063V215.571403z"  ></path></symbol><symbol id="tingwu-scroll-to-bottom" viewBox="0 0 1024 1024"><path d="M479.573333 794.4192l411.374934-411.306667-96.4608-96.529066L547.84 533.162667V0h-136.533333v533.162667L164.727467 286.583467 68.266667 383.112533l411.306666 411.306667z m379.835734 184.9344v-136.465067H93.252267v136.465067h766.1568z"  ></path></symbol><symbol id="tingwu-return-down1" viewBox="0 0 1024 1024"><path d="M809.117538 463.478154l132.804924 121.462154-353.910154 353.516307-1.496616 1.496616a92.868923 92.868923 0 0 1-131.623384-0.393846L99.485538 584.940308 236.307692 463.478154l245.602462 250.564923a55.611077 55.611077 0 0 0 78.060308 0.078769l249.147076-250.643692zM809.038769 4.017231l132.883693 121.462154-353.988924 353.516307-1.417846 1.496616a92.868923 92.868923 0 0 1-131.702154-0.393846L99.406769 125.479385 236.307692 4.017231l245.602462 250.564923a55.611077 55.611077 0 0 0 78.060308 0.078769L809.038769 4.017231z"  ></path></symbol><symbol id="tingwu-refresh1" viewBox="0 0 1024 1024"><path d="M511.998081 102.395264V0a511.976321 511.976321 0 1 1-373.61472 161.912512H26.900517V59.517247H334.08631v307.185793h-102.395265V213.302135A409.581057 409.581057 0 1 0 511.998081 102.459261v-0.127994z"  ></path></symbol><symbol id="tingwu-play-filled" viewBox="0 0 1024 1024"><path d="M512 0a512 512 0 1 1 0 1024A512 512 0 0 1 512 0zM431.616 326.4a22.08 22.08 0 0 0-22.016 22.016v327.488l0.384 4.224a22.144 22.144 0 0 0 33.792 14.144L448 691.52l268.8-179.392L448.128 332.8l-4.16-2.816a22.08 22.08 0 0 0-12.288-3.648z"  ></path></symbol><symbol id="tingwu-AI" viewBox="0 0 1024 1024"><path d="M546.112 85.312a51.2 51.2 0 0 1 51.2 51.2v76.8h256v213.376h76.8a51.2 51.2 0 0 1 51.2 51.2v196.224a51.2 51.2 0 0 1-51.2 51.2h-76.8v213.376h-256v-76.8a51.2 51.2 0 0 0-51.2-51.2H349.696a51.2 51.2 0 0 0-51.2 51.2v76.8H85.312v-213.312h76.8a51.2 51.2 0 0 0 50.816-45.248l0.32-6.016V477.888a51.2 51.2 0 0 0-51.2-51.2H85.376V213.312h213.248v-76.8a51.2 51.2 0 0 1 51.2-51.2h196.288z m-23.04 264.768H448.64l-99.712 301.824-12.8 39.552h68.864l21.76-70.208h116.224l20.352 70.208h71.424L523.072 350.08z m188.096 0H634.752v341.376h76.416V350.08z m-225.92 78.08l39.36 134.272h-80L485.12 428.16z"  ></path></symbol><symbol id="tingwu-logo" viewBox="0 0 1024 1024"><path d="M512 0a512 512 0 1 1 0 1024A512 512 0 0 1 512 0z m114.432 733.952l1.28-0.384 1.088-0.512 3.264-1.28 1.408-0.64 1.92-0.704 1.152-0.384 0.832-0.448 3.712-1.536 4.48-2.112 2.816-1.408 1.92-0.896 4.672-2.432-1.536 0.768 1.6-0.768 1.024-0.64 3.648-1.92 3.008-1.792 1.984-1.152 2.944-1.792 1.28-0.704 2.24-1.472 2.24-1.408-2.176 1.28 2.176-1.344 0.576-0.384 1.664-1.088 3.008-2.048 1.28-0.896 2.112-1.472 0.768-0.64 3.968-2.88 1.216-0.896 0.64-0.512 2.24-1.728 1.28-0.896 4.288-3.52 4.416-3.84 1.344-1.152 2.624-2.304 0.832-0.768 1.088-1.024 1.792-1.536 1.152-1.28 3.072-2.816 4.224-4.16 2.88-3.008 1.088-1.088 3.968-4.224 1.6-1.92 2.944-3.136 4.416-5.184 3.52-4.224 3.584-4.48 1.92-2.24 7.168-8.704 5.824-6.4 1.28-1.408 7.68-7.68 2.816-2.56a189.184 189.184 0 0 1 19.84-15.872l4.992-3.328 3.072-1.92 3.52-2.048 4.288-2.368 4.48-2.304 3.584-1.664 4.48-1.984 1.92-0.768 0.832-0.32 1.856-0.704 1.6-0.64 6.784-2.24 1.92-0.64h-0.64c-84.992 1.28-153.216-56.832-165.952-137.792l1.024 5.632c-4.544 2.56-8.96 5.312-13.248 8.256l-1.472 1.088-1.472 1.088-0.704 0.64-1.536 1.152-1.536 1.28-1.536 1.28-1.6 1.408-1.664 1.472-1.664 1.472-1.792 1.6-1.792 1.6-1.792 1.728-2.88 2.688-1.984 1.92-3.072 2.944-4.352 4.288-4.416 4.352-35.52 36.096-9.024 9.152-19.2 18.88a1037.184 1037.184 0 0 1-116.032 98.048l-3.456 2.432-1.664 1.216-12.608 8.512a234.048 234.048 0 0 1-41.408 20.48l-2.688 0.96 0.896 0.832 1.28 1.088 1.28 1.216 3.008 2.432 3.2 2.56 1.728 1.28 4.096 3.072 2.368 1.728 1.984 1.408 2.112 1.408 2.112 1.472 1.088 0.64 2.176 1.536 4.608 2.88 2.432 1.472 2.432 1.472 3.776 2.176 2.56 1.472 2.752 1.536 14.72 7.68c19.712 9.536 40.512 16.448 61.952 20.48l10.176 1.664 3.968 0.64 8.448 0.832-1.088-0.064 3.136 0.192 5.504 0.384 4.992 0.256 7.488 0.064H544l12.928-0.512h1.28l6.912-0.64 6.848-0.768-2.88 0.384c4.032-0.512 8.128-1.088 12.16-1.728l4.992-0.896 1.92-0.384a243.2 243.2 0 0 0 33.92-8.96l2.752-1.024 1.6-0.64zM96.704 601.6l0.64 0.704 3.2 3.584a247.04 247.04 0 0 0 149.568 79.808l2.24 0.32 12.16 1.28 3.072 0.32c7.488 0.512 14.976 0.768 22.4 0.64l8.704-0.256 1.152-0.064 0.768-0.064 5.888-0.448 0.832-0.064c1.28 0 2.88-0.192 4.48-0.32l1.536-0.192 3.328-0.32 9.024-1.344 1.088-0.192 3.904-0.64 5.888-1.088 5.568-1.152-2.304 0.448 3.968-0.832 5.568-1.408 4.544-1.408-9.344-12.544a245.504 245.504 0 0 0-61.76-54.784l-1.024-0.64c-58.816 23.04-125.376 20.8-184.512-9.024zM543.872 250.24h-7.68l-0.832 0.064-1.472 0.128-3.456 0.32-1.024 0.128-0.832 0.128-1.472 0.192-1.088 0.192-2.048 0.384-1.6 0.32-1.28 0.32-1.6 0.384-1.472 0.384-1.024 0.32-1.92 0.64-0.96 0.256-1.152 0.448-1.088 0.384L509.504 256l-1.088 0.448-1.792 0.832-1.792 0.832-1.472 0.704-1.536 0.832-1.344 0.768-1.728 1.024-2.752 1.728-0.768 0.448-0.96 0.704-0.768 0.512-1.664 1.216-0.768 0.576-0.896 0.64-1.6 1.28-1.088 0.96-1.088 0.896-2.304 2.048-2.048 1.92-1.664 1.664-1.024 1.024-1.6 1.792-1.28 1.408-1.536 1.664-0.896 1.088-1.216 1.472-1.408 1.792-1.6 2.112-1.408 1.92-1.408 1.92a149.76 149.76 0 0 0-1.92 2.752l-1.024 1.6-0.384 0.64-1.216 1.92-0.576 0.896-1.28 2.176-1.216 2.048-1.792 3.2-1.28 2.368-2.112 4.032-0.832 1.728-0.704 1.472-1.152 2.368-2.176 4.8-1.152 2.624-1.472 3.52-0.832 2.048-1.28 3.264-0.64 1.856-1.28 3.264-1.024 3.008-0.768 2.304a319.744 319.744 0 0 0-1.472 4.288l-1.024 3.2-0.96 3.2-0.896 3.008a376.896 376.896 0 0 0-2.432 8.768l-1.28 4.928-0.768 2.944-2.688 11.52-0.704 3.456-0.704 3.456-0.832 4.096-1.088 5.76-0.64 3.648-0.64 3.52-0.576 3.392-0.512 3.328-0.384 2.368-0.96 5.632-0.576 3.52-0.512 2.752-0.64 3.52-0.64 3.392-0.64 3.392-0.64 2.88-0.768 3.84-0.512 2.24-0.64 2.944-0.768 3.008-0.384 1.536-1.408 5.312-1.216 4.16-1.024 3.328-1.92 5.888-0.64 2.048-2.112 5.568-0.896 2.24-0.832 2.112-0.576 1.344c-0.64 1.664-1.408 3.264-2.112 4.928l-1.024 2.112-0.576 1.28-0.64 1.28-0.448 0.96-2.176 4.224a194.688 194.688 0 0 1-4.48 8.128l-0.576 1.024-1.088 1.792-1.344 2.176-2.368 3.712-1.856 2.752-1.408 2.112-1.6 2.176-1.28 1.92-4.096 5.312-1.92 2.368-1.152 1.472-0.704 0.896-1.28 1.472-2.112 2.496-3.328 3.776-1.28 1.408-1.92 2.048-2.368 2.56-2.688 2.752-4.8 4.736-0.832 0.832-2.688 2.56-4.288 3.904-1.024 0.96-2.88 2.56L340.928 576l-3.584 3.008-1.792 1.408-1.472 1.152-1.92 1.472-1.28 1.024-1.024 0.768-1.92 1.344-0.96 0.704-1.92 1.344-2.176 1.472-2.368 1.6-1.984 1.28-1.6 1.024-2.944 1.792-1.92 1.152-2.56 1.472-1.92 1.088-2.816 1.472-1.856 0.96-5.312 2.688-2.112 0.96-3.776-2.368 7.68 5.056c22.912 15.744 42.368 34.56 58.048 55.04l8.96 12.416c20.416-6.976 39.424-16.64 56.384-28.608l4.48-3.2 2.496-1.792c47.36-34.304 87.04-69.248 130.816-112.768l6.72-6.72 40.768-41.408 5.76-5.696 3.392-3.328 3.264-3.2 1.088-0.96 4.032-3.84 1.92-1.792 1.92-1.728 1.92-1.664 1.728-1.6 3.52-3.008 1.664-1.408 3.328-2.624 0.832-0.64 1.6-1.28 0.768-0.576 9.024-5.888 9.28-5.504a690.56 690.56 0 0 0-3.968-23.936l-1.152-6.208-1.024-5.12a540.288 540.288 0 0 0-1.536-7.36l-0.96-4.352-1.088-4.672-0.64-2.368-0.576-2.432-0.64-2.432-0.96-3.84-1.408-5.248-1.024-3.584-0.512-1.6-0.768-2.688-0.768-2.56-0.832-2.56-0.704-2.304-0.896-2.56-0.832-2.56a320 320 0 0 0-0.896-2.432l-0.384-1.088-1.408-3.968-0.896-2.432-0.96-2.368-0.96-2.368a262.4 262.4 0 0 0-1.92-4.8L634.24 325.76a222.08 222.08 0 0 0-6.912-14.336L625.088 307.2l-1.152-2.048-2.304-3.968-0.64-1.024-1.28-2.048-1.408-2.048-0.832-1.28-1.024-1.472-0.768-1.088-0.64-0.832-0.704-1.088-1.472-1.92-1.344-1.792-0.768-0.896-0.704-0.896-0.704-0.832-0.768-0.96-1.28-1.472-0.896-0.96-0.768-0.896-0.832-0.832-1.472-1.536-1.6-1.664-0.832-0.832-1.408-1.28-0.96-0.96-1.536-1.28-1.728-1.472-1.6-1.28-1.92-1.6-1.28-0.96-1.408-0.96-1.792-1.216-0.832-0.576-0.96-0.64-0.64-0.32-1.28-0.768-0.832-0.512-1.6-0.896-1.088-0.64-3.008-1.408L576 257.6l-2.56-1.152-1.472-0.64-0.64-0.192-1.28-0.448-1.984-0.768-0.768-0.192-1.28-0.448-1.152-0.32-1.088-0.32-0.896-0.256-1.28-0.32-0.768-0.192-1.344-0.256-1.088-0.256-1.28-0.256-0.896-0.128-1.28-0.256-1.408-0.192-1.024-0.128-1.408-0.192-2.304-0.192a90.752 90.752 0 0 0-3.2-0.256l-1.664-0.064zM155.84 573.696h-9.728l-2.944 0.064-2.432 0.128h-1.92l-2.24 0.192-3.072 0.192-3.2 0.256-1.472 0.128-3.072 0.256-2.88 0.384-4.416 0.512-2.88 0.384-2.816 0.448-1.408 0.256-1.28 0.192-2.816 0.512-3.968 0.704-2.56 0.576-2.56 0.512-2.56 0.64-4.8 1.152-2.368 0.64-1.408 0.32c56.64 34.56 122.24 40.64 180.608 20.736l-3.072-1.6-3.2-1.6-2.88-1.408L256 597.12l-2.56-1.216-2.752-1.28-2.432-0.96-2.816-1.216-1.92-0.768-2.56-0.96-2.368-0.96-2.56-0.96-3.2-1.152-1.216-0.384-2.176-0.768-2.048-0.64-3.008-0.96-2.88-0.896-1.92-0.64-2.048-0.512-3.008-0.832-4.032-1.024-2.432-0.64-1.856-0.384-3.072-0.704-1.216-0.256-3.072-0.64-1.6-0.32-3.456-0.64-1.28-0.192-4.544-0.768-1.92-0.256-3.072-0.448-1.536-0.192-1.92-0.256-0.832-0.064-0.896-0.128a244.288 244.288 0 0 0-5.76-0.576l-3.2-0.256-1.344-0.064-2.048-0.128-4.096-0.192-1.792-0.128-3.648-0.064zM744.32 429.44h-7.04l-3.2 0.064-1.408 0.064-3.392 0.192-1.088 0.128-1.6 0.128-1.088 0.064-1.728 0.192-1.92 0.256-2.304 0.32-2.176 0.32-2.624 0.384-1.856 0.32-3.84 0.768-1.792 0.384-1.28 0.32-1.728 0.448-1.472 0.32-1.92 0.512-2.048 0.64-1.792 0.448-1.6 0.512-1.728 0.512-2.368 0.832-2.56 0.832-2.752 1.088-1.92 0.704-1.664 0.64-3.328 1.472-2.496 1.088c13.632 80.64 86.656 136.064 174.848 124.096a104.96 104.96 0 0 1 30.72 1.664l9.216 2.24-0.96-9.984a166.208 166.208 0 0 0-22.336-60.672l-1.984-3.264-1.856-2.816-0.64-0.96-0.64-0.96-0.704-1.088-1.28-1.728-1.28-1.792-0.704-0.896-1.28-1.664-0.768-0.96-1.856-2.304-1.088-1.28-0.704-0.832-1.408-1.6-1.6-1.728-1.344-1.472-1.664-1.728-1.664-1.664-0.64-0.64-1.28-1.28-0.96-0.832-2.304-2.112-1.28-1.088-3.136-2.624-2.56-2.176-2.048-1.536-1.92-1.344-0.96-0.768-1.792-1.28-2.112-1.408-3.008-1.92-0.96-0.64-1.856-1.152-1.408-0.896-3.328-1.92-1.408-0.768-3.392-1.728-1.728-0.896-2.048-0.96-0.96-0.448-1.024-0.512-1.6-0.64-1.344-0.64-2.752-1.152-1.92-0.832-1.792-0.64-1.664-0.64-1.792-0.64-2.368-0.768-1.408-0.512-1.28-0.384-1.792-0.512-1.92-0.64-6.144-1.536-1.152-0.256-2.432-0.576-1.664-0.32-1.728-0.32-1.664-0.32-2.88-0.512-1.92-0.256-0.896-0.128-1.216-0.192-0.96-0.128-1.6-0.192-1.856-0.192-1.216-0.128-1.728-0.128-1.664-0.128-2.304-0.128-1.344-0.128h-1.472l-1.728-0.064z"  ></path></symbol><symbol id="tingwu-loading2" viewBox="0 0 1024 1024"><path d="M512 0a512 512 0 1 0 0 1024A512 512 0 0 0 512 0z m0 128a384 384 0 1 1 0 768A384 384 0 0 1 512 128z" fill="#CDCDD6" ></path><path d="M512 0a64 64 0 1 1 0 128 384 384 0 0 0-384 384 64 64 0 1 1-128 0 512 512 0 0 1 512-512z" fill="#7D7D94" ></path></symbol><symbol id="tingwu-meeting-loading" viewBox="0 0 1024 1024"><path d="M512 64a448 448 0 1 0 0 896A448 448 0 0 0 512 64z m0 137.856a310.144 310.144 0 1 1 0 620.288 310.144 310.144 0 0 1 0-620.288z" fill="#000000" opacity=".15" ></path><path d="M512 64a68.928 68.928 0 1 1 0 137.856 310.144 310.144 0 0 0 0 620.288A68.928 68.928 0 0 1 512 960 448 448 0 0 1 512 64z" fill="#FAFCFF" ></path></symbol><symbol id="tingwu-next1" viewBox="0 0 1024 1024"><path d="M397.568 510.976v-48.448c22.464-1.024 38.208-2.56 47.232-4.48 14.336-3.2 25.984-9.6 35.008-19.072a62.528 62.528 0 0 0 14.016-25.984 59.712 59.712 0 0 0 2.752-14.464h59.2v362.496h-72.96V510.976H397.568z" fill="#000000" ></path><path d="M510.912 114.048a448 448 0 1 1-351.744 170.496l6.4-7.872 6.464-7.68 27.904-32.256 64.576 55.808-27.968 32.256a360.896 360.896 0 0 0-88.32 237.184 362.688 362.688 0 1 0 373.568-362.432l-10.88-0.192h-42.688V114.048h42.688z" fill="#605CE5" ></path><path d="M327.36 141.696l190.336-132.48L517.696 307.776l-190.272-132.48-0.064-0.064a20.992 20.992 0 0 1 0-33.6z" fill="#605CE5" ></path></symbol><symbol id="tingwu-logo-unknown1" viewBox="0 0 1024 1024"><path d="M512 512m-512 0a512 512 0 1 0 1024 0 512 512 0 1 0-1024 0Z" fill="#D8E5F5" ></path><path d="M343.808 518.144c31.36 20.224 67.2 36.928 107.392 50.048-12.736 29.632-19.84 62.336-19.84 96.64 0 72.576 31.552 137.792 81.728 182.656-16.256 0.64-32.832 0.896-49.664 0.896-129.408 0-244.928-16.768-320.64-78.976 25.92-115.328 101.888-208.832 201.024-251.264z m119.68-412.8c90.688 0 164.224 88.32 164.224 197.12 0 52.864-17.28 100.864-45.568 136.32-31.104 12.8-58.88 32-81.92 55.872a137.216 137.216 0 0 1-36.8 4.992c-90.688 0-164.288-88.32-164.288-197.12 0-108.928 73.6-197.12 164.288-197.12z" fill="#97C2F8" ></path><path d="M676.48 463.744a201.152 201.152 0 1 1 0 402.24 201.152 201.152 0 0 1 0-402.24z m-4.736 281.6a28.992 28.992 0 1 0 0 57.984 28.992 28.992 0 0 0 0-57.984z m4.928-208.256c-24.832 0-44.608 7.808-58.816 23.424-12.16 12.8-18.944 29.568-20.352 50.048l-0.256 7.616 0.256 3.008 1.024 3.776 1.408 2.944a20.608 20.608 0 0 0 18.048 10.752c10.88 0 19.84-8.448 20.672-19.328l0.192-5.952 0.512-5.312 0.832-4.736a38.336 38.336 0 0 1 7.04-15.424c5.952-8.256 14.976-12.16 28.16-12.16 11.328 0 19.328 2.816 24.704 8.32 5.504 5.568 8.32 13.312 8.32 23.424a30.592 30.592 0 0 1-7.552 19.52l-2.944 3.392-7.168 7.232-5.312 4.8-5.76 5.568c-11.072 10.88-18.368 20.16-22.144 28.288a67.2 67.2 0 0 0-6.208 24.128l-0.256 6.4 0.32 3.584 0.896 3.392 1.344 3.072a20.736 20.736 0 0 0 18.368 11.136c11.52 0 20.864-9.344 20.864-20.928 0-7.04 1.536-13.12 4.8-18.56a51.584 51.584 0 0 1 9.6-12.096l15.552-14.08 8.576-8.192 3.904-4.032 1.536-1.728 3.776-5.376 3.136-5.632c4.736-9.472 7.04-19.84 7.04-31.168 0-20.928-6.784-37.952-20.224-50.304-13.632-12.608-31.552-18.816-53.888-18.816z" fill="#97C2F8" ></path></symbol><symbol id="tingwu-radio-dis" viewBox="0 0 1024 1024"><path d="M512 0a512 512 0 1 1 0 1024A512 512 0 0 1 512 0z m0 110.933333a401.066667 401.066667 0 1 0 0 802.133334 401.066667 401.066667 0 0 0 0-802.133334z" fill="#CDCDD6" ></path><path d="M512 110.933333a401.066667 401.066667 0 1 0 0 802.133334 401.066667 401.066667 0 0 0 0-802.133334z" fill="#27264D" fill-opacity=".12" ></path></symbol><symbol id="tingwu-default" viewBox="0 0 1024 1024"><path d="M512 512m-512 0a512 512 0 1 0 1024 0 512 512 0 1 0-1024 0Z" fill="#97C2F8" ></path><path d="M335.616 372.16a225.856 188.224 90 1 0 376.448 0 225.856 188.224 90 1 0-376.448 0Z" fill="#D9E8FB" ></path><path d="M373.824 626.048c43.264 25.344 93.248 45.824 150.016 61.44 58.624-14.272 109.44-34.432 152.448-60.48a415.488 415.488 0 0 1 187.072 147.968A438.08 438.08 0 0 1 512 950.848c-136.32 0-258.048-62.08-338.56-159.552a415.424 415.424 0 0 1 200.384-165.248z" fill="#D9E8FB" ></path></symbol><symbol id="tingwu-close-eye" viewBox="0 0 1024 1024"><path d="M176.256 256c55.36 149.184 188.544 249.664 334.72 256.256 149.12-6.208 280.96-104.192 337.408-250.624L960 309.952a529.28 529.28 0 0 1-126.08 191.232l70.976 130.24a13.248 13.248 0 0 1-4.48 17.408l-83.52 51.2a11.712 11.712 0 0 1-16.512-4.672l-65.28-119.872a489.472 489.472 0 0 1-162.56 58.24V755.2c0 7.04-5.44 12.8-12.16 12.8H464c-6.656 0-12.096-5.76-12.096-12.8V633.792a482.752 482.752 0 0 1-162.176-59.072L224 695.36a11.712 11.712 0 0 1-16.448 4.672l-83.584-51.2a13.248 13.248 0 0 1-4.416-17.408l71.744-131.776A534.144 534.144 0 0 1 64 302.848L176.256 256z"  ></path></symbol><symbol id="tingwu-cut" viewBox="0 0 1024 1024"><path d="M926.417318 421.647059c35.237647-1.144471 65.054118 23.853176 67.343058 56.32 2.228706 32.527059-24.033882 60.717176-59.151058 63.668706L926.417318 542.117647H96.254494c-34.755765 0.481882-63.849412-24.335059-66.017882-56.32-2.168471-32.045176 23.250824-59.994353 57.825882-63.548235l8.192-0.481883H926.417318v-0.060235z"  ></path></symbol><symbol id="tingwu-more" viewBox="0 0 1024 1024"><path d="M256 384v256H0V384h256z m384 0v256H384V384h256z m384 0v256h-256V384h256z"  ></path></symbol><symbol id="tingwu-radio1" viewBox="0 0 1024 1024"><path d="M516.999529 35.117176a481.882353 481.882353 0 1 1 0 963.764706 481.882353 481.882353 0 0 1 0-963.764706z m0 166.189177a315.693176 315.693176 0 1 0 0 631.446588 315.693176 315.693176 0 0 0 0-631.446588z"  ></path></symbol><symbol id="tingwu-radio" viewBox="0 0 1024 1024"><path d="M498.326588 16.444235a481.882353 481.882353 0 1 1 0 963.764706 481.882353 481.882353 0 0 1 0-963.764706z m0 80.293647a401.588706 401.588706 0 1 0 0 803.117177 401.588706 401.588706 0 0 0 0-803.117177z"  ></path></symbol><symbol id="tingwu-share" viewBox="0 0 1109 1024"><path d="M101.12 1024C45.312 1024 0 978.773333 0 922.88c0-202.24 149.845333-353.962667 369.749333-353.962667 219.989333 0 369.834667 151.637333 369.834667 353.962667V1024H101.12z m695.296-341.333333c152.32 0 276.736 107.008 284.16 251.733333l0.341333 13.738667V1024H853.333333v-101.12c0-93.781333-32.170667-176.64-88.661333-238.592 10.410667-1.109333 20.992-1.621333 31.744-1.621333z m0-398.250667c88.405333 0 160 74.496 160 166.4s-71.68 166.4-160 166.4c-88.32 0-160-74.496-160-166.4s71.68-166.4 160-166.4zM369.749333 0c123.733333 0 224 103.168 224 230.4S493.482667 460.8 369.749333 460.8 145.749333 357.632 145.749333 230.4 246.101333 0 369.749333 0z"  ></path></symbol><symbol id="tingwu-smartMic" viewBox="0 0 1024 1024"><path d="M501.940706 20.058353a481.882353 481.882353 0 1 1 0 963.764706 481.882353 481.882353 0 0 1 0-963.764706z m224.37647 279.491765L499.952941 430.200471l-226.243765-130.710589-48.188235 83.486118 226.304 130.590118v261.421176h96.376471v-261.421176l226.304-130.590118-48.188236-83.425882z"  ></path></symbol><symbol id="tingwu-sharePerson" viewBox="0 0 1024 1024"><path d="M68.367059 975.691294a96.376471 96.376471 0 0 1-28.190118-68.126118c0-4.818824 0.060235-9.637647 0.301177-14.336 8.252235-185.524706 177.573647-323.041882 385.204706-323.041882 42.224941 0 82.944 5.722353 121.072941 16.444235a216.244706 216.244706 0 0 0-24.696471 100.713412c0 117.940706 93.184 213.473882 208.112941 213.473883 28.431059 0 55.476706-5.782588 80.173177-16.384a307.501176 307.501176 0 0 0-15.299765-76.077177c-19.275294 10.962824-41.381647 17.167059-64.873412 17.167059-74.390588 0-134.686118-61.861647-134.686117-138.179765 0-23.491765 5.662118-45.537882 15.781647-64.873412l5.421176-9.456941a415.623529 415.623529 0 0 0-69.993412-26.503529c35.056941-67.041882 104.026353-112.64 183.476706-112.64 114.928941 0 208.052706 95.593412 208.052706 213.473882 0 42.164706-11.866353 81.438118-32.346353 114.507294l98.063059 100.592941-51.983059 53.308236-95.774117-98.424471a207.932235 207.932235 0 0 1-45.778824 27.166118c0.481882 7.469176 0.783059 15.179294 0.783059 23.009882v96.376471h-674.635294c-25.6 0-50.115765-10.119529-68.186353-28.190118z m661.805176-426.465882a133.722353 133.722353 0 0 0-113.543529 63.849412c80.112941 38.972235 142.155294 102.4 173.056 180.464941l5.421176 14.817882a138.661647 138.661647 0 0 0 69.692236-121.072941c0-76.257882-60.235294-138.119529-134.625883-138.11953zM425.682824 40.116706a216.847059 216.847059 0 1 1 0 433.694118 216.847059 216.847059 0 0 1 0-433.694118z"  ></path></symbol><symbol id="tingwu-password_new" viewBox="0 0 1024 1024"><path d="M733.403429 0v341.357714h146.285714v633.856H245.76l-8.557714-0.219428a146.285714 146.285714 0 0 1-137.508572-137.508572l-0.219428-8.557714V341.357714h146.285714V0h487.643429zM635.830857 585.142857h-292.571428v48.786286l0.365714 5.705143a48.786286 48.786286 0 0 0 42.715428 42.715428l5.705143 0.292572h243.785143V585.142857z m0-487.643428h-292.571428v243.858285h292.571428V97.499429z"  ></path></symbol><symbol id="tingwu-passwordShow" viewBox="0 0 1303 1024"><path d="M623.057455 30.999273c241.291636 0 397.405091 121.856 490.961454 240.919272 44.590545 57.064727 81.082182 119.901091 108.637091 186.833455l8.098909 20.666182 5.306182 14.801454 5.213091 16.197819 4.933818 17.128727-6.888727 23.738182-5.399273 15.825454-6.888727 18.338909c-27.927273 70.935273-66.001455 137.495273-112.919273 197.632C1020.369455 902.237091 864.349091 1024 623.057455 1024 381.858909 1024 225.745455 902.144 132.189091 783.080727A795.368727 795.368727 0 0 1 34.164364 621.009455l-5.585455-12.846546-9.402182-22.714182-6.888727-18.432-7.447273-22.341818L0 527.546182l6.888727-23.831273 5.399273-15.732364 6.795636-18.338909 9.495273-22.714181c1.675636-4.189091 3.630545-8.471273 5.585455-12.846546A799.557818 799.557818 0 0 1 132.096 271.825455C225.745455 152.762182 381.765818 30.999273 623.057455 30.999273z m0 279.272727a217.181091 217.181091 0 1 0 0 434.455273 217.181091 217.181091 0 0 0 0-434.455273z"  ></path></symbol><symbol id="tingwu-passwordHide" viewBox="0 0 1102 1024"><path d="M136.034462 37.100308L269.705846 170.929231c68.923077-39.305846 153.993846-65.851077 257.575385-65.851077 204.091077 0 336.187077 103.108923 415.350154 203.854769 37.730462 48.285538 68.608 101.454769 91.923692 158.089846l6.852923 17.486769 4.489846 12.524308 4.411077 13.705846 4.174769 14.493539-5.828923 20.086154-4.568615 13.390769-5.828923 15.517538c-23.630769 60.022154-55.847385 116.342154-95.547077 167.227077a597.385846 597.385846 0 0 1-48.285539 54.272l132.726154 132.647385-74.279384 74.279384L61.676308 111.458462 135.955692 37.021538z m-20.48 266.948923l227.958153 228.036923 0.157539 3.150769a183.768615 183.768615 0 0 0 176.521846 173.607385l201.019077 200.940307c-55.926154 22.055385-120.280615 35.446154-194.008615 35.446154-204.169846 0-336.265846-103.108923-415.428924-203.854769A673.004308 673.004308 0 0 1 28.908308 604.238769l-4.804923-10.870154-7.876923-19.219692L10.24 558.473846l-6.301538-18.904615L0 525.154462l5.828923-20.164924 4.568615-13.312 5.750154-15.517538 8.034462-19.219692c1.417846-3.544615 3.072-7.168 4.726154-10.870154 15.202462-33.555692 38.281846-77.193846 71.443692-122.171077l15.202462-19.849846z m411.648 37.257846c-25.6 0-50.018462 5.277538-72.231385 14.729846l241.270154 241.348923a183.768615 183.768615 0 0 0-169.038769-256z"  ></path></symbol><symbol id="tingwu-mark-question" viewBox="0 0 1024 1024"><path d="M551.749818 824.226909h-164.770909v164.864h164.770909v-164.770909zM469.364364 0A329.728 329.728 0 0 0 140.008727 313.250909L139.636364 329.728h164.770909a164.770909 164.770909 0 1 1 177.245091 164.398545l-12.288 0.465455h-82.478546v207.034182h164.864v-52.596364A329.821091 329.821091 0 0 0 469.364364 0z"  ></path></symbol><symbol id="tingwu-spin" viewBox="0 0 1024 1024"><path d="M816.875243 40.821622l172.571676 173.208216 0.249081 0.249081a121.772973 121.772973 0 0 1-21.628541 187.156757l-10.447567 6.033297-155.606487 78.764973-88.326919 370.88173-0.041513 0.207567a95.342703 95.342703 0 0 1-62.007351 68.123676 95.494919 95.494919 0 0 1-90.776217-16.051892l-7.915243-7.195676L381.965838 728.977297 86.694054 1024 0 937.402811l295.922162-295.61773L117.676973 461.284324a95.190486 95.190486 0 0 1-23.35827-94.429405 95.315027 95.315027 0 0 1 71.818378-65.688216l0.19373-0.041514 375.835675-78.045405 72.953082-151.385946a121.302486 121.302486 0 0 1 196.73254-35.881514l5.064649 5.064649-0.041514-0.041514z"  ></path></symbol><symbol id="tingwu-mark-main" viewBox="0 0 1024 1024"><path d="M313.344 306.048A126.912 126.912 0 0 1 432.448 133.76l164.48 0.384a127.424 127.424 0 0 1 122.112 156.8l-2.816 9.984-28.416 86.72 118.656 192.64c30.08 48.896 17.6 111.808-27.2 145.664l-8.768 6.016c-14.016 8.64-29.824 14.016-48.832 15.936l-9.664 0.384-158.848-1.088 0.064 216.832h-96v-217.536l-148.8-0.96a110.08 110.08 0 0 1-108.864-100.288l-0.448-10.56c0.128-21.184 6.4-41.856 18.048-59.584L341.12 385.792l-27.776-79.744z m107.456-74.24a31.232 31.232 0 0 0-17.344 41.216L439.68 376.32a48 48 0 0 1-5.12 42.24L297.408 627.52a14.08 14.08 0 0 0 11.52 21.952h0.064l400.96 2.816 4.224-0.128a14.08 14.08 0 0 0 10.496-21.568L594.432 419.072a48 48 0 0 1-4.736-40.064l34.56-105.472 1.536-5.312a31.36 31.36 0 0 0-29.76-38.08L432 229.76c-3.84 0-7.68 0.64-11.2 2.048z"  ></path></symbol><symbol id="tingwu-next" viewBox="0 0 1024 1024"><path d="M934.2976 67.072a81.92 81.92 0 0 1 81.5104 72.2944l0.6144 9.6256 0.8192 737.28a81.92 81.92 0 0 1-163.2256 9.728l-0.512-9.728-1.024-737.28a81.92 81.92 0 0 1 81.92-81.92zM133.632 54.272c27.648 0 54.6816 8.6016 77.312 24.576l475.9552 337.3056a100.352 100.352 0 0 1 0 163.7376L210.944 916.992A133.7344 133.7344 0 0 1 0 807.7312V187.904C-0.1024 114.0736 59.6992 54.272 133.632 54.272z"  ></path></symbol><symbol id="tingwu-moveToFolder" viewBox="0 0 1146 1024"><path d="M340.701612 0l159.193791 128H1146.268657V1024H191.044776C89.882746 1024 6.266269 944.754627 0.305672 843.271642L0 832.007642V0h340.701612z m268.853492 276.48l-90.112 90.555224 127.373374 128H291.152239v128h355.648955l-127.35809 139.019463 90.112 90.478806 281.095642-293.490627-281.095642-282.501732v-0.061134z"  ></path></symbol><symbol id="tingwu-open2" viewBox="0 0 1102 1024"><path d="M951.689846 65.851077c75.145846 0 135.955692 60.888615 135.955692 135.955692v611.879385c0 75.067077-60.809846 135.955692-135.955692 135.955692H135.955692A135.955692 135.955692 0 0 1 0 813.686154V201.806769C0 126.818462 60.888615 65.851077 135.955692 65.851077h815.734154zM463.556923 314.289231a54.980923 54.980923 0 0 0-55.138461 54.980923v285.065846a54.980923 54.980923 0 0 0 86.409846 45.213538l222.12923-153.836307a41.196308 41.196308 0 0 0 0-67.899077l-222.12923-153.757539a54.980923 54.980923 0 0 0-31.271385-9.767384z"  ></path></symbol><symbol id="tingwu-mute" viewBox="0 0 1170 1024"><path d="M105.691429 15.506286l6.144 5.339428 875.154285 882.980572a54.857143 54.857143 0 0 1-71.753143 82.578285l-6.144-5.339428-297.252571-299.885714v222.281142c0 71.68-32.402286 87.405714-73.142857 73.142858l-292.571429-219.428572h-146.285714a73.142857 73.142857 0 0 1-73.142857-73.142857v-365.714286a73.142857 73.142857 0 0 1 73.142857-73.142857h79.798857L33.938286 98.084571a54.857143 54.857143 0 0 1 71.753143-82.651428z m904.777142 140.068571c158.500571 170.569143 165.522286 456.923429 20.918858 637.659429L953.417143 714.605714c102.838857-139.264 95.085714-357.010286-23.332572-484.425143a54.857143 54.857143 0 0 1 80.384-74.605714z m-211.382857 110.153143c88.210286 94.793143 110.006857 239.616 65.462857 359.131429l-89.746285-90.550858c9.508571-69.339429-9.069714-143.433143-56.027429-193.901714a54.857143 54.857143 0 0 1 80.384-74.678857z m-187.245714-166.838857v271.140571l-226.962286-228.937143L538.770286 25.746286c40.374857-14.262857 73.142857 1.755429 73.142857 73.142857z"  ></path></symbol><symbol id="tingwu-fullscreen" viewBox="0 0 1084 1024"><path d="M1024.60175 672.045384a54.211733 54.211733 0 0 1 53.729851 46.802796l0.481882 7.408936v144.564621a126.494043 126.494043 0 0 1-116.193814 126.072397l-10.300229 0.421646h-144.564621a54.211733 54.211733 0 0 1-7.408937-107.881348l7.408937-0.542117h144.564621a18.070578 18.070578 0 0 0 17.588695-13.97458l0.481882-4.095998v-144.564621a54.211733 54.211733 0 0 1 54.211733-54.211732z m-961.354728 0a54.211733 54.211733 0 0 1 53.72985 46.802796l0.421647 7.408936v144.564621a18.070578 18.070578 0 0 0 13.97458 17.588696l4.095998 0.481882h144.564621a54.211733 54.211733 0 0 1 7.408936 107.941583l-7.348701 0.481882h-144.564621a126.494043 126.494043 0 0 1-126.132632-116.254049l-0.421646-10.300229v-144.564621a54.211733 54.211733 0 0 1 54.211732-54.211733z m652.588792-422.851516a72.28231 72.28231 0 0 1 72.282311 72.28231v361.411552a72.28231 72.28231 0 0 1-72.282311 72.342546h-361.411552a72.28231 72.28231 0 0 1-72.28231-72.282311v-361.411552a72.28231 72.28231 0 0 1 72.28231-72.342545h361.411552zM272.685016 0.000602a54.211733 54.211733 0 0 1 7.408937 107.941584l-7.408937 0.481882h-144.564621a18.070578 18.070578 0 0 0-17.588695 13.97458l-0.481882 4.095998v144.56462a54.211733 54.211733 0 0 1-107.941584 7.408937l-0.481882-7.348701V126.494646A126.494043 126.494043 0 0 1 117.880401 0.362014L128.120395 0.000602h144.564621z m672.225487 0a126.494043 126.494043 0 0 1 126.132632 116.193814l0.421646 10.360465v144.564621a54.211733 54.211733 0 0 1-108.001818 7.348701l-0.481882-7.288466v-144.564621a18.070578 18.070578 0 0 0-13.914345-17.648931l-4.156233-0.481882h-144.564621a54.211733 54.211733 0 0 1-7.348701-108.001819l7.348701-0.421646h144.564621V0.000602z"  ></path></symbol><symbol id="tingwu-executor" viewBox="0 0 1102 1024"><path d="M206.611692 288.689231c0 117.523692 92.475077 212.676923 206.690462 212.676923 114.215385 0 206.848-95.153231 206.848-212.676923 0-117.366154-92.632615-212.676923-206.848-212.676923s-206.769231 95.310769-206.769231 212.676923zM71.916308 927.901538c0 51.593846 41.905231 93.341538 93.420307 93.341539h589.351385V927.901538c0-186.683077-138.318769-326.734769-341.385846-326.734769C210.313846 601.166769 71.995077 741.218462 71.995077 927.901538z m587.618461-435.672615c0 84.755692 66.087385 153.6 147.613539 153.6 81.604923 0 147.771077-68.844308 147.771077-153.6 0-84.834462-66.244923-153.6-147.771077-153.6s-147.692308 68.765538-147.692308 153.6z m147.613539 213.937231c144.935385 0 262.616615 105.078154 262.616615 245.129846v69.947077h-210.077538V927.901538c0-86.567385-29.696-163.052308-81.841231-220.238769 9.609846-1.024 19.377231-1.496615 29.302154-1.496615z"  ></path></symbol><symbol id="tingwu-eye" viewBox="0 0 1339 1024"><path d="M662.764308 40.566154c278.212923 0 514.835692 195.584 602.584615 468.676923-87.748923 273.171692-324.371692 468.676923-602.584615 468.676923S147.849846 782.414769 60.179692 509.321846C147.849846 236.150154 384.551385 40.644923 662.764308 40.644923z m0 217.639384a251.116308 251.116308 0 1 0 0 502.153847 251.116308 251.116308 0 0 0 0-502.153847z m0 100.43077a150.685538 150.685538 0 1 1 0 301.292307 150.685538 150.685538 0 0 1 0-301.292307z"  ></path></symbol><symbol id="tingwu-right" viewBox="0 0 1024 1024"><path d="M986.112 509.76l-31.872 25.152-523.584 413.184-51.84 40.896v-255.808H60.48V256.128h318.336V30.528l51.84 40.896 523.584 413.184 31.872 25.088z m-103.296 0L442.88 162.56V320H124.48v349.184H442.88v187.712l440-347.136z"  ></path></symbol><symbol id="tingwu-pick-right" viewBox="0 0 1462 1024"><path d="M505.709714 14.043429a73.142857 73.142857 0 0 1 48.566857 18.432l475.062858 422.326857a73.142857 73.142857 0 0 1 6.070857 103.204571l-6.070857 6.070857-475.062858 422.326857a73.142857 73.142857 0 0 1-121.709714-54.710857V655.725714h-329.142857a36.571429 36.571429 0 0 1-36.571429-36.571428v-219.428572a36.571429 36.571429 0 0 1 36.571429-36.571428h329.142857V87.186286a73.142857 73.142857 0 0 1 73.142857-73.142857z m569.270857 187.977142l7.460572 5.339429 280.137143 227.620571a109.714286 109.714286 0 0 1 15.945143 154.331429l-7.533715 8.411429-8.411428 7.606857-280.137143 227.620571a73.142857 73.142857 0 0 1-99.035429-107.373714l6.802286-6.217143 245.174857-199.241143-245.174857-199.168a73.142857 73.142857 0 0 1-16.091429-95.451428l5.412572-7.460572a73.142857 73.142857 0 0 1 95.451428-16.018286z"  ></path></symbol><symbol id="tingwu-pick-left" viewBox="0 0 1024 1024"><path d="M667.949176 58.127059a90.352941 90.352941 0 0 1 56.862118 20.118588l6.625882 5.903059 202.511059 199.981176c15.058824 14.757647 24.395294 34.334118 26.50353 55.235765l0.421647 9.035294v553.020235A120.470588 120.470588 0 0 1 849.317647 1021.590588l-9.035294 0.301177h-662.588235a120.470588 120.470588 0 0 1-120.109177-111.435294l-0.301176-9.035295v-722.823529A120.470588 120.470588 0 0 1 168.779294 58.428235l9.035294-0.301176h490.194824-0.060236zM371.290353 367.314824l-26.985412-46.802824a10.842353 10.842353 0 0 0-6.806588-4.999529 17.046588 17.046588 0 0 0-16.685177 5.903058l-2.048 3.192471-65.957647 136.854588a27.467294 27.467294 0 0 0-1.807058 4.577883 20.841412 20.841412 0 0 0 15.540705 26.74447l4.818824 0.783059 151.491765 11.324235a16.865882 16.865882 0 0 0 9.637647-2.288941c5.842824-3.373176 8.914824-9.517176 7.830588-14.757647l-1.204706-3.011765-31.563294-54.814117a177.694118 177.694118 0 1 1-55.235765 237.989647 36.141176 36.141176 0 0 0-62.403764 36.562823 249.976471 249.976471 0 1 0 93.726117-344.666353l-12.348235 7.469177z"  ></path></symbol><symbol id="tingwu-filter" viewBox="0 0 1152 1024"><path d="M397.568 504.768v348.736c0 30.72 18.56 58.24 46.976 69.824l222.464 90.56a75.456 75.456 0 0 0 103.808-69.952V504.768L1112.192 0H56.192l341.376 504.768z"  ></path></symbol><symbol id="tingwu-hotword" viewBox="0 0 1024 1024"><path d="M935.04 49.92v754.56H180.224v53.888c0 29.76 24.064 53.888 53.888 53.888h700.8v107.776H234.24l-9.472-0.256a161.664 161.664 0 0 1-152.128-161.344V212.48l0.32-9.6A162.56 162.56 0 0 1 235.072 49.92H935.04zM570.24 193.344H438.4l-167.424 448.832h102.144l38.848-111.232h182.4l38.144 111.232h104.128L570.368 193.408z m-62.72 85.952l58.24 170.176H440.256l59.52-170.176h7.744z"  ></path></symbol><symbol id="tingwu-file" viewBox="0 0 1152 1024"><path d="M1109.589333 378.368v474.368a138.666667 138.666667 0 0 1-138.666666 138.666667H138.666667A138.666667 138.666667 0 0 1 0 852.778667V378.368h1109.589333zM617.813333 506.026667a39.125333 39.125333 0 0 0-39.04 39.04l26.154667 144.042666H325.248c-43.093333 0-59.093333 26.581333-59.093333 50.901334 0 24.32 16.042667 49.749333 59.093333 49.749333h498.773333c46.890667 0-8.405333-59.861333-19.84-74.069333l-156.032-195.029334a39.04 39.04 0 0 0-30.293333-14.634666h-0.085333zM373.248 20.522667c26.24 0 50.261333 14.890667 61.994667 38.4l31.061333 61.952c11.733333 23.466667 35.754667 38.357333 61.994667 38.4h511.957333c38.314667 0 69.333333 31.018667 69.333333 69.290666v69.376H0v-138.666666A138.666667 138.666667 0 0 1 138.666667 20.48h234.581333z"  ></path></symbol><symbol id="tingwu-copy2" viewBox="0 0 1024 1024"><path d="M786.701474 215.147789v755.065264H35.193263V215.147789h751.508211z m-75.021474 75.237053H110.160842v604.483369h601.519158V290.384842zM972.476632 32.606316V653.743158h-74.913685l-0.107789-545.845895H351.770947V32.606316h620.705685z"  ></path></symbol><symbol id="tingwu-cancel" viewBox="0 0 1024 1024"><path d="M528.685176 45.176471a481.882353 481.882353 0 1 1 0 963.764705 481.882353 481.882353 0 0 1 0-963.764705z m0 29.214117a452.668235 452.668235 0 1 0 310.512942 782.095059l8.613647-8.432941L209.799529 210.221176l20.660706-20.720941 637.349647 637.409883 8.07153-9.276236a450.740706 450.740706 0 0 0 105.291294-276.118588l0.180706-14.396235a452.668235 452.668235 0 0 0-452.668236-452.668235z"  ></path></symbol><symbol id="tingwu-arrow-right2" viewBox="0 0 1417 1024"><path d="M393.924923 0l644.489846 508.534154-644.489846 508.534154V665.442462H2.126769V314.289231h391.798154V0z m315.076923 0l644.489846 508.534154-644.489846 508.534154v-124.297846l486.951385-384.236308L708.923077 124.297846V0h0.078769z"  ></path></symbol><symbol id="tingwu-file2" viewBox="0 0 1103 1024"><path d="M463.556923 99.721846L432.679385 38.124308A68.923077 68.923077 0 0 0 371.003077 0H137.846154A137.846154 137.846154 0 0 0 0 137.846154V275.692308h1103.005538v-68.844308a68.923077 68.923077 0 0 0-68.923076-69.001846h-508.849231a68.923077 68.923077 0 0 1-61.676308-38.124308zM137.846154 965.159385h827.313231a137.846154 137.846154 0 0 0 137.846153-137.846154V379.352615H0v447.960616c0 76.091077 61.755077 137.846154 137.846154 137.846154z"  ></path></symbol><symbol id="tingwu-file-my" viewBox="0 0 1024 1024"><path d="M621.348571 0c21.942857 0 43.300571 7.533714 60.416 21.357714l7.021715 6.290286 215.259428 212.406857c15.872 15.725714 25.819429 36.498286 28.086857 58.733714l0.438858 9.654858v587.556571a128 128 0 0 1-118.418286 127.707429L804.571429 1024H164.571429a128 128 0 0 1-127.707429-118.418286L36.571429 896V128A128 128 0 0 1 154.989714 0.292571L164.571429 0h456.777142zM388.827429 460.068571c-53.028571 0.073143-95.963429 51.638857-95.963429 115.273143 0 43.739429 20.333714 81.846857 50.249143 101.302857-84.626286 15.433143-147.309714 70.436571-147.309714 135.899429 0 77.458286 392.045714 77.458286 392.045714 0 0-66.706286-65.024-122.514286-152.137143-136.777143 29.257143-19.602286 49.152-57.270857 49.152-100.498286 0-63.634286-43.008-115.2-96.036571-115.2z m225.865142-378.441142a12.8 12.8 0 0 0-12.361142 9.362285l-0.438858 3.437715v190.025142c0 15.433143 11.044571 28.672 26.258286 31.451429l5.705143 0.512h192.804571a12.8 12.8 0 0 0 11.483429-18.578286l-2.486857-3.291428-212.041143-209.261715a12.8 12.8 0 0 0-8.923429-3.657142z"  ></path></symbol><symbol id="tingwu-dingding" viewBox="0 0 1024 1024"><path d="M601.387 219.221C434.73 157.056 190.89 43.435 190.89 43.435c-17.323-4.608-19.755 12.544-19.755 12.544-5.504 68.949 37.035 181.077 59.093 206.25 21.931 25.174 351.744 128.256 351.744 128.256s-253.653-52.352-314.794-70.4c-61.312-18.048-41.814 20.054-41.814 20.054 12.587 69.632 71.552 148.736 118.187 156.16 46.507 7.466 242.603 4.522 242.603 4.522s-39.126 4.651-102.742 13.44c-47.061 6.528-106.922 14.08-122.453 20.054-36.48 14.122 26.453 70.656 26.453 70.656 93.355 86.613 142.976 56.96 142.976 56.96 36.694-12.075 67.67-20.864 93.91-27.307l-32.512 138.112h93.269l-51.37 208.597L859.988 674.56H741.461l24.576-43.648c0.342 0.555 0.427 0.896 0.427 0.896s84.139-137.728 116.31-208.043l0.682-1.109h-0.128c5.547-12.203 9.472-22.23 11.05-29.099 18.731-80.469-126.207-112.17-292.991-174.336z"  ></path></symbol><symbol id="tingwu-captions-close" viewBox="0 0 1216 1024"><path d="M1099.392 889.344a53.248 53.248 0 0 1 0 106.56H69.632a53.248 53.248 0 1 1 0-106.56h1029.76zM1002.112 12.8a142.08 142.08 0 0 1 142.016 142.016v497.088a142.08 142.08 0 0 1-142.08 142.08H149.952a142.08 142.08 0 0 1-142.016-142.08V154.816a142.08 142.08 0 0 1 142.08-142.08h852.16z m-102.4 480.32H473.728l-7.232 0.512a53.248 53.248 0 0 0 0 105.536l7.232 0.448h426.112l7.168-0.448a53.248 53.248 0 0 0 0-105.6l-7.168-0.448z m-607.744-1.024h-71.04l-7.232 0.512a53.248 53.248 0 0 0 0 105.536l7.232 0.512h71.04l7.232-0.512a53.248 53.248 0 0 0 0-105.536l-7.232-0.512z m355.072-212.992H220.928l-7.232 0.448a53.248 53.248 0 0 0 0 105.6l7.232 0.448h426.112l7.232-0.512a53.248 53.248 0 0 0 0-105.536l-7.232-0.448z m248.512 0h-71.04l-7.232 0.448a53.248 53.248 0 0 0 0 105.6l7.296 0.448h71.04l7.168-0.512a53.248 53.248 0 0 0 0-105.536l-7.232-0.448z"  ></path></symbol><symbol id="tingwu-captions-open" viewBox="0 0 1229 1024"><path d="M1075.473067 0a153.6 153.6 0 0 1 153.6 153.6v691.4048a153.6 153.6 0 0 1-153.6 153.6H153.6A153.6 153.6 0 0 1 0 845.073067V153.668267A153.6 153.6 0 0 1 153.6 0h921.873067z m-110.728534 673.245867H503.876267l-7.850667 0.546133a57.617067 57.617067 0 0 0 0 114.141867l7.850667 0.546133h460.868266l7.7824-0.546133a57.617067 57.617067 0 0 0 0-114.141867l-7.7824-0.546133z m-657.408-1.092267H230.4l-7.850667 0.546133a57.617067 57.617067 0 0 0 0 114.141867l7.850667 0.546133H307.2l7.850667-0.546133a57.617067 57.617067 0 0 0 0-114.141867L307.2 672.1536z m384-230.468267H230.468267l-7.850667 0.546134a57.617067 57.617067 0 0 0 0 114.141866l7.850667 0.546134h460.868266l7.850667-0.546134a57.617067 57.617067 0 0 0 0-114.141866l-7.850667-0.546134z m268.9024 0H883.370667l-7.850667 0.546134a57.617067 57.617067 0 0 0 0 114.141866l7.850667 0.546134h76.8l7.850666-0.546134a57.617067 57.617067 0 0 0 0-114.141866l-7.850666-0.546134z"  ></path></symbol><symbol id="tingwu-export1" viewBox="0 0 1024 1024"><path d="M128 682.688a42.88 42.88 0 0 1 42.24 36.352l0.448 6.272v128h682.688v-128c0-21.312 15.744-39.104 36.352-42.24l6.272-0.384h85.376a42.88 42.88 0 0 1 42.176 36.352l0.448 6.272v256a42.752 42.752 0 0 1-36.352 42.24l-6.272 0.448H42.688a42.688 42.688 0 0 1-42.24-36.352L0 981.312v-256c0-21.312 15.808-39.104 36.352-42.24l6.336-0.384H128zM573.696 0c12.352 0 22.72 8.768 25.152 20.48l0.512 5.12v375.488c0 1.408 30.976 2.368 37.568 3.712l1.28 0.512h194.048c35.456 0 54.4 38.4 34.176 64l-4.224 4.672-320.256 303.616a44.032 44.032 0 0 1-54.656 4.224l-5.248-4.224-320.192-303.616c-26.688-25.28-7.872-68.672 29.952-68.672h2.368c9.92-0.128 50.176-0.576 94.592-1.216l42.368-0.64c47.808-0.704 90.88-1.536 96.384-2.24L428.096 25.6a25.6 25.6 0 0 1 20.48-25.088L453.76 0h119.936z"  ></path></symbol><symbol id="tingwu-mic1" viewBox="0 0 1024 1024"><path d="M522.059294 40.176941a481.882353 481.882353 0 1 1 0 963.764706 481.882353 481.882353 0 0 1 0-963.764706zM336.293647 525.432471h-56.259765l-8.673882 8.673882v84.329412l0.421647 8.493176 1.204706 8.372706a93.063529 93.063529 0 0 0 91.376941 76.137412l119.265882-0.060235v103.785411l8.673883 8.673883h56.259765l8.673882-8.673883V711.378824h202.992941l8.673882-8.613648v-168.658823l-8.673882-8.673882h-56.199529l-8.673883 8.673882-0.060235 103.725176H364.363294l-4.21647-0.421647a19.275294 19.275294 0 0 1-15.179295-18.974117v-84.329412l-8.673882-8.673882z m269.251765-292.562824H435.380706a28.129882 28.129882 0 0 0-28.129882 28.129882v309.187765h224.918588V259.493647a26.624 26.624 0 0 0-21.865412-26.142118l-4.818824-0.481882z"  ></path></symbol><symbol id="tingwu-upload-writing" viewBox="0 0 1024 1024"><path d="M20.058353 501.940706a481.882353 481.882353 0 1 0 963.764706 0 481.882353 481.882353 0 0 0-963.764706 0z m240.941176-116.916706h96.376471v240.941176h-96.376471v-240.941176z m385.505883 0h96.37647v240.941176h-96.37647v-240.941176z m-192.752941-96.376471h96.37647v433.694118h-96.37647v-433.694118z"  ></path></symbol><symbol id="tingwu-warn2" viewBox="0 0 1024 1024"><path d="M512 0a512 512 0 1 1 0 1024A512 512 0 0 1 512 0z m2.24 634.24a85.312 85.312 0 1 0 0 170.624 85.312 85.312 0 0 0 0-170.688zM512 219.136a51.2 51.2 0 0 0-51.2 51.2v238.528l0.448 6.976A51.2 51.2 0 0 0 563.2 508.928V270.4l-0.448-6.912A51.2 51.2 0 0 0 512 219.2z"  ></path></symbol><symbol id="tingwu-upload-uploading" viewBox="0 0 1024 1024"><path d="M20.058353 501.940706a481.882353 481.882353 0 1 0 963.764706 0 481.882353 481.882353 0 0 0-963.764706 0z m635.241412 56.862118l-101.195294-101.436236v321.656471H445.741176v-321.656471L344.545882 558.802824 268.047059 481.942588 499.952941 248.952471 731.858824 481.882353"  ></path></symbol><symbol id="tingwu-share2" viewBox="0 0 1024 1024"><path d="M683.121067 0l256 255.573333v736.426667a32 32 0 0 1-32 32h-704A32 32 0 0 1 171.121067 992V853.333333h597.333333V341.333333H603.163733A5.205333 5.205333 0 0 1 597.787733 336.042667V170.666667H341.787733v85.333333H171.121067V32C171.121067 14.336 185.457067 0 203.121067 0H683.121067zM341.787733 362.922667c0-19.114667 23.893333-28.757333 37.802667-15.189334l197.461333 191.744a20.992 20.992 0 0 1 0 30.464L379.5904 761.685333C365.681067 775.253333 341.787733 765.610667 341.787733 746.496V639.402667c-11.861333-0.426667-23.722667-0.682667-35.498666-1.536l-20.053334-1.962667a179.2 179.2 0 0 0-16.725333-1.28 189.952 189.952 0 0 0-35.328 3.157333c-23.808 5.546667-49.493333 16.384-71.68 35.498667-23.210667 18.517333-41.813333 44.885333-56.576 78.08a5.12 5.12 0 0 1-6.741333 2.816 4.693333 4.693333 0 0 1-2.730667-2.816 169.728 169.728 0 0 1-0.597333-116.906667c13.397333-39.936 41.216-77.056 79.104-104.362666a239.445333 239.445333 0 0 1 98.645333-41.130667l32.682667-3.584c11.776-0.853333 23.637333-1.109333 35.498666-1.536V362.922667z"  ></path></symbol><symbol id="tingwu-nav-user" viewBox="0 0 1024 1024"><path d="M368 976a192 192 0 0 1-192-192v-768h672v960h-480z m211.84-192H444.096l-0.448 1.28a71.616 71.616 0 0 0-3.2 14.848l-0.448 7.872a72 72 0 1 0 140.352-22.784l-0.512-1.216z m172.16-96v-576h-480V640c0 24.32 18.048 44.352 41.472 47.552l6.528 0.448h74.368l6.08-5.632c27.2-24.128 62.272-39.68 100.928-42.048L512 640c42.88 0 81.92 16 111.552 42.368l6.016 5.632H752z"  ></path></symbol><symbol id="tingwu-import" viewBox="0 0 1024 1024"><path d="M960 628.096c32.832 0 59.904 25.472 63.552 58.304l0.448 7.68v131.968c0 105.408-79.936 191.616-180.736 197.632L832 1024H192C89.728 1024 6.144 941.568 0.32 837.696L0 826.048v-126.272c0-36.416 28.672-65.92 64-65.92 32.832 0 59.904 25.472 63.552 58.24l0.448 7.68v126.272c0 33.856 24.704 61.76 56.512 65.536l7.488 0.448h640c32.832 0 59.904-25.472 63.552-58.24l0.448-7.68v-132.032c0-36.416 28.672-65.92 64-65.92zM555.264 17.344l3.904 4.032 255.68 287.552a33.728 33.728 0 0 1-1.92 46.592 31.488 31.488 0 0 1-21.696 8.704H608v362.88a32.512 32.512 0 0 1-32 32.96H448c-17.664 0-32-14.72-32-32.96V364.16H232.768c-17.728 0-32-14.784-32-33.024 0-8.256 3.008-16.192 8.384-22.272L464.832 21.376A62.72 62.72 0 0 1 555.264 17.344z"  ></path></symbol><symbol id="tingwu-feedback" viewBox="0 0 1024 1024"><path d="M320.768 168A384.064 384.064 0 0 0 126.976 495.36c-1.088 66.688 8.32 129.728 40.32 188.16l-14.528 125.568a45.696 45.696 0 0 0 40.128 50.688l5.248 0.32 5.44-0.32 125.44-14.528c51.328 28.16 105.536 37.248 164.032 40a384.064 384.064 0 1 0 17.856-767.616 384.128 384.128 0 0 0-190.144 50.432z m35.328 215.808h309.888V469.12H356.096V383.808z m0 161.664h309.888v85.312H398.72a42.688 42.688 0 0 1-42.432-38.016l-0.256-4.608v-42.688z"  ></path></symbol><symbol id="tingwu-download2" viewBox="0 0 1024 1024"><path d="M960 640a64 64 0 0 1 63.488 56.512L1024 704v128a192 192 0 0 1-180.736 191.68L832 1024H192a192 192 0 0 1-191.68-180.736L0 832v-122.496a64 64 0 0 1 127.552-7.424l0.448 7.424V832a64 64 0 0 0 56.512 63.552L192 896h640a64 64 0 0 0 63.552-56.512L896 832v-128a64 64 0 0 1 64-64zM576 0a32 32 0 0 1 32 32L607.808 384h183.296a32 32 0 0 1 23.68 53.632l-255.744 278.912a64 64 0 0 1-90.432 3.904l-3.84-3.904-255.744-278.912A32 32 0 0 1 232.768 384l183.104-0.064L416 32A32 32 0 0 1 448 0h128z"  ></path></symbol><symbol id="tingwu-learning" viewBox="0 0 1024 1024"><path d="M540.928 51.456c125.696 0 228.48 41.344 297.28 119.552 60.8 69.12 92.992 163.008 92.992 271.552a389.056 389.056 0 0 1-68.608 221.056 328.896 328.896 0 0 0-58.88 169.856l-0.32 14.784v131.584h-451.84V884.48l-29.632 2.24a155.072 155.072 0 0 1-119.296-40.576 160.832 160.832 0 0 1-51.584-108.032l-0.32-10.304v-83.2l-58.048-28.992-1.792-0.32-1.408-1.344a58.56 58.56 0 0 1-24.768-71.68l2.752-6.016 84.608-147.392c12.672-98.368 46.208-176.512 99.84-232.32C318.72 86.784 416 51.456 540.928 51.456z m2.56 132.096A76.8 76.8 0 0 0 470.784 284.8L380.352 361.408a102.4 102.4 0 1 0 53.888 123.904l182.08 25.536a89.6 89.6 0 1 0 4.8-51.072L437.12 433.92a101.888 101.888 0 0 0-16.96-39.232L502.4 325.12a76.8 76.8 0 1 0 41.216-141.632z"  ></path></symbol><symbol id="tingwu-edit2" viewBox="0 0 1024 1024"><path d="M493.411937 85.365385a45.437416 45.437416 0 0 1 4.351753 90.810835l-4.351753 0.191989H90.874831v756.628967h756.692964V513.117056a45.437416 45.437416 0 0 1 41.085663-45.309423l4.415749-0.191989a45.437416 45.437416 0 0 1 45.245426 41.085664l0.255986 4.415748v450.214395c0 31.99818-24.766591 58.236688-56.124808 60.47656l-4.543742 0.191989H60.668549a60.668549 60.668549 0 0 1-60.47656-56.124808L0 963.395447V145.969938c0-31.99818 24.766591-58.172691 56.124808-60.47656l4.479745-0.19199H493.411937zM1010.63052 13.36948c16.639054 16.639054 17.662995 43.06955 3.135822 60.924535l-3.199818 3.455803-591.582354 591.582354a45.501412 45.501412 0 0 1-67.452163-60.860539l3.135821-3.455803L946.250182 13.36948a45.501412 45.501412 0 0 1 64.380338 0z"  ></path></symbol><symbol id="tingwu-moveFolder" viewBox="0 0 1024 1024"><path d="M213.333 853.333a128 128 0 0 1-127.786-120.49l-0.214-7.51V128h270.934l106.666 85.333h347.734V384h128L817.323 811.179a49.963 49.963 0 0 1-44.118 41.898l-5.205 0.256H213.333z m142.934-640h-185.6v383.915L256 384h469.333v-85.333h-262.4l-106.666-85.334z"  ></path></symbol><symbol id="tingwu-markDoneNew" viewBox="0 0 1024 1024"><path d="M401.92 80.896l180.821 0.427h0.256a90.155 90.155 0 0 1 86.614 109.226l-2.304 8.619L627.2 321.707 775.083 561.92l0.085 0.128a70.528 70.528 0 0 1-52.608 107.093l-7.893 0.384-180.011-1.28 0.043 308.694h-90.624V667.605l-187.606-1.28a70.485 70.485 0 0 1-58.453-109.098l0.085-0.128 155.606-237.27-41.088-117.333a89.6 89.6 0 0 1 84.053-121.6h5.29z"  ></path></symbol><symbol id="tingwu-message" viewBox="0 0 1024 1024"><path d="M170.688 426.688v139.264L128 651.264v138.048h213.632a170.688 170.688 0 0 0 340.736 0H896v-138.048l-42.688-85.312V426.688a341.312 341.312 0 0 0-682.624 0z m256.64 362.624a85.376 85.376 0 0 0 169.344 0H427.328z"  ></path></symbol><symbol id="tingwu-help" viewBox="0 0 1024 1024"><path d="M512 0a512 512 0 1 1 0 1024A512 512 0 0 1 512 0z m11.008 690.752a64 64 0 1 0 0 128 64 64 0 0 0 0-128zM512 272.192c-46.72 0-86.144 15.68-114.496 47.296-26.752 28.48-39.936 66.752-39.936 111.808a48 48 0 1 0 96 0c0-22.016 5.12-36.672 14.72-46.912 9.792-10.944 22.976-16.192 43.712-16.192 18.752 0 30.72 4.16 39.36 12.16 7.296 6.848 11.008 16.384 11.008 32a44.16 44.16 0 0 1-5.248 22.208l-3.392 5.056-9.216 8.96-21.952 20.16c-13.632 11.904-24.32 24.768-32 38.784a110.08 110.08 0 0 0-14.272 45.184l-0.64 12.544v43.328l0.512 6.528a48 48 0 0 0 95.104 0l0.448-6.528v-43.328l0.256-4.224a16.448 16.448 0 0 1 2.112-6.272 45.12 45.12 0 0 1 8.064-10.368l21.12-19.328 13.312-12.736 9.6-9.984 3.52-3.968c19.456-25.984 28.672-54.656 28.672-86.016 0-41.152-13.824-76.352-41.472-102.144-27.52-25.728-63.104-38.016-104.96-38.016H512z"  ></path></symbol><symbol id="tingwu-meeting" viewBox="0 0 1024 1024"><path d="M341.312 128v469.312h341.376V125.76a40.448 40.448 0 0 0-36.032-40.192l-4.416-0.256H384A42.688 42.688 0 0 0 341.312 128z m-47.296 554.432l4.672 0.256H768V512h85.312v256H554.688v170.688H469.312V768H298.688a128 128 0 0 1-127.808-120.96L170.688 640V512H256v128c0 22.016 16.64 40.128 38.016 42.432z"  ></path></symbol><symbol id="tingwu-pick" viewBox="0 0 1024 1024"><path d="M554.667 725.333h-85.334v-384h85.334V170.667l384 362.666-384 362.667V725.333z m-341.334-384h-128v256a128 128 0 0 0 128 128v-384z m170.667 0h-85.333v384H384v-384z"  ></path></symbol><symbol id="tingwu-textarea" viewBox="0 0 1024 1024"><path d="M640.853 128.853l213.334 213.334v513.322l-0.256 4.822a41.387 41.387 0 0 1-36.267 36.266l-4.821 0.299h-513.28l-7.51-0.213a128 128 0 0 1-120.32-120.278l-0.17-7.509V171.904l0.256-4.693c2.133-19.883 17.877-35.712 37.717-38.016l5.035-0.299h426.325z m-148.48 294.699H292.267v220.715h200.021v-55.04H348.075V476.928h144.213v-53.419z m242.902 0H535.253v55.083h144.214v112.298H535.253v53.334h200.022V423.509z m-121.856 85.547H427.307v54.016h186.112v-54.102z"  ></path></symbol><symbol id="tingwu-next3" viewBox="0 0 1024 1024"><path d="M728.545882 1003.941647v-348.16l-502.844235 326.776471-3.011765 2.048A118.121412 118.121412 0 0 1 40.658824 896.903529l-0.602353-11.38447V160.165647A119.627294 119.627294 0 0 1 215.04 53.970824l9.938824 5.903058 503.567058 327.378824V40.176941h275.395765v963.764706h-275.395765z"  ></path></symbol><symbol id="tingwu-loading3" viewBox="0 0 1024 1024"><path d="M411.286588 110.170353a52.705882 52.705882 0 1 0 0-105.411765 52.705882 52.705882 0 0 0 0 105.411765z m-196.969412 89.148235a60.235294 60.235294 0 1 0-83.727058-86.738823 60.235294 60.235294 0 0 0 83.727058 86.738823z m-74.089411 196.969412a67.764706 67.764706 0 1 0-135.529412 0 67.764706 67.764706 0 0 0 135.529412 0z m-21.744941 186.368a75.294118 75.294118 0 1 0 106.435764 106.435765 75.294118 75.294118 0 0 0-106.496-106.496h0.060236z m292.743529 69.571765a82.823529 82.823529 0 1 0 0 165.647059 82.823529 82.823529 0 0 0 0-165.647059z m175.766588-80.233412a90.352941 90.352941 0 1 0 126.313412 129.204706 90.352941 90.352941 0 0 0-126.313412-129.204706z m163.117177-273.648941a97.882353 97.882353 0 1 0 0 195.764706 97.882353 97.882353 0 0 0 0-195.764706z m-24.696471-67.162353A105.411765 105.411765 0 1 0 576.451765 82.100706a105.411765 105.411765 0 0 0 149.082353 149.082353z"  ></path></symbol><symbol id="tingwu-password" viewBox="0 0 1024 1024"><path d="M512 0a245.76 245.76 0 0 1 245.76 245.76v113.472H800a128 128 0 0 1 128 128v349.12a128 128 0 0 1-128 128H224a128 128 0 0 1-128-128V487.296a128 128 0 0 1 128-128l42.176-0.064V245.824A245.824 245.824 0 0 1 499.328 0.32z m0 113.472A132.352 132.352 0 0 0 379.648 245.76l-0.128 113.472h264.768V245.824a132.352 132.352 0 0 0-122.88-132.032z"  ></path></symbol><symbol id="tingwu-last" viewBox="0 0 1024 1024"><path d="M292.544 0v369.92L826.88 22.72l3.2-2.112a125.504 125.504 0 0 1 193.28 93.184l0.64 12.096v770.688a127.104 127.104 0 0 1-185.792 112.768l-10.624-6.208-535.04-347.84V1024H0V0h292.544z"  ></path></symbol><symbol id="tingwu-marked" viewBox="0 0 1024 1024"><path d="M632.173714 0c14.189714 0 28.086857 3.730286 41.691429 11.922286l8.192 5.412571 7.314286 6.363429 256.731428 256.731428c29.257143 29.403429 31.597714 76.288 5.12 108.397715l-6.582857 7.314285-8.630857 7.753143-8.923429 7.168-10.532571 7.68c-46.592 32.182857-100.937143 49.883429-161.206857 41.106286l-3.364572-0.658286L667.794286 543.524571l1.828571 7.094858 5.851429 28.745142c21.065143 122.148571-1.828571 238.884571-92.525715 329.508572a80.164571 80.164571 0 0 1-98.889142 11.849143l-8.118858-5.485715-7.314285-6.363428-160.475429-160.475429-201.508571 205.092572a62.171429 62.171429 0 0 1-93.842286-81.261715l5.12-5.924571L220.306286 660.48 60.854857 501.028571a80.969143 80.969143 0 0 1-5.851428-107.812571l5.851428-6.509714c86.674286-86.674286 197.193143-111.396571 314.294857-94.793143l16.091429 2.486857 19.456 3.803429 15.506286 3.584 84.187428-84.114286-1.170286-7.168a211.968 211.968 0 0 1 19.017143-117.394286l6.875429-13.677714 7.606857-13.458286 8.265143-12.8 5.193143-7.168 11.044571-13.897143 7.753143-8.411428C590.116571 8.484571 610.669714 0 632.173714 0z"  ></path></symbol><symbol id="tingwu-play-media" viewBox="0 0 1144 1024"><path d="M0 221.665882A169.863529 169.863529 0 0 1 169.863529 51.802353h964.005647v963.764706H0V221.665882z m443.753412 138.11953v347.617882a28.310588 28.310588 0 0 0 43.971764 23.612235l260.698353-173.839058a28.310588 28.310588 0 0 0 0-47.164236L487.785412 336.233412a28.310588 28.310588 0 0 0-44.032 23.552z"  ></path></symbol><symbol id="tingwu-datepicker" viewBox="0 0 1024 1024"><path d="M512 0c282.752 0 512 222.272 512 496.512C1024 770.688 794.752 1024 512 1024s-512-253.312-512-527.488C0 222.272 229.248 0 512 0z m-62.592 271.424a48 48 0 0 0-47.552 41.472l-0.448 6.528-0.128 249.6 0.448 6.848a54.4 54.4 0 0 0 47.168 47.168l6.848 0.384h249.664l6.528-0.448a48 48 0 0 0 41.024-41.024l0.448-6.528-0.448-6.528a48 48 0 0 0-41.024-41.024l-6.528-0.448H497.28l0.128-208-0.448-6.464a48 48 0 0 0-47.552-41.536z"  ></path></symbol><symbol id="tingwu-loading" viewBox="0 0 1024 1024"><path d="M469.333 512A85.333 85.333 0 1 0 640 512a85.333 85.333 0 1 0-170.667 0zM128 512a128 128 0 1 0 256 0 128 128 0 1 0-256 0zM725.333 512A85.333 85.333 0 1 0 896 512a85.333 85.333 0 1 0-170.667 0z"  ></path></symbol><symbol id="tingwu-mic2" viewBox="0 0 1024 1024"><path d="M294.772364 139.636364m217.227636 0l-0.046545 0q217.227636 0 217.227636 217.227636l0 155.136q0 217.227636-217.227636 217.227636l0.046545 0q-217.227636 0-217.227636-217.227636l0-155.136q0-217.227636 217.227636-217.227636Z"  ></path><path d="M756.875636 692.782545a37.236364 37.236364 0 1 1 68.794182 28.532364 339.688727 339.688727 0 0 1-313.949091 209.128727 339.688727 339.688727 0 0 1-313.297454-207.499636 37.236364 37.236364 0 1 1 68.608-28.904727 265.262545 265.262545 0 0 0 244.689454 161.978182 265.216 265.216 0 0 0 245.154909-163.23491z"  ></path></symbol><symbol id="tingwu-radio-summary" viewBox="0 0 1024 1024"><path d="M170.688 171.008V768a128 128 0 0 0 128 128h513.28c22.848 0 41.344-18.56 41.344-41.344v-513.28L640 128H213.696c-23.744 0-43.008 19.2-43.008 43.008z m512 383.68V640H384a42.688 42.688 0 0 1-42.688-42.688v-42.624h341.376zM341.312 384v85.312h256V384h-256z"  ></path></symbol><symbol id="tingwu-radio-choose" viewBox="0 0 1024 1024"><path d="M512 0a512 512 0 1 1 0 1024A512 512 0 0 1 512 0z m0 341.333333a170.666667 170.666667 0 1 0 0 341.333334 170.666667 170.666667 0 0 0 0-341.333334z"  ></path></symbol><symbol id="tingwu-prev2" viewBox="0 0 1024 1024"><path d="M397.568 510.976v-48.448c22.464-1.024 38.208-2.56 47.232-4.48 14.336-3.2 25.984-9.6 35.008-19.072a62.528 62.528 0 0 0 14.016-25.984 59.712 59.712 0 0 0 2.752-14.464h59.2v362.496h-72.96V510.976H397.568z"  ></path><path d="M510.912 114.048a448 448 0 1 0 351.744 170.496l-6.4-7.872-6.464-7.68-27.904-32.256-64.512 55.808 27.904 32.256a360.896 360.896 0 0 1 88.32 237.184 362.688 362.688 0 1 1-373.568-362.432l10.88-0.192h42.688V114.048h-42.688z"  ></path><path d="M694.528 141.632L504.192 9.152v298.624l190.272-132.48 0.064-0.064a20.992 20.992 0 0 0 0-33.6z"  ></path></symbol><symbol id="tingwu-pause2" viewBox="0 0 1024 1024"><path d="M213.3504 298.6496v554.7008h213.2992V170.6496H341.3504a128 128 0 0 0-128 128z m384-128v682.7008h213.2992V170.6496h-213.2992z"  ></path></symbol><symbol id="tingwu-syncbtn" viewBox="0 0 1024 1024"><path d="M506.368 0a505.152 505.152 0 0 1 429.888 241.28l39.36-11.328a37.888 37.888 0 0 1 46.912 26.24 38.784 38.784 0 0 1-0.512 22.912l-59.776 178.56a28.352 28.352 0 0 1-44.992 12.992L773.12 351.36a38.656 38.656 0 0 1 13.568-66.56l35.84-10.368a392.384 392.384 0 0 0-316.096-160.64C288.832 113.792 112.512 292.16 112.512 512s176.32 398.208 393.856 398.208c164.736 0 310.272-103.168 368.064-256.128a56.064 56.064 0 0 1 72.64-32.896c29.056 11.264 43.52 44.16 32.512 73.472C905.216 891.392 718.08 1024 506.368 1024 226.688 1024 0 794.752 0 512s226.688-512 506.368-512zM440.384 298.688c12.352 0 24.32 3.84 34.56 10.88l245.184 171.712a46.336 46.336 0 0 1 0 75.648l-245.184 171.648a60.288 60.288 0 0 1-84.48-15.488 61.824 61.824 0 0 1-10.816-34.944v-318.08c0-33.92 27.2-61.44 60.736-61.44z"  ></path></symbol><symbol id="tingwu-process" viewBox="0 0 1303 1024"><path d="M651.636364 768c95.232 0 170.356364 66.56 195.490909 153.6h205.544727V614.4h50.082909c55.109818 0 100.258909-46.08 100.258909-102.4 0-56.32-45.149091-102.4-100.258909-102.4h-50.082909V102.4H847.127273A200.797091 200.797091 0 0 1 651.636364 256c-95.232 0-170.356364-66.56-195.490909-153.6H250.600727v307.2h-50.082909c-55.109818 0-100.258909 46.08-100.258909 102.4 0 56.32 45.149091 102.4 100.258909 102.4h50.082909v307.2H456.145455c25.134545-87.04 100.258909-153.6 195.490909-153.6z m501.294545 153.6c0 56.32-45.149091 102.4-100.258909 102.4H751.895273v-51.2c0-56.32-45.149091-102.4-100.258909-102.4s-100.258909 46.08-100.258909 102.4V1024h-300.683637a101.655273 101.655273 0 0 1-100.352-102.4V711.68C65.163636 691.2 0 609.28 0 512s65.163636-174.08 150.341818-199.68V102.4C150.341818 46.08 195.490909 0 250.600727 0h300.776728v51.2c0 56.32 45.149091 102.4 100.258909 102.4s100.258909-46.08 100.258909-102.4V0h300.683636c55.202909 0 100.352 46.08 100.352 102.4v209.92C1238.109091 332.8 1303.272727 414.72 1303.272727 512s-65.163636 174.08-150.341818 199.68V921.6z"  ></path><path d="M426.635636 465.454545H535.272727c32.581818 0 54.272 18.618182 54.272 46.545455S567.854545 558.545455 535.272727 558.545455H426.635636C394.053818 558.545455 372.363636 539.927273 372.363636 512s21.690182-46.545455 54.272-46.545455zM861.090909 465.454545h108.637091c32.581818 0 54.272 18.618182 54.272 46.545455s-21.690182 46.545455-54.272 46.545455H861.090909c-32.581818 0-54.272-18.618182-54.272-46.545455S828.509091 465.454545 861.090909 465.454545z"  ></path></symbol><symbol id="tingwu-recover" viewBox="0 0 1024 1024"><path d="M1029.81571318 476.99528059L615.66702933 835.68715852 512 925.52730548V822.68918518l-0.05218608-138.35984593H370.94710992a254.246912 254.246912 0 0 0-165.38980503 60.84289423L-5.81571318 926.25184237V671.84958578c0-189.77890608 157.31309985-343.62223882 351.338496-343.62223881h166.4250311v-230.48040297l517.86789926 379.24833659z"  ></path></symbol><symbol id="tingwu-reload" viewBox="0 0 1024 1024"><path d="M683.199998 0.00001a95.999999 95.999999 0 0 1 67.456 27.648l215.167998 212.415998a95.999999 95.999999 0 0 1 28.607999 68.287999V896.000001a127.999999 127.999999 0 0 1-127.999998 127.999999h-703.999994a127.999999 127.999999 0 0 1-127.999998-127.999999V128.000009a127.999999 127.999999 0 0 1 127.999998-127.999999zM332.160002 273.472007a18.176 18.176 0 0 0-19.904 9.6l-70.143999 145.535999a29.184 29.184 0 0 0-1.856 4.864c-4.16 14.976 5.504 28.032 21.567999 29.247999l160.959999 12.032a17.92 17.92 0 0 0 10.24-2.432c7.424-4.352 10.624-12.8 7.104-18.943999l-33.664-58.24A188.799998 188.799998 0 1 1 347.776002 648.000004a38.4 38.4 0 0 0-66.24 38.911999A265.599997 265.599997 0 1 0 368.000001 328.512007l-28.671999-49.664a11.52 11.52 0 0 0-7.232-5.312z"  ></path></symbol><symbol id="tingwu-reset" viewBox="0 0 1024 1024"><path d="M178.346667 26.453333a20.992 20.992 0 0 1 15.104 7.082667l88.234666 101.717333A448.170667 448.170667 0 0 1 532.309333 58.794667c252.586667 0 456.874667 209.237333 456.874667 466.773333s-204.288 466.773333-456.874667 466.773333c-164.181333 0-313.173333-89.258667-394.496-231.082666a53.504 53.504 0 0 1 92.842667-53.248c62.549333 109.226667 176.384 177.408 301.653333 177.408 193.024 0 349.952-160.853333 349.952-359.936 0-198.997333-157.013333-359.765333-349.866666-359.765334a341.333333 341.333333 0 0 0-179.968 51.029334l86.869333 100.181333c8.704 9.984 5.802667 26.624-6.314667 37.205333a33.194667 33.194667 0 0 1-17.749333 8.021334l-297.813333 35.157333c-29.696 3.413333-51.882667-17.066667-49.664-45.909333a54.442667 54.442667 0 0 1 1.621333-9.557334L145.493333 51.029333A33.706667 33.706667 0 0 1 178.346667 26.453333z"  ></path></symbol><symbol id="tingwu-refresh" viewBox="0 0 1024 1024"><path d="M1020.748406 0v446.050462h-3.990974v0.577641l-132.023795-0.091898-0.098462-0.485743h-313.63282l207.563487-205.627077c-120.333128-120.851692-306.103795-147.515077-455.56841-65.378462C173.532816 257.181538 96.437432 428.288 133.93815 594.661744c37.500718 166.367179 180.558769 287.85559 350.805333 297.918359C654.996611 902.642872 811.353534 798.851282 868.198663 638.057026h136.493948c-57.810051 224.032821-259.085128 381.144615-490.436923 382.857846-231.358359 1.706667-434.937436-152.418462-496.049231-375.558564-61.124923-223.146667 35.498667-459.493744 235.434667-575.914667 199.942564-116.420923 453.185641-83.797333 617.084718 79.497846L1020.741842 0z"  ></path></symbol><symbol id="tingwu-mute2" viewBox="0 0 1024 1024"><path d="M210.901 341.333l514.432 514.475v80.427L370.347 682.667H213.333A128 128 0 0 1 85.547 562.176l-0.214-7.51V341.334h125.568zM180.14 77.141L413.44 310.485l311.893-222.72v534.571l178.859 178.859-60.33 60.33-724.054-724.053 60.33-60.33zM894.72 331.008l1.28 5.077a725.333 725.333 0 0 1 4.779 331.392L896 687.957l-1.28 5.078-82.773-20.736 1.28-5.078a640 640 0 0 0 4.48-291.285l-4.48-19.157-1.28-5.12 82.773-20.694z"  ></path></symbol><symbol id="tingwu-edit" viewBox="0 0 1024 1024"><path d="M459.233882 26.684235c35.177412 0 64.331294 28.431059 66.379294 64.752941 2.048 36.382118-23.612235 68.065882-58.608941 72.402824l-7.830588 0.481882h-246.964706c-23.792941 0-43.971765 18.130824-47.164235 42.465883l-0.481882 6.686117v590.125177c0 24.816941 17.950118 45.417412 41.08047 48.670117l6.505412 0.481883h570.729412c24.033882 0 43.971765-18.552471 47.043764-42.465883l0.481883-6.686117v-198.294588c0-36.382118 27.527529-66.499765 62.644706-68.668236 35.177412-2.108235 65.897412 24.455529 70.053647 60.656941l0.481882 7.951059v198.294589c0 98.785882-74.330353 180.525176-169.743059 186.548705l-10.962823 0.361412H212.148706c-95.533176 0-174.561882-76.920471-180.404706-175.525647l-0.301176-11.324235V213.473882c0-98.785882 74.330353-180.464941 169.682823-186.48847l11.023059-0.301177h247.085176z m238.351059 157.756236l146.672941 147.877647-309.067294 319.126588a33.310118 33.310118 0 0 1-9.33647 6.746353l-5.300706 2.048-190.945883 54.814117-0.12047-0.421647 52.284235-197.692235a34.936471 34.936471 0 0 1 4.818824-10.661647l3.794823-4.577882 307.2-317.31953v0.060236zM820.344471 57.765647a100.111059 100.111059 0 0 1 144.805647 0 108.423529 108.423529 0 0 1 7.047529 141.613177l-7.047529 8.071529-76.197647 78.727529-147.154824-147.335529L820.344471 57.825882z"  ></path></symbol><symbol id="tingwu-play-media2" viewBox="0 0 1024 1024"><path d="M843.968 572.928l-1.28 0.96L149.312 983.04v-960L842.688 435.2a82.176 82.176 0 0 1 1.28 137.792z"  ></path></symbol><symbol id="tingwu-revoke" viewBox="0 0 1283 1024"><path d="M641.97158201 2.544716L5.097075 468.953791l636.87450699 551.60740299V723.929791H815.379104a312.679164 312.679164 0 0 1 203.401553 74.828418l259.943164 222.697075V708.585075c0-233.39558199-193.45958201-422.591045-432.074508-422.59104499H641.97158201V2.544716z"  ></path></symbol><symbol id="tingwu-open" viewBox="0 0 1024 1024"><path d="M505.685 690.475l-209.28-312.448-16.81-28.587a19.541 19.541 0 0 1 16.81-29.44H774.7a14.933 14.933 0 0 1 13.013 22.315l-13.013 23.082-217.344 325.12-0.128 0.171a31.787 31.787 0 0 1-51.542-0.213z"  ></path></symbol><symbol id="tingwu-replace" viewBox="0 0 1024 1024"><path d="M944.583111 751.388444v113.038223H593.237333l73.671111 84.764444-77.824 63.203556-212.536888-240.298667a12.458667 12.458667 0 0 1 9.329777-20.650667h558.705778v-0.056889zM615.594667 0.056889L882.517333 210.488889V339.057778h-130.104889V273.351111l-181.930666-143.36H158.378667v670.663111c0 14.165333 9.898667 26.112 20.423111 29.184l3.925333 0.625778 5.859556 0.341333 128.682666-0.056889v129.934223l-128.682666 0.056889-9.784889-0.284445a160.199111 160.199111 0 0 1-150.072889-150.072889L28.444444 800.654222V53.873778L28.842667 47.502222a53.873778 53.873778 0 0 1 47.217777-47.104L82.147556 0h533.390222v0.056889z m128.455111 410.168889l212.650666 240.298666a12.458667 12.458667 0 0 1-9.329777 20.650667H388.551111V558.193778h351.288889l-73.614222-84.764445L744.106667 410.168889z"  ></path></symbol><symbol id="tingwu-pause3" viewBox="0 0 1024 1024"><path d="M85.357714 24.356571v974.994286h304.859429V24.356571H85.357714z m548.717715 0v974.994286h304.859428V24.356571H634.075429z"  ></path></symbol><symbol id="tingwu-selectAll" viewBox="0 0 1024 1024"><path d="M78.185412 348.340706c26.503529 0 48.007529 20.901647 48.007529 46.622118v404.660705c0 67.704471 52.404706 123.120941 118.904471 127.819295l9.155764 0.301176h404.781177c25.720471 0 46.622118 21.564235 46.622118 48.067765 0 26.503529-20.901647 48.067765-46.622118 48.067764h-436.705882A192.150588 192.150588 0 0 1 30.117647 831.728941V394.962824c0-25.720471 21.504-46.622118 48.067765-46.622118zM865.761882 59.632941C936.538353 59.632941 993.882353 116.916706 993.882353 187.693176v512.421648a128.120471 128.120471 0 0 1-128.120471 128.12047H353.340235a128.120471 128.120471 0 0 1-128.12047-128.12047V187.693176C225.219765 116.916706 282.503529 59.632941 353.340235 59.632941h512.421647z m-121.193411 201.487059l-4.457412 4.818824-169.923765 253.650823-94.027294-85.534118-5.360941-4.698353A48.067765 48.067765 0 0 0 402.793412 495.736471l4.577882 5.421176 131.674353 124.084706 5.300706 4.638118a48.067765 48.067765 0 0 0 61.44-2.710589l4.818823-5.180235 203.956706-295.454118 4.096-5.842823a48.067765 48.067765 0 0 0-74.089411-59.632941z"  ></path></symbol><symbol id="tingwu-next2" viewBox="0 0 1024 1024"><path d="M397.568 510.976v-48.448c22.464-1.024 38.208-2.56 47.232-4.48 14.336-3.2 25.984-9.6 35.008-19.072a62.528 62.528 0 0 0 14.016-25.984 59.712 59.712 0 0 0 2.752-14.464h59.2v362.496h-72.96V510.976H397.568z"  ></path><path d="M510.912 114.048a448 448 0 1 1-351.744 170.496l6.4-7.872 6.464-7.68 27.904-32.256 64.576 55.808-27.968 32.256a360.896 360.896 0 0 0-88.32 237.184 362.688 362.688 0 1 0 373.568-362.432l-10.88-0.192h-42.688V114.048h42.688z"  ></path><path d="M327.36 141.696l190.336-132.48L517.696 307.776l-190.272-132.48-0.064-0.064a20.992 20.992 0 0 1 0-33.6z"  ></path></symbol><symbol id="tingwu-spot" viewBox="0 0 1024 1024"><path d="M341.333 426.667v170.666H170.667V426.667h170.666z m256 0v170.666H426.667V426.667h170.666z m256 0v170.666H682.667V426.667h170.666z"  ></path></symbol><symbol id="tingwu-share3" viewBox="0 0 1024 1024"><path d="M739.584 0L1024 284.416V1024H170.688l-10.048-0.256A170.688 170.688 0 0 1 0 853.312V0h739.584z m-56.832 340.864H568.96v0.64H284.416v113.728h203.52L145.216 798.08l115.328 115.392h160.96L305.92 798.08l262.976-263.04v204.48h113.792v-398.72z"  ></path></symbol><symbol id="tingwu-praise" viewBox="0 0 1102 1024"><path d="M630.390154 6.065231s177.073231 19.692308 72.231384 406.921846h271.281231c7.561846-0.393846 67.268923-1.181538 67.268923 64.984615v2.205539c-0.708923 16.462769-8.349538 128-100.588307 441.422769 0 0-31.192615 100.430769-69.395693 100.430769H464.738462c-28.356923 0-100.588308-19.140923-100.588308-72.152615V412.987077l2.993231-2.205539c24.812308-19.219692 198.104615-159.744 198.104615-335.399384 5.671385-9.924923-9.846154-69.316923 65.220923-69.316923zM254.030769 413.144615c5.750154 0.236308 40.408615 2.993231 40.408616 41.117539v544.925538s0.157538 22.843077-29.065847 22.843077H124.219077c-5.513846-0.393846-33.555692-3.544615-33.555692-34.500923L57.265231 445.991385s0.551385-32.846769 33.949538-32.84677h162.816z"  ></path></symbol><symbol id="tingwu-summary-audio" viewBox="0 0 1024 1024"><path d="M455.111111 0h113.777778v1024H455.111111V0z m455.111111 398.222222h113.777778v284.444445h-113.777778V398.222222zM0 398.222222h113.777778v284.444445H0V398.222222z m227.555556-227.555555h113.777777v682.666666H227.555556V170.666667z m455.111111 0h113.777777v682.666666h-113.777777V170.666667z"  ></path></symbol><symbol id="tingwu-play" viewBox="0 0 1024 1024"><path d="M851.321263 587.829895L328.757895 949.571368a129.347368 129.347368 0 0 1-202.967579-106.38821V173.002105A129.347368 129.347368 0 0 1 328.757895 66.56l522.563368 361.741474a97.010526 97.010526 0 0 1 0 159.528421z"  ></path></symbol><symbol id="tingwu-search" viewBox="0 0 1084 1024"><path d="M472.184471 9.336471a440.380235 440.380235 0 0 1 371.83247 676.442353l207.510588 207.510588-109.869176 109.929412-202.992941-202.872471A440.380235 440.380235 0 1 1 472.244706 9.336471z m0 155.407058a284.912941 284.912941 0 1 0 0 569.946353 284.912941 284.912941 0 0 0 0-569.886117z"  ></path></symbol><symbol id="tingwu-rangePickerIcon" viewBox="0 0 1024 1024"><path d="M298.667 85.333v128h426.666v-128h85.334v128h128V896H213.333l-7.509-0.213A128 128 0 0 1 85.547 775.509L85.333 768V213.333h128v-128h85.334z m64 517.334H256v66.73c0 22.059 17.92 39.936 39.936 39.936h66.73V602.667z m202.666 0H458.667v106.666h106.666V602.667z m202.667 0H661.333v106.666H768V602.667zM362.667 400H256v106.667h106.667V400z m202.666 0H458.667v106.667h106.666V400zM768 400H661.333v106.667H768V400z"  ></path></symbol><symbol id="tingwu-questionClose" viewBox="0 0 1024 1024"><path d="M512 0a512 512 0 1 1 0 1024A512 512 0 0 1 512 0z m191.36 240.192L512 431.552l-191.36-191.36L240.192 320.64 431.552 512l-191.36 191.36 80.448 80.448L512 592.448l191.36 191.36 80.448-80.448L592.448 512l191.36-191.36-80.448-80.448z"  ></path></symbol><symbol id="tingwu-maximize-icon" viewBox="0 0 1024 1024"><path d="M320.128 426.666667l-0.042667 279.296H597.333333V853.333333l-277.248-0.042666V853.333333H170.666667V426.666667h149.461333zM853.333333 170.666667v426.666666h-149.461333l0.042667-279.296H426.666667V170.666667h426.666666z"  ></path></symbol><symbol id="tingwu-translate" viewBox="0 0 1024 1024"><path d="M995.5328 0v995.5328H170.7008A170.6496 170.6496 0 0 1 0 824.8832V0h995.5328zM332.1344 393.3696h-141.824v86.5792h62.976V686.08c0 21.2992-0.6656 34.3552-13.824 50.1248l56.0128 57.7536c10.3936-13.1072 22.8864-28.8768 33.8944-41.984l65.7408-67.9936v32.9728h139.7248v93.5424h83.0464v-93.4912h159.0272v-76.1856h-159.0784v-42.7008h130.7136v-72.0896h-130.7136V480.768l-82.9952-3.4304v48.7424H401.3056v72.192h133.4272v42.5984H395.0592v24.6784l-32.512-56.32c-8.2944 8.9088-20.0704 22.016-30.4128 30.9248V393.3696z m421.888-174.5408H388.1984v77.0048h67.1232l-38.0928 24.064c25.6 32.256 52.5312 59.6992 80.1792 81.0496-38.656 15.7696-83.6096 28.8256-136.9088 41.8816l34.6112 72.1408c73.984-22.016 131.3792-43.264 179.2-65.9456 55.296 26.7776 118.8864 46.6944 202.5984 65.9968l29.7472-74.9056c-60.16-11.6736-109.2608-22.6816-152.832-38.5024a384.1536 384.1536 0 0 0 100.3008-105.7792V218.8288z m-471.7568-24.7296l-64.256 54.272c25.6 27.5456 72.6016 86.5792 92.672 118.2208L379.1872 312.32c-22.2208-32.9728-72.704-92.1088-96.9216-118.2208z m378.368 101.7344c-21.4528 24.7296-49.1008 48.0768-87.808 69.376A297.6256 297.6256 0 0 1 492.544 295.8336h168.0384z"  ></path></symbol><symbol id="tingwu-success" viewBox="0 0 1024 1024"><path d="M808.256 203.84l88 87.488-412.8 412.864-87.616 87.552-88-87.552 0.256-0.256-201.408-201.408 87.488-87.552 201.472 201.472z"  ></path></symbol><symbol id="tingwu-user" viewBox="0 0 1024 1024"><path d="M349.824 562.304c47.296 26.24 101.184 64.192 161.6 64.192 60.48 0 112.32-37.44 158.464-63.104a35.904 35.904 0 0 1 26.432-0.96 479.552 479.552 0 0 1 291.392 441.088h-3.2l-3.968 0.064h-95.36l-89.728-0.064h-62.72l-22.016-0.064h-45.44l-23.296-0.064h-47.488l-72.448-0.128h-48.576l-119.04-0.192-45.44-0.128-141.056-0.192H134.4l-42.56-0.128H44.544l-5.44-0.128H32a479.552 479.552 0 0 1 291.52-441.28 35.904 35.904 0 0 1 26.304 1.024v0.064zM511.424 0c120.32 0 217.984 117.12 217.984 261.44 0 144.512-97.6 261.632-217.984 261.632-120.32 0-217.92-117.12-217.92-261.568C293.504 117.12 391.104 0 511.424 0z"  ></path></symbol><symbol id="tingwu-save" viewBox="0 0 1024 1024"><path d="M779.685647 983.823059v-428.272941H244.314353v428.272941h-53.609412A160.647529 160.647529 0 0 1 30.117647 823.235765V20.058353h749.568L993.882353 234.315294v749.568h-214.196706z m-107.038118 0H351.352471V662.588235h321.295058v321.234824z"  ></path></symbol><symbol id="tingwu-outdent" viewBox="0 0 1024 1024"><path d="M408 441.984h480A8 8 0 0 0 896 433.984v-56a8 8 0 0 0-8-8h-480a8 8 0 0 0-8 8v56c0 4.416 3.584 8 8 8z m-8 204.032c0 4.416 3.584 8 8 8h480a8 8 0 0 0 8-8v-56a8 8 0 0 0-8-8h-480a8 8 0 0 0-8 8v56zM904 160H120a8 8 0 0 0-8 8V224c0 4.416 3.584 8 8 8h784a8 8 0 0 0 8-8v-56a8 8 0 0 0-8-8z m0 632H120a8 8 0 0 0-8 8v56c0 4.416 3.584 8 8 8h784a8 8 0 0 0 8-8V800a8 8 0 0 0-8-8zM115.392 518.912l156.288 123.072c5.76 4.608 14.4 0.512 14.4-6.912V388.928a8.832 8.832 0 0 0-14.4-6.912L115.392 505.088a8.768 8.768 0 0 0 0 13.824z"  ></path></symbol><symbol id="tingwu-volume" viewBox="0 0 1024 1024"><path d="M725.333 87.765v848.47L370.347 682.667H213.333a128 128 0 0 1-128-128V341.333h285.014L725.333 87.765z m87.894 269.014a640 640 0 0 1 0 310.442l-1.28 5.12 82.773 20.694 1.28-5.12a725.333 725.333 0 0 0 0-351.83l-1.28-5.12-82.773 20.736 1.28 5.078z"  ></path></symbol><symbol id="tingwu-summary-video" viewBox="0 0 1408 1024"><path d="M1312 0A96 96 0 0 1 1408 96v832a96 96 0 0 1-96 96H192a192 192 0 0 1-192-192V96A96 96 0 0 1 96 0h1216zM1280 896V128H128v704a64 64 0 0 0 56.512 63.552L192 896h1088z m-367.168-350.144l-0.64 0.448-337.92 199.488V277.76l337.92 200.96a40.064 40.064 0 0 1 0.64 67.136z"  ></path></symbol><symbol id="tingwu-wordDef" viewBox="0 0 1024 1024"><path d="M819.627 153.515v548.778H270.763v39.211c0 21.632 17.493 39.21 39.168 39.21h509.696v78.38H309.973l-6.912-0.214a117.59 117.59 0 0 1-110.634-117.333V271.744l0.213-6.955a118.23 118.23 0 0 1 117.973-111.274h509.014zM554.41 257.877h-96L336.64 584.32h74.325l28.246-80.896h132.65l27.734 80.896h75.733L554.453 257.877z m-45.654 62.55l42.368 123.733H459.82l43.306-123.733h5.632z"  ></path></symbol><symbol id="tingwu-summary" viewBox="0 0 1024 1024"><path d="M672 32l266.688 266.688v641.6l-0.384 6.08a51.712 51.712 0 0 1-45.376 45.312l-5.952 0.32H245.312l-9.344-0.256a160 160 0 0 1-150.4-150.4L85.312 832V85.76l0.32-5.888a53.76 53.76 0 0 1 47.168-47.488L139.072 32H672z m53.312 533.312H298.688v53.376l0.32 6.208a53.312 53.312 0 0 0 46.72 46.72l6.272 0.384h373.312V565.312zM618.688 352h-320v106.688h320V352z"  ></path></symbol><symbol id="tingwu-spread" viewBox="0 0 1024 1024"><path d="M505.685 690.475l-209.28-312.448-16.81-28.587a19.541 19.541 0 0 1 16.81-29.44H774.7a14.933 14.933 0 0 1 13.013 22.315l-13.013 23.082-217.344 325.12-0.128 0.171a31.787 31.787 0 0 1-51.542-0.213z"  ></path></symbol><symbol id="tingwu-pause" viewBox="0 0 1024 1024"><path d="M754.944 51.2a76.8 76.8 0 0 1 76.288 67.712l0.576 8.96 0.96 768a76.8 76.8 0 0 1-153.024 9.152l-0.576-9.088-0.96-768A76.8 76.8 0 0 1 754.944 51.2z m-537.6 0a76.8 76.8 0 0 1 76.288 67.712l0.576 9.024 0.96 768a76.8 76.8 0 0 1-153.024 9.152L141.568 896 140.608 128A76.8 76.8 0 0 1 217.344 51.2z"  ></path></symbol><symbol id="tingwu-review" viewBox="0 0 1024 1024"><path d="M561.536 128c208.256 0 377.152 171.904 377.152 384s-168.896 384-377.152 384a372.288 372.288 0 0 1-258.24-104.128l92.544-54.4c45.056 33.472 100.544 53.248 160.64 53.248 150.4 0 272.32-124.16 272.32-277.312 0-153.216-121.92-277.376-272.384-277.376-149.312 0-270.592 122.368-272.384 273.92-2.368 31.104-0.768 78.976 4.864 143.744-20.416-21.056-98.304-96.64-233.792-226.944l66.112-80.064 73.856 74.048C235.328 252.736 384.128 128 561.536 128z"  ></path><path d="M469.312 341.312h85.312v256H469.312z"  ></path><path d="M682.688 512l0 85.376-213.312 0L469.376 512z"  ></path></symbol><symbol id="tingwu-vector" viewBox="0 0 1160 1024"><path d="M631.1936 742.6048H517.461333V230.263467h113.800534V2.525867l512.341333 483.9424-512.341333 483.805866v-227.669333z m-455.338667-512.341333H5.051733v341.538133a170.8032 170.8032 0 0 0 170.8032 170.8032V230.263467z m227.669334 0H289.655467v512.341333H403.456V230.263467z"  ></path></symbol><symbol id="tingwu-warn" viewBox="0 0 1024 1024"><path d="M532.058353 50.176a481.882353 481.882353 0 1 1 0 963.764706 481.882353 481.882353 0 0 1 0-963.764706z m0 87.642353a394.24 394.24 0 1 0 0 788.48 394.24 394.24 0 0 0 0-788.48z m0 175.224471c24.214588 0 43.851294 19.636706 43.851294 43.791058v219.075765a43.791059 43.791059 0 1 1-87.642353 0V356.833882c0-24.154353 19.636706-43.791059 43.791059-43.791058z m0 350.448941a43.791059 43.791059 0 1 1 0 87.642353 43.791059 43.791059 0 0 1 0-87.642353z"  ></path></symbol><symbol id="tingwu-prev" viewBox="0 0 1126 1024"><path d="M1029.053112 62.628889c17.816442 24.983976 27.339023 54.882833 27.339023 85.703229v686.444981a148.265563 148.265563 0 0 1-233.866399 120.92654l-527.325724-373.53092a111.199172 111.199172 0 0 1 0-181.23622L822.525736 27.200792A148.265563 148.265563 0 0 1 1029.053112 62.526496v0.102393zM81.914676 47.884248a81.914676 81.914676 0 0 1 81.300315 72.289701l0.61436 9.624974 0.92154 737.23208a81.914676 81.914676 0 0 1-163.317384 9.727368L1.023933 867.031003 0 129.798923a81.914676 81.914676 0 0 1 81.914676-81.914675z"  ></path></symbol><symbol id="tingwu-upload_close" viewBox="0 0 1024 1024"><path d="M512 128a384 384 0 1 1 0 768 384 384 0 0 1 0-768z m143.53 180.139L512 451.669 368.47 308.14l-60.331 60.33L451.669 512 308.14 655.53l60.33 60.331L512 572.331l143.53 143.53 60.331-60.33L572.331 512l143.53-143.53-60.33-60.331z"  ></path></symbol><symbol id="tingwu-translate-arrows" viewBox="0 0 1024 1024"><path d="M626.7392 645.4272l57.2416-70.144-474.112 0 0-87.808 474.112 0-57.2416-65.792 60.416-49.1008 137.0624 158.7712-137.0624 160.5632z"  ></path></symbol><symbol id="tingwu-nav-verify" viewBox="0 0 1024 1024"><path d="M918.588235 245.338353a67.282824 67.282824 0 0 0-51.621647-59.873882 1176.816941 1176.816941 0 0 1-167.03247-40.116706c-53.609412-22.889412-103.785412-53.549176-149.202824-90.955294a65.957647 65.957647 0 0 0-79.751529 0 387.794824 387.794824 0 0 1-150.347294 90.352941c-51.802353 22.407529-106.616471 36.502588-162.394353 41.923764-28.491294 4.818824-49.814588 29.816471-51.07953 59.873883 0 0-1.746824 150.287059-1.746823 282.563765 0 239.495529 270.817882 471.220706 406.287059 471.220705 135.469176 0 365.025882-163.478588 401.769411-467.606588 9.155765-179.621647 2.770824-286.72 2.770824-286.72l2.349176-0.662588z m-147.456 184.982588l-282.985411 278.40753a37.225412 37.225412 0 0 1-46.98353 4.818823l-7.469176-6.625882-156.129883-169.381647a41.923765 41.923765 0 0 1 2.288941-57.464471 37.888 37.888 0 0 1 55.115295 2.409412l128.542117 140.649412 254.795294-251.482353a37.827765 37.827765 0 0 1 38.068706-8.854589c13.251765 4.336941 23.371294 15.721412 26.383059 29.936942a41.803294 41.803294 0 0 1-11.625412 38.791529v-1.204706z"  ></path></symbol><symbol id="tingwu-mark-schedule" viewBox="0 0 1024 1024"><path d="M533.824 0v136.512H136.512v591.68a159.36 159.36 0 0 0 146.24 158.72l13.056 0.576 591.68-0.064V570.432H1024v385.28c0 34.56-25.664 63.168-59.008 67.648l-9.28 0.64H295.872a295.808 295.808 0 0 1-295.424-279.04L0 728.192V68.352C0 33.728 25.664 5.12 59.008 0.64L68.288 0 533.76 0z m360.64 101.44l94.848 98.176-499.264 482.112-245.056-253.696 98.24-94.848 150.144 155.52 401.088-387.264z"  ></path></symbol><symbol id="tingwu-recycler" viewBox="0 0 1024 1024"><path d="M640 725.312H554.688v-256H640v256z m-170.688-256H384v213.376c0 23.552 19.072 42.624 42.688 42.624h42.624v-256zM128 256v85.312h85.312V768a128 128 0 0 0 128 128h469.376V341.312H896V256H128z m512-128H384v85.312h256V128z"  ></path></symbol><symbol id="tingwu-warning" viewBox="0 0 1024 1024"><path d="M522.059294 1003.941647a481.882353 481.882353 0 1 0 0-963.764706 481.882353 481.882353 0 0 0 0 963.764706z m-48.188235-722.823529h96.37647v289.129411h-96.37647v-289.129411z m0 385.505882h96.37647v96.376471h-96.37647v-96.376471z"  ></path></symbol><symbol id="tingwu-replace1" viewBox="0 0 1210 1024"><path d="M132.840727 436.224l1.396364-157.602909h614.306909c-43.752727-38.912-87.505455-77.824-131.351273-116.549818L707.304727 52.875636l242.036364 225.559273a38.167273 38.167273 0 0 0-0.372364 0.186182l173.242182 157.602909H132.840727zM1064.029091 634.88l-1.396364 157.602909h-614.4c43.752727 38.912 87.598545 77.730909 131.537455 116.363636l-90.205091 109.381819-242.036364-225.559273a38.446545 38.446545 0 0 0 0.372364-0.186182L74.752 634.786909H1064.029091z"  ></path></symbol><symbol id="tingwu-setting" viewBox="0 0 1024 1024"><path d="M687.585882 47.465412l150.588236 89.630117c26.864941 15.962353 36.141176 51.440941 20.660706 79.028706a106.977882 106.977882 0 0 0 0 105.411765c18.492235 33.008941 51.742118 52.645647 88.726588 52.645647 30.960941 0 56.259765 25.901176 56.259764 57.946353v179.2c0 31.804235-25.298824 57.825882-56.259764 57.825882-37.104941 0-70.234353 19.696941-88.726588 52.705883a106.977882 106.977882 0 0 0 0 105.411764 58.789647 58.789647 0 0 1-20.660706 79.028706l-150.588236 89.509647a55.476706 55.476706 0 0 1-76.8-21.082353 100.894118 100.894118 0 1 0-177.513411-0.12047 55.898353 55.898353 0 0 1-48.790589 28.912941 54.814118 54.814118 0 0 1-27.949176-7.710118l-150.829177-89.509647a57.223529 57.223529 0 0 1-26.262588-35.117176 58.428235 58.428235 0 0 1 5.601883-43.971765 106.977882 106.977882 0 0 0 0-105.351529A101.014588 101.014588 0 0 0 96.376471 669.214118c-30.960941 0-56.259765-26.021647-56.259765-57.886118V432.067765c0-31.804235 25.298824-57.825882 56.259765-57.825883 36.984471 0 70.234353-19.696941 88.726588-52.705882a106.977882 106.977882 0 0 0 0-105.411765 58.669176 58.669176 0 0 1 20.60047-78.908235L356.412235 47.585882a55.296 55.296 0 0 1 76.8 21.202824 101.014588 101.014588 0 0 0 177.453177 0 55.416471 55.416471 0 0 1 76.92047-21.323294z m-165.647058 265.396706a208.835765 208.835765 0 1 0 0 417.671529 208.835765 208.835765 0 0 0 0-417.671529z m0 96.37647a112.459294 112.459294 0 1 1 0 224.918588 112.459294 112.459294 0 0 1 0-224.918588z"  ></path></symbol><symbol id="tingwu-stop" viewBox="0 0 1024 1024"><path d="M300.363926 188.822075a68.265392 68.265392 0 0 1-8.191847 96.185938 341.326962 341.326962 0 1 0 441.199231 1.365308 68.265392 68.265392 0 0 1 88.608479-103.899927 477.857747 477.857747 0 1 1-617.801801-1.843166 68.265392 68.265392 0 0 1 96.254204 8.191847zM513.010624 0a68.265392 68.265392 0 0 1 67.787534 60.278341L581.276016 68.265392v409.592355a68.265392 68.265392 0 0 1-136.052927 7.987051L444.745231 477.857747V68.265392a68.265392 68.265392 0 0 1 68.265393-68.265392z"  ></path></symbol><symbol id="tingwu-voice" viewBox="0 0 1170 1024"><path d="M585.142857 77.897143v804.571428c0 71.68-32.475429 87.405714-73.142857 73.142858l-292.571429-219.428572H73.142857a73.142857 73.142857 0 0 1-73.142857-73.142857v-365.714286a73.142857 73.142857 0 0 1 73.142857-73.142857h146.285714l292.571429-219.428571c40.374857-14.189714 73.142857 1.755429 73.142857 73.142857z m398.555429 56.758857c165.814857 178.395429 165.814857 483.474286 0 661.942857a54.857143 54.857143 0 1 1-80.384-74.752c126.683429-136.265143 126.683429-376.173714 0-512.512a54.857143 54.857143 0 0 1 80.384-74.678857z m-211.382857 110.08c117.101714 125.952 117.101714 340.260571 0 466.212571a54.857143 54.857143 0 0 1-80.310858-74.752c77.970286-83.821714 77.970286-232.886857 0-316.708571a54.857143 54.857143 0 1 1 80.310858-74.752z"  ></path></symbol><symbol id="tingwu-favorites" viewBox="0 0 1024 1024"><path d="M652.8 346.496l226.816 34.176a42.88 42.88 0 0 1 23.68 72.896l-0.32 0.32-163.072 160.64 37.504 225.856 0.128 0.512a42.752 42.752 0 0 1-61.888 44.992L511.936 780.16l-203.712 105.728a42.752 42.752 0 0 1-61.888-44.928v-0.192l37.632-226.24-155.52-153.984L121.6 453.76a42.88 42.88 0 0 1 23.68-73.088l225.728-34.24 102.4-204.8a43.072 43.072 0 0 1 77.056 0v0.192l102.4 204.608z"  ></path></symbol><symbol id="tingwu-play-filled2" viewBox="0 0 1024 1024"><path d="M527.058824 45.176471a481.882353 481.882353 0 1 1 0 963.764705 481.882353 481.882353 0 0 1 0-963.764705z m-54.573177 277.684705a60.235294 60.235294 0 0 0-60.235294 60.235295v309.187764a60.235294 60.235294 0 0 0 95.051294 49.152l218.232471-154.624a60.235294 60.235294 0 0 0 0-98.304L507.301647 333.944471a60.235294 60.235294 0 0 0-34.816-11.083295z"  ></path></symbol><symbol id="tingwu-add2" viewBox="0 0 1024 1024"><path d="M512 1024A512 512 0 1 1 512 0a512 512 0 0 1 0 1024z m-42.688-554.688H256a42.688 42.688 0 0 0 0 85.376h213.312V768a42.688 42.688 0 0 0 85.376 0V554.688H768a42.688 42.688 0 0 0 0-85.376H554.688V256a42.688 42.688 0 0 0-85.376 0v213.312z"  ></path></symbol><symbol id="tingwu-add" viewBox="0 0 1024 1024"><path d="M957.096367 578.743657H578.775657v378.448694a66.743657 66.743657 0 0 1-133.615298 0V578.743657H66.839649a66.743657 66.743657 0 1 1 0-133.487314h378.32071V66.807649a66.807649 66.807649 0 0 1 133.615298 0v378.448694h378.32071a66.743657 66.743657 0 1 1 0 133.487314z"  ></path></symbol><symbol id="tingwu-alls" viewBox="0 0 1024 1024"><path d="M512 0a512 512 0 1 1 0 1024A512 512 0 0 1 512 0zM279.424 439.04a72.96 72.96 0 1 0 0 145.92 72.96 72.96 0 0 0 0-145.92zM512 439.04a72.96 72.96 0 1 0 0 145.92 72.96 72.96 0 0 0 0-145.92z m232.832 0a72.96 72.96 0 1 0 0 145.92 72.96 72.96 0 0 0 0-145.92z"  ></path></symbol><symbol id="tingwu-arrow-down2" viewBox="0 0 1024 1024"><path d="M128.384 300.16c0 9.6 3.2 19.264 9.6 27.392l340.864 423.744a43.712 43.712 0 0 0 68.16 0l339.072-421.952a43.712 43.712 0 0 0-68.096-54.72l-305.088 379.584-306.816-381.44a43.712 43.712 0 0 0-77.696 27.328z"  ></path></symbol><symbol id="tingwu-add3" viewBox="0 0 1024 1024"><path d="M435.84 1024h153.6V583.168H1024v-153.6H589.44V0h-153.6v429.568H0v153.6h435.84z"  ></path></symbol><symbol id="tingwu-arrow-right" viewBox="0 0 1024 1024"><path d="M300.736 781.824L398.272 875.008 714.112 558.72a60.352 60.352 0 0 0 0.256-85.568l-0.96-0.96-315.136-315.136-97.536 93.888L552.064 490.624a36.16 36.16 0 0 1 0 50.752l-251.328 240.384z"  ></path></symbol><symbol id="tingwu-alibaba" viewBox="0 0 1925 1024"><path d="M1155.066 867.157c278.186-18.176 534.186-116.992 770.26-220.33-161.834 110.165-983.04 529.237-988.586 244.181 1.067-35.2 15.53-73.813 44.33-115.84 25.473-40.875 62.038-81.792 98.604-126.08 56.576-66.987 196.18-222.592 243.84-319.147 8.874-18.133 14.42-35.2 16.64-49.92 5.546-86.314-101.974-120.405-261.547-165.845l-31.019 19.285 59.862 50.006c-269.398 48.853-431.147 99.968-627.328 170.41l27.733 71.51-98.688 98.816c16.64 3.413 188.416 62.464 365.781-64.726l1.067-1.152 2.219-2.261c-5.547-9.045-16.64-19.328-32.128-31.787 53.205 3.414 85.333 51.115 79.786 99.926H802.64c1.067-17.067-3.328-32.939-7.765-45.44-137.43 104.533-298.155 118.144-434.475 69.248V670.72c-67.627 23.85-182.87 98.816-182.87 170.368 4.438 35.2 21.035 47.701 37.675 56.747 150.742 87.466 558.635-31.787 557.483-31.787-146.261 77.227-291.456 138.581-506.453 147.627C-18.652 1008-59.612 813.824 72.27 611.669c127.445-204.501 328.021-386.176 648.277-502.058 93.184-34.091 229.547-71.552 361.43-74.966 189.44 0 373.46 57.942 361.258 245.334-8.874 144.213-206.165 341.845-312.576 487.253-46.506 62.464-54.272 105.6 24.406 99.925z m179.626-655.36c43.52 17.067 55.979 36.352 43.52 56.747 12.502-22.656 0-41.984-43.52-56.747z"  ></path></symbol><symbol id="tingwu-checkbox0" viewBox="0 0 1024 1024"><path d="M916.48 43.633778c26.453333 0 48.298667 19.911111 51.256889 45.624889l0.341333 6.030222V921.6c0 26.510222-19.911111 48.355556-45.624889 51.313778l-5.973333 0.341333H193.422222A154.965333 154.965333 0 0 1 38.684444 827.733333l-0.284444-9.443555V95.288889c0-26.510222 19.911111-48.355556 45.624889-51.313778l6.030222-0.341333H916.48z m-51.655111 103.310222H141.767111v671.402667l0.284445 6.030222a51.655111 51.655111 0 0 0 51.313777 45.624889h671.459556V146.944z"  ></path></symbol><symbol id="tingwu-back" viewBox="0 0 1024 1024"><path d="M723.264 242.176L625.728 148.992 309.888 465.28a60.352 60.352 0 0 0-0.256 85.568l0.96 0.96 315.136 315.136 97.536-93.888L471.936 533.376a36.16 36.16 0 0 1 0-50.752l251.328-240.384z"  ></path></symbol><symbol id="tingwu-arrow-down" viewBox="0 0 1024 1024"><path d="M242.176 300.736L148.992 398.272 465.28 714.112a60.352 60.352 0 0 0 85.568 0.256l0.96-0.96 315.136-315.136-93.888-97.536L533.376 552.064a36.16 36.16 0 0 1-50.752 0l-240.384-251.328z"  ></path></symbol><symbol id="tingwu-cancel-token" viewBox="0 0 1024 1024"><path d="M149.961598 149.961597a511.98688 511.98688 0 1 1 724.077445 724.077446A511.98688 511.98688 0 0 1 149.961598 149.961597z m49.022743 139.516425a384.118157 384.118157 0 0 0 535.474279 535.666274l-535.474279-535.666274z m584.561021-49.022744a384.118157 384.118157 0 0 0-494.06734-41.406939l535.474279 535.538277a384.118157 384.118157 0 0 0-41.406939-494.067339z"  ></path></symbol><symbol id="tingwu-checkbox" viewBox="0 0 1024 1024"><path d="M817.408 158.912c19.84 0 36.224 14.912 38.464 34.176l0.32 4.544v619.776c0 19.84-14.976 36.224-34.24 38.464l-4.48 0.32H275.072a116.224 116.224 0 0 1-116.032-109.184l-0.192-7.04V197.568c0-19.84 14.912-36.224 34.176-38.464l4.544-0.256h619.776zM645.632 342.464L446.72 541.248 365.12 459.776l-62.528 63.168L448.896 669.248l260.672-260.608-64-66.176z"  ></path></symbol><symbol id="tingwu-avatar" viewBox="0 0 1024 1024"><path d="M512 51.2a460.8 460.8 0 0 1 306.752 804.672l10.624-9.792a464 464 0 0 1-85.952 64.448l-1.216 0.704-4.992 2.88a459.904 459.904 0 0 1-204.48 58.24A467.968 467.968 0 0 1 512 972.8h-0.256l-13.312-0.192h-1.664L512 972.8a468.672 468.672 0 0 1-115.648-14.656 457.152 457.152 0 0 1-180.032-92.672A460.8 460.8 0 0 1 512 51.2zM512 128a384 384 0 0 0-291.072 634.432A322.432 322.432 0 0 1 395.456 599.68 481.088 481.088 0 0 0 512 647.296c45.568-11.072 85.056-26.752 118.464-46.976a322.944 322.944 0 0 1 172.672 162.048A384 384 0 0 0 512 128z m0 98.752c80.768 0 146.304 78.592 146.304 175.552S592.768 577.856 512 577.856 365.696 499.2 365.696 402.304 431.232 226.752 512 226.752z"  ></path></symbol><symbol id="tingwu-check-outlined" viewBox="0 0 1024 1024"><path d="M257.984 457.856A49.92 49.92 0 0 1 324.48 453.12l5.12 4.672 107.264 109.44 250.624-255.488a49.92 49.92 0 0 1 66.368-4.608l5.12 4.608c17.92 18.24 19.84 47.168 4.544 67.776l-4.48 5.248-286.272 292.032a49.92 49.92 0 0 1-66.368 4.608l-5.184-4.608L257.92 530.88a52.352 52.352 0 0 1 0-72.96v-0.064z"  ></path></symbol><symbol id="tingwu-close" viewBox="0 0 1024 1024"><path d="M0 891.136L132.992 1024l381.76-381.312 376.256 375.872L1024 885.696l-376.32-375.872 372.032-371.52L886.72 5.44 514.752 377.024 137.28 0 4.288 132.864l377.408 376.96z"  ></path></symbol><symbol id="tingwu-checkbox1" viewBox="0 0 1024 1024"><path d="M817.408 158.912c19.84 0 36.224 14.912 38.464 34.176l0.32 4.544v619.776c0 19.84-14.976 36.224-34.24 38.464l-4.48 0.32H275.072a116.224 116.224 0 0 1-116.032-109.184l-0.192-7.04V197.568c0-19.84 14.912-36.224 34.176-38.464l4.544-0.256h619.776z m-157.952 309.76H360.768v92.032h298.688V468.672z"  ></path></symbol><symbol id="tingwu-clear" viewBox="0 0 1024 1024"><path d="M512 0a512 512 0 1 1 0 1024A512 512 0 0 1 512 0z m121.024 321.472L512 442.496l-121.024-120.96-72.384 72.32 120.96 121.088-120.96 120.96 72.32 72.448L512 587.328l121.024 121.024 72.384-72.384-120.96-121.024 120.96-121.088-72.32-72.32z"  ></path></symbol><symbol id="tingwu-common-search" viewBox="0 0 1024 1024"><path d="M467.392 0A467.712 467.712 0 0 1 876.8 240.896a463.68 463.68 0 0 1-14.464 473.344l133.568 140.8c37.44 38.592 37.44 99.712 0.128 138.368a100.48 100.48 0 0 1-138.88 5.184l-7.04-6.656-128.64-135.936a468.992 468.992 0 0 1-542.144-24.192A464.192 464.192 0 0 1 25.536 313.664 467.2 467.2 0 0 1 467.392 0z m0 132.992a334.08 334.08 0 0 0-289.152 166.144 331.2 331.2 0 0 0 0 332.416 334.08 334.08 0 0 0 289.152 166.208c184.32 0 333.824-148.8 333.824-332.416 0-183.552-149.504-332.352-333.824-332.352z"  ></path></symbol><symbol id="tingwu-close_fullscreen" viewBox="0 0 1024 1024"><path d="M740.874019 1023.936004a57.27642 57.27642 0 0 1-56.060496-50.55684l-0.511968-7.935504V809.549403c0-71.03556 52.732704-130.231861 121.208424-135.9915l10.87932-0.447972h150.838573a57.404412 57.404412 0 0 1 56.63646 54.524592 58.044372 58.044372 0 0 1-48.95694 61.948128l-7.67952 0.511968h-150.902569a19.006812 19.006812 0 0 0-18.366852 14.975064l-0.511968 4.47972v155.958253c0 32.253984-25.342416 58.492344-56.572464 58.492344z m-450.019874 0a57.27642 57.27642 0 0 1-56.060496-50.55684l-0.511968-7.9995v-155.958253a19.390788 19.390788 0 0 0-14.591088-18.942816l-4.287732-0.511968H64.500292a57.404412 57.404412 0 0 1-56.63646-54.524592 58.044372 58.044372 0 0 1 48.95694-61.948128l7.67952-0.511968h150.902569c68.731704 0 125.944128 54.524592 131.575776 125.304168l0.447972 11.135304v155.958253c0 32.31798-25.342416 58.492344-56.572464 58.492344zM56.756776 351.018061a57.404412 57.404412 0 0 1-56.572464-54.524592 58.044372 58.044372 0 0 1 48.95694-61.948128l7.67952-0.511968h150.838573a19.006812 19.006812 0 0 0 18.366852-15.03906l0.511968-4.47972V58.684332a57.724392 57.724392 0 0 1 52.732704-58.55634 57.084432 57.084432 0 0 1 59.900256 50.55684l0.511968 7.9995v155.894257c0 71.03556-52.732704 130.231861-121.208424 135.9915l-10.815324 0.511968H56.756776z m751.889007 0c-68.731704 0-126.008124-54.460596-131.639772-125.304168l-0.383976-11.1993V58.684332a57.724392 57.724392 0 0 1 52.732704-58.492344 57.084432 57.084432 0 0 1 59.900256 50.55684l0.511968 7.935504v155.894257c0 9.27942 6.207612 17.022936 14.527092 19.006812l4.351728 0.511968h150.902569a57.404412 57.404412 0 0 1 56.572464 54.524592 58.044372 58.044372 0 0 1-48.95694 61.948128l-7.67952 0.511968h-150.838573z"  ></path></symbol><symbol id="tingwu-download" viewBox="0 0 1024 1024"><path d="M284.416 568.896L512 739.584l227.584-170.688H1024V1024H170.496A170.688 170.688 0 0 1 0 853.312V568.96h284.416z m568.96 170.688a56.896 56.896 0 1 0 0 113.728 56.896 56.896 0 0 0 0-113.728zM568.896 0v443.968l85.312-74.24 63.616 78.4L512 625.792 303.872 448.128l60.352-78.336 90.88 74.176V0H568.96z"  ></path></symbol><symbol id="tingwu-change" viewBox="0 0 1024 1024"><path d="M544.154 51.2c10.444 0 20.787 0.41 30.924 1.229l19.661 2.048 17.05 2.867 15.309 3.226 18.33 4.608 13.67 3.942 14.643 4.71 7.629 2.714 15.718 6.042c2.662 1.024 5.376 2.201 8.09 3.379l16.435 7.475c85.965 41.216 182.937 124.058 186.214 288.256v50.483c0 75.264-25.293 145.664-66.048 210.74l-9.011 13.823-11.776 16.384c-17.254 22.836-23.45 51.559-28.98 80.59a173.466 173.466 0 0 0-1.791 45.874l1.485 22.682 0.307 12.083v121.19c0 10.548-18.279 16.077-30.515 17.101l-3.84 0.154H375.962c-10.65 0-39.936-4.608-45.21-14.234l-0.82-3.072-0.05-97.843c-0.359-24.73-3.124-53.401-23.86-57.344l-5.12-0.512h-17.305c-60.57 0-121.14-31.59-126.31-84.992l-0.359-7.373v-80.588c0-15.207-4.198-26.112-17.254-32.256l-5.325-2.1-22.784-5.734c-11.06 0-11.06-17.05-5.53-22.63 40.755-68.813 63.335-126.67 75.11-173.62 0-5.324 5.479-10.854 5.479-22.528C203.93 189.594 354.099 51.2 544.154 51.2z m187.34 451.686H341.197a10.24 10.24 0 0 0-9.421 14.285l1.74 2.765 147.56 166.81 54.783-44.544-51.865-59.7h247.5v-79.616zM589.21 233.728l-54.784 44.544 51.814 59.648H338.79v79.616h390.298a10.24 10.24 0 0 0 9.42-14.234l-1.74-2.764-147.558-166.81z"  ></path></symbol><symbol id="tingwu-control" viewBox="0 0 1024 1024"><path d="M185.024 0v237.056h61.696v128h-61.696V1024H61.696V365.12H0V236.992h61.696V0H184.96z m386.368 0v664.64h61.696v128h-61.696V1024H448v-231.296h-61.568v-128H448V0h123.392z m390.912 0v237.056H1024v128h-61.632V1024H839.04V365.12h-61.696V236.992h61.696V0h123.328z"  ></path></symbol><symbol id="tingwu-del" viewBox="0 0 1088 1024"><path d="M1038.272 170.688v113.728h-113.728V1024H298.752l-10.048-0.256a170.688 170.688 0 0 1-160.32-160.384L128 853.312V284.416H14.272V170.688h1024zM696.96 455.04H583.168v341.312h113.792V455.104z m-227.52 0H355.648v284.48c0 28.8 21.568 53.12 50.24 56.448l6.656 0.384h56.896V455.104zM696.96 0v113.792H355.648V0h341.312z"  ></path></symbol><symbol id="tingwu-collect" viewBox="0 0 1024 1024"><path d="M1021.595811 398.224213a51.513818 51.513818 0 0 0-40.827101-37.115546l-291.16506-54.329481L557.907454 29.436468a50.937887 50.937887 0 0 0-45.434548-29.436468c-19.197696 0-36.795585 11.326641-45.562533 29.436468L336.622008 306.779186l-291.16506 55.865297a51.385834 51.385834 0 0 0-42.682878 36.027676 56.057273 56.057273 0 0 0 12.798464 56.185258l212.454505 206.50322-54.649442 299.484062a55.673319 55.673319 0 0 0 20.477543 52.729672 52.473703 52.473703 0 0 0 53.881534 3.967524l264.288286-137.135544 263.520377 137.135544a48.634164 48.634164 0 0 0 53.75355-3.839539 55.673319 55.673319 0 0 0 20.477543-52.857657l-53.113627-299.484062 210.406751-207.911051a55.673319 55.673319 0 0 0 14.718234-55.161381l-0.255969-0.063992h0.063992z"  ></path></symbol><symbol id="tingwu-dot" viewBox="0 0 1024 1024"><path d="M512 512m-512 0a512 512 0 1 0 1024 0 512 512 0 1 0-1024 0Z"  ></path></symbol><symbol id="tingwu-delete" viewBox="0 0 1088 1024"><path d="M997.12 320l-0.192 631.872c0 39.872-39.168 72.128-87.744 72.128H207.232c-48.512 0-87.808-32.256-87.808-72.128V320h877.76zM435.136 512c-30.336 0-54.848 21.504-54.848 48v160c0 26.496 24.512 48 54.848 48 30.272 0 54.848-21.504 54.848-48v-160c0-26.496-24.576-48-54.848-48z m246.464 0c-30.272 0-54.848 21.504-54.848 48v160c0 26.496 24.576 48 54.848 48 30.336 0 54.848-21.504 54.848-48v-160c0-26.496-24.512-48-54.848-48z m-49.024-512c78.272 0 142.336 52.224 147.968 118.4l0.192 4.544h224.32c36.032 0 65.28 25.28 65.28 56.32 0 31.168-29.248 56.32-65.28 56.32H111.616c-35.776 0.192-65.024-24.96-65.28-56.256 0-31.04 29.248-56.32 65.28-56.32h224.256l0.192-4.48C341.76 52.224 405.824 0 484.032 0h148.48z"  ></path></symbol><symbol id="tingwu-common-edit" viewBox="0 0 1024 1024"><path d="M430.682353 3.975529c35.237647 0.060235 64.331294 28.491294 66.379294 64.813177 2.048 36.382118-23.612235 68.065882-58.608941 72.402823l-7.830588 0.481883h-246.964706c-23.792941 0-43.971765 18.070588-47.164236 42.465882l-0.421647 6.686118v590.125176c0 24.816941 17.889882 45.417412 41.080471 48.670118l6.445176 0.481882h570.729412c24.033882 0 43.971765-18.552471 47.043765-42.465882l0.481882-6.686118V582.656c0-36.382118 27.527529-66.499765 62.644706-68.668235 35.237647-2.108235 65.897412 24.455529 70.053647 60.656941l0.481883 7.951059v198.294588c0 98.785882-74.330353 180.525176-169.743059 186.548706l-10.962824 0.301176H183.597176c-95.533176 0-174.561882-76.860235-180.404705-175.465411l-0.301177-11.324236V190.825412c0-98.785882 74.330353-180.464941 169.682824-186.488471l11.023058-0.361412H430.682353z m238.351059 157.816471l146.672941 147.877647-309.067294 319.126588a33.310118 33.310118 0 0 1-9.336471 6.746353l-5.300706 2.048-190.945882 54.814118-0.060235-0.421647 52.224-197.692235a34.936471 34.936471 0 0 1 4.818823-10.661648l3.794824-4.577882 307.2-317.319529zM791.792941 35.117176a100.111059 100.111059 0 0 1 144.805647 0 108.423529 108.423529 0 0 1 7.107765 141.552942l-7.107765 8.131764-76.197647 78.72753-147.154823-147.33553L791.792941 35.117176z"  ></path></symbol><symbol id="tingwu-copy3" viewBox="0 0 1024 1024"><path d="M245.880471 12.408471v722.823529c0 26.624 26.985412 48.188235 60.235294 48.188235h662.588235V233.351529L692.525176 12.408471H245.880471z m-60.235295 867.388235h481.882353v96.37647h-481.882353c-99.749647 0-180.705882-64.692706-180.705882-144.564705v-578.258824h120.470588v578.258824c0 26.624 26.925176 48.188235 60.235294 48.188235z"  ></path></symbol><symbol id="tingwu-copy4" viewBox="0 0 1024 1024"><path d="M718.426353 27.828706l276.239059 220.943059v742.821647h-783.058824c-95.653647 0-174.682353-59.632941-180.34447-136.07153l-0.361412-8.493176V27.828706h687.525647zM491.339294 293.345882v102.038589H414.72v229.556705h76.619294v102.098824l304.308706-216.847059-304.308706-216.847059z m-158.418823 103.002353H240.880941v231.424h91.979294V396.348235z"  ></path></symbol><symbol id="tingwu-close2" viewBox="0 0 1024 1024"><path d="M138.016381 18.387625l8.124511 7.036978L512.063774 391.411458l365.922882-365.922882a85.275385 85.275385 0 0 1 127.753146 112.591656l-7.036978 7.996566L632.588024 511.99968l365.986855 365.922882a85.275385 85.275385 0 0 1-112.527684 127.689173l-8.124511-7.036978L512.063774 632.587903l-365.922882 365.922881a85.275385 85.275385 0 0 1-127.753146-112.591656l7.036979-7.996566L391.411579 511.99968 25.488698 146.076798A85.275385 85.275385 0 0 1 138.080353 18.323652z"  ></path></symbol><symbol id="tingwu-exit-fullscreen-icon" viewBox="0 0 1024 1024"><path d="M1024 625.792v113.792h-284.416V1024H625.792V625.792H1024zM398.4 625.28v398.272H284.608v-284.48H0.192V625.344h398.208V625.28zM398.208 0v398.208H0V284.416h284.416V0h113.792z m341.376 0v284.416H1024v113.792H625.792V0h113.792z"  ></path></symbol><symbol id="tingwu-finishNew" viewBox="0 0 1024 1024"><path d="M660.336299 89.975467a455.338667 455.338667 0 0 1-170.666667 877.1584 455.133867 455.133867 0 0 1-170.666667-877.1584v477.184c0 30.173867 22.7328 55.022933 52.155734 58.231466l6.417066 0.341334h226.986667l6.485333-0.4096a55.773867 55.773867 0 0 0 48.878934-48.878934l0.341333-6.485333 0.068267-480.0512v0.068267zM546.535765 0v512H432.803499V0h113.732266z"  ></path></symbol><symbol id="tingwu-edits" viewBox="0 0 1024 1024"><path d="M498.507294 180.525176l310.211765 311.296-385.144471 412.310589h449.957647v115.230117H21.624471v-0.060235H17.889882l1.385412-322.258823 479.232-516.517648zM786.672941 98.183529l7.710118 7.830589 187.331765 200.764235L874.616471 421.044706 564.224 109.568l3.373176-3.614118c59.632941-64.030118 155.467294-67.463529 219.01553-7.830588z"  ></path></symbol><symbol id="tingwu-exit" viewBox="0 0 1024 1024"><path d="M993.882353 30.117647v963.764706H190.765176l-9.456941-0.240941A160.647529 160.647529 0 0 1 30.358588 842.691765L30.117647 833.234824V30.117647h963.764706zM458.450824 137.216H137.216v696.018824l0.361412 6.26447c2.891294 24.636235 22.287059 43.971765 46.923294 46.923294l6.26447 0.361412H458.390588v-107.098353H244.314353V244.314353H458.390588V137.216z m160.828235 133.842824L543.563294 346.774588l107.098353 107.098353H351.593412v107.038118h299.068235l-107.098353 116.314353 75.715765 75.715764 236.363294-245.519058L619.218824 271.058824z"  ></path></symbol><symbol id="tingwu-feedback2" viewBox="0 0 1024 1024"><path d="M258.60992 67.2A512.128 512.128 0 0 0 0.24192 503.68c-1.472 88.832 11.072 172.864 53.76 250.88L34.67392 921.984a60.928 60.928 0 0 0 67.584 67.584h0.192l167.296-19.456c68.48 37.568 140.672 49.728 218.688 53.312a512.128 512.128 0 0 0 428.352-825.28A512.064 512.064 0 0 0 258.67392 67.2zM307.31392 358.4h409.6v102.4h-409.6V358.4z m0 204.8h409.6v102.4h-358.4a51.2 51.2 0 0 1-51.2-51.2v-51.2z"  ></path></symbol><symbol id="tingwu-question" viewBox="0 0 1024 1024"><path d="M522.059294 40.176941a481.882353 481.882353 0 1 1 0 963.764706 481.882353 481.882353 0 0 1 0-963.764706z m48.188235 674.635294h-96.37647v96.376471h96.37647v-96.376471z m-48.188235-481.882353a192.752941 192.752941 0 0 0-192.512 183.115294l-0.240941 9.637648h96.376471a96.376471 96.376471 0 1 1 103.604705 96.135529l-7.228235 0.240941h-48.188235v121.072941h96.37647v-30.780235a192.873412 192.873412 0 0 0-48.188235-379.482353z"  ></path></symbol><symbol id="tingwu-fullscreen-icon" viewBox="0 0 1024 1024"><path d="M113.792 625.792v203.904l194.176-194.112 80.448 80.448-194.24 194.176h204.032V1024H170.688A170.688 170.688 0 0 1 0 853.312V625.792h113.792z m910.208 0V1024H625.792v-113.792h203.968l-194.176-194.176 80.448-80.448 194.176 194.176V625.792H1024zM398.208 0v113.792H194.24l194.176 194.176L307.968 388.48 113.792 194.24v203.968H0V0h398.208zM1024 0v398.208h-113.792V194.176l-194.176 194.24L635.52 307.968l194.112-194.176H625.792V0H1024z"  ></path></symbol><symbol id="tingwu-end" viewBox="0 0 1024 1024"><path d="M340.288 190.592v168.64a245.312 245.312 0 1 0 341.376-0.448V190.592a384 384 0 1 1-341.376 0z m235.008-82.56V577.28h-128V107.968h128z"  ></path></symbol><symbol id="tingwu-copy" viewBox="0 0 1024 1024"><path d="M692.032 0c26.88 0 52.736 9.92 71.936 27.648l229.568 212.352c19.52 18.048 30.464 42.688 30.464 68.352V896c0 33.92-14.4 66.56-40 90.496-25.6 24-60.352 37.504-96.512 37.504H136.512c-36.16 0-70.912-13.44-96.512-37.504A124.096 124.096 0 0 1 0 896V128C0 57.28 61.12 0 136.512 0h555.52zM364.8 264.128a39.232 39.232 0 0 0-26.816 10.368 34.432 34.432 0 0 0-11.136 25.152v134.144H191.168c-10.496 0-18.944 7.936-19.008 17.728v106.688c0 9.792 8.448 17.728 19.008 17.728h135.808v134.144c0 14.08 8.768 26.752 22.4 32.512 13.632 5.76 29.632 3.392 40.768-5.952l246.08-205.12 3.2-2.944a34.176 34.176 0 0 0-3.2-50.24L390.08 273.152a39.36 39.36 0 0 0-25.28-8.96l0.064-0.064zM665.6 334.912a35.776 35.776 0 0 0-43.264 6.08l-3.648 4.672a30.592 30.592 0 0 0 6.464 40.512l139.968 116.672-139.968 116.48-4.224 4.288a30.592 30.592 0 0 0 3.712 42.88c12.8 11.328 32.64 11.584 45.888 0.704l149.312-124.416 3.392-3.072 5.056-6.08a51.2 51.2 0 0 0-8.448-70.848l-149.312-124.416-4.928-3.456z"  ></path></symbol><symbol id="tingwu-bars" viewBox="0 0 1024 1024"><path d="M51.072 306.688c28.16 0 51.008 22.08 51.008 49.408v429.824c0 71.808 55.68 130.688 126.336 135.68l9.728 0.384h430.08c27.328 0 49.536 22.848 49.536 51.008 0 28.16-22.208 51.008-49.536 51.008h-464A204.16 204.16 0 0 1 0 819.968V356.16c0-27.392 22.848-49.472 51.072-49.472zM887.872 0C963.072 0 1024 60.928 1024 136v544.256a136.064 136.064 0 0 1-136.128 136.064H343.424a136.064 136.064 0 0 1-136.128-136.064V136C207.296 60.928 268.224 0 343.424 0h544.448z m-128.768 213.888l-4.736 5.12-180.544 269.44-99.904-90.88-5.696-4.928a51.072 51.072 0 0 0-72.256 70.464l4.864 5.76 139.904 131.84 5.632 4.864a51.072 51.072 0 0 0 65.28-2.88l5.12-5.44 216.704-313.728 4.352-6.208a51.008 51.008 0 0 0-78.72-63.36z"  ></path></symbol><symbol id="tingwu-folder" viewBox="0 0 1243 1024"><path d="M400.822857 24.356571l143.506286 114.761143h467.456v229.449143h172.178286l-163.181715 574.390857a67.145143 67.145143 0 0 1-58.806857 56.246857l-7.460571 0.438858H208.676571a172.105143 172.105143 0 0 1-171.812571-161.645715L36.571429 827.465143V24.356571h364.251428z m0 114.761143H151.332571V655.36l114.834286-286.72h630.930286V253.805714H544.329143L400.822857 139.190857z"  ></path></symbol><symbol id="tingwu-return-down" viewBox="0 0 1024 1024"><path d="M166.39844 0L0 129.150789l431.99595 377.020466c21.119802 18.687825 49.855533 29.247726 79.871251 29.311725a121.59886 121.59886 0 0 0 80.191248-28.86373l1.663985-1.599985L1023.9904 129.150789 862.455914 0 559.866751 266.301503l-0.127999 0.191999a74.6233 74.6233 0 0 1-94.84711-0.064L166.39844 0z"  ></path><path d="M166.39844 488.50742L0 617.658209l431.99595 377.020466c21.119802 18.687825 49.919532 29.247726 79.871251 29.311725a121.59886 121.59886 0 0 0 80.127249-28.863729l1.791983-1.599985L1023.9904 617.658209l-161.406487-129.150789-302.717162 266.365503-0.127999 0.127999a74.6233 74.6233 0 0 1-94.84711-0.064L166.39844 488.50742z"  ></path></symbol><symbol id="tingwu-hot-words" viewBox="0 0 1024 1024"><path d="M885.458824 42.164706a120.470588 120.470588 0 0 1 120.470588 120.470588v722.82353a120.470588 120.470588 0 0 1-120.470588 120.470588h-722.82353a120.470588 120.470588 0 0 1-120.470588-120.470588v-722.82353a120.470588 120.470588 0 0 1 120.470588-120.470588h722.82353z m-59.452236 180.705882H644.517647l-10.601412 0.301177A180.705882 180.705882 0 0 0 463.811765 403.576471v420.141176l0.421647 7.047529a60.235294 60.235294 0 0 0 120.048941-7.047529V403.576471l0.421647-7.04753A60.235294 60.235294 0 0 1 644.517647 343.341176h181.488941l7.04753-0.421647a60.235294 60.235294 0 0 0-7.04753-120.048941z m-388.939294-0.060235L222.870588 222.870588l-7.047529 0.421647A60.235294 60.235294 0 0 0 222.870588 343.341176h149.985883c6.023529-47.405176 29.515294-89.630118 64.210823-120.530823z"  ></path></symbol><symbol id="tingwu-home" viewBox="0 0 1024 1024"><path d="M896 339.84V896H588.8V629.12H435.2V896H242.368C179.2 896 128 844.8 128 781.632V339.84L512 128l384 211.84z"  ></path></symbol><symbol id="tingwu-participant" viewBox="0 0 1024 1024"><path d="M512 431.346087A215.689968 215.689968 0 1 1 512 0.03415a215.689968 215.689968 0 0 1 0 431.311937z m359.732947 466.045932v71.919989H152.880053v-71.987989a359.459947 359.459947 0 1 1 718.852894 0z"  ></path></symbol><symbol id="tingwu-textarea2" viewBox="0 0 1024 1024"><path d="M645.568 35.2c23.424 0 45.888 9.28 62.592 25.728l199.808 197.248c17.024 16.704 26.56 39.616 26.56 63.424v545.664A118.848 118.848 0 0 1 815.68 986.112H221.376a118.848 118.848 0 0 1-118.848-118.848V154.112c0-65.664 53.184-118.848 118.848-118.848z m66.112 598.4H325.44l-6.016 0.448a44.608 44.608 0 0 0 6.016 88.768h386.304l6.016-0.448a44.608 44.608 0 0 0-6.016-88.704zM537.408 364.672H325.44l-6.016 0.448a44.608 44.608 0 0 0 6.016 88.704h211.968l6.08-0.384a44.608 44.608 0 0 0-6.08-88.768z"  ></path></symbol><symbol id="tingwu-detele" viewBox="0 0 1024 1024"><path d="M512 0a512 512 0 1 1 0 1024A512 512 0 0 1 512 0z m191.36 240.192L512 431.552l-191.36-191.36L240.192 320.64 431.552 512l-191.36 191.36 80.448 80.448L512 592.448l191.36 191.36 80.448-80.448L592.448 512l191.36-191.36-80.448-80.448z"  ></path></symbol><symbol id="tingwu-participant2" viewBox="0 0 1024 1024"><path d="M320 277.333a192 192 0 1 0 384 0 192 192 0 0 0-384 0z m-149.333 576A85.333 85.333 0 0 0 256 938.667h597.333v-85.334c0-170.666-152.832-298.666-341.333-298.666s-341.333 128-341.333 298.666z"  ></path></symbol></svg>', function (h) {
    var l = (l = document.getElementsByTagName("script"))[l.length - 1],
      a = l.getAttribute("data-injectcss"),
      l = l.getAttribute("data-disable-injectsvg");
    if (!l) {
      var t,
        _o,
        i,
        m,
        v,
        s = function s(l, a) {
          a.parentNode.insertBefore(l, a);
        };
      if (a && !h.__iconfont__svg__cssinject__) {
        h.__iconfont__svg__cssinject__ = !0;
        try {
          document.write("<style>.svgfont {display: inline-block;width: 1em;height: 1em;fill: currentColor;vertical-align: -0.1em;font-size:16px;}</style>");
        } catch (l) {
          console && void 0;
        }
      }
      t = function t() {
        var l,
          a = document.createElement("div");
        a.innerHTML = h._iconfont_svg_string_3888402, (a = a.getElementsByTagName("svg")[0]) && (a.setAttribute("aria-hidden", "true"), a.style.position = "absolute", a.style.width = 0, a.style.height = 0, a.style.overflow = "hidden", a = a, (l = document.body).firstChild ? s(a, l.firstChild) : l.appendChild(a));
      }, document.addEventListener ? ~["complete", "loaded", "interactive"].indexOf(document.readyState) ? setTimeout(t, 0) : (_o = function o() {
        document.removeEventListener("DOMContentLoaded", _o, !1), t();
      }, document.addEventListener("DOMContentLoaded", _o, !1)) : document.attachEvent && (i = t, m = h.document, v = !1, p(), m.onreadystatechange = function () {
        "complete" == m.readyState && (m.onreadystatechange = null, d());
      });
    }
    function d() {
      v || (v = !0, i());
    }
    function p() {
      try {
        m.documentElement.doScroll("left");
      } catch (l) {
        return void setTimeout(p, 50);
      }
      d();
    }
  }(window);
};
;// CONCATENATED MODULE: ./node_modules/_@ali_tingwu-icon@0.3.9@@ali/tingwu-icon/dist-web/icon.js


var icon_excluded = ["type", "viewBox", "size", "color", "spin", "rotate", "className"];

var icon_createElement = /*#__PURE__*/_react_18_2_0_react.createElement;


var icon_Icon = /*#__PURE__*/(0,_react_18_2_0_react.memo)(function (props) {
  var type = props.type,
    viewBox = props.viewBox,
    size = props.size,
    color = props.color,
    spin = props.spin,
    _props$rotate = props.rotate,
    rotate = _props$rotate === void 0 ? 0 : _props$rotate,
    _props$className = props.className,
    className = _props$className === void 0 ? '' : _props$className,
    rest = _objectWithoutPropertiesLoose(props, icon_excluded);
  _react_18_2_0_react.useEffect(function () {
    loadIcon();
  }, []);
  return /*#__PURE__*/icon_createElement(IconContainer, extends_extends({
    className: "tingwu-icon " + className,
    size: size
  }, rest), /*#__PURE__*/icon_createElement(IconSvg, {
    className: spin ? 'tingwu-icon-spin' : '',
    viewBox: viewBox,
    fill: color || 'currentColor',
    rotate: rotate,
    "aria-hidden": "true"
  }, /*#__PURE__*/icon_createElement("use", {
    xlinkHref: "#" + type
  })));
});
;// CONCATENATED MODULE: ./node_modules/_@ali_tingwu-component-react@0.3.9@@ali/tingwu-component-react/dist-web/components/tagControlBar/tagControlBar.js

var tagControlBar_createElement = /*#__PURE__*/_react_18_2_0_react.createElement;




/**
 * onClickNail 可选 重点
 * onClickQuestion 可选  问题
 * onClickTodo 可选 代办
 * onClickReset 可选  重置/清空
 * title 可选 显示标题
 * useHover 可选 默认不支持  是否支持hover：放大1.2倍
 * markButtonMarginLeft 可选 默认值8 按钮之间间距
 */

var TagControlBar = /*#__PURE__*/(0,_react_18_2_0_react.memo)(function (props) {
  var onClickNail = props.onClickNail,
    onClickQuestion = props.onClickQuestion,
    onClickTodo = props.onClickTodo,
    onClickReset = props.onClickReset,
    title = props.title,
    _props$tagControlBarS = props.tagControlBarSpaceBetween,
    tagControlBarSpaceBetween = _props$tagControlBarS === void 0 ? 8 : _props$tagControlBarS,
    useHover = props.useHover,
    pid = props.pid;
  var tagControlBars = _react_18_2_0_react.useMemo(function () {
    return [{
      bar: /*#__PURE__*/tagControlBar_createElement(tooltip, {
        title: "\u6807\u8BB0\u4E3A\u91CD\u70B9"
      }, /*#__PURE__*/tagControlBar_createElement(icon_Icon, {
        type: 'tingwu-important',
        size: 16,
        color: '#7DDCFF',
        key: title + "Nail",
        onClick: onClickNail
      })),
      key: title + "Nail"
    }, {
      bar: /*#__PURE__*/tagControlBar_createElement(tooltip, {
        title: "\u6807\u8BB0\u4E3A\u95EE\u9898"
      }, /*#__PURE__*/tagControlBar_createElement(icon_Icon, {
        type: 'tingwu-question',
        size: 17,
        color: '#FF9ECB',
        key: title + "Question",
        onClick: onClickQuestion,
        style: {
          marginLeft: tagControlBarSpaceBetween
        }
      })),
      key: title + "Question"
    }, {
      bar: /*#__PURE__*/tagControlBar_createElement(tooltip, {
        title: "\u6807\u8BB0\u4E3A\u5F85\u529E"
      }, /*#__PURE__*/tagControlBar_createElement(icon_Icon, {
        type: 'tingwu-todo',
        size: 16,
        color: '#FFD600',
        key: title + "Todo",
        onClick: onClickTodo,
        style: {
          marginLeft: tagControlBarSpaceBetween
        }
      })),
      key: title + "Todo",
      tips: '标记为待办'
    }, {
      bar: /*#__PURE__*/tagControlBar_createElement(tooltip, {
        title: "\u53D6\u6D88\u6807\u8BB0"
      }, /*#__PURE__*/tagControlBar_createElement(icon_Icon, {
        type: 'tingwu-cancel1',
        size: 16,
        color: '#CDCDD6',
        key: title + "Reset",
        style: {
          marginLeft: tagControlBarSpaceBetween,
          transform: 'rotate(90deg)'
        },
        onClick: onClickReset,
        "data-e2e-test-id": "trans_paragraphHead_tagReset_button"
      })),
      key: title + "Reset"
    }];
  }, [pid]);
  return /*#__PURE__*/tagControlBar_createElement(styled_Wrapper, null, title ? /*#__PURE__*/tagControlBar_createElement(Title, null, title) : null, /*#__PURE__*/tagControlBar_createElement(styled_Content, null, tagControlBars.map(function (tagControlBarInfo) {
    return useHover ? /*#__PURE__*/tagControlBar_createElement(TagControlBarUseHover, {
      key: "hover" + tagControlBarInfo.key,
      tagControlBar: tagControlBarInfo.bar
    }) : tagControlBarInfo.bar;
  })));
});
;// CONCATENATED MODULE: ./node_modules/_@ali_tingwu-component-react@0.3.9@@ali/tingwu-component-react/dist-web/extensions/chromeExtension/chromeContextMenu/styled.js

var chromeContextMenu_styled_Wrapper = /*#__PURE__*/styled_components_browser_esm.div(["background:#FFFFFF;box-shadow:0 3px 6px -4px rgba(39,38,77,0.12),0 6px 16px 0 rgba(39,38,77,0.08),0 9px 28px 8px rgba(39,38,77,0.05);border-radius:8px;padding:10px 12px;width:148px;height:40px;"]);
;// CONCATENATED MODULE: ./node_modules/_@ali_tingwu-component-react@0.3.9@@ali/tingwu-component-react/dist-web/extensions/chromeExtension/chromeContextMenu/chromeContextMenu.js

var chromeContextMenu_createElement = /*#__PURE__*/_react_18_2_0_react.createElement;


var ChromeContextMenu = /*#__PURE__*/(0,_react_18_2_0_react.memo)(function (props) {
  var controller = props.controller,
    _props$visible = props.visible,
    visible = _props$visible === void 0 ? true : _props$visible,
    currentSelection = props.currentSelection;
  var setParagraphColor = (0,_react_18_2_0_react.useCallback)(function (color) {
    controller.markSelectContents(currentSelection, color);
  }, [controller, currentSelection]);
  var handleClickNail = (0,_react_18_2_0_react.useCallback)(function () {
    setParagraphColor('blue');
  }, [setParagraphColor]);
  var handleClickQuestion = (0,_react_18_2_0_react.useCallback)(function () {
    setParagraphColor('red');
  }, [setParagraphColor]);
  var handleClickTodo = (0,_react_18_2_0_react.useCallback)(function () {
    setParagraphColor('yellow');
  }, [setParagraphColor]);
  var handleClickReset = (0,_react_18_2_0_react.useCallback)(function () {
    setParagraphColor(undefined);
  }, [setParagraphColor]);
  if (!visible) {
    return null;
  }
  return /*#__PURE__*/chromeContextMenu_createElement(chromeContextMenu_styled_Wrapper, null, /*#__PURE__*/chromeContextMenu_createElement(TagControlBar, {
    title: "\u6807\u8BB0\uFF1A",
    onClickNail: handleClickNail,
    onClickQuestion: handleClickQuestion,
    onClickTodo: handleClickTodo,
    onClickReset: handleClickReset,
    useHover: true
  }));
});
;// CONCATENATED MODULE: ./node_modules/_@ali_tingwu-component-react@0.3.9@@ali/tingwu-component-react/dist-web/extensions/chromeExtension/chromeHeadingExtra/chromeHeadingExtra.js

var chromeHeadingExtra_createElement = /*#__PURE__*/_react_18_2_0_react.createElement;

var ChromeHeadingExtra = /*#__PURE__*/(0,_react_18_2_0_react.memo)(function (props) {
  var controller = props.controller,
    pid = props.pid,
    emptyUnfix = props.emptyUnfix,
    _props$visible = props.visible,
    visible = _props$visible === void 0 ? true : _props$visible;
  var setParagraphColor = (0,_react_18_2_0_react.useCallback)(function (color) {
    if (pid) {
      controller.setParagraphMark(pid, color);
    } else if (emptyUnfix) {
      controller.setEmptyUnfixTempParagraphMark(color);
    }
  }, [controller, pid, emptyUnfix]);
  var handleClickNail = (0,_react_18_2_0_react.useCallback)(function () {
    setParagraphColor('blue');
  }, [setParagraphColor]);
  var handleClickQuestion = (0,_react_18_2_0_react.useCallback)(function () {
    setParagraphColor('red');
  }, [setParagraphColor]);
  var handleClickTodo = (0,_react_18_2_0_react.useCallback)(function () {
    setParagraphColor('yellow');
  }, [setParagraphColor]);
  var handleClickReset = (0,_react_18_2_0_react.useCallback)(function () {
    setParagraphColor('');
  }, [setParagraphColor]);
  if (!visible) {
    return null;
  }
  return /*#__PURE__*/chromeHeadingExtra_createElement(TagControlBar, {
    title: "\u6807\u8BB0\uFF1A",
    onClickNail: handleClickNail,
    onClickQuestion: handleClickQuestion,
    onClickTodo: handleClickTodo,
    onClickReset: handleClickReset,
    useHover: true,
    pid: pid
  });
});
;// CONCATENATED MODULE: ./node_modules/_@ali_tingwu-component-react@0.3.9@@ali/tingwu-component-react/dist-web/extensions/chromeExtension/chromeScrollToBottomForNotSticky/styled.js

var styled_Container = /*#__PURE__*/styled_components_browser_esm.div(["width:100%;position:absolute;bottom:20px;text-align:center;pointer-events:none;display:flex;justify-content:center;"]);
var styled_Button = /*#__PURE__*/styled_components_browser_esm.div(["pointer-events:all;height:40px;padding:8px 16px;background:#FFFFFF;box-shadow:0 2px 8px 0 rgba(90,68,151,0.12);border-radius:8px;z-index:200;cursor:pointer;color:#605CE5;font-size:14px;line-height:24px;display:flex;align-items:center;"]);
var IconWrapper = /*#__PURE__*/styled_components_browser_esm.div(["display:flex;justify-content:center;align-items:center;width:20px;height:20px;border-radius:20px;background:#605CE5;margin-right:8px;color:#fff;font-size:12px;"]);
;// CONCATENATED MODULE: ./node_modules/_@ali_tingwu-component-react@0.3.9@@ali/tingwu-component-react/dist-web/extensions/chromeExtension/chromeScrollToBottomForNotSticky/chromeScrollToBottomForNotSticky.js
var _IconWrapper;


var chromeScrollToBottomForNotSticky_createElement = /*#__PURE__*/_react_18_2_0_react.createElement;

var ChromeScrollToBottomForNotSticky = /*#__PURE__*/(0,_react_18_2_0_react.memo)(function (props) {
  var onClick = props.onClick;
  return /*#__PURE__*/chromeScrollToBottomForNotSticky_createElement(styled_Container, null, /*#__PURE__*/chromeScrollToBottomForNotSticky_createElement(styled_Button, {
    onClick: onClick
  }, _IconWrapper || (_IconWrapper = /*#__PURE__*/chromeScrollToBottomForNotSticky_createElement(IconWrapper, null, /*#__PURE__*/chromeScrollToBottomForNotSticky_createElement(icon_Icon, {
    type: 'tingwu-arrow-down',
    size: 14
  }))), "\u56DE\u5230\u6700\u65B0\u5185\u5BB9"));
});
;// CONCATENATED MODULE: ./node_modules/_@ali_tingwu-component-react@0.3.9@@ali/tingwu-component-react/dist-web/extensions/chromeExtension/chromeExtension.js

var _div;


var chromeExtension_createElement = /*#__PURE__*/_react_18_2_0_react.createElement;




var ChromeExtension = /*#__PURE__*/function (_BaseExtension) {
  inheritsLoose_inheritsLoose(ChromeExtension, _BaseExtension);
  function ChromeExtension() {
    return _BaseExtension.apply(this, arguments) || this;
  }
  var _proto = ChromeExtension.prototype;
  _proto.renderParagraphHeadingExtra = function renderParagraphHeadingExtra(params) {
    /**
       * isUnfix 是否为unfix区域，unfix区域默认是显示，不受hover影响
       * isDropdownShowUp 当前ChromeExtension中，划选状态和右上角的标记显示是互斥状态
       * isEditorFocus 是否是编辑状态，（fix区域）编辑状态和右上角的标记显示是互斥状态
       */
    var isMouseEnter = params.isMouseEnter,
      controller = params.controller,
      pid = params.pid,
      emptyUnfix = params.emptyUnfix,
      isUnfix = params.isUnfix,
      isDropdownShowUp = params.isDropdownShowUp,
      isEditorFocus = params.isEditorFocus,
      readonly = params.readonly,
      translateMode = params.translateMode; // 只显示译文时，不显示此内容

    if (translateMode === translateController_TranslateMode.TranslateOnly) {
      return;
    } // 只读状态下，右上角打标

    if (readonly) {
      return;
    } // 如果处于编辑状态，fix区域右上角打标是不会出现的，unfix区域不受影响

    if (isEditorFocus && !isUnfix) {
      return;
    } // mouseEnter 是否是hover状态，fix hover时候右上角出现标记，unfix区域常驻，所以unfix这个值始终为true;

    var mouseEnter = isUnfix ? true : isMouseEnter; // isDropdownShowUp 为true, 表示划选会下拉选择菜单这个时候右上角的标记消失，否则根据mouseEnter决定

    var isVisible = isDropdownShowUp ? false : mouseEnter;
    return /*#__PURE__*/chromeExtension_createElement(ChromeHeadingExtra, {
      visible: isVisible,
      controller: controller,
      pid: pid,
      emptyUnfix: emptyUnfix
    });
  };
  _proto.renderUnfixMask = function renderUnfixMask() {
    return _div || (_div = /*#__PURE__*/chromeExtension_createElement("div", null));
  };
  _proto.renderSelectionContextMenu = function renderSelectionContextMenu(params) {
    var controller = params.controller,
      currentSelection = params.currentSelection;
    return /*#__PURE__*/chromeExtension_createElement(ChromeContextMenu, {
      controller: controller,
      currentSelection: currentSelection
    });
  };
  _proto.getContextMenuSize = function getContextMenuSize() {
    return {
      width: 148,
      height: 40
    };
  };
  _proto.getIsRenderUnfixSpeakerPlaceholder = function getIsRenderUnfixSpeakerPlaceholder() {
    return false;
  };
  _proto.renderScrollToBottomButton = function renderScrollToBottomButton(params) {
    var onScrollToBottom = params.onScrollToBottom,
      isShowingLivingScrollToBottom = params.isShowingLivingScrollToBottom;
    if (!isShowingLivingScrollToBottom) {
      return null;
    }
    return /*#__PURE__*/chromeExtension_createElement(ChromeScrollToBottomForNotSticky, {
      onClick: onScrollToBottom
    });
  };
  return ChromeExtension;
}(BaseExtension);
;// CONCATENATED MODULE: ./src/components/marksGuide/styled.tsx
var styled_templateObject,styled_templateObject2,_templateObject3,_templateObject4,_templateObject5,_templateObject6,_templateObject7;var marksGuide_styled_Content=styled_components_browser_esm.div(styled_templateObject||(styled_templateObject=_taggedTemplateLiteral(["\n  background: rgb(242, 245, 251);\n  padding: 12.5px 16px 6px;\n"])));var styled_GuideBox=styled_components_browser_esm.div(styled_templateObject2||(styled_templateObject2=_taggedTemplateLiteral(["\n  height: 98px;\n  width: 288px;\n  background-color: #ffffff;\n  border: 0.5px solid #dfe3ed;\n  border-radius: 8px;\n  padding: 12px 16px;\n"])));var styled_Header=styled_components_browser_esm.div(_templateObject3||(_templateObject3=_taggedTemplateLiteral(["\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  font-size: 12px;\n  color: #26314d;\n  margin-bottom: 12px;\n  height: 18px;\n"])));var styled_CloseButton=styled_components_browser_esm.div(_templateObject4||(_templateObject4=_taggedTemplateLiteral(["\n  background-image: url(",");\n  background-size: contain;\n  background-repeat: no-repeat;\n  background-position: center center;\n  width: 12px;\n  height: 12px;\n  cursor: pointer;\n  transition: all 0.3s;\n  &:hover {\n    background-image: url(",");\n  }\n\n  &:active {\n    background-image: url(",");\n  }\n"])),chrome.runtime.getURL('closeSmall.svg'),chrome.runtime.getURL('closeHoverSmall.svg'),chrome.runtime.getURL('closeActiveSmall.svg'));var styled_MarksItemWrap=styled_components_browser_esm.div(_templateObject5||(_templateObject5=_taggedTemplateLiteral(["\n  display: flex;\n  flex-wrap: wrap;\n"])));var styled_MarksItem=styled_components_browser_esm.div(_templateObject6||(_templateObject6=_taggedTemplateLiteral(["\n  display: flex;\n  align-items: center;\n  color: rgba(39, 38, 77, 0.65);\n  font-size: 12px;\n  margin: 0 20px 8px 0;\n"])));var styled_MarksImg=styled_components_browser_esm.div(_templateObject7||(_templateObject7=_taggedTemplateLiteral(["\n  background-size: contain;\n  background-repeat: no-repeat;\n  background-position: center center;\n  width: 16px;\n  height: 16px;\n  margin-right: 6px;\n"])));
;// CONCATENATED MODULE: ./src/components/marksGuide/marksGuide.tsx
var marksArr=[{text:"标记为重点内容",src:"".concat(chrome.runtime.getURL("marksGuideBlue.svg"))},{text:"标记为讨论问题",src:"".concat(chrome.runtime.getURL("marksGuideRed.svg"))},{text:"标记为待办事项",src:"".concat(chrome.runtime.getURL("marksGuideYellow.svg"))}];var marksGuide_MarksGuide=/*#__PURE__*/(/* unused pure expression or super */ null && (memo(function(props){var changeMarksGuide=props.changeMarksGuide;var marksGuide=useRecoilValue(marksGuideState);return/*#__PURE__*/_jsx(Content,{style:{display:marksGuide===0?"block":"none"},children:/*#__PURE__*/_jsxs(GuideBox,{children:[/*#__PURE__*/_jsxs(Header,{children:["\u5F55\u97F3\u4E2D\u9009\u4E2D\u6587\u5B57\u968F\u65F6\u6807\u8BB0\u4F60\u7684\u91CD\u8981\u4FE1\u606F",/*#__PURE__*/_jsx(CloseButton,{onClick:function onClick(){return changeMarksGuide();}})]}),/*#__PURE__*/_jsx(MarksItemWrap,{children:marksArr.map(function(item,index){var src=item.src,text=item.text;return/*#__PURE__*/_jsxs(MarksItem,{children:[/*#__PURE__*/_jsx(MarksImg,{style:{backgroundImage:"url(".concat(src,")")}}),text]},+index);})})]})});})));
;// CONCATENATED MODULE: ./src/components/marksGuide/index.ts

;// CONCATENATED MODULE: ./src/components/transContainer/transContainer.tsx
var extensions=[new ChromeExtension()];var theme={transMinWidth:320,transHorizontalPadding:16,transVerticalPadding:10,paragraphHorizontalPadding:12,paragraphVerticalPadding:16,paragraphMarginBottom:16,unfixParagraphContentSticky:false};var transContainer_TransContainer=/*#__PURE__*/(/* unused pure expression or super */ null && (memo(function(props){var controller=props.controller,isExpand=props.isExpand,panelHeight=props.panelHeight;var _useRecoilState=useRecoilState(marksGuideState),_useRecoilState2=_slicedToArray(_useRecoilState,2),marksGuide=_useRecoilState2[0],setMarksGuide=_useRecoilState2[1];var tranStyle=useMemo(function(){return{borderRadius:'0 0 12px 12px',background:'#F2F5FB',// transition: 'all 0.2s',
height:isExpand?panelHeight-75:0// minHeight: isExpand ? 485 : 0,
// maxHeight: 645,
};},[isExpand,panelHeight]);var onEvent=function onEvent(e,transId){if(e==='userEditParagraph'){sendLog('edit_paragraph',{et:'INPUT',c1:transId});}};return/*#__PURE__*/_jsx(Provider,{controller:controller,children:/*#__PURE__*/_jsx(Transcription,{enableSelectAlibabaEmployee:false,enableShowSpeaker:false,enableOfflineEditWordTip:false,extensions:extensions,theme:theme,style:tranStyle,renderBefore:function renderBefore(){return marksGuide===0?/*#__PURE__*/_jsx(MarksGuide,{changeMarksGuide:/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(){return _regeneratorRuntime().wrap(function _callee$(_context){while(1)switch(_context.prev=_context.next){case 0:setMarksGuide(1);_context.next=3;return service.setMarksGuideStatus(1);case 3:case"end":return _context.stop();}},_callee);}))}):null;},onEvent:onEvent})});})));
;// CONCATENATED MODULE: ./src/components/transContainer/index.ts

// EXTERNAL MODULE: ./node_modules/_react-draggable@4.4.5@react-draggable/build/cjs/cjs.js
var cjs = __webpack_require__(1710);
// EXTERNAL MODULE: ./node_modules/_react-resizable@3.0.5@react-resizable/index.js
var _react_resizable_3_0_5_react_resizable = __webpack_require__(3350);
// EXTERNAL MODULE: ./node_modules/_dayjs@1.11.7@dayjs/dayjs.min.js
var dayjs_min = __webpack_require__(8789);
var dayjs_min_default = /*#__PURE__*/__webpack_require__.n(dayjs_min);
// EXTERNAL MODULE: ./node_modules/_dayjs@1.11.7@dayjs/plugin/duration.js
var duration = __webpack_require__(8053);
var duration_default = /*#__PURE__*/__webpack_require__.n(duration);
;// CONCATENATED MODULE: ./src/components/recordControl/styled.tsx
var recordControl_styled_templateObject,recordControl_styled_templateObject2,styled_templateObject3,styled_templateObject4,styled_templateObject5,styled_templateObject6,styled_templateObject7,_templateObject8,_templateObject9,_templateObject10,_templateObject11,_templateObject12;var recordControl_styled_Content=styled_components_browser_esm.div(recordControl_styled_templateObject||(recordControl_styled_templateObject=_taggedTemplateLiteral(["\n  display: flex;\n  width: 100%;\n  height: 75px;\n  min-height: 75px;\n  display: flex;\n  align-items: center;\n  user-select: none;\n\n  .tweant-popover{\n    top: 47px !important;\n    left: 12px !important;\n  }\n"])));var styled_RecordHeading=styled_components_browser_esm.div(recordControl_styled_templateObject2||(recordControl_styled_templateObject2=_taggedTemplateLiteral(["\n  display: flex;\n  align-items: center;\n  margin-left: 17px;\n  flex: 1 1;\n"])));var styled_RecordHeadingText=styled_components_browser_esm.div(styled_templateObject3||(styled_templateObject3=_taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: column;\n  justify-content: center;\n  align-items: flex-start;\n  margin-left: 6px;\n"])));var styled_RecordTitle=styled_components_browser_esm.div(styled_templateObject4||(styled_templateObject4=_taggedTemplateLiteral(["\n  font-size: 14px;\n  color: #27264D;\n  line-height: 14px;\n"])));var styled_RecordDatetime=styled_components_browser_esm.div(styled_templateObject5||(styled_templateObject5=_taggedTemplateLiteral(["\n  margin-top: 4px;\n  font-size: 12px;\n  color: rgba(38,49,77,0.50);\n  line-height: 12px;\n"])));var styled_ControlBox=styled_components_browser_esm.div(styled_templateObject6||(styled_templateObject6=_taggedTemplateLiteral(["\n  display: flex;\n  justify-content: flex-end;\n  align-items: center;\n  margin-right: 23px;\n\n  .tweant-popover{\n    .tweant-popover-arrow{\n      display: none !important;\n    }\n    .tweant-popover-inner{\n      border-radius: 8px !important;\n      box-shadow: 0 3px 6px -4px rgba(39, 38, 77, 0.12),\n    0 6px 16px 0 rgba(39, 38, 77, 0.08), 0 9px 28px 8px rgba(39, 38, 77, 0.05) !important;\n      .tweant-popover-inner-content{\n        padding: 0 !important;\n      }\n    }\n  }\n"])));var styled_StopButton=styled_components_browser_esm.div(styled_templateObject7||(styled_templateObject7=_taggedTemplateLiteral(["\n  background-image: url(",");\n  background-size: contain;\n  width: 16px;\n  height: 16px;\n  cursor: pointer;\n  transition: all 0.3s;\n  &:hover{\n    background-image: url(",");\n  }\n  &:active{\n    background-image: url(",");\n  }\n"])),chrome.runtime.getURL('stopButton.svg'),chrome.runtime.getURL('stopButtonHover.svg'),chrome.runtime.getURL('stopButtonActive.svg'));var styled_RestartButton=styled_components_browser_esm.div(_templateObject8||(_templateObject8=_taggedTemplateLiteral(["\n  background-image: url(",");\n  background-size: contain;\n  background-position: center center;\n  background-repeat: no-repeat;\n  width: 16px;\n  height: 16px;\n  cursor: pointer;\n  margin-left: 12px;\n  transition: all 0.3s;\n  &:hover{\n    background-image: url(",");\n  }\n  &:active{\n    background-image: url(",");\n  }\n"])),chrome.runtime.getURL('restartButton.svg'),chrome.runtime.getURL('restartButtonHover.svg'),chrome.runtime.getURL('restartButtonActive.svg'));var styled_PauseButton=styled_components_browser_esm.div(_templateObject9||(_templateObject9=_taggedTemplateLiteral(["\n  background-image: url(",");\n  background-size: contain;\n  width: 16px;\n  height: 16px;\n  cursor: pointer;\n  margin-left: 12px;\n  transition: all 0.3s;\n  &:hover{\n    background-image: url(",");\n  }\n  &:active{\n    background-image: url(",");\n  }\n"])),chrome.runtime.getURL('pauseButton.svg'),chrome.runtime.getURL('pauseButtonHover.svg'),chrome.runtime.getURL('pauseButtonActive.svg'));var styled_CaptionButton=styled_components_browser_esm.div(_templateObject10||(_templateObject10=_taggedTemplateLiteral(["\n  background-image: url(",");\n  background-size: contain;\n  width: 16px;\n  height: 16px;\n  cursor: pointer;\n  margin-left: 12px;\n  transition: all 0.3s;\n  &:hover{\n    background-image: url(",");\n  }\n  &:active{\n    background-image: url(",");\n  }\n"])),chrome.runtime.getURL('captionButton.svg'),chrome.runtime.getURL('captionButtonHover.svg'),chrome.runtime.getURL('captionButtonActive.svg'));var styled_TranslateButton=styled_components_browser_esm.div(_templateObject11||(_templateObject11=_taggedTemplateLiteral(["\n  background-size: contain;\n  background-position: center center;\n  background-repeat: no-repeat;\n  width: 16px;\n  height: 16px;\n  cursor: pointer;\n  margin-left: 12px;\n  transition: all 0.3s;\n"])));var styled_ExpandButton=styled_components_browser_esm.div(_templateObject12||(_templateObject12=_taggedTemplateLiteral(["\n  background-image: url(",");\n  background-size: contain;\n  background-repeat: no-repeat;\n  background-position: center center;\n  width: 16px;\n  height: 16px;\n  cursor: pointer;\n  margin-left: 12px;\n  transition: all 0.3s;\n  &:hover{\n    background-image: url(",");\n  }\n\n  &:active{\n    background-image: url(",");\n  }\n"])),chrome.runtime.getURL('expandButton.svg'),chrome.runtime.getURL('expandButtonHover.svg'),chrome.runtime.getURL('expandButtonActive.svg'));
;// CONCATENATED MODULE: ./src/components/translatePopWindow/styled.tsx
var translatePopWindow_styled_templateObject,translatePopWindow_styled_templateObject2,translatePopWindow_styled_templateObject3,translatePopWindow_styled_templateObject4,translatePopWindow_styled_templateObject5;var styled_TranslatePopWindowContainer=styled_components_browser_esm.div(translatePopWindow_styled_templateObject||(translatePopWindow_styled_templateObject=_taggedTemplateLiteral(["\n  user-select: none;\n  height: 136px;\n  width: 296px;\n  border-radius: 8px;\n  padding: 16px 0 24px 24px;\n  cursor: default;\n  .translate-title {\n    font-weight: 500;\n    font-size: 18px;\n    color: #27264d;\n    line-height: 28px;\n    display: flex;\n    align-items: center;\n    justify-content: space-between;\n\n    .tweant-switch {\n      scale: 0.75;\n      margin-left: 4.5px;\n    }\n\n    .tweant-switch{\n      background: #D8D7F2 !important;\n    }\n\n    .tweant-switch-checked {\n      background: #605ce5 !important;\n    }\n  }\n  .translate-feedback {\n    display: none;\n  }\n  :hover {\n    .translate-feedback {\n      display: block;\n      color: #7d7d94;\n      cursor: pointer;\n      :hover {\n        color: #605ce5;\n      }\n    }\n  }\n  .translate-item {\n    margin-top: 16px;\n    display: flex;\n    align-items: center;\n    .translate-item-title {\n      font-weight: 400;\n      font-size: 12px;\n      color: rgba(39, 38, 77, 0.65);\n      margin-right: 16px;\n    }\n    .translate-item-des {\n      font-weight: 400;\n      font-size: 12px;\n      color: #27264d;\n      display: flex;\n      align-items: center;\n      .translate-item-des-item {\n        display: flex;\n        align-items: center;\n        cursor: pointer;\n        :hover {\n          color: rgba(39, 38, 77, 0.65);\n        }\n      }\n    }\n    .translate-item-des-unCheck {\n      color: rgba(39, 38, 77, 0.45) !important;\n      cursor: not-allowed !important;\n      .translate-item-des-item {\n        cursor: not-allowed;\n        :hover {\n          color: rgba(39, 38, 77, 0.45) !important;\n        }\n      }\n    }\n    .tweant-select {\n      font-size: 12px;\n      .tweant-select-selector {\n        height: 19px;\n        border: none !important;\n        box-shadow: none !important;\n        padding: 0 14px 0 0;\n        .label_item {\n          height: 19px;\n          line-height: 19px;\n          color: #27264d;\n        }\n      }\n      .tweant-select-arrow {\n        width: 12px;\n        height: 12px;\n        background: url(",")\n          center center no-repeat;\n\n        .anticon {\n          display: none;\n        }\n      }\n      .tweant-select-dropdown {\n        width: 296px !important;\n        height: 104px !important;\n        left: -200px !important;\n        border-radius: 8px !important;\n\n        .rc-virtual-list-holder {\n          max-height: 330px !important;\n          padding: 0 12px;\n        }\n\n        .tweant-select-item-option-active:not(.tweant-select-item-option-disabled) {\n          background: #ffffff;\n        }\n        \n        .tweant-select-item-option-selected:not(.tweant-select-item-option-disabled){\n          color: #605ce5 !important;\n          font-weight: 400 !important;\n          background-color: transparent !important;\n        }\n\n        .tweant-select-item {\n          height: 48px;\n          border-radius: 4px;\n          color: #27264D;\n          &:hover {\n            background: rgba(96, 92, 229, 0.08);\n          }\n          .tweant-select-item-option-content {\n            display: flex;\n            justify-content: space-between;\n            align-items: center;\n          }\n        }\n      }\n    }\n    .tweant-select-open {\n      .tweant-select-selection-item {\n        .label_item {\n          color: #605ce5;\n        }\n      }\n      .tweant-select-arrow {\n        transform: rotate(180deg);\n        background: url(",")\n          center center no-repeat;\n      }\n    }\n  }\n  .caption-translate-title,\n  .caption-translate-item-title,\n  .caption-translate-item-des,\n  .caption-translate-item-des-item {\n    color: #fff !important;\n  }\n\n  .caption-translate-item-des-item:hover {\n    color: rgba(255, 255, 255, 0.85) !important;\n  }\n"])),chrome.runtime.getURL('translateSelectArrow.svg'),chrome.runtime.getURL('translateSelectArrowActive.svg'));var styled_IconTranslateArrows=styled_components_browser_esm.div(translatePopWindow_styled_templateObject2||(translatePopWindow_styled_templateObject2=_taggedTemplateLiteral(["\n  width: 16px;\n  height: 16px;\n  margin: 0 16px;\n  /* background-image: url(","); */\n  background-size: contain;\n  background-repeat: no-repeat;\n  background-position: center center;\n"])),chrome.runtime.getURL('translateArrows.svg'));var IconTranslateDown=styled_components_browser_esm.div(translatePopWindow_styled_templateObject3||(translatePopWindow_styled_templateObject3=_taggedTemplateLiteral(["\n  width: 12px;\n  height: 12px;\n  background-size: contain;\n  background-repeat: no-repeat;\n  background-position: center center;\n"])));var styled_IconTranslateCheck=styled_components_browser_esm.div(translatePopWindow_styled_templateObject4||(translatePopWindow_styled_templateObject4=_taggedTemplateLiteral(["\n  width: 10px;\n  height: 10px;\n  background-size: contain;\n  background-repeat: no-repeat;\n  background-position: center center;\n"])));var styled_SelectIcon=styled_components_browser_esm.img(translatePopWindow_styled_templateObject5||(translatePopWindow_styled_templateObject5=_taggedTemplateLiteral(["\n  width: 16px;\n  height: 16px;\n"])));
;// CONCATENATED MODULE: ./src/components/translatePopWindow/switchView.tsx
var switchView_SwitchView=function SwitchView(_ref){var checked=_ref.checked,defaultChecked=_ref.defaultChecked,onChange=_ref.onChange,setChecked=_ref.setChecked;var _React$useState=React.useState(false),_React$useState2=_slicedToArray(_React$useState,2),check=_React$useState2[0],setCheck=_React$useState2[1];React.useEffect(function(){if(defaultChecked!==undefined){setCheck(defaultChecked);}},[defaultChecked]);var _onChange=function _onChange(_checked){if(onChange){onChange(_checked);}if(setChecked){setChecked(_checked);}else{setCheck(_checked);}};return/*#__PURE__*/_jsx(Switch,{size:"small",checked:checked!==undefined?checked:check,onChange:_onChange});};/* harmony default export */ var switchView = (/*#__PURE__*/(/* unused pure expression or super */ null && (React.memo(switchView_SwitchView,function(props,nextProps){if(props.checked!==nextProps.checked||props.defaultChecked!==nextProps.defaultChecked){return false;}return true;}))));
;// CONCATENATED MODULE: ./src/components/translatePopWindow/radio.tsx
var radio_Radio=function Radio(_ref){var type=_ref.type,style=_ref.style,iconStyle=_ref.iconStyle,changeTranStatus=_ref.changeTranStatus;if(type==="check"){return/*#__PURE__*/_jsx("div",{style:_objectSpread({},style),children:/*#__PURE__*/_jsx(IconTranslateCheck,{style:_objectSpread(_objectSpread({},iconStyle),{},{backgroundImage:"url(".concat(chrome.runtime.getURL('translateRadioCheck.svg'),")")})})});}if(type==="unCheck"){return/*#__PURE__*/_jsx("div",{style:_objectSpread({},style),children:/*#__PURE__*/_jsx(IconTranslateCheck,{style:_objectSpread(_objectSpread({},iconStyle),{},{backgroundImage:"url(".concat(chrome.runtime.getURL('translateRadioUncheck.svg'),")")})})});}return/*#__PURE__*/_jsx("div",{style:_objectSpread({},style),children:/*#__PURE__*/_jsx(IconTranslateCheck,{style:_objectSpread(_objectSpread({},iconStyle),{},{backgroundImage:changeTranStatus?"url(".concat(chrome.runtime.getURL("translateRadioCaption.svg"),")"):"url(".concat(chrome.runtime.getURL("translateRadio.svg"),")")})})});};/* harmony default export */ var translatePopWindow_radio = ((/* unused pure expression or super */ null && (radio_Radio)));
;// CONCATENATED MODULE: ./src/components/translatePopWindow/translatePopWindow.tsx
var targetTransLgOptions=[{title:"中文",value:"cn"},{title:"英文",value:"en"}];var translatePopWindow_TranslatePopWindow=/*#__PURE__*/(/* unused pure expression or super */ null && (memo(function(props){var controller=props.controller,translateSwitch=props.translateSwitch,showLanguage=props.showLanguage,changeTranStatus=props.changeTranStatus,doubleLanguage=props.doubleLanguage,getMeetingContext=props.getMeetingContext;// const [translateSwitch, setTranslateSwitch] = useRecoilState(
//   translateSwitchState
// );
var setTranslateSwitch=useSetRecoilState(translateSwitchState);var sourceLanguage=useRecoilValue(sourceLanguageState);var _useRecoilState=useRecoilState(targetLanguageState),_useRecoilState2=_slicedToArray(_useRecoilState,2),targetLanguage=_useRecoilState2[0],setTargetLanguage=_useRecoilState2[1];// const [showLanguage, setShowLanguage] = useRecoilState(showLanguageState);
var setShowLanguage=useSetRecoilState(showLanguageState);var transId=useRecoilValue(transIdState);useEffect(function(){if(!translateSwitch){controller.setTranslateMode(TranslateMode.Disabled);return;}if(showLanguage===2){controller.setTranslateMode(TranslateMode.OriginAndTranslate);}else{controller.setTranslateMode(TranslateMode.TranslateOnly);}},[translateSwitch,showLanguage]);var getWordBySc=function getWordBySc(sc){return{bt:sc.bt,et:sc.et,si:String(sc.si),tc:sc.txt};};var translateFullDocument=useCallback(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(){var targetLanguage,fixPids,unfixPid,paragraphIds,body,fixedTrans;return _regeneratorRuntime().wrap(function _callee$(_context){while(1)switch(_context.prev=_context.next){case 0:targetLanguage=sourceLanguage==="cn"?"en":"cn";fixPids=controller.getPids();unfixPid=controller.getUnfixPid();paragraphIds=fixPids.filter(function(item){return item!==unfixPid;});_context.next=6;return service.getMeetingHistoryTranslate(Number(getMeetingContext().meetingConfig.meetingId),sourceLanguage,targetLanguage,paragraphIds);case 6:body=_context.sent;fixedTrans=JSON.parse(body.data.translatedParagraph);fixedTrans.pg.forEach(function(resultata){var tsData=resultata.ts.map(function(item){return getWordBySc(item);});controller.setTranslate(resultata.pi,tsData);});case 9:case"end":return _context.stop();}},_callee);})),[]);var onChange=function onChange(check){setTranslateSwitch(check);if(changeTranStatus){changeTranStatus(check);}if(check){var _targetLanguage=sourceLanguage==="cn"?"en":"cn";enableTranslate({controller:controller,meetingContext:getMeetingContext(),targetLanguage:_targetLanguage,translateMode:showLanguage===1?1:0,translateFullDocument:translateFullDocument}).then(function(){message.destroy();if(changeTranStatus){message.config({getContainer:function getContainer(){return document.getElementById("caption_draggable_panel")||document.body;}});}else{message.config({getContainer:function getContainer(){return document.getElementById("main_draggable_panel")||document.body;}});}message.success({content:/*#__PURE__*/_jsx(_Fragment,{children:"\u7FFB\u8BD1\u529F\u80FD\u5DF2\u5F00\u542F"}),duration:3});}).catch(function(){message.destroy();if(changeTranStatus){message.config({getContainer:function getContainer(){return document.getElementById("caption_draggable_panel")||document.body;}});}else{message.config({getContainer:function getContainer(){return document.getElementById("main_draggable_panel")||document.body;}});}message.error({content:/*#__PURE__*/_jsx(_Fragment,{children:"\u7FFB\u8BD1\u5F00\u542F\u5931\u8D25"}),duration:3});});sendLog("turn_on_translate",{et:"CLK",c1:transId,c2:sourceLanguage,c3:_targetLanguage});}else{disableTranslate({controller:controller,meetingContext:getMeetingContext()}).then(function(){message.destroy();if(changeTranStatus){message.config({getContainer:function getContainer(){return document.getElementById("caption_draggable_panel")||document.body;}});}else{message.config({getContainer:function getContainer(){return document.getElementById("main_draggable_panel")||document.body;}});}message.success({content:/*#__PURE__*/_jsx(_Fragment,{children:"\u7FFB\u8BD1\u529F\u80FD\u5DF2\u5173\u95ED"}),duration:3});}).catch(function(){message.destroy();if(changeTranStatus){message.config({getContainer:function getContainer(){return document.getElementById("caption_draggable_panel")||document.body;}});}else{message.config({getContainer:function getContainer(){return document.getElementById("main_draggable_panel")||document.body;}});}message.error({content:/*#__PURE__*/_jsx(_Fragment,{children:"\u7FFB\u8BD1\u5173\u95ED\u5931\u8D25"}),duration:3});});sendLog("turn_off_translate",{et:"CLK",c1:transId});}};return/*#__PURE__*/_jsxs(TranslatePopWindowContainer,{style:{background:changeTranStatus?'radial-gradient(circle at 50% 58%, rgba(24,24,29,0.66) 0%, rgba(22,22,27,0.72) 55%)':'#fff',backdropFilter:changeTranStatus?'blur(10px)':'none'},children:[/*#__PURE__*/_jsx("div",{className:"translate-title ".concat(changeTranStatus&&'caption-translate-title'),children:/*#__PURE__*/_jsxs("div",{className:"translate-title ".concat(changeTranStatus&&'caption-translate-title'),children:[/*#__PURE__*/_jsx("span",{children:"\u7FFB\u8BD1"}),/*#__PURE__*/_jsx(SwitchView,{checked:translateSwitch,onChange:onChange,setChecked:setTranslateSwitch})]})}),/*#__PURE__*/_jsxs("div",{className:"translate-item",children:[/*#__PURE__*/_jsx("span",{className:"translate-item-title ".concat(changeTranStatus&&'caption-translate-item-title'),children:"\u76EE\u6807\u8BED\u8A00"}),/*#__PURE__*/_jsxs("span",{className:"translate-item-des ".concat(changeTranStatus&&'caption-translate-item-des'),children:[sourceLanguage==="cn"&&"中文",sourceLanguage==="en"&&"英语",sourceLanguage==="fspk"&&"中英文自由说"]}),/*#__PURE__*/_jsx(IconTranslateArrows,{style:{backgroundImage:changeTranStatus?"url(".concat(chrome.runtime.getURL('translateArrowsCaption.svg'),")"):"url(".concat(chrome.runtime.getURL('translateArrows.svg'),")")}}),/*#__PURE__*/_jsxs("span",{className:"translate-item-des ".concat(changeTranStatus&&'caption-translate-item-des'),children:[sourceLanguage==="cn"&&"英语",sourceLanguage==="en"&&"中文",sourceLanguage==="fspk"&&/*#__PURE__*/_jsx(Select,{placement:"bottomRight",value:targetLanguage,onChange:setTargetLanguage,getPopupContainer:function getPopupContainer(triggerNode){return triggerNode.parentElement;},children:targetTransLgOptions===null||targetTransLgOptions===void 0?void 0:targetTransLgOptions.map(function(item){var title=item.title,value=item.value;return/*#__PURE__*/_jsxs(Select.Option,{value:value,style:{display:"flex",alignItems:"center",justifyContent:"space-between"},children:[/*#__PURE__*/_jsx("div",{className:"label_item",children:title}),targetLanguage===value&&/*#__PURE__*/_jsx(SelectIcon,{src:"".concat(chrome.runtime.getURL('selectOptionCheck.svg'))})]},value);})})]})]}),/*#__PURE__*/_jsxs("div",{className:"translate-item",style:{marginTop:12},children:[/*#__PURE__*/_jsx("span",{className:"translate-item-title ".concat(changeTranStatus&&'caption-translate-item-title'),children:"\u663E\u793A\u8BED\u8A00"}),/*#__PURE__*/_jsxs("span",{className:"translate-item-des ".concat(changeTranStatus&&'caption-translate-item-des'),children:[/*#__PURE__*/_jsxs("span",{className:"translate-item-des-item ".concat(changeTranStatus&&'caption-translate-item-des-item'),onClick:function onClick(){setShowLanguage(1);if(doubleLanguage){doubleLanguage(1);}},children:[/*#__PURE__*/_jsx(Radio,{changeTranStatus:changeTranStatus,type:showLanguage===1?"check":"defult",style:{minWidth:10,minHeight:10}}),/*#__PURE__*/_jsx("span",{style:{marginLeft:8},children:"\u7EAF\u8BD1\u6587\u663E\u793A"})]}),/*#__PURE__*/_jsxs("span",{className:"translate-item-des-item ".concat(changeTranStatus&&'caption-translate-item-des-item'),style:{marginLeft:20},onClick:function onClick(){setShowLanguage(2);if(doubleLanguage){doubleLanguage(2);}},children:[/*#__PURE__*/_jsx(Radio,{changeTranStatus:changeTranStatus,type:showLanguage===2?"check":"defult",style:{minWidth:10,minHeight:10}}),/*#__PURE__*/_jsx("span",{style:{marginLeft:8},children:"\u53CC\u8BED\u663E\u793A"})]})]})]})]});})));
;// CONCATENATED MODULE: ./src/components/translatePopWindow/index.ts

;// CONCATENATED MODULE: ./src/components/envMark/styled.tsx
var envMark_styled_templateObject;var envMark_styled_Content=styled_components_browser_esm.div(envMark_styled_templateObject||(envMark_styled_templateObject=_taggedTemplateLiteral(["\n  position: absolute;\n  top: 0;\n  right: 0;\n  font-size: 12px;\n  font-weight: bold;\n  color: red;\n  padding: 5px 6px;\n  z-index: 2;\n  pointer-events: none;\n"])));
;// CONCATENATED MODULE: ./src/components/envMark/envMark.tsx
var envMark_EnvMark=/*#__PURE__*/(/* unused pure expression or super */ null && (memo(function(){var _getGlobalConfig$getE=getGlobalConfig().getEnvInfo(),env=_getGlobalConfig$getE.env;return/*#__PURE__*/_jsx(_Fragment,{children:env==="pre"?/*#__PURE__*/_jsx(Content,{}):null});})));
;// CONCATENATED MODULE: ./src/components/envMark/index.ts

;// CONCATENATED MODULE: ./src/components/recordControl/recordControl.tsx
dayjs_min_default().extend((duration_default()));var assetUrls={applaudB:chrome.runtime.getURL('applaudB.png'),laughB:chrome.runtime.getURL('laughB.png'),musicB:chrome.runtime.getURL('musicB.png'),networkB:chrome.runtime.getURL('networkB.png'),noiseA:chrome.runtime.getURL('noiseA.png'),noiseC:chrome.runtime.getURL('noiseC.png'),recordingB:chrome.runtime.getURL('recordingB.png'),recordingC:chrome.runtime.getURL('recordingC.png'),stopA:chrome.runtime.getURL('stopA.png'),stopB:chrome.runtime.getURL('stopB.png'),stopC:chrome.runtime.getURL('stopC.png'),tableB:chrome.runtime.getURL('tableB.png')};var recordControl_sourceLanguageMap=new Map([['cn',1],['en',2],['yue',3],['fspk',4]]);var recordControl_RecordControl=/*#__PURE__*/(/* unused pure expression or super */ null && (memo(function(props){var className=props.className,controlBoxClassName=props.controlBoxClassName,meetingController=props.meetingController,controller=props.controller,getMeetingContext=props.getMeetingContext;var isPauseRecord=useRecoilValue(isPauseRecordState);var _usePanelVisible=usePanelVisible(),showCaption=_usePanelVisible.showCaption;var second=useRecoilValue(secondState);var _useRecoilState=useRecoilState(isExpandState),_useRecoilState2=_slicedToArray(_useRecoilState,2),isExpand=_useRecoilState2[0],setIsExpand=_useRecoilState2[1];var _useState=useState(false),_useState2=_slicedToArray(_useState,2),isTranslateHover=_useState2[0],setIsTranslateHover=_useState2[1];var _useRecoilState3=useRecoilState(translateSwitchState),_useRecoilState4=_slicedToArray(_useRecoilState3,2),translateSwitch=_useRecoilState4[0],setTranslateSwitch=_useRecoilState4[1];var sourceLanguage=useRecoilValue(sourceLanguageState);var _useRecoilState5=useRecoilState(targetLanguageState),_useRecoilState6=_slicedToArray(_useRecoilState5,2),targetLanguage=_useRecoilState6[0],setTargetLanguage=_useRecoilState6[1];var _useRecoilState7=useRecoilState(showLanguageState),_useRecoilState8=_slicedToArray(_useRecoilState7,2),showLanguage=_useRecoilState8[0],setShowLanguage=_useRecoilState8[1];var isStoping=useRecoilValue(isStopingState);var _useRecoilState9=useRecoilState(transIdState),_useRecoilState10=_slicedToArray(_useRecoilState9,2),transId=_useRecoilState10[0],setTransId=_useRecoilState10[1];useEffect(function(){if(isStoping||transId===''||transId==='0')return;var tag={};if(translateSwitch){tag={translateSwitch:1,originLanguageValue:recordControl_sourceLanguageMap.get(sourceLanguage),transTargetValue:sourceLanguage==='cn'?2:1,translateLanguageConf:showLanguage};}else{tag={translateSwitch:0,originLanguageValue:recordControl_sourceLanguageMap.get(sourceLanguage),transTargetValue:0,translateLanguageConf:showLanguage};}service.getSyncTransTag(Number(transId),tag);},[isStoping,transId,translateSwitch,sourceLanguage,showLanguage]);useEffect(function(){sendLog('change_translate_display_mode',{et:'CLK',c1:showLanguage});},[showLanguage]);var handleExpandChange=useCallback(function(){// onExpandChange(!isExpand);
setIsExpand(!isExpand);sendLog('change_chrome_shape',{et:'CLK',c1:isExpand?3:1});},[isExpand]);var handleRestart=useCallback(function(){meetingController.resumeMeeting();sendLog('re_start_record',{et:'CLK',c1:transId});},[transId]);var handleStop=useCallback(function(){meetingController.stopMeeting();service.getSyncTransTag(Number(transId),{read:'0'});// 结束会议
setTranslateSwitch(false);setTargetLanguage('cn');setShowLanguage(1);setTransId('');sendLog('stop_record',{et:'CLK',c1:transId});},[meetingController,transId]);var handlePause=useCallback(function(){meetingController.pauseMeeing();sendLog('pause_record',{et:'CLK',c1:transId});},[transId]);var renderedTime=useMemo(function(){if(!second){return'00:00';}return getFlexibleTime(second*1000);// return dayjs.duration(second * 1000).format('HH:mm:ss');
},[second]);return/*#__PURE__*/_jsxs(Content,{className:className,style:{borderBottom:isExpand?'0.5px solid #E5E6ED':'none'},children:[/*#__PURE__*/_jsx(EnvMark,{}),/*#__PURE__*/_jsxs(RecordHeading,{children:[/*#__PURE__*/_jsx(TingwuBall,{assetUrls:assetUrls,status:isPauseRecord?'stop':'recording',style:{width:44,height:44,borderRadius:44,border:'0.5px solid #DFE1EB'}}),/*#__PURE__*/_jsxs(RecordHeadingText,{children:[/*#__PURE__*/_jsx(RecordTitle,{children:isPauseRecord?'录音已暂停':'听悟录音中'}),/*#__PURE__*/_jsx(RecordDatetime,{children:renderedTime})]})]}),/*#__PURE__*/_jsxs(ControlBox,{className:controlBoxClassName,children:[/*#__PURE__*/_jsx(Tooltip,{placement:"bottom",color:"rgb(39, 38, 77)",overlayInnerStyle:{borderRadius:"8px",padding:"4px 8px",fontSize:"12px",minHeight:26},title:"\u7ED3\u675F\u5F55\u97F3",getPopupContainer:function getPopupContainer(triggerNode){return triggerNode.parentElement;},children:/*#__PURE__*/_jsx(StopButton,{onClick:handleStop})}),/*#__PURE__*/_jsx(Tooltip,{placement:"bottom",color:"rgb(39, 38, 77)",overlayInnerStyle:{borderRadius:"8px",padding:"4px 8px",fontSize:"12px",minHeight:26},title:isPauseRecord?'继续录音':'暂停录音',getPopupContainer:function getPopupContainer(triggerNode){return triggerNode.parentElement;},children:isPauseRecord?/*#__PURE__*/_jsx(RestartButton,{onClick:handleRestart}):/*#__PURE__*/_jsx(PauseButton,{onClick:handlePause})}),sourceLanguage!=='yue'&&sourceLanguage!=='fspk'&&/*#__PURE__*/_jsx(Popover,{placement:"topRight",title:null,content:/*#__PURE__*/_jsx(TranslatePopWindow,{controller:controller,translateSwitch:translateSwitch,showLanguage:showLanguage,getMeetingContext:getMeetingContext}),getPopupContainer:function getPopupContainer(triggerNode){return triggerNode.parentElement;},children:/*#__PURE__*/_jsx(TranslateButton,{style:{backgroundImage:isTranslateHover||translateSwitch?"url(".concat(chrome.runtime.getURL('translateButtonHover.svg'),")"):"url(".concat(chrome.runtime.getURL('translateButton.svg'),")")},onMouseEnter:function onMouseEnter(){return setIsTranslateHover(true);},onMouseLeave:function onMouseLeave(){return setIsTranslateHover(false);}})}),/*#__PURE__*/_jsx(Tooltip,{placement:"bottom",color:"rgb(39, 38, 77)",overlayInnerStyle:{borderRadius:"8px",padding:"4px 8px",fontSize:"12px",minHeight:26},title:"\u5B57\u5E55",getPopupContainer:function getPopupContainer(triggerNode){return triggerNode.parentElement;},children:/*#__PURE__*/_jsx(CaptionButton,{onClick:function onClick(){showCaption();sendLog('change_chrome_shape',{et:'CLK',c1:2});}})}),/*#__PURE__*/_jsx(Tooltip,{placement:"bottom",color:"rgb(39, 38, 77)",overlayInnerStyle:{borderRadius:"8px",padding:"4px 8px",fontSize:"12px",minHeight:26},title:isExpand?'收起':' 展开',getPopupContainer:function getPopupContainer(triggerNode){return triggerNode.parentElement;},children:/*#__PURE__*/_jsx(ExpandButton,{style:{transform:"rotate(".concat(isExpand?'0':'180',"deg)")},onClick:handleExpandChange})})]})]});})));
;// CONCATENATED MODULE: ./src/components/recordControl/index.ts

;// CONCATENATED MODULE: ./src/components/stoping/styled.tsx
var stoping_styled_templateObject,stoping_styled_templateObject2,stoping_styled_templateObject3;var styled_StopingStyled=styled_components_browser_esm.div(stoping_styled_templateObject||(stoping_styled_templateObject=_taggedTemplateLiteral(["\n  position: absolute;\n  top: 0;\n  left: 0;\n  bottom: 0;\n  right: 0;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  background-color: rgba(185, 184, 222, 0.2);\n  z-index: 2147483647;\n  backdrop-filter: blur(6px);\n  border-radius: 10px;\n"])));var styled_StopingTag=styled_components_browser_esm.div(stoping_styled_templateObject2||(stoping_styled_templateObject2=_taggedTemplateLiteral(["\n  background: #FFFFFF;\n  box-shadow: 0 2px 8px 0 rgba(90,68,151,0.12);\n  border-radius: 8px;\n  font-size: 14px;\n  color: rgba(39,38,77,0.70);\n  line-height: 22px;\n  padding: 0 16px;\n  height: 40px;\n  line-height: 40px;\n  display: flex;\n  align-items: center;\n"])));var styled_StopingText=styled_components_browser_esm.div(stoping_styled_templateObject3||(stoping_styled_templateObject3=_taggedTemplateLiteral(["\n  margin-left: 5px;\n"])));
;// CONCATENATED MODULE: ./src/components/stoping/stoping.tsx
var stoping_Stoping=/*#__PURE__*/(/* unused pure expression or super */ null && (memo(function(){return/*#__PURE__*/_jsx(StopingStyled,{children:/*#__PURE__*/_jsxs(StopingTag,{children:[/*#__PURE__*/_jsx(Ellipsis,{color:"#605CE5"}),/*#__PURE__*/_jsx(StopingText,{children:"\u4FDD\u5B58\u4E2D"})]})});})));
;// CONCATENATED MODULE: ./src/components/stoping/index.ts

;// CONCATENATED MODULE: ./src/components/mainPanel/styled.tsx
var mainPanel_styled_templateObject,mainPanel_styled_templateObject2;var mainPanel_styled_Content=styled_components_browser_esm.div(mainPanel_styled_templateObject||(mainPanel_styled_templateObject=_taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: column;\n  position: fixed;\n  z-index: 2147483647;\n  top: 40px;\n  right: 32px;\n  width: 320px;\n\n  background: #F9FAFF;\n  box-shadow: 0 0 1px 1px rgba(63,60,161,0.30);\n  border-radius: 12px;\n  /* overflow: hidden; */\n\n  .react-resizable-handle {\n    position: absolute;\n    left: 4px;\n    right: 4px;\n    box-sizing: border-box;\n    user-select: none;\n    height: 10px;\n    z-index: 201;\n  }\n\n  .react-resizable-handle-n {\n    top: 0;\n    cursor: ",";\n  }\n\n  .react-resizable-handle-s {\n    bottom: 0;\n    cursor: ",";\n  }\n\n  .tweant-message {\n    top: 50%;\n    transform: translate(0, -50%);\n\n    .tweant-message-notice-content {\n      border-radius: 8px !important;\n    }\n  }\n\n  .transWrap>div>div::-webkit-scrollbar {\n    width: 0 !important;\n  }\n"])),function(props){return!props.isExpand?'default':props.northMax?'s-resize':'ns-resize';},function(props){return!props.isExpand?'default':props.southMax?'n-resize':'ns-resize';});var DragHandle=styled_components_browser_esm.div(mainPanel_styled_templateObject2||(mainPanel_styled_templateObject2=_taggedTemplateLiteral(["\n  user-select: none;\n  background-color: #fff;\n  padding: 5px;\n"])));
;// CONCATENATED MODULE: ./src/components/mainPanel/mainPanel.tsx
var mainPanel_MainPanel=/*#__PURE__*/(/* unused pure expression or super */ null && (memo(function(props){var controller=props.controller,meetingController=props.meetingController,_props$visible=props.visible,visible=_props$visible===void 0?true:_props$visible,getMeetingContext=props.getMeetingContext;// const [isExpand, setIsExpand] = useState(true);
var isExpand=useRecoilValue(isExpandState);var isStoping=useRecoilValue(isStopingState);var _useRecoilState=useRecoilState(panelHeightState),_useRecoilState2=_slicedToArray(_useRecoilState,2),panelHeight=_useRecoilState2[0],setPanelHeight=_useRecoilState2[1];var _useRecoilState3=useRecoilState(panelPositionState),_useRecoilState4=_slicedToArray(_useRecoilState3,2),panelPosition=_useRecoilState4[0],setPanelPosition=_useRecoilState4[1];var _useState=useState(false),_useState2=_slicedToArray(_useState,2),northMax=_useState2[0],setNorthMax=_useState2[1];var _useState3=useState(false),_useState4=_slicedToArray(_useState3,2),southMax=_useState4[0],setSouthMax=_useState4[1];// const left = useMemo(() => {
//   return Math.max(0, window.innerWidth - 320 - 40);
// }, []);
var calcStyle=useMemo(function(){return{// left,
height:isExpand?panelHeight>=window.innerHeight?window.innerHeight:panelHeight:75,display:visible?'flex':'none'};},[isExpand,panelHeight,visible]);var resizeableProps=useMemo(function(){return{resizeHandles:['s'],draggableOpts:{grid:[1,1]},minConstraints:[320,480],maxConstraints:[320,window.innerHeight>960?960:window.innerHeight]};},[]);var onDrag=useCallback(function(_event,data){var x=data.x,y=data.y;if(y+panelHeight+40<window.innerHeight-24){setSouthMax(false);}else{setSouthMax(true);}setPanelPosition({x:x,y:y});},[panelHeight]);var onResize=useCallback(function(_event,data){var handle=data.handle,size=data.size;if(handle==='s'){// 向下拉伸临界点
if(size.height+panelPosition.y+40>=window.innerHeight||size.height>=960){setSouthMax(true);return;}else{setSouthMax(false);}}setPanelHeight(size.height);},[panelPosition]);return/*#__PURE__*/_jsx(Draggable,{onDrag:onDrag,position:panelPosition,handle:".handle",cancel:".not-handle",bounds:"body",children:/*#__PURE__*/_jsx(Resizable,_objectSpread(_objectSpread({width:320,height:isExpand?panelHeight>=window.innerHeight?window.innerHeight:panelHeight:75,onResize:onResize},resizeableProps),{},{children:/*#__PURE__*/_jsxs(Content,{id:"main_draggable_panel",style:calcStyle,isExpand:isExpand,northMax:northMax,southMax:southMax,children:[/*#__PURE__*/_jsx(RecordControl,{className:"handle",controlBoxClassName:"not-handle"// isExpand={isExpand}
// onExpandChange={setIsExpand}
,meetingController:meetingController,controller:controller,getMeetingContext:getMeetingContext}),/*#__PURE__*/_jsx("div",{style:{background:'#F2F5FB',borderRadius:'0 0 12px 12px'},children:/*#__PURE__*/_jsx("div",{className:"transWrap",children:/*#__PURE__*/_jsx(TransContainer,{controller:controller,isExpand:isExpand,panelHeight:panelHeight})})}),isStoping&&/*#__PURE__*/_jsx(Stoping,{})]})}))});})));
;// CONCATENATED MODULE: ./src/components/mainPanel/index.ts

;// CONCATENATED MODULE: ./src/components/captionContainer/styled.tsx
var captionContainer_styled_templateObject,captionContainer_styled_templateObject2,captionContainer_styled_templateObject3,captionContainer_styled_templateObject4,captionContainer_styled_templateObject5,captionContainer_styled_templateObject6,captionContainer_styled_templateObject7,styled_templateObject8,styled_templateObject9,styled_templateObject10;var RESIZE_HANDLE_WIDTH=10;var captionContainer_styled_Content=styled_components_browser_esm.div(captionContainer_styled_templateObject||(captionContainer_styled_templateObject=_taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: column;\n  position: fixed;\n  z-index: 2147483647;\n  // overflow: hidden;\n  border-radius: 8px;\n\n  .captionWrapper>div>div:nth-child(2){\n    opacity: ",";\n  }\n\n  .react-resizable-handle {\n    position: absolute;\n    box-sizing: border-box;\n    user-select: none;\n  }\n\n  .react-resizable-handle-se {\n    cursor: se-resize;\n    bottom: 0;\n    right: 0;\n    width: ","px;\n    height: ","px;\n  }\n\n  .react-resizable-handle-ne {\n    cursor: ne-resize;\n    top: 0;\n    right: 0;\n    width: ","px;\n    height: ","px;\n  }\n\n  .react-resizable-handle-sw {\n    cursor: sw-resize;\n    bottom: 0;\n    left: 0;\n    width: ","px;\n    height: ","px;\n  }\n  .react-resizable-handle-nw {\n    cursor: nw-resize;\n    top: 0;\n    left: 0;\n    width: ","px;\n    height: ","px;\n  }\n\n  .react-resizable-handle-e {\n    cursor: ",";\n    top: ","px;\n    bottom: ","px;\n    right: 0;\n    width: ","px;\n  }\n\n  .react-resizable-handle-w {\n    cursor: w-resize;\n    top: ","px;\n    bottom: ","px;\n    left: 0;\n    width: ","px;\n  }\n\n  .react-resizable-handle-n {\n    cursor: n-resize;\n    left: ","px;\n    right: ","px;\n    top: 0;\n    height: ","px;\n  }\n\n  .react-resizable-handle-s {\n    cursor: ",";\n    left: ","px;\n    right: ","px;\n    bottom: 0;\n    height: ","px;\n  }\n\n  .tweant-message {\n    top: 50%;\n    transform: translate(0, -50%);\n\n    .tweant-message-notice-content {\n      border-radius: 8px !important;\n    }\n  }\n"])),function(props){return props.isPauseRecord?'0':'1';},RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,function(props){return!props.directionsData.eastMax&&!props.directionsData.eastMin?'ew-resize':props.directionsData.eastMax?'w-resize':'e-resize';},RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,function(props){return!props.directionsData.southMax&&!props.directionsData.southMin?'ns-resize':props.directionsData.southMax?'n-resize':'s-resize';},RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH,RESIZE_HANDLE_WIDTH);var styled_CaptionWrapper=styled_components_browser_esm.div(captionContainer_styled_templateObject2||(captionContainer_styled_templateObject2=_taggedTemplateLiteral(["\n  display: flex;\n  width: 100%;\n  height: 100%;\n  & > div {\n    width: 100%;\n    height: 100%;\n    flex: 1 1;\n  }\n"])));var captionContainer_styled_ControlBox=styled_components_browser_esm.div(captionContainer_styled_templateObject3||(captionContainer_styled_templateObject3=_taggedTemplateLiteral(["\n  display: flex;\n"])));var captionContainer_styled_StopButton=styled_components_browser_esm.div(captionContainer_styled_templateObject4||(captionContainer_styled_templateObject4=_taggedTemplateLiteral(["\n  background-image: url(",");\n  background-size: contain;\n  width: 16px;\n  height: 16px;\n  cursor: pointer;\n  transition: all 0.3s;\n  &:hover{\n    background-image: url(",");\n  }\n  &:active{\n    background-image: url(",");\n  }\n"])),chrome.runtime.getURL('stopButton.svg'),chrome.runtime.getURL('stopButtonHover.svg'),chrome.runtime.getURL('stopButtonActive.svg'));var styled_MainPanelButton=styled_components_browser_esm.div(captionContainer_styled_templateObject5||(captionContainer_styled_templateObject5=_taggedTemplateLiteral(["\n  background-image: url(",");\n  background-size: contain;\n  width: 16px;\n  height: 16px;\n  cursor: pointer;\n  margin-left: 13px;\n  transition: all 0.3s;\n  &:hover{\n    background-image: url(",");\n  }\n"])),chrome.runtime.getURL('mainPanelButton.svg'),chrome.runtime.getURL('mainPanelButtonHover.svg'));var styled_Logo=styled_components_browser_esm.div(captionContainer_styled_templateObject6||(captionContainer_styled_templateObject6=_taggedTemplateLiteral(["\n  background-image: url(",");\n  background-position: 0 0;\n  background-repeat: no-repeat;\n  background-size: contain;\n  width: ",";\n  height: 16px;\n"])),createConfig_getGlobalConfig().renderLogoBase64(),createConfig_getGlobalConfig().renderLogoSizeInCaption());var captionContainer_styled_RestartButton=styled_components_browser_esm.div(captionContainer_styled_templateObject7||(captionContainer_styled_templateObject7=_taggedTemplateLiteral(["\n  background-image: url(",");\n  background-size: contain;\n  background-position: center center;\n  background-repeat: no-repeat;\n  width: 16px;\n  height: 16px;\n  cursor: pointer;\n  margin-left: 12px;\n  transition: all 0.3s;\n  &:hover{\n    background-image: url(",");\n  }\n  /* &:active{\n    background-image: url(",");\n  } */\n"])),chrome.runtime.getURL('restartButtonCaption.svg'),chrome.runtime.getURL('restartButtonHoverCaption.svg'),chrome.runtime.getURL('restartButtonActive.svg'));var captionContainer_styled_PauseButton=styled_components_browser_esm.div(styled_templateObject8||(styled_templateObject8=_taggedTemplateLiteral(["\n  background-image: url(",");\n  background-size: contain;\n  width: 16px;\n  height: 16px;\n  cursor: pointer;\n  margin-left: 12px;\n  transition: all 0.3s;\n  &:hover{\n    background-image: url(",");\n  }\n  /* &:active{\n    background-image: url(",");\n  } */\n"])),chrome.runtime.getURL('pauseButtonCaption.svg'),chrome.runtime.getURL('pauseButtonHoverCaption.svg'),chrome.runtime.getURL('pauseButtonActive.svg'));var captionContainer_styled_TranslateButton=styled_components_browser_esm.div(styled_templateObject9||(styled_templateObject9=_taggedTemplateLiteral(["\n  background-size: contain;\n  background-position: center center;\n  background-repeat: no-repeat;\n  width: 16px;\n  height: 16px;\n  cursor: pointer;\n  margin-left: 12px;\n  transition: all 0.3s;\n"])));var styled_PauseRecordTips=styled_components_browser_esm.span(styled_templateObject10||(styled_templateObject10=_taggedTemplateLiteral(["\n  position: absolute;\n  top: 48px;\n  left: 24px;\n  color: rgba(255, 255, 255, 0.6);\n  z-index: 1;\n  font-size: 15px;\n"])));
;// CONCATENATED MODULE: ./src/components/captionContainer/captionContainer.tsx
var captionContainer_CaptionContainer=function CaptionContainer(props){var meetingController=props.meetingController,_props$defaultWidth=props.defaultWidth,defaultWidth=_props$defaultWidth===void 0?720:_props$defaultWidth,_props$defaultHeight=props.defaultHeight,defaultHeight=_props$defaultHeight===void 0?116:_props$defaultHeight,visible=props.visible,controller=props.controller,getMeetingContext=props.getMeetingContext;var _useState=useState(defaultWidth),_useState2=_slicedToArray(_useState,2),width=_useState2[0],setWidth=_useState2[1];var _useState3=useState(defaultHeight),_useState4=_slicedToArray(_useState3,2),height=_useState4[0],setHeight=_useState4[1];var _useState5=useState(0),_useState6=_slicedToArray(_useState5,2),top=_useState6[0],setTop=_useState6[1];var _useState7=useState(0),_useState8=_slicedToArray(_useState7,2),left=_useState8[0],setLeft=_useState8[1];var _usePanelVisible=usePanelVisible(),showMainPanel=_usePanelVisible.showMainPanel;var isStoping=useRecoilValue(isStopingState);var _useRecoilState=useRecoilState(translateSwitchState),_useRecoilState2=_slicedToArray(_useRecoilState,2),translateSwitch=_useRecoilState2[0],setTranslateSwitch=_useRecoilState2[1];var setTargetLanguage=useSetRecoilState(targetLanguageState);var _useRecoilState3=useRecoilState(showLanguageState),_useRecoilState4=_slicedToArray(_useRecoilState3,2),showLanguage=_useRecoilState4[0],setShowLanguage=_useRecoilState4[1];var _useRecoilState5=useRecoilState(transIdState),_useRecoilState6=_slicedToArray(_useRecoilState5,2),transId=_useRecoilState6[0],setTransId=_useRecoilState6[1];var isExpand=useRecoilValue(isExpandState);var _useState9=useState({eastMax:false,eastMin:false,southMax:false,southMin:false}),_useState10=_slicedToArray(_useState9,2),directionsData=_useState10[0],setDirectionsData=_useState10[1];var isPauseRecord=useRecoilValue(isPauseRecordState);var sourceLanguage=useRecoilValue(sourceLanguageState);var _useState11=useState(false),_useState12=_slicedToArray(_useState11,2),isTranslateHover=_useState12[0],setIsTranslateHover=_useState12[1];var handleRestart=useCallback(function(){meetingController.resumeMeeting();sendLog('re_start_record',{et:'CLK',c1:transId});},[transId]);var handlePause=useCallback(function(){meetingController.pauseMeeing();sendLog('pause_record',{et:'CLK',c1:transId});},[transId]);var handleStop=useCallback(function(){meetingController.stopMeeting();service.getSyncTransTag(Number(transId),{read:'0'});setTranslateSwitch(false);setTargetLanguage('cn');setShowLanguage(1);setTransId('');sendLog('stop_record',{et:'CLK',c1:transId});},[meetingController,transId]);var onResize=useCallback(function(_event,data){var handle=data.handle,size=data.size;setWidth(size.width);setHeight(size.height);if(handle==='e'){if(size.width>=720){setDirectionsData(_objectSpread(_objectSpread({},directionsData),{},{eastMax:true,eastMin:false}));}else if(size.width<=320){setDirectionsData(_objectSpread(_objectSpread({},directionsData),{},{eastMin:true,eastMax:false}));}else{setDirectionsData(_objectSpread(_objectSpread({},directionsData),{},{eastMax:false,eastMin:false}));}}else if(handle==='s'){if(size.height>=193){setDirectionsData(_objectSpread(_objectSpread({},directionsData),{},{southMax:true,southMin:false}));}else if(size.height<=118){setDirectionsData(_objectSpread(_objectSpread({},directionsData),{},{southMin:true,southMax:false}));}else{setDirectionsData(_objectSpread(_objectSpread({},directionsData),{},{southMax:false,southMin:false}));}}},[directionsData]);// 开启翻译 双语展示，默认各展示两行。
useEffect(function(){if(translateSwitch&&showLanguage===2){setHeight(168);}},[translateSwitch,showLanguage]);useEffect(function(){setTop(Math.max(0,window.innerHeight-height-67));setLeft(Math.max(0,(window.innerWidth-width)/2));},[]);useEffect(function(){if(isStoping||transId===''||transId==='0')return;var tag={};if(translateSwitch){tag={translateSwitch:1,originLanguageValue:sourceLanguageMap.get(sourceLanguage),transTargetValue:sourceLanguage==='cn'?2:1,translateLanguageConf:showLanguage};}else{tag={translateSwitch:0,originLanguageValue:sourceLanguageMap.get(sourceLanguage),transTargetValue:0,translateLanguageConf:showLanguage};}service.getSyncTransTag(Number(transId),tag);},[isStoping,transId,translateSwitch,sourceLanguage,showLanguage]);var calcStyle=useMemo(function(){return{width:width,height:height,left:left,top:top,display:visible?'flex':'none'};},[width,height,left,visible]);var extraContent=/*#__PURE__*/_jsxs(ControlBox,{children:[/*#__PURE__*/_jsx(Tooltip,{placement:"top",color:"rgb(39, 38, 77)",overlayInnerStyle:{borderRadius:"8px",padding:"4px 8px",fontSize:"12px",minHeight:26},title:"\u7ED3\u675F\u5F55\u97F3",getPopupContainer:function getPopupContainer(triggerNode){return triggerNode.parentElement;},children:/*#__PURE__*/_jsx(StopButton,{onClick:handleStop})}),/*#__PURE__*/_jsx(Tooltip,{placement:"top",color:"rgb(39, 38, 77)",overlayInnerStyle:{borderRadius:"8px",padding:"4px 8px",fontSize:"12px",minHeight:26},title:isPauseRecord?"继续录音":"暂停录音",getPopupContainer:function getPopupContainer(triggerNode){return triggerNode.parentElement;},children:isPauseRecord?/*#__PURE__*/_jsx(RestartButton,{onClick:handleRestart}):/*#__PURE__*/_jsx(PauseButton,{onClick:handlePause})}),sourceLanguage!=="yue"&&sourceLanguage!=="fspk"&&/*#__PURE__*/_jsx(Tooltip,{overlayClassName:"translateTooltip",placement:"topRight",color:"transparent",overlayInnerStyle:{borderRadius:"8px",padding:"0"},title:/*#__PURE__*/_jsx(TranslatePopWindow,{controller:controller,translateSwitch:translateSwitch,showLanguage:showLanguage,changeTranStatus:setTranslateSwitch,doubleLanguage:setShowLanguage,getMeetingContext:getMeetingContext})// getPopupContainer={(triggerNode) => triggerNode.parentElement as any}
,children:/*#__PURE__*/_jsx(TranslateButton,{style:{backgroundImage:isTranslateHover||translateSwitch?"url(".concat(chrome.runtime.getURL("translateButtonHoverCaption.svg"),")"):"url(".concat(chrome.runtime.getURL("translateButtonCaption.svg"),")")},onMouseEnter:function onMouseEnter(){return setIsTranslateHover(true);},onMouseLeave:function onMouseLeave(){return setIsTranslateHover(false);}})}),/*#__PURE__*/_jsx(Tooltip,{placement:"top",color:"rgb(39, 38, 77)",overlayInnerStyle:{borderRadius:"8px",padding:"4px 8px",fontSize:"12px",minHeight:26},title:"\u5173\u95ED\u5B57\u5E55",getPopupContainer:function getPopupContainer(triggerNode){return triggerNode.parentElement;},children:/*#__PURE__*/_jsx(MainPanelButton,{onClick:function onClick(){showMainPanel();sendLog("change_chrome_shape",{et:"CLK",c1:isExpand?1:3});}})})]});var resizeableProps=useMemo(function(){return{// resizeHandles: ['s', 'w', 'e', 'n', 'sw', 'nw', 'se', 'ne'],
resizeHandles:['s','e','se'],draggableOpts:{grid:[1,1]},minConstraints:[320,118],maxConstraints:[720,193]};},[]);return/*#__PURE__*/_jsx(Draggable,{handle:".handle",bounds:"body",children:/*#__PURE__*/_jsx(Resizable,_objectSpread(_objectSpread({width:width,height:height,onResize:onResize},resizeableProps),{},{children:/*#__PURE__*/_jsxs(Content,{id:"caption_draggable_panel",style:calcStyle,directionsData:directionsData,isPauseRecord:isPauseRecord,children:[/*#__PURE__*/_jsxs(CaptionWrapper,{className:"handle captionWrapper",children:[isPauseRecord&&/*#__PURE__*/_jsx(PauseRecordTips,{children:"\u5F55\u97F3\u5DF2\u6682\u505C"}),/*#__PURE__*/_jsx(Provider,{controller:controller,children:/*#__PURE__*/_jsx(Caption,{extraContent:extraContent,logo:/*#__PURE__*/_jsx(Logo,{})})})]}),isStoping&&/*#__PURE__*/_jsx(Stoping,{})]})}))});};
;// CONCATENATED MODULE: ./src/components/captionContainer/index.ts

;// CONCATENATED MODULE: ./src/components/provider/provider.tsx
var provider_Provider=/*#__PURE__*/(/* unused pure expression or super */ null && (memo(function(props){var children=props.children;return/*#__PURE__*/_jsx(React.StrictMode,{children:/*#__PURE__*/_jsx(RecoilRoot,{children:/*#__PURE__*/_jsx(ConfigProvider,{prefixCls:"tweant",children:children})})});})));
;// CONCATENATED MODULE: ./src/components/provider/index.ts

;// CONCATENATED MODULE: ./src/components/loginPanel/styled.tsx
var loginPanel_styled_templateObject,loginPanel_styled_templateObject2,loginPanel_styled_templateObject3,loginPanel_styled_templateObject4,loginPanel_styled_templateObject5,loginPanel_styled_templateObject6,loginPanel_styled_templateObject7,loginPanel_styled_templateObject8,loginPanel_styled_templateObject9;var styled_Panel=styled_components_browser_esm.div(loginPanel_styled_templateObject||(loginPanel_styled_templateObject=_taggedTemplateLiteral(["\n  width: 320px;\n  height: 322px;\n  display: flex;\n  flex-direction: column;\n  position: fixed;\n  z-index: 2147483647;\n  top: 40px;\n  right: 32px;\n  .tweant-modal-mask {\n    background-color: rgba(185, 184, 222, 0.2);\n    backdrop-filter: blur(6px);\n  }\n  .tweant-modal-confirm-title{\n    font-family: PingFangSC;\n    font-weight: 500;\n    font-size: 14px;\n    color: #27264D;\n    letter-spacing: 0;\n    text-align: center;\n    line-height: 20px;\n  }\n  .tweant-btn-primary{\n    margin-left: -30px;\n  }\n  .tweant-modal-content {\n    border-radius: 8px;\n  }\n  .tweant-btn-primary {\n    background-color: #605ce5;\n    border-color: #605ce5;\n    font-size: 14px;\n    color: #fff;\n    border-radius: 8px;\n  }\n  .tweant-btn-primary:hover {\n    background-color: #7470e7;\n    border-color: #7470e7;\n  }\n  .tweant-btn-primary:focus,\n  .tweant-btn-primary:active {\n    background-color: #5b57ce;\n    border-color: #5b57ce;\n  }\n"])));var styled_Background=styled_components_browser_esm.div(loginPanel_styled_templateObject2||(loginPanel_styled_templateObject2=_taggedTemplateLiteral(["\n  background-color: #F9FAFF;  \n  background-image: url(",");\n  background-position: 0 0;\n  background-repeat: no-repeat;\n  background-size: contain;\n  box-shadow: 0 0 1px 1px rgba(63,60,161,0.30);\n  border-radius: 8px;\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 100%;\n  height: 100%;\n  z-index: 1;\n"])),chrome.runtime.getURL('background.svg'));var loginPanel_styled_Container=styled_components_browser_esm.div(loginPanel_styled_templateObject3||(loginPanel_styled_templateObject3=_taggedTemplateLiteral(["\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 100%;\n  height: 100%;\n  z-index: 2;\n  display: flex;\n  flex-direction: column;\n  /* align-items: center; */\n  justify-content: flex-start;\n  user-select: none;\n  padding: 0 24px;\n"])));var loginPanel_styled_Logo=styled_components_browser_esm.div(loginPanel_styled_templateObject4||(loginPanel_styled_templateObject4=_taggedTemplateLiteral(["\n  background: url(",") 0 0 no-repeat;\n  background-size: contain;\n  width: 200px;\n  height: 24px;\n  margin-top: 28px;\n  /* margin-left: 24px; */\n  align-self: flex-start;\n"])),chrome.runtime.getURL(createConfig_getGlobalConfig().renderLogoUrl()));var loginPanel_styled_CloseButton=styled_components_browser_esm.div(loginPanel_styled_templateObject5||(loginPanel_styled_templateObject5=_taggedTemplateLiteral(["\n  background: url(",") center center no-repeat;\n  width: 20px;\n  height: 20px;\n  cursor: pointer;\n  position: absolute;\n  top: 33px;\n  right: 24px;\n  transition: all 0.3s;\n  &:hover {\n    background: url(",") center center no-repeat;\n  }\n\n  &:active {\n    background: url(",") center center no-repeat;\n  }\n"])),chrome.runtime.getURL('closeLarge.svg'),chrome.runtime.getURL('closeHoverLarge.svg'),chrome.runtime.getURL('closeActiveLarge.svg'));var styled_Features=styled_components_browser_esm.div(loginPanel_styled_templateObject6||(loginPanel_styled_templateObject6=_taggedTemplateLiteral(["\n  background: url(",") 0 0 no-repeat;\n  background-size: contain;\n  width: 208px;\n  height: 49px;\n  margin-top: 30px;\n"])),chrome.runtime.getURL('loginPoint.svg'));var loginPanel_styled_Button=styled_components_browser_esm.div(loginPanel_styled_templateObject7||(loginPanel_styled_templateObject7=_taggedTemplateLiteral(["\n  width: 272px;\n  height: 40px;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  background: #605CE5;\n  border-radius: 8px;\n  margin-top: 35px;\n  color: #fff;\n  font-size: 14px;\n  color: #F9FAFC;\n  line-height: 24px;\n  cursor: pointer;\n\n  &:hover {\n    background: #7470E7;\n  }\n\n  &:active {\n    background: #5B57CE;\n  }\n"])));var styled_LoginPoints=styled_components_browser_esm.div(loginPanel_styled_templateObject8||(loginPanel_styled_templateObject8=_taggedTemplateLiteral(["\n  margin-top: 16px;\n  display: flex;\n  flex-wrap: wrap;\n  align-items: center;\n"])));var styled_LoginPointItem=styled_components_browser_esm.div(loginPanel_styled_templateObject9||(loginPanel_styled_templateObject9=_taggedTemplateLiteral(["\n  padding: 5px 12px;\n  border-radius: 15px;\n  color: #605CE5;\n  font-size: 12px;\n  background: rgba(96, 92, 229, 0.1);\n  margin-bottom: 8px;\n  margin-right: 8px;\n"])));
;// CONCATENATED MODULE: ./src/components/safeDialog/safeDialog.tsx
var safeDialog_templateObject;var safeDialog_StorageNotificationBody=styled_components_browser_esm.div(safeDialog_templateObject||(safeDialog_templateObject=_taggedTemplateLiteral(["\n  position: absolute;\n  left: 0px;\n  width: 100%;\n  top: 44px;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  flex-direction: column;\n  .des {\n    height: 60px;\n    width: 231px;\n    font-family: PingFangSC;\n    font-weight: 400;\n    font-size: 12px;\n    color: rgba(39, 38, 77, 0.65);\n    letter-spacing: 0;\n    text-align: justify;\n    line-height: 20px;\n    display: block;\n  }\n  .desHref {\n    height: 20px;\n    width: 96px;\n    font-family: PingFangSC;\n    font-weight: 400;\n    font-size: 12px;\n    color: #605ce5;\n    letter-spacing: 0;\n    text-align: justify;\n    line-height: 20px;\n    display: block;\n    margin-top: 4px;\n    cursor: pointer;\n  }\n  .StorageNotificationContent {\n    margin-top: 16px;\n  }\n"])));var safeDialog_SafeDialog=/*#__PURE__*/(/* unused pure expression or super */ null && (memo(function(props){var _props$idName=props.idName,idName=_props$idName===void 0?"":_props$idName;var env=getGlobalConfig().getEnvInfo();useEffect(function(){if(env.publishName==="publicServer"){service.isWhiteList().then(function(isInc){if(isInc){// todo集团员工账号已经登陆，展示数据安全提示
showInfo();}else{service.getUserInfoIsInAli().then(function(data){// todo集团员工账号已经登陆，展示数据安全提示
showInfo();}).catch(function(e){// 未登录集团员工账号
});}});}},[]);var showInfo=function showInfo(){//获取存储
chrome.storage.local.get(["value"],function(result){if(result.value){if(dayjs().isAfter(result.value)){toastContain();chrome.storage.local.set({value:dayjs().format('YYYY-MM-DD 23:59:59')});}}else{//执行存储
chrome.storage.local.set({value:dayjs().format('YYYY-MM-DD 23:59:59')});toastContain();}});};var toastContain=function toastContain(){return Modal.info({getContainer:function getContainer(){return document.getElementById(idName)||document.body;},centered:true,icon:null,width:272,bodyStyle:{height:220,paddingTop:'28px'},okButtonProps:{style:{marginTop:"88px",marginLeft:"61px",float:"left"}},closable:false,okText:"我知道了",title:"数据安全提示",content:/*#__PURE__*/_jsx(_Fragment,{children:/*#__PURE__*/_jsx(safeDialog_StorageNotificationBody,{children:/*#__PURE__*/_jsxs("div",{className:"StorageNotificationContent",children:[/*#__PURE__*/_jsx("span",{className:"des",children:"\u6B63\u5728\u901A\u8FC7\u96C6\u56E2\u5185\u7F51\u8BBF\u95EE\u542C\u609F\u516C\u7F51\u7248\u672C\uFF0C\u516C\u7F51\u7248\u672C\u4EC5\u670D\u52A1\u4E8E\u4E92\u8054\u7F51\u4E0A\u7684\u4E2A\u4EBA\u7528\u6237\uFF0C\u8BF7\u6CE8\u610F\u6570\u636E\u5916\u6CC4\u98CE\u9669\uFF0C\u52FF\u4E0A\u4F20\u5DE5\u4F5C\u76F8\u5173\u5185\u5BB9\u3002"}),/*#__PURE__*/_jsx("span",{className:"desHref",onClick:function onClick(){service.fetchDomainConfig().then(function(res){if(res.data&&res.data.chrome&&res.data.chrome.version){var u=res.data.chrome.aliVersion;if(u){window.open(u);}}});},children:"\u5B89\u88C5\u5185\u7F51\u7248\u672C\u63D2\u4EF6"})]})})})});};return/*#__PURE__*/_jsx(_Fragment,{});})));
;// CONCATENATED MODULE: ./src/components/safeDialog/index.ts

;// CONCATENATED MODULE: ./src/components/loginPanel/loginPanel.tsx
var loginPoints=[{title:'实时记录划重点'},{title:'字幕形态随心切换'},{title:'实时翻译字幕'},{title:'智能总结提炼'}];var loginPanel_LoginPanel=/*#__PURE__*/(/* unused pure expression or super */ null && (memo(function(props){var _props$visible=props.visible,visible=_props$visible===void 0?true:_props$visible,onCloseApp=props.onCloseApp;var _useConfig=useConfig(),loginUrl=_useConfig.loginUrl;// const left = useMemo(() => {
//   return Math.max(0, window.innerWidth - 500);
// }, []);
var calcStyle=useMemo(function(){return{// left,
display:visible?'flex':'none'};},[visible]);var handleLogin=useCallback(function(){window.open(loginUrl);sendLogWithUnknownUser("chrome_login",{});},[]);return/*#__PURE__*/_jsx(Draggable,{handle:".handle",cancel:".not-handle",bounds:"body",children:/*#__PURE__*/_jsxs(Panel,{style:calcStyle,className:"handle",id:"draggable_panel_login",children:[getGlobalConfig().renderExtContent("draggable_panel_login"),/*#__PURE__*/_jsx(SafeDialog,{idName:"draggable_panel_login"}),/*#__PURE__*/_jsx(EnvMark,{}),/*#__PURE__*/_jsx(Background,{}),/*#__PURE__*/_jsxs(Container,{children:[/*#__PURE__*/_jsx(Logo,{}),/*#__PURE__*/_jsx(Features,{}),/*#__PURE__*/_jsx(LoginPoints,{children:loginPoints===null||loginPoints===void 0?void 0:loginPoints.map(function(item){var title=item.title;return/*#__PURE__*/_jsx(LoginPointItem,{children:title});})}),/*#__PURE__*/_jsx(Button,{onClick:handleLogin,children:"\u767B\u5F55\u4F53\u9A8C"}),/*#__PURE__*/_jsx(CloseButton,{className:"not-handle",onClick:onCloseApp})]})]})});})));
;// CONCATENATED MODULE: ./src/components/loginPanel/index.ts

;// CONCATENATED MODULE: ./src/components/startPanel/styled.tsx
var startPanel_styled_templateObject,startPanel_styled_templateObject2,startPanel_styled_templateObject3,startPanel_styled_templateObject4,startPanel_styled_templateObject5,startPanel_styled_templateObject6,startPanel_styled_templateObject7,startPanel_styled_templateObject8,startPanel_styled_templateObject9,startPanel_styled_templateObject10,styled_templateObject11,styled_templateObject12,_templateObject13,_templateObject14,_templateObject15,_templateObject16,_templateObject17,_templateObject18,_templateObject19,_templateObject20,_templateObject21,_templateObject22,_templateObject23,_templateObject24,_templateObject25;var startPanel_styled_Content=styled_components_browser_esm.div(startPanel_styled_templateObject||(startPanel_styled_templateObject=_taggedTemplateLiteral(["\n  width: 320px;\n  /* height: 76vh; */\n  min-height: 480px;\n  max-height: 960px;\n  position: fixed;\n  z-index: 2147483647;\n  top: 40px;\n  right: 32px;\n  .tweant-modal-content {\n    border-radius: 8px;\n  }\n  .tweant-btn-primary {\n    background-color: #605ce5;\n    border-color: #605ce5;\n    font-size: 14px;\n    color: #fff;\n    border-radius: 8px;\n  }\n  .tweant-btn-primary:hover {\n    background-color: #7470e7;\n    border-color: #7470e7;\n  }\n  .tweant-btn-primary:focus,\n  .tweant-btn-primary:active {\n    background-color: #5b57ce;\n    border-color: #5b57ce;\n  }\n  .tweant-message {\n    top: 103px;\n  }\n  .tweant-modal-confirm-title{\n    font-family: PingFangSC;\n    font-weight: 500;\n    font-size: 14px;\n    color: #27264D;\n    letter-spacing: 0;\n    text-align: center;\n    line-height: 20px;\n  }\n  .tweant-modal-mask {\n    background-color: rgba(185, 184, 222, 0.2);\n    backdrop-filter: blur(6px);\n  }\n  .tweant-message-notice-content {\n    padding: 9px 16px;\n    border-radius: 8px !important;\n    color: #27264d !important;\n  }\n  .react-resizable-handle {\n    position: absolute;\n    left: 4px;\n    right: 4px;\n    box-sizing: border-box;\n    user-select: none;\n    height: 10px;\n    z-index: 201;\n  }\n\n  .react-resizable-handle-n {\n    top: 0;\n    cursor: ",";\n  }\n\n  .react-resizable-handle-s {\n    bottom: 0;\n    cursor: ",";\n  }\n"])),function(props){return props.northMax?'s-resize':'ns-resize';},function(props){return props.southMax?'n-resize':'ns-resize';});var startPanel_styled_Panel=styled_components_browser_esm.div(startPanel_styled_templateObject2||(startPanel_styled_templateObject2=_taggedTemplateLiteral(["\n  width: 100%;\n  height: 100%;\n"])));var startPanel_styled_Background=styled_components_browser_esm.div(startPanel_styled_templateObject3||(startPanel_styled_templateObject3=_taggedTemplateLiteral(["\n  background-color: #F9FAFF;\n  background-image: url(",");\n  background-position: 0 0;\n  background-repeat: no-repeat;\n  background-size: contain;\n  box-shadow: 0 0 1px 1px rgba(63,60,161,0.30);\n  border-radius: 8px;\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 100%;\n  height: 100%;\n  z-index: 1;\n"])),chrome.runtime.getURL('background.svg'));var startPanel_styled_Container=styled_components_browser_esm.div(startPanel_styled_templateObject4||(startPanel_styled_templateObject4=_taggedTemplateLiteral(["\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 100%;\n  height: 100%;\n  z-index: 2;\n  user-select: none;\n"])));var startPanel_styled_Header=styled_components_browser_esm.div(startPanel_styled_templateObject5||(startPanel_styled_templateObject5=_taggedTemplateLiteral(["\n  height: 32px;\n  display: flex;\n  align-items: center;\n  margin: 24px 24px 0;\n"])));var styled_HeaderExtra=styled_components_browser_esm.div(startPanel_styled_templateObject6||(startPanel_styled_templateObject6=_taggedTemplateLiteral(["\n  flex: 1;\n  display: flex;\n  align-items: center;\n  justify-content: flex-end;\n"])));var startPanel_styled_Logo=styled_components_browser_esm.div(startPanel_styled_templateObject7||(startPanel_styled_templateObject7=_taggedTemplateLiteral(["\n  background: url(",") 0 0 no-repeat;\n  background-size: contain;\n  width: ",";\n  height: 24px;\n"])),chrome.runtime.getURL(createConfig_getGlobalConfig().renderLogoUrl()),createConfig_getGlobalConfig().renderLogoSize());var styled_Avatar=styled_components_browser_esm.div(startPanel_styled_templateObject8||(startPanel_styled_templateObject8=_taggedTemplateLiteral(["\n  margin-right: 17px;\n  &, img {\n    width: 32px;\n    height: 32px;\n  }\n  border-radius: 32px;\n  overflow: hidden;\n"])));var startPanel_styled_CloseButton=styled_components_browser_esm.div(startPanel_styled_templateObject9||(startPanel_styled_templateObject9=_taggedTemplateLiteral(["\n  background: url(",") center center no-repeat;\n  width: 20px;\n  height: 20px;\n  cursor: pointer;\n  transition: all 0.3s;\n  &:hover {\n    background: url(",") center center no-repeat;\n  }\n\n  &:active {\n    background: url(",") center center no-repeat;\n  }\n"])),chrome.runtime.getURL('closeLarge.svg'),chrome.runtime.getURL('closeHoverLarge.svg'),chrome.runtime.getURL('closeActiveLarge.svg'));var styled_WarnTipsIcon=styled_components_browser_esm.div(startPanel_styled_templateObject10||(startPanel_styled_templateObject10=_taggedTemplateLiteral(["\n  background: url(",")\n    center center no-repeat;\n  width: 16px;\n  height: 16px;\n  cursor: pointer;\n  margin-left: 4px;\n  transition: all 0.3s;\n  &:hover{\n    background-image: url(",");\n  }\n"])),chrome.runtime.getURL('warn.svg'),chrome.runtime.getURL('warnHover.svg'));var styled_Form=styled_components_browser_esm.div(styled_templateObject11||(styled_templateObject11=_taggedTemplateLiteral(["\n  margin: 28px 24px 24px;\n\n  .transLgControlItem,\n  .saveAsControlItem {\n    &:hover {\n      border-color: rgba(96,92,229,1);\n      box-shadow: 0 0 0 0.5px rgba(96,92,229,1);\n    }\n  }\n\n  .titleControlItem {\n    &:hover {\n      border-color: rgba(96,92,229,1);\n      box-shadow: 0 0 0 0.5px rgba(96,92,229,1), 0 0 0 2px rgba(96,92,229,0.2);\n    }\n  }\n\n  .form_item_focus {\n    border-color: rgba(96,92,229,1);\n    box-shadow: 0 0 0 0.5px rgba(96,92,229,1), 0 0 0 2px rgba(96,92,229,0.2);\n  }\n\n  .form_item_select_focus {\n    border-color: rgba(96,92,229,1);\n    box-shadow: 0 0 0 0.5px rgba(96,92,229,1);\n  }\n"])));var styled_FormItem=styled_components_browser_esm.div(styled_templateObject12||(styled_templateObject12=_taggedTemplateLiteral(["\n  height: 44px;\n  background: #FFFFFF;\n  border: 0.5px solid #DFE3ED;\n  border-radius: 8px;\n  /* overflow: hidden; */\n  display: flex;\n  align-items: center;\n  margin-bottom: 12px;\n  &:last-child {\n    margin-bottom: 0;\n  }\n\n  .transLgControl {\n    .tweant-select-dropdown {\n      width: 273px !important;\n      height: 204px !important;\n      left: -73px !important;\n      top: 43px !important;\n\n      .tweant-select-item {\n        .tweant-select-item-option-content {\n          justify-content: space-between;\n        }\n      }\n    }\n  }\n\n  .saveAsControl {\n    .tweant-select-dropdown {\n      width: 273px !important;\n      left: -59px !important;\n      top: 43px !important;\n    }\n  }\n"])));var styled_FormItemLabel=styled_components_browser_esm.div(_templateObject13||(_templateObject13=_taggedTemplateLiteral(["\n  font-size: 14px;\n  color: rgba(39,38,77,0.65);\n  line-height: 22px;\n  margin-left: 16px;\n"])));var styled_FormItemControl=styled_components_browser_esm.div(_templateObject14||(_templateObject14=_taggedTemplateLiteral(["\n  flex: 1;\n  display: flex;\n  justify-content: flex-end;\n  align-items: center;\n  margin-right: 16px;\n\n  .tweant-switch{\n    scale: 0.75;\n  }\n\n  .tweant-switch{\n    background: #D8D7F2;\n  }\n\n  .tweant-switch-checked{\n    background: #605CE5;\n  }\n\n  .tweant-select {\n    width: 100% !important;\n\n    &:hover {\n      .tweant-select-arrow {\n        background-image: url(",");\n      }\n    }\n  }\n  .tweant-select-selector {\n    border: none !important;\n    box-shadow: none !important;\n    padding-right: 0;\n\n    .label_item {\n      color: #27264D;\n    }\n  }\n  .tweant-select-arrow{\n    width: 16px;\n    height: 16px;\n    background: url(",")\n    center center no-repeat;\n    margin-top: -8px;\n    right: -2px;\n    transform: rotate(180deg);\n\n    .anticon{\n      display: none;\n    }\n  }\n  .tweant-select-selection-item {\n    font-family: PingFangSC-Medium;\n    text-align: right !important;\n    padding: 0 10px 0 9px !important;\n\n    img,.waring_wrap{\n      display: none;\n    }\n    .label_item{\n      height: 32px;\n      line-height: 32px;\n    }\n  }\n  .tweant-select-single.tweant-select-open .tweant-select-selection-item{\n    color: #27264D;\n  }\n  .tweant-select-dropdown{\n    border-radius: 8px !important;\n    .rc-virtual-list-holder{\n      padding: 0 12px;\n    }\n\n    .tweant-select-item-option-active:not(.tweant-select-item-option-disabled){\n      background: #ffffff;\n    }\n\n    .tweant-select-item-option-selected:not(.tweant-select-item-option-disabled){\n      color: #605ce5 !important;\n      font-weight: 400 !important;\n      background-color: transparent !important;\n    }\n\n    .tweant-select-item{\n      height: 48px;\n      border-radius: 4px;\n      color: #27264D;\n      &:hover{\n        background: rgba(96,92,229,0.08);\n      }\n      .tweant-select-item-option-content{\n        display: flex;\n        align-items: center;\n      }\n    }\n  }\n  .tweant-select-open {\n    .tweant-select-arrow {\n      transform: rotate(0deg);\n    }\n  }\n  .tweant-input {\n    border: none !important;\n    outline: none !important;\n    box-shadow: none !important;\n    text-align: right !important;\n    white-space: nowrap;\n    overflow: hidden;\n    text-overflow: ellipsis;\n    word-break: break-all;\n    padding-left: 16px;\n    padding-right: 0px;\n    font-family: PingFangSC-Medium;\n    color: #27264D;\n  }\n"])),chrome.runtime.getURL('selectArrowHover.svg'),chrome.runtime.getURL('selectArrow.svg'));var styled_SubmitButton=styled_components_browser_esm.div(_templateObject15||(_templateObject15=_taggedTemplateLiteral(["\n  margin: 0 24px;\n  height: 40px;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  background: #605CE5;\n  border-radius: 8px;\n  /* margin-top: 24px; */\n  font-size: 14px;\n  color: #F9FAFC;\n  line-height: 24px;\n  cursor: pointer;\n  font-weight: 500;\n\n  &:hover {\n    background: #7470E7;\n  }\n\n  &:active {\n    background: #5B57CE;\n  }\n\n  .tweant-message {\n    top: unset !important;\n    bottom: 107px !important;\n\n    .tweant-message-notice-content {\n      width: 272px;\n    }\n    \n    .tweant-message-custom-content {\n      text-align: left;\n    }\n  }\n"])));var styled_NormalButton=styled_components_browser_esm.div(_templateObject16||(_templateObject16=_taggedTemplateLiteral(["\n  margin: 16px 24px 0;\n  /* cursor: pointer; */\n  font-size: 14px;\n  color: #27264D;\n  line-height: 22px;\n  text-align: center;\n  \n  span {\n    cursor: pointer;\n  }\n\n  &:hover {\n    color: #605CE5;\n  }\n\n  &:active {\n    color: #5B57CE;\n  }\n"])));var startPanel_styled_StopingStyled=styled_components_browser_esm.div(_templateObject17||(_templateObject17=_taggedTemplateLiteral(["\n  position: absolute;\n  top: 0;\n  left: 0;\n  bottom: 0;\n  right: 0;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  background: rgba(0,0,0,0.60);\n  z-index: 2147483647;\n  backdrop-filter: blur(6px);\n"])));var styled_SpanRadio=styled_components_browser_esm.img(_templateObject18||(_templateObject18=_taggedTemplateLiteral(["\n  height: 12px;\n  width: 12px;\n"])));var styled_FolderRadio=styled_components_browser_esm.img(_templateObject19||(_templateObject19=_taggedTemplateLiteral(["\n  height: 20px;\n  width: 20px;\n  margin: 0 8px;\n"])));var styled_WarningRadio=styled_components_browser_esm.img(_templateObject20||(_templateObject20=_taggedTemplateLiteral(["\n  height: 16px;\n  width: 16px;\n  margin-right: 4px;\n"])));var styled_LabelWrap=styled_components_browser_esm.div(_templateObject21||(_templateObject21=_taggedTemplateLiteral(["\n  .label_item{ \n    color: #27264D;\n    max-width: 180px;\n    white-space: nowrap;\n    overflow: hidden;\n    text-overflow: ellipsis;\n    word-break: break-all;\n  }\n"])));var styled_WarningWrap=styled_components_browser_esm.div(_templateObject22||(_templateObject22=_taggedTemplateLiteral(["\n  display: flex;\n  align-items: center;\n  position: absolute;\n  font-size: 12px;\n  bottom: -5px;\n  color: rgba(39,38,77,0.45);\n"])));var styled_SuccessMsg=styled_components_browser_esm.span(_templateObject23||(_templateObject23=_taggedTemplateLiteral(["\n  color: rgba(39,38,77,0.7);\n  font-size: 14px;\n\n  span{\n    color: #605CE5;\n    margin: 0 2px;\n    cursor: pointer;\n  }\n"])));var startPanel_styled_SelectIcon=styled_components_browser_esm.img(_templateObject24||(_templateObject24=_taggedTemplateLiteral(["\n  width: 16px;\n  height: 16px;\n"])));var styled_BottomContent=styled_components_browser_esm.div(_templateObject25||(_templateObject25=_taggedTemplateLiteral(["\n  width: 100%;\n  position: absolute;\n  left: 0;\n  bottom: 24px;\n\n  .tweant-tooltip {\n    top: -70px !important;\n    max-width: 272px !important;\n\n    .tweant-tooltip-arrow-content {\n      --antd-arrow-background-color: rgb(255, 255, 255) !important;\n    }\n  }\n"])));
;// CONCATENATED MODULE: ./src/utils/chrome.ts
var getCurrentTab=function getCurrentTab(){return new Promise(function(resolve){chrome.tabs.query({active:true,currentWindow:true},function(tabs){var tab=tabs[0];resolve(tab);});});};
;// CONCATENATED MODULE: ./src/utils/stream.ts
// @ts-ignore
if(!navigator.getUserMedia){// @ts-ignore
navigator.getUserMedia=navigator.getUserMedia||navigator.webkitGetUserMedia||navigator.mozGetUserMedia||navigator.msGetUserMedia;}var getMicStream=function getMicStream(){return new Promise(function(resolve,reject){// @ts-ignore
if(navigator.getUserMedia){// @ts-ignore
navigator.getUserMedia({audio:true},function(stream){resolve(stream);},function(error){reject(error);});}else{reject();}});};var getTingwuAudioContextByStreamId=function getTingwuAudioContextByStreamId(streamId,enableMicphone){return new Promise(function(resolve,reject){navigator.mediaDevices.getUserMedia({video:{// @ts-ignore
mandatory:{chromeMediaSource:'screen',chromeMediaSourceId:streamId}},audio:{// @ts-ignore
mandatory:{chromeMediaSource:'desktop',chromeMediaSourceId:streamId}}}).then(/*#__PURE__*/function(){var _ref=_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(stream){var audioCtx,source,micStream,gain,destination,tingwuAudioContext;return _regeneratorRuntime().wrap(function _callee$(_context){while(1)switch(_context.prev=_context.next){case 0:stream.removeTrack(stream.getVideoTracks()[0]);audioCtx=new AudioContext({sampleRate:16000});if(!enableMicphone){_context.next=21;break;}_context.prev=3;_context.next=6;return getMicStream();case 6:micStream=_context.sent;_context.next=13;break;case 9:_context.prev=9;_context.t0=_context["catch"](3);stream===null||stream===void 0?void 0:stream.getTracks().forEach(function(track){track.stop();});reject({type:'micPermissionDenied'});case 13:gain=audioCtx.createGain();if(micStream){audioCtx.createMediaStreamSource(micStream).connect(gain);}audioCtx.createMediaStreamSource(stream).connect(gain);destination=audioCtx.createMediaStreamDestination();gain.connect(destination);source=audioCtx.createMediaStreamSource(destination.stream);_context.next=22;break;case 21:source=audioCtx.createMediaStreamSource(stream);case 22:tingwuAudioContext={tabStream:stream,micStream:micStream,source:source,audioContext:audioCtx};resolve(tingwuAudioContext);case 24:case"end":return _context.stop();}},_callee,null,[[3,9]]);}));return function(_x){return _ref.apply(this,arguments);};}());});};
;// CONCATENATED MODULE: ./src/utils/env.ts
var getChromeMainVersion=function getChromeMainVersion(){var match=navigator.userAgent.match(/Chrome\/(\d+)/);return match?parseInt(match[1]):undefined;};
;// CONCATENATED MODULE: ./src/utils/index.ts

;// CONCATENATED MODULE: ./src/components/selectShare/styled.tsx
var selectShare_styled_templateObject,selectShare_styled_templateObject2;var selectShare_styled_Content=styled_components_browser_esm.div(selectShare_styled_templateObject||(selectShare_styled_templateObject=_taggedTemplateLiteral(["\n  font-size: 14px;\n  color: #27264D;\n  display: flex;\n  justify-content: space-between;\n"])));var selectShare_styled_WarnTipsIcon=styled_components_browser_esm.div(selectShare_styled_templateObject2||(selectShare_styled_templateObject2=_taggedTemplateLiteral(["\n  background: url(",") center center no-repeat;\n  min-width: 16px;\n  height: 16px;\n  margin-right: 8px;\n  margin-top: 3px;\n"])),chrome.runtime.getURL('warnLargeHover.svg'));
;// CONCATENATED MODULE: ./src/components/selectShare/selectShare.tsx
var selectShare_SelectShare=/*#__PURE__*/(/* unused pure expression or super */ null && (memo(function(){return/*#__PURE__*/_jsxs(Content,{children:[/*#__PURE__*/_jsx(WarnTipsIcon,{}),"\u70B9\u51FB\u9009\u62E9\u6807\u7B7E\u9875\u5E76\u5206\u4EAB\u97F3\u9891\uFF0C\u5373\u53EF\u5F00\u542F\u5B9E\u65F6\u8BB0\u5F55"]});})));
;// CONCATENATED MODULE: ./src/components/selectShare/index.ts

;// CONCATENATED MODULE: ./src/components/startPanel/startPanel.tsx
var startPanel_mainVersion=getChromeMainVersion();var defaultFilename=dayjs_min_default()().format("YYYY-MM-DD HH:mm 记录");var transLanguageObj={cn:1,en:2,yue:3,fspk:4};var transLanguageOptions=[{title:'中文',value:'cn'},{title:'英语',value:'en'},{title:'粤语',value:'yue'},{title:'中英文自由说',value:'fspk'}];var isMac=/macintosh|mac os x/i.test(navigator.userAgent);var startPanel_StartPanel=/*#__PURE__*/(/* unused pure expression or super */ null && (memo(function(props){var _props$visible=props.visible,visible=_props$visible===void 0?true:_props$visible,_props$isVisibleTips=props.isVisibleTips,isVisibleTips=_props$isVisibleTips===void 0?false:_props$isVisibleTips,_props$hasNoCompetenc=props.hasNoCompetence,hasNoCompetence=_props$hasNoCompetenc===void 0?false:_props$hasNoCompetenc,onCloseApp=props.onCloseApp,getTransId=props.getTransId;var _useConfig=useConfig(),tingwuUrl=_useConfig.tingwuUrl;var _useRecord=useRecord(),startRecord=_useRecord.startRecord;var folders=useRecoilValue(foldersState);var avatarUrl=useRecoilValue(avatarUrlState);var _usePanelVisible=usePanelVisible(),showMainPanel=_usePanelVisible.showMainPanel;var _useState=useState(false),_useState2=_slicedToArray(_useState,2),enabledMicphone=_useState2[0],setEnabledMicphone=_useState2[1];var _useState3=useState('0'),_useState4=_slicedToArray(_useState3,2),saveAs=_useState4[0],setSaveAs=_useState4[1];var _useRecoilState=useRecoilState(sourceLanguageState),_useRecoilState2=_slicedToArray(_useRecoilState,2),sourceLanguage=_useRecoilState2[0],setSourceLanguage=_useRecoilState2[1];var _useState5=useState(false),_useState6=_slicedToArray(_useState5,2),transLgSelectFocus=_useState6[0],setTransLgSelectFocus=_useState6[1];var _useState7=useState(defaultFilename),_useState8=_slicedToArray(_useState7,2),filename=_useState8[0],setFilename=_useState8[1];var _useState9=useState(defaultFilename),_useState10=_slicedToArray(_useState9,2),prevFilename=_useState10[0],setPrevFilename=_useState10[1];// 上一次保留的标题，为空取
var _useState11=useState(false),_useState12=_slicedToArray(_useState11,2),selectFocus=_useState12[0],setSelectFocus=_useState12[1];var _useState13=useState(false),_useState14=_slicedToArray(_useState13,2),inputFocus=_useState14[0],setInputFocus=_useState14[1];var inputRef=useRef();var draggableRef=useRef();var SubmitButtonRef=useRef();var _useRecoilState3=useRecoilState(isNotifyUserTransFinishState),_useRecoilState4=_slicedToArray(_useRecoilState3,2),isNotifyUserTransFinish=_useRecoilState4[0],setIsNotifyUserTransFinish=_useRecoilState4[1];var _useState15=useState(false),_useState16=_slicedToArray(_useState15,2),titleTipsVisible=_useState16[0],setTitleTipsVisible=_useState16[1];var _useRecoilState5=useRecoilState(transIdState),_useRecoilState6=_slicedToArray(_useRecoilState5,2),transId=_useRecoilState6[0],setTransId=_useRecoilState6[1];var _useRecoilState7=useRecoilState(panelHeightState),_useRecoilState8=_slicedToArray(_useRecoilState7,2),panelHeight=_useRecoilState8[0],setPanelHeight=_useRecoilState8[1];var _useRecoilState9=useRecoilState(panelPositionState),_useRecoilState10=_slicedToArray(_useRecoilState9,2),panelPosition=_useRecoilState10[0],setPanelPosition=_useRecoilState10[1];var _useState17=useState(false),_useState18=_slicedToArray(_useState17,2),northMax=_useState18[0],setNorthMax=_useState18[1];var _useState19=useState(false),_useState20=_slicedToArray(_useState19,2),southMax=_useState20[0],setSouthMax=_useState20[1];var _useMarksGuide=useMarksGuide(),fetchMarksGuide=_useMarksGuide.fetchMarksGuide;// const left = useMemo(() => {
//   return Math.max(0, window.innerWidth - 500);
// }, []);
var resizeableProps=useMemo(function(){return{resizeHandles:['s'],draggableOpts:{grid:[1,1]},minConstraints:[320,480],maxConstraints:[320,window.innerHeight>960?960:window.innerHeight]};},[window.innerHeight]);var onDrag=useCallback(function(_event,data){var x=data.x,y=data.y;if(y+panelHeight+40<window.innerHeight-24){setSouthMax(false);}else{setSouthMax(true);}setPanelPosition({x:x,y:y});},[panelHeight]);var onResize=useCallback(function(_event,data){var handle=data.handle,size=data.size;if(handle==='s'){// 向下拉伸临界点
if(size.height+panelPosition.y+40>=window.innerHeight||size.height>=960){setSouthMax(true);return;}else{setSouthMax(false);}}setPanelHeight(size.height);},[panelPosition]);var calcStyle=useMemo(function(){return{// left,
height:panelHeight,display:visible?'flex':'none'};},[panelHeight,visible]);var handleStartRecord=useCallback(function(){if(hasNoCompetence){message.destroy();message.config({getContainer:function getContainer(){return SubmitButtonRef.current;}});message.warn({content:/*#__PURE__*/_jsx(_Fragment,{children:"\u62B1\u6B49\uFF0C\u5F53\u524D\u7F51\u9875\u65E0\u6CD5\u4F7F\u7528\u672C\u529F\u80FD"}),duration:3});}var trimFilename=filename.trim();if(!trimFilename){window.alert('请输入有效的标题');return;}fetchMarksGuide();showMainPanel();startRecord(enabledMicphone,trimFilename,saveAs,sourceLanguage);if(enabledMicphone){sendLog('turn_on_record_local',{et:'CLK',c1:1});}else{sendLog('turn_off_record_local',{et:'CLK',c1:2});}sendLog('save_file_folder',{et:'CLK',c1:saveAs==='0'?1:2});if(filename!==defaultFilename){sendLog('edit_file_title',{et:'INPUT'});}sendLog('trans_language_select',{et:'CLK',c1:transLanguageObj[sourceLanguage]});sendLog('start_record',{et:'CLK'});},[enabledMicphone,filename,saveAs,sourceLanguage,hasNoCompetence]);var handleGotoTingwu=useCallback(function(){window.open(tingwuUrl);sendLog('check_history_summary',{et:'CLK'});},[tingwuUrl]);var handleGotoTingwuTrans=useCallback(function(){var u=tingwuUrl+'/doc/edit/file?transId='+getTransId();window.open(u);sendLog('check_history_summary',{et:'CLK'});},[tingwuUrl]);var saveAsOptions=useMemo(function(){// const options = [{ label: '默认文件夹', value: '0', disabled: false }];
var options=[];folders.forEach(function(folder){options.push({label:"".concat(folder.dirName).concat(folder.isFull?'（已达上限）':''),value:String(folder.dirId),disabled:folder.isFull});});var lastItem=options.pop();options.unshift(lastItem);return options;},[folders]);var onBlur=function onBlur(){var _inputRef$current,_inputRef$current$inp,_inputRef$current4;if((inputRef===null||inputRef===void 0?void 0:(_inputRef$current=inputRef.current)===null||_inputRef$current===void 0?void 0:(_inputRef$current$inp=_inputRef$current.input)===null||_inputRef$current$inp===void 0?void 0:_inputRef$current$inp.value.trim())===''){setFilename(prevFilename);}else{var _inputRef$current2,_inputRef$current2$in,_inputRef$current3,_inputRef$current3$in;setFilename(inputRef===null||inputRef===void 0?void 0:(_inputRef$current2=inputRef.current)===null||_inputRef$current2===void 0?void 0:(_inputRef$current2$in=_inputRef$current2.input)===null||_inputRef$current2$in===void 0?void 0:_inputRef$current2$in.value);setPrevFilename(inputRef===null||inputRef===void 0?void 0:(_inputRef$current3=inputRef.current)===null||_inputRef$current3===void 0?void 0:(_inputRef$current3$in=_inputRef$current3.input)===null||_inputRef$current3$in===void 0?void 0:_inputRef$current3$in.value);}inputRef===null||inputRef===void 0?void 0:(_inputRef$current4=inputRef.current)===null||_inputRef$current4===void 0?void 0:_inputRef$current4.blur();setInputFocus(false);};var onMouseEnter=function onMouseEnter(e){if(e.target.offsetWidth<e.target.scrollWidth){setTitleTipsVisible(true);}else{setTitleTipsVisible(false);}};var _useRecoilState11=useRecoilState(isExpandState),_useRecoilState12=_slicedToArray(_useRecoilState11,2),isExpand=_useRecoilState12[0],setIsExpand=_useRecoilState12[1];useEffect(function(){setEnabledMicphone(false);setSaveAs('0');setFilename(dayjs().format("YYYY-MM-DD HH:mm 记录"));setPrevFilename(dayjs().format("YYYY-MM-DD HH:mm 记录"));},[visible]);useEffect(function(){setIsExpand(true);},[]);useEffect(function(){if(!draggableRef.current||!isNotifyUserTransFinish)return;// 通过其他方式触发message
setIsNotifyUserTransFinish(false);message.destroy();message.config({getContainer:function getContainer(){return draggableRef.current;}});message.success({content:/*#__PURE__*/_jsxs(SuccessMsg,{children:["\u8BB0\u5F55\u5DF2\u4FDD\u5B58\uFF0C",/*#__PURE__*/_jsx("span",{style:{fontWeight:isMac?500:600},onClick:handleGotoTingwuTrans,children:"\u7ACB\u5373\u67E5\u770B"})]}),duration:3});sendLog('stop_record_success',{et:'SYS',c1:''});},[isNotifyUserTransFinish]);var recorderTooltip=useMemo(function(){if(startPanel_mainVersion&&(startPanel_mainVersion===107||startPanel_mainVersion===108)&&enabledMicphone){return/*#__PURE__*/_jsx(Tooltip,{color:"rgb(39, 38, 77)",overlayInnerStyle:{borderRadius:"8px",padding:"4px 12px",fontSize:"12px"},title:"\u4F60\u5F53\u524D\u4F7F\u7528\u7684\u6D4F\u89C8\u5668\u662FChrome107\u6216108\u7248\u672C\uFF0C\u5B58\u5728\u5F55\u97F3\u529F\u80FD\u4E22\u5E27\u73B0\u8C61\uFF0C\u4F1A\u5BFC\u81F4\u542C\u609F\u5F55\u97F3\u529F\u80FD\u5F02\u5E38\uFF0C\u5EFA\u8BAE\u5173\u95ED\u672C\u5730\u5F55\u5236\u3002",getPopupContainer:function getPopupContainer(triggerNode){return triggerNode.parentElement;},children:/*#__PURE__*/_jsx(WarnTipsIcon,{})});}return null;},[enabledMicphone]);return/*#__PURE__*/_jsx(Draggable,{onDrag:onDrag,position:panelPosition,handle:".handle",cancel:".not-handle",bounds:"body",children:/*#__PURE__*/_jsx(Resizable,_objectSpread(_objectSpread({width:320,height:panelHeight,onResize:onResize},resizeableProps),{},{children:/*#__PURE__*/_jsx(Content,{style:_objectSpread({},calcStyle),northMax:northMax,southMax:southMax,children:/*#__PURE__*/_jsxs(Panel,{id:"draggable_panel",ref:draggableRef,className:"handle",children:[getGlobalConfig().renderExtContent("draggable_panel"),/*#__PURE__*/_jsx(SafeDialog,{idName:"draggable_panel"}),/*#__PURE__*/_jsx(EnvMark,{}),/*#__PURE__*/_jsx(Background,{}),/*#__PURE__*/_jsxs(Container,{children:[/*#__PURE__*/_jsxs(Header,{children:[/*#__PURE__*/_jsx(Logo,{}),/*#__PURE__*/_jsxs(HeaderExtra,{children:[/*#__PURE__*/_jsx(Avatar,{children:/*#__PURE__*/_jsx("img",{src:avatarUrl})}),/*#__PURE__*/_jsx(CloseButton,{onClick:onCloseApp})]})]}),/*#__PURE__*/_jsxs(Form,{className:"not-handle",children:[/*#__PURE__*/_jsxs(FormItem,{children:[/*#__PURE__*/_jsxs(FormItemLabel,{style:{display:"flex",alignItems:"center"},children:["\u540C\u65F6\u5F55\u5236\u672C\u5730\u9EA6\u514B\u98CE",recorderTooltip]}),/*#__PURE__*/_jsx(FormItemControl,{style:{marginRight:12},children:/*#__PURE__*/_jsx(Switch,{size:"small",checked:enabledMicphone,onChange:setEnabledMicphone})})]}),/*#__PURE__*/_jsxs(FormItem,{className:"transLgControlItem ".concat(transLgSelectFocus&&"form_item_select_focus"),children:[/*#__PURE__*/_jsx(FormItemLabel,{children:"\u8F6C\u5199\u8BED\u8A00"}),/*#__PURE__*/_jsx(FormItemControl,{className:"transLgControl",style:{maxWidth:183},children:/*#__PURE__*/_jsx(Select,{placement:"bottomRight",value:sourceLanguage,onChange:setSourceLanguage,onDropdownVisibleChange:function onDropdownVisibleChange(visible){return setTransLgSelectFocus(visible);},getPopupContainer:function getPopupContainer(triggerNode){return triggerNode.parentElement;},children:transLanguageOptions===null||transLanguageOptions===void 0?void 0:transLanguageOptions.map(function(item){var title=item.title,value=item.value;return/*#__PURE__*/_jsxs(Select.Option,{value:value,style:{display:'flex',alignItems:'center',justifyContent:'space-between'},children:[/*#__PURE__*/_jsx("div",{className:"label_item",children:title}),sourceLanguage===value&&/*#__PURE__*/_jsx(SelectIcon,{src:"".concat(chrome.runtime.getURL('selectOptionCheck.svg'))})]},value);})})})]}),/*#__PURE__*/_jsxs(FormItem,{className:"saveAsControlItem ".concat(selectFocus&&"form_item_select_focus"),children:[/*#__PURE__*/_jsx(FormItemLabel,{children:"\u4FDD\u5B58\u81F3"}),/*#__PURE__*/_jsx(FormItemControl,{className:"saveAsControl",style:{maxWidth:197},children:/*#__PURE__*/_jsx(Select,{placement:"bottomRight",listHeight:330,value:saveAs,onChange:setSaveAs// options={saveAsOptions}
,onDropdownVisibleChange:function onDropdownVisibleChange(visible){return setSelectFocus(visible);},getPopupContainer:function getPopupContainer(triggerNode){return triggerNode.parentElement;},children:saveAsOptions===null||saveAsOptions===void 0?void 0:saveAsOptions.map(function(item){var label=item.label,value=item.value,disabled=item.disabled;return/*#__PURE__*/_jsxs(Select.Option,{value:value,disabled:disabled,children:[/*#__PURE__*/_jsx(SpanRadio,{src:disabled?"".concat(chrome.runtime.getURL('selectRadioDisabled.svg')):value===saveAs?"".concat(chrome.runtime.getURL('selectRadioActive.svg')):"".concat(chrome.runtime.getURL('selectRadioDefault.svg'))}),/*#__PURE__*/_jsx(FolderRadio,{src:disabled?"".concat(chrome.runtime.getURL('folderRadioDisabled.svg')):"".concat(chrome.runtime.getURL('folderRadioDefault.svg'))}),/*#__PURE__*/_jsxs(LabelWrap,{children:[/*#__PURE__*/_jsx("div",{className:"label_item",children:label}),disabled&&/*#__PURE__*/_jsxs(WarningWrap,{className:"waring_wrap",children:[/*#__PURE__*/_jsx(WarningRadio,{src:"".concat(chrome.runtime.getURL('warnRadio.svg'))}),/*#__PURE__*/_jsx("span",{children:"\u5DF2\u8FBE\u4E0A\u9650\uFF0C\u4E0D\u53EF\u6DFB\u52A0"})]})]})]},value);})})})]}),/*#__PURE__*/_jsxs(FormItem,{className:"titleControlItem ".concat(inputFocus&&"form_item_focus"),children:[/*#__PURE__*/_jsx(FormItemLabel,{className:"form_item_label",children:"\u6807\u9898"}),/*#__PURE__*/_jsx(FormItemControl,{children:/*#__PURE__*/_jsx(Tooltip,{color:"rgb(39, 38, 77)",overlayInnerStyle:{borderRadius:"8px",padding:"4px 12px",fontSize:"12px"},title:filename,visible:!inputFocus&&titleTipsVisible,getPopupContainer:function getPopupContainer(triggerNode){return triggerNode.parentElement;},children:/*#__PURE__*/_jsx(Input,{ref:inputRef,maxLength:150,value:filename,onChange:function onChange(e){return setFilename(e.target.value);},onBlur:onBlur,onFocus:function onFocus(){return setInputFocus(true);},onPressEnter:onBlur,onMouseEnter:onMouseEnter,onMouseLeave:function onMouseLeave(){return setTitleTipsVisible(false);}})})})]})]}),/*#__PURE__*/_jsxs(BottomContent,{children:[isVisibleTips?/*#__PURE__*/_jsx(Tooltip,{placement:"top",color:"#fff",overlayInnerStyle:{borderRadius:"8px",padding:"8px 16px"},title:/*#__PURE__*/_jsx(SelectShare,{}),open:true,getPopupContainer:function getPopupContainer(triggerNode){return triggerNode.parentElement;},children:/*#__PURE__*/_jsx(SubmitButton,{id:"Submit_Button",ref:SubmitButtonRef,className:"not-handle",onClick:handleStartRecord,children:"\u5F00\u542F\u5B9E\u65F6\u8BB0\u5F55"})}):/*#__PURE__*/_jsx(SubmitButton,{id:"Submit_Button",ref:SubmitButtonRef,className:"not-handle",onClick:handleStartRecord,children:"\u5F00\u542F\u5B9E\u65F6\u8BB0\u5F55"}),/*#__PURE__*/_jsx(NormalButton,{className:"not-handle",children:/*#__PURE__*/_jsx("span",{onClick:handleGotoTingwu,children:"\u67E5\u770B\u5386\u53F2\u8BB0\u5F55"})})]})]})]})})}))});})));
;// CONCATENATED MODULE: ./src/components/startPanel/index.ts

;// CONCATENATED MODULE: ./node_modules/_@ali_tingwu-common@0.3.9@@ali/tingwu-common/dist-web/eventer.js

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 = eventer_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 eventer_unsupportedIterableToArray(o, minLen) {
  if (!o) return;
  if (typeof o === "string") return eventer_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 eventer_arrayLikeToArray(o, minLen);
}
function eventer_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;
}
var EventResult = /*#__PURE__*/function () {
  function EventResult() {
    this._isDefaultPrevented = false;
    this._isStopped = false;
  }
  var _proto = EventResult.prototype;
  _proto.preventDefault = function preventDefault() {
    this._isDefaultPrevented = true;
  };
  _proto.stop = function stop() {
    this._isStopped = true;
  };
  _createClass(EventResult, [{
    key: "isDefaultPrevented",
    get: function get() {
      return this._isDefaultPrevented;
    }
  }, {
    key: "isStopped",
    get: function get() {
      return this._isStopped;
    }
  }]);
  return EventResult;
}();
function nextTick(callback) {
  if (typeof window === 'object' && window.requestAnimationFrame) window.requestAnimationFrame(callback);else if (typeof setTimeout === 'function') setTimeout(callback, 1); // 若不支持setTimeout降级为同步方法（例如j2v8环境）
  else callback();
}
var Eventer = /*#__PURE__*/function () {
  function Eventer() {
    this.listeners = {};
  }
  var _proto2 = Eventer.prototype;

  /* 绑定事件监听器 */
  _proto2.on = function on(type, handler) {
    var _this = this;
    var list = this.listeners[type] || [];
    list.push(handler);
    this.listeners[type] = list;
    return function () {
      return _this.off(type, handler);
    };
  }
  /**
   * 把当前已经注册的监听器重新输送出去
   * @param callback 输出的回调
   * @param clearCurrent 输出后是否清除当前实例上的监听器
   */;

  _proto2.pipe = function pipe(callback, clearCurrent) {
    if (clearCurrent === void 0) {
      clearCurrent = true;
    }
    var listeners = this.listeners;
    Object.keys(listeners).forEach(function (key) {
      var list = listeners[key] || [];
      list.forEach(function (h) {
        return callback(key, h);
      });
    });
    if (clearCurrent) this.listeners = {};
  }
  /* 移除事件监听器 */;

  _proto2.off = function off(type, handler) {
    var list = this.listeners[type] || [];
    this.listeners[type] = handler ? list.filter(function (f) {
      return f !== handler;
    }) : [];
  }
  /* 移除所有监听器 */;

  _proto2.offAll = function offAll() {
    var _this2 = this;
    Object.keys(this.listeners).forEach(function (k) {
      _this2.listeners[k] = [];
    });
  }
  /* 触发事件（同步执行） */;

  _proto2.emit = function emit(type, event) {
    var eventResult = new EventResult();
    var list = this.listeners[type] || [];
    for (var _iterator = _createForOfIteratorHelperLoose(list), _step; !(_step = _iterator()).done;) {
      var _handler = _step.value;
      _handler(event, eventResult);
      if (eventResult.isStopped) {
        break;
      }
    }
    return eventResult;
  }
  /* 触发事件（下一帧执行） */;

  _proto2.emitAsync = function emitAsync(type, event) {
    var _this3 = this;
    nextTick(function () {
      return _this3.emit(type, event);
    });
  };
  return Eventer;
}();
;// CONCATENATED MODULE: ./src/eventer.ts
var eventer_eventer=new Eventer();
;// CONCATENATED MODULE: ./src/components/app/app.tsx
var _getGlobalConfig$getE=createConfig_getGlobalConfig().getEnvInfo(),app_env=_getGlobalConfig$getE.env,app_publishName=_getGlobalConfig$getE.publishName;var aemDelegationUrl='https://g.alicdn.com/idst-fe/tingwu-chrome-extension-aem-delegation/0.0.3/index.html';var App=/*#__PURE__*/(/* unused pure expression or super */ null && (memo(function(props){var controller=props.controller,meetingController=props.meetingController,timer=props.timer,getTransId=props.getTransId,getMeetingContext=props.getMeetingContext;var _usePanelVisible=usePanelVisible(),mainPanelVisible=_usePanelVisible.mainPanelVisible,captionVisible=_usePanelVisible.captionVisible;var _useFolder=useFolder(),fetchFolders=_useFolder.fetchFolders;var _useUser=useUser(),fetchUser=_useUser.fetchUser;var username=useRecoilValue(userNameState);var uid=useRecoilValue(userIdState);var isLogin=useRecoilValue(isLoginState);var _useRecoilState=useRecoilState(isShowAppState),_useRecoilState2=_slicedToArray(_useRecoilState,2),isShowApp=_useRecoilState2[0],setIsShowApp=_useRecoilState2[1];var _useRecoilState3=useRecoilState(isStartRecordState),_useRecoilState4=_slicedToArray(_useRecoilState3,2),isStartRecord=_useRecoilState4[0],setIsStartRecord=_useRecoilState4[1];var setIsPauseRecord=useSetRecoilState(isPauseRecordState);var appReady=useRecoilValue(appReadyState);var setIsStoping=useSetRecoilState(isStopingState);var setSecond=useSetRecoilState(secondState);var setIsNotifyUserTransFinish=useSetRecoilState(isNotifyUserTransFinishState);var _useState=useState(false),_useState2=_slicedToArray(_useState,2),isVisibleTips=_useState2[0],setIsVisibleTips=_useState2[1];var _useState3=useState(false),_useState4=_slicedToArray(_useState3,2),hasNoCompetence=_useState4[0],setHasNoCompetence=_useState4[1];var setTransId=useSetRecoilState(transIdState);var unknownLogSenderRef=useRef(null);var logSenderRef=useRef(null);var unknownAemIframeUrl=useMemo(function(){return"".concat(aemDelegationUrl,"?env=").concat(app_env,"&dim1=").concat(app_publishName);},[]);var aemIframeUrl=useMemo(function(){if(!uid){return null;}return"".concat(aemDelegationUrl,"?env=").concat(app_env,"&dim1=").concat(app_publishName,"&username=").concat(username,"&uid=").concat(uid);},[uid,username]);useEffect(function(){setSendLogWithUnknownUser(function(eventId,params){var _unknownLogSenderRef$;if(!unknownLogSenderRef.current){return;}(_unknownLogSenderRef$=unknownLogSenderRef.current.contentWindow)===null||_unknownLogSenderRef$===void 0?void 0:_unknownLogSenderRef$.postMessage({type:'log',payload:{eventId:eventId,params:params}},'\*');});},[]);useEffect(function(){if(!uid){return;}setSendLog(function(eventId,params){var _logSenderRef$current;if(!logSenderRef.current){return;}(_logSenderRef$current=logSenderRef.current.contentWindow)===null||_logSenderRef$current===void 0?void 0:_logSenderRef$current.postMessage({type:'log',payload:{eventId:eventId,params:params}},'\*');});},[uid]);useEffect(function(){return eventer.on('recalled',function(param){setIsShowApp(true);setIsVisibleTips(param.isVisibleTips);setHasNoCompetence(param.hasNoCompetence);});},[]);useEffect(function(){if(isStartRecord)setIsVisibleTips(false);},[isStartRecord]);useEffect(function(){if(hasNoCompetence){message.destroy();message.config({getContainer:function getContainer(){return document.getElementById('Submit_Button')||document.body;}});message.warn({content:/*#__PURE__*/_jsx(_Fragment,{children:"\u62B1\u6B49\uFF0C\u5F53\u524D\u7F51\u9875\u65E0\u6CD5\u4F7F\u7528\u672C\u529F\u80FD"}),duration:3});}},[hasNoCompetence]);useEffect(function(){return meetingController.on('meetingStateChange',function(_ref){var state=_ref.state;if(state===MeetingState.PreparePause||state===MeetingState.PrepareStop){setIsStoping(true);}else{setIsStoping(false);}if(state===MeetingState.Stop){setIsNotifyUserTransFinish(true);}if(state===MeetingState.InMeeting){setIsStartRecord(true);setIsPauseRecord(false);}else if(state===MeetingState.Pause){setIsPauseRecord(true);}else if(meetingController.isMeetingIdle()){setIsStartRecord(false);}});},[meetingController]);var checkLoginStatus=useCallback(function(){fetchFolders();fetchUser();},[]);var time=useRef(null);useEffect(function(){if(isShowApp){time.current&&clearInterval(time.current);time.current=null;checkLoginStatus();time.current=setInterval(function(){checkLoginStatus();},2000);}else{time.current&&clearInterval(time.current);time.current=null;}},[isShowApp]);useEffect(function(){return function(){time.current&&clearInterval(time.current);time.current=null;};},[]);useEffect(function(){if(getTransId()){setTransId(getTransId());}},[getTransId()]);useEffect(function(){return timer.on('timeChange',function(_ref2){var time=_ref2.time;setSecond(time/1000);});},[timer]);var handleCloseApp=useRecoilCallback(function(_ref3){var set=_ref3.set;return function(){set(isShowAppState,false);};});var renderedContent=useMemo(function(){if(!appReady||!isShowApp){return null;}if(!isLogin){return/*#__PURE__*/_jsx(LoginPanel,{onCloseApp:handleCloseApp});}if(!isStartRecord){return/*#__PURE__*/_jsx(StartPanel,{hasNoCompetence:hasNoCompetence,isVisibleTips:isVisibleTips,onCloseApp:handleCloseApp,getTransId:getTransId});}return/*#__PURE__*/_jsxs(_Fragment,{children:[/*#__PURE__*/_jsx(MainPanel,{visible:mainPanelVisible,controller:controller,meetingController:meetingController,getMeetingContext:getMeetingContext}),/*#__PURE__*/_jsx(CaptionContainer,{visible:captionVisible,controller:controller,meetingController:meetingController,getMeetingContext:getMeetingContext})]});},[appReady,isShowApp,isLogin,handleCloseApp,isVisibleTips,isStartRecord,mainPanelVisible,captionVisible,controller,meetingController,hasNoCompetence]);return/*#__PURE__*/_jsxs(_Fragment,{children:[renderedContent,/*#__PURE__*/_jsx("iframe",{ref:unknownLogSenderRef,src:unknownAemIframeUrl,width:0,height:0,style:{position:'absolute',top:0,opacity:0,zIndex:-1}}),aemIframeUrl&&/*#__PURE__*/_jsx("iframe",{ref:logSenderRef,src:aemIframeUrl,width:0,height:0,style:{position:'absolute',top:0,opacity:0,zIndex:-1}})]});})));
;// CONCATENATED MODULE: ./src/components/app/index.ts

;// CONCATENATED MODULE: ./src/components/index.ts

;// CONCATENATED MODULE: ./src/reportWebVitals.ts
var reportWebVitals=function reportWebVitals(onPerfEntry){if(onPerfEntry&&onPerfEntry instanceof Function){__webpack_require__.e(/* import() */ 923).then(__webpack_require__.bind(__webpack_require__, 2923)).then(function(_ref){var getCLS=_ref.getCLS,getFID=_ref.getFID,getFCP=_ref.getFCP,getLCP=_ref.getLCP,getTTFB=_ref.getTTFB;getCLS(onPerfEntry);getFID(onPerfEntry);getFCP(onPerfEntry);getLCP(onPerfEntry);getTTFB(onPerfEntry);});}};/* harmony default export */ var src_reportWebVitals = (reportWebVitals);
;// CONCATENATED MODULE: ./node_modules/_antd@4.24.8@antd/dist/antd.css
// extracted by mini-css-extract-plugin
/* harmony default export */ var antd = ({});
;// CONCATENATED MODULE: ./src/index.css
// extracted by mini-css-extract-plugin
/* harmony default export */ var src = ({});
;// CONCATENATED MODULE: ./src/index.tsx
function addElement(){return _addElement.apply(this,arguments);}function _addElement(){_addElement=asyncToGenerator_asyncToGenerator(/*#__PURE__*/regeneratorRuntime_regeneratorRuntime().mark(function _callee(){var tab;return regeneratorRuntime_regeneratorRuntime().wrap(function _callee$(_context){while(1)switch(_context.prev=_context.next){case 0:_context.next=2;return getCurrentTab();case 2:tab=_context.sent;if(tab.id){chrome.tabs.sendMessage(tab.id,{type:'initElements'});}case 4:case"end":return _context.stop();}},_callee);}));return _addElement.apply(this,arguments);}function startRecord(_x){return _startRecord.apply(this,arguments);}function _startRecord(){_startRecord=asyncToGenerator_asyncToGenerator(/*#__PURE__*/regeneratorRuntime_regeneratorRuntime().mark(function _callee2(enableMicphone){return regeneratorRuntime_regeneratorRuntime().wrap(function _callee2$(_context2){while(1)switch(_context2.prev=_context2.next){case 0:_context2.next=2;return chrome.runtime.sendMessage({type:'desktopCapture',payload:{enableMicphone:enableMicphone}});case 2:window.close();case 3:case"end":return _context2.stop();}},_callee2);}));return _startRecord.apply(this,arguments);}function init(){var root=client.createRoot(document.getElementById('root'));root.render(/*#__PURE__*/(0,jsx_runtime.jsx)(_react_18_2_0_react.StrictMode,{children:/*#__PURE__*/(0,jsx_runtime.jsx)(Popup,{addElement:addElement,startRecord:startRecord})}));}init();// If you want to start measuring performance in your app, pass a function
// to log results (for example: reportWebVitals(console.log))
// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
src_reportWebVitals();
}();
/******/ })()
;
//# sourceMappingURL=main.js.map