Update from Vibe Studio

node_modules/@umijs/route-utils/es/getFlatMenus/getFlatMenus.js

@@ -0,0 +1,35 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { stripQueryStringAndHashFromPath, childrenPropsName } from '../transformRoute/transformRoute';
+/**
+ * 获取打平的 menuData
+ * 以 path 为 key
+ * @param menuData
+ */
+var _getFlatMenus = function getFlatMenus() {
+  var menuData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var menus = {};
+  menuData.forEach(function (mapItem) {
+    var item = _objectSpread({}, mapItem);
+    if (!item || !item.key) {
+      return;
+    }
+    if (!item.children && item[childrenPropsName]) {
+      item.children = item[childrenPropsName];
+      delete item[childrenPropsName];
+    }
+    var routerChildren = item.children || [];
+    menus[stripQueryStringAndHashFromPath(item.path || item.key || '/')] = _objectSpread({}, item);
+    menus[item.key || item.path || '/'] = _objectSpread({}, item);
+    if (routerChildren) {
+      menus = _objectSpread(_objectSpread({}, menus), _getFlatMenus(routerChildren));
+    }
+  });
+  return menus;
+};
+export { _getFlatMenus as getFlatMenus };
+export default _getFlatMenus;

node_modules/@umijs/route-utils/es/getMatchMenu/getMatchMenu.js

@@ -0,0 +1,88 @@
+//@ts-ignore
+import { pathToRegexp } from '../path-to-regexp';
+import getFlatMenu from '../getFlatMenus/getFlatMenus';
+import { isUrl, stripQueryStringAndHashFromPath } from '../transformRoute/transformRoute';
+export var getMenuMatches = function getMenuMatches() {
+  var flatMenuKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var path = arguments.length > 1 ? arguments[1] : undefined;
+  var exact = arguments.length > 2 ? arguments[2] : undefined;
+  return flatMenuKeys.filter(function (item) {
+    if (item === '/' && path === '/') {
+      return true;
+    }
+    if (item !== '/' && item !== '/*' && item && !isUrl(item)) {
+      var pathKey = stripQueryStringAndHashFromPath(item);
+      try {
+        // exact
+        if (exact) {
+          if (pathToRegexp("".concat(pathKey)).test(path)) {
+            return true;
+          }
+        }
+        // /a
+        if (pathToRegexp("".concat(pathKey), []).test(path)) {
+          return true;
+        }
+        // /a/b/b
+        if (pathToRegexp("".concat(pathKey, "/(.*)")).test(path)) {
+          return true;
+        }
+      } catch (error) {
+        // console.log(error, path);
+      }
+    }
+    return false;
+  }).sort(function (a, b) {
+    // 如果完全匹配放到最后面
+    if (a === path) {
+      return 10;
+    }
+    if (b === path) {
+      return -10;
+    }
+    return a.substr(1).split('/').length - b.substr(1).split('/').length;
+  });
+};
+/**
+ * 获取当前的选中菜单列表
+ * @param pathname
+ * @param menuData
+ * @returns MenuDataItem[]
+ */
+export var getMatchMenu = function getMatchMenu(pathname, menuData,
+/**
+ * 要不要展示全部的 key
+ */
+fullKeys, exact) {
+  var flatMenus = getFlatMenu(menuData);
+  var flatMenuKeys = Object.keys(flatMenus);
+  var menuPathKeys = getMenuMatches(flatMenuKeys, pathname || '/', exact);
+  if (!menuPathKeys || menuPathKeys.length < 1) {
+    return [];
+  }
+  if (!fullKeys) {
+    menuPathKeys = [menuPathKeys[menuPathKeys.length - 1]];
+  }
+  return menuPathKeys.map(function (menuPathKey) {
+    var menuItem = flatMenus[menuPathKey] || {
+      pro_layout_parentKeys: '',
+      key: ''
+    };
+    // 去重
+    var map = new Map();
+    var parentItems = (menuItem.pro_layout_parentKeys || []).map(function (key) {
+      if (map.has(key)) {
+        return null;
+      }
+      map.set(key, true);
+      return flatMenus[key];
+    }).filter(function (item) {
+      return item;
+    });
+    if (menuItem.key) {
+      parentItems.push(menuItem);
+    }
+    return parentItems;
+  }).flat(1);
+};
+export default getMatchMenu;

node_modules/@umijs/route-utils/es/index.js

@@ -0,0 +1,3 @@
+export { default as transformRoute } from './transformRoute/transformRoute';
+export { default as getFlatMenus } from './getFlatMenus/getFlatMenus';
+export { default as getMatchMenu } from './getMatchMenu/getMatchMenu';

node_modules/@umijs/route-utils/es/path-to-regexp.js

