@lm_fe/components 0.2.2

package/dist/keep-alive/index.js

@@ -0,0 +1,1901 @@
+import React, { useEffect, useContext, useRef } from 'react';
+import ReactDOM from 'react-dom';
+import { mchcLogger } from '@lm_fe/env';
+import hoistNonReactStatics from 'hoist-non-react-statics';
+
+const noop = () => undefined;
+
+class ReactComment extends React.PureComponent {
+  static defaultProps = {
+    onLoaded: noop
+  };
+  parentNode;
+  currentNode;
+  commentNode;
+  content;
+  componentDidMount() {
+    const node = ReactDOM.findDOMNode(this);
+    const commentNode = this.createComment();
+    this.commentNode = commentNode;
+    this.currentNode = node;
+    this.parentNode = node.parentNode;
+    this.parentNode.replaceChild(commentNode, node);
+    ReactDOM.unmountComponentAtNode(node);
+    this.props.onLoaded();
+  }
+  componentWillUnmount() {
+    try {
+      this.parentNode.replaceChild(this.currentNode, this.commentNode);
+    } catch (error) {
+      mchcLogger.error('replaceChild', {
+        error,
+        currentNode: this.currentNode,
+        parent: this.parentNode,
+        commentNode: this.commentNode
+      });
+    }
+  }
+  createComment() {
+    let content = this.props.children;
+    if (typeof content !== 'string') {
+      content = '';
+    }
+    this.content = content.trim();
+    return document.createComment(this.content);
+  }
+  render() {
+    return /*#__PURE__*/React.createElement("div", null);
+  }
+}
+
+const KeepAliveContext = /*#__PURE__*/React.createContext({});
+
+let warn = () => undefined;
+if (process.env.NODE_ENV !== 'production') {
+  /**
+   * Prints a warning in the console if it exists.
+   *
+   * @param {*} message
+   */
+  warn = message => {
+    if (typeof console !== undefined && typeof console.error === 'function') {
+      console.error(message);
+    } else {
+      throw new Error(message);
+    }
+  };
+}
+
+function createEventEmitter() {
+  let events = Object.create(null);
+  function on(eventNames, listener, direction = false) {
+    eventNames = getEventNames(eventNames);
+    let current = events;
+    const maxIndex = eventNames.length - 1;
+    for (let i = 0; i < eventNames.length; i++) {
+      const key = eventNames[i];
+      if (!current[key]) {
+        current[key] = i === maxIndex ? [] : {};
+      }
+      current = current[key];
+    }
+    if (!Array.isArray(current)) {
+      warn('[React Keep Alive] Access path error.');
+    }
+    if (direction) {
+      current.unshift(listener);
+    } else {
+      current.push(listener);
+    }
+  }
+  function off(eventNames, listener) {
+    const listeners = getListeners(eventNames);
+    if (!listeners) {
+      return;
+    }
+    const matchIndex = listeners.findIndex(v => v === listener);
+    if (matchIndex !== -1) {
+      listeners.splice(matchIndex, 1);
+    }
+  }
+  function removeAllListeners(eventNames) {
+    const listeners = getListeners(eventNames);
+    if (!listeners) {
+      return;
+    }
+    eventNames = getEventNames(eventNames);
+    const lastEventName = eventNames.pop();
+    if (lastEventName) {
+      const event = eventNames.reduce((obj, key) => obj[key], events);
+      event[lastEventName] = [];
+    }
+  }
+  function emit(eventNames, ...args) {
+    const listeners = getListeners(eventNames);
+    if (!listeners) {
+      return;
+    }
+    for (const listener of listeners) {
+      if (listener) {
+        listener(...args);
+      }
+    }
+  }
+  function listenerCount(eventNames) {
+    const listeners = getListeners(eventNames);
+    return listeners ? listeners.length : 0;
+  }
+  function clear() {
+    events = Object.create(null);
+  }
+  function getListeners(eventNames) {
+    eventNames = getEventNames(eventNames);
+    try {
+      return eventNames.reduce((obj, key) => obj[key], events);
+    } catch (e) {
+      return;
+    }
+  }
+  function getEventNames(eventNames) {
+    if (!eventNames) {
+      warn('[React Keep Alive] Must exist event name.');
+    }
+    if (typeof eventNames === 'string') {
+      eventNames = [eventNames];
+    }
+    return eventNames;
+  }
+  return {
+    on,
+    off,
+    emit,
+    clear,
+    listenerCount,
+    removeAllListeners
+  };
+}
+
+const hexDigits = '0123456789abcdef';
+const prefix = 'keep-alive';
+/**
+ * Create UUID
+ * Reference: https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript
+ * @export
+ * @returns
+ */
+function createUniqueIdentification(length = 6) {
+  const strings = [];
+  for (let i = 0; i < length; i++) {
+    strings[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1);
+  }
+  return `${prefix}-${strings.join('')}`;
+}
+
+function createStoreElement() {
+  const keepAliveDOM = document.createElement('div');
+  keepAliveDOM.dataset.type = prefix;
+  keepAliveDOM.style.display = 'none';
+  document.body.appendChild(keepAliveDOM);
+  return keepAliveDOM;
+}
+
+var LIFECYCLE;
+(function (LIFECYCLE) {
+  LIFECYCLE[LIFECYCLE["MOUNTED"] = 1] = "MOUNTED";
+  LIFECYCLE[LIFECYCLE["UPDATING"] = 2] = "UPDATING";
+  LIFECYCLE[LIFECYCLE["UNMOUNTED"] = 3] = "UNMOUNTED";
+})(LIFECYCLE || (LIFECYCLE = {}));
+const keepAliveProviderTypeName = '$$KeepAliveProvider';
+const START_MOUNTING_DOM = 'startMountingDOM';
+
+class KeepAliveProvider extends React.PureComponent {
+  static displayName = keepAliveProviderTypeName;
+  static defaultProps = {
+    max: 10
+  };
+  storeElement;
+  // Sometimes data that changes with setState cannot be synchronized, so force refresh
+  cache = Object.create(null);
+  keys = [];
+  eventEmitter = createEventEmitter();
+  existed = true;
+  needRerender = false;
+  providerIdentification = createUniqueIdentification();
+  componentDidMount() {
+    this.storeElement = createStoreElement();
+    this.forceUpdate();
+  }
+  componentDidUpdate() {
+    if (this.needRerender) {
+      this.needRerender = false;
+      this.forceUpdate();
+    }
+  }
+  componentWillUnmount() {
+    this.existed = false;
+    document.body.removeChild(this.storeElement);
+  }
+  isExisted = () => {
+    return this.existed;
+  };
+  setCache = (identification, value) => {
+    const {
+      cache,
+      keys
+    } = this;
+    const {
+      max
+    } = this.props;
+    const currentCache = cache[identification];
+    if (!currentCache) {
+      keys.push(identification);
+    }
+    this.cache[identification] = {
+      ...currentCache,
+      ...value
+    };
+    for (const key in cache) {
+      if (Object.prototype.hasOwnProperty.call(cache, key)) {
+        if (keys.indexOf(key) === -1) {
+          delete cache[key];
+        }
+      }
+    }
+    this.forceUpdate(() => {
+      // If the maximum value is set, the value in the cache is deleted after it goes out.
+      if (currentCache) {
+        return;
+      }
+      if (!max) {
+        return;
+      }
+      const difference = keys.length - max;
+      if (difference <= 0) {
+        return;
+      }
+      const spliceKeys = keys.splice(0, difference);
+      this.forceUpdate(() => {
+        spliceKeys.forEach(key => {
+          delete cache[key];
+        });
+      });
+    });
+  };
+  removeCache = name => {
+    const {
+      cache,
+      keys
+    } = this;
+    const needDeletedCacheKeys = [];
+    for (const key in cache) {
+      if (Object.prototype.hasOwnProperty.call(cache, key)) {
+        const keepAliveObject = cache[key];
+        // if name is array, mutiple delete caches
+        if (Object.prototype.toString.call(name) === '[object Array]') {
+          if (name.indexOf(keepAliveObject.children._owner.key) > -1) {
+            needDeletedCacheKeys.push(key);
+            delete cache[key];
+          }
+        } else if (Object.prototype.toString.call(name) === '[object String]') {
+          if (name.indexOf(keepAliveObject.children._owner.key) > -1) {
+            needDeletedCacheKeys.push(key);
+            delete cache[key];
+          }
+        } else {
+          throw new Error("name can be only string or string array");
+        }
+      }
+    }
+    this.keys = keys.filter(key => needDeletedCacheKeys.indexOf(key) === -1);
+    this.forceUpdate();
+  };
+  unactivate = identification => {
+    const {
+      cache
+    } = this;
+    this.cache[identification] = {
+      ...cache[identification],
+      activated: false,
+      lifecycle: LIFECYCLE.UNMOUNTED
+    };
+    this.forceUpdate();
+  };
+  startMountingDOM = identification => {
+    this.eventEmitter.emit([identification, START_MOUNTING_DOM]);
+  };
+  render() {
+    const {
+      cache,
+      keys,
+      providerIdentification,
+      isExisted,
+      setCache,
+      removeCache,
+      existed,
+      unactivate,
+      storeElement,
+      eventEmitter
+    } = this;
+    const {
+      children: innerChildren,
+      include,
+      exclude
+    } = this.props;
+    if (!storeElement) {
+      return null;
+    }
+    return /*#__PURE__*/React.createElement(KeepAliveContext.Provider, {
+      value: {
+        cache,
+        keys,
+        existed,
+        providerIdentification,
+        isExisted,
+        setCache,
+        removeCache,
+        unactivate,
+        storeElement,
+        eventEmitter,
+        include,
+        exclude
+      }
+    }, /*#__PURE__*/React.createElement(React.Fragment, null, innerChildren, /*#__PURE__*/ReactDOM.createPortal(keys.map(identification => {
+      const currentCache = cache[identification];
+      const {
+        keepAlive,
+        children,
+        lifecycle
+      } = currentCache;
+      let cacheChildren = children;
+      if (lifecycle === LIFECYCLE.MOUNTED && !keepAlive) {
+        // If the cache was last enabled, then the components of this keepAlive package are used,
+        // and the cache is not enabled, the UI needs to be reset.
+        cacheChildren = null;
+        this.needRerender = true;
+        currentCache.lifecycle = LIFECYCLE.UPDATING;
+      }
+      // current true, previous true | undefined, keepAlive false, not cache
+      // current true, previous true | undefined, keepAlive true, cache
+      // current true, previous false, keepAlive true, cache
+      // current true, previous false, keepAlive false, not cache
+      return cacheChildren ? (/*#__PURE__*/React.createElement(React.Fragment, {
+        key: identification
+      }, /*#__PURE__*/React.createElement(ReactComment, null, identification), cacheChildren, /*#__PURE__*/React.createElement(ReactComment, {
+        onLoaded: () => this.startMountingDOM(identification)
+      }, identification))) : null;
+    }), storeElement)));
+  }
+}
+
+const WithKeepAliveContext = /*#__PURE__*/React.createContext({});
+
+class Consumer extends React.PureComponent {
+  renderElement;
+  commentRef;
+  identification = this.props.identification;
+  componentDidMount() {
+    const {
+      setCache,
+      children,
+      keepAlive
+    } = this.props;
+    this.renderElement = this.commentRef.parentNode;
+    setCache(this.identification, {
+      children,
+      keepAlive,
+      lifecycle: LIFECYCLE.MOUNTED,
+      renderElement: this.renderElement,
+      activated: true
+    });
+  }
+  componentDidUpdate() {
+    const {
+      setCache,
+      children,
+      keepAlive
+    } = this.props;
+    setCache(this.identification, {
+      children,
+      keepAlive,
+      lifecycle: LIFECYCLE.UPDATING
+    });
+  }
+  componentWillUnmount() {
+    const {
+      unactivate
+    } = this.props;
+    unactivate(this.identification);
+  }
+  render() {
+    const {
+      identification
+    } = this;
+    return /*#__PURE__*/React.createElement(ReactComment, {
+      ref: ref => this.commentRef = ref
+    }, identification);
+  }
+}
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var md5$1 = {exports: {}};
+
+/**
+ * [js-md5]{@link https://github.com/emn178/js-md5}
+ *
+ * @namespace md5
+ * @version 0.7.3
+ * @author Chen, Yi-Cyuan [emn178@gmail.com]
+ * @copyright Chen, Yi-Cyuan 2014-2017
+ * @license MIT
+ */
+(function (module) {
+  (function () {
+
+    var ERROR = 'input is invalid type';
+    var WINDOW = typeof window === 'object';
+    var root = WINDOW ? window : {};
+    if (root.JS_MD5_NO_WINDOW) {
+      WINDOW = false;
+    }
+    var WEB_WORKER = !WINDOW && typeof self === 'object';
+    var NODE_JS = !root.JS_MD5_NO_NODE_JS && typeof process === 'object' && process.versions && process.versions.node;
+    if (NODE_JS) {
+      root = commonjsGlobal;
+    } else if (WEB_WORKER) {
+      root = self;
+    }
+    var COMMON_JS = !root.JS_MD5_NO_COMMON_JS && 'object' === 'object' && module.exports;
+    var ARRAY_BUFFER = !root.JS_MD5_NO_ARRAY_BUFFER && typeof ArrayBuffer !== 'undefined';
+    var HEX_CHARS = '0123456789abcdef'.split('');
+    var EXTRA = [128, 32768, 8388608, -2147483648];
+    var SHIFT = [0, 8, 16, 24];
+    var OUTPUT_TYPES = ['hex', 'array', 'digest', 'buffer', 'arrayBuffer', 'base64'];
+    var BASE64_ENCODE_CHAR = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
+    var blocks = [],
+      buffer8;
+    if (ARRAY_BUFFER) {
+      var buffer = new ArrayBuffer(68);
+      buffer8 = new Uint8Array(buffer);
+      blocks = new Uint32Array(buffer);
+    }
+    if (root.JS_MD5_NO_NODE_JS || !Array.isArray) {
+      Array.isArray = function (obj) {
+        return Object.prototype.toString.call(obj) === '[object Array]';
+      };
+    }
+    if (ARRAY_BUFFER && (root.JS_MD5_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView)) {
+      ArrayBuffer.isView = function (obj) {
+        return typeof obj === 'object' && obj.buffer && obj.buffer.constructor === ArrayBuffer;
+      };
+    }
+
+    /**
+     * @method hex
+     * @memberof md5
+     * @description Output hash as hex string
+     * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash
+     * @returns {String} Hex string
+     * @example
+     * md5.hex('The quick brown fox jumps over the lazy dog');
+     * // equal to
+     * md5('The quick brown fox jumps over the lazy dog');
+     */
+    /**
+     * @method digest
+     * @memberof md5
+     * @description Output hash as bytes array
+     * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash
+     * @returns {Array} Bytes array
+     * @example
+     * md5.digest('The quick brown fox jumps over the lazy dog');
+     */
+    /**
+     * @method array
+     * @memberof md5
+     * @description Output hash as bytes array
+     * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash
+     * @returns {Array} Bytes array
+     * @example
+     * md5.array('The quick brown fox jumps over the lazy dog');
+     */
+    /**
+     * @method arrayBuffer
+     * @memberof md5
+     * @description Output hash as ArrayBuffer
+     * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash
+     * @returns {ArrayBuffer} ArrayBuffer
+     * @example
+     * md5.arrayBuffer('The quick brown fox jumps over the lazy dog');
+     */
+    /**
+     * @method buffer
+     * @deprecated This maybe confuse with Buffer in node.js. Please use arrayBuffer instead.
+     * @memberof md5
+     * @description Output hash as ArrayBuffer
+     * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash
+     * @returns {ArrayBuffer} ArrayBuffer
+     * @example
+     * md5.buffer('The quick brown fox jumps over the lazy dog');
+     */
+    /**
+     * @method base64
+     * @memberof md5
+     * @description Output hash as base64 string
+     * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash
+     * @returns {String} base64 string
+     * @example
+     * md5.base64('The quick brown fox jumps over the lazy dog');
+     */
+    var createOutputMethod = function (outputType) {
+      return function (message) {
+        return new Md5(true).update(message)[outputType]();
+      };
+    };
+
+    /**
+     * @method create
+     * @memberof md5
+     * @description Create Md5 object
+     * @returns {Md5} Md5 object.
+     * @example
+     * var hash = md5.create();
+     */
+    /**
+     * @method update
+     * @memberof md5
+     * @description Create and update Md5 object
+     * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash
+     * @returns {Md5} Md5 object.
+     * @example
+     * var hash = md5.update('The quick brown fox jumps over the lazy dog');
+     * // equal to
+     * var hash = md5.create();
+     * hash.update('The quick brown fox jumps over the lazy dog');
+     */
+    var createMethod = function () {
+      var method = createOutputMethod('hex');
+      if (NODE_JS) {
+        method = nodeWrap(method);
+      }
+      method.create = function () {
+        return new Md5();
+      };
+      method.update = function (message) {
+        return method.create().update(message);
+      };
+      for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
+        var type = OUTPUT_TYPES[i];
+        method[type] = createOutputMethod(type);
+      }
+      return method;
+    };
+    var nodeWrap = function (method) {
+      var crypto = eval("require('crypto')");
+      var Buffer = eval("require('buffer').Buffer");
+      var nodeMethod = function (message) {
+        if (typeof message === 'string') {
+          return crypto.createHash('md5').update(message, 'utf8').digest('hex');
+        } else {
+          if (message === null || message === undefined) {
+            throw ERROR;
+          } else if (message.constructor === ArrayBuffer) {
+            message = new Uint8Array(message);
+          }
+        }
+        if (Array.isArray(message) || ArrayBuffer.isView(message) || message.constructor === Buffer) {
+          return crypto.createHash('md5').update(new Buffer(message)).digest('hex');
+        } else {
+          return method(message);
+        }
+      };
+      return nodeMethod;
+    };
+
+    /**
+     * Md5 class
+     * @class Md5
+     * @description This is internal class.
+     * @see {@link md5.create}
+     */
+    function Md5(sharedMemory) {
+      if (sharedMemory) {
+        blocks[0] = blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] = blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] = blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+        this.blocks = blocks;
+        this.buffer8 = buffer8;
+      } else {
+        if (ARRAY_BUFFER) {
+          var buffer = new ArrayBuffer(68);
+          this.buffer8 = new Uint8Array(buffer);
+          this.blocks = new Uint32Array(buffer);
+        } else {
+          this.blocks = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        }
+      }
+      this.h0 = this.h1 = this.h2 = this.h3 = this.start = this.bytes = this.hBytes = 0;
+      this.finalized = this.hashed = false;
+      this.first = true;
+    }
+
+    /**
+     * @method update
+     * @memberof Md5
+     * @instance
+     * @description Update hash
+     * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash
+     * @returns {Md5} Md5 object.
+     * @see {@link md5.update}
+     */
+    Md5.prototype.update = function (message) {
+      if (this.finalized) {
+        return;
+      }
+      var notString,
+        type = typeof message;
+      if (type !== 'string') {
+        if (type === 'object') {
+          if (message === null) {
+            throw ERROR;
+          } else if (ARRAY_BUFFER && message.constructor === ArrayBuffer) {
+            message = new Uint8Array(message);
+          } else if (!Array.isArray(message)) {
+            if (!ARRAY_BUFFER || !ArrayBuffer.isView(message)) {
+              throw ERROR;
+            }
+          }
+        } else {
+          throw ERROR;
+        }
+        notString = true;
+      }
+      var code,
+        index = 0,
+        i,
+        length = message.length,
+        blocks = this.blocks;
+      var buffer8 = this.buffer8;
+      while (index < length) {
+        if (this.hashed) {
+          this.hashed = false;
+          blocks[0] = blocks[16];
+          blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] = blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] = blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+        }
+        if (notString) {
+          if (ARRAY_BUFFER) {
+            for (i = this.start; index < length && i < 64; ++index) {
+              buffer8[i++] = message[index];
+            }
+          } else {
+            for (i = this.start; index < length && i < 64; ++index) {
+              blocks[i >> 2] |= message[index] << SHIFT[i++ & 3];
+            }
+          }
+        } else {
+          if (ARRAY_BUFFER) {
+            for (i = this.start; index < length && i < 64; ++index) {
+              code = message.charCodeAt(index);
+              if (code < 0x80) {
+                buffer8[i++] = code;
+              } else if (code < 0x800) {
+                buffer8[i++] = 0xc0 | code >> 6;
+                buffer8[i++] = 0x80 | code & 0x3f;
+              } else if (code < 0xd800 || code >= 0xe000) {
+                buffer8[i++] = 0xe0 | code >> 12;
+                buffer8[i++] = 0x80 | code >> 6 & 0x3f;
+                buffer8[i++] = 0x80 | code & 0x3f;
+              } else {
+                code = 0x10000 + ((code & 0x3ff) << 10 | message.charCodeAt(++index) & 0x3ff);
+                buffer8[i++] = 0xf0 | code >> 18;
+                buffer8[i++] = 0x80 | code >> 12 & 0x3f;
+                buffer8[i++] = 0x80 | code >> 6 & 0x3f;
+                buffer8[i++] = 0x80 | code & 0x3f;
+              }
+            }
+          } else {
+            for (i = this.start; index < length && i < 64; ++index) {
+              code = message.charCodeAt(index);
+              if (code < 0x80) {
+                blocks[i >> 2] |= code << SHIFT[i++ & 3];
+              } else if (code < 0x800) {
+                blocks[i >> 2] |= (0xc0 | code >> 6) << SHIFT[i++ & 3];
+                blocks[i >> 2] |= (0x80 | code & 0x3f) << SHIFT[i++ & 3];
+              } else if (code < 0xd800 || code >= 0xe000) {
+                blocks[i >> 2] |= (0xe0 | code >> 12) << SHIFT[i++ & 3];
+                blocks[i >> 2] |= (0x80 | code >> 6 & 0x3f) << SHIFT[i++ & 3];
+                blocks[i >> 2] |= (0x80 | code & 0x3f) << SHIFT[i++ & 3];
+              } else {
+                code = 0x10000 + ((code & 0x3ff) << 10 | message.charCodeAt(++index) & 0x3ff);
+                blocks[i >> 2] |= (0xf0 | code >> 18) << SHIFT[i++ & 3];
+                blocks[i >> 2] |= (0x80 | code >> 12 & 0x3f) << SHIFT[i++ & 3];
+                blocks[i >> 2] |= (0x80 | code >> 6 & 0x3f) << SHIFT[i++ & 3];
+                blocks[i >> 2] |= (0x80 | code & 0x3f) << SHIFT[i++ & 3];
+              }
+            }
+          }
+        }
+        this.lastByteIndex = i;
+        this.bytes += i - this.start;
+        if (i >= 64) {
+          this.start = i - 64;
+          this.hash();
+          this.hashed = true;
+        } else {
+          this.start = i;
+        }
+      }
+      if (this.bytes > 4294967295) {
+        this.hBytes += this.bytes / 4294967296 << 0;
+        this.bytes = this.bytes % 4294967296;
+      }
+      return this;
+    };
+    Md5.prototype.finalize = function () {
+      if (this.finalized) {
+        return;
+      }
+      this.finalized = true;
+      var blocks = this.blocks,
+        i = this.lastByteIndex;
+      blocks[i >> 2] |= EXTRA[i & 3];
+      if (i >= 56) {
+        if (!this.hashed) {
+          this.hash();
+        }
+        blocks[0] = blocks[16];
+        blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] = blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] = blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+      }
+      blocks[14] = this.bytes << 3;
+      blocks[15] = this.hBytes << 3 | this.bytes >>> 29;
+      this.hash();
+    };
+    Md5.prototype.hash = function () {
+      var a,
+        b,
+        c,
+        d,
+        bc,
+        da,
+        blocks = this.blocks;
+      if (this.first) {
+        a = blocks[0] - 680876937;
+        a = (a << 7 | a >>> 25) - 271733879 << 0;
+        d = (-1732584194 ^ a & 2004318071) + blocks[1] - 117830708;
+        d = (d << 12 | d >>> 20) + a << 0;
+        c = (-271733879 ^ d & (a ^ -271733879)) + blocks[2] - 1126478375;
+        c = (c << 17 | c >>> 15) + d << 0;
+        b = (a ^ c & (d ^ a)) + blocks[3] - 1316259209;
+        b = (b << 22 | b >>> 10) + c << 0;
+      } else {
+        a = this.h0;
+        b = this.h1;
+        c = this.h2;
+        d = this.h3;
+        a += (d ^ b & (c ^ d)) + blocks[0] - 680876936;
+        a = (a << 7 | a >>> 25) + b << 0;
+        d += (c ^ a & (b ^ c)) + blocks[1] - 389564586;
+        d = (d << 12 | d >>> 20) + a << 0;
+        c += (b ^ d & (a ^ b)) + blocks[2] + 606105819;
+        c = (c << 17 | c >>> 15) + d << 0;
+        b += (a ^ c & (d ^ a)) + blocks[3] - 1044525330;
+        b = (b << 22 | b >>> 10) + c << 0;
+      }
+      a += (d ^ b & (c ^ d)) + blocks[4] - 176418897;
+      a = (a << 7 | a >>> 25) + b << 0;
+      d += (c ^ a & (b ^ c)) + blocks[5] + 1200080426;
+      d = (d << 12 | d >>> 20) + a << 0;
+      c += (b ^ d & (a ^ b)) + blocks[6] - 1473231341;
+      c = (c << 17 | c >>> 15) + d << 0;
+      b += (a ^ c & (d ^ a)) + blocks[7] - 45705983;
+      b = (b << 22 | b >>> 10) + c << 0;
+      a += (d ^ b & (c ^ d)) + blocks[8] + 1770035416;
+      a = (a << 7 | a >>> 25) + b << 0;
+      d += (c ^ a & (b ^ c)) + blocks[9] - 1958414417;
+      d = (d << 12 | d >>> 20) + a << 0;
+      c += (b ^ d & (a ^ b)) + blocks[10] - 42063;
+      c = (c << 17 | c >>> 15) + d << 0;
+      b += (a ^ c & (d ^ a)) + blocks[11] - 1990404162;
+      b = (b << 22 | b >>> 10) + c << 0;
+      a += (d ^ b & (c ^ d)) + blocks[12] + 1804603682;
+      a = (a << 7 | a >>> 25) + b << 0;
+      d += (c ^ a & (b ^ c)) + blocks[13] - 40341101;
+      d = (d << 12 | d >>> 20) + a << 0;
+      c += (b ^ d & (a ^ b)) + blocks[14] - 1502002290;
+      c = (c << 17 | c >>> 15) + d << 0;
+      b += (a ^ c & (d ^ a)) + blocks[15] + 1236535329;
+      b = (b << 22 | b >>> 10) + c << 0;
+      a += (c ^ d & (b ^ c)) + blocks[1] - 165796510;
+      a = (a << 5 | a >>> 27) + b << 0;
+      d += (b ^ c & (a ^ b)) + blocks[6] - 1069501632;
+      d = (d << 9 | d >>> 23) + a << 0;
+      c += (a ^ b & (d ^ a)) + blocks[11] + 643717713;
+      c = (c << 14 | c >>> 18) + d << 0;
+      b += (d ^ a & (c ^ d)) + blocks[0] - 373897302;
+      b = (b << 20 | b >>> 12) + c << 0;
+      a += (c ^ d & (b ^ c)) + blocks[5] - 701558691;
+      a = (a << 5 | a >>> 27) + b << 0;
+      d += (b ^ c & (a ^ b)) + blocks[10] + 38016083;
+      d = (d << 9 | d >>> 23) + a << 0;
+      c += (a ^ b & (d ^ a)) + blocks[15] - 660478335;
+      c = (c << 14 | c >>> 18) + d << 0;
+      b += (d ^ a & (c ^ d)) + blocks[4] - 405537848;
+      b = (b << 20 | b >>> 12) + c << 0;
+      a += (c ^ d & (b ^ c)) + blocks[9] + 568446438;
+      a = (a << 5 | a >>> 27) + b << 0;
+      d += (b ^ c & (a ^ b)) + blocks[14] - 1019803690;
+      d = (d << 9 | d >>> 23) + a << 0;
+      c += (a ^ b & (d ^ a)) + blocks[3] - 187363961;
+      c = (c << 14 | c >>> 18) + d << 0;
+      b += (d ^ a & (c ^ d)) + blocks[8] + 1163531501;
+      b = (b << 20 | b >>> 12) + c << 0;
+      a += (c ^ d & (b ^ c)) + blocks[13] - 1444681467;
+      a = (a << 5 | a >>> 27) + b << 0;
+      d += (b ^ c & (a ^ b)) + blocks[2] - 51403784;
+      d = (d << 9 | d >>> 23) + a << 0;
+      c += (a ^ b & (d ^ a)) + blocks[7] + 1735328473;
+      c = (c << 14 | c >>> 18) + d << 0;
+      b += (d ^ a & (c ^ d)) + blocks[12] - 1926607734;
+      b = (b << 20 | b >>> 12) + c << 0;
+      bc = b ^ c;
+      a += (bc ^ d) + blocks[5] - 378558;
+      a = (a << 4 | a >>> 28) + b << 0;
+      d += (bc ^ a) + blocks[8] - 2022574463;
+      d = (d << 11 | d >>> 21) + a << 0;
+      da = d ^ a;
+      c += (da ^ b) + blocks[11] + 1839030562;
+      c = (c << 16 | c >>> 16) + d << 0;
+      b += (da ^ c) + blocks[14] - 35309556;
+      b = (b << 23 | b >>> 9) + c << 0;
+      bc = b ^ c;
+      a += (bc ^ d) + blocks[1] - 1530992060;
+      a = (a << 4 | a >>> 28) + b << 0;
+      d += (bc ^ a) + blocks[4] + 1272893353;
+      d = (d << 11 | d >>> 21) + a << 0;
+      da = d ^ a;
+      c += (da ^ b) + blocks[7] - 155497632;
+      c = (c << 16 | c >>> 16) + d << 0;
+      b += (da ^ c) + blocks[10] - 1094730640;
+      b = (b << 23 | b >>> 9) + c << 0;
+      bc = b ^ c;
+      a += (bc ^ d) + blocks[13] + 681279174;
+      a = (a << 4 | a >>> 28) + b << 0;
+      d += (bc ^ a) + blocks[0] - 358537222;
+      d = (d << 11 | d >>> 21) + a << 0;
+      da = d ^ a;
+      c += (da ^ b) + blocks[3] - 722521979;
+      c = (c << 16 | c >>> 16) + d << 0;
+      b += (da ^ c) + blocks[6] + 76029189;
+      b = (b << 23 | b >>> 9) + c << 0;
+      bc = b ^ c;
+      a += (bc ^ d) + blocks[9] - 640364487;
+      a = (a << 4 | a >>> 28) + b << 0;
+      d += (bc ^ a) + blocks[12] - 421815835;
+      d = (d << 11 | d >>> 21) + a << 0;
+      da = d ^ a;
+      c += (da ^ b) + blocks[15] + 530742520;
+      c = (c << 16 | c >>> 16) + d << 0;
+      b += (da ^ c) + blocks[2] - 995338651;
+      b = (b << 23 | b >>> 9) + c << 0;
+      a += (c ^ (b | ~d)) + blocks[0] - 198630844;
+      a = (a << 6 | a >>> 26) + b << 0;
+      d += (b ^ (a | ~c)) + blocks[7] + 1126891415;
+      d = (d << 10 | d >>> 22) + a << 0;
+      c += (a ^ (d | ~b)) + blocks[14] - 1416354905;
+      c = (c << 15 | c >>> 17) + d << 0;
+      b += (d ^ (c | ~a)) + blocks[5] - 57434055;
+      b = (b << 21 | b >>> 11) + c << 0;
+      a += (c ^ (b | ~d)) + blocks[12] + 1700485571;
+      a = (a << 6 | a >>> 26) + b << 0;
+      d += (b ^ (a | ~c)) + blocks[3] - 1894986606;
+      d = (d << 10 | d >>> 22) + a << 0;
+      c += (a ^ (d | ~b)) + blocks[10] - 1051523;
+      c = (c << 15 | c >>> 17) + d << 0;
+      b += (d ^ (c | ~a)) + blocks[1] - 2054922799;
+      b = (b << 21 | b >>> 11) + c << 0;
+      a += (c ^ (b | ~d)) + blocks[8] + 1873313359;
+      a = (a << 6 | a >>> 26) + b << 0;
+      d += (b ^ (a | ~c)) + blocks[15] - 30611744;
+      d = (d << 10 | d >>> 22) + a << 0;
+      c += (a ^ (d | ~b)) + blocks[6] - 1560198380;
+      c = (c << 15 | c >>> 17) + d << 0;
+      b += (d ^ (c | ~a)) + blocks[13] + 1309151649;
+      b = (b << 21 | b >>> 11) + c << 0;
+      a += (c ^ (b | ~d)) + blocks[4] - 145523070;
+      a = (a << 6 | a >>> 26) + b << 0;
+      d += (b ^ (a | ~c)) + blocks[11] - 1120210379;
+      d = (d << 10 | d >>> 22) + a << 0;
+      c += (a ^ (d | ~b)) + blocks[2] + 718787259;
+      c = (c << 15 | c >>> 17) + d << 0;
+      b += (d ^ (c | ~a)) + blocks[9] - 343485551;
+      b = (b << 21 | b >>> 11) + c << 0;
+      if (this.first) {
+        this.h0 = a + 1732584193 << 0;
+        this.h1 = b - 271733879 << 0;
+        this.h2 = c - 1732584194 << 0;
+        this.h3 = d + 271733878 << 0;
+        this.first = false;
+      } else {
+        this.h0 = this.h0 + a << 0;
+        this.h1 = this.h1 + b << 0;
+        this.h2 = this.h2 + c << 0;
+        this.h3 = this.h3 + d << 0;
+      }
+    };
+
+    /**
+     * @method hex
+     * @memberof Md5
+     * @instance
+     * @description Output hash as hex string
+     * @returns {String} Hex string
+     * @see {@link md5.hex}
+     * @example
+     * hash.hex();
+     */
+    Md5.prototype.hex = function () {
+      this.finalize();
+      var h0 = this.h0,
+        h1 = this.h1,
+        h2 = this.h2,
+        h3 = this.h3;
+      return HEX_CHARS[h0 >> 4 & 0x0F] + HEX_CHARS[h0 & 0x0F] + HEX_CHARS[h0 >> 12 & 0x0F] + HEX_CHARS[h0 >> 8 & 0x0F] + HEX_CHARS[h0 >> 20 & 0x0F] + HEX_CHARS[h0 >> 16 & 0x0F] + HEX_CHARS[h0 >> 28 & 0x0F] + HEX_CHARS[h0 >> 24 & 0x0F] + HEX_CHARS[h1 >> 4 & 0x0F] + HEX_CHARS[h1 & 0x0F] + HEX_CHARS[h1 >> 12 & 0x0F] + HEX_CHARS[h1 >> 8 & 0x0F] + HEX_CHARS[h1 >> 20 & 0x0F] + HEX_CHARS[h1 >> 16 & 0x0F] + HEX_CHARS[h1 >> 28 & 0x0F] + HEX_CHARS[h1 >> 24 & 0x0F] + HEX_CHARS[h2 >> 4 & 0x0F] + HEX_CHARS[h2 & 0x0F] + HEX_CHARS[h2 >> 12 & 0x0F] + HEX_CHARS[h2 >> 8 & 0x0F] + HEX_CHARS[h2 >> 20 & 0x0F] + HEX_CHARS[h2 >> 16 & 0x0F] + HEX_CHARS[h2 >> 28 & 0x0F] + HEX_CHARS[h2 >> 24 & 0x0F] + HEX_CHARS[h3 >> 4 & 0x0F] + HEX_CHARS[h3 & 0x0F] + HEX_CHARS[h3 >> 12 & 0x0F] + HEX_CHARS[h3 >> 8 & 0x0F] + HEX_CHARS[h3 >> 20 & 0x0F] + HEX_CHARS[h3 >> 16 & 0x0F] + HEX_CHARS[h3 >> 28 & 0x0F] + HEX_CHARS[h3 >> 24 & 0x0F];
+    };
+
+    /**
+     * @method toString
+     * @memberof Md5
+     * @instance
+     * @description Output hash as hex string
+     * @returns {String} Hex string
+     * @see {@link md5.hex}
+     * @example
+     * hash.toString();
+     */
+    Md5.prototype.toString = Md5.prototype.hex;
+
+    /**
+     * @method digest
+     * @memberof Md5
+     * @instance
+     * @description Output hash as bytes array
+     * @returns {Array} Bytes array
+     * @see {@link md5.digest}
+     * @example
+     * hash.digest();
+     */
+    Md5.prototype.digest = function () {
+      this.finalize();
+      var h0 = this.h0,
+        h1 = this.h1,
+        h2 = this.h2,
+        h3 = this.h3;
+      return [h0 & 0xFF, h0 >> 8 & 0xFF, h0 >> 16 & 0xFF, h0 >> 24 & 0xFF, h1 & 0xFF, h1 >> 8 & 0xFF, h1 >> 16 & 0xFF, h1 >> 24 & 0xFF, h2 & 0xFF, h2 >> 8 & 0xFF, h2 >> 16 & 0xFF, h2 >> 24 & 0xFF, h3 & 0xFF, h3 >> 8 & 0xFF, h3 >> 16 & 0xFF, h3 >> 24 & 0xFF];
+    };
+
+    /**
+     * @method array
+     * @memberof Md5
+     * @instance
+     * @description Output hash as bytes array
+     * @returns {Array} Bytes array
+     * @see {@link md5.array}
+     * @example
+     * hash.array();
+     */
+    Md5.prototype.array = Md5.prototype.digest;
+
+    /**
+     * @method arrayBuffer
+     * @memberof Md5
+     * @instance
+     * @description Output hash as ArrayBuffer
+     * @returns {ArrayBuffer} ArrayBuffer
+     * @see {@link md5.arrayBuffer}
+     * @example
+     * hash.arrayBuffer();
+     */
+    Md5.prototype.arrayBuffer = function () {
+      this.finalize();
+      var buffer = new ArrayBuffer(16);
+      var blocks = new Uint32Array(buffer);
+      blocks[0] = this.h0;
+      blocks[1] = this.h1;
+      blocks[2] = this.h2;
+      blocks[3] = this.h3;
+      return buffer;
+    };
+
+    /**
+     * @method buffer
+     * @deprecated This maybe confuse with Buffer in node.js. Please use arrayBuffer instead.
+     * @memberof Md5
+     * @instance
+     * @description Output hash as ArrayBuffer
+     * @returns {ArrayBuffer} ArrayBuffer
+     * @see {@link md5.buffer}
+     * @example
+     * hash.buffer();
+     */
+    Md5.prototype.buffer = Md5.prototype.arrayBuffer;
+
+    /**
+     * @method base64
+     * @memberof Md5
+     * @instance
+     * @description Output hash as base64 string
+     * @returns {String} base64 string
+     * @see {@link md5.base64}
+     * @example
+     * hash.base64();
+     */
+    Md5.prototype.base64 = function () {
+      var v1,
+        v2,
+        v3,
+        base64Str = '',
+        bytes = this.array();
+      for (var i = 0; i < 15;) {
+        v1 = bytes[i++];
+        v2 = bytes[i++];
+        v3 = bytes[i++];
+        base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] + BASE64_ENCODE_CHAR[(v1 << 4 | v2 >>> 4) & 63] + BASE64_ENCODE_CHAR[(v2 << 2 | v3 >>> 6) & 63] + BASE64_ENCODE_CHAR[v3 & 63];
+      }
+      v1 = bytes[i];
+      base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] + BASE64_ENCODE_CHAR[v1 << 4 & 63] + '==';
+      return base64Str;
+    };
+    var exports = createMethod();
+    if (COMMON_JS) {
+      module.exports = exports;
+    } else {
+      /**
+       * @method md5
+       * @description Md5 hash function, export to global in browsers.
+       * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash
+       * @returns {String} md5 hashes
+       * @example
+       * md5(''); // d41d8cd98f00b204e9800998ecf8427e
+       * md5('The quick brown fox jumps over the lazy dog'); // 9e107d9d372bb6826bd81d3542a419d6
+       * md5('The quick brown fox jumps over the lazy dog.'); // e4d909c290d0fb1ca068ffaddf22cbd0
+       *
+       * // It also supports UTF-8 encoding
+       * md5('中文'); // a7bac2239fcdcb3a067903d8077c4a07
+       *
+       * // It also supports byte `Array`, `Uint8Array`, `ArrayBuffer`
+       * md5([]); // d41d8cd98f00b204e9800998ecf8427e
+       * md5(new Uint8Array([])); // d41d8cd98f00b204e9800998ecf8427e
+       */
+      root.md5 = exports;
+    }
+  })();
+})(md5$1);
+var md5 = md5$1.exports;
+
+function createMD5(value = '', length = 6) {
+  return `${prefix}-${md5(value).substr(0, length)}`;
+}
+
+function getDisplayName(Component) {
+  return Component.displayName || Component.name || 'Component';
+}
+
+const WithKeepAliveContextConsumerDisplayName = 'withKeepAliveContextConsumer';
+function withKeepAliveContextConsumer(Component) {
+  const WithKeepAliveContextConsumer = props => (/*#__PURE__*/React.createElement(KeepAliveContext.Consumer, null, contextProps => /*#__PURE__*/React.createElement(Component, {
+    _keepAliveContextProps: contextProps,
+    ...props
+  })));
+  WithKeepAliveContextConsumer.displayName = `${WithKeepAliveContextConsumerDisplayName}(${getDisplayName(Component)})`;
+  return WithKeepAliveContextConsumer;
+}
+
+function getKeyByFiberNode(fiberNode) {
+  if (!fiberNode) {
+    return null;
+  }
+  const {
+    key,
+    type
+  } = fiberNode;
+  if (type.displayName && type.displayName.indexOf(WithKeepAliveContextConsumerDisplayName) !== -1) {
+    return key;
+  }
+  return getKeyByFiberNode(fiberNode.return);
+}
+
+const withIdentificationContextConsumerDisplayName = 'withIdentificationContextConsumer';
+function withIdentificationContextConsumer(Component) {
+  const WithIdentificationContextConsumer = props => (/*#__PURE__*/React.createElement(WithKeepAliveContext.Consumer, null, contextProps => /*#__PURE__*/React.createElement(Component, {
+    _identificationContextProps: contextProps,
+    ...props
+  })));
+  WithIdentificationContextConsumer.displayName = `${withIdentificationContextConsumerDisplayName}(${getDisplayName(Component)})`;
+  return WithIdentificationContextConsumer;
+}
+
+/**
+ * From react
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function shallowEqual(objA, objB) {
+  if (is(objA, objB)) {
+    return true;
+  }
+  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+    return false;
+  }
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  // Test for A's keys different from B.
+  for (const key of keysA) {
+    if (!hasOwnProperty.call(objB, key) || !is(objA[key], objB[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function isRegExp(value) {
+  return value && Object.prototype.toString.call(value) === '[object RegExp]';
+}
+
+function matches(pattern, name) {
+  if (Array.isArray(pattern)) {
+    return pattern.indexOf(name) > -1;
+  } else if (typeof pattern === 'string') {
+    return pattern.split(',').indexOf(name) > -1;
+  } else if (isRegExp(pattern)) {
+    return pattern.test(name);
+  }
+  return false;
+}
+function getKeepAlive(name, include, exclude, disabled) {
+  if (disabled !== undefined) {
+    return !disabled;
+  }
+  if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) {
+    return false;
+  }
+  return true;
+}
+
+var COMMAND;
+(function (COMMAND) {
+  COMMAND["UNACTIVATE"] = "unactivate";
+  COMMAND["UNMOUNT"] = "unmount";
+  COMMAND["ACTIVATE"] = "activate";
+  COMMAND["CURRENT_UNMOUNT"] = "current_unmount";
+  COMMAND["CURRENT_UNACTIVATE"] = "current_unactivate";
+})(COMMAND || (COMMAND = {}));
+/**
+ * Decorating the <KeepAlive> component, the main function is to listen to events emitted by the upper <KeepAlive> component, triggering events of the current <KeepAlive> component.
+ *
+ * @export
+ * @template P
+ * @param {React.ComponentType<any>} Component
+ * @returns {React.ComponentType<P>}
+ */
+function keepAliveDecorator(Component) {
+  class TriggerLifecycleContainer extends React.PureComponent {
+    identification;
+    activated = false;
+    ifStillActivate = false;
+    // Let the lifecycle of the cached component be called normally.
+    needActivate = true;
+    lifecycle = LIFECYCLE.MOUNTED;
+    constructor(props, ...args) {
+      super(props, ...args);
+      const {
+        _keepAliveContextProps: {
+          cache
+        }
+      } = props;
+      if (!cache) {
+        warn('[React Keep Alive] You should not use <KeepAlive> outside a <Provider>.');
+      }
+    }
+    componentDidMount() {
+      if (!this.ifStillActivate) {
+        this.activate();
+      }
+      const {
+        keepAlive,
+        _keepAliveContextProps: {
+          eventEmitter
+        }
+      } = this.props;
+      if (keepAlive) {
+        this.needActivate = true;
+        eventEmitter.emit([this.identification, COMMAND.ACTIVATE]);
+      }
+    }
+    componentDidCatch() {
+      if (!this.activated) {
+        this.activate();
+      }
+    }
+    componentWillUnmount() {
+      const {
+        getCombinedKeepAlive,
+        _keepAliveContextProps: {
+          eventEmitter,
+          isExisted
+        }
+      } = this.props;
+      const keepAlive = getCombinedKeepAlive();
+      if (!keepAlive || !isExisted()) {
+        eventEmitter.emit([this.identification, COMMAND.CURRENT_UNMOUNT]);
+        eventEmitter.emit([this.identification, COMMAND.UNMOUNT]);
+      }
+      // When the Provider components are unmounted, the cache is not needed,
+      // so you don't have to execute the componentWillUnactivate lifecycle.
+      if (keepAlive && isExisted()) {
+        eventEmitter.emit([this.identification, COMMAND.CURRENT_UNACTIVATE]);
+        eventEmitter.emit([this.identification, COMMAND.UNACTIVATE]);
+      }
+    }
+    activate = () => {
+      this.activated = true;
+    };
+    reactivate = () => {
+      this.ifStillActivate = false;
+      this.forceUpdate();
+    };
+    isNeedActivate = () => {
+      return this.needActivate;
+    };
+    notNeedActivate = () => {
+      this.needActivate = false;
+    };
+    getLifecycle = () => {
+      return this.lifecycle;
+    };
+    setLifecycle = lifecycle => {
+      this.lifecycle = lifecycle;
+    };
+    render() {
+      const {
+        propKey,
+        keepAlive,
+        extra,
+        getCombinedKeepAlive,
+        _keepAliveContextProps: {
+          isExisted,
+          storeElement,
+          cache,
+          eventEmitter,
+          setCache,
+          unactivate,
+          providerIdentification
+        },
+        ...wrapperProps
+      } = this.props;
+      if (!this.identification) {
+        // We need to generate a corresponding unique identifier based on the information of the component.
+        this.identification = createMD5(`${providerIdentification}${propKey}`);
+        // The last activated component must be unactivated before it can be activated again.
+        const currentCache = cache[this.identification];
+        if (currentCache) {
+          this.ifStillActivate = currentCache.activated;
+          currentCache.ifStillActivate = this.ifStillActivate;
+          currentCache.reactivate = this.reactivate;
+        }
+      }
+      const {
+        isNeedActivate,
+        notNeedActivate,
+        activated,
+        getLifecycle,
+        setLifecycle,
+        identification,
+        ifStillActivate
+      } = this;
+      return !ifStillActivate ? (/*#__PURE__*/React.createElement(Consumer, {
+        identification: identification,
+        keepAlive: keepAlive,
+        cache: cache,
+        setCache: setCache,
+        unactivate: unactivate
+      }, /*#__PURE__*/React.createElement(WithKeepAliveContext.Provider, {
+        value: {
+          identification,
+          eventEmitter,
+          keepAlive,
+          activated,
+          getLifecycle,
+          isExisted,
+          extra
+        }
+      }, /*#__PURE__*/React.createElement(Component, {
+        ...wrapperProps,
+        _container: {
+          isNeedActivate,
+          notNeedActivate,
+          setLifecycle,
+          eventEmitter,
+          identification,
+          storeElement,
+          keepAlive,
+          cache
+        }
+      })))) : null;
+    }
+  }
+  class ListenUpperKeepAliveContainer extends React.Component {
+    combinedKeepAlive;
+    state = {
+      activated: true
+    };
+    activate;
+    unactivate;
+    unmount;
+    shouldComponentUpdate(nextProps, nextState) {
+      if (this.state.activated !== nextState.activated) {
+        return true;
+      }
+      const {
+        _keepAliveContextProps,
+        _identificationContextProps,
+        ...rest
+      } = this.props;
+      const {
+        _keepAliveContextProps: nextKeepAliveContextProps,
+        _identificationContextProps: nextIdentificationContextProps,
+        ...nextRest
+      } = nextProps;
+      if (!shallowEqual(rest, nextRest)) {
+        return true;
+      }
+      if (!shallowEqual(_keepAliveContextProps, nextKeepAliveContextProps) || !shallowEqual(_identificationContextProps, nextIdentificationContextProps)) {
+        return true;
+      }
+      return false;
+    }
+    componentDidMount() {
+      this.listenUpperKeepAlive();
+    }
+    componentWillUnmount() {
+      this.unlistenUpperKeepAlive();
+    }
+    listenUpperKeepAlive() {
+      const {
+        identification,
+        eventEmitter
+      } = this.props._identificationContextProps;
+      if (!identification) {
+        return;
+      }
+      eventEmitter.on([identification, COMMAND.ACTIVATE], this.activate = () => this.setState({
+        activated: true
+      }), true);
+      eventEmitter.on([identification, COMMAND.UNACTIVATE], this.unactivate = () => this.setState({
+        activated: false
+      }), true);
+      eventEmitter.on([identification, COMMAND.UNMOUNT], this.unmount = () => this.setState({
+        activated: false
+      }), true);
+    }
+    unlistenUpperKeepAlive() {
+      const {
+        identification,
+        eventEmitter
+      } = this.props._identificationContextProps;
+      if (!identification) {
+        return;
+      }
+      eventEmitter.off([identification, COMMAND.ACTIVATE], this.activate);
+      eventEmitter.off([identification, COMMAND.UNACTIVATE], this.unactivate);
+      eventEmitter.off([identification, COMMAND.UNMOUNT], this.unmount);
+    }
+    getCombinedKeepAlive = () => {
+      return this.combinedKeepAlive;
+    };
+    render() {
+      const {
+        _identificationContextProps: {
+          identification,
+          keepAlive: upperKeepAlive,
+          getLifecycle
+        },
+        disabled,
+        name,
+        ...wrapperProps
+      } = this.props;
+      const {
+        activated
+      } = this.state;
+      const {
+        _keepAliveContextProps: {
+          include,
+          exclude
+        }
+      } = wrapperProps;
+      // When the parent KeepAlive component is mounted or unmounted,
+      // use the keepAlive prop of the parent KeepAlive component.
+      const propKey = name || getKeyByFiberNode(this._reactInternalFiber);
+      if (!propKey) {
+        warn('[React Keep Alive] <KeepAlive> components must have key or name.');
+        return null;
+      }
+      const newKeepAlive = getKeepAlive(propKey, include, exclude, disabled);
+      this.combinedKeepAlive = getLifecycle === undefined || getLifecycle() === LIFECYCLE.UPDATING ? newKeepAlive : identification ? upperKeepAlive && newKeepAlive : newKeepAlive;
+      return activated ? (/*#__PURE__*/React.createElement(TriggerLifecycleContainer, {
+        ...wrapperProps,
+        key: propKey,
+        propKey: propKey,
+        keepAlive: this.combinedKeepAlive,
+        getCombinedKeepAlive: this.getCombinedKeepAlive
+      })) : null;
+    }
+  }
+  const KeepAlive = withKeepAliveContextConsumer(withIdentificationContextConsumer(ListenUpperKeepAliveContainer));
+  return hoistNonReactStatics(KeepAlive, Component);
+}
+
+const bindLifecycleTypeName = '$$bindLifecycle';
+function bindLifecycle(Component) {
+  const WrappedComponent = Component.WrappedComponent || Component.wrappedComponent || Component;
+  const {
+    componentDidMount = noop,
+    componentDidUpdate = noop,
+    componentDidActivate = noop,
+    componentWillUnactivate = noop,
+    componentWillUnmount = noop,
+    shouldComponentUpdate = noop
+  } = WrappedComponent.prototype;
+  WrappedComponent.prototype.componentDidMount = function () {
+    componentDidMount.call(this);
+    this._needActivate = false;
+    const {
+      _container: {
+        identification,
+        eventEmitter,
+        activated
+      },
+      keepAlive
+    } = this.props;
+    // Determine whether to execute the componentDidActivate life cycle of the current component based on the activation state of the KeepAlive components
+    if (!activated && keepAlive !== false) {
+      componentDidActivate.call(this);
+    }
+    eventEmitter.on([identification, COMMAND.ACTIVATE], this._bindActivate = () => this._needActivate = true, true);
+    eventEmitter.on([identification, COMMAND.UNACTIVATE], this._bindUnactivate = () => {
+      componentWillUnactivate.call(this);
+      this._unmounted = false;
+    }, true);
+    eventEmitter.on([identification, COMMAND.UNMOUNT], this._bindUnmount = () => {
+      componentWillUnmount.call(this);
+      this._unmounted = true;
+    }, true);
+  };
+  // In order to be able to re-update after transferring the DOM, we need to block the first update.
+  WrappedComponent.prototype.shouldComponentUpdate = function (...args) {
+    if (this._needActivate) {
+      this.forceUpdate();
+      return false;
+    }
+    return shouldComponentUpdate.call(this, ...args) || true;
+  };
+  WrappedComponent.prototype.componentDidUpdate = function (...args) {
+    componentDidUpdate.call(this, ...args);
+    if (this._needActivate) {
+      this._needActivate = false;
+      componentDidActivate.call(this);
+    }
+  };
+  WrappedComponent.prototype.componentWillUnmount = function () {
+    if (!this._unmounted) {
+      componentWillUnmount.call(this);
+    }
+    const {
+      _container: {
+        identification,
+        eventEmitter
+      }
+    } = this.props;
+    eventEmitter.off([identification, COMMAND.ACTIVATE], this._bindActivate);
+    eventEmitter.off([identification, COMMAND.UNACTIVATE], this._bindUnactivate);
+    eventEmitter.off([identification, COMMAND.UNMOUNT], this._bindUnmount);
+  };
+  const BindLifecycleHOC = withIdentificationContextConsumer(({
+    forwardRef,
+    _identificationContextProps: {
+      identification,
+      eventEmitter,
+      activated,
+      keepAlive,
+      extra
+    },
+    ...wrapperProps
+  }) => {
+    if (!identification) {
+      warn('[React Keep Alive] You should not use bindLifecycle outside a <KeepAlive>.');
+      return null;
+    }
+    return /*#__PURE__*/React.createElement(Component, {
+      ...extra,
+      ...wrapperProps,
+      ref: forwardRef || noop,
+      _container: {
+        identification,
+        eventEmitter,
+        activated,
+        keepAlive
+      }
+    });
+  });
+  const BindLifecycle = /*#__PURE__*/React.forwardRef((props, ref) => (/*#__PURE__*/React.createElement(BindLifecycleHOC, {
+    ...props,
+    forwardRef: ref
+  })));
+  BindLifecycle.WrappedComponent = WrappedComponent;
+  BindLifecycle.displayName = `${bindLifecycleTypeName}(${getDisplayName(Component)})`;
+  return hoistNonReactStatics(BindLifecycle, Component);
+}
+
+class AsyncComponent extends React.Component {
+  state = {
+    component: null
+  };
+  /**
+   * Force update child nodes
+   *
+   * @private
+   * @returns
+   * @memberof AsyncComponent
+   */
+  forceUpdateChildren() {
+    if (!this.props.children) {
+      return;
+    }
+    const root = this._reactInternalFiber || this._reactInternalInstance;
+    if (!root) return;
+    let node = root.child;
+    let sibling = node;
+    while (sibling) {
+      while (true) {
+        if (node.type && node.type.displayName && node.type.displayName.indexOf(bindLifecycleTypeName) !== -1) {
+          return;
+        }
+        if (node.stateNode) {
+          break;
+        }
+        node = node.child;
+      }
+      if (typeof node.type === 'function') {
+        node.stateNode.forceUpdate();
+      }
+      sibling = sibling.sibling;
+    }
+  }
+  componentDidMount() {
+    const {
+      children
+    } = this.props;
+    Promise.resolve().then(() => this.setState({
+      component: children
+    }));
+  }
+  componentDidUpdate() {
+    this.props.onUpdate();
+  }
+  // Delayed update
+  // In order to be able to get real DOM data
+  shouldComponentUpdate() {
+    if (!this.state.component) {
+      // If it is already mounted asynchronously, you don't need to do it again when you update it.
+      this.props.setMounted(false);
+      return true;
+    }
+    Promise.resolve().then(() => {
+      if (this.props.getMounted()) {
+        this.props.setMounted(false);
+        this.forceUpdateChildren();
+        this.props.onUpdate();
+      }
+    });
+    return false;
+  }
+  render() {
+    return this.state.component;
+  }
+}
+
+var NODE_TYPES;
+(function (NODE_TYPES) {
+  NODE_TYPES[NODE_TYPES["ELEMENT"] = 1] = "ELEMENT";
+  NODE_TYPES[NODE_TYPES["COMMENT"] = 8] = "COMMENT";
+})(NODE_TYPES || (NODE_TYPES = {}));
+function findElementsBetweenComments(node, identification) {
+  const elements = [];
+  const childNodes = node.childNodes;
+  let startCommentExist = false;
+  for (const child of childNodes) {
+    if (child.nodeType === NODE_TYPES.COMMENT && child.nodeValue.trim() === identification && !startCommentExist) {
+      startCommentExist = true;
+    } else if (startCommentExist && child.nodeType === NODE_TYPES.ELEMENT) {
+      elements.push(child);
+    } else if (child.nodeType === NODE_TYPES.COMMENT && startCommentExist) {
+      return elements;
+    }
+  }
+  return elements;
+}
+function findComment(node, identification) {
+  const childNodes = node.childNodes;
+  for (const child of childNodes) {
+    if (child.nodeType === NODE_TYPES.COMMENT && child.nodeValue.trim() === identification) {
+      return child;
+    }
+  }
+}
+function changePositionByComment(identification, presentParentNode, originalParentNode) {
+  if (!presentParentNode || !originalParentNode) {
+    return;
+  }
+  const elementNodes = findElementsBetweenComments(originalParentNode, identification);
+  const commentNode = findComment(presentParentNode, identification);
+  if (!elementNodes.length || !commentNode) {
+    return;
+  }
+  elementNodes.push(elementNodes[elementNodes.length - 1].nextSibling);
+  elementNodes.unshift(elementNodes[0].previousSibling);
+  // Deleting comment elements when using commet components will result in component uninstallation errors
+  for (let i = elementNodes.length - 1; i >= 0; i--) {
+    try {
+      presentParentNode.insertBefore(elementNodes[i], commentNode);
+    } catch (error) {
+      mchcLogger.error('insertBefore', {
+        presentParentNode,
+        elementNodes: elementNodes[i],
+        commentNode
+      });
+    }
+  }
+  originalParentNode.appendChild(commentNode);
+}
+
+class KeepAlive extends React.PureComponent {
+  bindUnmount = null;
+  bindUnactivate = null;
+  unmounted = false;
+  mounted = false;
+  ref = null;
+  refNextSibling = null;
+  childNodes = [];
+  componentDidMount() {
+    const {
+      _container
+    } = this.props;
+    console.log('pro', this.props, this.props._container.eventEmitter);
+    const {
+      notNeedActivate,
+      identification,
+      eventEmitter,
+      keepAlive
+    } = _container;
+    notNeedActivate();
+    const cb = () => {
+      this.mount();
+      this.listen();
+      eventEmitter.off([identification, START_MOUNTING_DOM], cb);
+    };
+    eventEmitter.on([identification, START_MOUNTING_DOM], cb);
+    if (keepAlive) {
+      this.componentDidActivate();
+    }
+  }
+  componentDidActivate() {
+    // tslint-disable
+  }
+  componentDidUpdate() {
+    const {
+      _container
+    } = this.props;
+    const {
+      notNeedActivate,
+      isNeedActivate
+    } = _container;
+    if (isNeedActivate()) {
+      notNeedActivate();
+      this.mount();
+      this.listen();
+      this.unmounted = false;
+      this.componentDidActivate();
+    }
+  }
+  componentWillUnactivate() {
+    this.unmount();
+    this.unlisten();
+  }
+  componentWillUnmount() {
+    if (!this.unmounted) {
+      this.unmounted = true;
+      this.unmount();
+      this.unlisten();
+    }
+  }
+  mount() {
+    const {
+      _container: {
+        cache,
+        identification,
+        storeElement,
+        setLifecycle
+      }
+    } = this.props;
+    this.setMounted(true);
+    const {
+      renderElement
+    } = cache[identification];
+    setLifecycle(LIFECYCLE.UPDATING);
+    changePositionByComment(identification, renderElement, storeElement);
+  }
+  correctionPosition = () => {
+    if (this.ref && this.ref.parentNode && this.ref.nextSibling) {
+      const childNodes = this.ref.childNodes;
+      this.refNextSibling = this.ref.nextSibling;
+      this.childNodes = [];
+      while (childNodes.length) {
+        const child = childNodes[0];
+        this.childNodes.push(child);
+        try {
+          this.ref.parentNode.insertBefore(child, this.ref.nextSibling);
+        } catch (error) {
+          mchcLogger.error('insertBefore', {
+            error,
+            ref: this.ref,
+            child,
+            parent: this.ref.parentNode,
+            nextSibling: this.ref.nextSibling
+          });
+        }
+      }
+      try {
+        this.ref.parentNode.removeChild(this.ref);
+      } catch (error) {
+        mchcLogger.error('removeChild', {
+          error,
+          ref: this.ref,
+          parent: this.ref.parentNode
+        });
+      }
+    }
+  };
+  retreatPosition = () => {
+    if (this.ref && this.refNextSibling && this.refNextSibling.parentNode) {
+      for (const child of this.childNodes) {
+        this.ref.appendChild(child);
+      }
+      try {
+        this.refNextSibling.parentNode.insertBefore(this.ref, this.refNextSibling);
+      } catch (error) {
+        mchcLogger.error('insertBefore', {
+          error,
+          ref: this.ref,
+          parent: this.refNextSibling.parentNode,
+          nextSibling: this.refNextSibling
+        });
+      }
+    }
+  };
+  unmount() {
+    const {
+      _container: {
+        identification,
+        storeElement,
+        cache,
+        setLifecycle
+      }
+    } = this.props;
+    if (cache[identification]) {
+      const {
+        renderElement,
+        ifStillActivate,
+        reactivate
+      } = cache[identification];
+      setLifecycle(LIFECYCLE.UNMOUNTED);
+      this.retreatPosition();
+      changePositionByComment(identification, storeElement, renderElement);
+      if (ifStillActivate) {
+        reactivate();
+      }
+    }
+  }
+  listen() {
+    const {
+      _container: {
+        identification,
+        eventEmitter
+      }
+    } = this.props;
+    eventEmitter.on([identification, COMMAND.CURRENT_UNMOUNT], this.bindUnmount = this.componentWillUnmount.bind(this));
+    eventEmitter.on([identification, COMMAND.CURRENT_UNACTIVATE], this.bindUnactivate = this.componentWillUnactivate.bind(this));
+  }
+  unlisten() {
+    const {
+      _container: {
+        identification,
+        eventEmitter
+      }
+    } = this.props;
+    eventEmitter.off([identification, COMMAND.CURRENT_UNMOUNT], this.bindUnmount);
+    eventEmitter.off([identification, COMMAND.CURRENT_UNACTIVATE], this.bindUnactivate);
+  }
+  setMounted = value => {
+    this.mounted = value;
+  };
+  getMounted = () => {
+    return this.mounted;
+  };
+  render() {
+    // The purpose of this div is to not report an error when moving the DOM,
+    // so you need to remove this div later.
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref => this.ref = ref
+    }, /*#__PURE__*/React.createElement(AsyncComponent, {
+      setMounted: this.setMounted,
+      getMounted: this.getMounted,
+      onUpdate: this.correctionPosition
+    }, this.props.children));
+  }
+}
+var keepAlive = keepAliveDecorator(KeepAlive);
+
+function useKeepAliveEffect(effect) {
+  if (!useEffect) {
+    warn('[React Keep Alive] useKeepAliveEffect API requires react 16.8 or later.');
+  }
+  const {
+    eventEmitter,
+    identification
+  } = useContext(WithKeepAliveContext);
+  const effectRef = useRef(effect);
+  effectRef.current = effect;
+  useEffect(() => {
+    if (!eventEmitter) {
+      console.log('pro', 'eventEmitter not found');
+      return useEffect(effectRef.current);
+    }
+    let bindActivate = null;
+    let bindUnactivate = null;
+    let bindUnmount = null;
+    let effectResult = effectRef.current();
+    let unmounted = false;
+    eventEmitter.on([identification, COMMAND.ACTIVATE], bindActivate = () => {
+      // Delayed update
+      Promise.resolve().then(() => {
+        effectResult = effectRef.current();
+      });
+      unmounted = false;
+    }, true);
+    eventEmitter.on([identification, COMMAND.UNACTIVATE], bindUnactivate = () => {
+      if (effectResult) {
+        effectResult();
+        unmounted = true;
+      }
+    }, true);
+    eventEmitter.on([identification, COMMAND.UNMOUNT], bindUnmount = () => {
+      if (effectResult) {
+        effectResult();
+        unmounted = true;
+      }
+    }, true);
+    return () => {
+      if (effectResult && !unmounted) {
+        effectResult();
+      }
+      eventEmitter.off([identification, COMMAND.ACTIVATE], bindActivate);
+      eventEmitter.off([identification, COMMAND.UNACTIVATE], bindUnactivate);
+      eventEmitter.off([identification, COMMAND.UNMOUNT], bindUnmount);
+    };
+  }, []);
+}
+
+export { keepAlive as KeepAlive, KeepAliveProvider as Provider, bindLifecycle, useKeepAliveEffect };