cnhis-design-vue 2.1.52 → 2.1.54

package/cnhis-design-vue/node_modules/core-js/modules/esnext.array.group-by.js

@@ -0,0 +1,17 @@
+'use strict';
+var $ = require('../internals/export');
+var $groupBy = require('../internals/array-group-by');
+var arrayMethodIsStrict = require('../internals/array-method-is-strict');
+var addToUnscopables = require('../internals/add-to-unscopables');
+
+// `Array.prototype.groupBy` method
+// https://github.com/tc39/proposal-array-grouping
+// https://bugs.webkit.org/show_bug.cgi?id=236541
+$({ target: 'Array', proto: true, forced: !arrayMethodIsStrict('groupBy') }, {
+  groupBy: function groupBy(callbackfn /* , thisArg */) {
+    var thisArg = arguments.length > 1 ? arguments[1] : undefined;
+    return $groupBy(this, callbackfn, thisArg);
+  }
+});
+
+addToUnscopables('groupBy');

package/cnhis-design-vue/node_modules/core-js/modules/esnext.array.is-template-object.js

@@ -0,0 +1,29 @@
+var $ = require('../internals/export');
+var isArray = require('../internals/is-array');
+
+// eslint-disable-next-line es/no-object-isfrozen -- safe
+var isFrozen = Object.isFrozen;
+
+var isFrozenStringArray = function (array, allowUndefined) {
+  if (!isFrozen || !isArray(array) || !isFrozen(array)) return false;
+  var index = 0;
+  var length = array.length;
+  var element;
+  while (index < length) {
+    element = array[index++];
+    if (!(typeof element == 'string' || (allowUndefined && typeof element == 'undefined'))) {
+      return false;
+    }
+  } return length !== 0;
+};
+
+// `Array.isTemplateObject` method
+// https://github.com/tc39/proposal-array-is-template-object
+$({ target: 'Array', stat: true, sham: true, forced: true }, {
+  isTemplateObject: function isTemplateObject(value) {
+    if (!isFrozenStringArray(value, true)) return false;
+    var raw = value.raw;
+    if (raw.length !== value.length || !isFrozenStringArray(raw, false)) return false;
+    return true;
+  }
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.array.last-index.js

@@ -0,0 +1,21 @@
+'use strict';
+var DESCRIPTORS = require('../internals/descriptors');
+var addToUnscopables = require('../internals/add-to-unscopables');
+var toObject = require('../internals/to-object');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
+var defineProperty = require('../internals/object-define-property').f;
+
+// `Array.prototype.lastIndex` getter
+// https://github.com/keithamus/proposal-array-last
+if (DESCRIPTORS) {
+  defineProperty(Array.prototype, 'lastIndex', {
+    configurable: true,
+    get: function lastIndex() {
+      var O = toObject(this);
+      var len = lengthOfArrayLike(O);
+      return len == 0 ? 0 : len - 1;
+    }
+  });
+
+  addToUnscopables('lastIndex');
+}

package/cnhis-design-vue/node_modules/core-js/modules/esnext.array.last-item.js

@@ -0,0 +1,26 @@
+'use strict';
+var DESCRIPTORS = require('../internals/descriptors');
+var addToUnscopables = require('../internals/add-to-unscopables');
+var toObject = require('../internals/to-object');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
+var defineProperty = require('../internals/object-define-property').f;
+
+// `Array.prototype.lastIndex` accessor
+// https://github.com/keithamus/proposal-array-last
+if (DESCRIPTORS) {
+  defineProperty(Array.prototype, 'lastItem', {
+    configurable: true,
+    get: function lastItem() {
+      var O = toObject(this);
+      var len = lengthOfArrayLike(O);
+      return len == 0 ? undefined : O[len - 1];
+    },
+    set: function lastItem(value) {
+      var O = toObject(this);
+      var len = lengthOfArrayLike(O);
+      return O[len == 0 ? 0 : len - 1] = value;
+    }
+  });
+
+  addToUnscopables('lastItem');
+}

package/cnhis-design-vue/node_modules/core-js/modules/esnext.array.to-reversed.js

@@ -0,0 +1,18 @@
+'use strict';
+var $ = require('../internals/export');
+var global = require('../internals/global');
+var arrayToReversed = require('../internals/array-to-reversed');
+var toIndexedObject = require('../internals/to-indexed-object');
+var addToUnscopables = require('../internals/add-to-unscopables');
+
+var Array = global.Array;
+
+// `Array.prototype.toReversed` method
+// https://tc39.es/proposal-change-array-by-copy/#sec-array.prototype.toReversed
+$({ target: 'Array', proto: true, forced: true }, {
+  toReversed: function toReversed() {
+    return arrayToReversed(toIndexedObject(this), Array);
+  }
+});
+
+addToUnscopables('toReversed');

package/cnhis-design-vue/node_modules/core-js/modules/esnext.array.to-sorted.js

@@ -0,0 +1,25 @@
+'use strict';
+var $ = require('../internals/export');
+var global = require('../internals/global');
+var uncurryThis = require('../internals/function-uncurry-this');
+var aCallable = require('../internals/a-callable');
+var toIndexedObject = require('../internals/to-indexed-object');
+var arrayFromConstructorAndList = require('../internals/array-from-constructor-and-list');
+var getVirtual = require('../internals/entry-virtual');
+var addToUnscopables = require('../internals/add-to-unscopables');
+
+var Array = global.Array;
+var sort = uncurryThis(getVirtual('Array').sort);
+
+// `Array.prototype.toSorted` method
+// https://tc39.es/proposal-change-array-by-copy/#sec-array.prototype.toSorted
+$({ target: 'Array', proto: true, forced: true }, {
+  toSorted: function toSorted(compareFn) {
+    if (compareFn !== undefined) aCallable(compareFn);
+    var O = toIndexedObject(this);
+    var A = arrayFromConstructorAndList(Array, O);
+    return sort(A, compareFn);
+  }
+});
+
+addToUnscopables('toSorted');

package/cnhis-design-vue/node_modules/core-js/modules/esnext.array.to-spliced.js

@@ -0,0 +1,20 @@
+'use strict';
+var $ = require('../internals/export');
+var global = require('../internals/global');
+var toIndexedObject = require('../internals/to-indexed-object');
+var arraySlice = require('../internals/array-slice');
+var arrayToSpliced = require('../internals/array-to-spliced');
+var addToUnscopables = require('../internals/add-to-unscopables');
+
+var Array = global.Array;
+
+// `Array.prototype.toSpliced` method
+// https://tc39.es/proposal-change-array-by-copy/#sec-array.prototype.toSpliced
+$({ target: 'Array', proto: true, forced: true }, {
+  // eslint-disable-next-line no-unused-vars -- required for .length
+  toSpliced: function toSpliced(start, deleteCount /* , ...items */) {
+    return arrayToSpliced(toIndexedObject(this), Array, arraySlice(arguments));
+  }
+});
+
+addToUnscopables('toSpliced');

package/cnhis-design-vue/node_modules/core-js/modules/esnext.array.unique-by.js

@@ -0,0 +1,12 @@
+'use strict';
+var $ = require('../internals/export');
+var addToUnscopables = require('../internals/add-to-unscopables');
+var uniqueBy = require('../internals/array-unique-by');
+
+// `Array.prototype.uniqueBy` method
+// https://github.com/tc39/proposal-array-unique
+$({ target: 'Array', proto: true, forced: true }, {
+  uniqueBy: uniqueBy
+});
+
+addToUnscopables('uniqueBy');

package/cnhis-design-vue/node_modules/core-js/modules/esnext.array.with.js

@@ -0,0 +1,15 @@
+'use strict';
+var $ = require('../internals/export');
+var global = require('../internals/global');
+var arrayWith = require('../internals/array-with');
+var toIndexedObject = require('../internals/to-indexed-object');
+
+var Array = global.Array;
+
+// `Array.prototype.with` method
+// https://tc39.es/proposal-change-array-by-copy/#sec-array.prototype.with
+$({ target: 'Array', proto: true, forced: true }, {
+  'with': function (index, value) {
+    return arrayWith(toIndexedObject(this), Array, index, value);
+  }
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.async-iterator.as-indexed-pairs.js

@@ -0,0 +1,28 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var apply = require('../internals/function-apply');
+var anObject = require('../internals/an-object');
+var createAsyncIteratorProxy = require('../internals/async-iterator-create-proxy');
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (Promise, args) {
+  var state = this;
+  var iterator = state.iterator;
+
+  return Promise.resolve(anObject(apply(state.next, iterator, args))).then(function (step) {
+    if (anObject(step).done) {
+      state.done = true;
+      return { done: true, value: undefined };
+    }
+    return { done: false, value: [state.index++, step.value] };
+  });
+});
+
+$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, {
+  asIndexedPairs: function asIndexedPairs() {
+    return new AsyncIteratorProxy({
+      iterator: anObject(this),
+      index: 0
+    });
+  }
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.async-iterator.constructor.js

@@ -0,0 +1,29 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var anInstance = require('../internals/an-instance');
+var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
+var hasOwn = require('../internals/has-own-property');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var AsyncIteratorPrototype = require('../internals/async-iterator-prototype');
+var IS_PURE = require('../internals/is-pure');
+
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+
+var AsyncIteratorConstructor = function AsyncIterator() {
+  anInstance(this, AsyncIteratorPrototype);
+};
+
+AsyncIteratorConstructor.prototype = AsyncIteratorPrototype;
+
+if (!hasOwn(AsyncIteratorPrototype, TO_STRING_TAG)) {
+  createNonEnumerableProperty(AsyncIteratorPrototype, TO_STRING_TAG, 'AsyncIterator');
+}
+
+if (IS_PURE || !hasOwn(AsyncIteratorPrototype, 'constructor') || AsyncIteratorPrototype.constructor === Object) {
+  createNonEnumerableProperty(AsyncIteratorPrototype, 'constructor', AsyncIteratorConstructor);
+}
+
+$({ global: true, forced: IS_PURE }, {
+  AsyncIterator: AsyncIteratorConstructor
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.async-iterator.drop.js

@@ -0,0 +1,42 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var apply = require('../internals/function-apply');
+var anObject = require('../internals/an-object');
+var toPositiveInteger = require('../internals/to-positive-integer');
+var createAsyncIteratorProxy = require('../internals/async-iterator-create-proxy');
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (Promise, args) {
+  var state = this;
+
+  return new Promise(function (resolve, reject) {
+    var loop = function () {
+      try {
+        Promise.resolve(
+          anObject(apply(state.next, state.iterator, state.remaining ? [] : args))
+        ).then(function (step) {
+          try {
+            if (anObject(step).done) {
+              state.done = true;
+              resolve({ done: true, value: undefined });
+            } else if (state.remaining) {
+              state.remaining--;
+              loop();
+            } else resolve({ done: false, value: step.value });
+          } catch (err) { reject(err); }
+        }, reject);
+      } catch (error) { reject(error); }
+    };
+
+    loop();
+  });
+});
+
+$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, {
+  drop: function drop(limit) {
+    return new AsyncIteratorProxy({
+      iterator: anObject(this),
+      remaining: toPositiveInteger(limit)
+    });
+  }
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.async-iterator.every.js

@@ -0,0 +1,10 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var $every = require('../internals/async-iterator-iteration').every;
+
+$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, {
+  every: function every(fn) {
+    return $every(this, fn);
+  }
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.async-iterator.filter.js

@@ -0,0 +1,43 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var apply = require('../internals/function-apply');
+var aCallable = require('../internals/a-callable');
+var anObject = require('../internals/an-object');
+var createAsyncIteratorProxy = require('../internals/async-iterator-create-proxy');
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (Promise, args) {
+  var state = this;
+  var filterer = state.filterer;
+
+  return new Promise(function (resolve, reject) {
+    var loop = function () {
+      try {
+        Promise.resolve(anObject(apply(state.next, state.iterator, args))).then(function (step) {
+          try {
+            if (anObject(step).done) {
+              state.done = true;
+              resolve({ done: true, value: undefined });
+            } else {
+              var value = step.value;
+              Promise.resolve(filterer(value)).then(function (selected) {
+                selected ? resolve({ done: false, value: value }) : loop();
+              }, reject);
+            }
+          } catch (err) { reject(err); }
+        }, reject);
+      } catch (error) { reject(error); }
+    };
+
+    loop();
+  });
+});
+
+$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, {
+  filter: function filter(filterer) {
+    return new AsyncIteratorProxy({
+      iterator: anObject(this),
+      filterer: aCallable(filterer)
+    });
+  }
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.async-iterator.find.js

@@ -0,0 +1,10 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var $find = require('../internals/async-iterator-iteration').find;
+
+$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, {
+  find: function find(fn) {
+    return $find(this, fn);
+  }
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.async-iterator.flat-map.js

@@ -0,0 +1,65 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var call = require('../internals/function-call');
+var aCallable = require('../internals/a-callable');
+var anObject = require('../internals/an-object');
+var createAsyncIteratorProxy = require('../internals/async-iterator-create-proxy');
+var getAsyncIterator = require('../internals/get-async-iterator');
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (Promise) {
+  var state = this;
+  var mapper = state.mapper;
+  var innerIterator;
+
+  return new Promise(function (resolve, reject) {
+    var outerLoop = function () {
+      try {
+        Promise.resolve(anObject(call(state.next, state.iterator))).then(function (step) {
+          try {
+            if (anObject(step).done) {
+              state.done = true;
+              resolve({ done: true, value: undefined });
+            } else {
+              Promise.resolve(mapper(step.value)).then(function (mapped) {
+                try {
+                  state.innerIterator = innerIterator = getAsyncIterator(mapped);
+                  state.innerNext = aCallable(innerIterator.next);
+                  return innerLoop();
+                } catch (error2) { reject(error2); }
+              }, reject);
+            }
+          } catch (error1) { reject(error1); }
+        }, reject);
+      } catch (error) { reject(error); }
+    };
+
+    var innerLoop = function () {
+      if (innerIterator = state.innerIterator) {
+        try {
+          Promise.resolve(anObject(call(state.innerNext, innerIterator))).then(function (result) {
+            try {
+              if (anObject(result).done) {
+                state.innerIterator = state.innerNext = null;
+                outerLoop();
+              } else resolve({ done: false, value: result.value });
+            } catch (error1) { reject(error1); }
+          }, reject);
+        } catch (error) { reject(error); }
+      } else outerLoop();
+    };
+
+    innerLoop();
+  });
+});
+
+$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, {
+  flatMap: function flatMap(mapper) {
+    return new AsyncIteratorProxy({
+      iterator: anObject(this),
+      mapper: aCallable(mapper),
+      innerIterator: null,
+      innerNext: null
+    });
+  }
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.async-iterator.for-each.js

@@ -0,0 +1,10 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var $forEach = require('../internals/async-iterator-iteration').forEach;
+
+$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, {
+  forEach: function forEach(fn) {
+    return $forEach(this, fn);
+  }
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.async-iterator.from.js

@@ -0,0 +1,37 @@
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var apply = require('../internals/function-apply');
+var anObject = require('../internals/an-object');
+var toObject = require('../internals/to-object');
+var isPrototypeOf = require('../internals/object-is-prototype-of');
+var AsyncIteratorPrototype = require('../internals/async-iterator-prototype');
+var createAsyncIteratorProxy = require('../internals/async-iterator-create-proxy');
+var getAsyncIterator = require('../internals/get-async-iterator');
+var getIterator = require('../internals/get-iterator');
+var getIteratorMethod = require('../internals/get-iterator-method');
+var getMethod = require('../internals/get-method');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var AsyncFromSyncIterator = require('../internals/async-from-sync-iterator');
+
+var ASYNC_ITERATOR = wellKnownSymbol('asyncIterator');
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (Promise, args) {
+  return anObject(apply(this.next, this.iterator, args));
+}, true);
+
+$({ target: 'AsyncIterator', stat: true, forced: true }, {
+  from: function from(O) {
+    var object = toObject(O);
+    var usingIterator = getMethod(object, ASYNC_ITERATOR);
+    var iterator;
+    if (usingIterator) {
+      iterator = getAsyncIterator(object, usingIterator);
+      if (isPrototypeOf(AsyncIteratorPrototype, iterator)) return iterator;
+    }
+    if (iterator === undefined) {
+      usingIterator = getIteratorMethod(object);
+      if (usingIterator) return new AsyncFromSyncIterator(getIterator(object, usingIterator));
+    }
+    return new AsyncIteratorProxy({ iterator: iterator !== undefined ? iterator : object });
+  }
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.async-iterator.map.js

@@ -0,0 +1,31 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var apply = require('../internals/function-apply');
+var aCallable = require('../internals/a-callable');
+var anObject = require('../internals/an-object');
+var createAsyncIteratorProxy = require('../internals/async-iterator-create-proxy');
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (Promise, args) {
+  var state = this;
+  var mapper = state.mapper;
+
+  return Promise.resolve(anObject(apply(state.next, state.iterator, args))).then(function (step) {
+    if (anObject(step).done) {
+      state.done = true;
+      return { done: true, value: undefined };
+    }
+    return Promise.resolve(mapper(step.value)).then(function (value) {
+      return { done: false, value: value };
+    });
+  });
+});
+
+$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, {
+  map: function map(mapper) {
+    return new AsyncIteratorProxy({
+      iterator: anObject(this),
+      mapper: aCallable(mapper)
+    });
+  }
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.async-iterator.reduce.js

@@ -0,0 +1,49 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var global = require('../internals/global');
+var call = require('../internals/function-call');
+var aCallable = require('../internals/a-callable');
+var anObject = require('../internals/an-object');
+var getBuiltIn = require('../internals/get-built-in');
+
+var Promise = getBuiltIn('Promise');
+var TypeError = global.TypeError;
+
+$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, {
+  reduce: function reduce(reducer /* , initialValue */) {
+    var iterator = anObject(this);
+    var next = aCallable(iterator.next);
+    var noInitial = arguments.length < 2;
+    var accumulator = noInitial ? undefined : arguments[1];
+    aCallable(reducer);
+
+    return new Promise(function (resolve, reject) {
+      var loop = function () {
+        try {
+          Promise.resolve(anObject(call(next, iterator))).then(function (step) {
+            try {
+              if (anObject(step).done) {
+                noInitial ? reject(TypeError('Reduce of empty iterator with no initial value')) : resolve(accumulator);
+              } else {
+                var value = step.value;
+                if (noInitial) {
+                  noInitial = false;
+                  accumulator = value;
+                  loop();
+                } else {
+                  Promise.resolve(reducer(accumulator, value)).then(function (result) {
+                    accumulator = result;
+                    loop();
+                  }, reject);
+                }
+              }
+            } catch (err) { reject(err); }
+          }, reject);
+        } catch (error) { reject(error); }
+      };
+
+      loop();
+    });
+  }
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.async-iterator.some.js

@@ -0,0 +1,10 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var $some = require('../internals/async-iterator-iteration').some;
+
+$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, {
+  some: function some(fn) {
+    return $some(this, fn);
+  }
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.async-iterator.take.js

@@ -0,0 +1,33 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var apply = require('../internals/function-apply');
+var call = require('../internals/function-call');
+var anObject = require('../internals/an-object');
+var toPositiveInteger = require('../internals/to-positive-integer');
+var createAsyncIteratorProxy = require('../internals/async-iterator-create-proxy');
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (Promise, args) {
+  var iterator = this.iterator;
+  var returnMethod, result;
+  if (!this.remaining--) {
+    result = { done: true, value: undefined };
+    this.done = true;
+    returnMethod = iterator['return'];
+    if (returnMethod !== undefined) {
+      return Promise.resolve(call(returnMethod, iterator)).then(function () {
+        return result;
+      });
+    }
+    return result;
+  } return apply(this.next, iterator, args);
+});
+
+$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, {
+  take: function take(limit) {
+    return new AsyncIteratorProxy({
+      iterator: anObject(this),
+      remaining: toPositiveInteger(limit)
+    });
+  }
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.async-iterator.to-array.js

@@ -0,0 +1,10 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var $ = require('../internals/export');
+var $toArray = require('../internals/async-iterator-iteration').toArray;
+
+$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, {
+  toArray: function toArray() {
+    return $toArray(this, undefined, []);
+  }
+});

package/cnhis-design-vue/node_modules/core-js/modules/esnext.bigint.range.js

@@ -0,0 +1,14 @@
+'use strict';
+/* eslint-disable es/no-bigint -- safe */
+var $ = require('../internals/export');
+var NumericRangeIterator = require('../internals/numeric-range-iterator');
+
+// `BigInt.range` method
+// https://github.com/tc39/proposal-Number.range
+if (typeof BigInt == 'function') {
+  $({ target: 'BigInt', stat: true, forced: true }, {
+    range: function range(start, end, option) {
+      return new NumericRangeIterator(start, end, option, 'bigint', BigInt(0), BigInt(1));
+    }
+  });
+}

package/cnhis-design-vue/node_modules/core-js/modules/esnext.composite-key.js

@@ -0,0 +1,20 @@
+var $ = require('../internals/export');
+var global = require('../internals/global');
+var apply = require('../internals/function-apply');
+var getCompositeKeyNode = require('../internals/composite-key');
+var getBuiltIn = require('../internals/get-built-in');
+var create = require('../internals/object-create');
+
+var Object = global.Object;
+
+var initializer = function () {
+  var freeze = getBuiltIn('Object', 'freeze');
+  return freeze ? freeze(create(null)) : create(null);
+};
+
+// https://github.com/tc39/proposal-richer-keys/tree/master/compositeKey
+$({ global: true, forced: true }, {
+  compositeKey: function compositeKey() {
+    return apply(getCompositeKeyNode, Object, arguments).get('object', initializer);
+  }
+});