@ibiz-template/vue3-components 0.7.41-alpha.9 → 0.7.41-alpha.90

package/lib/node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/es.string.match.cjs

@@ -0,0 +1,87 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../../../../../../_virtual/_commonjsHelpers.cjs');
+var es_string_match = require('../../../../../../_virtual/es.string.match.cjs');
+require('../../../../../../_virtual/function-call.cjs');
+require('../../../../../../_virtual/function-uncurry-this.cjs');
+require('../../../../../../_virtual/fix-regexp-well-known-symbol-logic.cjs');
+require('../../../../../../_virtual/an-object.cjs');
+require('../../../../../../_virtual/is-object.cjs');
+require('../../../../../../_virtual/to-length.cjs');
+require('../../../../../../_virtual/to-string.cjs');
+require('../../../../../../_virtual/require-object-coercible.cjs');
+require('../../../../../../_virtual/get-method.cjs');
+require('../../../../../../_virtual/advance-string-index.cjs');
+require('../../../../../../_virtual/regexp-get-flags.cjs');
+require('../../../../../../_virtual/regexp-exec-abstract.cjs');
+var functionCall = require('../internals/function-call.cjs');
+var functionUncurryThis = require('../internals/function-uncurry-this.cjs');
+var fixRegexpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic.cjs');
+var anObject$1 = require('../internals/an-object.cjs');
+var isObject$1 = require('../internals/is-object.cjs');
+var toLength$1 = require('../internals/to-length.cjs');
+var toString$1 = require('../internals/to-string.cjs');
+var requireObjectCoercible$1 = require('../internals/require-object-coercible.cjs');
+var getMethod$1 = require('../internals/get-method.cjs');
+var advanceStringIndex$1 = require('../internals/advance-string-index.cjs');
+var regexpGetFlags = require('../internals/regexp-get-flags.cjs');
+var regexpExecAbstract = require('../internals/regexp-exec-abstract.cjs');
+
+'use strict';
+var call = functionCall.functionCall;
+var uncurryThis = functionUncurryThis.functionUncurryThis;
+var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic.fixRegexpWellKnownSymbolLogic;
+var anObject = anObject$1.anObject;
+var isObject = isObject$1.isObject;
+var toLength = toLength$1.toLength;
+var toString = toString$1.toString;
+var requireObjectCoercible = requireObjectCoercible$1.requireObjectCoercible;
+var getMethod = getMethod$1.getMethod;
+var advanceStringIndex = advanceStringIndex$1.advanceStringIndex;
+var getRegExpFlags = regexpGetFlags.regexpGetFlags;
+var regExpExec = regexpExecAbstract.regexpExecAbstract;
+
+var stringIndexOf = uncurryThis(''.indexOf);
+
+// @@match logic
+fixRegExpWellKnownSymbolLogic('match', function (MATCH, nativeMatch, maybeCallNative) {
+  return [
+    // `String.prototype.match` method
+    // https://tc39.es/ecma262/#sec-string.prototype.match
+    function match(regexp) {
+      var O = requireObjectCoercible(this);
+      var matcher = isObject(regexp) ? getMethod(regexp, MATCH) : undefined;
+      return matcher ? call(matcher, regexp, O) : new RegExp(regexp)[MATCH](toString(O));
+    },
+    // `RegExp.prototype[@@match]` method
+    // https://tc39.es/ecma262/#sec-regexp.prototype-@@match
+    function (string) {
+      var rx = anObject(this);
+      var S = toString(string);
+      var res = maybeCallNative(nativeMatch, rx, S);
+
+      if (res.done) return res.value;
+
+      var flags = toString(getRegExpFlags(rx));
+
+      if (!~stringIndexOf(flags, 'g')) return regExpExec(rx, S);
+
+      var fullUnicode = !!~stringIndexOf(flags, 'u') || !!~stringIndexOf(flags, 'v');
+      rx.lastIndex = 0;
+      var A = [];
+      var n = 0;
+      var result;
+      while ((result = regExpExec(rx, S)) !== null) {
+        var matchStr = toString(result[0]);
+        A[n] = matchStr;
+        if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
+        n++;
+      }
+      return n === 0 ? null : A;
+    }
+  ];
+});
+
+exports.default = es_string_match.__exports;

package/lib/node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/es.string.replace.cjs