@@ -0,0 +1,457 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.pathToRegexp = exports.tokensToRegexp = exports.regexpToFunction = exports.match = exports.tokensToFunction = exports.compile = exports.parse = void 0;
+/**
+ * Tokenize input string.
+ */
+function lexer(str) {
+  var tokens = [];
+  var i = 0;
+  while (i < str.length) {
+    var char = str[i];
+    if (char === '*' || char === '+' || char === '?') {
+      tokens.push({
+        type: 'MODIFIER',
+        index: i,
+        value: str[i++]
+      });
+      continue;
+    }
+    if (char === '\\') {
+      tokens.push({
+        type: 'ESCAPED_CHAR',
+        index: i++,
+        value: str[i++]
+      });
+      continue;
+    }
+    if (char === '{') {
+      tokens.push({
+        type: 'OPEN',
+        index: i,
+        value: str[i++]
+      });
+      continue;
+    }
+    if (char === '}') {
+      tokens.push({
+        type: 'CLOSE',
+        index: i,
+        value: str[i++]
+      });
+      continue;
+    }
+    if (char === ':') {
+      var name = '';
+      var j = i + 1;
+      while (j < str.length) {
+        var code = str.charCodeAt(j);
+        if (
+        // `0-9`
+        code >= 48 && code <= 57 ||
+        // `A-Z`
+        code >= 65 && code <= 90 ||
+        // `a-z`
+        code >= 97 && code <= 122 ||
+        // `_`
+        code === 95) {
+          name += str[j++];
+          continue;
+        }
+        break;
+      }
+      if (!name) throw new TypeError('Missing parameter name at ' + i);
+      tokens.push({
+        type: 'NAME',
+        index: i,
+        value: name
+      });
+      i = j;
+      continue;
+    }
+    if (char === '(') {
+      var count = 1;
+      var pattern = '';
+      var j = i + 1;
+      if (str[j] === '?') {
+        throw new TypeError('Pattern cannot start with "?" at ' + j);
+      }
+      while (j < str.length) {
+        if (str[j] === '\\') {
+          pattern += str[j++] + str[j++];
+          continue;
+        }
+        if (str[j] === ')') {
+          count--;
+          if (count === 0) {
+            j++;
+            break;
+          }
+        } else if (str[j] === '(') {
+          count++;
+          if (str[j + 1] !== '?') {
+            throw new TypeError('Capturing groups are not allowed at ' + j);
+          }
+        }
+        pattern += str[j++];
+      }
+      if (count) throw new TypeError('Unbalanced pattern at ' + i);
+      if (!pattern) throw new TypeError('Missing pattern at ' + i);
+      tokens.push({
+        type: 'PATTERN',
+        index: i,
+        value: pattern
+      });
+      i = j;
+      continue;
+    }
+    tokens.push({
+      type: 'CHAR',
+      index: i,
+      value: str[i++]
+    });
+  }
+  tokens.push({
+    type: 'END',
+    index: i,
+    value: ''
+  });
+  return tokens;
+}
+/**
+ * Parse a string for the raw tokens.
+ */
+function parse(str, options) {
+  if (options === void 0) {
+    // eslint-disable-next-line no-param-reassign
+    options = {};
+  }
+  var tokens = lexer(str);
+  var _a = options.prefixes,
+    prefixes = _a === void 0 ? './' : _a;
+  var defaultPattern = '[^' + escapeString(options.delimiter || '/#?') + ']+?';
+  var result = [];
+  var key = 0;
+  var i = 0;
+  var path = '';
+  var tryConsume = function tryConsume(type) {
+    if (i < tokens.length && tokens[i].type === type) return tokens[i++].value;
+  };
+  var mustConsume = function mustConsume(type) {
+    var value = tryConsume(type);
+    if (value !== undefined) return value;
+    var _a = tokens[i],
+      nextType = _a.type,
+      index = _a.index;
+    throw new TypeError('Unexpected ' + nextType + ' at ' + index + ', expected ' + type);
+  };
+  var consumeText = function consumeText() {
+    var result = '';
+    var value;
+    // tslint:disable-next-line
+    while (value = tryConsume('CHAR') || tryConsume('ESCAPED_CHAR')) {
+      result += value;
+    }
+    return result;
+  };
+  while (i < tokens.length) {
+    var char = tryConsume('CHAR');
+    var name = tryConsume('NAME');
+    var pattern = tryConsume('PATTERN');
+    if (name || pattern) {
+      var prefix = char || '';
+      if (prefixes.indexOf(prefix) === -1) {
+        path += prefix;
+        prefix = '';
+      }
+      if (path) {
+        result.push(path);
+        path = '';
+      }
+      result.push({
+        name: name || key++,
+        prefix: prefix,
+        suffix: '',
+        pattern: pattern || defaultPattern,
+        modifier: tryConsume('MODIFIER') || ''
+      });
+      continue;
+    }
+    var value = char || tryConsume('ESCAPED_CHAR');
+    if (value) {
+      path += value;
+      continue;
+    }
+    if (path) {
+      result.push(path);
+      path = '';
+    }
+    var open = tryConsume('OPEN');
+    if (open) {
+      var prefix = consumeText();
+      var name_1 = tryConsume('NAME') || '';
+      var pattern_1 = tryConsume('PATTERN') || '';
+      var suffix = consumeText();
+      mustConsume('CLOSE');
+      result.push({
+        name: name_1 || (pattern_1 ? key++ : ''),
+        pattern: name_1 && !pattern_1 ? defaultPattern : pattern_1,
+        prefix: prefix,
+        suffix: suffix,
+        modifier: tryConsume('MODIFIER') || ''
+      });
+      continue;
+    }
+    mustConsume('END');
+  }
+  return result;
+}
+exports.parse = parse;
+/**
+ * Compile a string to a template function for the path.
+ */
+function compile(str, options) {
+  return tokensToFunction(parse(str, options), options);
+}
+exports.compile = compile;
+/**
+ * Expose a method for transforming tokens into the path function.
+ */
+function tokensToFunction(tokens, options) {
+  if (options === void 0) {
+    // eslint-disable-next-line no-param-reassign
+    options = {};
+  }
+  var reFlags = flags(options);
+  var _a = options.encode,
+    encode = _a === void 0 ? function (x) {
+      return x;
+    } : _a,
+    _b = options.validate,
+    validate = _b === void 0 ? true : _b;
+  // Compile all the tokens into regexps.
+  var matches = tokens.map(function (token) {
+    if (_typeof(token) === 'object') {
+      return new RegExp('^(?:' + token.pattern + ')$', reFlags);
+    }
+  });
+  return function (data) {
+    var path = '';
+    for (var i = 0; i < tokens.length; i++) {
+      var token = tokens[i];
+      if (typeof token === 'string') {
+        path += token;
+        continue;
+      }
+      var value = data ? data[token.name] : undefined;
+      var optional = token.modifier === '?' || token.modifier === '*';
+      var repeat = token.modifier === '*' || token.modifier === '+';
+      if (Array.isArray(value)) {
+        if (!repeat) {
+          throw new TypeError('Expected "' + token.name + '" to not repeat, but got an array');
+        }
+        if (value.length === 0) {
+          if (optional) continue;
+          throw new TypeError('Expected "' + token.name + '" to not be empty');
+        }
+        for (var j = 0; j < value.length; j++) {
+          var segment = encode(value[j], token);
+          if (validate && !matches[i].test(segment)) {
+            throw new TypeError('Expected all "' + token.name + '" to match "' + token.pattern + '", but got "' + segment + '"');
+          }
+          path += token.prefix + segment + token.suffix;
+        }
+        continue;
+      }
+      if (typeof value === 'string' || typeof value === 'number') {
+        var segment = encode(String(value), token);
+        if (validate && !matches[i].test(segment)) {
+          throw new TypeError('Expected "' + token.name + '" to match "' + token.pattern + '", but got "' + segment + '"');
+        }
+        path += token.prefix + segment + token.suffix;
+        continue;
+      }
+      if (optional) continue;
+      var typeOfMessage = repeat ? 'an array' : 'a string';
+      throw new TypeError('Expected "' + token.name + '" to be ' + typeOfMessage);
+    }
+    return path;
+  };
+}
+exports.tokensToFunction = tokensToFunction;
+/**
+ * Create path match function from `path-to-regexp` spec.
+ */
+function match(str, options) {
+  var keys = [];
+  var re = pathToRegexp(str, keys, options);
+  return regexpToFunction(re, keys, options);
+}
+exports.match = match;
+/**
+ * Create a path match function from `path-to-regexp` output.
+ */
+function regexpToFunction(re, keys, options) {
+  if (options === void 0) {
+    // eslint-disable-next-line no-param-reassign
+    options = {};
+  }
+  var _a = options.decode,
+    decode = _a === void 0 ? function (x) {
+      return x;
+    } : _a;
+  return function (pathname) {
+    var m = re.exec(pathname);
+    if (!m) return false;
+    var path = m[0],
+      index = m.index;
+    var params = Object.create(null);
+    var _loop_1 = function _loop_1(i) {
+      // tslint:disable-next-line
+      if (m[i] === undefined) return 'continue';
+      var key = keys[i - 1];
+      if (key.modifier === '*' || key.modifier === '+') {
+        params[key.name] = m[i].split(key.prefix + key.suffix).map(function (value) {
+          return decode(value, key);
+        });
+      } else {
+        params[key.name] = decode(m[i], key);
+      }
+    };
+    for (var i = 1; i < m.length; i++) {
+      _loop_1(i);
+    }
+    return {
+      path: path,
+      index: index,
+      params: params
+    };
+  };
+}
+exports.regexpToFunction = regexpToFunction;
+/**
+ * Escape a regular expression string.
+ */
+function escapeString(str) {
+  return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1');
+}
+/**
+ * Get the flags for a regexp from the options.
+ */
+function flags(options) {
+  return options && options.sensitive ? '' : 'i';
+}
+/**
+ * Pull out keys from a regexp.
+ */
+function regexpToRegexp(path, keys) {
+  if (!keys) return path;
+  // Use a negative lookahead to match only capturing groups.
+  var groups = path.source.match(/\((?!\?)/g);
+  if (groups) {
+    for (var i = 0; i < groups.length; i++) {
+      keys.push({
+        name: i,
+        prefix: '',
+        suffix: '',
+        modifier: '',
+        pattern: ''
+      });
+    }
+  }
+  return path;
+}
+/**
+ * Transform an array into a regexp.
+ */
+function arrayToRegexp(paths, keys, options) {
+  var parts = paths.map(function (path) {
+    return pathToRegexp(path, keys, options).source;
+  });
+  return new RegExp('(?:' + parts.join('|') + ')', flags(options));
+}
+/**
+ * Create a path regexp from string input.
+ */
+function stringToRegexp(path, keys, options) {
+  return tokensToRegexp(parse(path, options), keys, options);
+}
+/**
+ * Expose a function for taking tokens and returning a RegExp.
+ */
+function tokensToRegexp(tokens, keys, options) {
+  if (options === void 0) {
+    // eslint-disable-next-line no-param-reassign
+    options = {};
+  }
+  var _a = options.strict,
+    strict = _a === void 0 ? false : _a,
+    _b = options.start,
+    start = _b === void 0 ? true : _b,
+    _c = options.end,
+    end = _c === void 0 ? true : _c,
+    _d = options.encode,
+    encode = _d === void 0 ? function (x) {
+      return x;
+    } : _d;
+  var endsWith = '[' + escapeString(options.endsWith || '') + ']|$';
+  var delimiter = '[' + escapeString(options.delimiter || '/#?') + ']';
+  var route = start ? '^' : '';
+  // Iterate over the tokens and create our regexp string.
+  for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+    var token = tokens_1[_i];
+    if (typeof token === 'string') {
+      route += escapeString(encode(token));
+    } else {
+      var prefix = escapeString(encode(token.prefix));
+      var suffix = escapeString(encode(token.suffix));
+      if (token.pattern) {
+        if (keys) keys.push(token);
+        if (prefix || suffix) {
+          if (token.modifier === '+' || token.modifier === '*') {
+            var mod = token.modifier === '*' ? '?' : '';
+            route += '(?:' + prefix + '((?:' + token.pattern + ')(?:' + suffix + prefix + '(?:' + token.pattern + '))*)' + suffix + ')' + mod;
+          } else {
+            route += '(?:' + prefix + '(' + token.pattern + ')' + suffix + ')' + token.modifier;
+          }
+        } else {
+          route += '(' + token.pattern + ')' + token.modifier;
+        }
+      } else {
+        route += '(?:' + prefix + suffix + ')' + token.modifier;
+      }
+    }
+  }
+  if (end) {
+    if (!strict) route += delimiter + '?';
+    route += !options.endsWith ? '$' : '(?=' + endsWith + ')';
+  } else {
+    var endToken = tokens[tokens.length - 1];
+    var isEndDelimited = typeof endToken === 'string' ? delimiter.indexOf(endToken[endToken.length - 1]) > -1 :
+    // tslint:disable-next-line
+    endToken === undefined;
+    if (!strict) {
+      route += '(?:' + delimiter + '(?=' + endsWith + '))?';
+    }
+    if (!isEndDelimited) {
+      route += '(?=' + delimiter + '|' + endsWith + ')';
+    }
+  }
+  return new RegExp(route, flags(options));
+}
+exports.tokensToRegexp = tokensToRegexp;
+/**
+ * Normalize the given path string, returning a regular expression.
+ *
+ * An empty array can be passed in for the keys, which will hold the
+ * placeholder key descriptions. For example, using `/user/:id`, `keys` will
+ * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
+ */
+function pathToRegexp(path, keys, options) {
+  if (path instanceof RegExp) return regexpToRegexp(path, keys);
+  if (Array.isArray(path)) return arrayToRegexp(path, keys, options);
+  return stringToRegexp(path, keys, options);
+}
+exports.pathToRegexp = pathToRegexp;

