@teamix/pro 1.5.5 → 1.5.7-beta.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/pro.js CHANGED
@@ -59618,517 +59618,6 @@ module.exports = posix;
59618
59618
 
59619
59619
  /***/ }),
59620
59620
 
59621
- /***/ 56947:
59622
- /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
59623
-
59624
- "use strict";
59625
- // Copyright Joyent, Inc. and other Node contributors.
59626
- //
59627
- // Permission is hereby granted, free of charge, to any person obtaining a
59628
- // copy of this software and associated documentation files (the
59629
- // "Software"), to deal in the Software without restriction, including
59630
- // without limitation the rights to use, copy, modify, merge, publish,
59631
- // distribute, sublicense, and/or sell copies of the Software, and to permit
59632
- // persons to whom the Software is furnished to do so, subject to the
59633
- // following conditions:
59634
- //
59635
- // The above copyright notice and this permission notice shall be included
59636
- // in all copies or substantial portions of the Software.
59637
- //
59638
- // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
59639
- // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
59640
- // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
59641
- // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
59642
- // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
59643
- // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
59644
- // USE OR OTHER DEALINGS IN THE SOFTWARE.
59645
-
59646
-
59647
-
59648
- function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
59649
- var isWindows = process.platform === 'win32';
59650
- var util = __webpack_require__(74585);
59651
-
59652
- // resolves . and .. elements in a path array with directory names there
59653
- // must be no slashes or device names (c:\) in the array
59654
- // (so also no leading and trailing slashes - it does not distinguish
59655
- // relative and absolute paths)
59656
- function normalizeArray(parts, allowAboveRoot) {
59657
- var res = [];
59658
- for (var i = 0; i < parts.length; i++) {
59659
- var p = parts[i];
59660
-
59661
- // ignore empty parts
59662
- if (!p || p === '.') continue;
59663
- if (p === '..') {
59664
- if (res.length && res[res.length - 1] !== '..') {
59665
- res.pop();
59666
- } else if (allowAboveRoot) {
59667
- res.push('..');
59668
- }
59669
- } else {
59670
- res.push(p);
59671
- }
59672
- }
59673
- return res;
59674
- }
59675
-
59676
- // returns an array with empty elements removed from either end of the input
59677
- // array or the original array if no elements need to be removed
59678
- function trimArray(arr) {
59679
- var lastIndex = arr.length - 1;
59680
- var start = 0;
59681
- for (; start <= lastIndex; start++) {
59682
- if (arr[start]) break;
59683
- }
59684
- var end = lastIndex;
59685
- for (; end >= 0; end--) {
59686
- if (arr[end]) break;
59687
- }
59688
- if (start === 0 && end === lastIndex) return arr;
59689
- if (start > end) return [];
59690
- return arr.slice(start, end + 1);
59691
- }
59692
-
59693
- // Regex to split a windows path into three parts: [*, device, slash,
59694
- // tail] windows-only
59695
- var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
59696
-
59697
- // Regex to split the tail part of the above into [*, dir, basename, ext]
59698
- var splitTailRe = /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;
59699
- var win32 = {};
59700
-
59701
- // Function to split a filename into [root, dir, basename, ext]
59702
- function win32SplitPath(filename) {
59703
- // Separate device+slash from tail
59704
- var result = splitDeviceRe.exec(filename),
59705
- device = (result[1] || '') + (result[2] || ''),
59706
- tail = result[3] || '';
59707
- // Split the tail into dir, basename and extension
59708
- var result2 = splitTailRe.exec(tail),
59709
- dir = result2[1],
59710
- basename = result2[2],
59711
- ext = result2[3];
59712
- return [device, dir, basename, ext];
59713
- }
59714
- function win32StatPath(path) {
59715
- var result = splitDeviceRe.exec(path),
59716
- device = result[1] || '',
59717
- isUnc = !!device && device[1] !== ':';
59718
- return {
59719
- device: device,
59720
- isUnc: isUnc,
59721
- isAbsolute: isUnc || !!result[2],
59722
- // UNC paths are always absolute
59723
- tail: result[3]
59724
- };
59725
- }
59726
- function normalizeUNCRoot(device) {
59727
- return '\\\\' + device.replace(/^[\\\/]+/, '').replace(/[\\\/]+/g, '\\');
59728
- }
59729
-
59730
- // path.resolve([from ...], to)
59731
- win32.resolve = function () {
59732
- var resolvedDevice = '',
59733
- resolvedTail = '',
59734
- resolvedAbsolute = false;
59735
- for (var i = arguments.length - 1; i >= -1; i--) {
59736
- var path;
59737
- if (i >= 0) {
59738
- path = arguments[i];
59739
- } else if (!resolvedDevice) {
59740
- path = process.cwd();
59741
- } else {
59742
- // Windows has the concept of drive-specific current working
59743
- // directories. If we've resolved a drive letter but not yet an
59744
- // absolute path, get cwd for that drive. We're sure the device is not
59745
- // an unc path at this points, because unc paths are always absolute.
59746
- path = process.env['=' + resolvedDevice];
59747
- // Verify that a drive-local cwd was found and that it actually points
59748
- // to our drive. If not, default to the drive's root.
59749
- if (!path || path.substr(0, 3).toLowerCase() !== resolvedDevice.toLowerCase() + '\\') {
59750
- path = resolvedDevice + '\\';
59751
- }
59752
- }
59753
-
59754
- // Skip empty and invalid entries
59755
- if (!util.isString(path)) {
59756
- throw new TypeError('Arguments to path.resolve must be strings');
59757
- } else if (!path) {
59758
- continue;
59759
- }
59760
- var result = win32StatPath(path),
59761
- device = result.device,
59762
- isUnc = result.isUnc,
59763
- isAbsolute = result.isAbsolute,
59764
- tail = result.tail;
59765
- if (device && resolvedDevice && device.toLowerCase() !== resolvedDevice.toLowerCase()) {
59766
- // This path points to another device so it is not applicable
59767
- continue;
59768
- }
59769
- if (!resolvedDevice) {
59770
- resolvedDevice = device;
59771
- }
59772
- if (!resolvedAbsolute) {
59773
- resolvedTail = tail + '\\' + resolvedTail;
59774
- resolvedAbsolute = isAbsolute;
59775
- }
59776
- if (resolvedDevice && resolvedAbsolute) {
59777
- break;
59778
- }
59779
- }
59780
-
59781
- // Convert slashes to backslashes when `resolvedDevice` points to an UNC
59782
- // root. Also squash multiple slashes into a single one where appropriate.
59783
- if (isUnc) {
59784
- resolvedDevice = normalizeUNCRoot(resolvedDevice);
59785
- }
59786
-
59787
- // At this point the path should be resolved to a full absolute path,
59788
- // but handle relative paths to be safe (might happen when process.cwd()
59789
- // fails)
59790
-
59791
- // Normalize the tail path
59792
- resolvedTail = normalizeArray(resolvedTail.split(/[\\\/]+/), !resolvedAbsolute).join('\\');
59793
- return resolvedDevice + (resolvedAbsolute ? '\\' : '') + resolvedTail || '.';
59794
- };
59795
- win32.normalize = function (path) {
59796
- var result = win32StatPath(path),
59797
- device = result.device,
59798
- isUnc = result.isUnc,
59799
- isAbsolute = result.isAbsolute,
59800
- tail = result.tail,
59801
- trailingSlash = /[\\\/]$/.test(tail);
59802
-
59803
- // Normalize the tail path
59804
- tail = normalizeArray(tail.split(/[\\\/]+/), !isAbsolute).join('\\');
59805
- if (!tail && !isAbsolute) {
59806
- tail = '.';
59807
- }
59808
- if (tail && trailingSlash) {
59809
- tail += '\\';
59810
- }
59811
-
59812
- // Convert slashes to backslashes when `device` points to an UNC root.
59813
- // Also squash multiple slashes into a single one where appropriate.
59814
- if (isUnc) {
59815
- device = normalizeUNCRoot(device);
59816
- }
59817
- return device + (isAbsolute ? '\\' : '') + tail;
59818
- };
59819
- win32.isAbsolute = function (path) {
59820
- return win32StatPath(path).isAbsolute;
59821
- };
59822
- win32.join = function () {
59823
- var paths = [];
59824
- for (var i = 0; i < arguments.length; i++) {
59825
- var arg = arguments[i];
59826
- if (!util.isString(arg)) {
59827
- throw new TypeError('Arguments to path.join must be strings');
59828
- }
59829
- if (arg) {
59830
- paths.push(arg);
59831
- }
59832
- }
59833
- var joined = paths.join('\\');
59834
-
59835
- // Make sure that the joined path doesn't start with two slashes, because
59836
- // normalize() will mistake it for an UNC path then.
59837
- //
59838
- // This step is skipped when it is very clear that the user actually
59839
- // intended to point at an UNC path. This is assumed when the first
59840
- // non-empty string arguments starts with exactly two slashes followed by
59841
- // at least one more non-slash character.
59842
- //
59843
- // Note that for normalize() to treat a path as an UNC path it needs to
59844
- // have at least 2 components, so we don't filter for that here.
59845
- // This means that the user can use join to construct UNC paths from
59846
- // a server name and a share name; for example:
59847
- // path.join('//server', 'share') -> '\\\\server\\share\')
59848
- if (!/^[\\\/]{2}[^\\\/]/.test(paths[0])) {
59849
- joined = joined.replace(/^[\\\/]{2,}/, '\\');
59850
- }
59851
- return win32.normalize(joined);
59852
- };
59853
-
59854
- // path.relative(from, to)
59855
- // it will solve the relative path from 'from' to 'to', for instance:
59856
- // from = 'C:\\orandea\\test\\aaa'
59857
- // to = 'C:\\orandea\\impl\\bbb'
59858
- // The output of the function should be: '..\\..\\impl\\bbb'
59859
- win32.relative = function (from, to) {
59860
- from = win32.resolve(from);
59861
- to = win32.resolve(to);
59862
-
59863
- // windows is not case sensitive
59864
- var lowerFrom = from.toLowerCase();
59865
- var lowerTo = to.toLowerCase();
59866
- var toParts = trimArray(to.split('\\'));
59867
- var lowerFromParts = trimArray(lowerFrom.split('\\'));
59868
- var lowerToParts = trimArray(lowerTo.split('\\'));
59869
- var length = Math.min(lowerFromParts.length, lowerToParts.length);
59870
- var samePartsLength = length;
59871
- for (var i = 0; i < length; i++) {
59872
- if (lowerFromParts[i] !== lowerToParts[i]) {
59873
- samePartsLength = i;
59874
- break;
59875
- }
59876
- }
59877
- if (samePartsLength == 0) {
59878
- return to;
59879
- }
59880
- var outputParts = [];
59881
- for (var i = samePartsLength; i < lowerFromParts.length; i++) {
59882
- outputParts.push('..');
59883
- }
59884
- outputParts = outputParts.concat(toParts.slice(samePartsLength));
59885
- return outputParts.join('\\');
59886
- };
59887
- win32._makeLong = function (path) {
59888
- // Note: this will *probably* throw somewhere.
59889
- if (!util.isString(path)) return path;
59890
- if (!path) {
59891
- return '';
59892
- }
59893
- var resolvedPath = win32.resolve(path);
59894
- if (/^[a-zA-Z]\:\\/.test(resolvedPath)) {
59895
- // path is local filesystem path, which needs to be converted
59896
- // to long UNC path.
59897
- return '\\\\?\\' + resolvedPath;
59898
- } else if (/^\\\\[^?.]/.test(resolvedPath)) {
59899
- // path is network UNC path, which needs to be converted
59900
- // to long UNC path.
59901
- return "\\\\?\\UNC\\" + resolvedPath.substring(2);
59902
- }
59903
- return path;
59904
- };
59905
- win32.dirname = function (path) {
59906
- var result = win32SplitPath(path),
59907
- root = result[0],
59908
- dir = result[1];
59909
- if (!root && !dir) {
59910
- // No dirname whatsoever
59911
- return '.';
59912
- }
59913
- if (dir) {
59914
- // It has a dirname, strip trailing slash
59915
- dir = dir.substr(0, dir.length - 1);
59916
- }
59917
- return root + dir;
59918
- };
59919
- win32.basename = function (path, ext) {
59920
- var f = win32SplitPath(path)[2];
59921
- // TODO: make this comparison case-insensitive on windows?
59922
- if (ext && f.substr(-1 * ext.length) === ext) {
59923
- f = f.substr(0, f.length - ext.length);
59924
- }
59925
- return f;
59926
- };
59927
- win32.extname = function (path) {
59928
- return win32SplitPath(path)[3];
59929
- };
59930
- win32.format = function (pathObject) {
59931
- if (!util.isObject(pathObject)) {
59932
- throw new TypeError("Parameter 'pathObject' must be an object, not " + _typeof(pathObject));
59933
- }
59934
- var root = pathObject.root || '';
59935
- if (!util.isString(root)) {
59936
- throw new TypeError("'pathObject.root' must be a string or undefined, not " + _typeof(pathObject.root));
59937
- }
59938
- var dir = pathObject.dir;
59939
- var base = pathObject.base || '';
59940
- if (!dir) {
59941
- return base;
59942
- }
59943
- if (dir[dir.length - 1] === win32.sep) {
59944
- return dir + base;
59945
- }
59946
- return dir + win32.sep + base;
59947
- };
59948
- win32.parse = function (pathString) {
59949
- if (!util.isString(pathString)) {
59950
- throw new TypeError("Parameter 'pathString' must be a string, not " + _typeof(pathString));
59951
- }
59952
- var allParts = win32SplitPath(pathString);
59953
- if (!allParts || allParts.length !== 4) {
59954
- throw new TypeError("Invalid path '" + pathString + "'");
59955
- }
59956
- return {
59957
- root: allParts[0],
59958
- dir: allParts[0] + allParts[1].slice(0, -1),
59959
- base: allParts[2],
59960
- ext: allParts[3],
59961
- name: allParts[2].slice(0, allParts[2].length - allParts[3].length)
59962
- };
59963
- };
59964
- win32.sep = '\\';
59965
- win32.delimiter = ';';
59966
-
59967
- // Split a filename into [root, dir, basename, ext], unix version
59968
- // 'root' is just a slash, or nothing.
59969
- var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
59970
- var posix = {};
59971
- function posixSplitPath(filename) {
59972
- return splitPathRe.exec(filename).slice(1);
59973
- }
59974
-
59975
- // path.resolve([from ...], to)
59976
- // posix version
59977
- posix.resolve = function () {
59978
- var resolvedPath = '',
59979
- resolvedAbsolute = false;
59980
- for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
59981
- var path = i >= 0 ? arguments[i] : process.cwd();
59982
-
59983
- // Skip empty and invalid entries
59984
- if (!util.isString(path)) {
59985
- throw new TypeError('Arguments to path.resolve must be strings');
59986
- } else if (!path) {
59987
- continue;
59988
- }
59989
- resolvedPath = path + '/' + resolvedPath;
59990
- resolvedAbsolute = path[0] === '/';
59991
- }
59992
-
59993
- // At this point the path should be resolved to a full absolute path, but
59994
- // handle relative paths to be safe (might happen when process.cwd() fails)
59995
-
59996
- // Normalize the path
59997
- resolvedPath = normalizeArray(resolvedPath.split('/'), !resolvedAbsolute).join('/');
59998
- return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';
59999
- };
60000
-
60001
- // path.normalize(path)
60002
- // posix version
60003
- posix.normalize = function (path) {
60004
- var isAbsolute = posix.isAbsolute(path),
60005
- trailingSlash = path && path[path.length - 1] === '/';
60006
-
60007
- // Normalize the path
60008
- path = normalizeArray(path.split('/'), !isAbsolute).join('/');
60009
- if (!path && !isAbsolute) {
60010
- path = '.';
60011
- }
60012
- if (path && trailingSlash) {
60013
- path += '/';
60014
- }
60015
- return (isAbsolute ? '/' : '') + path;
60016
- };
60017
-
60018
- // posix version
60019
- posix.isAbsolute = function (path) {
60020
- return path.charAt(0) === '/';
60021
- };
60022
-
60023
- // posix version
60024
- posix.join = function () {
60025
- var path = '';
60026
- for (var i = 0; i < arguments.length; i++) {
60027
- var segment = arguments[i];
60028
- if (!util.isString(segment)) {
60029
- throw new TypeError('Arguments to path.join must be strings');
60030
- }
60031
- if (segment) {
60032
- if (!path) {
60033
- path += segment;
60034
- } else {
60035
- path += '/' + segment;
60036
- }
60037
- }
60038
- }
60039
- return posix.normalize(path);
60040
- };
60041
-
60042
- // path.relative(from, to)
60043
- // posix version
60044
- posix.relative = function (from, to) {
60045
- from = posix.resolve(from).substr(1);
60046
- to = posix.resolve(to).substr(1);
60047
- var fromParts = trimArray(from.split('/'));
60048
- var toParts = trimArray(to.split('/'));
60049
- var length = Math.min(fromParts.length, toParts.length);
60050
- var samePartsLength = length;
60051
- for (var i = 0; i < length; i++) {
60052
- if (fromParts[i] !== toParts[i]) {
60053
- samePartsLength = i;
60054
- break;
60055
- }
60056
- }
60057
- var outputParts = [];
60058
- for (var i = samePartsLength; i < fromParts.length; i++) {
60059
- outputParts.push('..');
60060
- }
60061
- outputParts = outputParts.concat(toParts.slice(samePartsLength));
60062
- return outputParts.join('/');
60063
- };
60064
- posix._makeLong = function (path) {
60065
- return path;
60066
- };
60067
- posix.dirname = function (path) {
60068
- var result = posixSplitPath(path),
60069
- root = result[0],
60070
- dir = result[1];
60071
- if (!root && !dir) {
60072
- // No dirname whatsoever
60073
- return '.';
60074
- }
60075
- if (dir) {
60076
- // It has a dirname, strip trailing slash
60077
- dir = dir.substr(0, dir.length - 1);
60078
- }
60079
- return root + dir;
60080
- };
60081
- posix.basename = function (path, ext) {
60082
- var f = posixSplitPath(path)[2];
60083
- // TODO: make this comparison case-insensitive on windows?
60084
- if (ext && f.substr(-1 * ext.length) === ext) {
60085
- f = f.substr(0, f.length - ext.length);
60086
- }
60087
- return f;
60088
- };
60089
- posix.extname = function (path) {
60090
- return posixSplitPath(path)[3];
60091
- };
60092
- posix.format = function (pathObject) {
60093
- if (!util.isObject(pathObject)) {
60094
- throw new TypeError("Parameter 'pathObject' must be an object, not " + _typeof(pathObject));
60095
- }
60096
- var root = pathObject.root || '';
60097
- if (!util.isString(root)) {
60098
- throw new TypeError("'pathObject.root' must be a string or undefined, not " + _typeof(pathObject.root));
60099
- }
60100
- var dir = pathObject.dir ? pathObject.dir + posix.sep : '';
60101
- var base = pathObject.base || '';
60102
- return dir + base;
60103
- };
60104
- posix.parse = function (pathString) {
60105
- if (!util.isString(pathString)) {
60106
- throw new TypeError("Parameter 'pathString' must be a string, not " + _typeof(pathString));
60107
- }
60108
- var allParts = posixSplitPath(pathString);
60109
- if (!allParts || allParts.length !== 4) {
60110
- throw new TypeError("Invalid path '" + pathString + "'");
60111
- }
60112
- allParts[1] = allParts[1] || '';
60113
- allParts[2] = allParts[2] || '';
60114
- allParts[3] = allParts[3] || '';
60115
- return {
60116
- root: allParts[0],
60117
- dir: allParts[0] + allParts[1].slice(0, -1),
60118
- base: allParts[2],
60119
- ext: allParts[3],
60120
- name: allParts[2].slice(0, allParts[2].length - allParts[3].length)
60121
- };
60122
- };
60123
- posix.sep = '/';
60124
- posix.delimiter = ':';
60125
- if (isWindows) module.exports = win32;else /* posix */
60126
- module.exports = posix;
60127
- module.exports.posix = posix;
60128
- module.exports.win32 = win32;
60129
-
60130
- /***/ }),
60131
-
60132
59621
  /***/ 89112:
60133
59622
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
60134
59623
 
@@ -63693,551 +63182,6 @@ function useDeepCompareEffectNoCheck(callback, dependencies) {
63693
63182
  }
63694
63183
 
63695
63184
 
63696
- /***/ }),
63697
-
63698
- /***/ 29007:
63699
- /***/ ((module) => {
63700
-
63701
- if (typeof Object.create === 'function') {
63702
- // implementation from standard node.js 'util' module
63703
- module.exports = function inherits(ctor, superCtor) {
63704
- ctor.super_ = superCtor;
63705
- ctor.prototype = Object.create(superCtor.prototype, {
63706
- constructor: {
63707
- value: ctor,
63708
- enumerable: false,
63709
- writable: true,
63710
- configurable: true
63711
- }
63712
- });
63713
- };
63714
- } else {
63715
- // old school shim for old browsers
63716
- module.exports = function inherits(ctor, superCtor) {
63717
- ctor.super_ = superCtor;
63718
- var TempCtor = function TempCtor() {};
63719
- TempCtor.prototype = superCtor.prototype;
63720
- ctor.prototype = new TempCtor();
63721
- ctor.prototype.constructor = ctor;
63722
- };
63723
- }
63724
-
63725
- /***/ }),
63726
-
63727
- /***/ 62050:
63728
- /***/ ((module) => {
63729
-
63730
- function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
63731
- module.exports = function isBuffer(arg) {
63732
- return arg && _typeof(arg) === 'object' && typeof arg.copy === 'function' && typeof arg.fill === 'function' && typeof arg.readUInt8 === 'function';
63733
- };
63734
-
63735
- /***/ }),
63736
-
63737
- /***/ 74585:
63738
- /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
63739
-
63740
- function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
63741
- // Copyright Joyent, Inc. and other Node contributors.
63742
- //
63743
- // Permission is hereby granted, free of charge, to any person obtaining a
63744
- // copy of this software and associated documentation files (the
63745
- // "Software"), to deal in the Software without restriction, including
63746
- // without limitation the rights to use, copy, modify, merge, publish,
63747
- // distribute, sublicense, and/or sell copies of the Software, and to permit
63748
- // persons to whom the Software is furnished to do so, subject to the
63749
- // following conditions:
63750
- //
63751
- // The above copyright notice and this permission notice shall be included
63752
- // in all copies or substantial portions of the Software.
63753
- //
63754
- // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
63755
- // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
63756
- // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
63757
- // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
63758
- // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
63759
- // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
63760
- // USE OR OTHER DEALINGS IN THE SOFTWARE.
63761
-
63762
- var formatRegExp = /%[sdj%]/g;
63763
- exports.format = function (f) {
63764
- if (!isString(f)) {
63765
- var objects = [];
63766
- for (var i = 0; i < arguments.length; i++) {
63767
- objects.push(inspect(arguments[i]));
63768
- }
63769
- return objects.join(' ');
63770
- }
63771
- var i = 1;
63772
- var args = arguments;
63773
- var len = args.length;
63774
- var str = String(f).replace(formatRegExp, function (x) {
63775
- if (x === '%%') return '%';
63776
- if (i >= len) return x;
63777
- switch (x) {
63778
- case '%s':
63779
- return String(args[i++]);
63780
- case '%d':
63781
- return Number(args[i++]);
63782
- case '%j':
63783
- try {
63784
- return JSON.stringify(args[i++]);
63785
- } catch (_) {
63786
- return '[Circular]';
63787
- }
63788
- default:
63789
- return x;
63790
- }
63791
- });
63792
- for (var x = args[i]; i < len; x = args[++i]) {
63793
- if (isNull(x) || !isObject(x)) {
63794
- str += ' ' + x;
63795
- } else {
63796
- str += ' ' + inspect(x);
63797
- }
63798
- }
63799
- return str;
63800
- };
63801
-
63802
- // Mark that a method should not be used.
63803
- // Returns a modified function which warns once by default.
63804
- // If --no-deprecation is set, then it is a no-op.
63805
- exports.deprecate = function (fn, msg) {
63806
- // Allow for deprecating things in the process of starting up.
63807
- if (isUndefined(__webpack_require__.g.process)) {
63808
- return function () {
63809
- return exports.deprecate(fn, msg).apply(this, arguments);
63810
- };
63811
- }
63812
- if (process.noDeprecation === true) {
63813
- return fn;
63814
- }
63815
- var warned = false;
63816
- function deprecated() {
63817
- if (!warned) {
63818
- if (process.throwDeprecation) {
63819
- throw new Error(msg);
63820
- } else if (process.traceDeprecation) {
63821
- console.trace(msg);
63822
- } else {
63823
- console.error(msg);
63824
- }
63825
- warned = true;
63826
- }
63827
- return fn.apply(this, arguments);
63828
- }
63829
- return deprecated;
63830
- };
63831
- var debugs = {};
63832
- var debugEnviron;
63833
- exports.debuglog = function (set) {
63834
- if (isUndefined(debugEnviron)) debugEnviron = process.env.NODE_DEBUG || '';
63835
- set = set.toUpperCase();
63836
- if (!debugs[set]) {
63837
- if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
63838
- var pid = process.pid;
63839
- debugs[set] = function () {
63840
- var msg = exports.format.apply(exports, arguments);
63841
- console.error('%s %d: %s', set, pid, msg);
63842
- };
63843
- } else {
63844
- debugs[set] = function () {};
63845
- }
63846
- }
63847
- return debugs[set];
63848
- };
63849
-
63850
- /**
63851
- * Echos the value of a value. Trys to print the value out
63852
- * in the best way possible given the different types.
63853
- *
63854
- * @param {Object} obj The object to print out.
63855
- * @param {Object} opts Optional options object that alters the output.
63856
- */
63857
- /* legacy: obj, showHidden, depth, colors*/
63858
- function inspect(obj, opts) {
63859
- // default options
63860
- var ctx = {
63861
- seen: [],
63862
- stylize: stylizeNoColor
63863
- };
63864
- // legacy...
63865
- if (arguments.length >= 3) ctx.depth = arguments[2];
63866
- if (arguments.length >= 4) ctx.colors = arguments[3];
63867
- if (isBoolean(opts)) {
63868
- // legacy...
63869
- ctx.showHidden = opts;
63870
- } else if (opts) {
63871
- // got an "options" object
63872
- exports._extend(ctx, opts);
63873
- }
63874
- // set default options
63875
- if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
63876
- if (isUndefined(ctx.depth)) ctx.depth = 2;
63877
- if (isUndefined(ctx.colors)) ctx.colors = false;
63878
- if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
63879
- if (ctx.colors) ctx.stylize = stylizeWithColor;
63880
- return formatValue(ctx, obj, ctx.depth);
63881
- }
63882
- exports.inspect = inspect;
63883
-
63884
- // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
63885
- inspect.colors = {
63886
- 'bold': [1, 22],
63887
- 'italic': [3, 23],
63888
- 'underline': [4, 24],
63889
- 'inverse': [7, 27],
63890
- 'white': [37, 39],
63891
- 'grey': [90, 39],
63892
- 'black': [30, 39],
63893
- 'blue': [34, 39],
63894
- 'cyan': [36, 39],
63895
- 'green': [32, 39],
63896
- 'magenta': [35, 39],
63897
- 'red': [31, 39],
63898
- 'yellow': [33, 39]
63899
- };
63900
-
63901
- // Don't use 'blue' not visible on cmd.exe
63902
- inspect.styles = {
63903
- 'special': 'cyan',
63904
- 'number': 'yellow',
63905
- 'boolean': 'yellow',
63906
- 'undefined': 'grey',
63907
- 'null': 'bold',
63908
- 'string': 'green',
63909
- 'date': 'magenta',
63910
- // "name": intentionally not styling
63911
- 'regexp': 'red'
63912
- };
63913
- function stylizeWithColor(str, styleType) {
63914
- var style = inspect.styles[styleType];
63915
- if (style) {
63916
- return "\x1B[" + inspect.colors[style][0] + 'm' + str + "\x1B[" + inspect.colors[style][1] + 'm';
63917
- } else {
63918
- return str;
63919
- }
63920
- }
63921
- function stylizeNoColor(str, styleType) {
63922
- return str;
63923
- }
63924
- function arrayToHash(array) {
63925
- var hash = {};
63926
- array.forEach(function (val, idx) {
63927
- hash[val] = true;
63928
- });
63929
- return hash;
63930
- }
63931
- function formatValue(ctx, value, recurseTimes) {
63932
- // Provide a hook for user-specified inspect functions.
63933
- // Check that value is an object with an inspect function on it
63934
- if (ctx.customInspect && value && isFunction(value.inspect) &&
63935
- // Filter out the util module, it's inspect function is special
63936
- value.inspect !== exports.inspect &&
63937
- // Also filter out any prototype objects using the circular check.
63938
- !(value.constructor && value.constructor.prototype === value)) {
63939
- var ret = value.inspect(recurseTimes, ctx);
63940
- if (!isString(ret)) {
63941
- ret = formatValue(ctx, ret, recurseTimes);
63942
- }
63943
- return ret;
63944
- }
63945
-
63946
- // Primitive types cannot have properties
63947
- var primitive = formatPrimitive(ctx, value);
63948
- if (primitive) {
63949
- return primitive;
63950
- }
63951
-
63952
- // Look up the keys of the object.
63953
- var keys = Object.keys(value);
63954
- var visibleKeys = arrayToHash(keys);
63955
- if (ctx.showHidden) {
63956
- keys = Object.getOwnPropertyNames(value);
63957
- }
63958
-
63959
- // IE doesn't make error fields non-enumerable
63960
- // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
63961
- if (isError(value) && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
63962
- return formatError(value);
63963
- }
63964
-
63965
- // Some type of object without properties can be shortcutted.
63966
- if (keys.length === 0) {
63967
- if (isFunction(value)) {
63968
- var name = value.name ? ': ' + value.name : '';
63969
- return ctx.stylize('[Function' + name + ']', 'special');
63970
- }
63971
- if (isRegExp(value)) {
63972
- return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
63973
- }
63974
- if (isDate(value)) {
63975
- return ctx.stylize(Date.prototype.toString.call(value), 'date');
63976
- }
63977
- if (isError(value)) {
63978
- return formatError(value);
63979
- }
63980
- }
63981
- var base = '',
63982
- array = false,
63983
- braces = ['{', '}'];
63984
-
63985
- // Make Array say that they are Array
63986
- if (isArray(value)) {
63987
- array = true;
63988
- braces = ['[', ']'];
63989
- }
63990
-
63991
- // Make functions say that they are functions
63992
- if (isFunction(value)) {
63993
- var n = value.name ? ': ' + value.name : '';
63994
- base = ' [Function' + n + ']';
63995
- }
63996
-
63997
- // Make RegExps say that they are RegExps
63998
- if (isRegExp(value)) {
63999
- base = ' ' + RegExp.prototype.toString.call(value);
64000
- }
64001
-
64002
- // Make dates with properties first say the date
64003
- if (isDate(value)) {
64004
- base = ' ' + Date.prototype.toUTCString.call(value);
64005
- }
64006
-
64007
- // Make error with message first say the error
64008
- if (isError(value)) {
64009
- base = ' ' + formatError(value);
64010
- }
64011
- if (keys.length === 0 && (!array || value.length == 0)) {
64012
- return braces[0] + base + braces[1];
64013
- }
64014
- if (recurseTimes < 0) {
64015
- if (isRegExp(value)) {
64016
- return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
64017
- } else {
64018
- return ctx.stylize('[Object]', 'special');
64019
- }
64020
- }
64021
- ctx.seen.push(value);
64022
- var output;
64023
- if (array) {
64024
- output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
64025
- } else {
64026
- output = keys.map(function (key) {
64027
- return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
64028
- });
64029
- }
64030
- ctx.seen.pop();
64031
- return reduceToSingleString(output, base, braces);
64032
- }
64033
- function formatPrimitive(ctx, value) {
64034
- if (isUndefined(value)) return ctx.stylize('undefined', 'undefined');
64035
- if (isString(value)) {
64036
- var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '').replace(/'/g, "\\'").replace(/\\"/g, '"') + '\'';
64037
- return ctx.stylize(simple, 'string');
64038
- }
64039
- if (isNumber(value)) return ctx.stylize('' + value, 'number');
64040
- if (isBoolean(value)) return ctx.stylize('' + value, 'boolean');
64041
- // For some reason typeof null is "object", so special case here.
64042
- if (isNull(value)) return ctx.stylize('null', 'null');
64043
- }
64044
- function formatError(value) {
64045
- return '[' + Error.prototype.toString.call(value) + ']';
64046
- }
64047
- function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
64048
- var output = [];
64049
- for (var i = 0, l = value.length; i < l; ++i) {
64050
- if (hasOwnProperty(value, String(i))) {
64051
- output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
64052
- } else {
64053
- output.push('');
64054
- }
64055
- }
64056
- keys.forEach(function (key) {
64057
- if (!key.match(/^\d+$/)) {
64058
- output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
64059
- }
64060
- });
64061
- return output;
64062
- }
64063
- function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
64064
- var name, str, desc;
64065
- desc = Object.getOwnPropertyDescriptor(value, key) || {
64066
- value: value[key]
64067
- };
64068
- if (desc.get) {
64069
- if (desc.set) {
64070
- str = ctx.stylize('[Getter/Setter]', 'special');
64071
- } else {
64072
- str = ctx.stylize('[Getter]', 'special');
64073
- }
64074
- } else {
64075
- if (desc.set) {
64076
- str = ctx.stylize('[Setter]', 'special');
64077
- }
64078
- }
64079
- if (!hasOwnProperty(visibleKeys, key)) {
64080
- name = '[' + key + ']';
64081
- }
64082
- if (!str) {
64083
- if (ctx.seen.indexOf(desc.value) < 0) {
64084
- if (isNull(recurseTimes)) {
64085
- str = formatValue(ctx, desc.value, null);
64086
- } else {
64087
- str = formatValue(ctx, desc.value, recurseTimes - 1);
64088
- }
64089
- if (str.indexOf('\n') > -1) {
64090
- if (array) {
64091
- str = str.split('\n').map(function (line) {
64092
- return ' ' + line;
64093
- }).join('\n').substr(2);
64094
- } else {
64095
- str = '\n' + str.split('\n').map(function (line) {
64096
- return ' ' + line;
64097
- }).join('\n');
64098
- }
64099
- }
64100
- } else {
64101
- str = ctx.stylize('[Circular]', 'special');
64102
- }
64103
- }
64104
- if (isUndefined(name)) {
64105
- if (array && key.match(/^\d+$/)) {
64106
- return str;
64107
- }
64108
- name = JSON.stringify('' + key);
64109
- if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
64110
- name = name.substr(1, name.length - 2);
64111
- name = ctx.stylize(name, 'name');
64112
- } else {
64113
- name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
64114
- name = ctx.stylize(name, 'string');
64115
- }
64116
- }
64117
- return name + ': ' + str;
64118
- }
64119
- function reduceToSingleString(output, base, braces) {
64120
- var numLinesEst = 0;
64121
- var length = output.reduce(function (prev, cur) {
64122
- numLinesEst++;
64123
- if (cur.indexOf('\n') >= 0) numLinesEst++;
64124
- return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
64125
- }, 0);
64126
- if (length > 60) {
64127
- return braces[0] + (base === '' ? '' : base + '\n ') + ' ' + output.join(',\n ') + ' ' + braces[1];
64128
- }
64129
- return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
64130
- }
64131
-
64132
- // NOTE: These type checking functions intentionally don't use `instanceof`
64133
- // because it is fragile and can be easily faked with `Object.create()`.
64134
- function isArray(ar) {
64135
- return Array.isArray(ar);
64136
- }
64137
- exports.isArray = isArray;
64138
- function isBoolean(arg) {
64139
- return typeof arg === 'boolean';
64140
- }
64141
- exports.isBoolean = isBoolean;
64142
- function isNull(arg) {
64143
- return arg === null;
64144
- }
64145
- exports.isNull = isNull;
64146
- function isNullOrUndefined(arg) {
64147
- return arg == null;
64148
- }
64149
- exports.isNullOrUndefined = isNullOrUndefined;
64150
- function isNumber(arg) {
64151
- return typeof arg === 'number';
64152
- }
64153
- exports.isNumber = isNumber;
64154
- function isString(arg) {
64155
- return typeof arg === 'string';
64156
- }
64157
- exports.isString = isString;
64158
- function isSymbol(arg) {
64159
- return _typeof(arg) === 'symbol';
64160
- }
64161
- exports.isSymbol = isSymbol;
64162
- function isUndefined(arg) {
64163
- return arg === void 0;
64164
- }
64165
- exports.isUndefined = isUndefined;
64166
- function isRegExp(re) {
64167
- return isObject(re) && objectToString(re) === '[object RegExp]';
64168
- }
64169
- exports.isRegExp = isRegExp;
64170
- function isObject(arg) {
64171
- return _typeof(arg) === 'object' && arg !== null;
64172
- }
64173
- exports.isObject = isObject;
64174
- function isDate(d) {
64175
- return isObject(d) && objectToString(d) === '[object Date]';
64176
- }
64177
- exports.isDate = isDate;
64178
- function isError(e) {
64179
- return isObject(e) && (objectToString(e) === '[object Error]' || e instanceof Error);
64180
- }
64181
- exports.isError = isError;
64182
- function isFunction(arg) {
64183
- return typeof arg === 'function';
64184
- }
64185
- exports.isFunction = isFunction;
64186
- function isPrimitive(arg) {
64187
- return arg === null || typeof arg === 'boolean' || typeof arg === 'number' || typeof arg === 'string' || _typeof(arg) === 'symbol' ||
64188
- // ES6 symbol
64189
- typeof arg === 'undefined';
64190
- }
64191
- exports.isPrimitive = isPrimitive;
64192
- exports.isBuffer = __webpack_require__(62050);
64193
- function objectToString(o) {
64194
- return Object.prototype.toString.call(o);
64195
- }
64196
- function pad(n) {
64197
- return n < 10 ? '0' + n.toString(10) : n.toString(10);
64198
- }
64199
- var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
64200
-
64201
- // 26 Feb 16:19:34
64202
- function timestamp() {
64203
- var d = new Date();
64204
- var time = [pad(d.getHours()), pad(d.getMinutes()), pad(d.getSeconds())].join(':');
64205
- return [d.getDate(), months[d.getMonth()], time].join(' ');
64206
- }
64207
-
64208
- // log is just a thin wrapper to console.log that prepends a timestamp
64209
- exports.log = function () {
64210
- console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
64211
- };
64212
-
64213
- /**
64214
- * Inherit the prototype methods from one constructor into another.
64215
- *
64216
- * The Function.prototype.inherits from lang.js rewritten as a standalone
64217
- * function (not on Function.prototype). NOTE: If this file is to be loaded
64218
- * during bootstrapping this function needs to be rewritten using some native
64219
- * functions as prototype setup using normal JavaScript does not work as
64220
- * expected during bootstrapping (see mirror.js in r114903).
64221
- *
64222
- * @param {function} ctor Constructor function which needs to inherit the
64223
- * prototype.
64224
- * @param {function} superCtor Constructor function to inherit prototype from.
64225
- */
64226
- exports.inherits = __webpack_require__(29007);
64227
- exports._extend = function (origin, add) {
64228
- // Don't do anything if add isn't an object
64229
- if (!add || !isObject(add)) return origin;
64230
- var keys = Object.keys(add);
64231
- var i = keys.length;
64232
- while (i--) {
64233
- origin[keys[i]] = add[keys[i]];
64234
- }
64235
- return origin;
64236
- };
64237
- function hasOwnProperty(obj, prop) {
64238
- return Object.prototype.hasOwnProperty.call(obj, prop);
64239
- }
64240
-
64241
63185
  /***/ }),