@@ -0,0 +1,190 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../../../../../../_virtual/_commonjsHelpers.cjs');
+var es_string_replace = require('../../../../../../_virtual/es.string.replace.cjs');
+require('../../../../../../_virtual/function-apply.cjs');
+require('../../../../../../_virtual/function-call.cjs');
+require('../../../../../../_virtual/function-uncurry-this.cjs');
+require('../../../../../../_virtual/fix-regexp-well-known-symbol-logic.cjs');
+require('../../../../../../_virtual/fails.cjs');
+require('../../../../../../_virtual/an-object.cjs');
+require('../../../../../../_virtual/is-callable.cjs');
+require('../../../../../../_virtual/is-object.cjs');
+require('../../../../../../_virtual/to-integer-or-infinity.cjs');
+require('../../../../../../_virtual/to-length.cjs');
+require('../../../../../../_virtual/to-string.cjs');
+require('../../../../../../_virtual/require-object-coercible.cjs');
+require('../../../../../../_virtual/advance-string-index.cjs');
+require('../../../../../../_virtual/get-method.cjs');
+require('../../../../../../_virtual/get-substitution.cjs');
+require('../../../../../../_virtual/regexp-get-flags.cjs');
+require('../../../../../../_virtual/regexp-exec-abstract.cjs');
+require('../../../../../../_virtual/well-known-symbol.cjs');
+var functionApply = require('../internals/function-apply.cjs');
+var functionCall = require('../internals/function-call.cjs');
+var functionUncurryThis = require('../internals/function-uncurry-this.cjs');
+var fixRegexpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic.cjs');
+var fails$1 = require('../internals/fails.cjs');
+var anObject$1 = require('../internals/an-object.cjs');
+var isCallable$1 = require('../internals/is-callable.cjs');
+var isObject$1 = require('../internals/is-object.cjs');
+var toIntegerOrInfinity$1 = require('../internals/to-integer-or-infinity.cjs');
+var toLength$1 = require('../internals/to-length.cjs');
+var toString$1 = require('../internals/to-string.cjs');
+var requireObjectCoercible$1 = require('../internals/require-object-coercible.cjs');
+var advanceStringIndex$1 = require('../internals/advance-string-index.cjs');
+var getMethod$1 = require('../internals/get-method.cjs');
+var getSubstitution$1 = require('../internals/get-substitution.cjs');
+var regexpGetFlags = require('../internals/regexp-get-flags.cjs');
+var regexpExecAbstract = require('../internals/regexp-exec-abstract.cjs');
+var wellKnownSymbol$1 = require('../internals/well-known-symbol.cjs');
+
+'use strict';
+var apply = functionApply.functionApply;
+var call = functionCall.functionCall;
+var uncurryThis = functionUncurryThis.functionUncurryThis;
+var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic.fixRegexpWellKnownSymbolLogic;
+var fails = fails$1.fails;
+var anObject = anObject$1.anObject;
+var isCallable = isCallable$1.isCallable;
+var isObject = isObject$1.isObject;
+var toIntegerOrInfinity = toIntegerOrInfinity$1.toIntegerOrInfinity;
+var toLength = toLength$1.toLength;
+var toString = toString$1.toString;
+var requireObjectCoercible = requireObjectCoercible$1.requireObjectCoercible;
+var advanceStringIndex = advanceStringIndex$1.advanceStringIndex;
+var getMethod = getMethod$1.getMethod;
+var getSubstitution = getSubstitution$1.getSubstitution;
+var getRegExpFlags = regexpGetFlags.regexpGetFlags;
+var regExpExec = regexpExecAbstract.regexpExecAbstract;
+var wellKnownSymbol = wellKnownSymbol$1.wellKnownSymbol;
+
+var REPLACE = wellKnownSymbol('replace');
+var max = Math.max;
+var min = Math.min;
+var concat = uncurryThis([].concat);
+var push = uncurryThis([].push);
+var stringIndexOf = uncurryThis(''.indexOf);
+var stringSlice = uncurryThis(''.slice);
+
+var maybeToString = function (it) {
+  return it === undefined ? it : String(it);
+};
+
+// IE <= 11 replaces $0 with the whole match, as if it was $&
+// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0
+var REPLACE_KEEPS_$0 = (function () {
+  // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing
+  return 'a'.replace(/./, '$0') === '$0';
+})();
+
+// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string
+var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {
+  if (/./[REPLACE]) {
+    return /./[REPLACE]('a', '$0') === '';
+  }
+  return false;
+})();
+
+var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
+  var re = /./;
+  re.exec = function () {
+    var result = [];
+    result.groups = { a: '7' };
+    return result;
+  };
+  // eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive
+  return ''.replace(re, '$<a>') !== '7';
+});
+
+// @@replace logic
+fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) {
+  var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';
+
+  return [
+    // `String.prototype.replace` method
+    // https://tc39.es/ecma262/#sec-string.prototype.replace
+    function replace(searchValue, replaceValue) {
+      var O = requireObjectCoercible(this);
+      var replacer = isObject(searchValue) ? getMethod(searchValue, REPLACE) : undefined;
+      return replacer
+        ? call(replacer, searchValue, O, replaceValue)
+        : call(nativeReplace, toString(O), searchValue, replaceValue);
+    },
+    // `RegExp.prototype[@@replace]` method
+    // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
+    function (string, replaceValue) {
+      var rx = anObject(this);
+      var S = toString(string);
+
+      var functionalReplace = isCallable(replaceValue);
+      if (!functionalReplace) replaceValue = toString(replaceValue);
+      var flags = toString(getRegExpFlags(rx));
+
+      if (
+        typeof replaceValue == 'string' &&
+        !~stringIndexOf(replaceValue, UNSAFE_SUBSTITUTE) &&
+        !~stringIndexOf(replaceValue, '$<') &&
+        !~stringIndexOf(flags, 'y')
+      ) {
+        var res = maybeCallNative(nativeReplace, rx, S, replaceValue);
+        if (res.done) return res.value;
+      }
+
+      var global = !!~stringIndexOf(flags, 'g');
+      var fullUnicode;
+      if (global) {
+        fullUnicode = !!~stringIndexOf(flags, 'u') || !!~stringIndexOf(flags, 'v');
+        rx.lastIndex = 0;
+      }
+
+      var results = [];
+      var result;
+      while (true) {
+        result = regExpExec(rx, S);
+        if (result === null) break;
+
+        push(results, result);
+        if (!global) break;
+
+        var matchStr = toString(result[0]);
+        if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
+      }
+
+      var accumulatedResult = '';
+      var nextSourcePosition = 0;
+      for (var i = 0; i < results.length; i++) {
+        result = results[i];
+
+        var matched = toString(result[0]);
+        var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);
+        var captures = [];
+        var replacement;
+        // NOTE: This is equivalent to
+        //   captures = result.slice(1).map(maybeToString)
+        // but for some reason `nativeSlice.call(result, 1, result.length)` (called in
+        // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
+        // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
+        for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j]));
+        var namedCaptures = result.groups;
+        if (functionalReplace) {
+          var replacerArgs = concat([matched], captures, position, S);
+          if (namedCaptures !== undefined) push(replacerArgs, namedCaptures);
+          replacement = toString(apply(replaceValue, undefined, replacerArgs));
+        } else {
+          replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
+        }
+        if (position >= nextSourcePosition) {
+          accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;
+          nextSourcePosition = position + matched.length;
+        }
+      }
+
+      return accumulatedResult + stringSlice(S, nextSourcePosition);
+    }
+  ];
+}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
+
+exports.default = es_string_replace.__exports;

