@vention/vention-cli 0.38.34 → 0.38.36

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/main.esm.js CHANGED
@@ -2,8 +2,10 @@
2
2
  import { Command, Option } from 'commander';
3
3
  import chalk from 'chalk';
4
4
  import { select } from '@inquirer/prompts';
5
- import fs, { promises } from 'fs';
6
- import path$2 from 'path';
5
+ import * as fs from 'fs';
6
+ import fs__default, { promises } from 'fs';
7
+ import * as path$2 from 'path';
8
+ import path__default from 'path';
7
9
  import { z } from 'zod';
8
10
  import { spawn } from 'node:child_process';
9
11
  import { release } from 'node:os';
@@ -3320,9 +3322,9 @@ const getConfigPath = () => {
3320
3322
  console.warn(chalk.yellow("Warning: Could not determine home directory. Using current directory instead."));
3321
3323
  console.warn(chalk.yellow("This may cause issues if the CLI is run from different directories."));
3322
3324
  console.warn(chalk.blue("To fix this permanently, set the HOME environment variable."));
3323
- return path$2.join(process.cwd(), ".vention-cli-config.json");
3325
+ return path__default.join(process.cwd(), ".vention-cli-config.json");
3324
3326
  }
3325
- return path$2.join(homeDir, ".vention-cli-config.json");
3327
+ return path__default.join(homeDir, ".vention-cli-config.json");
3326
3328
  };
3327
3329
  const saveSession = async data => {
3328
3330
  const configPath = getConfigPath();
@@ -5620,53 +5622,6 @@ if ($transfer) $$n({ target: 'ArrayBuffer', proto: true }, {
5620
5622
  }
5621
5623
  });
5622
5624
 
5623
- var globalThis$h = globalThis_1;
5624
- var fails$h = fails$E;
5625
-
5626
- // babel-minify and Closure Compiler transpiles RegExp('.', 'd') -> /./d and it causes SyntaxError
5627
- var RegExp$1 = globalThis$h.RegExp;
5628
-
5629
- var FLAGS_GETTER_IS_CORRECT = !fails$h(function () {
5630
- var INDICES_SUPPORT = true;
5631
- try {
5632
- RegExp$1('.', 'd');
5633
- } catch (error) {
5634
- INDICES_SUPPORT = false;
5635
- }
5636
-
5637
- var O = {};
5638
- // modern V8 bug
5639
- var calls = '';
5640
- var expected = INDICES_SUPPORT ? 'dgimsy' : 'gimsy';
5641
-
5642
- var addGetter = function (key, chr) {
5643
- // eslint-disable-next-line es/no-object-defineproperty -- safe
5644
- Object.defineProperty(O, key, { get: function () {
5645
- calls += chr;
5646
- return true;
5647
- } });
5648
- };
5649
-
5650
- var pairs = {
5651
- dotAll: 's',
5652
- global: 'g',
5653
- ignoreCase: 'i',
5654
- multiline: 'm',
5655
- sticky: 'y'
5656
- };
5657
-
5658
- if (INDICES_SUPPORT) pairs.hasIndices = 'd';
5659
-
5660
- for (var key in pairs) addGetter(key, pairs[key]);
5661
-
5662
- // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
5663
- var result = Object.getOwnPropertyDescriptor(RegExp$1.prototype, 'flags').get.call(O);
5664
-
5665
- return result !== expected || calls !== expected;
5666
- });
5667
-
5668
- var regexpFlagsDetection = { correct: FLAGS_GETTER_IS_CORRECT };
5669
-
5670
5625
  var anObject$8 = anObject$p;
5671
5626
 
5672
5627
  // `RegExp.prototype.flags` getter implementation
@@ -5685,29 +5640,13 @@ var regexpFlags$1 = function () {
5685
5640
  return result;
5686
5641
  };
5687
5642
 
5688
- var call$e = functionCall;
5689
- var hasOwn$4 = hasOwnProperty_1;
5690
- var isPrototypeOf$3 = objectIsPrototypeOf;
5691
- var regExpFlagsDetection = regexpFlagsDetection;
5692
- var regExpFlagsGetterImplementation = regexpFlags$1;
5693
-
5694
- var RegExpPrototype$4 = RegExp.prototype;
5695
-
5696
- var regexpGetFlags = regExpFlagsDetection.correct ? function (it) {
5697
- return it.flags;
5698
- } : function (it) {
5699
- return (!regExpFlagsDetection.correct && isPrototypeOf$3(RegExpPrototype$4, it) && !hasOwn$4(it, 'flags'))
5700
- ? call$e(regExpFlagsGetterImplementation, it)
5701
- : it.flags;
5702
- };
5703
-
5704
- var fails$g = fails$E;
5705
- var globalThis$g = globalThis_1;
5643
+ var fails$h = fails$E;
5644
+ var globalThis$h = globalThis_1;
5706
5645
 
5707
5646
  // babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
5708
- var $RegExp$2 = globalThis$g.RegExp;
5647
+ var $RegExp$2 = globalThis$h.RegExp;
5709
5648
 