64242
63186
 
64243
63187
  /***/ 50870:
@@ -75690,16 +74634,68 @@ function renderPreviewProps(val, mode, render, options, beforeFormatter, customO
75690
74634
  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
75691
74635
  /* harmony import */ var react_router_dom__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(18944);
75692
74636
  /* harmony import */ var react_router_dom__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react_router_dom__WEBPACK_IMPORTED_MODULE_1__);
74637
+ function _slicedToArray(arr, i) {
74638
+ return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
74639
+ }
74640
+ function _nonIterableRest() {
74641
+ throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
74642
+ }
74643
+ function _unsupportedIterableToArray(o, minLen) {
74644
+ if (!o) return;
74645
+ if (typeof o === "string") return _arrayLikeToArray(o, minLen);
74646
+ var n = Object.prototype.toString.call(o).slice(8, -1);
74647
+ if (n === "Object" && o.constructor) n = o.constructor.name;
74648
+ if (n === "Map" || n === "Set") return Array.from(o);
74649
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
74650
+ }
74651
+ function _arrayLikeToArray(arr, len) {
74652
+ if (len == null || len > arr.length) len = arr.length;
74653
+ for (var i = 0, arr2 = new Array(len); i < len; i++) {
74654
+ arr2[i] = arr[i];
74655
+ }
74656
+ return arr2;
74657
+ }
74658
+ function _iterableToArrayLimit(arr, i) {
74659
+ var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
74660
+ if (_i == null) return;
74661
+ var _arr = [];
74662
+ var _n = true;
74663
+ var _d = false;
74664
+ var _s, _e;
74665
+ try {
74666
+ for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
74667
+ _arr.push(_s.value);
74668
+ if (i && _arr.length === i) break;
74669
+ }
74670
+ } catch (err) {
74671
+ _d = true;
74672
+ _e = err;
74673
+ } finally {
74674
+ try {
74675
+ if (!_n && _i["return"] != null) _i["return"]();
74676
+ } finally {
74677
+ if (_d) throw _e;
74678
+ }
74679
+ }
74680
+ return _arr;
74681
+ }
74682
+ function _arrayWithHoles(arr) {
74683
+ if (Array.isArray(arr)) return arr;
74684
+ }
75693
74685
  // 兼容 react-router-dom v5&v6,拿到真正的 history
