@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 +870 -857
- package/package.json +1 -1
- package/src/digital-twin-client.d.ts +1 -3
- package/src/file-system.d.ts +2 -6
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
|
|
6
|
-
import
|
|
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
|
|
3325
|
+
return path__default.join(process.cwd(), ".vention-cli-config.json");
|
|
3324
3326
|
}
|
|
3325
|
-
return
|
|
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
|
|
5689
|
-
var
|
|
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$
|
|
5647
|
+
var $RegExp$2 = globalThis$h.RegExp;
|
|
5709
5648
|
|
|
5710
|
-
var UNSUPPORTED_Y$2 = fails$
|
|
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$
|
|
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$
|
|
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$
|
|
5736
|
-
var globalThis$
|
|
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$
|
|
5678
|
+
var $RegExp$1 = globalThis$g.RegExp;
|
|
5740
5679
|
|
|
5741
|
-
var regexpUnsupportedDotAll = fails$
|
|
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$
|
|
5747
|
-
var globalThis$
|
|
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$
|
|
5689
|
+
var $RegExp = globalThis$f.RegExp;
|
|
5751
5690
|
|
|
5752
|
-
var regexpUnsupportedNcg = fails$
|
|
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
|
-
|
|
5759
|
-
|
|
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
|
|
5702
|
+
var regexpFlags = regexpFlags$1;
|
|
5770
5703
|
var stickyHelpers$1 = regexpStickyHelpers;
|
|
5771
|
-
var
|
|
5772
|
-
var
|
|
5773
|
-
var
|
|
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
|
|
5782
|
-
var
|
|
5783
|
-
var
|
|
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
|
-
|
|
5796
|
-
var
|
|
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
|
|
5799
|
-
var UNSUPPORTED_Y$1 = stickyHelpers$1.UNSUPPORTED_Y;
|
|
5726
|
+
var UNSUPPORTED_Y$1 = stickyHelpers$1.BROKEN_CARET;
|
|
5800
5727
|
|
|
5801
|
-
|
|
5802
|
-
|
|
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
|
|
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
|
|
5834
|
-
var
|
|
5835
|
-
var
|
|
5836
|
-
|
|
5837
|
-
|
|
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
|
-
|
|
5893
|
-
|
|
5894
|
-
|
|
5895
|
-
|
|
5896
|
-
var
|
|
5897
|
-
var
|
|
5898
|
-
var
|
|
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 (
|
|
5917
|
-
|
|
5918
|
-
|
|
5919
|
-
|
|
5749
|
+
if (raw) {
|
|
5750
|
+
raw.lastIndex = re.lastIndex;
|
|
5751
|
+
result = call$e(patchedExec, raw, str);
|
|
5752
|
+
re.lastIndex = raw.lastIndex;
|
|
5920
5753
|
|
|
5921
|
-
|
|
5754
|
+
if (result && state.groups) setGroups(result, state.groups);
|
|
5922
5755
|
|
|
5923
|
-
|
|
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
|
-
|
|
5929
|
-
|
|
5930
|
-
|
|
5931
|
-
|
|
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
|
-
|
|
5766
|
+
if (sticky) {
|
|
5767
|
+
flags = replace$3(flags, 'y', '');
|
|
5768
|
+
if (indexOf(flags, 'g') === -1) {
|
|
5769
|
+
flags += 'g';
|
|
5770
|
+
}
|
|
5935
5771
|
|
|
5936
|
-
|
|
5937
|
-
|
|
5938
|
-
|
|
5939
|
-
|
|
5940
|
-
|
|
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
|
-
|
|
5943
|
-
|
|
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 (
|
|
5947
|
-
|
|
5948
|
-
|
|
5949
|
-
|
|
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
|
-
|
|
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$
|
|
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$
|
|
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
|
|
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$
|
|
6195
|
-
has: uncurryThis$
|
|
6196
|
-
remove: uncurryThis$
|
|
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$
|
|
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$
|
|
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$
|
|
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$
|
|
6227
|
-
var keys = uncurryThis$
|
|
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$
|
|
6257
|
-
var call$
|
|
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$
|
|
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$
|
|
5919
|
+
return getIteratorDirect$3(anObject$7(call$c(this.keys, this.set)));
|
|
6276
5920
|
},
|
|
6277
5921
|
includes: function (it) {
|
|
6278
|
-
return call$
|
|
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$
|
|
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$
|
|
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 $$
|
|
6023
|
+
var $$l = _export;
|
|
6380
6024
|
var difference = setDifference;
|
|
6381
|
-
var fails$
|
|
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$
|
|
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
|
-
$$
|
|
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 $$
|
|
6448
|
-
var fails$
|
|
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$
|
|
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
|
-
$$
|
|
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 $$
|
|
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
|
-
$$
|
|
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 $$
|
|
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
|
-
$$
|
|
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 $$
|
|
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
|
-
$$
|
|
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 $$
|
|
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
|
-
$$
|
|
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 $$
|
|
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
|
-
$$
|
|
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$
|
|
6664
|
-
var defineBuiltIn$
|
|
6307
|
+
var call$b = functionCall;
|
|
6308
|
+
var defineBuiltIn$3 = defineBuiltIn$a;
|
|
6665
6309
|
var regexpExec$1 = regexpExec$2;
|
|
6666
|
-
var fails$
|
|
6667
|
-
var wellKnownSymbol$
|
|
6668
|
-
var createNonEnumerableProperty$
|
|
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$
|
|
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$
|
|
6318
|
+
var SYMBOL = wellKnownSymbol$4(KEY);
|
|
6675
6319
|
|
|
6676
|
-
var DELEGATES_TO_SYMBOL = !fails$
|
|
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$
|
|
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$
|
|
6369
|
+
return { done: true, value: call$b(nativeRegExpMethod, regexp, str, arg2) };
|
|
6726
6370
|
}
|
|
6727
|
-
return { done: true, value: call$
|
|
6371
|
+
return { done: true, value: call$b(nativeMethod, str, regexp, arg2) };
|
|
6728
6372
|
}
|
|
6729
6373
|
return { done: false };
|
|
6730
6374
|
});
|
|
6731
6375
|
|
|
6732
|
-
defineBuiltIn$
|
|
6733
|
-
defineBuiltIn$
|
|
6376
|
+
defineBuiltIn$3(String.prototype, KEY, methods[0]);
|
|
6377
|
+
defineBuiltIn$3(RegExpPrototype$4, SYMBOL, methods[1]);
|
|
6734
6378
|
}
|
|
6735
6379
|
|
|
6736
|
-
if (SHAM) createNonEnumerableProperty$
|
|
6380
|
+
if (SHAM) createNonEnumerableProperty$3(RegExpPrototype$4[SYMBOL], 'sham', true);
|
|
6737
6381
|
};
|
|
6738
6382
|
|
|
6739
|
-
var uncurryThis$
|
|
6383
|
+
var uncurryThis$f = functionUncurryThis;
|
|
6740
6384
|
var toIntegerOrInfinity$5 = toIntegerOrInfinity$b;
|
|
6741
|
-
var toString$
|
|
6385
|
+
var toString$8 = toString$g;
|
|
6742
6386
|
var requireObjectCoercible$5 = requireObjectCoercible$b;
|
|
6743
6387
|
|
|
6744
|
-
var charAt$
|
|
6745
|
-
var charCodeAt = uncurryThis$
|
|
6746
|
-
var stringSlice$
|
|
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$
|
|
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$
|
|
6403
|
+
? charAt$4(S, position)
|
|
6760
6404
|
: first
|
|
6761
6405
|
: CONVERT_TO_STRING
|
|
6762
|
-
? stringSlice$
|
|
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$
|
|
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$
|
|
6422
|
+
return index + (unicode ? charAt$3(S, index).length || 1 : 1);
|
|
6779
6423
|
};
|
|
6780
6424
|
|
|
6781
|
-
var uncurryThis$
|
|
6425
|
+
var uncurryThis$e = functionUncurryThis;
|
|
6782
6426
|
var toObject$5 = toObject$a;
|
|
6783
6427
|
|
|
6784
6428
|
var floor$4 = Math.floor;
|
|
6785
|
-
var charAt$
|
|
6786
|
-
var replace$
|
|
6787
|
-
var stringSlice$
|
|
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$
|
|
6446
|
+
return replace$2(replacement, symbols, function (match, ch) {
|
|
6803
6447
|
var capture;
|
|
6804
|
-
switch (charAt$
|
|
6448
|
+
switch (charAt$2(ch, 0)) {
|
|
6805
6449
|
case '$': return '$';
|
|
6806
6450
|
case '&': return matched;
|
|
6807
|
-
case '`': return stringSlice$
|
|
6808
|
-
case "'": return stringSlice$
|
|
6451
|
+
case '`': return stringSlice$4(str, 0, position);
|
|
6452
|
+
case "'": return stringSlice$4(str, tailPos);
|
|
6809
6453
|
case '<':
|
|
6810
|
-
capture = namedCaptures[stringSlice$
|
|
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$
|
|
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
|
|
6828
|
-
var
|
|
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
|
-
|
|
6474
|
+
// babel-minify and Closure Compiler transpiles RegExp('.', 'd') -> /./d and it causes SyntaxError
|
|
6475
|
+
var RegExp$1 = globalThis$e.RegExp;
|
|
6834
6476
|
|
|
6835
|
-
|
|
6836
|
-
|
|
6837
|
-
|
|
6838
|
-
|
|
6839
|
-
|
|
6840
|
-
|
|
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
|
|
6868
|
-
|
|
6869
|
-
var
|
|
6870
|
-
var
|
|
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
|
|
6876
|
-
|
|
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
|
-
|
|
6880
|
-
|
|
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$
|
|
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$
|
|
6917
|
-
: call$
|
|
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$
|
|
6923
|
-
var S = toString$
|
|
6629
|
+
var rx = anObject$5(this);
|
|
6630
|
+
var S = toString$7(string);
|
|
6924
6631
|
|
|
6925
|
-
var functionalReplace = isCallable$
|
|
6926
|
-
if (!functionalReplace) replaceValue = toString$
|
|
6927
|
-
var flags = toString$
|
|
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$
|
|
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$
|
|
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$
|
|
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$
|
|
6690
|
+
accumulatedResult += stringSlice$3(S, nextSourcePosition, position) + replacement;
|
|
6984
6691
|
nextSourcePosition = position + matched.length;
|
|
6985
6692
|
}
|
|
6986
6693
|
}
|
|
6987
6694
|
|
|
6988
|
-
return accumulatedResult + stringSlice$
|
|
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$
|
|
6997
|
-
var globalThis$
|
|
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$
|
|
7001
|
-
var classof$
|
|
6707
|
+
var hasOwn$3 = hasOwnProperty_1;
|
|
6708
|
+
var classof$5 = classof$f;
|
|
7002
6709
|
var tryToString$1 = tryToString$6;
|
|
7003
|
-
var createNonEnumerableProperty$
|
|
7004
|
-
var defineBuiltIn = defineBuiltIn$a;
|
|
7005
|
-
var defineBuiltInAccessor$
|
|
7006
|
-
var isPrototypeOf$
|
|
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$
|
|
6716
|
+
var wellKnownSymbol$2 = wellKnownSymbol$n;
|
|
7010
6717
|
var uid = uid$4;
|
|
7011
6718
|
var InternalStateModule$1 = internalState;
|
|
7012
6719
|
|
|
7013
|
-
var enforceInternalState$
|
|
7014
|
-
var getInternalState$
|
|
7015
|
-
var Int8Array$4 = globalThis$
|
|
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$
|
|
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$
|
|
6729
|
+
var TypeError$2 = globalThis$d.TypeError;
|
|
7023
6730
|
|
|
7024
|
-
var TO_STRING_TAG = wellKnownSymbol$
|
|
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$
|
|
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$
|
|
7053
|
-
return (state && hasOwn$
|
|
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$
|
|
7059
|
-
return hasOwn$
|
|
7060
|
-
|| hasOwn$
|
|
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$
|
|
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$
|
|
6781
|
+
if (!DESCRIPTORS$3) return;
|
|
7075
6782
|
if (forced) for (var ARRAY in TypedArrayConstructorsList) {
|
|
7076
|
-
var TypedArrayConstructor = globalThis$
|
|
7077
|
-
if (TypedArrayConstructor && hasOwn$
|
|
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$
|
|
6800
|
+
Constructor = globalThis$d[NAME];
|
|
7094
6801
|
Prototype = Constructor && Constructor.prototype;
|
|
7095
|
-
if (Prototype) enforceInternalState$
|
|
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$
|
|
6807
|
+
Constructor = globalThis$d[NAME];
|
|
7101
6808
|
Prototype = Constructor && Constructor.prototype;
|
|
7102
|
-
if (Prototype) enforceInternalState$
|
|
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$
|
|
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$
|
|
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$
|
|
6835
|
+
if (DESCRIPTORS$3 && !hasOwn$3(TypedArrayPrototype$1, TO_STRING_TAG)) {
|
|
7129
6836
|
TYPED_ARRAY_TAG_REQUIRED = true;
|
|
7130
|
-
defineBuiltInAccessor$
|
|
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$
|
|
7137
|
-
createNonEnumerableProperty$
|
|
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$
|
|
7155
|
-
var fails$
|
|
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$
|
|
7160
|
-
var Int8Array$3 = globalThis$
|
|
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$
|
|
6869
|
+
var typedArrayConstructorsRequireWrappers = !NATIVE_ARRAY_BUFFER_VIEWS$1 || !fails$9(function () {
|
|
7163
6870
|
Int8Array$3(1);
|
|
7164
|
-
}) || !fails$
|
|
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$
|
|
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$
|
|
6929
|
+
var classof$4 = classof$f;
|
|
7223
6930
|
|
|
7224
6931
|
var isBigIntArray$2 = function (it) {
|
|
7225
|
-
var klass = classof$
|
|
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$
|
|
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$
|
|
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$
|
|
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$
|
|
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 $$
|
|
7378
|
-
var globalThis$
|
|
7379
|
-
var call$
|
|
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$
|
|
7393
|
-
var classof$
|
|
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$
|
|
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$
|
|
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$
|
|
7461
|
-
&& !hasOwn$
|
|
7462
|
-
&& !hasOwn$
|
|
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$
|
|
7466
|
-
&& (!hasOwn$
|
|
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
|
-
$$
|
|
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$
|
|
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$
|
|
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$
|
|
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
|
-
$$
|
|
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$
|
|
7645
|
-
var call$
|
|
7646
|
-
var uncurryThis$
|
|
7647
|
-
var fails$
|
|
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$
|
|
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$
|
|
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$
|
|
7667
|
-
return call$
|
|
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$
|
|
7730
|
-
var call$
|
|
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$
|
|
7442
|
+
var fails$7 = fails$E;
|
|
7736
7443
|
|
|
7737
|
-
var RangeError$1 = globalThis$
|
|
7738
|
-
var Int8Array$2 = globalThis$
|
|
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$
|
|
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$
|
|
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$
|
|
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$
|
|
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$
|
|
7832
|
-
var uncurryThis$
|
|
7833
|
-
var fails$
|
|
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$
|
|
7845
|
-
var nativeSort$1 = Uint16Array && uncurryThis$
|
|
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$
|
|
7555
|
+
var ACCEPT_INCORRECT_ARGUMENTS = !!nativeSort$1 && !(fails$6(function () {
|
|
7849
7556
|
nativeSort$1(new Uint16Array(2), null);
|
|
7850
|
-
}) && fails$
|
|
7557
|
+
}) && fails$6(function () {
|
|
7851
7558
|
nativeSort$1(new Uint16Array(2), {});
|
|
7852
7559
|
}));
|
|
7853
7560
|
|
|
7854
|
-
var STABLE_SORT$1 = !!nativeSort$1 && !fails$
|
|
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$
|
|
7608
|
+
var globalThis$8 = globalThis_1;
|
|
7902
7609
|
var apply = functionApply;
|
|
7903
7610
|
var ArrayBufferViewCore$3 = arrayBufferViewCore;
|
|
7904
|
-
var fails$
|
|
7611
|
+
var fails$5 = fails$E;
|
|
7905
7612
|
var arraySlice = arraySlice$5;
|
|
7906
7613
|
|
|
7907
|
-
var Int8Array$1 = globalThis$
|
|
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$
|
|
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$
|
|
7624
|
+
var FORCED$2 = fails$5(function () {
|
|
7918
7625
|
return [1, 2].toLocaleString() !== new Int8Array$1([1, 2]).toLocaleString();
|
|
7919
|
-
}) || !fails$
|
|
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$
|
|
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$
|
|
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$
|
|
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$
|
|
7732
|
+
throw new $TypeError$6($String(argument) + ' is not an object or undefined');
|
|
8026
7733
|
};
|
|
8027
7734
|
|
|
8028
|
-
var $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$
|
|
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$
|
|
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$
|
|
7766
|
+
throw new $TypeError$4('Incorrect `alphabet` option');
|
|
8060
7767
|
};
|
|
8061
7768
|
|
|
8062
|
-
var globalThis$
|
|
8063
|
-
var uncurryThis$
|
|
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$
|
|
8075
|
-
var TypeError$1 = globalThis$
|
|
8076
|
-
var at = uncurryThis$
|
|
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$
|
|
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$
|
|
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$
|
|
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$
|
|
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$
|
|
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$
|
|
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$
|
|
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$
|
|
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$
|
|
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$
|
|
7933
|
+
if (classof$1(argument) === 'Uint8Array') return argument;
|
|
7934
|
+
throw new $TypeError$3('Argument is not an Uint8Array');
|
|
8228
7935
|
};
|
|
8229
7936
|
|
|
8230
|
-
var $$
|
|
8231
|
-
var globalThis$
|
|
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$
|
|
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) $$
|
|
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$
|
|
8268
|
-
var uncurryThis$
|
|
7974
|
+
var globalThis$5 = globalThis_1;
|
|
7975
|
+
var uncurryThis$8 = functionUncurryThis;
|
|
8269
7976
|
|
|
8270
|
-
var Uint8Array$3 = globalThis$
|
|
8271
|
-
var 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$
|
|
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$
|
|
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$
|
|
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 $$
|
|
8294
|
-
var globalThis$
|
|
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$
|
|
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 $$
|
|
8326
|
-
var globalThis$
|
|
8327
|
-
var uncurryThis$
|
|
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$
|
|
8044
|
+
var charAt$1 = uncurryThis$7(''.charAt);
|
|
8338
8045
|
|
|
8339
|
-
var Uint8Array$2 = globalThis$
|
|
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) $$
|
|
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 $$
|
|
8386
|
-
var globalThis$
|
|
8387
|
-
var uncurryThis$
|
|
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$
|
|
8392
|
-
var join = uncurryThis$
|
|
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$
|
|
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) $$
|
|
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 =
|
|
8440
|
-
const resolvedPath =
|
|
8441
|
-
if (resolvedPath.indexOf(resolvedBase +
|
|
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
|
|
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
|
|
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
|
-
|
|
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
|
|
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
|
|
8202
|
+
await fs__default.promises.chmod(filePath, 0o644);
|
|
8525
8203
|
}
|
|
8526
|
-
await
|
|
8527
|
-
await
|
|
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
|
|
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
|
|
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$
|
|
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$
|
|
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 $$
|
|
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
|
-
$$
|
|
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$
|
|
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$
|
|
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 $$
|
|
8631
|
-
var uncurryThis$
|
|
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$
|
|
8637
|
-
var fails$
|
|
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$
|
|
8647
|
-
var push = uncurryThis$
|
|
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$
|
|
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$
|
|
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$
|
|
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$
|
|
8703
|
-
var yString = toString$
|
|
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
|
-
$$
|
|
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$
|
|
8746
|
-
var anObject$
|
|
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$
|
|
8429
|
+
if (!stringHandling || typeof obj !== 'string') anObject$4(obj);
|
|
8752
8430
|
var method = getIteratorMethod(obj);
|
|
8753
|
-
return getIteratorDirect$2(anObject$
|
|
8431
|
+
return getIteratorDirect$2(anObject$4(method !== undefined ? call$3(method, obj) : obj));
|
|
8754
8432
|
};
|
|
8755
8433
|
|
|
8756
|
-
var $$
|
|
8757
|
-
var call$
|
|
8434
|
+
var $$7 = _export;
|
|
8435
|
+
var call$2 = functionCall;
|
|
8758
8436
|
var aCallable$2 = aCallable$l;
|
|
8759
|
-
var anObject$
|
|
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$
|
|
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$
|
|
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
|
-
$$
|
|
8489
|
+
$$7({ target: 'Iterator', proto: true, real: true, forced: FORCED }, {
|
|
8812
8490
|
flatMap: function flatMap(mapper) {
|
|
8813
|
-
anObject$
|
|
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$
|
|
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
|
|
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 =>
|
|
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 +
|
|
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 =
|
|
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
|
|
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 =>
|
|
10295
|
-
return [...byDirectory].filter(([directory]) =>
|
|
10296
|
-
skill:
|
|
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
|
-
|
|
10384
|
+
fs__default.mkdirSync(skillPath(catalogDir, ".agents", "plugins"), {
|
|
10372
10385
|
recursive: true
|
|
10373
10386
|
});
|
|
10374
|
-
|
|
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
|
-
|
|
10395
|
+
fs__default.mkdirSync(agentsDir, {
|
|
10383
10396
|
recursive: true
|
|
10384
10397
|
});
|
|
10385
|
-
const extractDir =
|
|
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
|
-
|
|
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
|
-
|
|
10409
|
+
fs__default.rmSync(target, {
|
|
10397
10410
|
recursive: true,
|
|
10398
10411
|
force: true
|
|
10399
10412
|
});
|
|
10400
|
-
|
|
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
|
-
|
|
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 =>
|
|
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) {
|