package/lib/node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/es.string.split.cjs

@@ -0,0 +1,152 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../../../../../../_virtual/_commonjsHelpers.cjs');
+var es_string_split = require('../../../../../../_virtual/es.string.split.cjs');
+require('../../../../../../_virtual/function-call.cjs');
+require('../../../../../../_virtual/function-uncurry-this.cjs');
+require('../../../../../../_virtual/fix-regexp-well-known-symbol-logic.cjs');
+require('../../../../../../_virtual/an-object.cjs');
+require('../../../../../../_virtual/is-object.cjs');
+require('../../../../../../_virtual/require-object-coercible.cjs');
+require('../../../../../../_virtual/species-constructor.cjs');
+require('../../../../../../_virtual/advance-string-index.cjs');
+require('../../../../../../_virtual/to-length.cjs');
+require('../../../../../../_virtual/to-string.cjs');
+require('../../../../../../_virtual/get-method.cjs');
+require('../../../../../../_virtual/regexp-get-flags.cjs');
+require('../../../../../../_virtual/regexp-exec-abstract.cjs');
+require('../../../../../../_virtual/regexp-sticky-helpers.cjs');
+require('../../../../../../_virtual/fails.cjs');
+var functionCall = require('../internals/function-call.cjs');
+var functionUncurryThis = require('../internals/function-uncurry-this.cjs');
+var fixRegexpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic.cjs');
+var anObject$1 = require('../internals/an-object.cjs');
+var isObject$1 = require('../internals/is-object.cjs');
+var requireObjectCoercible$1 = require('../internals/require-object-coercible.cjs');
+var speciesConstructor$1 = require('../internals/species-constructor.cjs');
+var advanceStringIndex$1 = require('../internals/advance-string-index.cjs');
+var toLength$1 = require('../internals/to-length.cjs');
+var toString$1 = require('../internals/to-string.cjs');
+var getMethod$1 = require('../internals/get-method.cjs');
+var regexpGetFlags = require('../internals/regexp-get-flags.cjs');
+var regexpExecAbstract = require('../internals/regexp-exec-abstract.cjs');
+var regexpStickyHelpers = require('../internals/regexp-sticky-helpers.cjs');
+var fails$1 = require('../internals/fails.cjs');
+
+'use strict';
+var call = functionCall.functionCall;
+var uncurryThis = functionUncurryThis.functionUncurryThis;
+var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic.fixRegexpWellKnownSymbolLogic;
+var anObject = anObject$1.anObject;
+var isObject = isObject$1.isObject;
+var requireObjectCoercible = requireObjectCoercible$1.requireObjectCoercible;
+var speciesConstructor = speciesConstructor$1.speciesConstructor;
+var advanceStringIndex = advanceStringIndex$1.advanceStringIndex;
+var toLength = toLength$1.toLength;
+var toString = toString$1.toString;
+var getMethod = getMethod$1.getMethod;
+var getRegExpFlags = regexpGetFlags.regexpGetFlags;
+var regExpExec = regexpExecAbstract.regexpExecAbstract;
+var stickyHelpers = regexpStickyHelpers.regexpStickyHelpers;
+var fails = fails$1.fails;
+
+var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;
+var MAX_UINT32 = 0xFFFFFFFF;
+var min = Math.min;
+var push = uncurryThis([].push);
+var stringSlice = uncurryThis(''.slice);
+var stringIndexOf = uncurryThis(''.indexOf);
+
+// Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
+// Weex JS has frozen built-in prototypes, so use try / catch wrapper
+var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () {
+  // eslint-disable-next-line regexp/no-empty-group -- required for testing
+  var re = /(?:)/;
+  var originalExec = re.exec;
+  re.exec = function () { return originalExec.apply(this, arguments); };
+  var result = 'ab'.split(re);
+  return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';
+});
+
+var BUGGY = 'abbc'.split(/(b)*/)[1] === 'c' ||
+  // eslint-disable-next-line regexp/no-empty-group -- required for testing
+  'test'.split(/(?:)/, -1).length !== 4 ||
+  'ab'.split(/(?:ab)*/).length !== 2 ||
+  '.'.split(/(.?)(.?)/).length !== 4 ||
+  // eslint-disable-next-line regexp/no-empty-capturing-group, regexp/no-empty-group -- required for testing
+  '.'.split(/()()/).length > 1 ||
+  ''.split(/.?/).length;
+
+// @@split logic
+fixRegExpWellKnownSymbolLogic('split', function (SPLIT, nativeSplit, maybeCallNative) {
+  var internalSplit = '0'.split(undefined, 0).length ? function (separator, limit) {
+    return separator === undefined && limit === 0 ? [] : call(nativeSplit, this, separator, limit);
+  } : nativeSplit;
+
+  return [
+    // `String.prototype.split` method
+    // https://tc39.es/ecma262/#sec-string.prototype.split
+    function split(separator, limit) {
+      var O = requireObjectCoercible(this);
+      var splitter = isObject(separator) ? getMethod(separator, SPLIT) : undefined;
+      return splitter
+        ? call(splitter, separator, O, limit)
+        : call(internalSplit, toString(O), separator, limit);
+    },
+    // `RegExp.prototype[@@split]` method
+    // https://tc39.es/ecma262/#sec-regexp.prototype-@@split
+    //
+    // NOTE: This cannot be properly polyfilled in engines that don't support
+    // the 'y' flag.
+    function (string, limit) {
+      var rx = anObject(this);
+      var S = toString(string);
+
+      if (!BUGGY) {
+        var res = maybeCallNative(internalSplit, rx, S, limit, internalSplit !== nativeSplit);
+        if (res.done) return res.value;
+      }
+
+      var C = speciesConstructor(rx, RegExp);
+      var flags = toString(getRegExpFlags(rx));
+      var unicodeMatching = !!~stringIndexOf(flags, 'u') || !!~stringIndexOf(flags, 'v');
+      if (UNSUPPORTED_Y) {
+        if (!~stringIndexOf(flags, 'g')) flags += 'g';
+      } else if (!~stringIndexOf(flags, 'y')) flags += 'y';
+      // ^(? + rx + ) is needed, in combination with some S slicing, to
+      // simulate the 'y' flag.
+      var splitter = new C(UNSUPPORTED_Y ? '^(?:' + rx.source + ')' : rx, flags);
+      var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
+      if (lim === 0) return [];
+      if (S.length === 0) return regExpExec(splitter, S) === null ? [S] : [];
+      var p = 0;
+      var q = 0;
+      var A = [];
+      while (q < S.length) {
+        splitter.lastIndex = UNSUPPORTED_Y ? 0 : q;
+        var z = regExpExec(splitter, UNSUPPORTED_Y ? stringSlice(S, q) : S);
+        var e;
+        if (
+          z === null ||
+          (e = min(toLength(splitter.lastIndex + (UNSUPPORTED_Y ? q : 0)), S.length)) === p
+        ) {
+          q = advanceStringIndex(S, q, unicodeMatching);
+        } else {
+          push(A, stringSlice(S, p, q));
+          if (A.length === lim) return A;
+          for (var i = 1; i <= z.length - 1; i++) {
+            push(A, z[i]);
+            if (A.length === lim) return A;
+          }
+          q = p = e;
+        }
+      }
+      push(A, stringSlice(S, p));
+      return A;
+    }
+  ];
+}, BUGGY || !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y);
+
+exports.default = es_string_split.__exports;