node_modules/@umijs/route-utils/es/sha265.js

@@ -0,0 +1,223 @@
+/* eslint-disable no-redeclare */
+/* eslint-disable no-multi-assign */
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-return-assign */
+/* eslint-disable no-new-wrappers */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-var */
+/* eslint-disable no-plusplus */
+/* eslint-disable prefer-destructuring */
+/* eslint-disable @typescript-eslint/naming-convention */
+/* eslint-disable block-scoped-var */
+/* eslint-disable vars-on-top */
+/* eslint-disable no-bitwise */
+/* eslint-disable no-cond-assign */
+/*
+ * A JavaScript implementation of the SHA256 hash function.
+ *
+ * FILE:	sha256.js
+ * VERSION:	0.8
+ * AUTHOR:	Christoph Bichlmeier <informatik@zombiearena.de>
+ *
+ * NOTE: This version is not tested thoroughly!
+ *
+ * Copyright (c) 2003, Christoph Bichlmeier
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * ======================================================================
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/* SHA256 logical functions */
+function rotateRight(n, x) {
+  return x >>> n | x << 32 - n;
+}
+function choice(x, y, z) {
+  return x & y ^ ~x & z;
+}
+function majority(x, y, z) {
+  return x & y ^ x & z ^ y & z;
+}
+function sha256_Sigma0(x) {
+  return rotateRight(2, x) ^ rotateRight(13, x) ^ rotateRight(22, x);
+}
+function sha256_Sigma1(x) {
+  return rotateRight(6, x) ^ rotateRight(11, x) ^ rotateRight(25, x);
+}
+function sha256_sigma0(x) {
+  return rotateRight(7, x) ^ rotateRight(18, x) ^ x >>> 3;
+}
+function sha256_sigma1(x) {
+  return rotateRight(17, x) ^ rotateRight(19, x) ^ x >>> 10;
+}
+function sha256_expand(W, j) {
+  return W[j & 0x0f] += sha256_sigma1(W[j + 14 & 0x0f]) + W[j + 9 & 0x0f] + sha256_sigma0(W[j + 1 & 0x0f]);
+}
+/* Hash constant words K: */
+var K256 = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2];
+/* global arrays */
+var ihash;
+var count;
+var buffer;
+var sha256_hex_digits = '0123456789abcdef';
+/* Add 32-bit integers with 16-bit operations (bug in some JS-interpreters:
+overflow) */
+function safe_add(x, y) {
+  var lsw = (x & 0xffff) + (y & 0xffff);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return msw << 16 | lsw & 0xffff;
+}
+/* Initialise the SHA256 computation */
+function sha256_init() {
+  ihash = new Array(8);
+  count = new Array(2);
+  buffer = new Array(64);
+  count[0] = count[1] = 0;
+  ihash[0] = 0x6a09e667;
+  ihash[1] = 0xbb67ae85;
+  ihash[2] = 0x3c6ef372;
+  ihash[3] = 0xa54ff53a;
+  ihash[4] = 0x510e527f;
+  ihash[5] = 0x9b05688c;
+  ihash[6] = 0x1f83d9ab;
+  ihash[7] = 0x5be0cd19;
+}
+/* Transform a 512-bit message block */
+function sha256_transform() {
+  var a;
+  var b;
+  var c;
+  var d;
+  var e;
+  var f;
+  var g;
+  var h;
+  var T1;
+  var T2;
+  var W = new Array(16);
+  /* Initialize registers with the previous intermediate value */
+  a = ihash[0];
+  b = ihash[1];
+  c = ihash[2];
+  d = ihash[3];
+  e = ihash[4];
+  f = ihash[5];
+  g = ihash[6];
+  h = ihash[7];
+  /* make 32-bit words */
+  for (var i = 0; i < 16; i++) W[i] = buffer[(i << 2) + 3] | buffer[(i << 2) + 2] << 8 | buffer[(i << 2) + 1] << 16 | buffer[i << 2] << 24;
+  for (var j = 0; j < 64; j++) {
+    T1 = h + sha256_Sigma1(e) + choice(e, f, g) + K256[j];
+    if (j < 16) T1 += W[j];else T1 += sha256_expand(W, j);
+    T2 = sha256_Sigma0(a) + majority(a, b, c);
+    h = g;
+    g = f;
+    f = e;
+    e = safe_add(d, T1);
+    d = c;
+    c = b;
+    b = a;
+    a = safe_add(T1, T2);
+  }
+  /* Compute the current intermediate hash value */
+  ihash[0] += a;
+  ihash[1] += b;
+  ihash[2] += c;
+  ihash[3] += d;
+  ihash[4] += e;
+  ihash[5] += f;
+  ihash[6] += g;
+  ihash[7] += h;
+}
+/* Read the next chunk of data and update the SHA256 computation */
+function sha256_update(data, inputLen) {
+  var i;
+  var index;
+  var curpos = 0;
+  /* Compute number of bytes mod 64 */
+  index = count[0] >> 3 & 0x3f;
+  var remainder = inputLen & 0x3f;
+  /* Update number of bits */
+  if ((count[0] += inputLen << 3) < inputLen << 3) count[1]++;
+  count[1] += inputLen >> 29;
+  /* Transform as many times as possible */
+  for (i = 0; i + 63 < inputLen; i += 64) {
+    for (var j = index; j < 64; j++) buffer[j] = data.charCodeAt(curpos++);
+    sha256_transform();
+    index = 0;
+  }
+  /* Buffer remaining input */
+  for (var _j = 0; _j < remainder; _j++) buffer[_j] = data.charCodeAt(curpos++);
+}
+/* Finish the computation by operations such as padding */
+function sha256_final() {
+  var index = count[0] >> 3 & 0x3f;
+  buffer[index++] = 0x80;
+  if (index <= 56) {
+    for (var i = index; i < 56; i++) buffer[i] = 0;
+  } else {
+    for (var _i = index; _i < 64; _i++) buffer[_i] = 0;
+    sha256_transform();
+    for (var _i2 = 0; _i2 < 56; _i2++) buffer[_i2] = 0;
+  }
+  buffer[56] = count[1] >>> 24 & 0xff;
+  buffer[57] = count[1] >>> 16 & 0xff;
+  buffer[58] = count[1] >>> 8 & 0xff;
+  buffer[59] = count[1] & 0xff;
+  buffer[60] = count[0] >>> 24 & 0xff;
+  buffer[61] = count[0] >>> 16 & 0xff;
+  buffer[62] = count[0] >>> 8 & 0xff;
+  buffer[63] = count[0] & 0xff;
+  sha256_transform();
+}
+/* Split the internal hash values into an array of bytes */
+function sha256_encode_bytes() {
+  var j = 0;
+  var output = new Array(32);
+  for (var i = 0; i < 8; i++) {
+    output[j++] = ihash[i] >>> 24 & 0xff;
+    output[j++] = ihash[i] >>> 16 & 0xff;
+    output[j++] = ihash[i] >>> 8 & 0xff;
+    output[j++] = ihash[i] & 0xff;
+  }
+  return output;
+}
+/* Get the internal hash as a hex string */
+function sha256_encode_hex() {
+  var output = new String();
+  for (var i = 0; i < 8; i++) {
+    for (var j = 28; j >= 0; j -= 4) output += sha256_hex_digits.charAt(ihash[i] >>> j & 0x0f);
+  }
+  return output;
+}
+/* Main function: returns a hex string representing the SHA256 value of the
+given data */
+function digest(data) {
+  sha256_init();
+  sha256_update(data, data.length);
+  sha256_final();
+  return sha256_encode_hex();
+}
+export default digest;