5710
- var UNSUPPORTED_Y$2 = fails$g(function () {
5649
+ var UNSUPPORTED_Y$2 = fails$h(function () {
5711
5650
  var re = $RegExp$2('a', 'y');
5712
5651
  re.lastIndex = 2;
5713
5652
  return re.exec('abcd') !== null;
@@ -5715,11 +5654,11 @@ var UNSUPPORTED_Y$2 = fails$g(function () {
5715
5654
 
5716
5655
  // UC Browser bug
5717
5656
  // https://github.com/zloirock/core-js/issues/1008
5718
- var MISSED_STICKY$1 = UNSUPPORTED_Y$2 || fails$g(function () {
5657
+ var MISSED_STICKY$1 = UNSUPPORTED_Y$2 || fails$h(function () {
5719
5658
  return !$RegExp$2('a', 'y').sticky;
5720
5659
  });
5721
5660
 
5722
- var BROKEN_CARET = UNSUPPORTED_Y$2 || fails$g(function () {
5661
+ var BROKEN_CARET = UNSUPPORTED_Y$2 || fails$h(function () {
5723
5662
  // https://bugzilla.mozilla.org/show_bug.cgi?id=773687
5724
5663
  var re = $RegExp$2('^r', 'gy');
5725
5664
  re.lastIndex = 2;
@@ -5732,363 +5671,129 @@ var regexpStickyHelpers = {
5732
5671
  UNSUPPORTED_Y: UNSUPPORTED_Y$2
5733
5672
  };
5734
5673
 
5735
- var fails$f = fails$E;
5736
- var globalThis$f = globalThis_1;
5674
+ var fails$g = fails$E;
5675
+ var globalThis$g = globalThis_1;
5737
5676
 
5738
5677
  // babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
5739
- var $RegExp$1 = globalThis$f.RegExp;
5678
+ var $RegExp$1 = globalThis$g.RegExp;
5740
5679
 
5741
- var regexpUnsupportedDotAll = fails$f(function () {
5680
+ var regexpUnsupportedDotAll = fails$g(function () {
5742
5681
  var re = $RegExp$1('.', 's');
5743
5682
  return !(re.dotAll && re.test('\n') && re.flags === 's');
5744
5683
  });
5745
5684
 
5746
- var fails$e = fails$E;
5747
- var globalThis$e = globalThis_1;
5685
+ var fails$f = fails$E;
5686
+ var globalThis$f = globalThis_1;
5748
5687
 
5749
5688
  // babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
5750
- var $RegExp = globalThis$e.RegExp;
5689
+ var $RegExp = globalThis$f.RegExp;
5751
5690
 
5752
- var regexpUnsupportedNcg = fails$e(function () {
5691
+ var regexpUnsupportedNcg = fails$f(function () {
5753
5692
  var re = $RegExp('(?<a>b)', 'g');
5754
5693
  return re.exec('b').groups.a !== 'b' ||
5755
5694
  'b'.replace(re, '$<a>c') !== 'bc';
5756
5695
  });
5757
5696
 
5758
- var DESCRIPTORS$3 = descriptors;
5759
- var globalThis$d = globalThis_1;
5697
+ /* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
5698
+ /* eslint-disable regexp/no-useless-quantifier -- testing */
5699
+ var call$e = functionCall;
5760
5700
  var uncurryThis$i = functionUncurryThis;
5761
- var isForced = isForced_1;
5762
- var inheritIfRequired$1 = inheritIfRequired$4;
5763
- var createNonEnumerableProperty$3 = createNonEnumerableProperty$d;
5764
- var create$2 = objectCreate;
5765
- var getOwnPropertyNames$1 = objectGetOwnPropertyNames.f;
5766
- var isPrototypeOf$2 = objectIsPrototypeOf;
5767
- var isRegExp = isRegexp;
5768
5701
  var toString$9 = toString$g;
5769
- var getRegExpFlags$2 = regexpGetFlags;
5702
+ var regexpFlags = regexpFlags$1;
5770
5703
  var stickyHelpers$1 = regexpStickyHelpers;
5771
- var proxyAccessor = proxyAccessor$2;
5772
- var defineBuiltIn$3 = defineBuiltIn$a;
5773
- var fails$d = fails$E;
5774
- var hasOwn$3 = hasOwnProperty_1;
5775
- var enforceInternalState$2 = internalState.enforce;
5776
- var setSpecies$1 = setSpecies$4;
5777
- var wellKnownSymbol$4 = wellKnownSymbol$n;
5704
+ var shared = shared$4;
5705
+ var create$2 = objectCreate;
5706
+ var getInternalState$3 = internalState.get;
5778
5707
  var UNSUPPORTED_DOT_ALL$2 = regexpUnsupportedDotAll;
5779
5708
  var UNSUPPORTED_NCG$1 = regexpUnsupportedNcg;
5780
5709
 
5781
- var MATCH = wellKnownSymbol$4('match');
5782
- var NativeRegExp = globalThis$d.RegExp;
5783
- var RegExpPrototype$3 = NativeRegExp.prototype;
5784
- var SyntaxError$3 = globalThis$d.SyntaxError;
5785
- var exec$1 = uncurryThis$i(RegExpPrototype$3.exec);
5710
+ var nativeReplace = shared('native-string-replace', String.prototype.replace);
5711
+ var nativeExec = RegExp.prototype.exec;
5712
+ var patchedExec = nativeExec;
5786
5713
  var charAt$5 = uncurryThis$i(''.charAt);
5714
+ var indexOf = uncurryThis$i(''.indexOf);
5787
5715
  var replace$3 = uncurryThis$i(''.replace);
5788
- var stringIndexOf$1 = uncurryThis$i(''.indexOf);
5789
5716
  var stringSlice$6 = uncurryThis$i(''.slice);
5790
- // TODO: Use only proper RegExpIdentifierName
5791
- var IS_NCG = /^\?<[^\s\d!#%&*+<=>@^][^\s!#%&*+<=>@^]*>/;
5792
- var re1 = /a/g;
5793
- var re2 = /a/g;
5794
5717
 
5795
- // "new" should create a new object, old webkit bug
5796
- var CORRECT_NEW = new NativeRegExp(re1) !== re1;
5718
+ var UPDATES_LAST_INDEX_WRONG = (function () {
5719
+ var re1 = /a/;
5720
+ var re2 = /b*/g;
5721
+ call$e(nativeExec, re1, 'a');
5722
+ call$e(nativeExec, re2, 'a');
5723
+ return re1.lastIndex !== 0 || re2.lastIndex !== 0;
5724
+ })();
5797
5725
 
5798
- var MISSED_STICKY = stickyHelpers$1.MISSED_STICKY;
5799
- var UNSUPPORTED_Y$1 = stickyHelpers$1.UNSUPPORTED_Y;
5726
+ var UNSUPPORTED_Y$1 = stickyHelpers$1.BROKEN_CARET;
5800
5727
 
5801
- var BASE_FORCED = DESCRIPTORS$3 &&
5802
- (!CORRECT_NEW || MISSED_STICKY || UNSUPPORTED_DOT_ALL$2 || UNSUPPORTED_NCG$1 || fails$d(function () {
5803
- re2[MATCH] = false;
5804
- // RegExp constructor can alter flags and IsRegExp works correct with @@match
5805
- // eslint-disable-next-line sonarjs/inconsistent-function-call -- required for testing
5806
- return NativeRegExp(re1) !== re1 || NativeRegExp(re2) === re2 || String(NativeRegExp(re1, 'i')) !== '/a/i';
5807
- }));
5728
+ // nonparticipating capturing group, copied from es5-shim's String#split patch.
5729
+ var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
5808
5730
 
5809
- var handleDotAll = function (string) {
5810
- var length = string.length;
5811
- var index = 0;
5812
- var result = '';
5813
- var brackets = false;
5814
- var chr;
5815
- for (; index < length; index++) {
5816
- chr = charAt$5(string, index);
5817
- if (chr === '\\') {
5818
- result += chr + charAt$5(string, ++index);
5819
- continue;
5820
- }
5821
- if (!brackets && chr === '.') {
5822
- result += '[\\s\\S]';
5823
- } else {
5824
- if (chr === '[') {
5825
- brackets = true;
5826
- } else if (chr === ']') {
5827
- brackets = false;
5828
- } result += chr;
5829
- }
5830
- } return result;
5831
- };
5731
+ var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y$1 || UNSUPPORTED_DOT_ALL$2 || UNSUPPORTED_NCG$1;
5832
5732
 
5833
- var handleNCG = function (string) {
5834
- var length = string.length;
5835
- var index = 0;
5836
- var result = '';
5837
- var named = [];
5838
- var names = create$2(null);
5839
- var brackets = false;
5840
- var ncg = false;
5841
- var groupid = 0;
5842
- var groupname = '';
5843
- var chr;
5844
- for (; index < length; index++) {
5845
- chr = charAt$5(string, index);
5846
- if (chr === '\\') {
5847
- chr += charAt$5(string, ++index);
5848
- // use `\x5c` for escaped backslash to avoid corruption by `\k<name>` to `\N` replacement below
5849
- if (!ncg && charAt$5(chr, 1) === '\\') {
5850
- result += '\\x5c';
5851
- continue;
5852
- }
5853
- } else if (chr === ']') {
5854
- brackets = false;
5855
- } else if (!brackets) switch (true) {
5856
- case chr === '[':
5857
- brackets = true;
5858
- break;
5859
- case chr === '(':
5860
- result += chr;
5861
- if (exec$1(IS_NCG, stringSlice$6(string, index + 1))) {
5862
- index += 2;
5863
- ncg = true;
5864
- groupid++;
5865
- } else if (charAt$5(string, index + 1) !== '?') {
5866
- groupid++;
5867
- }
5868
- continue;
5869
- case chr === '>' && ncg:
5870
- if (groupname === '' || hasOwn$3(names, groupname)) {
5871
- throw new SyntaxError$3('Invalid capture group name');
5872
- }
5873
- names[groupname] = true;
5874
- named[named.length] = [groupname, groupid];
5875
- ncg = false;
5876
- groupname = '';
5877
- continue;
5878
- }
5879
- if (ncg) groupname += chr;
5880
- else result += chr;
5733
+ var setGroups = function (re, groups) {
5734
+ var object = re.groups = create$2(null);
5735
+ for (var i = 0; i < groups.length; i++) {
5736
+ var group = groups[i];
5737
+ object[group[0]] = re[group[1]];
5881
5738
  }
5882
- // convert `\k<name>` backreferences to numbered backreferences
5883
- for (var ni = 0; ni < named.length; ni++) {
5884
- var backref = '\\k<' + named[ni][0] + '>';
5885
- var numRef = '\\' + named[ni][1];
5886
- while (stringIndexOf$1(result, backref) > -1) {
5887
- result = replace$3(result, backref, numRef);
5888
- }
5889
- } return [result, named];
5890
5739
  };
5891
5740
 
5892
- // `RegExp` constructor
5893
- // https://tc39.es/ecma262/#sec-regexp-constructor
5894
- if (isForced('RegExp', BASE_FORCED)) {
5895
- var RegExpWrapper = function RegExp(pattern, flags) {
5896
- var thisIsRegExp = isPrototypeOf$2(RegExpPrototype$3, this);
5897
- var patternIsRegExp = isRegExp(pattern);
5898
- var flagsAreUndefined = flags === undefined;
5899
- var groups = [];
5900
- var rawPattern = pattern;
5901
- var rawFlags, dotAll, sticky, handled, result, state;
5902
-
5903
- if (!thisIsRegExp && patternIsRegExp && flagsAreUndefined && pattern.constructor === RegExpWrapper) {
5904
- return pattern;
5905
- }
5906
-
5907
- if (patternIsRegExp || isPrototypeOf$2(RegExpPrototype$3, pattern)) {
5908
- pattern = pattern.source;
5909
- if (flagsAreUndefined) flags = getRegExpFlags$2(rawPattern);
5910
- }
5911
-
5912
- pattern = pattern === undefined ? '' : toString$9(pattern);
5913
- flags = flags === undefined ? '' : toString$9(flags);
5914
- rawPattern = pattern;
5741
+ if (PATCH) {
5742
+ patchedExec = function exec(string) {
5743
+ var re = this;
5744
+ var state = getInternalState$3(re);
5745
+ var str = toString$9(string);
5746
+ var raw = state.raw;
5747
+ var result, reCopy, lastIndex;
5915
5748
 
5916
- if (UNSUPPORTED_DOT_ALL$2 && 'dotAll' in re1) {
5917
- dotAll = !!flags && stringIndexOf$1(flags, 's') > -1;
5918
- if (dotAll) flags = replace$3(flags, /s/g, '');
5919
- }
5749
+ if (raw) {
5750
+ raw.lastIndex = re.lastIndex;
5751
+ result = call$e(patchedExec, raw, str);
5752
+ re.lastIndex = raw.lastIndex;
5920
5753
 
5921
- rawFlags = flags;
5754
+ if (result && state.groups) setGroups(result, state.groups);
5922
5755
 
5923
- if (MISSED_STICKY && 'sticky' in re1) {
5924
- sticky = !!flags && stringIndexOf$1(flags, 'y') > -1;
5925
- if (sticky && UNSUPPORTED_Y$1) flags = replace$3(flags, /y/g, '');
5756
+ return result;
5926
5757
  }
5927
5758
 
5928
- if (UNSUPPORTED_NCG$1) {
5929
- handled = handleNCG(pattern);
5930
- pattern = handled[0];
5931
- groups = handled[1];
5932
- }
5759
+ var groups = state.groups;
5760
+ var sticky = UNSUPPORTED_Y$1 && re.sticky;
5761
+ var flags = call$e(regexpFlags, re);
5762
+ var source = re.source;
5763
+ var charsAdded = 0;
5764
+ var strCopy = str;
5933
5765
 
5934
- result = inheritIfRequired$1(NativeRegExp(pattern, flags), thisIsRegExp ? this : RegExpPrototype$3, RegExpWrapper);
5766
+ if (sticky) {
5767
+ flags = replace$3(flags, 'y', '');
5768
+ if (indexOf(flags, 'g') === -1) {
5769
+ flags += 'g';
5770
+ }
5935
5771
 
5936
- if (dotAll || sticky || groups.length) {
5937
- state = enforceInternalState$2(result);
5938
- if (dotAll) {
5939
- state.dotAll = true;
5940
- state.raw = RegExpWrapper(handleDotAll(pattern), rawFlags);
5772
+ strCopy = stringSlice$6(str, re.lastIndex);
5773
+ // Support anchored sticky behavior.
5774
+ var prevChar = re.lastIndex > 0 && charAt$5(str, re.lastIndex - 1);
5775
+ if (re.lastIndex > 0 &&
5776
+ (!re.multiline || re.multiline && prevChar !== '\n' && prevChar !== '\r' && prevChar !== '\u2028' && prevChar !== '\u2029')) {
5777
+ source = '(?: (?:' + source + '))';
5778
+ strCopy = ' ' + strCopy;
5779
+ charsAdded++;
5941
5780
  }
5942
- if (sticky) state.sticky = true;
5943
- if (groups.length) state.groups = groups;
5781
+ // ^(? + rx + ) is needed, in combination with some str slicing, to
5782
+ // simulate the 'y' flag.
5783
+ reCopy = new RegExp('^(?:' + source + ')', flags);
5944
5784
  }
5945
5785
 
5946
- if (pattern !== rawPattern) try {
5947
- // fails in old engines, but we have no alternatives for unsupported regex syntax
5948
- createNonEnumerableProperty$3(result, 'source', rawPattern === '' ? '(?:)' : rawPattern);
5949
- } catch (error) { /* empty */ }
5950
-
5951
- return result;
5952
- };
5786
+ if (NPCG_INCLUDED) {
5787
+ reCopy = new RegExp('^' + source + '$(?!\\s)', flags);
5788
+ }
5789
+ if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
5953
5790
 
5954
- for (var keys$1 = getOwnPropertyNames$1(NativeRegExp), index = 0; keys$1.length > index;) {
5955
- proxyAccessor(RegExpWrapper, NativeRegExp, keys$1[index++]);
5956
- }
5957
-
5958
- RegExpPrototype$3.constructor = RegExpWrapper;
5959
- RegExpWrapper.prototype = RegExpPrototype$3;
5960
- defineBuiltIn$3(globalThis$d, 'RegExp', RegExpWrapper, { constructor: true });
5961
- }
5962
-
5963
- // https://tc39.es/ecma262/#sec-get-regexp-@@species
5964
- setSpecies$1('RegExp');
5965
-
5966
- var DESCRIPTORS$2 = descriptors;
5967
- var UNSUPPORTED_DOT_ALL$1 = regexpUnsupportedDotAll;
5968
- var classof$6 = classofRaw$2;
5969
- var defineBuiltInAccessor$2 = defineBuiltInAccessor$8;
5970
- var getInternalState$3 = internalState.get;
5971
-
5972
- var RegExpPrototype$2 = RegExp.prototype;
5973
- var $TypeError$9 = TypeError;
5974
-
5975
- // `RegExp.prototype.dotAll` getter
5976
- // https://tc39.es/ecma262/#sec-get-regexp.prototype.dotall
5977
- if (DESCRIPTORS$2 && UNSUPPORTED_DOT_ALL$1) {
5978
- defineBuiltInAccessor$2(RegExpPrototype$2, 'dotAll', {
5979
- configurable: true,
5980
- get: function dotAll() {
5981
- if (this === RegExpPrototype$2) return;
5982
- // We can't use InternalStateModule.getterFor because
5983
- // we don't add metadata for regexps created by a literal.
5984
- if (classof$6(this) === 'RegExp') {
5985
- return !!getInternalState$3(this).dotAll;
5986
- }
5987
- throw new $TypeError$9('Incompatible receiver, RegExp required');
5988
- }
5989
- });
5990
- }
5991
-
5992
- /* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
5993
- /* eslint-disable regexp/no-useless-quantifier -- testing */
5994
- var call$d = functionCall;
5995
- var uncurryThis$h = functionUncurryThis;
5996
- var toString$8 = toString$g;
5997
- var regexpFlags = regexpFlags$1;
5998
- var stickyHelpers = regexpStickyHelpers;
5999
- var shared = shared$4;
6000
- var create$1 = objectCreate;
6001
- var getInternalState$2 = internalState.get;
6002
- var UNSUPPORTED_DOT_ALL = regexpUnsupportedDotAll;
6003
- var UNSUPPORTED_NCG = regexpUnsupportedNcg;
6004
-
6005
- var nativeReplace = shared('native-string-replace', String.prototype.replace);
6006
- var nativeExec = RegExp.prototype.exec;
6007
- var patchedExec = nativeExec;
6008
- var charAt$4 = uncurryThis$h(''.charAt);
6009
- var indexOf = uncurryThis$h(''.indexOf);
6010
- var replace$2 = uncurryThis$h(''.replace);
6011
- var stringSlice$5 = uncurryThis$h(''.slice);
6012
-
6013
- var UPDATES_LAST_INDEX_WRONG = (function () {
6014
- var re1 = /a/;
6015
- var re2 = /b*/g;
6016
- call$d(nativeExec, re1, 'a');
6017
- call$d(nativeExec, re2, 'a');
6018
- return re1.lastIndex !== 0 || re2.lastIndex !== 0;
6019
- })();
6020
-
6021
- var UNSUPPORTED_Y = stickyHelpers.BROKEN_CARET;
6022
-
6023
- // nonparticipating capturing group, copied from es5-shim's String#split patch.
6024
- var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
6025
-
6026
- var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
6027
-
6028
- var setGroups = function (re, groups) {
6029
- var object = re.groups = create$1(null);
6030
- for (var i = 0; i < groups.length; i++) {
6031
- var group = groups[i];
6032
- object[group[0]] = re[group[1]];
6033
- }
6034
- };
6035
-
6036
- if (PATCH) {
6037
- patchedExec = function exec(string) {
6038
- var re = this;
6039
- var state = getInternalState$2(re);
6040
- var str = toString$8(string);
6041
- var raw = state.raw;
6042
- var result, reCopy, lastIndex;
6043
-
6044
- if (raw) {
6045
- raw.lastIndex = re.lastIndex;
6046
- result = call$d(patchedExec, raw, str);
6047
- re.lastIndex = raw.lastIndex;
6048
-
6049
- if (result && state.groups) setGroups(result, state.groups);
6050
-
6051
- return result;
6052
- }
6053
-
6054
- var groups = state.groups;
6055
- var sticky = UNSUPPORTED_Y && re.sticky;
6056
- var flags = call$d(regexpFlags, re);
6057
- var source = re.source;
6058
- var charsAdded = 0;
6059
- var strCopy = str;
6060
-
6061
- if (sticky) {
6062
- flags = replace$2(flags, 'y', '');
6063
- if (indexOf(flags, 'g') === -1) {
6064
- flags += 'g';
6065
- }
6066
-
6067
- strCopy = stringSlice$5(str, re.lastIndex);
6068
- // Support anchored sticky behavior.
6069
- var prevChar = re.lastIndex > 0 && charAt$4(str, re.lastIndex - 1);
6070
- if (re.lastIndex > 0 &&
6071
- (!re.multiline || re.multiline && prevChar !== '\n' && prevChar !== '\r' && prevChar !== '\u2028' && prevChar !== '\u2029')) {
6072
- source = '(?: (?:' + source + '))';
6073
- strCopy = ' ' + strCopy;
6074
- charsAdded++;
6075
- }
6076
- // ^(? + rx + ) is needed, in combination with some str slicing, to
6077
- // simulate the 'y' flag.
6078
- reCopy = new RegExp('^(?:' + source + ')', flags);
6079
- }
6080
-
6081
- if (NPCG_INCLUDED) {
6082
- reCopy = new RegExp('^' + source + '$(?!\\s)', flags);
6083
- }
6084
- if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
6085
-
6086
- var match = call$d(nativeExec, sticky ? reCopy : re, strCopy);
5791
+ var match = call$e(nativeExec, sticky ? reCopy : re, strCopy);
6087
5792
 
6088
5793
  if (sticky) {
6089
5794
  if (match) {
6090
5795
  match.input = str;
6091
- match[0] = stringSlice$5(match[0], charsAdded);
5796
+ match[0] = stringSlice$6(match[0], charsAdded);
6092
5797
  match.index = re.lastIndex;
6093
5798
  re.lastIndex += match[0].length;
6094
5799
  } else re.lastIndex = 0;
@@ -6098,7 +5803,7 @@ if (PATCH) {
6098
5803
  if (NPCG_INCLUDED && match && match.length > 1) {
6099
5804
  // Fix browsers whose `exec` methods don't consistently return `undefined`
6100
5805
  // for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/
6101
- call$d(nativeReplace, match[0], reCopy, function () {
5806
+ call$e(nativeReplace, match[0], reCopy, function () {
6102
5807
  for (var i = 1; i < arguments.length - 2; i++) {
6103
5808
  if (arguments[i] === undefined) match[i] = undefined;
6104
5809
  }
@@ -6114,76 +5819,15 @@ if (PATCH) {
6114
5819
  var regexpExec$2 = patchedExec;
6115
5820
 
6116
5821
  var $$m = _export;
6117
- var exec = regexpExec$2;
5822
+ var exec$1 = regexpExec$2;
6118
5823
 
6119
5824
  // `RegExp.prototype.exec` method
6120
5825
  // https://tc39.es/ecma262/#sec-regexp.prototype.exec
6121
- $$m({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {
6122
- exec: exec
6123
- });
6124
-
6125
- // TODO: Remove from `core-js@4` since it's moved to entry points
6126
-
6127
- var $$l = _export;
6128
- var call$c = functionCall;
6129
- var isCallable$3 = isCallable$s;
6130
- var anObject$7 = anObject$p;
6131
- var toString$7 = toString$g;
6132
-
6133
- var DELEGATES_TO_EXEC = function () {
6134
- var execCalled = false;
6135
- var re = /[ac]/;
6136
- re.exec = function () {
6137
- execCalled = true;
6138
- return /./.exec.apply(this, arguments);
6139
- };
6140
- return re.test('abc') === true && execCalled;
6141
- }();
6142
-
6143
- var nativeTest = /./.test;
6144
-
6145
- // `RegExp.prototype.test` method
6146
- // https://tc39.es/ecma262/#sec-regexp.prototype.test
6147
- $$l({ target: 'RegExp', proto: true, forced: !DELEGATES_TO_EXEC }, {
6148
- test: function (S) {
6149
- var R = anObject$7(this);
6150
- var string = toString$7(S);
6151
- var exec = R.exec;
6152
- if (!isCallable$3(exec)) return call$c(nativeTest, R, string);
6153
- var result = call$c(exec, R, string);
6154
- if (result === null) return false;
6155
- anObject$7(result);
6156
- return true;
6157
- }
5826
+ $$m({ target: 'RegExp', proto: true, forced: /./.exec !== exec$1 }, {
5827
+ exec: exec$1
6158
5828
  });
6159
5829
 
6160
- var PROPER_FUNCTION_NAME$1 = functionName.PROPER;
6161
- var defineBuiltIn$2 = defineBuiltIn$a;
6162
- var anObject$6 = anObject$p;
6163
- var $toString = toString$g;
6164
- var fails$c = fails$E;
6165
- var getRegExpFlags$1 = regexpGetFlags;
6166
-
6167
- var TO_STRING = 'toString';
6168
- var RegExpPrototype$1 = RegExp.prototype;
6169
- var nativeToString = RegExpPrototype$1[TO_STRING];
6170
-
6171
- var NOT_GENERIC = fails$c(function () { return nativeToString.call({ source: 'a', flags: 'b' }) !== '/a/b'; });
6172
- // FF44- RegExp#toString has a wrong name
6173
- var INCORRECT_NAME = PROPER_FUNCTION_NAME$1 && nativeToString.name !== TO_STRING;
6174
-
6175
- // `RegExp.prototype.toString` method
6176
- // https://tc39.es/ecma262/#sec-regexp.prototype.tostring
6177
- if (NOT_GENERIC || INCORRECT_NAME) {
6178
- defineBuiltIn$2(RegExpPrototype$1, TO_STRING, function toString() {
6179
- var R = anObject$6(this);
6180
- var pattern = $toString(R.source);
6181
- var flags = $toString(getRegExpFlags$1(R));
6182
- return '/' + pattern + '/' + flags;
6183
- }, { unsafe: true });
6184
- }
6185
-
6186
- var uncurryThis$g = functionUncurryThis;
5830
+ var uncurryThis$h = functionUncurryThis;
6187
5831
 
6188
5832
  // eslint-disable-next-line es/no-set -- safe
6189
5833
  var SetPrototype$1 = Set.prototype;
@@ -6191,9 +5835,9 @@ var SetPrototype$1 = Set.prototype;
6191
5835
  var setHelpers = {
6192
5836
  // eslint-disable-next-line es/no-set -- safe
6193
5837
  Set: Set,
6194
- add: uncurryThis$g(SetPrototype$1.add),
6195
- has: uncurryThis$g(SetPrototype$1.has),
6196
- remove: uncurryThis$g(SetPrototype$1['delete']),
5838
+ add: uncurryThis$h(SetPrototype$1.add),
5839
+ has: uncurryThis$h(SetPrototype$1.has),
5840
+ remove: uncurryThis$h(SetPrototype$1['delete']),
6197
5841
  proto: SetPrototype$1
6198
5842
  };
6199
5843
 
@@ -6205,30 +5849,30 @@ var aSet$7 = function (it) {
6205
5849
  return it;
6206
5850
  };
6207
5851
 
6208
- var call$b = functionCall;
5852
+ var call$d = functionCall;
6209
5853
 
6210
5854
  var iterateSimple$7 = function (record, fn, ITERATOR_INSTEAD_OF_RECORD) {
6211
5855
  var iterator = ITERATOR_INSTEAD_OF_RECORD ? record : record.iterator;
6212
5856
  var next = record.next;
6213
5857
  var step, result;
6214
- while (!(step = call$b(next, iterator)).done) {
5858
+ while (!(step = call$d(next, iterator)).done) {
6215
5859
  result = fn(step.value);
6216
5860
  if (result !== undefined) return result;
6217
5861
  }
6218
5862
  };
6219
5863
 
6220
- var uncurryThis$f = functionUncurryThis;
5864
+ var uncurryThis$g = functionUncurryThis;
6221
5865
  var iterateSimple$6 = iterateSimple$7;
6222
5866
  var SetHelpers$5 = setHelpers;
6223
5867
 
6224
5868
  var Set$3 = SetHelpers$5.Set;
6225
5869
  var SetPrototype = SetHelpers$5.proto;
6226
- var forEach$1 = uncurryThis$f(SetPrototype.forEach);
6227
- var keys = uncurryThis$f(SetPrototype.keys);
6228
- var next = keys(new Set$3()).next;
5870
+ var forEach$1 = uncurryThis$g(SetPrototype.forEach);
5871
+ var keys$1 = uncurryThis$g(SetPrototype.keys);
5872
+ var next = keys$1(new Set$3()).next;
6229
5873
 
6230
5874
  var setIterate = function (set, fn, interruptible) {
6231
- return interruptible ? iterateSimple$6({ iterator: keys(set), next: next }, fn) : forEach$1(set, fn);
5875
+ return interruptible ? iterateSimple$6({ iterator: keys$1(set), next: next }, fn) : forEach$1(set, fn);
6232
5876
  };
6233
5877
 
6234
5878
  var SetHelpers$4 = setHelpers;
@@ -6253,14 +5897,14 @@ var setSize = uncurryThisAccessor(SetHelpers$3.proto, 'size', 'get') || function
6253
5897
  };
6254
5898
 
6255
5899
  var aCallable$8 = aCallable$l;
6256
- var anObject$5 = anObject$p;
6257
- var call$a = functionCall;
5900
+ var anObject$7 = anObject$p;
5901
+ var call$c = functionCall;
6258
5902
  var toIntegerOrInfinity$6 = toIntegerOrInfinity$b;
6259
5903
  var getIteratorDirect$3 = getIteratorDirect$8;
6260
5904
 
6261
5905
  var INVALID_SIZE = 'Invalid size';
6262
5906
  var $RangeError$4 = RangeError;
6263
- var $TypeError$8 = TypeError;
5907
+ var $TypeError$9 = TypeError;
6264
5908
  var max$1 = Math.max;
6265
5909
 
6266
5910
  var SetRecord = function (set, intSize) {
@@ -6272,21 +5916,21 @@ var SetRecord = function (set, intSize) {
6272
5916
 
6273
5917
  SetRecord.prototype = {
6274
5918
  getIterator: function () {
6275
- return getIteratorDirect$3(anObject$5(call$a(this.keys, this.set)));
5919
+ return getIteratorDirect$3(anObject$7(call$c(this.keys, this.set)));
6276
5920
  },
6277
5921
  includes: function (it) {
6278
- return call$a(this.has, this.set, it);
5922
+ return call$c(this.has, this.set, it);
6279
5923
  }
6280
5924
  };
6281
5925
 
6282
5926
  // `GetSetRecord` abstract operation
6283
5927
  // https://tc39.es/proposal-set-methods/#sec-getsetrecord
6284
5928
  var getSetRecord$7 = function (obj) {
6285
- anObject$5(obj);
5929
+ anObject$7(obj);
6286
5930
  var numSize = +obj.size;
6287
5931
  // NOTE: If size is undefined, then numSize will be NaN
6288
5932
  // eslint-disable-next-line no-self-compare -- NaN check
6289
- if (numSize !== numSize) throw new $TypeError$8(INVALID_SIZE);
5933
+ if (numSize !== numSize) throw new $TypeError$9(INVALID_SIZE);
6290
5934
  var intSize = toIntegerOrInfinity$6(numSize);
6291
5935
  if (intSize < 0) throw new $RangeError$4(INVALID_SIZE);
6292
5936
  return new SetRecord(obj, intSize);
@@ -6376,16 +6020,16 @@ var setMethodAcceptSetLike$7 = function (name, callback) {
6376
6020
  }
6377
6021
  };
6378
6022
 
6379
- var $$k = _export;
6023
+ var $$l = _export;
6380
6024
  var difference = setDifference;
6381
- var fails$b = fails$E;
6025
+ var fails$e = fails$E;
6382
6026
  var setMethodAcceptSetLike$6 = setMethodAcceptSetLike$7;
6383
6027
 
6384
6028
  var SET_LIKE_INCORRECT_BEHAVIOR = !setMethodAcceptSetLike$6('difference', function (result) {
6385
6029
  return result.size === 0;
6386
6030
  });
6387
6031
 
6388
- var FORCED$5 = SET_LIKE_INCORRECT_BEHAVIOR || fails$b(function () {
6032
+ var FORCED$5 = SET_LIKE_INCORRECT_BEHAVIOR || fails$e(function () {
6389
6033
  // https://bugs.webkit.org/show_bug.cgi?id=288595
6390
6034
  var setLike = {
6391
6035
  size: 1,
@@ -6409,7 +6053,7 @@ var FORCED$5 = SET_LIKE_INCORRECT_BEHAVIOR || fails$b(function () {
6409
6053
 
6410
6054
  // `Set.prototype.difference` method
6411
6055
  // https://tc39.es/ecma262/#sec-set.prototype.difference
6412
- $$k({ target: 'Set', proto: true, real: true, forced: FORCED$5 }, {
6056
+ $$l({ target: 'Set', proto: true, real: true, forced: FORCED$5 }, {
6413
6057
  difference: difference
6414
6058
  });
6415
6059
 
@@ -6444,21 +6088,21 @@ var setIntersection = function intersection(other) {
6444
6088
  return result;
6445
6089
  };
6446
6090
 
6447
- var $$j = _export;
6448
- var fails$a = fails$E;
6091
+ var $$k = _export;
6092
+ var fails$d = fails$E;
6449
6093
  var intersection = setIntersection;
6450
6094
  var setMethodAcceptSetLike$5 = setMethodAcceptSetLike$7;
6451
6095
 
6452
6096
  var INCORRECT$3 = !setMethodAcceptSetLike$5('intersection', function (result) {
6453
6097
  return result.size === 2 && result.has(1) && result.has(2);
6454
- }) || fails$a(function () {
6098
+ }) || fails$d(function () {
6455
6099
  // eslint-disable-next-line es/no-array-from, es/no-set, es/no-set-prototype-intersection -- testing
6456
6100
  return String(Array.from(new Set([1, 2, 3]).intersection(new Set([3, 2])))) !== '3,2';
6457
6101
  });
6458
6102
 
6459
6103
  // `Set.prototype.intersection` method
6460
6104
  // https://tc39.es/ecma262/#sec-set.prototype.intersection
6461
- $$j({ target: 'Set', proto: true, real: true, forced: INCORRECT$3 }, {
6105
+ $$k({ target: 'Set', proto: true, real: true, forced: INCORRECT$3 }, {
6462
6106
  intersection: intersection
6463
6107
  });
6464
6108
 
@@ -6484,7 +6128,7 @@ var setIsDisjointFrom = function isDisjointFrom(other) {
6484
6128
  }) !== false;
6485
6129
  };
6486
6130
 
6487
- var $$i = _export;
6131
+ var $$j = _export;
6488
6132
  var isDisjointFrom = setIsDisjointFrom;
6489
6133
  var setMethodAcceptSetLike$4 = setMethodAcceptSetLike$7;
6490
6134
 
@@ -6494,7 +6138,7 @@ var INCORRECT$2 = !setMethodAcceptSetLike$4('isDisjointFrom', function (result)
6494
6138
 
6495
6139
  // `Set.prototype.isDisjointFrom` method
6496
6140
  // https://tc39.es/ecma262/#sec-set.prototype.isdisjointfrom
6497
- $$i({ target: 'Set', proto: true, real: true, forced: INCORRECT$2 }, {
6141
+ $$j({ target: 'Set', proto: true, real: true, forced: INCORRECT$2 }, {
6498
6142
  isDisjointFrom: isDisjointFrom
6499
6143
  });
6500
6144
 
@@ -6514,7 +6158,7 @@ var setIsSubsetOf = function isSubsetOf(other) {
6514
6158
  }, true) !== false;
6515
6159
  };
6516
6160
 
6517
- var $$h = _export;
6161
+ var $$i = _export;
6518
6162
  var isSubsetOf = setIsSubsetOf;
6519
6163
  var setMethodAcceptSetLike$3 = setMethodAcceptSetLike$7;
6520
6164
 
@@ -6524,7 +6168,7 @@ var INCORRECT$1 = !setMethodAcceptSetLike$3('isSubsetOf', function (result) {
6524
6168
 
6525
6169
  // `Set.prototype.isSubsetOf` method
6526
6170
  // https://tc39.es/ecma262/#sec-set.prototype.issubsetof
6527
- $$h({ target: 'Set', proto: true, real: true, forced: INCORRECT$1 }, {
6171
+ $$i({ target: 'Set', proto: true, real: true, forced: INCORRECT$1 }, {
6528
6172
  isSubsetOf: isSubsetOf
6529
6173
  });
6530
6174
 
@@ -6547,7 +6191,7 @@ var setIsSupersetOf = function isSupersetOf(other) {
6547
6191
  }) !== false;
6548
6192
  };
6549
6193
 
6550
- var $$g = _export;
6194
+ var $$h = _export;
6551
6195
  var isSupersetOf = setIsSupersetOf;
6552
6196
  var setMethodAcceptSetLike$2 = setMethodAcceptSetLike$7;
6553
6197
 
@@ -6557,7 +6201,7 @@ var INCORRECT = !setMethodAcceptSetLike$2('isSupersetOf', function (result) {
6557
6201
 
6558
6202
  // `Set.prototype.isSupersetOf` method
6559
6203
  // https://tc39.es/ecma262/#sec-set.prototype.issupersetof
6560
- $$g({ target: 'Set', proto: true, real: true, forced: INCORRECT }, {
6204
+ $$h({ target: 'Set', proto: true, real: true, forced: INCORRECT }, {
6561
6205
  isSupersetOf: isSupersetOf
6562
6206
  });
6563
6207
 
@@ -6614,7 +6258,7 @@ var setMethodGetKeysBeforeCloningDetection = function (METHOD_NAME) {
6614
6258
  }
6615
6259
  };
6616
6260
 
6617
- var $$f = _export;
6261
+ var $$g = _export;
6618
6262
  var symmetricDifference = setSymmetricDifference;
6619
6263
  var setMethodGetKeysBeforeCloning$1 = setMethodGetKeysBeforeCloningDetection;
6620
6264
  var setMethodAcceptSetLike$1 = setMethodAcceptSetLike$7;
@@ -6623,7 +6267,7 @@ var FORCED$4 = !setMethodAcceptSetLike$1('symmetricDifference') || !setMethodGet
6623
6267
 
6624
6268
  // `Set.prototype.symmetricDifference` method
6625
6269
  // https://tc39.es/ecma262/#sec-set.prototype.symmetricdifference
6626
- $$f({ target: 'Set', proto: true, real: true, forced: FORCED$4 }, {
6270
+ $$g({ target: 'Set', proto: true, real: true, forced: FORCED$4 }, {
6627
6271
  symmetricDifference: symmetricDifference
6628
6272
  });
6629
6273
 
@@ -6645,7 +6289,7 @@ var setUnion = function union(other) {
6645
6289
  return result;
6646
6290
  };
6647
6291
 
6648
- var $$e = _export;
6292
+ var $$f = _export;
6649
6293
  var union = setUnion;
6650
6294
  var setMethodGetKeysBeforeCloning = setMethodGetKeysBeforeCloningDetection;
6651
6295
  var setMethodAcceptSetLike = setMethodAcceptSetLike$7;
@@ -6654,26 +6298,26 @@ var FORCED$3 = !setMethodAcceptSetLike('union') || !setMethodGetKeysBeforeClonin
6654
6298
 
6655
6299
  // `Set.prototype.union` method
6656
6300
  // https://tc39.es/ecma262/#sec-set.prototype.union
6657
- $$e({ target: 'Set', proto: true, real: true, forced: FORCED$3 }, {
6301
+ $$f({ target: 'Set', proto: true, real: true, forced: FORCED$3 }, {
6658
6302
  union: union
6659
6303
  });
6660
6304
 
6661
6305
  // TODO: Remove from `core-js@4` since it's moved to entry points
6662
6306
 
6663
- var call$9 = functionCall;
6664
- var defineBuiltIn$1 = defineBuiltIn$a;
6307
+ var call$b = functionCall;
6308
+ var defineBuiltIn$3 = defineBuiltIn$a;
6665
6309
  var regexpExec$1 = regexpExec$2;
6666
- var fails$9 = fails$E;
6667
- var wellKnownSymbol$3 = wellKnownSymbol$n;
6668
- var createNonEnumerableProperty$2 = createNonEnumerableProperty$d;
6310
+ var fails$c = fails$E;
6311
+ var wellKnownSymbol$4 = wellKnownSymbol$n;
6312
+ var createNonEnumerableProperty$3 = createNonEnumerableProperty$d;
6669
6313
 
6670
- var SPECIES$1 = wellKnownSymbol$3('species');
6671
- var RegExpPrototype = RegExp.prototype;
6314
+ var SPECIES$1 = wellKnownSymbol$4('species');
6315
+ var RegExpPrototype$4 = RegExp.prototype;
6672
6316
 
6673
6317
  var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
6674
- var SYMBOL = wellKnownSymbol$3(KEY);
6318
+ var SYMBOL = wellKnownSymbol$4(KEY);
6675
6319
 
6676
- var DELEGATES_TO_SYMBOL = !fails$9(function () {
6320
+ var DELEGATES_TO_SYMBOL = !fails$c(function () {
6677
6321
  // String methods call symbol-named RegExp methods
6678
6322
  var O = {};
6679
6323
  // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation
@@ -6681,7 +6325,7 @@ var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
6681
6325
  return ''[KEY](O) !== 7;
6682
6326
  });
6683
6327
 
6684
- var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$9(function () {
6328
+ var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$c(function () {
6685
6329
  // Symbol-named RegExp methods call .exec
6686
6330
  var execCalled = false;
6687
6331
  var re = /a/;
@@ -6717,37 +6361,37 @@ var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
6717
6361
  var nativeRegExpMethod = /./[SYMBOL];
6718
6362
  var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
6719
6363
  var $exec = regexp.exec;
6720
- if ($exec === regexpExec$1 || $exec === RegExpPrototype.exec) {
6364
+ if ($exec === regexpExec$1 || $exec === RegExpPrototype$4.exec) {
6721
6365
  if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
6722
6366
  // The native String method already delegates to @@method (this
6723
6367
  // polyfilled function), leasing to infinite recursion.
6724
6368
  // We avoid it by directly calling the native @@method method.
6725
- return { done: true, value: call$9(nativeRegExpMethod, regexp, str, arg2) };
6369
+ return { done: true, value: call$b(nativeRegExpMethod, regexp, str, arg2) };
6726
6370
  }
6727
- return { done: true, value: call$9(nativeMethod, str, regexp, arg2) };
6371
+ return { done: true, value: call$b(nativeMethod, str, regexp, arg2) };
6728
6372
  }
6729
6373
  return { done: false };
6730
6374
  });
6731
6375
 
6732
- defineBuiltIn$1(String.prototype, KEY, methods[0]);
6733
- defineBuiltIn$1(RegExpPrototype, SYMBOL, methods[1]);
6376
+ defineBuiltIn$3(String.prototype, KEY, methods[0]);
6377
+ defineBuiltIn$3(RegExpPrototype$4, SYMBOL, methods[1]);
6734
6378
  }
6735
6379
 
6736
- if (SHAM) createNonEnumerableProperty$2(RegExpPrototype[SYMBOL], 'sham', true);
6380
+ if (SHAM) createNonEnumerableProperty$3(RegExpPrototype$4[SYMBOL], 'sham', true);
6737
6381
  };
6738
6382
 
6739
- var uncurryThis$e = functionUncurryThis;
6383
+ var uncurryThis$f = functionUncurryThis;
6740
6384
  var toIntegerOrInfinity$5 = toIntegerOrInfinity$b;
6741
- var toString$6 = toString$g;
6385
+ var toString$8 = toString$g;
6742
6386
  var requireObjectCoercible$5 = requireObjectCoercible$b;
6743
6387
 
6744
- var charAt$3 = uncurryThis$e(''.charAt);
6745
- var charCodeAt = uncurryThis$e(''.charCodeAt);
6746
- var stringSlice$4 = uncurryThis$e(''.slice);
6388
+ var charAt$4 = uncurryThis$f(''.charAt);
6389
+ var charCodeAt = uncurryThis$f(''.charCodeAt);
6390
+ var stringSlice$5 = uncurryThis$f(''.slice);
6747
6391
 
6748
6392
  var createMethod$4 = function (CONVERT_TO_STRING) {
6749
6393
  return function ($this, pos) {
6750
- var S = toString$6(requireObjectCoercible$5($this));
6394
+ var S = toString$8(requireObjectCoercible$5($this));
6751
6395
  var position = toIntegerOrInfinity$5(pos);
6752
6396
  var size = S.length;
6753
6397
  var first, second;
@@ -6756,10 +6400,10 @@ var createMethod$4 = function (CONVERT_TO_STRING) {
6756
6400
  return first < 0xD800 || first > 0xDBFF || position + 1 === size
6757
6401
  || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF
6758
6402
  ? CONVERT_TO_STRING
6759
- ? charAt$3(S, position)
6403
+ ? charAt$4(S, position)
6760
6404
  : first
6761
6405
  : CONVERT_TO_STRING
6762
- ? stringSlice$4(S, position, position + 2)
6406
+ ? stringSlice$5(S, position, position + 2)
6763
6407
  : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
6764
6408
  };
6765
6409
  };
@@ -6770,21 +6414,21 @@ var stringMultibyte = {
6770
6414
  charAt: createMethod$4(true)
6771
6415
  };
6772
6416
 
6773
- var charAt$2 = stringMultibyte.charAt;
6417
+ var charAt$3 = stringMultibyte.charAt;
6774
6418
 
6775
6419
  // `AdvanceStringIndex` abstract operation
6776
6420
  // https://tc39.es/ecma262/#sec-advancestringindex
6777
6421
  var advanceStringIndex$1 = function (S, index, unicode) {
6778
- return index + (unicode ? charAt$2(S, index).length || 1 : 1);
6422
+ return index + (unicode ? charAt$3(S, index).length || 1 : 1);
6779
6423
  };
6780
6424
 
6781
- var uncurryThis$d = functionUncurryThis;
6425
+ var uncurryThis$e = functionUncurryThis;
6782
6426
  var toObject$5 = toObject$a;
6783
6427
 
6784
6428
  var floor$4 = Math.floor;
6785
- var charAt$1 = uncurryThis$d(''.charAt);
6786
- var replace$1 = uncurryThis$d(''.replace);
6787
- var stringSlice$3 = uncurryThis$d(''.slice);
6429
+ var charAt$2 = uncurryThis$e(''.charAt);
6430
+ var replace$2 = uncurryThis$e(''.replace);
6431
+ var stringSlice$4 = uncurryThis$e(''.slice);
6788
6432
  // eslint-disable-next-line redos/no-vulnerable -- safe
6789
6433
  var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
6790
6434
  var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
@@ -6799,15 +6443,15 @@ var getSubstitution$1 = function (matched, str, position, captures, namedCapture
6799
6443
  namedCaptures = toObject$5(namedCaptures);
6800
6444
  symbols = SUBSTITUTION_SYMBOLS;
6801
6445
  }
6802
- return replace$1(replacement, symbols, function (match, ch) {
6446
+ return replace$2(replacement, symbols, function (match, ch) {
6803
6447
  var capture;
6804
- switch (charAt$1(ch, 0)) {
6448
+ switch (charAt$2(ch, 0)) {
6805
6449
  case '$': return '$';
6806
6450
  case '&': return matched;
6807
- case '`': return stringSlice$3(str, 0, position);
6808
- case "'": return stringSlice$3(str, tailPos);
6451
+ case '`': return stringSlice$4(str, 0, position);
6452
+ case "'": return stringSlice$4(str, tailPos);
6809
6453
  case '<':
6810
- capture = namedCaptures[stringSlice$3(ch, 1, -1)];
6454
+ capture = namedCaptures[stringSlice$4(ch, 1, -1)];
6811
6455
  break;
6812
6456
  default: // \d\d?
6813
6457
  var n = +ch;
@@ -6815,7 +6459,7 @@ var getSubstitution$1 = function (matched, str, position, captures, namedCapture
6815
6459
  if (n > m) {
6816
6460
  var f = floor$4(n / 10);
6817
6461
  if (f === 0) return match;
6818
- if (f <= m) return captures[f - 1] === undefined ? charAt$1(ch, 1) : captures[f - 1] + charAt$1(ch, 1);
6462
+ if (f <= m) return captures[f - 1] === undefined ? charAt$2(ch, 1) : captures[f - 1] + charAt$2(ch, 1);
6819
6463
  return match;
6820
6464
  }
6821
6465
  capture = captures[n - 1];
@@ -6824,60 +6468,123 @@ var getSubstitution$1 = function (matched, str, position, captures, namedCapture
6824
6468
  });
6825
6469
  };
6826
6470
 
6827
- var call$8 = functionCall;
6828
- var anObject$4 = anObject$p;
6829
- var isCallable$2 = isCallable$s;
6830
- var classof$5 = classofRaw$2;
6831
- var regexpExec = regexpExec$2;
6471
+ var globalThis$e = globalThis_1;
6472
+ var fails$b = fails$E;
6832
6473
 
6833
- var $TypeError$7 = TypeError;
6474
+ // babel-minify and Closure Compiler transpiles RegExp('.', 'd') -> /./d and it causes SyntaxError
6475
+ var RegExp$1 = globalThis$e.RegExp;
6834
6476
 
6835
- // `RegExpExec` abstract operation
6836
- // https://tc39.es/ecma262/#sec-regexpexec
6837
- var regexpExecAbstract = function (R, S) {
6838
- var exec = R.exec;
6839
- if (isCallable$2(exec)) {
6840
- var result = call$8(exec, R, S);
6841
- if (result !== null) anObject$4(result);
6842
- return result;
6477
+ var FLAGS_GETTER_IS_CORRECT = !fails$b(function () {
6478
+ var INDICES_SUPPORT = true;
6479
+ try {
6480
+ RegExp$1('.', 'd');
6481
+ } catch (error) {
6482
+ INDICES_SUPPORT = false;
6843
6483
  }
6844
- if (classof$5(R) === 'RegExp') return call$8(regexpExec, R, S);
6845
- throw new $TypeError$7('RegExp#exec called on incompatible receiver');
6846
- };
6847
-
6848
- var apply$1 = functionApply;
6849
- var call$7 = functionCall;
6850
- var uncurryThis$c = functionUncurryThis;
6851
- var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic;
6852
- var fails$8 = fails$E;
6853
- var anObject$3 = anObject$p;
6854
- var isCallable$1 = isCallable$s;
6855
- var isObject$5 = isObject$l;
6856
- var toIntegerOrInfinity$4 = toIntegerOrInfinity$b;
6857
- var toLength$2 = toLength$7;
6858
- var toString$5 = toString$g;
6859
- var requireObjectCoercible$4 = requireObjectCoercible$b;
6860
- var advanceStringIndex = advanceStringIndex$1;
6861
- var getMethod = getMethod$5;
6862
- var getSubstitution = getSubstitution$1;
6863
- var getRegExpFlags = regexpGetFlags;
6864
- var regExpExec = regexpExecAbstract;
6865
- var wellKnownSymbol$2 = wellKnownSymbol$n;
6866
6484
 
6867
- var REPLACE = wellKnownSymbol$2('replace');
6868
- var max = Math.max;
6869
- var min$2 = Math.min;
6870
- var concat = uncurryThis$c([].concat);
6871
- var push$1 = uncurryThis$c([].push);
6872
- var stringIndexOf = uncurryThis$c(''.indexOf);
6873
- var stringSlice$2 = uncurryThis$c(''.slice);
6485
+ var O = {};
6486
+ // modern V8 bug
6487
+ var calls = '';
6488
+ var expected = INDICES_SUPPORT ? 'dgimsy' : 'gimsy';
6874
6489
 
6875
- var maybeToString = function (it) {
6876
- return it === undefined ? it : String(it);
6877
- };
6490
+ var addGetter = function (key, chr) {
6491
+ // eslint-disable-next-line es/no-object-defineproperty -- safe
6492
+ Object.defineProperty(O, key, { get: function () {
6493
+ calls += chr;
6494
+ return true;
6495
+ } });
6496
+ };
6878
6497
 
6879
- // IE <= 11 replaces $0 with the whole match, as if it was $&
6880
- // https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0
6498
+ var pairs = {
6499
+ dotAll: 's',
6500
+ global: 'g',
6501
+ ignoreCase: 'i',
6502
+ multiline: 'm',
6503
+ sticky: 'y'
6504
+ };
6505
+
6506
+ if (INDICES_SUPPORT) pairs.hasIndices = 'd';
6507
+
6508
+ for (var key in pairs) addGetter(key, pairs[key]);
6509
+
6510
+ // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
6511
+ var result = Object.getOwnPropertyDescriptor(RegExp$1.prototype, 'flags').get.call(O);
6512
+
6513
+ return result !== expected || calls !== expected;
6514
+ });
6515
+
6516
+ var regexpFlagsDetection = { correct: FLAGS_GETTER_IS_CORRECT };
6517
+
6518
+ var call$a = functionCall;
6519
+ var hasOwn$4 = hasOwnProperty_1;
6520
+ var isPrototypeOf$3 = objectIsPrototypeOf;
6521
+ var regExpFlagsDetection = regexpFlagsDetection;
6522
+ var regExpFlagsGetterImplementation = regexpFlags$1;
6523
+
6524
+ var RegExpPrototype$3 = RegExp.prototype;
6525
+
6526
+ var regexpGetFlags = regExpFlagsDetection.correct ? function (it) {
6527
+ return it.flags;
6528
+ } : function (it) {
6529
+ return (!regExpFlagsDetection.correct && isPrototypeOf$3(RegExpPrototype$3, it) && !hasOwn$4(it, 'flags'))
6530
+ ? call$a(regExpFlagsGetterImplementation, it)
6531
+ : it.flags;
6532
+ };
6533
+
6534
+ var call$9 = functionCall;
6535
+ var anObject$6 = anObject$p;
6536
+ var isCallable$3 = isCallable$s;
6537
+ var classof$6 = classofRaw$2;
6538
+ var regexpExec = regexpExec$2;
6539
+
6540
+ var $TypeError$8 = TypeError;
6541
+
6542
+ // `RegExpExec` abstract operation
6543
+ // https://tc39.es/ecma262/#sec-regexpexec
6544
+ var regexpExecAbstract = function (R, S) {
6545
+ var exec = R.exec;
6546
+ if (isCallable$3(exec)) {
6547
+ var result = call$9(exec, R, S);
6548
+ if (result !== null) anObject$6(result);
6549
+ return result;
6550
+ }
6551
+ if (classof$6(R) === 'RegExp') return call$9(regexpExec, R, S);
6552
+ throw new $TypeError$8('RegExp#exec called on incompatible receiver');
6553
+ };
6554
+
6555
+ var apply$1 = functionApply;
6556
+ var call$8 = functionCall;
6557
+ var uncurryThis$d = functionUncurryThis;
6558
+ var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic;
6559
+ var fails$a = fails$E;
6560
+ var anObject$5 = anObject$p;
6561
+ var isCallable$2 = isCallable$s;
6562
+ var isObject$5 = isObject$l;
6563
+ var toIntegerOrInfinity$4 = toIntegerOrInfinity$b;
6564
+ var toLength$2 = toLength$7;
6565
+ var toString$7 = toString$g;
6566
+ var requireObjectCoercible$4 = requireObjectCoercible$b;
6567
+ var advanceStringIndex = advanceStringIndex$1;
6568
+ var getMethod = getMethod$5;
6569
+ var getSubstitution = getSubstitution$1;
6570
+ var getRegExpFlags$2 = regexpGetFlags;
6571
+ var regExpExec = regexpExecAbstract;
6572
+ var wellKnownSymbol$3 = wellKnownSymbol$n;
6573
+
6574
+ var REPLACE = wellKnownSymbol$3('replace');
6575
+ var max = Math.max;
6576
+ var min$2 = Math.min;
6577
+ var concat = uncurryThis$d([].concat);
6578
+ var push$1 = uncurryThis$d([].push);
6579
+ var stringIndexOf$1 = uncurryThis$d(''.indexOf);
6580
+ var stringSlice$3 = uncurryThis$d(''.slice);
6581
+
6582
+ var maybeToString = function (it) {
6583
+ return it === undefined ? it : String(it);
6584
+ };
6585
+
6586
+ // IE <= 11 replaces $0 with the whole match, as if it was $&
6587
+ // https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0
6881
6588
  var REPLACE_KEEPS_$0 = (function () {
6882
6589
  // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing
6883
6590
  return 'a'.replace(/./, '$0') === '$0';
@@ -6891,7 +6598,7 @@ var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {
6891
6598
  return false;
6892
6599
  })();
6893
6600
 
6894
- var REPLACE_SUPPORTS_NAMED_GROUPS = !fails$8(function () {
6601
+ var REPLACE_SUPPORTS_NAMED_GROUPS = !fails$a(function () {
6895
6602
  var re = /./;
6896
6603
  re.exec = function () {
6897
6604
  var result = [];
@@ -6913,33 +6620,33 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
6913
6620
  var O = requireObjectCoercible$4(this);
6914
6621
  var replacer = isObject$5(searchValue) ? getMethod(searchValue, REPLACE) : undefined;
6915
6622
  return replacer
6916
- ? call$7(replacer, searchValue, O, replaceValue)
6917
- : call$7(nativeReplace, toString$5(O), searchValue, replaceValue);
6623
+ ? call$8(replacer, searchValue, O, replaceValue)
6624
+ : call$8(nativeReplace, toString$7(O), searchValue, replaceValue);
6918
6625
  },
6919
6626
  // `RegExp.prototype[@@replace]` method
6920
6627
  // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
6921
6628
  function (string, replaceValue) {
6922
- var rx = anObject$3(this);
6923
- var S = toString$5(string);
6629
+ var rx = anObject$5(this);
6630
+ var S = toString$7(string);
6924
6631
 
6925
- var functionalReplace = isCallable$1(replaceValue);
6926
- if (!functionalReplace) replaceValue = toString$5(replaceValue);
6927
- var flags = toString$5(getRegExpFlags(rx));
6632
+ var functionalReplace = isCallable$2(replaceValue);
6633
+ if (!functionalReplace) replaceValue = toString$7(replaceValue);
6634
+ var flags = toString$7(getRegExpFlags$2(rx));
6928
6635
 
6929
6636
  if (
6930
6637
  typeof replaceValue == 'string' &&
6931
- !~stringIndexOf(replaceValue, UNSAFE_SUBSTITUTE) &&
6932
- !~stringIndexOf(replaceValue, '$<') &&
6933
- !~stringIndexOf(flags, 'y')
6638
+ !~stringIndexOf$1(replaceValue, UNSAFE_SUBSTITUTE) &&
6639
+ !~stringIndexOf$1(replaceValue, '$<') &&
6640
+ !~stringIndexOf$1(flags, 'y')
6934
6641
  ) {
6935
6642
  var res = maybeCallNative(nativeReplace, rx, S, replaceValue);
6936
6643
  if (res.done) return res.value;
6937
6644
  }
6938
6645
 
6939
- var global = !!~stringIndexOf(flags, 'g');
6646
+ var global = !!~stringIndexOf$1(flags, 'g');
6940
6647
  var fullUnicode;
6941
6648
  if (global) {
6942
- fullUnicode = !!~stringIndexOf(flags, 'u') || !!~stringIndexOf(flags, 'v');
6649
+ fullUnicode = !!~stringIndexOf$1(flags, 'u') || !!~stringIndexOf$1(flags, 'v');
6943
6650
  rx.lastIndex = 0;
6944
6651
  }
6945
6652
 
@@ -6952,7 +6659,7 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
6952
6659
  push$1(results, result);
6953
6660
  if (!global) break;
6954
6661
 
6955
- var matchStr = toString$5(result[0]);
6662
+ var matchStr = toString$7(result[0]);
6956
6663
  if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength$2(rx.lastIndex), fullUnicode);
6957
6664
  }
6958
6665
 
@@ -6961,7 +6668,7 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
6961
6668
  for (var i = 0; i < results.length; i++) {
6962
6669
  result = results[i];
6963
6670
 
6964
- var matched = toString$5(result[0]);
6671
+ var matched = toString$7(result[0]);
6965
6672
  var position = max(min$2(toIntegerOrInfinity$4(result.index), S.length), 0);
6966
6673
  var captures = [];
6967
6674
  var replacement;
@@ -6975,17 +6682,17 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
6975
6682
  if (functionalReplace) {
6976
6683
  var replacerArgs = concat([matched], captures, position, S);
6977
6684
  if (namedCaptures !== undefined) push$1(replacerArgs, namedCaptures);
6978
- replacement = toString$5(apply$1(replaceValue, undefined, replacerArgs));
6685
+ replacement = toString$7(apply$1(replaceValue, undefined, replacerArgs));
6979
6686
  } else {
6980
6687
  replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
6981
6688
  }
6982
6689
  if (position >= nextSourcePosition) {
6983
- accumulatedResult += stringSlice$2(S, nextSourcePosition, position) + replacement;
6690
+ accumulatedResult += stringSlice$3(S, nextSourcePosition, position) + replacement;
6984
6691
  nextSourcePosition = position + matched.length;
6985
6692
  }
6986
6693
  }
6987
6694
 
6988
- return accumulatedResult + stringSlice$2(S, nextSourcePosition);
6695
+ return accumulatedResult + stringSlice$3(S, nextSourcePosition);
6989
6696
  }
6990
6697
  ];
6991
6698
  }, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
@@ -6993,39 +6700,39 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
6993
6700
  var typedArrayConstructor = {exports: {}};
6994
6701
 
6995
6702
  var NATIVE_ARRAY_BUFFER = arrayBufferBasicDetection;
6996
- var DESCRIPTORS$1 = descriptors;
6997
- var globalThis$c = globalThis_1;
6998
- var isCallable = isCallable$s;
6703
+ var DESCRIPTORS$3 = descriptors;
6704
+ var globalThis$d = globalThis_1;
6705
+ var isCallable$1 = isCallable$s;
6999
6706
  var isObject$4 = isObject$l;
7000
- var hasOwn$2 = hasOwnProperty_1;
7001
- var classof$4 = classof$f;
6707
+ var hasOwn$3 = hasOwnProperty_1;
6708
+ var classof$5 = classof$f;
7002
6709
  var tryToString$1 = tryToString$6;
7003
- var createNonEnumerableProperty$1 = createNonEnumerableProperty$d;
7004
- var defineBuiltIn = defineBuiltIn$a;
7005
- var defineBuiltInAccessor$1 = defineBuiltInAccessor$8;
7006
- var isPrototypeOf$1 = objectIsPrototypeOf;
6710
+ var createNonEnumerableProperty$2 = createNonEnumerableProperty$d;
6711
+ var defineBuiltIn$2 = defineBuiltIn$a;
6712
+ var defineBuiltInAccessor$2 = defineBuiltInAccessor$8;
6713
+ var isPrototypeOf$2 = objectIsPrototypeOf;
7007
6714
  var getPrototypeOf = objectGetPrototypeOf;
7008
6715
  var setPrototypeOf$1 = objectSetPrototypeOf;
7009
- var wellKnownSymbol$1 = wellKnownSymbol$n;
6716
+ var wellKnownSymbol$2 = wellKnownSymbol$n;
7010
6717
  var uid = uid$4;
7011
6718
  var InternalStateModule$1 = internalState;
7012
6719
 
7013
- var enforceInternalState$1 = InternalStateModule$1.enforce;
7014
- var getInternalState$1 = InternalStateModule$1.get;
7015
- var Int8Array$4 = globalThis$c.Int8Array;
6720
+ var enforceInternalState$2 = InternalStateModule$1.enforce;
6721
+ var getInternalState$2 = InternalStateModule$1.get;
6722
+ var Int8Array$4 = globalThis$d.Int8Array;
7016
6723
  var Int8ArrayPrototype$1 = Int8Array$4 && Int8Array$4.prototype;
7017
- var Uint8ClampedArray$1 = globalThis$c.Uint8ClampedArray;
6724
+ var Uint8ClampedArray$1 = globalThis$d.Uint8ClampedArray;
7018
6725
  var Uint8ClampedArrayPrototype = Uint8ClampedArray$1 && Uint8ClampedArray$1.prototype;
7019
6726
  var TypedArray$1 = Int8Array$4 && getPrototypeOf(Int8Array$4);
7020
6727
  var TypedArrayPrototype$1 = Int8ArrayPrototype$1 && getPrototypeOf(Int8ArrayPrototype$1);
7021
6728
  var ObjectPrototype = Object.prototype;
7022
- var TypeError$2 = globalThis$c.TypeError;
6729
+ var TypeError$2 = globalThis$d.TypeError;
7023
6730
 
7024
- var TO_STRING_TAG = wellKnownSymbol$1('toStringTag');
6731
+ var TO_STRING_TAG = wellKnownSymbol$2('toStringTag');
7025
6732
  var TYPED_ARRAY_TAG$1 = uid('TYPED_ARRAY_TAG');
7026
6733
  var TYPED_ARRAY_CONSTRUCTOR = 'TypedArrayConstructor';
7027
6734
  // Fixing native typed arrays in Opera Presto crashes the browser, see #595
7028
- var NATIVE_ARRAY_BUFFER_VIEWS$2 = NATIVE_ARRAY_BUFFER && !!setPrototypeOf$1 && classof$4(globalThis$c.opera) !== 'Opera';
6735
+ var NATIVE_ARRAY_BUFFER_VIEWS$2 = NATIVE_ARRAY_BUFFER && !!setPrototypeOf$1 && classof$5(globalThis$d.opera) !== 'Opera';
7029
6736
  var TYPED_ARRAY_TAG_REQUIRED = false;
7030
6737
  var NAME, Constructor, Prototype;
7031
6738
 
@@ -7049,15 +6756,15 @@ var BigIntArrayConstructorsList = {
7049
6756
  var getTypedArrayConstructor$3 = function (it) {
7050
6757
  var proto = getPrototypeOf(it);
7051
6758
  if (!isObject$4(proto)) return;
7052
- var state = getInternalState$1(proto);
7053
- return (state && hasOwn$2(state, TYPED_ARRAY_CONSTRUCTOR)) ? state[TYPED_ARRAY_CONSTRUCTOR] : getTypedArrayConstructor$3(proto);
6759
+ var state = getInternalState$2(proto);
6760
+ return (state && hasOwn$3(state, TYPED_ARRAY_CONSTRUCTOR)) ? state[TYPED_ARRAY_CONSTRUCTOR] : getTypedArrayConstructor$3(proto);
7054
6761
  };
7055
6762
 
7056
6763
  var isTypedArray$1 = function (it) {
7057
6764
  if (!isObject$4(it)) return false;
7058
- var klass = classof$4(it);
7059
- return hasOwn$2(TypedArrayConstructorsList, klass)
7060
- || hasOwn$2(BigIntArrayConstructorsList, klass);
6765
+ var klass = classof$5(it);
6766
+ return hasOwn$3(TypedArrayConstructorsList, klass)
6767
+ || hasOwn$3(BigIntArrayConstructorsList, klass);
7061
6768
  };
7062
6769
 
7063
6770
  var aTypedArray$a = function (it) {
@@ -7066,15 +6773,15 @@ var aTypedArray$a = function (it) {
7066
6773
  };
7067
6774
 
7068
6775
  var aTypedArrayConstructor$1 = function (C) {
7069
- if (isCallable(C) && (!setPrototypeOf$1 || isPrototypeOf$1(TypedArray$1, C))) return C;
6776
+ if (isCallable$1(C) && (!setPrototypeOf$1 || isPrototypeOf$2(TypedArray$1, C))) return C;
7070
6777
  throw new TypeError$2(tryToString$1(C) + ' is not a typed array constructor');
7071
6778
  };
7072
6779
 
7073
6780
  var exportTypedArrayMethod$a = function (KEY, property, forced, options) {
7074
- if (!DESCRIPTORS$1) return;
6781
+ if (!DESCRIPTORS$3) return;
7075
6782
  if (forced) for (var ARRAY in TypedArrayConstructorsList) {
7076
- var TypedArrayConstructor = globalThis$c[ARRAY];
7077
- if (TypedArrayConstructor && hasOwn$2(TypedArrayConstructor.prototype, KEY)) try {
6783
+ var TypedArrayConstructor = globalThis$d[ARRAY];
6784
+ if (TypedArrayConstructor && hasOwn$3(TypedArrayConstructor.prototype, KEY)) try {
7078
6785
  delete TypedArrayConstructor.prototype[KEY];
7079
6786
  } catch (error) {
7080
6787
  // old WebKit bug - some methods are non-configurable
@@ -7084,39 +6791,39 @@ var exportTypedArrayMethod$a = function (KEY, property, forced, options) {
7084
6791
  }
7085
6792
  }
7086
6793
  if (!TypedArrayPrototype$1[KEY] || forced) {
7087
- defineBuiltIn(TypedArrayPrototype$1, KEY, forced ? property
6794
+ defineBuiltIn$2(TypedArrayPrototype$1, KEY, forced ? property
7088
6795
  : NATIVE_ARRAY_BUFFER_VIEWS$2 && Int8ArrayPrototype$1[KEY] || property, options);
7089
6796
  }
7090
6797
  };
7091
6798
 
7092
6799
  for (NAME in TypedArrayConstructorsList) {
7093
- Constructor = globalThis$c[NAME];
6800
+ Constructor = globalThis$d[NAME];
7094
6801
  Prototype = Constructor && Constructor.prototype;
7095
- if (Prototype) enforceInternalState$1(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
6802
+ if (Prototype) enforceInternalState$2(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
7096
6803
  else NATIVE_ARRAY_BUFFER_VIEWS$2 = false;
7097
6804
  }
7098
6805
 
7099
6806
  for (NAME in BigIntArrayConstructorsList) {
7100
- Constructor = globalThis$c[NAME];
6807
+ Constructor = globalThis$d[NAME];
7101
6808
  Prototype = Constructor && Constructor.prototype;
7102
- if (Prototype) enforceInternalState$1(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
6809
+ if (Prototype) enforceInternalState$2(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
7103
6810
  }
7104
6811
 
7105
6812
  // WebKit bug - typed arrays constructors prototype is Object.prototype
7106
- if (!NATIVE_ARRAY_BUFFER_VIEWS$2 || !isCallable(TypedArray$1) || TypedArray$1 === Function.prototype) {
6813
+ if (!NATIVE_ARRAY_BUFFER_VIEWS$2 || !isCallable$1(TypedArray$1) || TypedArray$1 === Function.prototype) {
7107
6814
  // eslint-disable-next-line no-shadow -- safe
7108
6815
  TypedArray$1 = function TypedArray() {
7109
6816
  throw new TypeError$2('Incorrect invocation');
7110
6817
  };
7111
6818
  if (NATIVE_ARRAY_BUFFER_VIEWS$2) for (NAME in TypedArrayConstructorsList) {
7112
- if (globalThis$c[NAME]) setPrototypeOf$1(globalThis$c[NAME], TypedArray$1);
6819
+ if (globalThis$d[NAME]) setPrototypeOf$1(globalThis$d[NAME], TypedArray$1);
7113
6820
  }
7114
6821
  }
7115
6822
 
7116
6823
  if (!NATIVE_ARRAY_BUFFER_VIEWS$2 || !TypedArrayPrototype$1 || TypedArrayPrototype$1 === ObjectPrototype) {
7117
6824
  TypedArrayPrototype$1 = TypedArray$1.prototype;
7118
6825
  if (NATIVE_ARRAY_BUFFER_VIEWS$2) for (NAME in TypedArrayConstructorsList) {
7119
- if (globalThis$c[NAME]) setPrototypeOf$1(globalThis$c[NAME].prototype, TypedArrayPrototype$1);
6826
+ if (globalThis$d[NAME]) setPrototypeOf$1(globalThis$d[NAME].prototype, TypedArrayPrototype$1);
7120
6827
  }
7121
6828
  }
7122
6829
 
@@ -7125,16 +6832,16 @@ if (NATIVE_ARRAY_BUFFER_VIEWS$2 && getPrototypeOf(Uint8ClampedArrayPrototype) !=
7125
6832
  setPrototypeOf$1(Uint8ClampedArrayPrototype, TypedArrayPrototype$1);
7126
6833
  }
7127
6834
 
7128
- if (DESCRIPTORS$1 && !hasOwn$2(TypedArrayPrototype$1, TO_STRING_TAG)) {
6835
+ if (DESCRIPTORS$3 && !hasOwn$3(TypedArrayPrototype$1, TO_STRING_TAG)) {
7129
6836
  TYPED_ARRAY_TAG_REQUIRED = true;
7130
- defineBuiltInAccessor$1(TypedArrayPrototype$1, TO_STRING_TAG, {
6837
+ defineBuiltInAccessor$2(TypedArrayPrototype$1, TO_STRING_TAG, {
7131
6838
  configurable: true,
7132
6839
  get: function () {
7133
6840
  return isObject$4(this) ? this[TYPED_ARRAY_TAG$1] : undefined;
7134
6841
  }
7135
6842
  });
7136
- for (NAME in TypedArrayConstructorsList) if (globalThis$c[NAME]) {
7137
- createNonEnumerableProperty$1(globalThis$c[NAME].prototype, TYPED_ARRAY_TAG$1, NAME);
6843
+ for (NAME in TypedArrayConstructorsList) if (globalThis$d[NAME]) {
6844
+ createNonEnumerableProperty$2(globalThis$d[NAME].prototype, TYPED_ARRAY_TAG$1, NAME);
7138
6845
  }
7139
6846
  }
7140
6847
 
@@ -7151,24 +6858,24 @@ var arrayBufferViewCore = {
7151
6858
  };
7152
6859
 
7153
6860
  /* eslint-disable no-new, sonarjs/inconsistent-function-call -- required for testing */
7154
- var globalThis$b = globalThis_1;
7155
- var fails$7 = fails$E;
6861
+ var globalThis$c = globalThis_1;
6862
+ var fails$9 = fails$E;
7156
6863
  var checkCorrectnessOfIteration = checkCorrectnessOfIteration$2;
7157
6864
  var NATIVE_ARRAY_BUFFER_VIEWS$1 = arrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS;
7158
6865
 
7159
- var ArrayBuffer$2 = globalThis$b.ArrayBuffer;
7160
- var Int8Array$3 = globalThis$b.Int8Array;
6866
+ var ArrayBuffer$2 = globalThis$c.ArrayBuffer;
6867
+ var Int8Array$3 = globalThis$c.Int8Array;
7161
6868
 
7162
- var typedArrayConstructorsRequireWrappers = !NATIVE_ARRAY_BUFFER_VIEWS$1 || !fails$7(function () {
6869
+ var typedArrayConstructorsRequireWrappers = !NATIVE_ARRAY_BUFFER_VIEWS$1 || !fails$9(function () {
7163
6870
  Int8Array$3(1);
7164
- }) || !fails$7(function () {
6871
+ }) || !fails$9(function () {
7165
6872
  new Int8Array$3(-1);
7166
6873
  }) || !checkCorrectnessOfIteration(function (iterable) {
7167
6874
  new Int8Array$3();
7168
6875
  new Int8Array$3(null);
7169
6876
  new Int8Array$3(1.5);
7170
6877
  new Int8Array$3(iterable);
7171
- }, true) || fails$7(function () {
6878
+ }, true) || fails$9(function () {
7172
6879
  // Safari (11+) bug - a reason why even Safari 13 should load a typed array polyfill
7173
6880
  return new Int8Array$3(new ArrayBuffer$2(2), 1, undefined).length !== 1;
7174
6881
  });
@@ -7219,28 +6926,28 @@ var toUint8Clamped$1 = function (it) {
7219
6926
  return f % 2 === 0 ? f : f + 1;
7220
6927
  };
7221
6928
 
7222
- var classof$3 = classof$f;
6929
+ var classof$4 = classof$f;
7223
6930
 
7224
6931
  var isBigIntArray$2 = function (it) {
7225
- var klass = classof$3(it);
6932
+ var klass = classof$4(it);
7226
6933
  return klass === 'BigInt64Array' || klass === 'BigUint64Array';
7227
6934
  };
7228
6935
 
7229
6936
  var toPrimitive = toPrimitive$2;
7230
6937
 
7231
- var $TypeError$6 = TypeError;
6938
+ var $TypeError$7 = TypeError;
7232
6939
 
7233
6940
  // `ToBigInt` abstract operation
7234
6941
  // https://tc39.es/ecma262/#sec-tobigint
7235
6942
  var toBigInt$3 = function (argument) {
7236
6943
  var prim = toPrimitive(argument, 'number');
7237
- if (typeof prim == 'number') throw new $TypeError$6("Can't convert number to bigint");
6944
+ if (typeof prim == 'number') throw new $TypeError$7("Can't convert number to bigint");
7238
6945
  // eslint-disable-next-line es/no-bigint -- safe
7239
6946
  return BigInt(prim);
7240
6947
  };
7241
6948
 
7242
6949
  var bind$3 = functionBindContext;
7243
- var call$6 = functionCall;
6950
+ var call$7 = functionCall;
7244
6951
  var aCallable$7 = aCallable$l;
7245
6952
  var aConstructor = aConstructor$2;
7246
6953
  var toObject$4 = toObject$a;
@@ -7265,7 +6972,7 @@ var typedArrayFrom$1 = function from(source /* , mapfn, thisArg */) {
7265
6972
  iterator = getIterator(O, iteratorMethod);
7266
6973
  next = iterator.next;
7267
6974
  O = [];
7268
- while (!(step = call$6(next, iterator)).done) {
6975
+ while (!(step = call$7(next, iterator)).done) {
7269
6976
  O.push(step.value);
7270
6977
  }
7271
6978
  }
@@ -7286,9 +6993,9 @@ var typedArrayFrom$1 = function from(source /* , mapfn, thisArg */) {
7286
6993
  var isArray$1 = isArray$4;
7287
6994
  var isConstructor = isConstructor$2;
7288
6995
  var isObject$2 = isObject$l;
7289
- var wellKnownSymbol = wellKnownSymbol$n;
6996
+ var wellKnownSymbol$1 = wellKnownSymbol$n;
7290
6997
 
7291
- var SPECIES = wellKnownSymbol('species');
6998
+ var SPECIES = wellKnownSymbol$1('species');
7292
6999
  var $Array$1 = Array;
7293
7000
 
7294
7001
  // a part of `ArraySpeciesCreate` abstract operation
@@ -7374,45 +7081,45 @@ var arrayFromConstructorAndList$2 = function (Constructor, list, $length) {
7374
7081
  return result;
7375
7082
  };
7376
7083
 
7377
- var $$d = _export;
7378
- var globalThis$a = globalThis_1;
7379
- var call$5 = functionCall;
7380
- var DESCRIPTORS = descriptors;
7084
+ var $$e = _export;
7085
+ var globalThis$b = globalThis_1;
7086
+ var call$6 = functionCall;
7087
+ var DESCRIPTORS$2 = descriptors;
7381
7088
  var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = typedArrayConstructorsRequireWrappers;
7382
7089
  var ArrayBufferViewCore$a = arrayBufferViewCore;
7383
7090
  var ArrayBufferModule = arrayBuffer;
7384
7091
  var anInstance = anInstance$4;
7385
7092
  var createPropertyDescriptor = createPropertyDescriptor$6;
7386
- var createNonEnumerableProperty = createNonEnumerableProperty$d;
7093
+ var createNonEnumerableProperty$1 = createNonEnumerableProperty$d;
7387
7094
  var isIntegralNumber = isIntegralNumber$1;
7388
7095
  var toIndex = toIndex$3;
7389
7096
  var toOffset$1 = toOffset$2;
7390
7097
  var toUint8Clamped = toUint8Clamped$1;
7391
7098
  var toPropertyKey = toPropertyKey$3;
7392
- var hasOwn$1 = hasOwnProperty_1;
7393
- var classof$2 = classof$f;
7099
+ var hasOwn$2 = hasOwnProperty_1;
7100
+ var classof$3 = classof$f;
7394
7101
  var isObject$1 = isObject$l;
7395
7102
  var isSymbol = isSymbol$4;
7396
- var create = objectCreate;
7397
- var isPrototypeOf = objectIsPrototypeOf;
7103
+ var create$1 = objectCreate;
7104
+ var isPrototypeOf$1 = objectIsPrototypeOf;
7398
7105
  var setPrototypeOf = objectSetPrototypeOf;
7399
- var getOwnPropertyNames = objectGetOwnPropertyNames.f;
7106
+ var getOwnPropertyNames$1 = objectGetOwnPropertyNames.f;
7400
7107
  var typedArrayFrom = typedArrayFrom$1;
7401
7108
  var forEach = arrayIteration.forEach;
7402
- var setSpecies = setSpecies$4;
7403
- var defineBuiltInAccessor = defineBuiltInAccessor$8;
7109
+ var setSpecies$1 = setSpecies$4;
7110
+ var defineBuiltInAccessor$1 = defineBuiltInAccessor$8;
7404
7111
  var definePropertyModule = objectDefineProperty;
7405
7112
  var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
7406
7113
  var arrayFromConstructorAndList$1 = arrayFromConstructorAndList$2;
7407
7114
  var InternalStateModule = internalState;
7408
- var inheritIfRequired = inheritIfRequired$4;
7115
+ var inheritIfRequired$1 = inheritIfRequired$4;
7409
7116
 
7410
- var getInternalState = InternalStateModule.get;
7117
+ var getInternalState$1 = InternalStateModule.get;
7411
7118
  var setInternalState = InternalStateModule.set;
7412
- var enforceInternalState = InternalStateModule.enforce;
7119
+ var enforceInternalState$1 = InternalStateModule.enforce;
7413
7120
  var nativeDefineProperty = definePropertyModule.f;
7414
7121
  var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
7415
- var RangeError$2 = globalThis$a.RangeError;
7122
+ var RangeError$2 = globalThis$b.RangeError;
7416
7123
  var ArrayBuffer$1 = ArrayBufferModule.ArrayBuffer;
7417
7124
  var ArrayBufferPrototype = ArrayBuffer$1.prototype;
7418
7125
  var DataView$1 = ArrayBufferModule.DataView;
@@ -7425,17 +7132,17 @@ var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT';
7425
7132
  var WRONG_LENGTH = 'Wrong length';
7426
7133
 
7427
7134
  var addGetter = function (it, key) {
7428
- defineBuiltInAccessor(it, key, {
7135
+ defineBuiltInAccessor$1(it, key, {
7429
7136
  configurable: true,
7430
7137
  get: function () {
7431
- return getInternalState(this)[key];
7138
+ return getInternalState$1(this)[key];
7432
7139
  }
7433
7140
  });
7434
7141
  };
7435
7142
 
7436
7143
  var isArrayBuffer = function (it) {
7437
7144
  var klass;
7438
- return isPrototypeOf(ArrayBufferPrototype, it) || (klass = classof$2(it)) === 'ArrayBuffer' || klass === 'SharedArrayBuffer';
7145
+ return isPrototypeOf$1(ArrayBufferPrototype, it) || (klass = classof$3(it)) === 'ArrayBuffer' || klass === 'SharedArrayBuffer';
7439
7146
  };
7440
7147
 
7441
7148
  var isTypedArrayIndex = function (target, key) {
@@ -7457,20 +7164,20 @@ var wrappedDefineProperty = function defineProperty(target, key, descriptor) {
7457
7164
  key = toPropertyKey(key);
7458
7165
  if (isTypedArrayIndex(target, key)
7459
7166
  && isObject$1(descriptor)
7460
- && hasOwn$1(descriptor, 'value')
7461
- && !hasOwn$1(descriptor, 'get')
7462
- && !hasOwn$1(descriptor, 'set')
7167
+ && hasOwn$2(descriptor, 'value')
7168
+ && !hasOwn$2(descriptor, 'get')
7169
+ && !hasOwn$2(descriptor, 'set')
7463
7170
  // TODO: add validation descriptor w/o calling accessors
7464
7171
  && !descriptor.configurable
7465
- && (!hasOwn$1(descriptor, 'writable') || descriptor.writable)
7466
- && (!hasOwn$1(descriptor, 'enumerable') || descriptor.enumerable)
7172
+ && (!hasOwn$2(descriptor, 'writable') || descriptor.writable)
7173
+ && (!hasOwn$2(descriptor, 'enumerable') || descriptor.enumerable)
7467
7174
  ) {
7468
7175
  target[key] = descriptor.value;
7469
7176
  return target;
7470
7177
  } return nativeDefineProperty(target, key, descriptor);
7471
7178
  };
7472
7179
 
7473
- if (DESCRIPTORS) {
7180
+ if (DESCRIPTORS$2) {
7474
7181
  if (!NATIVE_ARRAY_BUFFER_VIEWS) {
7475
7182
  getOwnPropertyDescriptorModule.f = wrappedGetOwnPropertyDescriptor;
7476
7183
  definePropertyModule.f = wrappedDefineProperty;
@@ -7480,7 +7187,7 @@ if (DESCRIPTORS) {
7480
7187
  addGetter(TypedArrayPrototype, 'length');
7481
7188
  }
7482
7189
 
7483
- $$d({ target: 'Object', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, {
7190
+ $$e({ target: 'Object', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, {
7484
7191
  getOwnPropertyDescriptor: wrappedGetOwnPropertyDescriptor,
7485
7192
  defineProperty: wrappedDefineProperty
7486
7193
  });
@@ -7490,18 +7197,18 @@ if (DESCRIPTORS) {
7490
7197
  var CONSTRUCTOR_NAME = TYPE + (CLAMPED ? 'Clamped' : '') + 'Array';
7491
7198
  var GETTER = 'get' + TYPE;
7492
7199
  var SETTER = 'set' + TYPE;
7493
- var NativeTypedArrayConstructor = globalThis$a[CONSTRUCTOR_NAME];
7200
+ var NativeTypedArrayConstructor = globalThis$b[CONSTRUCTOR_NAME];
7494
7201
  var TypedArrayConstructor = NativeTypedArrayConstructor;
7495
7202
  var TypedArrayConstructorPrototype = TypedArrayConstructor && TypedArrayConstructor.prototype;
7496
7203
  var exported = {};
7497
7204
 
7498
7205
  var getter = function (that, index) {
7499
- var data = getInternalState(that);
7206
+ var data = getInternalState$1(that);
7500
7207
  return data.view[GETTER](index * BYTES + data.byteOffset, true);
7501
7208
  };
7502
7209
 
7503
7210
  var setter = function (that, index, value) {
7504
- var data = getInternalState(that);
7211
+ var data = getInternalState$1(that);
7505
7212
  data.view[SETTER](index * BYTES + data.byteOffset, CLAMPED ? toUint8Clamped(value) : value, true);
7506
7213
  };
7507
7214
 
@@ -7543,7 +7250,7 @@ if (DESCRIPTORS) {
7543
7250
  } else if (isTypedArray(data)) {
7544
7251
  return arrayFromConstructorAndList$1(TypedArrayConstructor, data);
7545
7252
  } else {
7546
- return call$5(typedArrayFrom, TypedArrayConstructor, data);
7253
+ return call$6(typedArrayFrom, TypedArrayConstructor, data);
7547
7254
  }
7548
7255
  setInternalState(that, {
7549
7256
  buffer: buffer,
@@ -7556,11 +7263,11 @@ if (DESCRIPTORS) {
7556
7263
  });
7557
7264
 
7558
7265
  if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray);
7559
- TypedArrayConstructorPrototype = TypedArrayConstructor.prototype = create(TypedArrayPrototype);
7266
+ TypedArrayConstructorPrototype = TypedArrayConstructor.prototype = create$1(TypedArrayPrototype);
7560
7267
  } else if (TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS) {
7561
7268
  TypedArrayConstructor = wrapper(function (dummy, data, typedArrayOffset, $length) {
7562
7269
  anInstance(dummy, TypedArrayConstructorPrototype);
7563
- return inheritIfRequired(function () {
7270
+ return inheritIfRequired$1(function () {
7564
7271
  if (!isObject$1(data)) return new NativeTypedArrayConstructor(toIndex(data));
7565
7272
  if (isArrayBuffer(data)) return $length !== undefined
7566
7273
  ? new NativeTypedArrayConstructor(data, toOffset$1(typedArrayOffset, BYTES), $length)
@@ -7568,44 +7275,44 @@ if (DESCRIPTORS) {
7568
7275
  ? new NativeTypedArrayConstructor(data, toOffset$1(typedArrayOffset, BYTES))
7569
7276
  : new NativeTypedArrayConstructor(data);
7570
7277
  if (isTypedArray(data)) return arrayFromConstructorAndList$1(TypedArrayConstructor, data);
7571
- return call$5(typedArrayFrom, TypedArrayConstructor, data);
7278
+ return call$6(typedArrayFrom, TypedArrayConstructor, data);
7572
7279
  }(), dummy, TypedArrayConstructor);
7573
7280
  });
7574
7281
 
7575
7282
  if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray);
7576
- forEach(getOwnPropertyNames(NativeTypedArrayConstructor), function (key) {
7283
+ forEach(getOwnPropertyNames$1(NativeTypedArrayConstructor), function (key) {
7577
7284
  if (!(key in TypedArrayConstructor)) {
7578
- createNonEnumerableProperty(TypedArrayConstructor, key, NativeTypedArrayConstructor[key]);
7285
+ createNonEnumerableProperty$1(TypedArrayConstructor, key, NativeTypedArrayConstructor[key]);
7579
7286
  }
7580
7287
  });
7581
7288
  TypedArrayConstructor.prototype = TypedArrayConstructorPrototype;
7582
7289
  }
7583
7290
 
7584
7291
  if (TypedArrayConstructorPrototype.constructor !== TypedArrayConstructor) {
7585
- createNonEnumerableProperty(TypedArrayConstructorPrototype, 'constructor', TypedArrayConstructor);
7292
+ createNonEnumerableProperty$1(TypedArrayConstructorPrototype, 'constructor', TypedArrayConstructor);
7586
7293
  }
7587
7294
 
7588
- enforceInternalState(TypedArrayConstructorPrototype).TypedArrayConstructor = TypedArrayConstructor;
7295
+ enforceInternalState$1(TypedArrayConstructorPrototype).TypedArrayConstructor = TypedArrayConstructor;
7589
7296
 
7590
7297
  if (TYPED_ARRAY_TAG) {
7591
- createNonEnumerableProperty(TypedArrayConstructorPrototype, TYPED_ARRAY_TAG, CONSTRUCTOR_NAME);
7298
+ createNonEnumerableProperty$1(TypedArrayConstructorPrototype, TYPED_ARRAY_TAG, CONSTRUCTOR_NAME);
7592
7299
  }
7593
7300
 
7594
7301
  var FORCED = TypedArrayConstructor !== NativeTypedArrayConstructor;
7595
7302
 
7596
7303
  exported[CONSTRUCTOR_NAME] = TypedArrayConstructor;
7597
7304
 
7598
- $$d({ global: true, constructor: true, forced: FORCED, sham: !NATIVE_ARRAY_BUFFER_VIEWS }, exported);
7305
+ $$e({ global: true, constructor: true, forced: FORCED, sham: !NATIVE_ARRAY_BUFFER_VIEWS }, exported);
7599
7306
 
7600
7307
  if (!(BYTES_PER_ELEMENT in TypedArrayConstructor)) {
7601
- createNonEnumerableProperty(TypedArrayConstructor, BYTES_PER_ELEMENT, BYTES);
7308
+ createNonEnumerableProperty$1(TypedArrayConstructor, BYTES_PER_ELEMENT, BYTES);
7602
7309
  }
7603
7310
 
7604
7311
  if (!(BYTES_PER_ELEMENT in TypedArrayConstructorPrototype)) {
7605
- createNonEnumerableProperty(TypedArrayConstructorPrototype, BYTES_PER_ELEMENT, BYTES);
7312
+ createNonEnumerableProperty$1(TypedArrayConstructorPrototype, BYTES_PER_ELEMENT, BYTES);
7606
7313
  }
7607
7314
 
7608
- setSpecies(CONSTRUCTOR_NAME);
7315
+ setSpecies$1(CONSTRUCTOR_NAME);
7609
7316
  };
7610
7317
  } else typedArrayConstructor.exports = function () { /* empty */ };
7611
7318
 
@@ -7641,17 +7348,17 @@ exportTypedArrayMethod$9('at', function at(index) {
7641
7348
  var ArrayBufferViewCore$8 = arrayBufferViewCore;
7642
7349
  var $fill = arrayFill$1;
7643
7350
  var toBigInt$1 = toBigInt$3;
7644
- var classof$1 = classof$f;
7645
- var call$4 = functionCall;
7646
- var uncurryThis$b = functionUncurryThis;
7647
- var fails$6 = fails$E;
7351
+ var classof$2 = classof$f;
7352
+ var call$5 = functionCall;
7353
+ var uncurryThis$c = functionUncurryThis;
7354
+ var fails$8 = fails$E;
7648
7355
 
7649
7356
  var aTypedArray$8 = ArrayBufferViewCore$8.aTypedArray;
7650
7357
  var exportTypedArrayMethod$8 = ArrayBufferViewCore$8.exportTypedArrayMethod;
7651
- var slice = uncurryThis$b(''.slice);
7358
+ var slice = uncurryThis$c(''.slice);
7652
7359
 
7653
7360
  // V8 ~ Chrome < 59, Safari < 14.1, FF < 55, Edge <=18
7654
- var CONVERSION_BUG = fails$6(function () {
7361
+ var CONVERSION_BUG = fails$8(function () {
7655
7362
  var count = 0;
7656
7363
  // eslint-disable-next-line es/no-typed-arrays -- safe
7657
7364
  new Int8Array(2).fill({ valueOf: function () { return count++; } });
@@ -7663,8 +7370,8 @@ var CONVERSION_BUG = fails$6(function () {
7663
7370
  exportTypedArrayMethod$8('fill', function fill(value /* , start, end */) {
7664
7371
  var length = arguments.length;
7665
7372
  aTypedArray$8(this);
7666
- var actualValue = slice(classof$1(this), 0, 3) === 'Big' ? toBigInt$1(value) : +value;
7667
- return call$4($fill, this, actualValue, length > 1 ? arguments[1] : undefined, length > 2 ? arguments[2] : undefined);
7373
+ var actualValue = slice(classof$2(this), 0, 3) === 'Big' ? toBigInt$1(value) : +value;
7374
+ return call$5($fill, this, actualValue, length > 1 ? arguments[1] : undefined, length > 2 ? arguments[2] : undefined);
7668
7375
  }, CONVERSION_BUG);
7669
7376
 
7670
7377
  var bind$1 = functionBindContext;
@@ -7726,30 +7433,30 @@ exportTypedArrayMethod$6('findLastIndex', function findLastIndex(predicate /* ,
7726
7433
  return $findLastIndex(aTypedArray$6(this), predicate, arguments.length > 1 ? arguments[1] : undefined);
7727
7434
  });
7728
7435
 
7729
- var globalThis$9 = globalThis_1;
7730
- var call$3 = functionCall;
7436
+ var globalThis$a = globalThis_1;
7437
+ var call$4 = functionCall;
7731
7438
  var ArrayBufferViewCore$5 = arrayBufferViewCore;
7732
7439
  var lengthOfArrayLike$5 = lengthOfArrayLike$f;
7733
7440
  var toOffset = toOffset$2;
7734
7441
  var toIndexedObject = toObject$a;
7735
- var fails$5 = fails$E;
7442
+ var fails$7 = fails$E;
7736
7443
 
7737
- var RangeError$1 = globalThis$9.RangeError;
7738
- var Int8Array$2 = globalThis$9.Int8Array;
7444
+ var RangeError$1 = globalThis$a.RangeError;
7445
+ var Int8Array$2 = globalThis$a.Int8Array;
7739
7446
  var Int8ArrayPrototype = Int8Array$2 && Int8Array$2.prototype;
7740
7447
  var $set = Int8ArrayPrototype && Int8ArrayPrototype.set;
7741
7448
  var aTypedArray$5 = ArrayBufferViewCore$5.aTypedArray;
7742
7449
  var exportTypedArrayMethod$5 = ArrayBufferViewCore$5.exportTypedArrayMethod;
7743
7450
 
7744
- var WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS = !fails$5(function () {
7451
+ var WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS = !fails$7(function () {
7745
7452
  // eslint-disable-next-line es/no-typed-arrays -- required for testing
7746
7453
  var array = new Uint8ClampedArray(2);
7747
- call$3($set, array, { length: 1, 0: 3 }, 1);
7454
+ call$4($set, array, { length: 1, 0: 3 }, 1);
7748
7455
  return array[1] !== 3;
7749
7456
  });
7750
7457
 
7751
7458
  // https://bugs.chromium.org/p/v8/issues/detail?id=11294 and other
7752
- var TO_OBJECT_BUG = WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS && ArrayBufferViewCore$5.NATIVE_ARRAY_BUFFER_VIEWS && fails$5(function () {
7459
+ var TO_OBJECT_BUG = WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS && ArrayBufferViewCore$5.NATIVE_ARRAY_BUFFER_VIEWS && fails$7(function () {
7753
7460
  var array = new Int8Array$2(2);
7754
7461
  array.set(1);
7755
7462
  array.set('2', 1);
@@ -7762,7 +7469,7 @@ exportTypedArrayMethod$5('set', function set(arrayLike /* , offset */) {
7762
7469
  aTypedArray$5(this);
7763
7470
  var offset = toOffset(arguments.length > 1 ? arguments[1] : undefined, 1);
7764
7471
  var src = toIndexedObject(arrayLike);
7765
- if (WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS) return call$3($set, this, src, offset);
7472
+ if (WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS) return call$4($set, this, src, offset);
7766
7473
  var length = this.length;
7767
7474
  var len = lengthOfArrayLike$5(src);
7768
7475
  var index = 0;
@@ -7828,9 +7535,9 @@ var webkit = userAgent$1.match(/AppleWebKit\/(\d+)\./);
7828
7535
 
7829
7536
  var environmentWebkitVersion = !!webkit && +webkit[1];
7830
7537
 
7831
- var globalThis$8 = globalThis_1;
7832
- var uncurryThis$a = functionUncurryThisClause;
7833
- var fails$4 = fails$E;
7538
+ var globalThis$9 = globalThis_1;
7539
+ var uncurryThis$b = functionUncurryThisClause;
7540
+ var fails$6 = fails$E;
7834
7541
  var aCallable$6 = aCallable$l;
7835
7542
  var internalSort$1 = arraySort;
7836
7543
  var ArrayBufferViewCore$4 = arrayBufferViewCore;
@@ -7841,17 +7548,17 @@ var WEBKIT$1 = environmentWebkitVersion;
7841
7548
 
7842
7549
  var aTypedArray$4 = ArrayBufferViewCore$4.aTypedArray;
7843
7550
  var exportTypedArrayMethod$4 = ArrayBufferViewCore$4.exportTypedArrayMethod;
7844
- var Uint16Array = globalThis$8.Uint16Array;
7845
- var nativeSort$1 = Uint16Array && uncurryThis$a(Uint16Array.prototype.sort);
7551
+ var Uint16Array = globalThis$9.Uint16Array;
7552
+ var nativeSort$1 = Uint16Array && uncurryThis$b(Uint16Array.prototype.sort);
7846
7553
 
7847
7554
  // WebKit
7848
- var ACCEPT_INCORRECT_ARGUMENTS = !!nativeSort$1 && !(fails$4(function () {
7555
+ var ACCEPT_INCORRECT_ARGUMENTS = !!nativeSort$1 && !(fails$6(function () {
7849
7556
  nativeSort$1(new Uint16Array(2), null);
7850
- }) && fails$4(function () {
7557
+ }) && fails$6(function () {
7851
7558
  nativeSort$1(new Uint16Array(2), {});
7852
7559
  }));
7853
7560
 
7854
- var STABLE_SORT$1 = !!nativeSort$1 && !fails$4(function () {
7561
+ var STABLE_SORT$1 = !!nativeSort$1 && !fails$6(function () {
7855
7562
  // feature detection can be too slow, so check engines versions
7856
7563
  if (V8$1) return V8$1 < 74;
7857
7564
  if (FF$1) return FF$1 < 67;
@@ -7898,25 +7605,25 @@ exportTypedArrayMethod$4('sort', function sort(comparefn) {
7898
7605
  return internalSort$1(aTypedArray$4(this), getSortCompare$1(comparefn));
7899
7606
  }, !STABLE_SORT$1 || ACCEPT_INCORRECT_ARGUMENTS);
7900
7607
 
7901
- var globalThis$7 = globalThis_1;
7608
+ var globalThis$8 = globalThis_1;
7902
7609
  var apply = functionApply;
7903
7610
  var ArrayBufferViewCore$3 = arrayBufferViewCore;
7904
- var fails$3 = fails$E;
7611
+ var fails$5 = fails$E;
7905
7612
  var arraySlice = arraySlice$5;
7906
7613
 
7907
- var Int8Array$1 = globalThis$7.Int8Array;
7614
+ var Int8Array$1 = globalThis$8.Int8Array;
7908
7615
  var aTypedArray$3 = ArrayBufferViewCore$3.aTypedArray;
7909
7616
  var exportTypedArrayMethod$3 = ArrayBufferViewCore$3.exportTypedArrayMethod;
7910
7617
  var $toLocaleString = [].toLocaleString;
7911
7618
 
7912
7619
  // iOS Safari 6.x fails here
7913
- var TO_LOCALE_STRING_BUG = !!Int8Array$1 && fails$3(function () {
7620
+ var TO_LOCALE_STRING_BUG = !!Int8Array$1 && fails$5(function () {
7914
7621
  $toLocaleString.call(new Int8Array$1(1));
7915
7622
  });
7916
7623
 
7917
- var FORCED$2 = fails$3(function () {
7624
+ var FORCED$2 = fails$5(function () {
7918
7625
  return [1, 2].toLocaleString() !== new Int8Array$1([1, 2]).toLocaleString();
7919
- }) || !fails$3(function () {
7626
+ }) || !fails$5(function () {
7920
7627
  Int8Array$1.prototype.toLocaleString.call([1, 2]);
7921
7628
  });
7922
7629
 
@@ -7949,14 +7656,14 @@ exportTypedArrayMethod$2('toReversed', function toReversed() {
7949
7656
  });
7950
7657
 
7951
7658
  var ArrayBufferViewCore$1 = arrayBufferViewCore;
7952
- var uncurryThis$9 = functionUncurryThis;
7659
+ var uncurryThis$a = functionUncurryThis;
7953
7660
  var aCallable$5 = aCallable$l;
7954
7661
  var arrayFromConstructorAndList = arrayFromConstructorAndList$2;
7955
7662
 
7956
7663
  var aTypedArray$1 = ArrayBufferViewCore$1.aTypedArray;
7957
7664
  var getTypedArrayConstructor$1 = ArrayBufferViewCore$1.getTypedArrayConstructor;
7958
7665
  var exportTypedArrayMethod$1 = ArrayBufferViewCore$1.exportTypedArrayMethod;
7959
- var sort = uncurryThis$9(ArrayBufferViewCore$1.TypedArrayPrototype.sort);
7666
+ var sort = uncurryThis$a(ArrayBufferViewCore$1.TypedArrayPrototype.sort);
7960
7667
 
7961
7668
  // `%TypedArray%.prototype.toSorted` method
7962
7669
  // https://tc39.es/ecma262/#sec-%typedarray%.prototype.tosorted
@@ -8018,18 +7725,18 @@ exportTypedArrayMethod('with', { 'with': function (index, value) {
8018
7725
  var isObject = isObject$l;
8019
7726
 
8020
7727
  var $String = String;
8021
- var $TypeError$5 = TypeError;
7728
+ var $TypeError$6 = TypeError;
8022
7729
 
8023
7730
  var anObjectOrUndefined$2 = function (argument) {
8024
7731
  if (argument === undefined || isObject(argument)) return argument;
8025
- throw new $TypeError$5($String(argument) + ' is not an object or undefined');
7732
+ throw new $TypeError$6($String(argument) + ' is not an object or undefined');
8026
7733
  };
8027
7734
 
8028
- var $TypeError$4 = TypeError;
7735
+ var $TypeError$5 = TypeError;
8029
7736
 
8030
7737
  var aString$2 = function (argument) {
8031
7738
  if (typeof argument == 'string') return argument;
8032
- throw new $TypeError$4('Argument is not a string');
7739
+ throw new $TypeError$5('Argument is not a string');
8033
7740
  };
8034
7741
 
8035
7742
  var commonAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
@@ -8051,19 +7758,19 @@ var base64Map$2 = {
8051
7758
  c2iUrl: inverse(base64UrlAlphabet$2)
8052
7759
  };
8053
7760
 
8054
- var $TypeError$3 = TypeError;
7761
+ var $TypeError$4 = TypeError;
8055
7762
 
8056
7763
  var getAlphabetOption$2 = function (options) {
8057
7764
  var alphabet = options && options.alphabet;
8058
7765
  if (alphabet === undefined || alphabet === 'base64' || alphabet === 'base64url') return alphabet || 'base64';
8059
- throw new $TypeError$3('Incorrect `alphabet` option');
7766
+ throw new $TypeError$4('Incorrect `alphabet` option');
8060
7767
  };
8061
7768
 
8062
- var globalThis$6 = globalThis_1;
8063
- var uncurryThis$8 = functionUncurryThis;
7769
+ var globalThis$7 = globalThis_1;
7770
+ var uncurryThis$9 = functionUncurryThis;
8064
7771
  var anObjectOrUndefined$1 = anObjectOrUndefined$2;
8065
7772
  var aString$1 = aString$2;
8066
- var hasOwn = hasOwnProperty_1;
7773
+ var hasOwn$1 = hasOwnProperty_1;
8067
7774
  var base64Map$1 = base64Map$2;
8068
7775
  var getAlphabetOption$1 = getAlphabetOption$2;
8069
7776
  var notDetached$3 = arrayBufferNotDetached;
@@ -8071,9 +7778,9 @@ var notDetached$3 = arrayBufferNotDetached;
8071
7778
  var base64Alphabet$1 = base64Map$1.c2i;
8072
7779
  var base64UrlAlphabet$1 = base64Map$1.c2iUrl;
8073
7780
 
8074
- var SyntaxError$2 = globalThis$6.SyntaxError;
8075
- var TypeError$1 = globalThis$6.TypeError;
8076
- var at = uncurryThis$8(''.charAt);
7781
+ var SyntaxError$3 = globalThis$7.SyntaxError;
7782
+ var TypeError$1 = globalThis$7.TypeError;
7783
+ var at = uncurryThis$9(''.charAt);
8077
7784
 
8078
7785
  var skipAsciiWhitespace = function (string, index) {
8079
7786
  var length = string.length;
@@ -8103,14 +7810,14 @@ var decodeBase64Chunk = function (chunk, alphabet, throwOnExtraBits) {
8103
7810
 
8104
7811
  if (chunkLength === 2) {
8105
7812
  if (throwOnExtraBits && chunkBytes[1] !== 0) {
8106
- throw new SyntaxError$2('Extra bits');
7813
+ throw new SyntaxError$3('Extra bits');
8107
7814
  }
8108
7815
  return [chunkBytes[0]];
8109
7816
  }
8110
7817
 
8111
7818
  if (chunkLength === 3) {
8112
7819
  if (throwOnExtraBits && chunkBytes[2] !== 0) {
8113
- throw new SyntaxError$2('Extra bits');
7820
+ throw new SyntaxError$3('Extra bits');
8114
7821
  }
8115
7822
  return [chunkBytes[0], chunkBytes[1]];
8116
7823
  }
@@ -8157,11 +7864,11 @@ var uint8FromBase64 = function (string, options, into, maxLength) {
8157
7864
  }
8158
7865
  if (lastChunkHandling === 'loose') {
8159
7866
  if (chunk.length === 1) {
8160
- throw new SyntaxError$2('Malformed padding: exactly one additional character');
7867
+ throw new SyntaxError$3('Malformed padding: exactly one additional character');
8161
7868
  }
8162
7869
  written = writeBytes(bytes, decodeBase64Chunk(chunk, alphabet, false), written);
8163
7870
  } else {
8164
- throw new SyntaxError$2('Missing padding');
7871
+ throw new SyntaxError$3('Missing padding');
8165
7872
  }
8166
7873
  }
8167
7874
  read = stringLength;
@@ -8171,7 +7878,7 @@ var uint8FromBase64 = function (string, options, into, maxLength) {
8171
7878
  ++index;
8172
7879
  if (chr === '=') {
8173
7880
  if (chunk.length < 2) {
8174
- throw new SyntaxError$2('Padding is too early');
7881
+ throw new SyntaxError$3('Padding is too early');
8175
7882
  }
8176
7883
  index = skipAsciiWhitespace(string, index);
8177
7884
  if (chunk.length === 2) {
@@ -8179,7 +7886,7 @@ var uint8FromBase64 = function (string, options, into, maxLength) {
8179
7886
  if (lastChunkHandling === 'stop-before-partial') {
8180
7887
  break;
8181
7888
  }
8182
- throw new SyntaxError$2('Malformed padding: only one =');
7889
+ throw new SyntaxError$3('Malformed padding: only one =');
8183
7890
  }
8184
7891
  if (at(string, index) === '=') {
8185
7892
  ++index;
@@ -8187,14 +7894,14 @@ var uint8FromBase64 = function (string, options, into, maxLength) {
8187
7894
  }
8188
7895
  }
8189
7896
  if (index < stringLength) {
8190
- throw new SyntaxError$2('Unexpected character after padding');
7897
+ throw new SyntaxError$3('Unexpected character after padding');
8191
7898
  }
8192
7899
  written = writeBytes(bytes, decodeBase64Chunk(chunk, alphabet, lastChunkHandling === 'strict'), written);
8193
7900
  read = stringLength;
8194
7901
  break;
8195
7902
  }
8196
- if (!hasOwn(alphabet, chr)) {
8197
- throw new SyntaxError$2('Unexpected character');
7903
+ if (!hasOwn$1(alphabet, chr)) {
7904
+ throw new SyntaxError$3('Unexpected character');
8198
7905
  }
8199
7906
  var remainingBytes = maxLength - written;
8200
7907
  if (remainingBytes === 1 && chunk.length === 2 || remainingBytes === 2 && chunk.length === 3) {
@@ -8216,23 +7923,23 @@ var uint8FromBase64 = function (string, options, into, maxLength) {
8216
7923
  return { bytes: bytes, read: read, written: written };
8217
7924
  };
8218
7925
 
8219
- var classof = classof$f;
7926
+ var classof$1 = classof$f;
8220
7927
 
8221
- var $TypeError$2 = TypeError;
7928
+ var $TypeError$3 = TypeError;
8222
7929
 
8223
7930
  // Perform ? RequireInternalSlot(argument, [[TypedArrayName]])
8224
7931
  // If argument.[[TypedArrayName]] is not "Uint8Array", throw a TypeError exception
8225
7932
  var anUint8Array$4 = function (argument) {
8226
- if (classof(argument) === 'Uint8Array') return argument;
8227
- throw new $TypeError$2('Argument is not an Uint8Array');
7933
+ if (classof$1(argument) === 'Uint8Array') return argument;
7934
+ throw new $TypeError$3('Argument is not an Uint8Array');
8228
7935
  };
8229
7936
 
8230
- var $$c = _export;
8231
- var globalThis$5 = globalThis_1;
7937
+ var $$d = _export;
7938
+ var globalThis$6 = globalThis_1;
8232
7939
  var $fromBase64 = uint8FromBase64;
8233
7940
  var anUint8Array$3 = anUint8Array$4;
8234
7941
 
8235
- var Uint8Array$4 = globalThis$5.Uint8Array;
7942
+ var Uint8Array$4 = globalThis$6.Uint8Array;
8236
7943
 
8237
7944
  var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS$2 = !Uint8Array$4 || !Uint8Array$4.prototype.setFromBase64 || !function () {
8238
7945
  var target = new Uint8Array$4([255, 255, 255, 255, 255]);
@@ -8254,7 +7961,7 @@ var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS$2 = !Uint8Array$4 || !Uint8Array$4.proto
8254
7961
 
8255
7962
  // `Uint8Array.prototype.setFromBase64` method
8256
7963
  // https://tc39.es/ecma262/#sec-uint8array.prototype.setfrombase64
8257
- if (Uint8Array$4) $$c({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS$2 }, {
7964
+ if (Uint8Array$4) $$d({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS$2 }, {
8258
7965
  setFromBase64: function setFromBase64(string /* , options */) {
8259
7966
  anUint8Array$3(this);
8260
7967
 
@@ -8264,17 +7971,17 @@ if (Uint8Array$4) $$c({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEH
8264
7971
  }
8265
7972
  });
8266
7973
 
8267
- var globalThis$4 = globalThis_1;
8268
- var uncurryThis$7 = functionUncurryThis;
7974
+ var globalThis$5 = globalThis_1;
7975
+ var uncurryThis$8 = functionUncurryThis;
8269
7976
 
8270
- var Uint8Array$3 = globalThis$4.Uint8Array;
8271
- var SyntaxError$1 = globalThis$4.SyntaxError;
7977
+ var Uint8Array$3 = globalThis$5.Uint8Array;
7978
+ var SyntaxError$2 = globalThis$5.SyntaxError;
8272
7979
  var min$1 = Math.min;
8273
- var stringMatch = uncurryThis$7(''.match);
7980
+ var stringMatch = uncurryThis$8(''.match);
8274
7981
 
8275
7982
  var uint8FromHex = function (string, into) {
8276
7983
  var stringLength = string.length;
8277
- if (stringLength % 2 !== 0) throw new SyntaxError$1('String should be an even number of characters');
7984
+ if (stringLength % 2 !== 0) throw new SyntaxError$2('String should be an even number of characters');
8278
7985
  var maxLength = into ? min$1(into.length, stringLength / 2) : stringLength / 2;
8279
7986
  var bytes = into || new Uint8Array$3(maxLength);
8280
7987
  var segments = stringMatch(string, /.{2}/g);
@@ -8283,15 +7990,15 @@ var uint8FromHex = function (string, into) {
8283
7990
  var result = +('0x' + segments[written] + '0');
8284
7991
  // eslint-disable-next-line no-self-compare -- NaN check
8285
7992
  if (result !== result) {
8286
- throw new SyntaxError$1('String should only contain hex characters');
7993
+ throw new SyntaxError$2('String should only contain hex characters');
8287
7994
  }
8288
7995
  bytes[written] = result >> 4;
8289
7996
  }
8290
7997
  return { bytes: bytes, read: written << 1 };
8291
7998
  };
8292
7999
 
8293
- var $$b = _export;
8294
- var globalThis$3 = globalThis_1;
8000
+ var $$c = _export;
8001
+ var globalThis$4 = globalThis_1;
8295
8002
  var aString = aString$2;
8296
8003
  var anUint8Array$2 = anUint8Array$4;
8297
8004
  var notDetached$2 = arrayBufferNotDetached;
@@ -8312,7 +8019,7 @@ function throwsOnLengthTrackingView() {
8312
8019
 
8313
8020
  // `Uint8Array.prototype.setFromHex` method
8314
8021
  // https://tc39.es/ecma262/#sec-uint8array.prototype.setfromhex
8315
- if (globalThis$3.Uint8Array) $$b({ target: 'Uint8Array', proto: true, forced: throwsOnLengthTrackingView() }, {
8022
+ if (globalThis$4.Uint8Array) $$c({ target: 'Uint8Array', proto: true, forced: throwsOnLengthTrackingView() }, {
8316
8023
  setFromHex: function setFromHex(string) {
8317
8024
  anUint8Array$2(this);
8318
8025
  aString(string);
@@ -8322,9 +8029,9 @@ if (globalThis$3.Uint8Array) $$b({ target: 'Uint8Array', proto: true, forced: th
8322
8029
  }
8323
8030
  });
8324
8031
 
8325
- var $$a = _export;
8326
- var globalThis$2 = globalThis_1;
8327
- var uncurryThis$6 = functionUncurryThis;
8032
+ var $$b = _export;
8033
+ var globalThis$3 = globalThis_1;
8034
+ var uncurryThis$7 = functionUncurryThis;
8328
8035
  var anObjectOrUndefined = anObjectOrUndefined$2;
8329
8036
  var anUint8Array$1 = anUint8Array$4;
8330
8037
  var notDetached$1 = arrayBufferNotDetached;
@@ -8334,9 +8041,9 @@ var getAlphabetOption = getAlphabetOption$2;
8334
8041
  var base64Alphabet = base64Map.i2c;
8335
8042
  var base64UrlAlphabet = base64Map.i2cUrl;
8336
8043
 
8337
- var charAt = uncurryThis$6(''.charAt);
8044
+ var charAt$1 = uncurryThis$7(''.charAt);
8338
8045
 
8339
- var Uint8Array$2 = globalThis$2.Uint8Array;
8046
+ var Uint8Array$2 = globalThis$3.Uint8Array;
8340
8047
 
8341
8048
  var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS$1 = !Uint8Array$2 || !Uint8Array$2.prototype.toBase64 || !function () {
8342
8049
  try {
@@ -8349,7 +8056,7 @@ var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS$1 = !Uint8Array$2 || !Uint8Array$2.proto
8349
8056
 
8350
8057
  // `Uint8Array.prototype.toBase64` method
8351
8058
  // https://tc39.es/ecma262/#sec-uint8array.prototype.tobase64
8352
- if (Uint8Array$2) $$a({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS$1 }, {
8059
+ if (Uint8Array$2) $$b({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS$1 }, {
8353
8060
  toBase64: function toBase64(/* options */) {
8354
8061
  var array = anUint8Array$1(this);
8355
8062
  var options = arguments.length ? anObjectOrUndefined(arguments[0]) : undefined;
@@ -8363,7 +8070,7 @@ if (Uint8Array$2) $$a({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEH
8363
8070
  var triplet;
8364
8071
 
8365
8072
  var at = function (shift) {
8366
- return charAt(alphabet, (triplet >> (6 * shift)) & 63);
8073
+ return charAt$1(alphabet, (triplet >> (6 * shift)) & 63);
8367
8074
  };
8368
8075
 
8369
8076
  for (; i + 2 < length; i += 3) {
@@ -8382,17 +8089,17 @@ if (Uint8Array$2) $$a({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEH
8382
8089
  }
8383
8090
  });
8384
8091
 
8385
- var $$9 = _export;
8386
- var globalThis$1 = globalThis_1;
8387
- var uncurryThis$5 = functionUncurryThis;
8092
+ var $$a = _export;
8093
+ var globalThis$2 = globalThis_1;
8094
+ var uncurryThis$6 = functionUncurryThis;
8388
8095
  var anUint8Array = anUint8Array$4;
8389
8096
  var notDetached = arrayBufferNotDetached;
8390
8097
 
8391
- var numberToString = uncurryThis$5(1.1.toString);
8392
- var join = uncurryThis$5([].join);
8098
+ var numberToString = uncurryThis$6(1.1.toString);
8099
+ var join = uncurryThis$6([].join);
8393
8100
  var $Array = Array;
8394
8101
 
8395
- var Uint8Array$1 = globalThis$1.Uint8Array;
8102
+ var Uint8Array$1 = globalThis$2.Uint8Array;
8396
8103
 
8397
8104
  var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array$1 || !Uint8Array$1.prototype.toHex || !(function () {
8398
8105
  try {
@@ -8405,7 +8112,7 @@ var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array$1 || !Uint8Array$1.prototy
8405
8112
 
8406
8113
  // `Uint8Array.prototype.toHex` method
8407
8114
  // https://tc39.es/ecma262/#sec-uint8array.prototype.tohex
8408
- if (Uint8Array$1) $$9({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS }, {
8115
+ if (Uint8Array$1) $$a({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS }, {
8409
8116
  toHex: function toHex() {
8410
8117
  anUint8Array(this);
8411
8118
  notDetached(this.buffer);
@@ -8421,46 +8128,17 @@ if (Uint8Array$1) $$9({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEH
8421
8128
  const getDefaultIgnorePatterns = () => {
8422
8129
  return new Set(["venv", ".venv", "node_modules", "dist", "build", "__pycache__", ".claude", ".agents", ".git", /\.egg-info$/, ".machine-code-app-directory-info.json", ".vention-design-scene-assets.json", ".vention-design-configuration.json"]);
8423
8130
  };
8424
- const shouldIgnoreFileSystemNode = (nodeName, ignoredNodes) => {
8425
- for (const pattern of ignoredNodes) {
8426
- if (typeof pattern === "string" && nodeName === pattern) {
8427
- return true;
8428
- }
8429
- if (pattern instanceof RegExp && pattern.test(nodeName)) {
8430
- return true;
8431
- }
8432
- }
8433
- return false;
8434
- };
8435
8131
  const sanitizeFileName = fileName => {
8436
8132
  return fileName.replace(/[^a-zA-Z0-9-_]/g, "_");
8437
8133
  };
8438
8134
  const sanitizeResolvedPath = (baseDirectory, pathSegment) => {
8439
- const resolvedBase = path$2.resolve(baseDirectory);
8440
- const resolvedPath = path$2.resolve(resolvedBase, pathSegment);
8441
- if (resolvedPath.indexOf(resolvedBase + path$2.sep) !== 0) {
8135
+ const resolvedBase = path__default.resolve(baseDirectory);
8136
+ const resolvedPath = path__default.resolve(resolvedBase, pathSegment);
8137
+ if (resolvedPath.indexOf(resolvedBase + path__default.sep) !== 0) {
8442
8138
  throw new Error(`Refusing to access path outside of target directory: "${pathSegment}"`);
8443
8139
  }
8444
8140
  return resolvedPath;
8445
8141
  };
8446
- const serializeFileSystem = (sourceDirectory, ignoredFileSystemNodes, shouldBase64Encoded) => {
8447
- const fileSystemNode = {};
8448
- const directoryContents = fs.readdirSync(sourceDirectory);
8449
- directoryContents.forEach(directoryItem => {
8450
- if (shouldIgnoreFileSystemNode(directoryItem, ignoredFileSystemNodes)) {
8451
- return;
8452
- }
8453
- const fullPath = sanitizeResolvedPath(sourceDirectory, directoryItem);
8454
- const directoryItemInformation = fs.statSync(fullPath);
8455
- if (directoryItemInformation.isDirectory()) {
8456
- fileSystemNode[directoryItem] = serializeFileSystem(fullPath, ignoredFileSystemNodes);
8457
- } else if (directoryItemInformation.isFile()) {
8458
- const fileContent = fs.readFileSync(fullPath, "base64") ;
8459
- fileSystemNode[directoryItem] = fileContent;
8460
- }
8461
- });
8462
- return fileSystemNode;
8463
- };
8464
8142
  const createFileSystemFromJson = async (fileSystemNode, targetDirectory) => {
8465
8143
  await ensureDirectoryExists(targetDirectory);
8466
8144
  const writeFiles = async (node, currentPath) => {
@@ -8468,7 +8146,7 @@ const createFileSystemFromJson = async (fileSystemNode, targetDirectory) => {
8468
8146
  const fullPath = sanitizeResolvedPath(currentPath, entryName);
8469
8147
  if (typeof contentOrNode === "string") {
8470
8148
  const decodedContent = Buffer.from(contentOrNode, "base64");
8471
- const fileHandle = await fs.promises.open(fullPath, "w");
8149
+ const fileHandle = await fs__default.promises.open(fullPath, "w");
8472
8150
  try {
8473
8151
  await fileHandle.writeFile(new Uint8Array(decodedContent));
8474
8152
  await fileHandle.sync();
@@ -8483,7 +8161,7 @@ const createFileSystemFromJson = async (fileSystemNode, targetDirectory) => {
8483
8161
  };
8484
8162
  await writeFiles(fileSystemNode, targetDirectory);
8485
8163
  if (process.platform !== "win32") {
8486
- const dirHandle = await fs.promises.open(targetDirectory, "r");
8164
+ const dirHandle = await fs__default.promises.open(targetDirectory, "r");
8487
8165
  try {
8488
8166
  await dirHandle.sync();
8489
8167
  } finally {
@@ -8494,13 +8172,13 @@ const createFileSystemFromJson = async (fileSystemNode, targetDirectory) => {
8494
8172
  const ensureDirectoryExists = async directory => {
8495
8173
  const directoryExists = await checkIfPathExists(directory);
8496
8174
  if (!directoryExists) {
8497
- fs.mkdirSync(directory, {
8175
+ fs__default.mkdirSync(directory, {
8498
8176
  recursive: true
8499
8177
  });
8500
8178
  }
8501
8179
  };
8502
8180
  const checkIfPathExists = async directory => {
8503
- const exists = await fs.promises.access(directory).then(() => true).catch(() => false);
8181
+ const exists = await fs__default.promises.access(directory).then(() => true).catch(() => false);
8504
8182
  return exists;
8505
8183
  };
8506
8184
  const checkIfAppDirectoryExists = async (appName, targetDirectory) => {
@@ -8521,21 +8199,21 @@ const writeApplicationToDisk = async (appName, sourceCode, targetDirectory, over
8521
8199
  const writeReadonlyJsonFile = async (targetDirectory, fileName, data) => {
8522
8200
  const filePath = sanitizeResolvedPath(targetDirectory, fileName);
8523
8201
  if (await checkIfPathExists(filePath)) {
8524
- await fs.promises.chmod(filePath, 0o644);
8202
+ await fs__default.promises.chmod(filePath, 0o644);
8525
8203
  }
8526
- await fs.promises.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
8527
- await fs.promises.chmod(filePath, 0o444);
8204
+ await fs__default.promises.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
8205
+ await fs__default.promises.chmod(filePath, 0o444);
8528
8206
  };
8529
8207
 
8530
8208
  const STATE_FILENAME = ".machine-code-app-directory-info.json";
8531
8209
  const writeMachineCodeAppDirectoryInfo = async (projectPath, state) => {
8532
8210
  const statePath = sanitizeResolvedPath(projectPath, STATE_FILENAME);
8533
- await fs.promises.writeFile(statePath, JSON.stringify(state, null, 2));
8211
+ await fs__default.promises.writeFile(statePath, JSON.stringify(state, null, 2));
8534
8212
  };
8535
8213
  const readMachineCodeAppDirectoryInfo = async projectPath => {
8536
8214
  const statePath = sanitizeResolvedPath(projectPath, STATE_FILENAME);
8537
8215
  try {
8538
- const data = await fs.promises.readFile(statePath, "utf-8");
8216
+ const data = await fs__default.promises.readFile(statePath, "utf-8");
8539
8217
  return JSON.parse(data);
8540
8218
  } catch (error) {
8541
8219
  if (error.code === "ENOENT") {
@@ -8545,11 +8223,11 @@ const readMachineCodeAppDirectoryInfo = async projectPath => {
8545
8223
  }
8546
8224
  };
8547
8225
 
8548
- var $TypeError$1 = TypeError;
8226
+ var $TypeError$2 = TypeError;
8549
8227
  var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991
8550
8228
 
8551
8229
  var doesNotExceedSafeInteger$1 = function (it) {
8552
- if (it > MAX_SAFE_INTEGER) throw new $TypeError$1('Maximum allowed index exceeded');
8230
+ if (it > MAX_SAFE_INTEGER) throw new $TypeError$2('Maximum allowed index exceeded');
8553
8231
  return it;
8554
8232
  };
8555
8233
 
@@ -8588,7 +8266,7 @@ var flattenIntoArray$1 = function (target, original, source, sourceLen, start, d
8588
8266
 
8589
8267
  var flattenIntoArray_1 = flattenIntoArray$1;
8590
8268
 
8591
- var $$8 = _export;
8269
+ var $$9 = _export;
8592
8270
  var flattenIntoArray = flattenIntoArray_1;
8593
8271
  var aCallable$4 = aCallable$l;
8594
8272
  var toObject$1 = toObject$a;
@@ -8597,7 +8275,7 @@ var arraySpeciesCreate = arraySpeciesCreate$2;
8597
8275
 
8598
8276
  // `Array.prototype.flatMap` method
8599
8277
  // https://tc39.es/ecma262/#sec-array.prototype.flatmap
8600
- $$8({ target: 'Array', proto: true }, {
8278
+ $$9({ target: 'Array', proto: true }, {
8601
8279
  flatMap: function flatMap(callbackfn /* , thisArg */) {
8602
8280
  var O = toObject$1(this);
8603
8281
  var sourceLen = lengthOfArrayLike$1(O);
@@ -8611,30 +8289,30 @@ $$8({ target: 'Array', proto: true }, {
8611
8289
 
8612
8290
  var tryToString = tryToString$6;
8613
8291
 
8614
- var $TypeError = TypeError;
8292
+ var $TypeError$1 = TypeError;
8615
8293
 
8616
8294
  var deletePropertyOrThrow$1 = function (O, P) {
8617
- if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));
8295
+ if (!delete O[P]) throw new $TypeError$1('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));
8618
8296
  };
8619
8297
 
8620
- var fails$2 = fails$E;
8298
+ var fails$4 = fails$E;
8621
8299
 
8622
8300
  var arrayMethodIsStrict$1 = function (METHOD_NAME, argument) {
8623
8301
  var method = [][METHOD_NAME];
8624
- return !!method && fails$2(function () {
8302
+ return !!method && fails$4(function () {
8625
8303
  // eslint-disable-next-line no-useless-call -- required for testing
8626
8304
  method.call(null, argument || function () { return 1; }, 1);
8627
8305
  });
8628
8306
  };
8629
8307
 
8630
- var $$7 = _export;
8631
- var uncurryThis$4 = functionUncurryThis;
8308
+ var $$8 = _export;
8309
+ var uncurryThis$5 = functionUncurryThis;
8632
8310
  var aCallable$3 = aCallable$l;
8633
8311
  var toObject = toObject$a;
8634
8312
  var lengthOfArrayLike = lengthOfArrayLike$f;
8635
8313
  var deletePropertyOrThrow = deletePropertyOrThrow$1;
8636
- var toString$4 = toString$g;
8637
- var fails$1 = fails$E;
8314
+ var toString$6 = toString$g;
8315
+ var fails$3 = fails$E;
8638
8316
  var internalSort = arraySort;
8639
8317
  var arrayMethodIsStrict = arrayMethodIsStrict$1;
8640
8318
  var FF = environmentFfVersion;
@@ -8643,21 +8321,21 @@ var V8 = environmentV8Version;
8643
8321
  var WEBKIT = environmentWebkitVersion;
8644
8322
 
8645
8323
  var test = [];
8646
- var nativeSort = uncurryThis$4(test.sort);
8647
- var push = uncurryThis$4(test.push);
8324
+ var nativeSort = uncurryThis$5(test.sort);
8325
+ var push = uncurryThis$5(test.push);
8648
8326
 
8649
8327
  // IE8-
8650
- var FAILS_ON_UNDEFINED = fails$1(function () {
8328
+ var FAILS_ON_UNDEFINED = fails$3(function () {
8651
8329
  test.sort(undefined);
8652
8330
  });
8653
8331
  // V8 bug
8654
- var FAILS_ON_NULL = fails$1(function () {
8332
+ var FAILS_ON_NULL = fails$3(function () {
8655
8333
  test.sort(null);
8656
8334
  });
8657
8335
  // Old WebKit
8658
8336
  var STRICT_METHOD = arrayMethodIsStrict('sort');
8659
8337
 
8660
- var STABLE_SORT = !fails$1(function () {
8338
+ var STABLE_SORT = !fails$3(function () {
8661
8339
  // feature detection can be too slow, so check engines versions
8662
8340
  if (V8) return V8 < 70;
8663
8341
  if (FF && FF > 3) return;
@@ -8699,15 +8377,15 @@ var getSortCompare = function (comparefn) {
8699
8377
  if (y === undefined) return -1;
8700
8378
  if (x === undefined) return 1;
8701
8379
  if (comparefn !== undefined) return +comparefn(x, y) || 0;
8702
- var xString = toString$4(x);
8703
- var yString = toString$4(y);
8380
+ var xString = toString$6(x);
8381
+ var yString = toString$6(y);
8704
8382
  return xString === yString ? 0 : xString > yString ? 1 : -1;
8705
8383
  };
8706
8384
  };
8707
8385
 
8708
8386
  // `Array.prototype.sort` method
8709
8387
  // https://tc39.es/ecma262/#sec-array.prototype.sort
8710
- $$7({ target: 'Array', proto: true, forced: FORCED$1 }, {
8388
+ $$8({ target: 'Array', proto: true, forced: FORCED$1 }, {
8711
8389
  sort: function sort(comparefn) {
8712
8390
  if (comparefn !== undefined) aCallable$3(comparefn);
8713
8391
 
@@ -8742,21 +8420,21 @@ var addToUnscopables = addToUnscopables$3;
8742
8420
  // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
8743
8421
  addToUnscopables('flatMap');
8744
8422
 
8745
- var call$2 = functionCall;
8746
- var anObject$2 = anObject$p;
8423
+ var call$3 = functionCall;
8424
+ var anObject$4 = anObject$p;
8747
8425
  var getIteratorDirect$2 = getIteratorDirect$8;
8748
8426
  var getIteratorMethod = getIteratorMethod$4;
8749
8427
 
8750
8428
  var getIteratorFlattenable$1 = function (obj, stringHandling) {
8751
- if (!stringHandling || typeof obj !== 'string') anObject$2(obj);
8429
+ if (!stringHandling || typeof obj !== 'string') anObject$4(obj);
8752
8430
  var method = getIteratorMethod(obj);
8753
- return getIteratorDirect$2(anObject$2(method !== undefined ? call$2(method, obj) : obj));
8431
+ return getIteratorDirect$2(anObject$4(method !== undefined ? call$3(method, obj) : obj));
8754
8432
  };
8755
8433
 
8756
- var $$6 = _export;
8757
- var call$1 = functionCall;
8434
+ var $$7 = _export;
8435
+ var call$2 = functionCall;
8758
8436
  var aCallable$2 = aCallable$l;
8759
- var anObject$1 = anObject$p;
8437
+ var anObject$3 = anObject$p;
8760
8438
  var getIteratorDirect$1 = getIteratorDirect$8;
8761
8439
  var getIteratorFlattenable = getIteratorFlattenable$1;
8762
8440
  var createIteratorProxy = iteratorCreateProxy;
@@ -8791,12 +8469,12 @@ var IteratorProxy = createIteratorProxy(function () {
8791
8469
 
8792
8470
  while (true) {
8793
8471
  if (inner = this.inner) try {
8794
- result = anObject$1(call$1(inner.next, inner.iterator));
8472
+ result = anObject$3(call$2(inner.next, inner.iterator));
8795
8473
  if (!result.done) return result.value;
8796
8474
  this.inner = null;
8797
8475
  } catch (error) { iteratorClose$1(iterator, 'throw', error); }
8798
8476
 
8799
- result = anObject$1(call$1(this.next, iterator));
8477
+ result = anObject$3(call$2(this.next, iterator));
8800
8478
 
8801
8479
  if (this.done = !!result.done) return;
8802
8480
 
@@ -8808,16 +8486,16 @@ var IteratorProxy = createIteratorProxy(function () {
8808
8486
 
8809
8487
  // `Iterator.prototype.flatMap` method
8810
8488
  // https://tc39.es/ecma262/#sec-iterator.prototype.flatmap
8811
- $$6({ target: 'Iterator', proto: true, real: true, forced: FORCED }, {
8489
+ $$7({ target: 'Iterator', proto: true, real: true, forced: FORCED }, {
8812
8490
  flatMap: function flatMap(mapper) {
8813
- anObject$1(this);
8491
+ anObject$3(this);
8814
8492
  try {
8815
8493
  aCallable$2(mapper);
8816
8494
  } catch (error) {
8817
8495
  iteratorClose$1(this, 'throw', error);
8818
8496
  }
8819
8497
 
8820
- if (flatMapWithoutClosingOnEarlyError) return call$1(flatMapWithoutClosingOnEarlyError, this, mapper);
8498
+ if (flatMapWithoutClosingOnEarlyError) return call$2(flatMapWithoutClosingOnEarlyError, this, mapper);
8821
8499
 
8822
8500
  return new IteratorProxy(getIteratorDirect$1(this), {
8823
8501
  mapper: mapper,
@@ -9879,6 +9557,341 @@ function createLinkCommand() {
9879
9557
  });
9880
9558
  }
9881
9559
 
9560
+ var DESCRIPTORS$1 = descriptors;
9561
+ var globalThis$1 = globalThis_1;
9562
+ var uncurryThis$4 = functionUncurryThis;
9563
+ var isForced = isForced_1;
9564
+ var inheritIfRequired = inheritIfRequired$4;
9565
+ var createNonEnumerableProperty = createNonEnumerableProperty$d;
9566
+ var create = objectCreate;
9567
+ var getOwnPropertyNames = objectGetOwnPropertyNames.f;
9568
+ var isPrototypeOf = objectIsPrototypeOf;
9569
+ var isRegExp = isRegexp;
9570
+ var toString$5 = toString$g;
9571
+ var getRegExpFlags$1 = regexpGetFlags;
9572
+ var stickyHelpers = regexpStickyHelpers;
9573
+ var proxyAccessor = proxyAccessor$2;
9574
+ var defineBuiltIn$1 = defineBuiltIn$a;
9575
+ var fails$2 = fails$E;
9576
+ var hasOwn = hasOwnProperty_1;
9577
+ var enforceInternalState = internalState.enforce;
9578
+ var setSpecies = setSpecies$4;
9579
+ var wellKnownSymbol = wellKnownSymbol$n;
9580
+ var UNSUPPORTED_DOT_ALL$1 = regexpUnsupportedDotAll;
9581
+ var UNSUPPORTED_NCG = regexpUnsupportedNcg;
9582
+
9583
+ var MATCH = wellKnownSymbol('match');
9584
+ var NativeRegExp = globalThis$1.RegExp;
9585
+ var RegExpPrototype$2 = NativeRegExp.prototype;
9586
+ var SyntaxError$1 = globalThis$1.SyntaxError;
9587
+ var exec = uncurryThis$4(RegExpPrototype$2.exec);
9588
+ var charAt = uncurryThis$4(''.charAt);
9589
+ var replace$1 = uncurryThis$4(''.replace);
9590
+ var stringIndexOf = uncurryThis$4(''.indexOf);
9591
+ var stringSlice$2 = uncurryThis$4(''.slice);
9592
+ // TODO: Use only proper RegExpIdentifierName
9593
+ var IS_NCG = /^\?<[^\s\d!#%&*+<=>@^][^\s!#%&*+<=>@^]*>/;
9594
+ var re1 = /a/g;
9595
+ var re2 = /a/g;
9596
+
9597
+ // "new" should create a new object, old webkit bug
9598
+ var CORRECT_NEW = new NativeRegExp(re1) !== re1;
9599
+
9600
+ var MISSED_STICKY = stickyHelpers.MISSED_STICKY;
9601
+ var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;
9602
+
9603
+ var BASE_FORCED = DESCRIPTORS$1 &&
9604
+ (!CORRECT_NEW || MISSED_STICKY || UNSUPPORTED_DOT_ALL$1 || UNSUPPORTED_NCG || fails$2(function () {
9605
+ re2[MATCH] = false;
9606
+ // RegExp constructor can alter flags and IsRegExp works correct with @@match
9607
+ // eslint-disable-next-line sonarjs/inconsistent-function-call -- required for testing
9608
+ return NativeRegExp(re1) !== re1 || NativeRegExp(re2) === re2 || String(NativeRegExp(re1, 'i')) !== '/a/i';
9609
+ }));
9610
+
9611
+ var handleDotAll = function (string) {
9612
+ var length = string.length;
9613
+ var index = 0;
9614
+ var result = '';
9615
+ var brackets = false;
9616
+ var chr;
9617
+ for (; index < length; index++) {
9618
+ chr = charAt(string, index);
9619
+ if (chr === '\\') {
9620
+ result += chr + charAt(string, ++index);
9621
+ continue;
9622
+ }
9623
+ if (!brackets && chr === '.') {
9624
+ result += '[\\s\\S]';
9625
+ } else {
9626
+ if (chr === '[') {
9627
+ brackets = true;
9628
+ } else if (chr === ']') {
9629
+ brackets = false;
9630
+ } result += chr;
9631
+ }
9632
+ } return result;
9633
+ };
9634
+
9635
+ var handleNCG = function (string) {
9636
+ var length = string.length;
9637
+ var index = 0;
9638
+ var result = '';
9639
+ var named = [];
9640
+ var names = create(null);
9641
+ var brackets = false;
9642
+ var ncg = false;
9643
+ var groupid = 0;
9644
+ var groupname = '';
9645
+ var chr;
9646
+ for (; index < length; index++) {
9647
+ chr = charAt(string, index);
9648
+ if (chr === '\\') {
9649
+ chr += charAt(string, ++index);
9650
+ // use `\x5c` for escaped backslash to avoid corruption by `\k<name>` to `\N` replacement below
9651
+ if (!ncg && charAt(chr, 1) === '\\') {
9652
+ result += '\\x5c';
9653
+ continue;
9654
+ }
9655
+ } else if (chr === ']') {
9656
+ brackets = false;
9657
+ } else if (!brackets) switch (true) {
9658
+ case chr === '[':
9659
+ brackets = true;
9660
+ break;
9661
+ case chr === '(':
9662
+ result += chr;
9663
+ if (exec(IS_NCG, stringSlice$2(string, index + 1))) {
9664
+ index += 2;
9665
+ ncg = true;
9666
+ groupid++;
9667
+ } else if (charAt(string, index + 1) !== '?') {
9668
+ groupid++;
9669
+ }
9670
+ continue;
9671
+ case chr === '>' && ncg:
9672
+ if (groupname === '' || hasOwn(names, groupname)) {
9673
+ throw new SyntaxError$1('Invalid capture group name');
9674
+ }
9675
+ names[groupname] = true;
9676
+ named[named.length] = [groupname, groupid];
9677
+ ncg = false;
9678
+ groupname = '';
9679
+ continue;
9680
+ }
9681
+ if (ncg) groupname += chr;
9682
+ else result += chr;
9683
+ }
9684
+ // convert `\k<name>` backreferences to numbered backreferences
9685
+ for (var ni = 0; ni < named.length; ni++) {
9686
+ var backref = '\\k<' + named[ni][0] + '>';
9687
+ var numRef = '\\' + named[ni][1];
9688
+ while (stringIndexOf(result, backref) > -1) {
9689
+ result = replace$1(result, backref, numRef);
9690
+ }
9691
+ } return [result, named];
9692
+ };
9693
+
9694
+ // `RegExp` constructor
9695
+ // https://tc39.es/ecma262/#sec-regexp-constructor
9696
+ if (isForced('RegExp', BASE_FORCED)) {
9697
+ var RegExpWrapper = function RegExp(pattern, flags) {
9698
+ var thisIsRegExp = isPrototypeOf(RegExpPrototype$2, this);
9699
+ var patternIsRegExp = isRegExp(pattern);
9700
+ var flagsAreUndefined = flags === undefined;
9701
+ var groups = [];
9702
+ var rawPattern = pattern;
9703
+ var rawFlags, dotAll, sticky, handled, result, state;
9704
+
9705
+ if (!thisIsRegExp && patternIsRegExp && flagsAreUndefined && pattern.constructor === RegExpWrapper) {
9706
+ return pattern;
9707
+ }
9708
+
9709
+ if (patternIsRegExp || isPrototypeOf(RegExpPrototype$2, pattern)) {
9710
+ pattern = pattern.source;
9711
+ if (flagsAreUndefined) flags = getRegExpFlags$1(rawPattern);
9712
+ }
9713
+
9714
+ pattern = pattern === undefined ? '' : toString$5(pattern);
9715
+ flags = flags === undefined ? '' : toString$5(flags);
9716
+ rawPattern = pattern;
9717
+
9718
+ if (UNSUPPORTED_DOT_ALL$1 && 'dotAll' in re1) {
9719
+ dotAll = !!flags && stringIndexOf(flags, 's') > -1;
9720
+ if (dotAll) flags = replace$1(flags, /s/g, '');
9721
+ }
9722
+
9723
+ rawFlags = flags;
9724
+
9725
+ if (MISSED_STICKY && 'sticky' in re1) {
9726
+ sticky = !!flags && stringIndexOf(flags, 'y') > -1;
9727
+ if (sticky && UNSUPPORTED_Y) flags = replace$1(flags, /y/g, '');
9728
+ }
9729
+
9730
+ if (UNSUPPORTED_NCG) {
9731
+ handled = handleNCG(pattern);
9732
+ pattern = handled[0];
9733
+ groups = handled[1];
9734
+ }
9735
+
9736
+ result = inheritIfRequired(NativeRegExp(pattern, flags), thisIsRegExp ? this : RegExpPrototype$2, RegExpWrapper);
9737
+
9738
+ if (dotAll || sticky || groups.length) {
9739
+ state = enforceInternalState(result);
9740
+ if (dotAll) {
9741
+ state.dotAll = true;
9742
+ state.raw = RegExpWrapper(handleDotAll(pattern), rawFlags);
9743
+ }
9744
+ if (sticky) state.sticky = true;
9745
+ if (groups.length) state.groups = groups;
9746
+ }
9747
+
9748
+ if (pattern !== rawPattern) try {
9749
+ // fails in old engines, but we have no alternatives for unsupported regex syntax
9750
+ createNonEnumerableProperty(result, 'source', rawPattern === '' ? '(?:)' : rawPattern);
9751
+ } catch (error) { /* empty */ }
9752
+
9753
+ return result;
9754
+ };
9755
+
9756
+ for (var keys = getOwnPropertyNames(NativeRegExp), index = 0; keys.length > index;) {
9757
+ proxyAccessor(RegExpWrapper, NativeRegExp, keys[index++]);
9758
+ }
9759
+
9760
+ RegExpPrototype$2.constructor = RegExpWrapper;
9761
+ RegExpWrapper.prototype = RegExpPrototype$2;
9762
+ defineBuiltIn$1(globalThis$1, 'RegExp', RegExpWrapper, { constructor: true });
9763
+ }
9764
+
9765
+ // https://tc39.es/ecma262/#sec-get-regexp-@@species
9766
+ setSpecies('RegExp');
9767
+
9768
+ var DESCRIPTORS = descriptors;
9769
+ var UNSUPPORTED_DOT_ALL = regexpUnsupportedDotAll;
9770
+ var classof = classofRaw$2;
9771
+ var defineBuiltInAccessor = defineBuiltInAccessor$8;
9772
+ var getInternalState = internalState.get;
9773
+
9774
+ var RegExpPrototype$1 = RegExp.prototype;
9775
+ var $TypeError = TypeError;
9776
+
9777
+ // `RegExp.prototype.dotAll` getter
9778
+ // https://tc39.es/ecma262/#sec-get-regexp.prototype.dotall
9779
+ if (DESCRIPTORS && UNSUPPORTED_DOT_ALL) {
9780
+ defineBuiltInAccessor(RegExpPrototype$1, 'dotAll', {
9781
+ configurable: true,
9782
+ get: function dotAll() {
9783
+ if (this === RegExpPrototype$1) return;
9784
+ // We can't use InternalStateModule.getterFor because
9785
+ // we don't add metadata for regexps created by a literal.
9786
+ if (classof(this) === 'RegExp') {
9787
+ return !!getInternalState(this).dotAll;
9788
+ }
9789
+ throw new $TypeError('Incompatible receiver, RegExp required');
9790
+ }
9791
+ });
9792
+ }
9793
+
9794
+ // TODO: Remove from `core-js@4` since it's moved to entry points
9795
+
9796
+ var $$6 = _export;
9797
+ var call$1 = functionCall;
9798
+ var isCallable = isCallable$s;
9799
+ var anObject$2 = anObject$p;
9800
+ var toString$4 = toString$g;
9801
+
9802
+ var DELEGATES_TO_EXEC = function () {
9803
+ var execCalled = false;
9804
+ var re = /[ac]/;
9805
+ re.exec = function () {
9806
+ execCalled = true;
9807
+ return /./.exec.apply(this, arguments);
9808
+ };
9809
+ return re.test('abc') === true && execCalled;
9810
+ }();
9811
+
9812
+ var nativeTest = /./.test;
9813
+
9814
+ // `RegExp.prototype.test` method
9815
+ // https://tc39.es/ecma262/#sec-regexp.prototype.test
9816
+ $$6({ target: 'RegExp', proto: true, forced: !DELEGATES_TO_EXEC }, {
9817
+ test: function (S) {
9818
+ var R = anObject$2(this);
9819
+ var string = toString$4(S);
9820
+ var exec = R.exec;
9821
+ if (!isCallable(exec)) return call$1(nativeTest, R, string);
9822
+ var result = call$1(exec, R, string);
9823
+ if (result === null) return false;
9824
+ anObject$2(result);
9825
+ return true;
9826
+ }
9827
+ });
9828
+
9829
+ var PROPER_FUNCTION_NAME$1 = functionName.PROPER;
9830
+ var defineBuiltIn = defineBuiltIn$a;
9831
+ var anObject$1 = anObject$p;
9832
+ var $toString = toString$g;
9833
+ var fails$1 = fails$E;
9834
+ var getRegExpFlags = regexpGetFlags;
9835
+
9836
+ var TO_STRING = 'toString';
9837
+ var RegExpPrototype = RegExp.prototype;
9838
+ var nativeToString = RegExpPrototype[TO_STRING];
9839
+
9840
+ var NOT_GENERIC = fails$1(function () { return nativeToString.call({ source: 'a', flags: 'b' }) !== '/a/b'; });
9841
+ // FF44- RegExp#toString has a wrong name
9842
+ var INCORRECT_NAME = PROPER_FUNCTION_NAME$1 && nativeToString.name !== TO_STRING;
9843
+
9844
+ // `RegExp.prototype.toString` method
9845
+ // https://tc39.es/ecma262/#sec-regexp.prototype.tostring
9846
+ if (NOT_GENERIC || INCORRECT_NAME) {
9847
+ defineBuiltIn(RegExpPrototype, TO_STRING, function toString() {
9848
+ var R = anObject$1(this);
9849
+ var pattern = $toString(R.source);
9850
+ var flags = $toString(getRegExpFlags(R));
9851
+ return '/' + pattern + '/' + flags;
9852
+ }, { unsafe: true });
9853
+ }
9854
+
9855
+ /**
9856
+ * Checks if a file system node should be ignored based on the provided ignore patterns
9857
+ */
9858
+ function shouldIgnoreFileSystemNode(nodeName, ignoredNodes) {
9859
+ for (const pattern of ignoredNodes) {
9860
+ if (typeof pattern === "string" && nodeName === pattern) {
9861
+ return true;
9862
+ }
9863
+ if (pattern instanceof RegExp && pattern.test(nodeName)) {
9864
+ return true;
9865
+ }
9866
+ }
9867
+ return false;
9868
+ }
9869
+
9870
+ /**
9871
+ * Serializes a directory structure into a FileSystemNode object
9872
+ * Files are read as binary and encoded to base64, directories are recursively processed
9873
+ */
9874
+ function serializeFileSystem(sourceDirectory, ignoredFileSystemNodes) {
9875
+ const fileSystemNode = {};
9876
+ const directoryContents = fs.readdirSync(sourceDirectory);
9877
+ directoryContents.forEach(directoryItem => {
9878
+ if (shouldIgnoreFileSystemNode(directoryItem, ignoredFileSystemNodes)) {
9879
+ return;
9880
+ }
9881
+ const fullPath = path$2.join(sourceDirectory, directoryItem);
9882
+ const directoryItemInformation = fs.statSync(fullPath);
9883
+ if (directoryItemInformation.isDirectory()) {
9884
+ fileSystemNode[directoryItem] = serializeFileSystem(fullPath, ignoredFileSystemNodes);
9885
+ } else if (directoryItemInformation.isFile()) {
9886
+ // Always read as binary and encode to base64 - this is the safest approach
9887
+ // and ensures all file types are handled correctly
9888
+ const buffer = fs.readFileSync(fullPath);
9889
+ fileSystemNode[directoryItem] = buffer.toString("base64");
9890
+ }
9891
+ });
9892
+ return fileSystemNode;
9893
+ }
9894
+
9882
9895
  function createPushCommand() {
9883
9896
  return new Command("push").description("Push local changes from this directory to the linked digital twin").action(async () => {
9884
9897
  try {
@@ -9931,7 +9944,7 @@ function createPushCommand() {
9931
9944
  console.log();
9932
9945
  console.log(chalk.blue("Serializing local files..."));
9933
9946
  const ignorePatterns = getDefaultIgnorePatterns();
9934
- const serializedSourceCode = serializeFileSystem(currentDir, ignorePatterns, true);
9947
+ const serializedSourceCode = serializeFileSystem(currentDir, ignorePatterns);
9935
9948
  const applicationToPush = {
9936
9949
  name: updatedMachineCodeAppDirectoryInfo.appName,
9937
9950
  id: updatedMachineCodeAppDirectoryInfo.applicationId,
@@ -10260,7 +10273,7 @@ const INSTALL_HINTS = {
10260
10273
  };
10261
10274
  const NPM_TIMEOUT_MS = 15000;
10262
10275
  const NOT_INSTALLED = "No Vention skills installed. Run 'vention skills install'.";
10263
- const listDirectory = directory => fs.existsSync(directory) ? fs.readdirSync(directory) : [];
10276
+ const listDirectory = directory => fs__default.existsSync(directory) ? fs__default.readdirSync(directory) : [];
10264
10277
  const compareVersions = (left, right) => Number(left !== "unknown") - Number(right !== "unknown") || left.localeCompare(right, undefined, {
10265
10278
  numeric: true
10266
10279
  });
@@ -10272,15 +10285,15 @@ const homeDirectory = () => {
10272
10285
  const scopeRoot = scope => scope === "user" ? homeDirectory() : process.cwd();
10273
10286
  const displayPath = directory => {
10274
10287
  const home = homeDirectory();
10275
- return directory === home || directory.startsWith(home + path$2.sep) ? `~${directory.slice(home.length)}` : directory;
10288
+ return directory === home || directory.startsWith(home + path__default.sep) ? `~${directory.slice(home.length)}` : directory;
10276
10289
  };
10277
10290
  function readSkillVersion(skillFile) {
10278
10291
  var _a, _b, _c;
10279
- const frontmatter = (_a = fs.readFileSync(skillFile, "utf8").split("---")[1]) !== null && _a !== void 0 ? _a : "";
10292
+ const frontmatter = (_a = fs__default.readFileSync(skillFile, "utf8").split("---")[1]) !== null && _a !== void 0 ? _a : "";
10280
10293
  return (_c = (_b = /^\s+version:\s*"?([^"\n]*?)"?\s*$/m.exec(frontmatter)) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : "unknown";
10281
10294
  }
10282
10295
  function skillPath(...segments) {
10283
- return path$2.join(...segments);
10296
+ return path__default.join(...segments);
10284
10297
  }
10285
10298
  function pluginSkillsDirectories(cacheRoot) {
10286
10299
  return listDirectory(cacheRoot).flatMap(marketplace => listDirectory(skillPath(cacheRoot, marketplace, PLUGIN)).sort(compareVersions).slice(-1).map(version => skillPath(cacheRoot, marketplace, PLUGIN, version, "skills")));
@@ -10291,9 +10304,9 @@ function findInstalledSkills() {
10291
10304
  const project = process.cwd();
10292
10305
  const pluginSkills = (cacheRoot, install) => pluginSkillsDirectories(cacheRoot).map(skillsDirectory => [skillsDirectory, install]);
10293
10306
  const sources = [...pluginSkills(skillPath(home, ".claude", "plugins", "cache"), "claude-code"), ...pluginSkills(skillPath(home, ".codex", "plugins", "cache"), "codex"), [skillPath(home, ".claude", "skills"), undefined], [skillPath(project, ".claude", "skills"), undefined], [skillPath(home, ".agents", "skills"), "user"], [skillPath(project, ".agents", "skills"), "project"]];
10294
- const byDirectory = new Map(sources.flatMap(([skillsDirectory, install]) => skillDirectories(skillsDirectory).filter(directory => path$2.basename(directory).startsWith(SKILL_PREFIX)).map(directory => [directory, install])));
10295
- return [...byDirectory].filter(([directory]) => fs.existsSync(skillPath(directory, "SKILL.md"))).map(([directory, install]) => ({
10296
- skill: path$2.basename(directory),
10307
+ const byDirectory = new Map(sources.flatMap(([skillsDirectory, install]) => skillDirectories(skillsDirectory).filter(directory => path__default.basename(directory).startsWith(SKILL_PREFIX)).map(directory => [directory, install])));
10308
+ return [...byDirectory].filter(([directory]) => fs__default.existsSync(skillPath(directory, "SKILL.md"))).map(([directory, install]) => ({
10309
+ skill: path__default.basename(directory),
10297
10310
  location: displayPath(directory),
10298
10311
  version: readSkillVersion(skillPath(directory, "SKILL.md")),
10299
10312
  install
@@ -10368,10 +10381,10 @@ function installForCodex(scope) {
10368
10381
  }
10369
10382
  }]
10370
10383
  };
10371
- fs.mkdirSync(skillPath(catalogDir, ".agents", "plugins"), {
10384
+ fs__default.mkdirSync(skillPath(catalogDir, ".agents", "plugins"), {
10372
10385
  recursive: true
10373
10386
  });
10374
- fs.writeFileSync(skillPath(catalogDir, ".agents", "plugins", "marketplace.json"), `${JSON.stringify(catalog, null, 2)}\n`);
10387
+ fs__default.writeFileSync(skillPath(catalogDir, ".agents", "plugins", "marketplace.json"), `${JSON.stringify(catalog, null, 2)}\n`);
10375
10388
  console.log(run("codex", ["plugin", "marketplace", "add", catalogDir]));
10376
10389
  console.log(run("codex", ["plugin", "add", `${PLUGIN}@${MARKETPLACE}`]));
10377
10390
  console.log(chalk.green(`Installed ${PLUGIN}@${MARKETPLACE} for Codex.`));
@@ -10379,29 +10392,29 @@ function installForCodex(scope) {
10379
10392
  function unpackSkills(agent, scope) {
10380
10393
  var _a;
10381
10394
  const agentsDir = skillPath(scopeRoot(scope), ".agents");
10382
- fs.mkdirSync(agentsDir, {
10395
+ fs__default.mkdirSync(agentsDir, {
10383
10396
  recursive: true
10384
10397
  });
10385
- const extractDir = fs.mkdtempSync(skillPath(agentsDir, ".vention-skills-"));
10398
+ const extractDir = fs__default.mkdtempSync(skillPath(agentsDir, ".vention-skills-"));
10386
10399
  try {
10387
10400
  const tarball = (_a = run("npm", ["pack", PACKAGE, "--silent"], extractDir).trim().split("\n").pop()) !== null && _a !== void 0 ? _a : "";
10388
10401
  run("tar", ["-xzf", tarball, "-C", extractDir], extractDir);
10389
10402
  const packagedSkills = listDirectory(skillPath(extractDir, "package", "skills"));
10390
10403
  if (packagedSkills.length === 0) throw new Error(`the ${PACKAGE} package holds no skills, so nothing was installed.`);
10391
- fs.mkdirSync(skillPath(agentsDir, "skills"), {
10404
+ fs__default.mkdirSync(skillPath(agentsDir, "skills"), {
10392
10405
  recursive: true
10393
10406
  });
10394
10407
  for (const skill of packagedSkills) {
10395
10408
  const target = skillPath(agentsDir, "skills", skill);
10396
- fs.rmSync(target, {
10409
+ fs__default.rmSync(target, {
10397
10410
  recursive: true,
10398
10411
  force: true
10399
10412
  });
10400
- fs.renameSync(skillPath(extractDir, "package", "skills", skill), target);
10413
+ fs__default.renameSync(skillPath(extractDir, "package", "skills", skill), target);
10401
10414
  }
10402
10415
  console.log(chalk.green(`Unpacked ${packagedSkills.length} Vention skills into ${displayPath(skillPath(agentsDir, "skills"))} for ${agent}.`));
10403
10416
  } finally {
10404
- fs.rmSync(extractDir, {
10417
+ fs__default.rmSync(extractDir, {
10405
10418
  recursive: true,
10406
10419
  force: true
10407
10420
  });
@@ -10510,7 +10523,7 @@ function createUpdateCommand() {
10510
10523
  process.exitCode = 1;
10511
10524
  }
10512
10525
  }
10513
- for (const folder of new Set(installed.filter(row => row.install === undefined).map(row => path$2.dirname(row.location)))) {
10526
+ for (const folder of new Set(installed.filter(row => row.install === undefined).map(row => path__default.dirname(row.location)))) {
10514
10527
  console.log(chalk.yellow(`Skipped ${folder}: its skills were copied by hand, so copy the new versions from the package.`));
10515
10528
  }
10516
10529
  } catch (error) {