75694
74686
 
75695
74687
  // import path from 'path';
75696
74688
 
75697
- var path = __webpack_require__(56947);
74689
+ var path = __webpack_require__(18041);
75698
74690
  var useRealHistory = function useRealHistory() {
75699
74691
  var history;
75700
74692
  if (react_router_dom__WEBPACK_IMPORTED_MODULE_1__.useHistory) {
75701
74693
  history = (0,react_router_dom__WEBPACK_IMPORTED_MODULE_1__.useHistory)();
75702
74694
  }
74695
+ var _useState = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(history),
74696
+ _useState2 = _slicedToArray(_useState, 2),
74697
+ realHistory = _useState2[0],
74698
+ setRealHistory = _useState2[1];
75703
74699
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(function () {
75704
74700
  if (window.HistoryLibrary) {
75705
74701
  history = window.HistoryLibrary.createBrowserHistory();
@@ -75708,9 +74704,10 @@ var useRealHistory = function useRealHistory() {
75708
74704
  var _window$ICESTARK;
75709
74705
  oldPush(path.join(((_window$ICESTARK = window.ICESTARK) === null || _window$ICESTARK === void 0 ? void 0 : _window$ICESTARK.basename) || '/', p));
75710
74706
  };
74707
+ setRealHistory(history);
75711
74708
  }
75712
74709
  }, []);
75713
- return history;
74710
+ return realHistory;
75714
74711
  };