package/lib/node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/es.string.starts-with.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../../../../../../_virtual/_commonjsHelpers.cjs');
+var es_string_startsWith = require('../../../../../../_virtual/es.string.starts-with.cjs');
+require('../../../../../../_virtual/export.cjs');
+require('../../../../../../_virtual/function-uncurry-this-clause.cjs');
+require('../../../../../../_virtual/object-get-own-property-descriptor.cjs');
+require('../../../../../../_virtual/to-length.cjs');
+require('../../../../../../_virtual/to-string.cjs');
+require('../../../../../../_virtual/not-a-regexp.cjs');
+require('../../../../../../_virtual/require-object-coercible.cjs');
+require('../../../../../../_virtual/correct-is-regexp-logic.cjs');
+require('../../../../../../_virtual/is-pure.cjs');
+var _export = require('../internals/export.cjs');
+var functionUncurryThisClause = require('../internals/function-uncurry-this-clause.cjs');
+var objectGetOwnPropertyDescriptor = require('../../../../../../_virtual/object-get-own-property-descriptor2.cjs');
+var toLength$1 = require('../internals/to-length.cjs');
+var toString$1 = require('../internals/to-string.cjs');
+var notARegexp = require('../internals/not-a-regexp.cjs');
+var requireObjectCoercible$1 = require('../internals/require-object-coercible.cjs');
+var correctIsRegexpLogic = require('../internals/correct-is-regexp-logic.cjs');
+var isPure = require('../internals/is-pure.cjs');
+
+'use strict';
+var $ = _export._export;
+var uncurryThis = functionUncurryThisClause.functionUncurryThisClause;
+var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.__exports.f;
+var toLength = toLength$1.toLength;
+var toString = toString$1.toString;
+var notARegExp = notARegexp.notARegexp;
+var requireObjectCoercible = requireObjectCoercible$1.requireObjectCoercible;
+var correctIsRegExpLogic = correctIsRegexpLogic.correctIsRegexpLogic;
+var IS_PURE = isPure.isPure;
+
+var stringSlice = uncurryThis(''.slice);
+var min = Math.min;
+
+var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith');
+// https://github.com/zloirock/core-js/pull/702
+var MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () {
+  var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith');
+  return descriptor && !descriptor.writable;
+}();
+
+// `String.prototype.startsWith` method
+// https://tc39.es/ecma262/#sec-string.prototype.startswith
+$({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {
+  startsWith: function startsWith(searchString /* , position = 0 */) {
+    var that = toString(requireObjectCoercible(this));
+    notARegExp(searchString);
+    var search = toString(searchString);
+    var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length));
+    return stringSlice(that, index, index + search.length) === search;
+  }
+});
+
+exports.default = es_string_startsWith.__exports;

