byt-ui 0.1.27 → 0.1.29

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.
@@ -264317,7 +264317,7 @@ function entry_lib_error (msg, err) {
264317
264317
 
264318
264318
  var entry_lib_isArray = Array.isArray;
264319
264319
 
264320
- function entry_lib_vue_i18n_esm_isObject (obj) {
264320
+ function entry_lib_isObject (obj) {
264321
264321
  return obj !== null && typeof obj === 'object'
264322
264322
  }
264323
264323
 
@@ -264325,7 +264325,7 @@ function entry_lib_isBoolean (val) {
264325
264325
  return typeof val === 'boolean'
264326
264326
  }
264327
264327
 
264328
- function entry_lib_vue_i18n_esm_isString (val) {
264328
+ function entry_lib_isString (val) {
264329
264329
  return typeof val === 'string'
264330
264330
  }
264331
264331
 
@@ -264350,7 +264350,7 @@ function entry_lib_parseArgs () {
264350
264350
  var locale = null;
264351
264351
  var params = null;
264352
264352
  if (args.length === 1) {
264353
- if (entry_lib_vue_i18n_esm_isObject(args[0]) || entry_lib_isArray(args[0])) {
264353
+ if (entry_lib_isObject(args[0]) || entry_lib_isArray(args[0])) {
264354
264354
  params = args[0];
264355
264355
  } else if (typeof args[0] === 'string') {
264356
264356
  locale = args[0];
@@ -264360,7 +264360,7 @@ function entry_lib_parseArgs () {
264360
264360
  locale = args[0];
264361
264361
  }
264362
264362
  /* istanbul ignore if */
264363
- if (entry_lib_vue_i18n_esm_isObject(args[1]) || entry_lib_isArray(args[1])) {
264363
+ if (entry_lib_isObject(args[1]) || entry_lib_isArray(args[1])) {
264364
264364
  params = args[1];
264365
264365
  }
264366
264366
  }
@@ -264403,7 +264403,7 @@ function entry_lib_merge (target) {
264403
264403
  var key = (void 0);
264404
264404
  for (key in source) {
264405
264405
  if (entry_lib_hasOwn(source, key)) {
264406
- if (entry_lib_vue_i18n_esm_isObject(source[key])) {
264406
+ if (entry_lib_isObject(source[key])) {
264407
264407
  output[key] = entry_lib_merge(output[key], source[key]);
264408
264408
  } else {
264409
264409
  output[key] = source[key];
@@ -264417,8 +264417,8 @@ function entry_lib_merge (target) {
264417
264417
 
264418
264418
  function entry_lib_looseEqual (a, b) {
264419
264419
  if (a === b) { return true }
264420
- var isObjectA = entry_lib_vue_i18n_esm_isObject(a);
264421
- var isObjectB = entry_lib_vue_i18n_esm_isObject(b);
264420
+ var isObjectA = entry_lib_isObject(a);
264421
+ var isObjectB = entry_lib_isObject(b);
264422
264422
  if (isObjectA && isObjectB) {
264423
264423
  try {
264424
264424
  var isArrayA = entry_lib_isArray(a);
@@ -264817,9 +264817,9 @@ var entry_lib_numberComponent = {
264817
264817
  var key = null;
264818
264818
  var options = null;
264819
264819
 
264820
- if (entry_lib_vue_i18n_esm_isString(props.format)) {
264820
+ if (entry_lib_isString(props.format)) {
264821
264821
  key = props.format;
264822
- } else if (entry_lib_vue_i18n_esm_isObject(props.format)) {
264822
+ } else if (entry_lib_isObject(props.format)) {
264823
264823
  if (props.format.key) {
264824
264824
  key = props.format.key;
264825
264825
  }
@@ -264950,7 +264950,7 @@ function entry_lib_parseValue (value) {
264950
264950
  var args;
264951
264951
  var choice;
264952
264952
 
264953
- if (entry_lib_vue_i18n_esm_isString(value)) {
264953
+ if (entry_lib_isString(value)) {
264954
264954
  path = value;
264955
264955
  } else if (entry_lib_isPlainObject(value)) {
264956
264956
  path = value.path;
@@ -264973,7 +264973,7 @@ function entry_lib_makeParams (locale, args) {
264973
264973
  return params
264974
264974
  }
264975
264975
 
264976
- var entry_lib_vue_i18n_esm_Vue;
264976
+ var entry_lib_Vue;
264977
264977
 
264978
264978
  function entry_lib_install (_Vue, options) {
264979
264979
  if ( options === void 0 ) options = { bridge: false };
@@ -264982,20 +264982,20 @@ function entry_lib_install (_Vue, options) {
264982
264982
  if (false) {}
264983
264983
  entry_lib_install.installed = true;
264984
264984
 
264985
- entry_lib_vue_i18n_esm_Vue = _Vue;
264985
+ entry_lib_Vue = _Vue;
264986
264986
 
264987
- var version = (entry_lib_vue_i18n_esm_Vue.version && Number(entry_lib_vue_i18n_esm_Vue.version.split('.')[0])) || -1;
264987
+ var version = (entry_lib_Vue.version && Number(entry_lib_Vue.version.split('.')[0])) || -1;
264988
264988
  /* istanbul ignore if */
264989
264989
  if (false) {}
264990
264990
 
264991
- entry_lib_extend(entry_lib_vue_i18n_esm_Vue);
264992
- entry_lib_vue_i18n_esm_Vue.mixin(entry_lib_defineMixin(options.bridge));
264993
- entry_lib_vue_i18n_esm_Vue.directive('t', { bind: entry_lib_bind, update: entry_lib_update, unbind: entry_lib_unbind });
264994
- entry_lib_vue_i18n_esm_Vue.component(entry_lib_interpolationComponent.name, entry_lib_interpolationComponent);
264995
- entry_lib_vue_i18n_esm_Vue.component(entry_lib_numberComponent.name, entry_lib_numberComponent);
264991
+ entry_lib_extend(entry_lib_Vue);
264992
+ entry_lib_Vue.mixin(entry_lib_defineMixin(options.bridge));
264993
+ entry_lib_Vue.directive('t', { bind: entry_lib_bind, update: entry_lib_update, unbind: entry_lib_unbind });
264994
+ entry_lib_Vue.component(entry_lib_interpolationComponent.name, entry_lib_interpolationComponent);
264995
+ entry_lib_Vue.component(entry_lib_numberComponent.name, entry_lib_numberComponent);
264996
264996
 
264997
264997
  // use simple mergeStrategies to prevent i18n instance lose '__proto__'
264998
- var strats = entry_lib_vue_i18n_esm_Vue.config.optionMergeStrategies;
264998
+ var strats = entry_lib_Vue.config.optionMergeStrategies;
264999
264999
  strats.i18n = function (parentVal, childVal) {
265000
265000
  return childVal === undefined
265001
265001
  ? parentVal
@@ -265074,7 +265074,7 @@ function entry_lib_compile (tokens, values) {
265074
265074
 
265075
265075
  var mode = Array.isArray(values)
265076
265076
  ? 'list'
265077
- : entry_lib_vue_i18n_esm_isObject(values)
265077
+ : entry_lib_isObject(values)
265078
265078
  ? 'named'
265079
265079
  : 'unknown';
265080
265080
  if (mode === 'unknown') { return compiled }
@@ -265380,7 +265380,7 @@ entry_lib_I18nPath.prototype.parsePath = function parsePath (path) {
265380
265380
  * Get path value from path string
265381
265381
  */
265382
265382
  entry_lib_I18nPath.prototype.getPathValue = function getPathValue (obj, path) {
265383
- if (!entry_lib_vue_i18n_esm_isObject(obj)) { return null }
265383
+ if (!entry_lib_isObject(obj)) { return null }
265384
265384
 
265385
265385
  var paths = this.parsePath(path);
265386
265386
  if (paths.length === 0) {
@@ -265426,7 +265426,7 @@ var entry_lib_VueI18n = function VueI18n (options) {
265426
265426
  // To allow users to avoid auto-installation in some cases,
265427
265427
  // this code should be placed here. See #290
265428
265428
  /* istanbul ignore if */
265429
- if (!entry_lib_vue_i18n_esm_Vue && typeof window !== 'undefined' && window.Vue) {
265429
+ if (!entry_lib_Vue && typeof window !== 'undefined' && window.Vue) {
265430
265430
  entry_lib_install(window.Vue);
265431
265431
  }
265432
265432
 
@@ -265569,7 +265569,7 @@ entry_lib_VueI18n.prototype._checkLocaleMessage = function _checkLocaleMessage (
265569
265569
  paths.pop();
265570
265570
  }
265571
265571
  });
265572
- } else if (entry_lib_vue_i18n_esm_isString(message)) {
265572
+ } else if (entry_lib_isString(message)) {
265573
265573
  var ret = entry_lib_htmlTagMatcher.test(message);
265574
265574
  if (ret) {
265575
265575
  var msg = "Detected HTML in message '" + message + "' of keypath '" + (paths.join('')) + "' at '" + locale + "'. Consider component interpolation with '<i18n>' to avoid XSS. See https://bit.ly/2ZqJzkp";
@@ -265586,10 +265586,10 @@ entry_lib_VueI18n.prototype._checkLocaleMessage = function _checkLocaleMessage (
265586
265586
  };
265587
265587
 
265588
265588
  entry_lib_VueI18n.prototype._initVM = function _initVM (data) {
265589
- var silent = entry_lib_vue_i18n_esm_Vue.config.silent;
265590
- entry_lib_vue_i18n_esm_Vue.config.silent = true;
265591
- this._vm = new entry_lib_vue_i18n_esm_Vue({ data: data, __VUE18N__INSTANCE__: true });
265592
- entry_lib_vue_i18n_esm_Vue.config.silent = silent;
265589
+ var silent = entry_lib_Vue.config.silent;
265590
+ entry_lib_Vue.config.silent = true;
265591
+ this._vm = new entry_lib_Vue({ data: data, __VUE18N__INSTANCE__: true });
265592
+ entry_lib_Vue.config.silent = silent;
265593
265593
  };
265594
265594
 
265595
265595
  entry_lib_VueI18n.prototype.destroyVM = function destroyVM () {
@@ -265610,7 +265610,7 @@ entry_lib_VueI18n.prototype.watchI18nData = function watchI18nData () {
265610
265610
  var listeners = entry_lib_arrayFrom(this$1._dataListeners);
265611
265611
  var i = listeners.length;
265612
265612
  while(i--) {
265613
- entry_lib_vue_i18n_esm_Vue.nextTick(function () {
265613
+ entry_lib_Vue.nextTick(function () {
265614
265614
  listeners[i] && listeners[i].$forceUpdate();
265615
265615
  });
265616
265616
  }
@@ -265711,7 +265711,7 @@ entry_lib_VueI18n.prototype._warnDefault = function _warnDefault (locale, key, r
265711
265711
  if (!entry_lib_isNull(result)) { return result }
265712
265712
  if (this._missing) {
265713
265713
  var missingRet = this._missing.apply(null, [locale, key, vm, values]);
265714
- if (entry_lib_vue_i18n_esm_isString(missingRet)) {
265714
+ if (entry_lib_isString(missingRet)) {
265715
265715
  return missingRet
265716
265716
  }
265717
265717
  } else {
@@ -265765,7 +265765,7 @@ entry_lib_VueI18n.prototype._interpolate = function _interpolate (
265765
265765
  /* istanbul ignore else */
265766
265766
  if (entry_lib_isPlainObject(message)) {
265767
265767
  ret = message[key];
265768
- if (!(entry_lib_vue_i18n_esm_isString(ret) || entry_lib_isFunction(ret))) {
265768
+ if (!(entry_lib_isString(ret) || entry_lib_isFunction(ret))) {
265769
265769
  if (false) {}
265770
265770
  return null
265771
265771
  }
@@ -265774,7 +265774,7 @@ entry_lib_VueI18n.prototype._interpolate = function _interpolate (
265774
265774
  }
265775
265775
  } else {
265776
265776
  /* istanbul ignore else */
265777
- if (entry_lib_vue_i18n_esm_isString(pathRet) || entry_lib_isFunction(pathRet)) {
265777
+ if (entry_lib_isString(pathRet) || entry_lib_isFunction(pathRet)) {
265778
265778
  ret = pathRet;
265779
265779
  } else {
265780
265780
  if (false) {}
@@ -265783,7 +265783,7 @@ entry_lib_VueI18n.prototype._interpolate = function _interpolate (
265783
265783
  }
265784
265784
 
265785
265785
  // Check for the existence of links within the translated string
265786
- if (entry_lib_vue_i18n_esm_isString(ret) && (ret.indexOf('@:') >= 0 || ret.indexOf('@.') >= 0)) {
265786
+ if (entry_lib_isString(ret) && (ret.indexOf('@:') >= 0 || ret.indexOf('@.') >= 0)) {
265787
265787
  ret = this._link(locale, message, ret, host, 'raw', values, visitedLinkStack);
265788
265788
  }
265789
265789
 
@@ -265870,7 +265870,7 @@ entry_lib_VueI18n.prototype._createMessageContext = function _createMessageConte
265870
265870
  var this$1 = this;
265871
265871
 
265872
265872
  var _list = entry_lib_isArray(values) ? values : [];
265873
- var _named = entry_lib_vue_i18n_esm_isObject(values) ? values : {};
265873
+ var _named = entry_lib_isObject(values) ? values : {};
265874
265874
  var list = function (index) { return _list[index]; };
265875
265875
  var named = function (key) { return _named[key]; };
265876
265876
  var messages = this._getMessages();
@@ -265904,7 +265904,7 @@ entry_lib_VueI18n.prototype._render = function _render (message, interpolateMode
265904
265904
 
265905
265905
  // if interpolateMode is **not** 'string' ('row'),
265906
265906
  // return the compiled data (e.g. ['foo', VNode, 'bar']) with formatter
265907
- return interpolateMode === 'string' && !entry_lib_vue_i18n_esm_isString(ret) ? ret.join('') : ret
265907
+ return interpolateMode === 'string' && !entry_lib_isString(ret) ? ret.join('') : ret
265908
265908
  };
265909
265909
 
265910
265910
  entry_lib_VueI18n.prototype._appendItemToChain = function _appendItemToChain (chain, item, blocks) {
@@ -265938,7 +265938,7 @@ entry_lib_VueI18n.prototype._appendBlockToChain = function _appendBlockToChain (
265938
265938
  var follow = true;
265939
265939
  for (var i = 0; (i < block.length) && (entry_lib_isBoolean(follow)); i++) {
265940
265940
  var locale = block[i];
265941
- if (entry_lib_vue_i18n_esm_isString(locale)) {
265941
+ if (entry_lib_isString(locale)) {
265942
265942
  follow = this._appendLocaleToChain(chain, locale, blocks);
265943
265943
  }
265944
265944
  }
@@ -265975,7 +265975,7 @@ entry_lib_VueI18n.prototype._getLocaleChain = function _getLocaleChain (start, f
265975
265975
  var defaults;
265976
265976
  if (entry_lib_isArray(fallbackLocale)) {
265977
265977
  defaults = fallbackLocale;
265978
- } else if (entry_lib_vue_i18n_esm_isObject(fallbackLocale)) {
265978
+ } else if (entry_lib_isObject(fallbackLocale)) {
265979
265979
  /* $FlowFixMe */
265980
265980
  if (fallbackLocale['default']) {
265981
265981
  defaults = fallbackLocale['default'];
@@ -265987,7 +265987,7 @@ entry_lib_VueI18n.prototype._getLocaleChain = function _getLocaleChain (start, f
265987
265987
  }
265988
265988
 
265989
265989
  // convert defaults to array
265990
- if (entry_lib_vue_i18n_esm_isString(defaults)) {
265990
+ if (entry_lib_isString(defaults)) {
265991
265991
  block = [defaults];
265992
265992
  } else {
265993
265993
  block = defaults;
@@ -266083,7 +266083,7 @@ entry_lib_VueI18n.prototype.i = function i (key, locale, values) {
266083
266083
  /* istanbul ignore if */
266084
266084
  if (!key) { return '' }
266085
266085
 
266086
- if (!entry_lib_vue_i18n_esm_isString(locale)) {
266086
+ if (!entry_lib_isString(locale)) {
266087
266087
  locale = this.locale;
266088
266088
  }
266089
266089
 
@@ -266115,7 +266115,7 @@ entry_lib_VueI18n.prototype._tc = function _tc (
266115
266115
 
266116
266116
  entry_lib_VueI18n.prototype.fetchChoice = function fetchChoice (message, choice) {
266117
266117
  /* istanbul ignore if */
266118
- if (!message || !entry_lib_vue_i18n_esm_isString(message)) { return null }
266118
+ if (!message || !entry_lib_isString(message)) { return null }
266119
266119
  var choices = message.split('|');
266120
266120
 
266121
266121
  choice = this.getChoiceIndex(choice, choices.length);
@@ -266268,9 +266268,9 @@ entry_lib_VueI18n.prototype.d = function d (value) {
266268
266268
  var options = null;
266269
266269
 
266270
266270
  if (args.length === 1) {
266271
- if (entry_lib_vue_i18n_esm_isString(args[0])) {
266271
+ if (entry_lib_isString(args[0])) {
266272
266272
  key = args[0];
266273
- } else if (entry_lib_vue_i18n_esm_isObject(args[0])) {
266273
+ } else if (entry_lib_isObject(args[0])) {
266274
266274
  if (args[0].locale) {
266275
266275
  locale = args[0].locale;
266276
266276
  }
@@ -266289,10 +266289,10 @@ entry_lib_VueI18n.prototype.d = function d (value) {
266289
266289
  }, null);
266290
266290
 
266291
266291
  } else if (args.length === 2) {
266292
- if (entry_lib_vue_i18n_esm_isString(args[0])) {
266292
+ if (entry_lib_isString(args[0])) {
266293
266293
  key = args[0];
266294
266294
  }
266295
- if (entry_lib_vue_i18n_esm_isString(args[1])) {
266295
+ if (entry_lib_isString(args[1])) {
266296
266296
  locale = args[1];
266297
266297
  }
266298
266298
  }
@@ -266405,9 +266405,9 @@ entry_lib_VueI18n.prototype.n = function n (value) {
266405
266405
  var options = null;
266406
266406
 
266407
266407
  if (args.length === 1) {
266408
- if (entry_lib_vue_i18n_esm_isString(args[0])) {
266408
+ if (entry_lib_isString(args[0])) {
266409
266409
  key = args[0];
266410
- } else if (entry_lib_vue_i18n_esm_isObject(args[0])) {
266410
+ } else if (entry_lib_isObject(args[0])) {
266411
266411
  if (args[0].locale) {
266412
266412
  locale = args[0].locale;
266413
266413
  }
@@ -266426,10 +266426,10 @@ entry_lib_VueI18n.prototype.n = function n (value) {
266426
266426
  }, null);
266427
266427
  }
266428
266428
  } else if (args.length === 2) {
266429
- if (entry_lib_vue_i18n_esm_isString(args[0])) {
266429
+ if (entry_lib_isString(args[0])) {
266430
266430
  key = args[0];
266431
266431
  }
266432
- if (entry_lib_vue_i18n_esm_isString(args[1])) {
266432
+ if (entry_lib_isString(args[1])) {
266433
266433
  locale = args[1];
266434
266434
  }
266435
266435
  }
@@ -266535,308 +266535,19 @@ var entry_lib_en_US = __webpack_require__(14373);
266535
266535
  }
266536
266536
  }
266537
266537
  });
266538
- ;// ./node_modules/element-ui/src/utils/types.js
266539
-
266540
-
266541
- function entry_lib_types_isString(obj) {
266542
- return Object.prototype.toString.call(obj) === '[object String]';
266543
- }
266544
-
266545
- function entry_lib_types_isObject(obj) {
266546
- return Object.prototype.toString.call(obj) === '[object Object]';
266547
- }
266548
-
266549
- function entry_lib_isHtmlElement(node) {
266550
- return node && node.nodeType === Node.ELEMENT_NODE;
266551
- }
266552
-
266553
- /**
266554
- * - Inspired:
266555
- * https://github.com/jashkenas/underscore/blob/master/modules/isFunction.js
266556
- */
266557
- let entry_lib_types_isFunction = (functionToCheck) => {
266558
- var getType = {};
266559
- return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
266560
- };
266561
-
266562
- if ( true && typeof Int8Array !== 'object' && ((entry_lib_external_commonjs_vue_commonjs2_vue_root_Vue_default()).prototype.$isServer || typeof document.childNodes !== 'function')) {
266563
- entry_lib_types_isFunction = function(obj) {
266564
- return typeof obj === 'function' || false;
266565
- };
266566
- }
266567
-
266568
-
266569
-
266570
- const entry_lib_isUndefined = (val)=> {
266571
- return val === void 0;
266572
- };
266573
-
266574
- const entry_lib_isDefined = (val) => {
266575
- return val !== undefined && val !== null;
266576
- };
266577
-
266578
- ;// ./node_modules/element-ui/src/utils/util.js
266579
-
266580
-
266581
-
266582
- const entry_lib_util_hasOwnProperty = Object.prototype.hasOwnProperty;
266583
-
266584
- function entry_lib_noop() {};
266585
-
266586
- function entry_lib_util_hasOwn(obj, key) {
266587
- return entry_lib_util_hasOwnProperty.call(obj, key);
266588
- };
266589
-
266590
- function entry_lib_util_extend(to, _from) {
266591
- for (let key in _from) {
266592
- to[key] = _from[key];
266593
- }
266594
- return to;
266595
- };
266596
-
266597
- function entry_lib_toObject(arr) {
266598
- var res = {};
266599
- for (let i = 0; i < arr.length; i++) {
266600
- if (arr[i]) {
266601
- entry_lib_util_extend(res, arr[i]);
266602
- }
266603
- }
266604
- return res;
266605
- };
266606
-
266607
- const entry_lib_getValueByPath = function(object, prop) {
266608
- prop = prop || '';
266609
- const paths = prop.split('.');
266610
- let current = object;
266611
- let result = null;
266612
- for (let i = 0, j = paths.length; i < j; i++) {
266613
- const path = paths[i];
266614
- if (!current) break;
266615
-
266616
- if (i === j - 1) {
266617
- result = current[path];
266618
- break;
266619
- }
266620
- current = current[path];
266621
- }
266622
- return result;
266623
- };
266624
-
266625
- function entry_lib_getPropByPath(obj, path, strict) {
266626
- let tempObj = obj;
266627
- path = path.replace(/\[(\w+)\]/g, '.$1');
266628
- path = path.replace(/^\./, '');
266629
-
266630
- let keyArr = path.split('.');
266631
- let i = 0;
266632
- for (let len = keyArr.length; i < len - 1; ++i) {
266633
- if (!tempObj && !strict) break;
266634
- let key = keyArr[i];
266635
- if (key in tempObj) {
266636
- tempObj = tempObj[key];
266637
- } else {
266638
- if (strict) {
266639
- throw new Error('please transfer a valid prop path to form item!');
266640
- }
266641
- break;
266642
- }
266643
- }
266644
- return {
266645
- o: tempObj,
266646
- k: keyArr[i],
266647
- v: tempObj ? tempObj[keyArr[i]] : null
266648
- };
266649
- };
266650
-
266651
- const entry_lib_generateId = function() {
266652
- return Math.floor(Math.random() * 10000);
266653
- };
266654
-
266655
- const entry_lib_valueEquals = (a, b) => {
266656
- // see: https://stackoverflow.com/questions/3115982/how-to-check-if-two-arrays-are-equal-with-javascript
266657
- if (a === b) return true;
266658
- if (!(a instanceof Array)) return false;
266659
- if (!(b instanceof Array)) return false;
266660
- if (a.length !== b.length) return false;
266661
- for (let i = 0; i !== a.length; ++i) {
266662
- if (a[i] !== b[i]) return false;
266663
- }
266664
- return true;
266665
- };
266666
-
266667
- const entry_lib_escapeRegexpString = (value = '') => String(value).replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');
266668
-
266669
- // TODO: use native Array.find, Array.findIndex when IE support is dropped
266670
- const entry_lib_arrayFindIndex = function(arr, pred) {
266671
- for (let i = 0; i !== arr.length; ++i) {
266672
- if (pred(arr[i])) {
266673
- return i;
266674
- }
266675
- }
266676
- return -1;
266677
- };
266678
-
266679
- const entry_lib_arrayFind = function(arr, pred) {
266680
- const idx = entry_lib_arrayFindIndex(arr, pred);
266681
- return idx !== -1 ? arr[idx] : undefined;
266682
- };
266683
-
266684
- // coerce truthy value to array
266685
- const entry_lib_coerceTruthyValueToArray = function(val) {
266686
- if (Array.isArray(val)) {
266687
- return val;
266688
- } else if (val) {
266689
- return [val];
266690
- } else {
266691
- return [];
266692
- }
266693
- };
266694
-
266695
- const entry_lib_isIE = function() {
266696
- return !Vue.prototype.$isServer && !isNaN(Number(document.documentMode));
266697
- };
266698
-
266699
- const entry_lib_isEdge = function() {
266700
- return !Vue.prototype.$isServer && navigator.userAgent.indexOf('Edge') > -1;
266701
- };
266702
-
266703
- const entry_lib_isFirefox = function() {
266704
- return !Vue.prototype.$isServer && !!window.navigator.userAgent.match(/firefox/i);
266705
- };
266706
-
266707
- const entry_lib_autoprefixer = function(style) {
266708
- if (typeof style !== 'object') return style;
266709
- const rules = ['transform', 'transition', 'animation'];
266710
- const prefixes = ['ms-', 'webkit-'];
266711
- rules.forEach(rule => {
266712
- const value = style[rule];
266713
- if (rule && value) {
266714
- prefixes.forEach(prefix => {
266715
- style[prefix + rule] = value;
266716
- });
266717
- }
266718
- });
266719
- return style;
266720
- };
266721
-
266722
- const entry_lib_kebabCase = function(str) {
266723
- const hyphenateRE = /([^-])([A-Z])/g;
266724
- return str
266725
- .replace(hyphenateRE, '$1-$2')
266726
- .replace(hyphenateRE, '$1-$2')
266727
- .toLowerCase();
266728
- };
266729
-
266730
- const entry_lib_capitalize = function(str) {
266731
- if (!isString(str)) return str;
266732
- return str.charAt(0).toUpperCase() + str.slice(1);
266733
- };
266734
-
266735
- const entry_lib_util_looseEqual = function(a, b) {
266736
- const isObjectA = isObject(a);
266737
- const isObjectB = isObject(b);
266738
- if (isObjectA && isObjectB) {
266739
- return JSON.stringify(a) === JSON.stringify(b);
266740
- } else if (!isObjectA && !isObjectB) {
266741
- return String(a) === String(b);
266742
- } else {
266743
- return false;
266744
- }
266745
- };
266746
-
266747
- const entry_lib_arrayEquals = function(arrayA, arrayB) {
266748
- arrayA = arrayA || [];
266749
- arrayB = arrayB || [];
266750
-
266751
- if (arrayA.length !== arrayB.length) {
266752
- return false;
266753
- }
266754
-
266755
- for (let i = 0; i < arrayA.length; i++) {
266756
- if (!entry_lib_util_looseEqual(arrayA[i], arrayB[i])) {
266757
- return false;
266758
- }
266759
- }
266760
-
266761
- return true;
266762
- };
266763
-
266764
- const entry_lib_isEqual = function(value1, value2) {
266765
- if (Array.isArray(value1) && Array.isArray(value2)) {
266766
- return entry_lib_arrayEquals(value1, value2);
266767
- }
266768
- return entry_lib_util_looseEqual(value1, value2);
266769
- };
266770
-
266771
- const entry_lib_isEmpty = function(val) {
266772
- // null or undefined
266773
- if (val == null) return true;
266774
-
266775
- if (typeof val === 'boolean') return false;
266776
-
266777
- if (typeof val === 'number') return !val;
266778
-
266779
- if (val instanceof Error) return val.message === '';
266780
-
266781
- switch (Object.prototype.toString.call(val)) {
266782
- // String or Array
266783
- case '[object String]':
266784
- case '[object Array]':
266785
- return !val.length;
266786
-
266787
- // Map or Set or File
266788
- case '[object File]':
266789
- case '[object Map]':
266790
- case '[object Set]': {
266791
- return !val.size;
266792
- }
266793
- // Plain Object
266794
- case '[object Object]': {
266795
- return !Object.keys(val).length;
266796
- }
266797
- }
266798
-
266799
- return false;
266800
- };
266801
-
266802
- function entry_lib_rafThrottle(fn) {
266803
- let locked = false;
266804
- return function(...args) {
266805
- if (locked) return;
266806
- locked = true;
266807
- window.requestAnimationFrame(_ => {
266808
- fn.apply(this, args);
266809
- locked = false;
266810
- });
266811
- };
266812
- }
266813
-
266814
- function entry_lib_objToArray(obj) {
266815
- if (Array.isArray(obj)) {
266816
- return obj;
266817
- }
266818
- return entry_lib_isEmpty(obj) ? [] : [obj];
266819
- }
266820
-
266821
- const entry_lib_isMac = function() {
266822
- return !Vue.prototype.$isServer && /macintosh|mac os x/i.test(navigator.userAgent);
266823
- };
266824
-
266825
266538
  ;// ./packages/locale/format.js
266826
-
266539
+ const entry_lib_format_hasOwnProperty = Object.prototype.hasOwnProperty;
266540
+ const entry_lib_format_hasOwn = function (obj, key) {
266541
+ return entry_lib_format_hasOwnProperty.call(obj, key);
266542
+ };
266827
266543
  const entry_lib_RE_NARGS = /(%|)\{([0-9a-zA-Z_]+)\}/g;
266828
- /**
266829
- * String format template
266830
- * - Inspired:
266831
- * https://github.com/Matt-Esch/string-template/index.js
266832
- */
266833
266544
  /* harmony default export */ function entry_lib_format(Vue) {
266834
- /**
266835
- * template
266836
- *
266837
- * @param {String} string
266838
- * @param {Array} ...args
266839
- * @return {String}
266545
+ /**
266546
+ * template
266547
+ *
266548
+ * @param {String} string
266549
+ * @param {Array} ...args
266550
+ * @return {String}
266840
266551
  */
266841
266552
 
266842
266553
  function template(string, ...args) {
@@ -266851,7 +266562,7 @@ const entry_lib_RE_NARGS = /(%|)\{([0-9a-zA-Z_]+)\}/g;
266851
266562
  if (string[index - 1] === '{' && string[index + match.length] === '}') {
266852
266563
  return i;
266853
266564
  } else {
266854
- result = entry_lib_util_hasOwn(args, i) ? args[i] : null;
266565
+ result = entry_lib_format_hasOwn(args, i) ? args[i] : null;
266855
266566
  if (result === null || result === undefined) {
266856
266567
  return '';
266857
266568
  }
@@ -266866,7 +266577,7 @@ const entry_lib_RE_NARGS = /(%|)\{([0-9a-zA-Z_]+)\}/g;
266866
266577
  * @Description:
266867
266578
  * @Author: 王国火
266868
266579
  * @Date: 2025-02-09 11:18:10
266869
- * @LastEditTime: 2025-03-12 13:11:45
266580
+ * @LastEditTime: 2025-03-26 12:36:05
266870
266581
  * @LastEditors: 王国火
266871
266582
  */
266872
266583
 
@@ -266878,8 +266589,6 @@ const entry_lib_RE_NARGS = /(%|)\{([0-9a-zA-Z_]+)\}/g;
266878
266589
 
266879
266590
 
266880
266591
 
266881
- // Vue.use(VueI18n);
266882
-
266883
266592
  const entry_lib_defaultLang = 'zh-CN';
266884
266593
  const entry_lib_messages = {
266885
266594
  [entry_lib_defaultLang]: {
@@ -266896,6 +266605,7 @@ const entry_lib_messages = {
266896
266605
  const entry_lib_locale_format = entry_lib_format((entry_lib_external_commonjs_vue_commonjs2_vue_root_Vue_default()));
266897
266606
  let entry_lib_lang = entry_lib_messages[entry_lib_defaultLang];
266898
266607
  let entry_lib_i18nHandler = function (key, value) {
266608
+ entry_lib_external_commonjs_vue_commonjs2_vue_root_Vue_default().use(entry_lib_vue_i18n_esm);
266899
266609
  const i18n = new entry_lib_vue_i18n_esm({
266900
266610
  locale: entry_lib_defaultLang,
266901
266611
  // 设置默认语种
@@ -266924,9 +266634,9 @@ const entry_lib_locale_t = function (path, options) {
266924
266634
  const entry_lib_use = function (l) {
266925
266635
  entry_lib_lang = l || entry_lib_lang;
266926
266636
  };
266927
- const entry_lib_i18n = function (fn) {
266637
+ const entry_lib_i18n = function (Vue, fn) {
266928
266638
  entry_lib_i18nHandler = fn || entry_lib_i18nHandler;
266929
- (entry_lib_external_commonjs_vue_commonjs2_vue_root_Vue_default()).prototype.$t = entry_lib_locale_t;
266639
+ if (!fn) Vue.prototype.$t = entry_lib_locale_t;
266930
266640
  };
266931
266641
  /* harmony default export */ var entry_lib_locale = ({
266932
266642
  use: entry_lib_use,
@@ -267051,7 +266761,7 @@ entry_lib_packages_components.map(component => {
267051
266761
  // install组件api
267052
266762
  const entry_lib_packages_install = function (Vue, opts = {}) {
267053
266763
  entry_lib_locale.use(opts.locale);
267054
- entry_lib_locale.i18n(opts.i18n);
266764
+ entry_lib_locale.i18n(Vue, opts.i18n);
267055
266765
  entry_lib_useElementUI(Vue, opts);
267056
266766
  entry_lib_useVxeTable(Vue, opts);
267057
266767
  entry_lib_packages_components.map(component => {