75715
74712
  /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (useRealHistory);
75716
74713
 
@@ -85085,6 +84082,54 @@ ProPageContainerTab.Item = _alicloudfe_components__WEBPACK_IMPORTED_MODULE_2__.T
85085
84082
  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
85086
84083
  /* harmony import */ var react_router_dom__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(18944);
85087
84084
  /* harmony import */ var react_router_dom__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react_router_dom__WEBPACK_IMPORTED_MODULE_1__);
84085
+ function _slicedToArray(arr, i) {
84086
+ return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
84087
+ }
84088
+ function _nonIterableRest() {
84089
+ throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
84090
+ }
84091
+ function _unsupportedIterableToArray(o, minLen) {
84092
+ if (!o) return;
84093
+ if (typeof o === "string") return _arrayLikeToArray(o, minLen);
84094
+ var n = Object.prototype.toString.call(o).slice(8, -1);
84095
+ if (n === "Object" && o.constructor) n = o.constructor.name;
84096
+ if (n === "Map" || n === "Set") return Array.from(o);
84097
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
84098
+ }
84099
+ function _arrayLikeToArray(arr, len) {
84100
+ if (len == null || len > arr.length) len = arr.length;
84101
+ for (var i = 0, arr2 = new Array(len); i < len; i++) {
84102
+ arr2[i] = arr[i];
84103
+ }
84104
+ return arr2;
84105
+ }
84106
+ function _iterableToArrayLimit(arr, i) {
84107
+ var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
84108
+ if (_i == null) return;
84109
+ var _arr = [];
84110
+ var _n = true;
84111
+ var _d = false;
84112
+ var _s, _e;
84113
+ try {
84114
+ for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
84115
+ _arr.push(_s.value);
84116
+ if (i && _arr.length === i) break;
84117
+ }
84118
+ } catch (err) {
84119
+ _d = true;
84120
+ _e = err;
84121
+ } finally {
84122
+ try {
84123
+ if (!_n && _i["return"] != null) _i["return"]();
84124
+ } finally {
84125
+ if (_d) throw _e;
84126
+ }
84127
+ }
84128
+ return _arr;
84129
+ }
84130
+ function _arrayWithHoles(arr) {
84131
+ if (Array.isArray(arr)) return arr;
84132
+ }
85088
84133
  // 兼容 react-router-dom v5&v6,拿到真正的 history