package/lib/node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/es.string.trim.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../../../../../../_virtual/_commonjsHelpers.cjs');
+var es_string_trim = require('../../../../../../_virtual/es.string.trim.cjs');
+require('../../../../../../_virtual/export.cjs');
+require('../../../../../../_virtual/string-trim.cjs');
+require('../../../../../../_virtual/string-trim-forced.cjs');
+var _export = require('../internals/export.cjs');
+var stringTrim = require('../internals/string-trim.cjs');
+var stringTrimForced = require('../internals/string-trim-forced.cjs');
+
+'use strict';
+var $ = _export._export;
+var $trim = stringTrim.stringTrim.trim;
+var forcedStringTrimMethod = stringTrimForced.stringTrimForced;
+
+// `String.prototype.trim` method
+// https://tc39.es/ecma262/#sec-string.prototype.trim
+$({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, {
+  trim: function trim() {
+    return $trim(this);
+  }
+});
+
+exports.default = es_string_trim.__exports;

package/lib/node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/web.dom-collections.iterator.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../../../../../../_virtual/_commonjsHelpers.cjs');
+var web_domCollections_iterator = require('../../../../../../_virtual/web.dom-collections.iterator.cjs');
+require('../../../../../../_virtual/global-this.cjs');
+require('../../../../../../_virtual/dom-iterables.cjs');
+require('../../../../../../_virtual/dom-token-list-prototype.cjs');
+require('../../../../../../_virtual/es.array.iterator.cjs');
+require('../../../../../../_virtual/create-non-enumerable-property.cjs');
+require('../../../../../../_virtual/set-to-string-tag.cjs');
+require('../../../../../../_virtual/well-known-symbol.cjs');
+var globalThis$1 = require('../internals/global-this.cjs');
+var domIterables = require('../internals/dom-iterables.cjs');
+var domTokenListPrototype = require('../internals/dom-token-list-prototype.cjs');
+var es_array_iterator = require('./es.array.iterator.cjs');
+var createNonEnumerableProperty$1 = require('../internals/create-non-enumerable-property.cjs');
+var setToStringTag$1 = require('../internals/set-to-string-tag.cjs');
+var wellKnownSymbol$1 = require('../internals/well-known-symbol.cjs');
+
+'use strict';
+var globalThis = globalThis$1.globalThis_1;
+var DOMIterables = domIterables.domIterables;
+var DOMTokenListPrototype = domTokenListPrototype.domTokenListPrototype;
+var ArrayIteratorMethods = es_array_iterator.es_array_iterator;
+var createNonEnumerableProperty = createNonEnumerableProperty$1.createNonEnumerableProperty;
+var setToStringTag = setToStringTag$1.setToStringTag;
+var wellKnownSymbol = wellKnownSymbol$1.wellKnownSymbol;
+
+var ITERATOR = wellKnownSymbol('iterator');
+var ArrayValues = ArrayIteratorMethods.values;
+
+var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
+  if (CollectionPrototype) {
+    // some Chrome versions have non-configurable methods on DOMTokenList
+    if (CollectionPrototype[ITERATOR] !== ArrayValues) try {
+      createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);
+    } catch (error) {
+      CollectionPrototype[ITERATOR] = ArrayValues;
+    }
+    setToStringTag(CollectionPrototype, COLLECTION_NAME, true);
+    if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {
+      // some Chrome versions have non-configurable methods on DOMTokenList
+      if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {
+        createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
+      } catch (error) {
+        CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
+      }
+    }
+  }
+};
+
+for (var COLLECTION_NAME in DOMIterables) {
+  handlePrototype(globalThis[COLLECTION_NAME] && globalThis[COLLECTION_NAME].prototype, COLLECTION_NAME);
+}
+
+handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
+
+exports.default = web_domCollections_iterator.__exports;