node_modules/@umijs/route-utils/es/transformRoute/transformRoute.js

@@ -0,0 +1,394 @@
+var _excluded = ["pro_layout_parentKeys", "children", "icon", "flatMenu", "indexRoute", "routes"];
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, 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 o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _wrapNativeSuper(t) { var r = "function" == typeof Map ? new Map() : void 0; return _wrapNativeSuper = function _wrapNativeSuper(t) { if (null === t || !_isNativeFunction(t)) return t; if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function"); if (void 0 !== r) { if (r.has(t)) return r.get(t); r.set(t, Wrapper); } function Wrapper() { return _construct(t, arguments, _getPrototypeOf(this).constructor); } return Wrapper.prototype = Object.create(t.prototype, { constructor: { value: Wrapper, enumerable: !1, writable: !0, configurable: !0 } }), _setPrototypeOf(Wrapper, t); }, _wrapNativeSuper(t); }
+function _construct(t, e, r) { if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments); var o = [null]; o.push.apply(o, e); var p = new (t.bind.apply(t, o))(); return r && _setPrototypeOf(p, r.prototype), p; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _isNativeFunction(t) { try { return -1 !== Function.toString.call(t).indexOf("[native code]"); } catch (n) { return "function" == typeof t; } }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+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."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+//@ts-ignore
+import { pathToRegexp } from '../path-to-regexp';
+import sha265 from '../sha265';
+export var childrenPropsName = 'routes';
+export function stripQueryStringAndHashFromPath(url) {
+  return url.split('?')[0].split('#')[0];
+}
+export var isUrl = function isUrl(path) {
+  if (!path.startsWith('http')) {
+    return false;
+  }
+  try {
+    var url = new URL(path);
+    return !!url;
+  } catch (error) {
+    return false;
+  }
+};
+export var getKeyByPath = function getKeyByPath(item) {
+  var path = item.path;
+  if (!path || path === '/') {
+    // 如果还是没有，用对象的hash 生成一个
+    try {
+      return "/".concat(sha265(JSON.stringify(item)));
+    } catch (error) {
+      // dom some thing
+    }
+  }
+  return path ? stripQueryStringAndHashFromPath(path) : path;
+};
+/**
+ * 获取locale，增加了一个功能，如果 locale = false，将不使用国际化
+ * @param item
+ * @param parentName
+ */
+var getItemLocaleName = function getItemLocaleName(item, parentName) {
+  var name = item.name,
+    locale = item.locale;
+  // 如果配置了 locale 并且 locale 为 false或 ""
+  if ('locale' in item && locale === false || !name) {
+    return false;
+  }
+  return item.locale || "".concat(parentName, ".").concat(name);
+};
+/**
+ * 如果不是 / 开头的和父节点做一下合并
+ * 如果是 / 开头的不作任何处理
+ * 如果是 url 也直接返回
+ * @param path
+ * @param parentPath
+ */
+var mergePath = function mergePath() {
+  var path = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var parentPath = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '/';
+  if (path.endsWith('/*')) {
+    return path.replace('/*', '/');
+  }
+  if ((path || parentPath).startsWith('/')) {
+    return path;
+  }
+  if (isUrl(path)) {
+    return path;
+  }
+  return "/".concat(parentPath, "/").concat(path).replace(/\/\//g, '/').replace(/\/\//g, '/');
+};
+// bigfish 的兼容准话
+var bigfishCompatibleConversions = function bigfishCompatibleConversions(route, props) {
+  var _route$menu = route.menu,
+    menu = _route$menu === void 0 ? {} : _route$menu,
+    indexRoute = route.indexRoute,
+    _route$path = route.path,
+    path = _route$path === void 0 ? '' : _route$path;
+  var routerChildren = route.children || [];
+  var _menu$name = menu.name,
+    name = _menu$name === void 0 ? route.name : _menu$name,
+    _menu$icon = menu.icon,
+    icon = _menu$icon === void 0 ? route.icon : _menu$icon,
+    _menu$hideChildren = menu.hideChildren,
+    hideChildren = _menu$hideChildren === void 0 ? route.hideChildren : _menu$hideChildren,
+    _menu$flatMenu = menu.flatMenu,
+    flatMenu = _menu$flatMenu === void 0 ? route.flatMenu : _menu$flatMenu; // 兼容平铺式写法
+  // 拼接 childrenRoutes, 处理存在 indexRoute 时的逻辑
+  var childrenList = indexRoute &&
+  // 如果只有 redirect,不用处理的
+  Object.keys(indexRoute).join(',') !== 'redirect' ? [_objectSpread({
+    path: path,
+    menu: menu
+  }, indexRoute)].concat(routerChildren || []) : routerChildren;
+  // 拼接返回的 menu 数据
+  var result = _objectSpread({}, route);
+  if (name) {
+    result.name = name;
+  }
+  if (icon) {
+    result.icon = icon;
+  }
+  if (childrenList && childrenList.length) {
+    /** 在菜单中隐藏子项 */
+    if (hideChildren) {
+      delete result.children;
+      return result;
+    }
+    // 需要重新进行一次
+    var finalChildren = formatter(_objectSpread(_objectSpread({}, props), {}, {
+      data: childrenList
+    }), route);
+    /** 在菜单中只隐藏此项，子项往上提，仍旧展示 */
+    if (flatMenu) {
+      return finalChildren;
+    }
+    delete result[childrenPropsName];
+  }
+  return result;
+};
+var notNullArray = function notNullArray(value) {
+  return Array.isArray(value) && value.length > 0;
+};
+/**
+ *
+ * @param props
+ * @param parent
+ */
+function formatter(props) {
+  var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    path: '/'
+  };
+  var data = props.data,
+    formatMessage = props.formatMessage,
+    parentName = props.parentName,
+    menuLocale = props.locale;
+  if (!data || !Array.isArray(data)) {
+    return [];
+  }
+  return data.filter(function (item) {
+    if (!item) return false;
+    if (notNullArray(item.children)) return true;
+    if (item.path) return true;
+    if (item.originPath) return true;
+    if (item.layout) return true;
+    // 重定向
+    if (item.redirect) return false;
+    if (item.unaccessible) return false;
+    return false;
+  }).filter(function (item) {
+    var _item$menu, _item$menu2;
+    if ((item === null || item === void 0 ? void 0 : (_item$menu = item.menu) === null || _item$menu === void 0 ? void 0 : _item$menu.name) || (item === null || item === void 0 ? void 0 : item.flatMenu) || (item === null || item === void 0 ? void 0 : (_item$menu2 = item.menu) === null || _item$menu2 === void 0 ? void 0 : _item$menu2.flatMenu)) {
+      return true;
+    }
+    // 显示指定在 menu 中隐藏该项
+    // layout 插件的功能，其实不应该存在的
+    if (item.menu === false) {
+      return false;
+    }
+    return true;
+  }).map(function (finallyItem) {
+    var item = _objectSpread(_objectSpread({}, finallyItem), {}, {
+      path: finallyItem.path || finallyItem.originPath
+    });
+    if (!item.children && item[childrenPropsName]) {
+      item.children = item[childrenPropsName];
+      delete item[childrenPropsName];
+    }
+    // 是否没有权限查看
+    // 这样就不会显示，是一个兼容性的方式
+    if (item.unaccessible) {
+      // eslint-disable-next-line no-param-reassign
+      delete item.name;
+    }
+    if (item.path === '*') {
+      item.path = '.';
+    }
+    if (item.path === '/*') {
+      item.path = '.';
+    }
+    if (!item.path && item.originPath) {
+      item.path = item.originPath;
+    }
+    return item;
+  }).map(function () {
+    var item = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+      path: '/'
+    };
+    var routerChildren = item.children || item[childrenPropsName] || [];
+    var path = mergePath(item.path, parent ? parent.path : '/');
+    var name = item.name;
+    var locale = getItemLocaleName(item, parentName || 'menu');
+    // if enableMenuLocale use item.name,
+    // close menu international
+    var localeName = locale !== false && menuLocale !== false && formatMessage && locale ? formatMessage({
+      id: locale,
+      defaultMessage: name
+    }) : name;
+    var _parent$pro_layout_pa = parent.pro_layout_parentKeys,
+      pro_layout_parentKeys = _parent$pro_layout_pa === void 0 ? [] : _parent$pro_layout_pa,
+      children = parent.children,
+      icon = parent.icon,
+      flatMenu = parent.flatMenu,
+      indexRoute = parent.indexRoute,
+      routes = parent.routes,
+      restParent = _objectWithoutProperties(parent, _excluded);
+    var item_pro_layout_parentKeys = new Set([].concat(_toConsumableArray(pro_layout_parentKeys), _toConsumableArray(item.parentKeys || [])));
+    if (parent.key) {
+      item_pro_layout_parentKeys.add(parent.key);
+    }
+    var finallyItem = _objectSpread(_objectSpread(_objectSpread({}, restParent), {}, {
+      menu: undefined
+    }, item), {}, {
+      path: path,
+      locale: locale,
+      key: item.key || getKeyByPath(_objectSpread(_objectSpread({}, item), {}, {
+        path: path
+      })),
+      pro_layout_parentKeys: Array.from(item_pro_layout_parentKeys).filter(function (key) {
+        return key && key !== '/';
+      })
+    });
+    if (localeName) {
+      finallyItem.name = localeName;
+    } else {
+      delete finallyItem.name;
+    }
+    if (finallyItem.menu === undefined) {
+      delete finallyItem.menu;
+    }
+    if (notNullArray(routerChildren)) {
+      var formatterChildren = formatter(_objectSpread(_objectSpread({}, props), {}, {
+        data: routerChildren,
+        parentName: locale || ''
+      }), finallyItem);
+      if (notNullArray(formatterChildren)) {
+        finallyItem.children = formatterChildren;
+      }
+    }
+    return bigfishCompatibleConversions(finallyItem, props);
+  }).flat(1);
+}
+/**
+ * 删除 hideInMenu 和 item.name 不存在的
+ */
+var _defaultFilterMenuData = function defaultFilterMenuData() {
+  var menuData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return menuData.filter(function (item) {
+    return item && (item.name || notNullArray(item.children)) && !item.hideInMenu && !item.redirect;
+  }).map(function (item) {
+    var newItem = _objectSpread({}, item);
+    var routerChildren = newItem.children || item[childrenPropsName] || [];
+    delete newItem[childrenPropsName];
+    if (notNullArray(routerChildren) && !newItem.hideChildrenInMenu && routerChildren.some(function (child) {
+      return child && !!child.name;
+    })) {
+      var newChildren = _defaultFilterMenuData(routerChildren);
+      if (newChildren.length) return _objectSpread(_objectSpread({}, newItem), {}, {
+        children: newChildren
+      });
+    }
+    return _objectSpread({}, item);
+  }).filter(function (item) {
+    return item;
+  });
+};
+/**
+ * support pathToRegexp get string
+ */
+var RouteListMap = /*#__PURE__*/function (_Map) {
+  function RouteListMap() {
+    _classCallCheck(this, RouteListMap);
+    return _callSuper(this, RouteListMap, arguments);
+  }
+  _inherits(RouteListMap, _Map);
+  return _createClass(RouteListMap, [{
+    key: "get",
+    value: function get(pathname) {
+      var routeValue;
+      try {
+        // eslint-disable-next-line no-restricted-syntax
+        var _iterator = _createForOfIteratorHelper(this.entries()),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var _step$value = _slicedToArray(_step.value, 2),
+              key = _step$value[0],
+              value = _step$value[1];
+            var path = stripQueryStringAndHashFromPath(key);
+            if (!isUrl(key) && pathToRegexp(path, []).test(pathname)) {
+              routeValue = value;
+              break;
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      } catch (error) {
+        routeValue = undefined;
+      }
+      return routeValue;
+    }
+  }]);
+}(/*#__PURE__*/_wrapNativeSuper(Map));
+/**
+ * 获取面包屑映射
+ * @param MenuDataItem[] menuData 菜单配置
+ */
+var getBreadcrumbNameMap = function getBreadcrumbNameMap(menuData) {
+  // Map is used to ensure the order of keys
+  var routerMap = new RouteListMap();
+  var _flattenMenuData = function flattenMenuData(data, parent) {
+    data.forEach(function (menuItem) {
+      var routerChildren = menuItem.children || menuItem[childrenPropsName] || [];
+      if (notNullArray(routerChildren)) {
+        _flattenMenuData(routerChildren, menuItem);
+      }
+      // Reduce memory usage
+      var path = mergePath(menuItem.path, parent ? parent.path : '/');
+      routerMap.set(stripQueryStringAndHashFromPath(path), menuItem);
+    });
+  };
+  _flattenMenuData(menuData);
+  return routerMap;
+};
+var _clearChildren = function clearChildren() {
+  var menuData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return menuData.map(function (item) {
+    var routerChildren = item.children || item[childrenPropsName];
+    if (notNullArray(routerChildren)) {
+      var newChildren = _clearChildren(routerChildren);
+      if (newChildren.length) return _objectSpread({}, item);
+    }
+    var finallyItem = _objectSpread({}, item);
+    delete finallyItem[childrenPropsName];
+    delete finallyItem.children;
+    return finallyItem;
+  }).filter(function (item) {
+    return item;
+  });
+};
+/**
+ * @param routeList 路由配置
+ * @param locale 是否使用国际化
+ * @param formatMessage 国际化的程序
+ * @param ignoreFilter 是否筛选掉不展示的 menuItem 项，plugin-layout需要所有项目来计算布局样式
+ * @returns { breadcrumb, menuData}
+ */
+var transformRoute = function transformRoute(routeList, locale, formatMessage, ignoreFilter) {
+  var originalMenuData = formatter({
+    data: _toConsumableArray(routeList).map(function (item) {
+      return _objectSpread({}, item);
+    }),
+    formatMessage: formatMessage,
+    locale: locale
+  });
+  var menuData = ignoreFilter ? _clearChildren(originalMenuData) : _defaultFilterMenuData(originalMenuData);
+  // Map type used for internal logic
+  var breadcrumb = getBreadcrumbNameMap(originalMenuData);
+  return {
+    breadcrumb: breadcrumb,
+    menuData: menuData
+  };
+};
+export default transformRoute;

node_modules/@umijs/route-utils/es/types.js

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