85089
84134
 
85090
84135
  // import path from 'path';
@@ -85095,6 +84140,10 @@ var useRealHistory = function useRealHistory() {
85095
84140
  if (react_router_dom__WEBPACK_IMPORTED_MODULE_1__.useHistory) {
85096
84141
  history = (0,react_router_dom__WEBPACK_IMPORTED_MODULE_1__.useHistory)();
85097
84142
  }
84143
+ var _useState = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(history),
84144
+ _useState2 = _slicedToArray(_useState, 2),
84145
+ realHistory = _useState2[0],
84146
+ setRealHistory = _useState2[1];
85098
84147
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(function () {
85099
84148
  if (window.HistoryLibrary) {
85100
84149
  history = window.HistoryLibrary.createBrowserHistory();
@@ -85103,9 +84152,10 @@ var useRealHistory = function useRealHistory() {
85103
84152
  var _window$ICESTARK;
85104
84153
  oldPush(path.join(((_window$ICESTARK = window.ICESTARK) === null || _window$ICESTARK === void 0 ? void 0 : _window$ICESTARK.basename) || '/', p));
85105
84154
  };
84155
+ setRealHistory(history);
85106
84156
  }
85107
84157
  }, []);
85108
- return history;
84158
+ return realHistory;
85109
84159
  };
85110
84160
  /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (useRealHistory);
85111
84161
 
@@ -93418,7 +92468,7 @@ if (!((_window = window) != null && _window.TEAMIXPRO_WITHOUT_ICON)) {
93418
92468
 
93419
92469
 
93420
92470
 
93421
- var version = '1.5.5';
92471
+ var version = '1.5.7-beta.0';
93422
92472
 
93423
92473
 
93424
92474
  /***/ }),
@@ -102589,6 +101639,9 @@ var useRealHistory = function useRealHistory() {
102589
101639
  if (react_router_dom__WEBPACK_IMPORTED_MODULE_1__.useHistory) {
102590
101640
  history = (0,react_router_dom__WEBPACK_IMPORTED_MODULE_1__.useHistory)();
102591
101641
  }
101642
+ var _useState = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(history),
101643
+ realHistory = _useState[0],
101644
+ setRealHistory = _useState[1];
102592
101645
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(function () {
102593
101646
  if (window.HistoryLibrary) {
102594
101647
  history = window.HistoryLibrary.createBrowserHistory();
@@ -102597,9 +101650,10 @@ var useRealHistory = function useRealHistory() {
102597
101650
  var _window$ICESTARK;
102598
101651
  oldPush(path.join(((_window$ICESTARK = window.ICESTARK) == null ? void 0 : _window$ICESTARK.basename) || '/', p));
102599
101652
  };
101653
+ setRealHistory(history);
102600
101654
  }
102601
101655
  }, []);
102602
- return history;
101656
+ return realHistory;
102603
101657
  };
102604
101658
  /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (useRealHistory);
102605
101659