+ if (!this.preserveMultipleSlashes) {
+ for (let i = 1; i < parts.length - 1; i++) {
+ const p = parts[i];
+ // don't squeeze out UNC patterns
+ if (i === 1 && p === '' && parts[0] === '')
+ continue;
+ if (p === '.' || p === '') {
+ didSomething = true;
+ parts.splice(i, 1);
+ i--;
+ }
+ }
+ if (parts[0] === '.' &&
+ parts.length === 2 &&
+ (parts[1] === '.' || parts[1] === '')) {
+ didSomething = true;
+ parts.pop();
+ }
+ }
+ // //../ -> /
+ let dd = 0;
+ while (-1 !== (dd = parts.indexOf('..', dd + 1))) {
+ const p = parts[dd - 1];
+ if (p &&
+ p !== '.' &&
+ p !== '..' &&
+ p !== '**' &&
+ !(this.isWindows && /^[a-z]:$/i.test(p))) {
+ didSomething = true;
+ parts.splice(dd - 1, 2);
+ dd -= 2;
+ }
+ }
+ } while (didSomething);
+ return parts.length === 0 ? [''] : parts;
+ }
+ // First phase: single-pattern processing
+ // is 1 or more portions
+ // is 1 or more portions
+ // is any portion other than ., .., '', or **
+ // is . or ''
+ //
+ // **/.. is *brutal* for filesystem walking performance, because
+ // it effectively resets the recursive walk each time it occurs,
+ // and ** cannot be reduced out by a .. pattern part like a regexp
+ // or most strings (other than .., ., and '') can be.
+ //
+ // /**/..//
/ -> {/..//
/,/**//
/}
+ // // -> /
+ // //../ -> /
+ // **/**/ -> **/
+ //
+ // **/*/ -> */**/ <== not valid because ** doesn't follow
+ // this WOULD be allowed if ** did follow symlinks, or * didn't
+ firstPhasePreProcess(globParts) {
+ let didSomething = false;
+ do {
+ didSomething = false;
+ // /**/..//
/ -> {/..//
/,/**//
/}
+ for (let parts of globParts) {
+ let gs = -1;
+ while (-1 !== (gs = parts.indexOf('**', gs + 1))) {
+ let gss = gs;
+ while (parts[gss + 1] === '**') {
+ // /**/**/ -> /**/
+ gss++;
+ }
+ // eg, if gs is 2 and gss is 4, that means we have 3 **
+ // parts, and can remove 2 of them.
+ if (gss > gs) {
+ parts.splice(gs + 1, gss - gs);
+ }
+ let next = parts[gs + 1];
+ const p = parts[gs + 2];
+ const p2 = parts[gs + 3];
+ if (next !== '..')
+ continue;
+ if (!p ||
+ p === '.' ||
+ p === '..' ||
+ !p2 ||
+ p2 === '.' ||
+ p2 === '..') {
+ continue;
+ }
+ didSomething = true;
+ // edit parts in place, and push the new one
+ parts.splice(gs, 1);
+ const other = parts.slice(0);
+ other[gs] = '**';
+ globParts.push(other);
+ gs--;
+ }
+ // // -> /
+ if (!this.preserveMultipleSlashes) {
+ for (let i = 1; i < parts.length - 1; i++) {
+ const p = parts[i];
+ // don't squeeze out UNC patterns
+ if (i === 1 && p === '' && parts[0] === '')
+ continue;
+ if (p === '.' || p === '') {
+ didSomething = true;
+ parts.splice(i, 1);
+ i--;
+ }
+ }
+ if (parts[0] === '.' &&
+ parts.length === 2 &&
+ (parts[1] === '.' || parts[1] === '')) {
+ didSomething = true;
+ parts.pop();
+ }
+ }
+ // //../ -> /
+ let dd = 0;
+ while (-1 !== (dd = parts.indexOf('..', dd + 1))) {
+ const p = parts[dd - 1];
+ if (p && p !== '.' && p !== '..' && p !== '**') {
+ didSomething = true;
+ const needDot = dd === 1 && parts[dd + 1] === '**';
+ const splin = needDot ? ['.'] : [];
+ parts.splice(dd - 1, 2, ...splin);
+ if (parts.length === 0)
+ parts.push('');
+ dd -= 2;
+ }
+ }
+ }
+ } while (didSomething);
+ return globParts;
+ }
+ // second phase: multi-pattern dedupes
+ // {/*/,//} -> /*/
+ // {/,/} -> /
+ // {/**/,/} -> /**/
+ //
+ // {/**/,/**//} -> /**/
+ // ^-- not valid because ** doens't follow symlinks
+ secondPhasePreProcess(globParts) {
+ for (let i = 0; i < globParts.length - 1; i++) {
+ for (let j = i + 1; j < globParts.length; j++) {
+ const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
+ if (matched) {
+ globParts[i] = [];
+ globParts[j] = matched;
+ break;
+ }
+ }
+ }
+ return globParts.filter(gs => gs.length);
+ }
+ partsMatch(a, b, emptyGSMatch = false) {
+ let ai = 0;
+ let bi = 0;
+ let result = [];
+ let which = '';
+ while (ai < a.length && bi < b.length) {
+ if (a[ai] === b[bi]) {
+ result.push(which === 'b' ? b[bi] : a[ai]);
+ ai++;
+ bi++;
+ }
+ else if (emptyGSMatch && a[ai] === '**' && b[bi] === a[ai + 1]) {
+ result.push(a[ai]);
+ ai++;
+ }
+ else if (emptyGSMatch && b[bi] === '**' && a[ai] === b[bi + 1]) {
+ result.push(b[bi]);
+ bi++;
+ }
+ else if (a[ai] === '*' &&
+ b[bi] &&
+ (this.options.dot || !b[bi].startsWith('.')) &&
+ b[bi] !== '**') {
+ if (which === 'b')
+ return false;
+ which = 'a';
+ result.push(a[ai]);
+ ai++;
+ bi++;
+ }
+ else if (b[bi] === '*' &&
+ a[ai] &&
+ (this.options.dot || !a[ai].startsWith('.')) &&
+ a[ai] !== '**') {
+ if (which === 'a')
+ return false;
+ which = 'b';
+ result.push(b[bi]);
+ ai++;
+ bi++;
+ }
+ else {
+ return false;
+ }
+ }
+ // if we fall out of the loop, it means they two are identical
+ // as long as their lengths match
+ return a.length === b.length && result;
+ }
+ parseNegate() {
+ if (this.nonegate)
+ return;
+ const pattern = this.pattern;
+ let negate = false;
+ let negateOffset = 0;
+ for (let i = 0; i < pattern.length && pattern.charAt(i) === '!'; i++) {
+ negate = !negate;
+ negateOffset++;
+ }
+ if (negateOffset)
+ this.pattern = pattern.slice(negateOffset);
+ this.negate = negate;
+ }
+ // set partial to true to test if, for example,
+ // "/a/b" matches the start of "/*/b/*/d"
+ // Partial means, if you run out of file before you run
+ // out of pattern, then that's fine, as long as all
+ // the parts match.
+ matchOne(file, pattern, partial = false) {
+ let fileStartIndex = 0;
+ let patternStartIndex = 0;
+ // UNC paths like //?/X:/... can match X:/... and vice versa
+ // Drive letters in absolute drive or unc paths are always compared
+ // case-insensitively.
+ if (this.isWindows) {
+ const fileDrive = typeof file[0] === 'string' && /^[a-z]:$/i.test(file[0]);
+ const fileUNC = !fileDrive &&
+ file[0] === '' &&
+ file[1] === '' &&
+ file[2] === '?' &&
+ /^[a-z]:$/i.test(file[3]);
+ const patternDrive = typeof pattern[0] === 'string' && /^[a-z]:$/i.test(pattern[0]);
+ const patternUNC = !patternDrive &&
+ pattern[0] === '' &&
+ pattern[1] === '' &&
+ pattern[2] === '?' &&
+ typeof pattern[3] === 'string' &&
+ /^[a-z]:$/i.test(pattern[3]);
+ const fdi = fileUNC ? 3
+ : fileDrive ? 0
+ : undefined;
+ const pdi = patternUNC ? 3
+ : patternDrive ? 0
+ : undefined;
+ if (typeof fdi === 'number' && typeof pdi === 'number') {
+ const [fd, pd] = [
+ file[fdi],
+ pattern[pdi],
+ ];
+ // start matching at the drive letter index of each
+ if (fd.toLowerCase() === pd.toLowerCase()) {
+ pattern[pdi] = fd;
+ patternStartIndex = pdi;
+ fileStartIndex = fdi;
+ }
+ }
+ }
+ // resolve and reduce . and .. portions in the file as well.
+ // don't need to do the second phase, because it's only one string[]
+ const { optimizationLevel = 1 } = this.options;
+ if (optimizationLevel >= 2) {
+ file = this.levelTwoFileOptimize(file);
+ }
+ if (pattern.includes(GLOBSTAR)) {
+ return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);
+ }
+ return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);
+ }
+ #matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
+ // split the pattern into head, tail, and middle of ** delimited parts
+ const firstgs = pattern.indexOf(GLOBSTAR, patternIndex);
+ const lastgs = pattern.lastIndexOf(GLOBSTAR);
+ // split the pattern up into globstar-delimited sections
+ // the tail has to be at the end, and the others just have
+ // to be found in order from the head.
+ const [head, body, tail] = partial ?
+ [
+ pattern.slice(patternIndex, firstgs),
+ pattern.slice(firstgs + 1),
+ [],
+ ]
+ : [
+ pattern.slice(patternIndex, firstgs),
+ pattern.slice(firstgs + 1, lastgs),
+ pattern.slice(lastgs + 1),
+ ];
+ // check the head, from the current file/pattern index.
+ if (head.length) {
+ const fileHead = file.slice(fileIndex, fileIndex + head.length);
+ if (!this.#matchOne(fileHead, head, partial, 0, 0)) {
+ return false;
+ }
+ fileIndex += head.length;
+ patternIndex += head.length;
+ }
+ // now we know the head matches!
+ // if the last portion is not empty, it MUST match the end
+ // check the tail
+ let fileTailMatch = 0;
+ if (tail.length) {
+ // if head + tail > file, then we cannot possibly match
+ if (tail.length + fileIndex > file.length)
+ return false;
+ // try to match the tail
+ let tailStart = file.length - tail.length;
+ if (this.#matchOne(file, tail, partial, tailStart, 0)) {
+ fileTailMatch = tail.length;
+ }
+ else {
+ // affordance for stuff like a/**/* matching a/b/
+ // if the last file portion is '', and there's more to the pattern
+ // then try without the '' bit.
+ if (file[file.length - 1] !== '' ||
+ fileIndex + tail.length === file.length) {
+ return false;
+ }
+ tailStart--;
+ if (!this.#matchOne(file, tail, partial, tailStart, 0)) {
+ return false;
+ }
+ fileTailMatch = tail.length + 1;
+ }
+ }
+ // now we know the tail matches!
+ // the middle is zero or more portions wrapped in **, possibly
+ // containing more ** sections.
+ // so a/**/b/**/c/**/d has become **/b/**/c/**
+ // if it's empty, it means a/**/b, just verify we have no bad dots
+ // if there's no tail, so it ends on /**, then we must have *something*
+ // after the head, or it's not a matc
+ if (!body.length) {
+ let sawSome = !!fileTailMatch;
+ for (let i = fileIndex; i < file.length - fileTailMatch; i++) {
+ const f = String(file[i]);
+ sawSome = true;
+ if (f === '.' ||
+ f === '..' ||
+ (!this.options.dot && f.startsWith('.'))) {
+ return false;
+ }
+ }
+ // in partial mode, we just need to get past all file parts
+ return partial || sawSome;
+ }
+ // now we know that there's one or more body sections, which can
+ // be matched anywhere from the 0 index (because the head was pruned)
+ // through to the length-fileTailMatch index.
+ // split the body up into sections, and note the minimum index it can
+ // be found at (start with the length of all previous segments)
+ // [section, before, after]
+ const bodySegments = [[[], 0]];
+ let currentBody = bodySegments[0];
+ let nonGsParts = 0;
+ const nonGsPartsSums = [0];
+ for (const b of body) {
+ if (b === GLOBSTAR) {
+ nonGsPartsSums.push(nonGsParts);
+ currentBody = [[], 0];
+ bodySegments.push(currentBody);
+ }
+ else {
+ currentBody[0].push(b);
+ nonGsParts++;
+ }
+ }
+ let i = bodySegments.length - 1;
+ const fileLength = file.length - fileTailMatch;
+ for (const b of bodySegments) {
+ b[1] = fileLength - (nonGsPartsSums[i--] + b[0].length);
+ }
+ return !!this.#matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
+ }
+ // return false for "nope, not matching"
+ // return null for "not matching, cannot keep trying"
+ #matchGlobStarBodySections(file,
+ // pattern section, last possible position for it
+ bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
+ // take the first body segment, and walk from fileIndex to its "after"
+ // value at the end
+ // If it doesn't match at that position, we increment, until we hit
+ // that final possible position, and give up.
+ // If it does match, then advance and try to rest.
+ // If any of them fail we keep walking forward.
+ // this is still a bit recursively painful, but it's more constrained
+ // than previous implementations, because we never test something that
+ // can't possibly be a valid matching condition.
+ const bs = bodySegments[bodyIndex];
+ if (!bs) {
+ // just make sure that there's no bad dots
+ for (let i = fileIndex; i < file.length; i++) {
+ sawTail = true;
+ const f = file[i];
+ if (f === '.' ||
+ f === '..' ||
+ (!this.options.dot && f.startsWith('.'))) {
+ return false;
+ }
+ }
+ return sawTail;
+ }
+ // have a non-globstar body section to test
+ const [body, after] = bs;
+ while (fileIndex <= after) {
+ const m = this.#matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);
+ // if limit exceeded, no match. intentional false negative,
+ // acceptable break in correctness for security.
+ if (m && globStarDepth < this.maxGlobstarRecursion) {
+ // match! see if the rest match. if so, we're done!
+ const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
+ if (sub !== false) {
+ return sub;
+ }
+ }
+ const f = file[fileIndex];
+ if (f === '.' ||
+ f === '..' ||
+ (!this.options.dot && f.startsWith('.'))) {
+ return false;
+ }
+ fileIndex++;
+ }
+ // walked off. no point continuing
+ return partial || null;
+ }
+ #matchOne(file, pattern, partial, fileIndex, patternIndex) {
+ let fi;
+ let pi;
+ let pl;
+ let fl;
+ for (fi = fileIndex,
+ pi = patternIndex,
+ fl = file.length,
+ pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+ this.debug('matchOne loop');
+ let p = pattern[pi];
+ let f = file[fi];
+ this.debug(pattern, p, f);
+ // should be impossible.
+ // some invalid regexp stuff in the set.
+ /* c8 ignore start */
+ if (p === false || p === GLOBSTAR) {
+ return false;
+ }
+ /* c8 ignore stop */
+ // something other than **
+ // non-magic patterns just have to match exactly
+ // patterns with magic have been turned into regexps.
+ let hit;
+ if (typeof p === 'string') {
+ hit = f === p;
+ this.debug('string match', p, f, hit);
+ }
+ else {
+ hit = p.test(f);
+ this.debug('pattern match', p, f, hit);
+ }
+ if (!hit)
+ return false;
+ }
+ // Note: ending in / means that we'll get a final ""
+ // at the end of the pattern. This can only match a
+ // corresponding "" at the end of the file.
+ // If the file ends in /, then it can only match a
+ // a pattern that ends in /, unless the pattern just
+ // doesn't have any more for it. But, a/b/ should *not*
+ // match "a/b/*", even though "" matches against the
+ // [^/]*? pattern, except in partial mode, where it might
+ // simply not be reached yet.
+ // However, a/b/ should still satisfy a/*
+ // now either we fell off the end of the pattern, or we're done.
+ if (fi === fl && pi === pl) {
+ // ran out of pattern and filename at the same time.
+ // an exact hit!
+ return true;
+ }
+ else if (fi === fl) {
+ // ran out of file, but still had pattern left.
+ // this is ok if we're doing the match as part of
+ // a glob fs traversal.
+ return partial;
+ }
+ else if (pi === pl) {
+ // ran out of pattern, still have file left.
+ // this is only acceptable if we're on the very last
+ // empty segment of a file with a trailing slash.
+ // a/* should match a/b/
+ return fi === fl - 1 && file[fi] === '';
+ /* c8 ignore start */
+ }
+ else {
+ // should be unreachable.
+ throw new Error('wtf?');
+ }
+ /* c8 ignore stop */
+ }
+ braceExpand() {
+ return braceExpand(this.pattern, this.options);
+ }
+ parse(pattern) {
+ assertValidPattern(pattern);
+ const options = this.options;
+ // shortcuts
+ if (pattern === '**')
+ return GLOBSTAR;
+ if (pattern === '')
+ return '';
+ // far and away, the most common glob pattern parts are
+ // *, *.*, and *. Add a fast check method for those.
+ let m;
+ let fastTest = null;
+ if ((m = pattern.match(starRE))) {
+ fastTest = options.dot ? starTestDot : starTest;
+ }
+ else if ((m = pattern.match(starDotExtRE))) {
+ fastTest = (options.nocase ?
+ options.dot ?
+ starDotExtTestNocaseDot
+ : starDotExtTestNocase
+ : options.dot ? starDotExtTestDot
+ : starDotExtTest)(m[1]);
+ }
+ else if ((m = pattern.match(qmarksRE))) {
+ fastTest = (options.nocase ?
+ options.dot ?
+ qmarksTestNocaseDot
+ : qmarksTestNocase
+ : options.dot ? qmarksTestDot
+ : qmarksTest)(m);
+ }
+ else if ((m = pattern.match(starDotStarRE))) {
+ fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
+ }
+ else if ((m = pattern.match(dotStarRE))) {
+ fastTest = dotStarTest;
+ }
+ const re = AST.fromGlob(pattern, this.options).toMMPattern();
+ if (fastTest && typeof re === 'object') {
+ // Avoids overriding in frozen environments
+ Reflect.defineProperty(re, 'test', { value: fastTest });
+ }
+ return re;
+ }
+ makeRe() {
+ if (this.regexp || this.regexp === false)
+ return this.regexp;
+ // at this point, this.set is a 2d array of partial
+ // pattern strings, or "**".
+ //
+ // It's better to use .match(). This function shouldn't
+ // be used, really, but it's pretty convenient sometimes,
+ // when you just want to work with a regex.
+ const set = this.set;
+ if (!set.length) {
+ this.regexp = false;
+ return this.regexp;
+ }
+ const options = this.options;
+ const twoStar = options.noglobstar ? esm_star
+ : options.dot ? twoStarDot
+ : twoStarNoDot;
+ const flags = new Set(options.nocase ? ['i'] : []);
+ // regexpify non-globstar patterns
+ // if ** is only item, then we just do one twoStar
+ // if ** is first, and there are more, prepend (\/|twoStar\/)? to next
+ // if ** is last, append (\/twoStar|) to previous
+ // if ** is in the middle, append (\/|\/twoStar\/) to previous
+ // then filter out GLOBSTAR symbols
+ let re = set
+ .map(pattern => {
+ const pp = pattern.map(p => {
+ if (p instanceof RegExp) {
+ for (const f of p.flags.split(''))
+ flags.add(f);
+ }
+ return (typeof p === 'string' ? esm_regExpEscape(p)
+ : p === GLOBSTAR ? GLOBSTAR
+ : p._src);
+ });
+ pp.forEach((p, i) => {
+ const next = pp[i + 1];
+ const prev = pp[i - 1];
+ if (p !== GLOBSTAR || prev === GLOBSTAR) {
+ return;
+ }
+ if (prev === undefined) {
+ if (next !== undefined && next !== GLOBSTAR) {
+ pp[i + 1] = '(?:\\/|' + twoStar + '\\/)?' + next;
+ }
+ else {
+ pp[i] = twoStar;
+ }
+ }
+ else if (next === undefined) {
+ pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + ')?';
+ }
+ else if (next !== GLOBSTAR) {
+ pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + '\\/)' + next;
+ pp[i + 1] = GLOBSTAR;
+ }
+ });
+ const filtered = pp.filter(p => p !== GLOBSTAR);
+ // For partial matches, we need to make the pattern match
+ // any prefix of the full path. We do this by generating
+ // alternative patterns that match progressively longer prefixes.
+ if (this.partial && filtered.length >= 1) {
+ const prefixes = [];
+ for (let i = 1; i <= filtered.length; i++) {
+ prefixes.push(filtered.slice(0, i).join('/'));
+ }
+ return '(?:' + prefixes.join('|') + ')';
+ }
+ return filtered.join('/');
+ })
+ .join('|');
+ // need to wrap in parens if we had more than one thing with |,
+ // otherwise only the first will be anchored to ^ and the last to $
+ const [open, close] = set.length > 1 ? ['(?:', ')'] : ['', ''];
+ // must match entire pattern
+ // ending in a * or ** will make it less strict.
+ re = '^' + open + re + close + '$';
+ // In partial mode, '/' should always match as it's a valid prefix for any pattern
+ if (this.partial) {
+ re = '^(?:\\/|' + open + re.slice(1, -1) + close + ')$';
+ }
+ // can match anything, as long as it's not this.
+ if (this.negate)
+ re = '^(?!' + re + ').+$';
+ try {
+ this.regexp = new RegExp(re, [...flags].join(''));
+ /* c8 ignore start */
+ }
+ catch {
+ // should be impossible
+ this.regexp = false;
+ }
+ /* c8 ignore stop */
+ return this.regexp;
+ }
+ slashSplit(p) {
+ // if p starts with // on windows, we preserve that
+ // so that UNC paths aren't broken. Otherwise, any number of
+ // / characters are coalesced into one, unless
+ // preserveMultipleSlashes is set to true.
+ if (this.preserveMultipleSlashes) {
+ return p.split('/');
+ }
+ else if (this.isWindows && /^\/\/[^/]+/.test(p)) {
+ // add an extra '' for the one we lose
+ return ['', ...p.split(/\/+/)];
+ }
+ else {
+ return p.split(/\/+/);
+ }
+ }
+ match(f, partial = this.partial) {
+ this.debug('match', f, this.pattern);
+ // short-circuit in the case of busted things.
+ // comments, etc.
+ if (this.comment) {
+ return false;
+ }
+ if (this.empty) {
+ return f === '';
+ }
+ if (f === '/' && partial) {
+ return true;
+ }
+ const options = this.options;
+ // windows: need to use /, not \
+ if (this.isWindows) {
+ f = f.split('\\').join('/');
+ }
+ // treat the test path as a set of pathparts.
+ const ff = this.slashSplit(f);
+ this.debug(this.pattern, 'split', ff);
+ // just ONE of the pattern sets in this.set needs to match
+ // in order for it to be valid. If negating, then just one
+ // match means that we have failed.
+ // Either way, return on the first hit.
+ const set = this.set;
+ this.debug(this.pattern, 'set', set);
+ // Find the basename of the path by looking for the last non-empty segment
+ let filename = ff[ff.length - 1];
+ if (!filename) {
+ for (let i = ff.length - 2; !filename && i >= 0; i--) {
+ filename = ff[i];
+ }
+ }
+ for (const pattern of set) {
+ let file = ff;
+ if (options.matchBase && pattern.length === 1) {
+ file = [filename];
+ }
+ const hit = this.matchOne(file, pattern, partial);
+ if (hit) {
+ if (options.flipNegate) {
+ return true;
+ }
+ return !this.negate;
+ }
+ }
+ // didn't get any hits. this is success if it's a negative
+ // pattern, failure otherwise.
+ if (options.flipNegate) {
+ return false;
+ }
+ return this.negate;
+ }
+ static defaults(def) {
+ return esm_minimatch.defaults(def).Minimatch;
+ }
+}
+/* c8 ignore start */
+
+
+
+/* c8 ignore stop */
+esm_minimatch.AST = AST;
+esm_minimatch.Minimatch = esm_Minimatch;
+esm_minimatch.escape = escape_escape;
+esm_minimatch.unescape = unescape_unescape;
+//# sourceMappingURL=index.js.map
+;// CONCATENATED MODULE: ./node_modules/@actions/glob/lib/internal-path.js
+
+
+
+const lib_internal_path_IS_WINDOWS = process.platform === 'win32';
+/**
+ * Helper class for parsing paths into segments
+ */
+class lib_internal_path_Path {
+ /**
+ * Constructs a Path
+ * @param itemPath Path or array of segments
+ */
+ constructor(itemPath) {
+ this.segments = [];
+ // String
+ if (typeof itemPath === 'string') {
+ external_assert_(itemPath, `Parameter 'itemPath' must not be empty`);
+ // Normalize slashes and trim unnecessary trailing slash
+ itemPath = internal_path_helper_safeTrimTrailingSeparator(itemPath);
+ // Not rooted
+ if (!internal_path_helper_hasRoot(itemPath)) {
+ this.segments = itemPath.split(external_path_.sep);
+ }
+ // Rooted
+ else {
+ // Add all segments, while not at the root
+ let remaining = itemPath;
+ let dir = internal_path_helper_dirname(remaining);
+ while (dir !== remaining) {
+ // Add the segment
+ const basename = external_path_.basename(remaining);
+ this.segments.unshift(basename);
+ // Truncate the last segment
+ remaining = dir;
+ dir = internal_path_helper_dirname(remaining);
+ }
+ // Remainder is the root
+ this.segments.unshift(remaining);
+ }
+ }
+ // Array
+ else {
+ // Must not be empty
+ external_assert_(itemPath.length > 0, `Parameter 'itemPath' must not be an empty array`);
+ // Each segment
+ for (let i = 0; i < itemPath.length; i++) {
+ let segment = itemPath[i];
+ // Must not be empty
+ external_assert_(segment, `Parameter 'itemPath' must not contain any empty segments`);
+ // Normalize slashes
+ segment = lib_internal_path_helper_normalizeSeparators(itemPath[i]);
+ // Root segment
+ if (i === 0 && internal_path_helper_hasRoot(segment)) {
+ segment = internal_path_helper_safeTrimTrailingSeparator(segment);
+ external_assert_(segment === internal_path_helper_dirname(segment), `Parameter 'itemPath' root segment contains information for multiple segments`);
+ this.segments.push(segment);
+ }
+ // All other segments
+ else {
+ // Must not contain slash
+ external_assert_(!segment.includes(external_path_.sep), `Parameter 'itemPath' contains unexpected path separators`);
+ this.segments.push(segment);
+ }
+ }
+ }
+ }
+ /**
+ * Converts the path to it's string representation
+ */
+ toString() {
+ // First segment
+ let result = this.segments[0];
+ // All others
+ let skipSlash = result.endsWith(external_path_.sep) || (lib_internal_path_IS_WINDOWS && /^[A-Z]:$/i.test(result));
+ for (let i = 1; i < this.segments.length; i++) {
+ if (skipSlash) {
+ skipSlash = false;
+ }
+ else {
+ result += external_path_.sep;
+ }
+ result += this.segments[i];
+ }
+ return result;
+ }
+}
+//# sourceMappingURL=internal-path.js.map
+;// CONCATENATED MODULE: ./node_modules/@actions/glob/lib/internal-pattern.js
+
+
+
+
+
+
+
+const lib_internal_pattern_IS_WINDOWS = process.platform === 'win32';
+class lib_internal_pattern_Pattern {
+ constructor(patternOrNegate, isImplicitPattern = false, segments, homedir) {
+ /**
+ * Indicates whether matches should be excluded from the result set
+ */
+ this.negate = false;
+ // Pattern overload
+ let pattern;
+ if (typeof patternOrNegate === 'string') {
+ pattern = patternOrNegate.trim();
+ }
+ // Segments overload
+ else {
+ // Convert to pattern
+ segments = segments || [];
+ external_assert_(segments.length, `Parameter 'segments' must not empty`);
+ const root = lib_internal_pattern_Pattern.getLiteral(segments[0]);
+ external_assert_(root && internal_path_helper_hasAbsoluteRoot(root), `Parameter 'segments' first element must be a root path`);
+ pattern = new lib_internal_path_Path(segments).toString().trim();
+ if (patternOrNegate) {
+ pattern = `!${pattern}`;
+ }
+ }
+ // Negate
+ while (pattern.startsWith('!')) {
+ this.negate = !this.negate;
+ pattern = pattern.substr(1).trim();
+ }
+ // Normalize slashes and ensures absolute root
+ pattern = lib_internal_pattern_Pattern.fixupPattern(pattern, homedir);
+ // Segments
+ this.segments = new lib_internal_path_Path(pattern).segments;
+ // Trailing slash indicates the pattern should only match directories, not regular files
+ this.trailingSeparator = lib_internal_path_helper_normalizeSeparators(pattern)
+ .endsWith(external_path_.sep);
+ pattern = internal_path_helper_safeTrimTrailingSeparator(pattern);
+ // Search path (literal path prior to the first glob segment)
+ let foundGlob = false;
+ const searchSegments = this.segments
+ .map(x => lib_internal_pattern_Pattern.getLiteral(x))
+ .filter(x => !foundGlob && !(foundGlob = x === ''));
+ this.searchPath = new lib_internal_path_Path(searchSegments).toString();
+ // Root RegExp (required when determining partial match)
+ this.rootRegExp = new RegExp(lib_internal_pattern_Pattern.regExpEscape(searchSegments[0]), lib_internal_pattern_IS_WINDOWS ? 'i' : '');
+ this.isImplicitPattern = isImplicitPattern;
+ // Create minimatch
+ const minimatchOptions = {
+ dot: true,
+ nobrace: true,
+ nocase: lib_internal_pattern_IS_WINDOWS,
+ nocomment: true,
+ noext: true,
+ nonegate: true
+ };
+ pattern = lib_internal_pattern_IS_WINDOWS ? pattern.replace(/\\/g, '/') : pattern;
+ this.minimatch = new esm_Minimatch(pattern, minimatchOptions);
+ }
+ /**
+ * Matches the pattern against the specified path
+ */
+ match(itemPath) {
+ // Last segment is globstar?
+ if (this.segments[this.segments.length - 1] === '**') {
+ // Normalize slashes
+ itemPath = lib_internal_path_helper_normalizeSeparators(itemPath);
+ // Append a trailing slash. Otherwise Minimatch will not match the directory immediately
+ // preceding the globstar. For example, given the pattern `/foo/**`, Minimatch returns
+ // false for `/foo` but returns true for `/foo/`. Append a trailing slash to handle that quirk.
+ if (!itemPath.endsWith(external_path_.sep) && this.isImplicitPattern === false) {
+ // Note, this is safe because the constructor ensures the pattern has an absolute root.
+ // For example, formats like C: and C:foo on Windows are resolved to an absolute root.
+ itemPath = `${itemPath}${external_path_.sep}`;
+ }
+ }
+ else {
+ // Normalize slashes and trim unnecessary trailing slash
+ itemPath = internal_path_helper_safeTrimTrailingSeparator(itemPath);
+ }
+ // Match
+ if (this.minimatch.match(itemPath)) {
+ return this.trailingSeparator ? lib_internal_match_kind_MatchKind.Directory : lib_internal_match_kind_MatchKind.All;
+ }
+ return lib_internal_match_kind_MatchKind.None;
+ }
+ /**
+ * Indicates whether the pattern may match descendants of the specified path
+ */
+ partialMatch(itemPath) {
+ // Normalize slashes and trim unnecessary trailing slash
+ itemPath = internal_path_helper_safeTrimTrailingSeparator(itemPath);
+ // matchOne does not handle root path correctly
+ if (internal_path_helper_dirname(itemPath) === itemPath) {
+ return this.rootRegExp.test(itemPath);
+ }
+ return this.minimatch.matchOne(itemPath.split(lib_internal_pattern_IS_WINDOWS ? /\\+/ : /\/+/), this.minimatch.set[0], true);
+ }
+ /**
+ * Escapes glob patterns within a path
+ */
+ static globEscape(s) {
+ return (lib_internal_pattern_IS_WINDOWS ? s : s.replace(/\\/g, '\\\\')) // escape '\' on Linux/macOS
+ .replace(/(\[)(?=[^/]+\])/g, '[[]') // escape '[' when ']' follows within the path segment
+ .replace(/\?/g, '[?]') // escape '?'
+ .replace(/\*/g, '[*]'); // escape '*'
+ }
+ /**
+ * Normalizes slashes and ensures absolute root
+ */
+ static fixupPattern(pattern, homedir) {
+ // Empty
+ external_assert_(pattern, 'pattern cannot be empty');
+ // Must not contain `.` segment, unless first segment
+ // Must not contain `..` segment
+ const literalSegments = new lib_internal_path_Path(pattern).segments.map(x => lib_internal_pattern_Pattern.getLiteral(x));
+ external_assert_(literalSegments.every((x, i) => (x !== '.' || i === 0) && x !== '..'), `Invalid pattern '${pattern}'. Relative pathing '.' and '..' is not allowed.`);
+ // Must not contain globs in root, e.g. Windows UNC path \\foo\b*r
+ external_assert_(!internal_path_helper_hasRoot(pattern) || literalSegments[0], `Invalid pattern '${pattern}'. Root segment must not contain globs.`);
+ // Normalize slashes
+ pattern = lib_internal_path_helper_normalizeSeparators(pattern);
+ // Replace leading `.` segment
+ if (pattern === '.' || pattern.startsWith(`.${external_path_.sep}`)) {
+ pattern = lib_internal_pattern_Pattern.globEscape(process.cwd()) + pattern.substr(1);
+ }
+ // Replace leading `~` segment
+ else if (pattern === '~' || pattern.startsWith(`~${external_path_.sep}`)) {
+ homedir = homedir || external_os_namespaceObject.homedir();
+ external_assert_(homedir, 'Unable to determine HOME directory');
+ external_assert_(internal_path_helper_hasAbsoluteRoot(homedir), `Expected HOME directory to be a rooted path. Actual '${homedir}'`);
+ pattern = lib_internal_pattern_Pattern.globEscape(homedir) + pattern.substr(1);
+ }
+ // Replace relative drive root, e.g. pattern is C: or C:foo
+ else if (lib_internal_pattern_IS_WINDOWS &&
+ (pattern.match(/^[A-Z]:$/i) || pattern.match(/^[A-Z]:[^\\]/i))) {
+ let root = internal_path_helper_ensureAbsoluteRoot('C:\\dummy-root', pattern.substr(0, 2));
+ if (pattern.length > 2 && !root.endsWith('\\')) {
+ root += '\\';
+ }
+ pattern = lib_internal_pattern_Pattern.globEscape(root) + pattern.substr(2);
+ }
+ // Replace relative root, e.g. pattern is \ or \foo
+ else if (lib_internal_pattern_IS_WINDOWS && (pattern === '\\' || pattern.match(/^\\[^\\]/))) {
+ let root = internal_path_helper_ensureAbsoluteRoot('C:\\dummy-root', '\\');
+ if (!root.endsWith('\\')) {
+ root += '\\';
+ }
+ pattern = lib_internal_pattern_Pattern.globEscape(root) + pattern.substr(1);
+ }
+ // Otherwise ensure absolute root
+ else {
+ pattern = internal_path_helper_ensureAbsoluteRoot(lib_internal_pattern_Pattern.globEscape(process.cwd()), pattern);
+ }
+ return lib_internal_path_helper_normalizeSeparators(pattern);
+ }
+ /**
+ * Attempts to unescape a pattern segment to create a literal path segment.
+ * Otherwise returns empty string.
+ */
+ static getLiteral(segment) {
+ let literal = '';
+ for (let i = 0; i < segment.length; i++) {
+ const c = segment[i];
+ // Escape
+ if (c === '\\' && !lib_internal_pattern_IS_WINDOWS && i + 1 < segment.length) {
+ literal += segment[++i];
+ continue;
+ }
+ // Wildcard
+ else if (c === '*' || c === '?') {
+ return '';
+ }
+ // Character set
+ else if (c === '[' && i + 1 < segment.length) {
+ let set = '';
+ let closed = -1;
+ for (let i2 = i + 1; i2 < segment.length; i2++) {
+ const c2 = segment[i2];
+ // Escape
+ if (c2 === '\\' && !lib_internal_pattern_IS_WINDOWS && i2 + 1 < segment.length) {
+ set += segment[++i2];
+ continue;
+ }
+ // Closed
+ else if (c2 === ']') {
+ closed = i2;
+ break;
+ }
+ // Otherwise
+ else {
+ set += c2;
+ }
+ }
+ // Closed?
+ if (closed >= 0) {
+ // Cannot convert
+ if (set.length > 1) {
+ return '';
+ }
+ // Convert to literal
+ if (set) {
+ literal += set;
+ i = closed;
+ continue;
+ }
+ }
+ // Otherwise fall thru
+ }
+ // Append
+ literal += c;
+ }
+ return literal;
+ }
+ /**
+ * Escapes regexp special characters
+ * https://javascript.info/regexp-escaping
+ */
+ static regExpEscape(s) {
+ return s.replace(/[[\\^$.|?*+()]/g, '\\$&');
+ }
+}
+//# sourceMappingURL=internal-pattern.js.map
+;// CONCATENATED MODULE: ./node_modules/@actions/glob/lib/internal-search-state.js
+class internal_search_state_SearchState {
+ constructor(path, level) {
+ this.path = path;
+ this.level = level;
+ }
+}
+//# sourceMappingURL=internal-search-state.js.map
+;// CONCATENATED MODULE: ./node_modules/@actions/glob/lib/internal-globber.js
+var lib_internal_globber_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var internal_globber_asyncValues = (undefined && undefined.__asyncValues) || function (o) {
+ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+ var m = o[Symbol.asyncIterator], i;
+ return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+ function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+ function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var internal_globber_await = (undefined && undefined.__await) || function (v) { return this instanceof internal_globber_await ? (this.v = v, this) : new internal_globber_await(v); }
+var internal_globber_asyncGenerator = (undefined && undefined.__asyncGenerator) || function (thisArg, _arguments, generator) {
+ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+ var g = generator.apply(thisArg, _arguments || []), i, q = [];
+ return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+ function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+ function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+ function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+ function step(r) { r.value instanceof internal_globber_await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+ function fulfill(value) { resume("next", value); }
+ function reject(value) { resume("throw", value); }
+ function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+
+
+
+
+
+
+
+
+const lib_internal_globber_IS_WINDOWS = process.platform === 'win32';
+class lib_internal_globber_DefaultGlobber {
+ constructor(options) {
+ this.patterns = [];
+ this.searchPaths = [];
+ this.options = internal_glob_options_helper_getOptions(options);
+ }
+ getSearchPaths() {
+ // Return a copy
+ return this.searchPaths.slice();
+ }
+ glob() {
+ return lib_internal_globber_awaiter(this, void 0, void 0, function* () {
+ var _a, e_1, _b, _c;
+ const result = [];
+ try {
+ for (var _d = true, _e = internal_globber_asyncValues(this.globGenerator()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+ _c = _f.value;
+ _d = false;
+ const itemPath = _c;
+ result.push(itemPath);
+ }
+ }
+ catch (e_1_1) { e_1 = { error: e_1_1 }; }
+ finally {
+ try {
+ if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+ }
+ finally { if (e_1) throw e_1.error; }
+ }
+ return result;
+ });
+ }
+ globGenerator() {
+ return internal_globber_asyncGenerator(this, arguments, function* globGenerator_1() {
+ // Fill in defaults options
+ const options = internal_glob_options_helper_getOptions(this.options);
+ // Implicit descendants?
+ const patterns = [];
+ for (const pattern of this.patterns) {
+ patterns.push(pattern);
+ if (options.implicitDescendants &&
+ (pattern.trailingSeparator ||
+ pattern.segments[pattern.segments.length - 1] !== '**')) {
+ patterns.push(new lib_internal_pattern_Pattern(pattern.negate, true, pattern.segments.concat('**')));
+ }
+ }
+ // Push the search paths
+ const stack = [];
+ for (const searchPath of internal_pattern_helper_getSearchPaths(patterns)) {
+ core_debug(`Search path '${searchPath}'`);
+ // Exists?
+ try {
+ // Intentionally using lstat. Detection for broken symlink
+ // will be performed later (if following symlinks).
+ yield internal_globber_await(external_fs_.promises.lstat(searchPath));
+ }
+ catch (err) {
+ if (err.code === 'ENOENT') {
+ continue;
+ }
+ throw err;
+ }
+ stack.unshift(new internal_search_state_SearchState(searchPath, 1));
+ }
+ // Search
+ const traversalChain = []; // used to detect cycles
+ while (stack.length) {
+ // Pop
+ const item = stack.pop();
+ // Match?
+ const match = internal_pattern_helper_match(patterns, item.path);
+ const partialMatch = !!match || internal_pattern_helper_partialMatch(patterns, item.path);
+ if (!match && !partialMatch) {
+ continue;
+ }
+ // Stat
+ const stats = yield internal_globber_await(lib_internal_globber_DefaultGlobber.stat(item, options, traversalChain)
+ // Broken symlink, or symlink cycle detected, or no longer exists
+ );
+ // Broken symlink, or symlink cycle detected, or no longer exists
+ if (!stats) {
+ continue;
+ }
+ // Hidden file or directory?
+ if (options.excludeHiddenFiles && external_path_.basename(item.path).match(/^\./)) {
+ continue;
+ }
+ // Directory
+ if (stats.isDirectory()) {
+ // Matched
+ if (match & lib_internal_match_kind_MatchKind.Directory && options.matchDirectories) {
+ yield yield internal_globber_await(item.path);
+ }
+ // Descend?
+ else if (!partialMatch) {
+ continue;
+ }
+ // Push the child items in reverse
+ const childLevel = item.level + 1;
+ const childItems = (yield internal_globber_await(external_fs_.promises.readdir(item.path))).map(x => new internal_search_state_SearchState(external_path_.join(item.path, x), childLevel));
+ stack.push(...childItems.reverse());
+ }
+ // File
+ else if (match & lib_internal_match_kind_MatchKind.File) {
+ yield yield internal_globber_await(item.path);
+ }
+ }
+ });
+ }
+ /**
+ * Constructs a DefaultGlobber
+ */
+ static create(patterns, options) {
+ return lib_internal_globber_awaiter(this, void 0, void 0, function* () {
+ const result = new lib_internal_globber_DefaultGlobber(options);
+ if (lib_internal_globber_IS_WINDOWS) {
+ patterns = patterns.replace(/\r\n/g, '\n');
+ patterns = patterns.replace(/\r/g, '\n');
+ }
+ const lines = patterns.split('\n').map(x => x.trim());
+ for (const line of lines) {
+ // Empty or comment
+ if (!line || line.startsWith('#')) {
+ continue;
+ }
+ // Pattern
+ else {
+ result.patterns.push(new lib_internal_pattern_Pattern(line));
+ }
+ }
+ result.searchPaths.push(...internal_pattern_helper_getSearchPaths(result.patterns));
+ return result;
+ });
+ }
+ static stat(item, options, traversalChain) {
+ return lib_internal_globber_awaiter(this, void 0, void 0, function* () {
+ // Note:
+ // `stat` returns info about the target of a symlink (or symlink chain)
+ // `lstat` returns info about a symlink itself
+ let stats;
+ if (options.followSymbolicLinks) {
+ try {
+ // Use `stat` (following symlinks)
+ stats = yield external_fs_.promises.stat(item.path);
+ }
+ catch (err) {
+ if (err.code === 'ENOENT') {
+ if (options.omitBrokenSymbolicLinks) {
+ core_debug(`Broken symlink '${item.path}'`);
+ return undefined;
+ }
+ throw new Error(`No information found for the path '${item.path}'. This may indicate a broken symbolic link.`);
+ }
+ throw err;
+ }
+ }
+ else {
+ // Use `lstat` (not following symlinks)
+ stats = yield external_fs_.promises.lstat(item.path);
+ }
+ // Note, isDirectory() returns false for the lstat of a symlink
+ if (stats.isDirectory() && options.followSymbolicLinks) {
+ // Get the realpath
+ const realPath = yield external_fs_.promises.realpath(item.path);
+ // Fixup the traversal chain to match the item level
+ while (traversalChain.length >= item.level) {
+ traversalChain.pop();
+ }
+ // Test for a cycle
+ if (traversalChain.some((x) => x === realPath)) {
+ core_debug(`Symlink cycle detected for path '${item.path}' and realpath '${realPath}'`);
+ return undefined;
+ }
+ // Update the traversal chain
+ traversalChain.push(realPath);
+ }
+ return stats;
+ });
+ }
+}
+//# sourceMappingURL=internal-globber.js.map
+;// CONCATENATED MODULE: ./node_modules/@actions/glob/lib/internal-hash-files.js
+var lib_internal_hash_files_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var lib_internal_hash_files_asyncValues = (undefined && undefined.__asyncValues) || function (o) {
+ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+ var m = o[Symbol.asyncIterator], i;
+ return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+ function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+ function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+
+
+
+
+
+
+function internal_hash_files_hashFiles(globber_1, currentWorkspace_1) {
+ return lib_internal_hash_files_awaiter(this, arguments, void 0, function* (globber, currentWorkspace, verbose = false) {
+ var _a, e_1, _b, _c;
+ var _d;
+ const writeDelegate = verbose ? info : core_debug;
+ let hasMatch = false;
+ const githubWorkspace = currentWorkspace
+ ? currentWorkspace
+ : ((_d = process.env['GITHUB_WORKSPACE']) !== null && _d !== void 0 ? _d : process.cwd());
+ const result = external_crypto_.createHash('sha256');
+ let count = 0;
+ try {
+ for (var _e = true, _f = lib_internal_hash_files_asyncValues(globber.globGenerator()), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
+ _c = _g.value;
+ _e = false;
+ const file = _c;
+ writeDelegate(file);
+ if (!file.startsWith(`${githubWorkspace}${external_path_.sep}`)) {
+ writeDelegate(`Ignore '${file}' since it is not under GITHUB_WORKSPACE.`);
+ continue;
+ }
+ if (external_fs_.statSync(file).isDirectory()) {
+ writeDelegate(`Skip directory '${file}'.`);
+ continue;
+ }
+ const hash = external_crypto_.createHash('sha256');
+ const pipeline = external_util_.promisify(external_stream_.pipeline);
+ yield pipeline(external_fs_.createReadStream(file), hash);
+ result.write(hash.digest());
+ count++;
+ if (!hasMatch) {
+ hasMatch = true;
+ }
+ }
+ }
+ catch (e_1_1) { e_1 = { error: e_1_1 }; }
+ finally {
+ try {
+ if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
+ }
+ finally { if (e_1) throw e_1.error; }
+ }
+ result.end();
+ if (hasMatch) {
+ writeDelegate(`Found ${count} files to hash.`);
+ return result.digest('hex');
+ }
+ else {
+ writeDelegate(`No matches found for glob`);
+ return '';
+ }
+ });
+}
+//# sourceMappingURL=internal-hash-files.js.map
+;// CONCATENATED MODULE: ./node_modules/@actions/glob/lib/glob.js
+var lib_glob_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+
+
+/**
+ * Constructs a globber
+ *
+ * @param patterns Patterns separated by newlines
+ * @param options Glob options
+ */
+function glob_create(patterns, options) {
+ return lib_glob_awaiter(this, void 0, void 0, function* () {
+ return yield lib_internal_globber_DefaultGlobber.create(patterns, options);
+ });
+}
+/**
+ * Computes the sha256 hash of a glob
+ *
+ * @param patterns Patterns separated by newlines
+ * @param currentWorkspace Workspace used when matching files
+ * @param options Glob options
+ * @param verbose Enables verbose logging
+ */
+function lib_glob_hashFiles(patterns_1) {
+ return lib_glob_awaiter(this, arguments, void 0, function* (patterns, currentWorkspace = '', options, verbose = false) {
+ let followSymbolicLinks = true;
+ if (options && typeof options.followSymbolicLinks === 'boolean') {
+ followSymbolicLinks = options.followSymbolicLinks;
+ }
+ const globber = yield glob_create(patterns, { followSymbolicLinks });
+ return internal_hash_files_hashFiles(globber, currentWorkspace, verbose);
+ });
+}
+//# sourceMappingURL=glob.js.map
+;// CONCATENATED MODULE: ./node_modules/@actions/tool-cache/lib/manifest.js
+var manifest_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+
+
+
+
+
+// Internal object for testability (allows mocking in ESM)
+const _internal = {
+ readLinuxVersionFile() {
+ const lsbReleaseFile = '/etc/lsb-release';
+ const osReleaseFile = '/etc/os-release';
+ let contents = '';
+ if (external_fs_.existsSync(lsbReleaseFile)) {
+ contents = external_fs_.readFileSync(lsbReleaseFile).toString();
+ }
+ else if (external_fs_.existsSync(osReleaseFile)) {
+ contents = external_fs_.readFileSync(osReleaseFile).toString();
+ }
+ return contents;
+ }
+};
+function _findMatch(versionSpec, stable, candidates, archFilter) {
+ return manifest_awaiter(this, void 0, void 0, function* () {
+ const platFilter = os.platform();
+ let result;
+ let match;
+ let file;
+ for (const candidate of candidates) {
+ const version = candidate.version;
+ debug(`check ${version} satisfies ${versionSpec}`);
+ if (semver.satisfies(version, versionSpec) &&
+ (!stable || candidate.stable === stable)) {
+ file = candidate.files.find(item => {
+ debug(`${item.arch}===${archFilter} && ${item.platform}===${platFilter}`);
+ let chk = item.arch === archFilter && item.platform === platFilter;
+ if (chk && item.platform_version) {
+ const osVersion = _getOsVersion();
+ if (osVersion === item.platform_version) {
+ chk = true;
+ }
+ else {
+ chk = semver.satisfies(osVersion, item.platform_version);
+ }
+ }
+ return chk;
+ });
+ if (file) {
+ debug(`matched ${candidate.version}`);
+ match = candidate;
+ break;
+ }
+ }
+ }
+ if (match && file) {
+ // clone since we're mutating the file list to be only the file that matches
+ result = Object.assign({}, match);
+ result.files = [file];
+ }
+ return result;
+ });
+}
+function _getOsVersion() {
+ // TODO: add windows and other linux, arm variants
+ // right now filtering on version is only an ubuntu and macos scenario for tools we build for hosted (python)
+ const plat = os.platform();
+ let version = '';
+ if (plat === 'darwin') {
+ version = cp.execSync('sw_vers -productVersion').toString();
+ }
+ else if (plat === 'linux') {
+ // lsb_release process not in some containers, readfile
+ // Run cat /etc/lsb-release
+ // DISTRIB_ID=Ubuntu
+ // DISTRIB_RELEASE=18.04
+ // DISTRIB_CODENAME=bionic
+ // DISTRIB_DESCRIPTION="Ubuntu 18.04.4 LTS"
+ const lsbContents = _internal.readLinuxVersionFile();
+ if (lsbContents) {
+ const lines = lsbContents.split('\n');
+ for (const line of lines) {
+ const parts = line.split('=');
+ if (parts.length === 2 &&
+ (parts[0].trim() === 'VERSION_ID' ||
+ parts[0].trim() === 'DISTRIB_RELEASE')) {
+ version = parts[1].trim().replace(/^"/, '').replace(/"$/, '');
+ break;
+ }
+ }
+ }
+ }
+ return version;
+}
+// Alias for backwards compatibility
+function _readLinuxVersionFile() {
+ return _internal.readLinuxVersionFile();
+}
+//# sourceMappingURL=manifest.js.map
+;// CONCATENATED MODULE: ./node_modules/@actions/tool-cache/lib/retry-helper.js
+var retry_helper_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+
+/**
+ * Internal class for retries
+ */
+class RetryHelper {
+ constructor(maxAttempts, minSeconds, maxSeconds) {
+ if (maxAttempts < 1) {
+ throw new Error('max attempts should be greater than or equal to 1');
+ }
+ this.maxAttempts = maxAttempts;
+ this.minSeconds = Math.floor(minSeconds);
+ this.maxSeconds = Math.floor(maxSeconds);
+ if (this.minSeconds > this.maxSeconds) {
+ throw new Error('min seconds should be less than or equal to max seconds');
+ }
+ }
+ execute(action, isRetryable) {
+ return retry_helper_awaiter(this, void 0, void 0, function* () {
+ let attempt = 1;
+ while (attempt < this.maxAttempts) {
+ // Try
+ try {
+ return yield action();
+ }
+ catch (err) {
+ if (isRetryable && !isRetryable(err)) {
+ throw err;
+ }
+ info(err.message);
+ }
+ // Sleep
+ const seconds = this.getSleepAmount();
+ info(`Waiting ${seconds} seconds before trying again`);
+ yield this.sleep(seconds);
+ attempt++;
+ }
+ // Last attempt
+ return yield action();
+ });
+ }
+ getSleepAmount() {
+ return (Math.floor(Math.random() * (this.maxSeconds - this.minSeconds + 1)) +
+ this.minSeconds);
+ }
+ sleep(seconds) {
+ return retry_helper_awaiter(this, void 0, void 0, function* () {
+ return new Promise(resolve => setTimeout(resolve, seconds * 1000));
+ });
+ }
+}
+//# sourceMappingURL=retry-helper.js.map
+;// CONCATENATED MODULE: ./node_modules/@actions/tool-cache/lib/tool-cache.js
+var tool_cache_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class HTTPError extends Error {
+ constructor(httpStatusCode) {
+ super(`Unexpected HTTP response: ${httpStatusCode}`);
+ this.httpStatusCode = httpStatusCode;
+ Object.setPrototypeOf(this, new.target.prototype);
+ }
+}
+const tool_cache_IS_WINDOWS = process.platform === 'win32';
+const IS_MAC = process.platform === 'darwin';
+const tool_cache_userAgent = 'actions/tool-cache';
+/**
+ * Download a tool from an url and stream it into a file
+ *
+ * @param url url of tool to download
+ * @param dest path to download tool
+ * @param auth authorization header
+ * @param headers other headers
+ * @returns path to downloaded tool
+ */
+function downloadTool(url, dest, auth, headers) {
+ return tool_cache_awaiter(this, void 0, void 0, function* () {
+ dest = dest || external_path_.join(_getTempDirectory(), external_crypto_.randomUUID());
+ yield mkdirP(external_path_.dirname(dest));
+ core_debug(`Downloading ${url}`);
+ core_debug(`Destination ${dest}`);
+ const maxAttempts = 3;
+ const minSeconds = _getGlobal('TEST_DOWNLOAD_TOOL_RETRY_MIN_SECONDS', 10);
+ const maxSeconds = _getGlobal('TEST_DOWNLOAD_TOOL_RETRY_MAX_SECONDS', 20);
+ const retryHelper = new RetryHelper(maxAttempts, minSeconds, maxSeconds);
+ return yield retryHelper.execute(() => tool_cache_awaiter(this, void 0, void 0, function* () {
+ return yield downloadToolAttempt(url, dest || '', auth, headers);
+ }), (err) => {
+ if (err instanceof HTTPError && err.httpStatusCode) {
+ // Don't retry anything less than 500, except 408 Request Timeout and 429 Too Many Requests
+ if (err.httpStatusCode < 500 &&
+ err.httpStatusCode !== 408 &&
+ err.httpStatusCode !== 429) {
+ return false;
+ }
+ }
+ // Otherwise retry
+ return true;
+ });
+ });
+}
+function downloadToolAttempt(url, dest, auth, headers) {
+ return tool_cache_awaiter(this, void 0, void 0, function* () {
+ if (external_fs_.existsSync(dest)) {
+ throw new Error(`Destination file path ${dest} already exists`);
+ }
+ // Get the response headers
+ const http = new lib_HttpClient(tool_cache_userAgent, [], {
+ allowRetries: false
+ });
+ if (auth) {
+ core_debug('set auth');
+ if (headers === undefined) {
+ headers = {};
+ }
+ headers.authorization = auth;
+ }
+ const response = yield http.get(url, headers);
+ if (response.message.statusCode !== 200) {
+ const err = new HTTPError(response.message.statusCode);
+ core_debug(`Failed to download from "${url}". Code(${response.message.statusCode}) Message(${response.message.statusMessage})`);
+ throw err;
+ }
+ // Download the response body
+ const pipeline = external_util_.promisify(external_stream_.pipeline);
+ const responseMessageFactory = _getGlobal('TEST_DOWNLOAD_TOOL_RESPONSE_MESSAGE_FACTORY', () => response.message);
+ const readStream = responseMessageFactory();
+ let succeeded = false;
+ try {
+ yield pipeline(readStream, external_fs_.createWriteStream(dest));
+ core_debug('download complete');
+ succeeded = true;
+ return dest;
+ }
+ finally {
+ // Error, delete dest before retry
+ if (!succeeded) {
+ core_debug('download failed');
+ try {
+ yield rmRF(dest);
+ }
+ catch (err) {
+ core_debug(`Failed to delete '${dest}'. ${err.message}`);
+ }
+ }
+ }
+ });
+}
+/**
+ * Extract a .7z file
+ *
+ * @param file path to the .7z file
+ * @param dest destination directory. Optional.
+ * @param _7zPath path to 7zr.exe. Optional, for long path support. Most .7z archives do not have this
+ * problem. If your .7z archive contains very long paths, you can pass the path to 7zr.exe which will
+ * gracefully handle long paths. By default 7zdec.exe is used because it is a very small program and is
+ * bundled with the tool lib. However it does not support long paths. 7zr.exe is the reduced command line
+ * interface, it is smaller than the full command line interface, and it does support long paths. At the
+ * time of this writing, it is freely available from the LZMA SDK that is available on the 7zip website.
+ * Be sure to check the current license agreement. If 7zr.exe is bundled with your action, then the path
+ * to 7zr.exe can be pass to this function.
+ * @returns path to the destination directory
+ */
+function extract7z(file, dest, _7zPath) {
+ return tool_cache_awaiter(this, void 0, void 0, function* () {
+ ok(tool_cache_IS_WINDOWS, 'extract7z() not supported on current OS');
+ ok(file, 'parameter "file" is required');
+ dest = yield _createExtractFolder(dest);
+ const originalCwd = process.cwd();
+ process.chdir(dest);
+ if (_7zPath) {
+ try {
+ const logLevel = core.isDebug() ? '-bb1' : '-bb0';
+ const args = [
+ 'x', // eXtract files with full paths
+ logLevel, // -bb[0-3] : set output log level
+ '-bd', // disable progress indicator
+ '-sccUTF-8', // set charset for for console input/output
+ file
+ ];
+ const options = {
+ silent: true
+ };
+ yield exec(`"${_7zPath}"`, args, options);
+ }
+ finally {
+ process.chdir(originalCwd);
+ }
+ }
+ else {
+ const escapedScript = path
+ .join(__dirname, '..', 'scripts', 'Invoke-7zdec.ps1')
+ .replace(/'/g, "''")
+ .replace(/"|\n|\r/g, ''); // double-up single quotes, remove double quotes and newlines
+ const escapedFile = file.replace(/'/g, "''").replace(/"|\n|\r/g, '');
+ const escapedTarget = dest.replace(/'/g, "''").replace(/"|\n|\r/g, '');
+ const command = `& '${escapedScript}' -Source '${escapedFile}' -Target '${escapedTarget}'`;
+ const args = [
+ '-NoLogo',
+ '-Sta',
+ '-NoProfile',
+ '-NonInteractive',
+ '-ExecutionPolicy',
+ 'Unrestricted',
+ '-Command',
+ command
+ ];
+ const options = {
+ silent: true
+ };
+ try {
+ const powershellPath = yield io.which('powershell', true);
+ yield exec(`"${powershellPath}"`, args, options);
+ }
+ finally {
+ process.chdir(originalCwd);
+ }
+ }
+ return dest;
+ });
+}
+/**
+ * Extract a compressed tar archive
+ *
+ * @param file path to the tar
+ * @param dest destination directory. Optional.
+ * @param flags flags for the tar command to use for extraction. Defaults to 'xz' (extracting gzipped tars). Optional.
+ * @returns path to the destination directory
+ */
+function tool_cache_extractTar(file_1, dest_1) {
+ return tool_cache_awaiter(this, arguments, void 0, function* (file, dest, flags = 'xz') {
+ if (!file) {
+ throw new Error("parameter 'file' is required");
+ }
+ // Create dest
+ dest = yield _createExtractFolder(dest);
+ // Determine whether GNU tar
+ core.debug('Checking tar --version');
+ let versionOutput = '';
+ yield exec('tar --version', [], {
+ ignoreReturnCode: true,
+ silent: true,
+ listeners: {
+ stdout: (data) => (versionOutput += data.toString()),
+ stderr: (data) => (versionOutput += data.toString())
+ }
+ });
+ core.debug(versionOutput.trim());
+ const isGnuTar = versionOutput.toUpperCase().includes('GNU TAR');
+ // Initialize args
+ let args;
+ if (flags instanceof Array) {
+ args = flags;
+ }
+ else {
+ args = [flags];
+ }
+ if (core.isDebug() && !flags.includes('v')) {
+ args.push('-v');
+ }
+ let destArg = dest;
+ let fileArg = file;
+ if (tool_cache_IS_WINDOWS && isGnuTar) {
+ args.push('--force-local');
+ destArg = dest.replace(/\\/g, '/');
+ // Technically only the dest needs to have `/` but for aesthetic consistency
+ // convert slashes in the file arg too.
+ fileArg = file.replace(/\\/g, '/');
+ }
+ if (isGnuTar) {
+ // Suppress warnings when using GNU tar to extract archives created by BSD tar
+ args.push('--warning=no-unknown-keyword');
+ args.push('--overwrite');
+ }
+ args.push('-C', destArg, '-f', fileArg);
+ yield exec(`tar`, args);
+ return dest;
+ });
+}
+/**
+ * Extract a xar compatible archive
+ *
+ * @param file path to the archive
+ * @param dest destination directory. Optional.
+ * @param flags flags for the xar. Optional.
+ * @returns path to the destination directory
+ */
+function extractXar(file_1, dest_1) {
+ return tool_cache_awaiter(this, arguments, void 0, function* (file, dest, flags = []) {
+ ok(IS_MAC, 'extractXar() not supported on current OS');
+ ok(file, 'parameter "file" is required');
+ dest = yield _createExtractFolder(dest);
+ let args;
+ if (flags instanceof Array) {
+ args = flags;
+ }
+ else {
+ args = [flags];
+ }
+ args.push('-x', '-C', dest, '-f', file);
+ if (core.isDebug()) {
+ args.push('-v');
+ }
+ const xarPath = yield io.which('xar', true);
+ yield exec(`"${xarPath}"`, _unique(args));
+ return dest;
+ });
+}
+/**
+ * Extract a zip
+ *
+ * @param file path to the zip
+ * @param dest destination directory. Optional.
+ * @returns path to the destination directory
+ */
+function extractZip(file, dest) {
+ return tool_cache_awaiter(this, void 0, void 0, function* () {
+ if (!file) {
+ throw new Error("parameter 'file' is required");
+ }
+ dest = yield _createExtractFolder(dest);
+ if (tool_cache_IS_WINDOWS) {
+ yield extractZipWin(file, dest);
+ }
+ else {
+ yield extractZipNix(file, dest);
+ }
+ return dest;
+ });
+}
+function extractZipWin(file, dest) {
+ return tool_cache_awaiter(this, void 0, void 0, function* () {
+ // build the powershell command
+ const escapedFile = file.replace(/'/g, "''").replace(/"|\n|\r/g, ''); // double-up single quotes, remove double quotes and newlines
+ const escapedDest = dest.replace(/'/g, "''").replace(/"|\n|\r/g, '');
+ const pwshPath = yield io.which('pwsh', false);
+ //To match the file overwrite behavior on nix systems, we use the overwrite = true flag for ExtractToDirectory
+ //and the -Force flag for Expand-Archive as a fallback
+ if (pwshPath) {
+ //attempt to use pwsh with ExtractToDirectory, if this fails attempt Expand-Archive
+ const pwshCommand = [
+ `$ErrorActionPreference = 'Stop' ;`,
+ `try { Add-Type -AssemblyName System.IO.Compression.ZipFile } catch { } ;`,
+ `try { [System.IO.Compression.ZipFile]::ExtractToDirectory('${escapedFile}', '${escapedDest}', $true) }`,
+ `catch { if (($_.Exception.GetType().FullName -eq 'System.Management.Automation.MethodException') -or ($_.Exception.GetType().FullName -eq 'System.Management.Automation.RuntimeException') ){ Expand-Archive -LiteralPath '${escapedFile}' -DestinationPath '${escapedDest}' -Force } else { throw $_ } } ;`
+ ].join(' ');
+ const args = [
+ '-NoLogo',
+ '-NoProfile',
+ '-NonInteractive',
+ '-ExecutionPolicy',
+ 'Unrestricted',
+ '-Command',
+ pwshCommand
+ ];
+ core.debug(`Using pwsh at path: ${pwshPath}`);
+ yield exec(`"${pwshPath}"`, args);
+ }
+ else {
+ const powershellCommand = [
+ `$ErrorActionPreference = 'Stop' ;`,
+ `try { Add-Type -AssemblyName System.IO.Compression.FileSystem } catch { } ;`,
+ `if ((Get-Command -Name Expand-Archive -Module Microsoft.PowerShell.Archive -ErrorAction Ignore)) { Expand-Archive -LiteralPath '${escapedFile}' -DestinationPath '${escapedDest}' -Force }`,
+ `else {[System.IO.Compression.ZipFile]::ExtractToDirectory('${escapedFile}', '${escapedDest}', $true) }`
+ ].join(' ');
+ const args = [
+ '-NoLogo',
+ '-Sta',
+ '-NoProfile',
+ '-NonInteractive',
+ '-ExecutionPolicy',
+ 'Unrestricted',
+ '-Command',
+ powershellCommand
+ ];
+ const powershellPath = yield io.which('powershell', true);
+ core.debug(`Using powershell at path: ${powershellPath}`);
+ yield exec(`"${powershellPath}"`, args);
+ }
+ });
+}
+function extractZipNix(file, dest) {
+ return tool_cache_awaiter(this, void 0, void 0, function* () {
+ const unzipPath = yield io.which('unzip', true);
+ const args = [file];
+ if (!core.isDebug()) {
+ args.unshift('-q');
+ }
+ args.unshift('-o'); //overwrite with -o, otherwise a prompt is shown which freezes the run
+ yield exec(`"${unzipPath}"`, args, { cwd: dest });
+ });
+}
+/**
+ * Caches a directory and installs it into the tool cacheDir
+ *
+ * @param sourceDir the directory to cache into tools
+ * @param tool tool name
+ * @param version version of the tool. semver format
+ * @param arch architecture of the tool. Optional. Defaults to machine architecture
+ */
+function cacheDir(sourceDir, tool, version, arch) {
+ return tool_cache_awaiter(this, void 0, void 0, function* () {
+ version = semver.clean(version) || version;
+ arch = arch || os.arch();
+ core.debug(`Caching tool ${tool} ${version} ${arch}`);
+ core.debug(`source dir: ${sourceDir}`);
+ if (!fs.statSync(sourceDir).isDirectory()) {
+ throw new Error('sourceDir is not a directory');
+ }
+ // Create the tool dir
+ const destPath = yield _createToolPath(tool, version, arch);
+ // copy each child item. do not move. move can fail on Windows
+ // due to anti-virus software having an open handle on a file.
+ for (const itemName of fs.readdirSync(sourceDir)) {
+ const s = path.join(sourceDir, itemName);
+ yield io.cp(s, destPath, { recursive: true });
+ }
+ // write .complete
+ _completeToolPath(tool, version, arch);
+ return destPath;
+ });
+}
+/**
+ * Caches a downloaded file (GUID) and installs it
+ * into the tool cache with a given targetName
+ *
+ * @param sourceFile the file to cache into tools. Typically a result of downloadTool which is a guid.
+ * @param targetFile the name of the file name in the tools directory
+ * @param tool tool name
+ * @param version version of the tool. semver format
+ * @param arch architecture of the tool. Optional. Defaults to machine architecture
+ */
+function cacheFile(sourceFile, targetFile, tool, version, arch) {
+ return tool_cache_awaiter(this, void 0, void 0, function* () {
+ version = node_modules_semver.clean(version) || version;
+ arch = arch || external_os_namespaceObject.arch();
+ core_debug(`Caching tool ${tool} ${version} ${arch}`);
+ core_debug(`source file: ${sourceFile}`);
+ if (!external_fs_.statSync(sourceFile).isFile()) {
+ throw new Error('sourceFile is not a file');
+ }
+ // create the tool dir
+ const destFolder = yield _createToolPath(tool, version, arch);
+ // copy instead of move. move can fail on Windows due to
+ // anti-virus software having an open handle on a file.
+ const destPath = external_path_.join(destFolder, targetFile);
+ core_debug(`destination file ${destPath}`);
+ yield io_cp(sourceFile, destPath);
+ // write .complete
+ _completeToolPath(tool, version, arch);
+ return destFolder;
+ });
+}
+/**
+ * Finds the path to a tool version in the local installed tool cache
+ *
+ * @param toolName name of the tool
+ * @param versionSpec version of the tool
+ * @param arch optional arch. defaults to arch of computer
+ */
+function find(toolName, versionSpec, arch) {
+ if (!toolName) {
+ throw new Error('toolName parameter is required');
+ }
+ if (!versionSpec) {
+ throw new Error('versionSpec parameter is required');
+ }
+ arch = arch || external_os_namespaceObject.arch();
+ // attempt to resolve an explicit version
+ if (!isExplicitVersion(versionSpec)) {
+ const localVersions = findAllVersions(toolName, arch);
+ const match = evaluateVersions(localVersions, versionSpec);
+ versionSpec = match;
+ }
+ // check for the explicit version in the cache
+ let toolPath = '';
+ if (versionSpec) {
+ versionSpec = node_modules_semver.clean(versionSpec) || '';
+ const cachePath = external_path_.join(_getCacheDirectory(), toolName, versionSpec, arch);
+ core_debug(`checking cache: ${cachePath}`);
+ if (external_fs_.existsSync(cachePath) && external_fs_.existsSync(`${cachePath}.complete`)) {
+ core_debug(`Found tool in cache ${toolName} ${versionSpec} ${arch}`);
+ toolPath = cachePath;
+ }
+ else {
+ core_debug('not found');
+ }
+ }
+ return toolPath;
+}
+/**
+ * Finds the paths to all versions of a tool that are installed in the local tool cache
+ *
+ * @param toolName name of the tool
+ * @param arch optional arch. defaults to arch of computer
+ */
+function findAllVersions(toolName, arch) {
+ const versions = [];
+ arch = arch || external_os_namespaceObject.arch();
+ const toolPath = external_path_.join(_getCacheDirectory(), toolName);
+ if (external_fs_.existsSync(toolPath)) {
+ const children = external_fs_.readdirSync(toolPath);
+ for (const child of children) {
+ if (isExplicitVersion(child)) {
+ const fullPath = external_path_.join(toolPath, child, arch || '');
+ if (external_fs_.existsSync(fullPath) && external_fs_.existsSync(`${fullPath}.complete`)) {
+ versions.push(child);
+ }
+ }
+ }
+ }
+ return versions;
+}
+function getManifestFromRepo(owner_1, repo_1, auth_1) {
+ return tool_cache_awaiter(this, arguments, void 0, function* (owner, repo, auth, branch = 'master') {
+ let releases = [];
+ const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${branch}`;
+ const http = new httpm.HttpClient('tool-cache');
+ const headers = {};
+ if (auth) {
+ core.debug('set auth');
+ headers.authorization = auth;
+ }
+ const response = yield http.getJson(treeUrl, headers);
+ if (!response.result) {
+ return releases;
+ }
+ let manifestUrl = '';
+ for (const item of response.result.tree) {
+ if (item.path === 'versions-manifest.json') {
+ manifestUrl = item.url;
+ break;
+ }
+ }
+ headers['accept'] = 'application/vnd.github.VERSION.raw';
+ let versionsRaw = yield (yield http.get(manifestUrl, headers)).readBody();
+ if (versionsRaw) {
+ // shouldn't be needed but protects against invalid json saved with BOM
+ versionsRaw = versionsRaw.replace(/^\uFEFF/, '');
+ try {
+ releases = JSON.parse(versionsRaw);
+ }
+ catch (_a) {
+ core.debug('Invalid json');
+ }
+ }
+ return releases;
+ });
+}
+function findFromManifest(versionSpec_1, stable_1, manifest_1) {
+ return tool_cache_awaiter(this, arguments, void 0, function* (versionSpec, stable, manifest, archFilter = os.arch()) {
+ // wrap the internal impl
+ const match = yield mm._findMatch(versionSpec, stable, manifest, archFilter);
+ return match;
+ });
+}
+function _createExtractFolder(dest) {
+ return tool_cache_awaiter(this, void 0, void 0, function* () {
+ if (!dest) {
+ // create a temp dir
+ dest = path.join(_getTempDirectory(), crypto.randomUUID());
+ }
+ yield io.mkdirP(dest);
+ return dest;
+ });
+}
+function _createToolPath(tool, version, arch) {
+ return tool_cache_awaiter(this, void 0, void 0, function* () {
+ const folderPath = external_path_.join(_getCacheDirectory(), tool, node_modules_semver.clean(version) || version, arch || '');
+ core_debug(`destination ${folderPath}`);
+ const markerPath = `${folderPath}.complete`;
+ yield rmRF(folderPath);
+ yield rmRF(markerPath);
+ yield mkdirP(folderPath);
+ return folderPath;
+ });
+}
+function _completeToolPath(tool, version, arch) {
+ const folderPath = external_path_.join(_getCacheDirectory(), tool, node_modules_semver.clean(version) || version, arch || '');
+ const markerPath = `${folderPath}.complete`;
+ external_fs_.writeFileSync(markerPath, '');
+ core_debug('finished caching tool');
+}
+/**
+ * Check if version string is explicit
+ *
+ * @param versionSpec version string to check
+ */
+function isExplicitVersion(versionSpec) {
+ const c = node_modules_semver.clean(versionSpec) || '';
+ core_debug(`isExplicit: ${c}`);
+ const valid = node_modules_semver.valid(c) != null;
+ core_debug(`explicit? ${valid}`);
+ return valid;
+}
+/**
+ * Get the highest satisfiying semantic version in `versions` which satisfies `versionSpec`
+ *
+ * @param versions array of versions to evaluate
+ * @param versionSpec semantic version spec to satisfy
+ */
+function evaluateVersions(versions, versionSpec) {
+ let version = '';
+ core_debug(`evaluating ${versions.length} versions`);
+ versions = versions.sort((a, b) => {
+ if (node_modules_semver.gt(a, b)) {
+ return 1;
+ }
+ return -1;
+ });
+ for (let i = versions.length - 1; i >= 0; i--) {
+ const potential = versions[i];
+ const satisfied = node_modules_semver.satisfies(potential, versionSpec);
+ if (satisfied) {
+ version = potential;
+ break;
+ }
+ }
+ if (version) {
+ core_debug(`matched: ${version}`);
+ }
+ else {
+ core_debug('match not found');
+ }
+ return version;
+}
+/**
+ * Gets RUNNER_TOOL_CACHE
+ */
+function _getCacheDirectory() {
+ const cacheDirectory = process.env['RUNNER_TOOL_CACHE'] || '';
+ (0,external_assert_.ok)(cacheDirectory, 'Expected RUNNER_TOOL_CACHE to be defined');
+ return cacheDirectory;
+}
+/**
+ * Gets RUNNER_TEMP
+ */
+function _getTempDirectory() {
+ const tempDirectory = process.env['RUNNER_TEMP'] || '';
+ (0,external_assert_.ok)(tempDirectory, 'Expected RUNNER_TEMP to be defined');
+ return tempDirectory;
+}
+/**
+ * Gets a global variable
+ */
+function _getGlobal(key, defaultValue) {
+ /* eslint-disable @typescript-eslint/no-explicit-any */
+ const value = global[key];
+ /* eslint-enable @typescript-eslint/no-explicit-any */
+ return value !== undefined ? value : defaultValue;
+}
+/**
+ * Returns an array of unique values.
+ * @param values Values to make unique.
+ */
+function _unique(values) {
+ return Array.from(new Set(values));
+}
+//# sourceMappingURL=tool-cache.js.map
+// EXTERNAL MODULE: ./node_modules/yaml/dist/index.js
+var yaml_dist = __nccwpck_require__(8815);
+;// CONCATENATED MODULE: ./config.js
+
+
+
+
+
+
+const bazeliskVersion = getInput('bazelisk-version')
+const cacheSave = getBooleanInput('cache-save')
+const cacheVersion = getInput('cache-version')
+const moduleRoot = getInput('module-root')
+
+const homeDir = external_os_namespaceObject.homedir()
+const config_arch = external_os_namespaceObject.arch()
+const config_platform = external_os_namespaceObject.platform()
+
+let bazelOutputBase = getInput('output-base')
+if (!bazelOutputBase) {
+ if (config_platform === 'win32') {
+ // check if GITHUB_WORKSPACE starts with D:
+ if (process.env.GITHUB_WORKSPACE?.toLowerCase()?.startsWith('d:')) {
+ bazelOutputBase = 'D:/_bazel'
+ } else {
+ bazelOutputBase = `C:/_bazel`
+ }
+ } else {
+ bazelOutputBase = `${homeDir}/.bazel`
+ }
+}
+
+let bazelDisk = toPosixPath(`${homeDir}/.cache/bazel-disk`)
+let bazelRepository = toPosixPath(`${homeDir}/.cache/bazel-repo`)
+let bazelrcPaths = [toPosixPath(`${homeDir}/.bazelrc`)]
+let userCacheDir = `${homeDir}/.cache`
+
+switch (config_platform) {
+ case 'darwin':
+ userCacheDir = `${homeDir}/Library/Caches`
+ break
+ case 'win32':
+ bazelDisk = `${bazelOutputBase}-disk`
+ bazelRepository = `${bazelOutputBase}-repo`
+ userCacheDir = `${homeDir}/AppData/Local`
+ if (process.env.HOME) {
+ bazelrcPaths.push(toPosixPath(`${process.env.HOME}/.bazelrc`))
+ }
+ break
+}
+
+const baseCacheKey = `setup-bazel-${cacheVersion}-${config_platform}-${config_arch}`
+const bazelrc = getMultilineInput('bazelrc')
+
+const diskCacheConfig = getInput('disk-cache')
+const diskCacheEnabled = diskCacheConfig !== 'false'
+let diskCacheName = 'disk'
+if (diskCacheEnabled) {
+ // Before Bazel 6.3, providing --disk_cache to common is an error,
+ // with Bazel 6.3 and onwards, common accepts any legal Bazel option
+ // https://github.com/bazelbuild/bazel/issues/3054
+ bazelrc.push(`build --disk_cache=${bazelDisk}`)
+ if (diskCacheName !== 'true') {
+ diskCacheName = `${diskCacheName}-${diskCacheConfig}`
+ }
+}
+
+const repositoryCacheConfig = yaml_dist.parse(getInput('repository-cache'))
+const repositoryCacheEnabled = repositoryCacheConfig !== false
+let repositoryCacheFiles = [
+ `${moduleRoot}/MODULE.bazel`,
+ `${moduleRoot}/WORKSPACE.bazel`,
+ `${moduleRoot}/WORKSPACE.bzlmod`,
+ `${moduleRoot}/WORKSPACE`
+]
+if (repositoryCacheEnabled) {
+ bazelrc.push(`common --repository_cache=${bazelRepository}`)
+ if (repositoryCacheConfig !== true) {
+ repositoryCacheFiles = Array(repositoryCacheConfig).flat()
+ }
+}
+
+const googleCredentials = getInput('google-credentials')
+const googleCredentialsSaved = (getState('google-credentials-path').length > 0)
+if (googleCredentials.length > 0 && !googleCredentialsSaved) {
+ const tmpDir = toPosixPath(external_fs_.mkdtempSync(process.env.RUNNER_TEMP))
+ const googleCredentialsPath = `${tmpDir}/key.json`
+ external_fs_.writeFileSync(googleCredentialsPath, googleCredentials)
+ bazelrc.push(`build --google_credentials=${googleCredentialsPath}`)
+ saveState('google-credentials-path', googleCredentialsPath)
+}
+
+const externalCacheConfig = yaml_dist.parse(getInput('external-cache'))
+const bazelExternal = toPosixPath(`${bazelOutputBase}/external`)
+const externalCache = {}
+if (externalCacheConfig) {
+ const { workflow, job } = github_context
+ const manifestName = externalCacheConfig.name ||
+ `${workflow.toLowerCase().replaceAll(/[ /]/g, '-')}-${job}`
+
+ externalCache.enabled = true
+ externalCache.minSize = 10 // MB
+ externalCache.baseCacheKey = `${baseCacheKey}-external-`
+ externalCache.manifest = {
+ files: [
+ `${moduleRoot}/MODULE.bazel`,
+ `${moduleRoot}/WORKSPACE.bazel`,
+ `${moduleRoot}/WORKSPACE.bzlmod`,
+ `${moduleRoot}/WORKSPACE`
+ ],
+ name: `external-${manifestName}-manifest`,
+ path: `${external_os_namespaceObject.tmpdir()}/external-cache-manifest.txt`
+ }
+ externalCache.default = {
+ enabled: true,
+ files: [
+ `${moduleRoot}/MODULE.bazel`,
+ `${moduleRoot}/WORKSPACE.bazel`,
+ `${moduleRoot}/WORKSPACE.bzlmod`,
+ `${moduleRoot}/WORKSPACE`
+ ],
+ name: (name) => { return `external-${name}` },
+ paths: (name) => {
+ return [
+ `${bazelExternal}/@${name}.marker`,
+ `${bazelExternal}/${name}`
+ ]
+ }
+ }
+
+ for (const name in externalCacheConfig.manifest) {
+ externalCache[name] = {
+ enabled: externalCacheConfig.manifest[name] != false,
+ files: Array(externalCacheConfig.manifest[name]).flat()
+ }
+ }
+}
+
+const cacheRestoreTimeoutMs = parseInt(getInput('cache-restore-timeout')) || 0
+
+const token = getInput('token')
+exportVariable('BAZELISK_GITHUB_TOKEN', token)
+
+/* harmony default export */ const config = ({
+ baseCacheKey,
+ cacheSave,
+ cacheRestoreTimeoutMs,
+ bazeliskCache: {
+ enabled: getBooleanInput('bazelisk-cache'),
+ files: [`${moduleRoot}/.bazelversion`],
+ name: 'bazelisk',
+ paths: [toPosixPath(`${userCacheDir}/bazelisk`)]
+ },
+ bazeliskVersion,
+ bazelrc,
+ diskCache: {
+ enabled: diskCacheEnabled,
+ files: [
+ ...repositoryCacheFiles,
+ `${moduleRoot}/**/BUILD.bazel`,
+ `${moduleRoot}/**/BUILD`
+ ],
+ name: diskCacheName,
+ paths: [bazelDisk]
+ },
+ externalCache,
+ paths: {
+ bazelExternal,
+ bazelOutputBase: toPosixPath(bazelOutputBase),
+ bazelrc: bazelrcPaths
+ },
+ os: {
+ arch: config_arch,
+ platform: config_platform,
+ },
+ repositoryCache: {
+ enabled: repositoryCacheEnabled,
+ files: repositoryCacheFiles,
+ name: 'repository',
+ paths: [bazelRepository]
+ },
+});
+
+;// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/bind.js
+
+
+/**
+ * Create a bound version of a function with a specified `this` context
+ *
+ * @param {Function} fn - The function to bind
+ * @param {*} thisArg - The value to be passed as the `this` parameter
+ * @returns {Function} A new function that will call the original function with the specified `this` context
+ */
+function bind_bind(fn, thisArg) {
+ return function wrap() {
+ return fn.apply(thisArg, arguments);
+ };
+}
+
+;// CONCATENATED MODULE: ./node_modules/axios/lib/utils.js
+
+
+
+
+// utils is a library of generic helper functions non-specific to axios
+
+const { toString: utils_toString } = Object.prototype;
+const { getPrototypeOf } = Object;
+const { iterator: utils_iterator, toStringTag } = Symbol;
+
+/* Creating a function that will check if an object has a property. */
+const utils_hasOwnProperty = (
+ ({ hasOwnProperty }) =>
+ (obj, prop) =>
+ hasOwnProperty.call(obj, prop)
+)(Object.prototype);
+
+/**
+ * Walk the prototype chain (excluding the shared Object.prototype) looking for
+ * an own `prop`. This distinguishes genuine own/inherited members — including
+ * class accessors and template prototypes — from members injected via
+ * Object.prototype pollution (e.g. `Object.prototype.username = '...'`), which
+ * live on Object.prototype itself and are therefore never matched.
+ *
+ * @param {*} thing The value whose chain to inspect
+ * @param {string|symbol} prop The property key to look for
+ *
+ * @returns {boolean} True when `prop` is owned below Object.prototype
+ */
+const hasOwnInPrototypeChain = (thing, prop) => {
+ let obj = thing;
+ const seen = [];
+
+ while (obj != null && obj !== Object.prototype) {
+ if (seen.indexOf(obj) !== -1) {
+ return false;
+ }
+ seen.push(obj);
+
+ if (utils_hasOwnProperty(obj, prop)) {
+ return true;
+ }
+ obj = getPrototypeOf(obj);
+ }
+ return false;
+};
+
+/**
+ * Read `obj[prop]` only when it is safe from Object.prototype pollution. Own
+ * properties and members inherited from a non-Object.prototype source (a class
+ * instance or template object) are honored; a value reachable only through a
+ * polluted Object.prototype is ignored and `undefined` is returned.
+ *
+ * @param {*} obj The source object
+ * @param {string|symbol} prop The property key to read
+ *
+ * @returns {*} The resolved value, or undefined when unsafe/absent
+ */
+const getSafeProp = (obj, prop) =>
+ obj != null && hasOwnInPrototypeChain(obj, prop) ? obj[prop] : undefined;
+
+const kindOf = ((cache) => (thing) => {
+ const str = utils_toString.call(thing);
+ return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
+})(Object.create(null));
+
+const kindOfTest = (type) => {
+ type = type.toLowerCase();
+ return (thing) => kindOf(thing) === type;
+};
+
+const typeOfTest = (type) => (thing) => typeof thing === type;
+
+/**
+ * Determine if a value is a non-null object
+ *
+ * @param {Object} val The value to test
+ *
+ * @returns {boolean} True if value is an Array, otherwise false
+ */
+const { isArray } = Array;
+
+/**
+ * Determine if a value is undefined
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if the value is undefined, otherwise false
+ */
+const isUndefined = typeOfTest('undefined');
+
+/**
+ * Determine if a value is a Buffer
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a Buffer, otherwise false
+ */
+function isBuffer(val) {
+ return (
+ val !== null &&
+ !isUndefined(val) &&
+ val.constructor !== null &&
+ !isUndefined(val.constructor) &&
+ isFunction(val.constructor.isBuffer) &&
+ val.constructor.isBuffer(val)
+ );
+}
+
+/**
+ * Determine if a value is an ArrayBuffer
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is an ArrayBuffer, otherwise false
+ */
+const utils_isArrayBuffer = kindOfTest('ArrayBuffer');
+
+/**
+ * Determine if a value is a view on an ArrayBuffer
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
+ */
+function isArrayBufferView(val) {
+ let result;
+ if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {
+ result = ArrayBuffer.isView(val);
+ } else {
+ result = val && val.buffer && utils_isArrayBuffer(val.buffer);
+ }
+ return result;
+}
+
+/**
+ * Determine if a value is a String
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a String, otherwise false
+ */
+const isString = typeOfTest('string');
+
+/**
+ * Determine if a value is a Function
+ *
+ * @param {*} val The value to test
+ * @returns {boolean} True if value is a Function, otherwise false
+ */
+const isFunction = typeOfTest('function');
+
+/**
+ * Determine if a value is a Number
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a Number, otherwise false
+ */
+const isNumber = typeOfTest('number');
+
+/**
+ * Determine if a value is an Object
+ *
+ * @param {*} thing The value to test
+ *
+ * @returns {boolean} True if value is an Object, otherwise false
+ */
+const utils_isObject = (thing) => thing !== null && typeof thing === 'object';
+
+/**
+ * Determine if a value is a Boolean
+ *
+ * @param {*} thing The value to test
+ * @returns {boolean} True if value is a Boolean, otherwise false
+ */
+const isBoolean = (thing) => thing === true || thing === false;
+
+/**
+ * Determine if a value is a plain Object
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a plain Object, otherwise false
+ */
+const utils_isPlainObject = (val) => {
+ if (!utils_isObject(val)) {
+ return false;
+ }
+
+ const prototype = getPrototypeOf(val);
+ return (
+ (prototype === null ||
+ prototype === Object.prototype ||
+ getPrototypeOf(prototype) === null) &&
+ // Treat any genuine (non-Object.prototype-polluted) Symbol.toStringTag or
+ // Symbol.iterator as evidence the value is a tagged/iterable type rather
+ // than a plain object, while ignoring keys injected onto Object.prototype.
+ !hasOwnInPrototypeChain(val, toStringTag) &&
+ !hasOwnInPrototypeChain(val, utils_iterator)
+ );
+};
+
+/**
+ * Determine if a value is an empty object (safely handles Buffers)
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is an empty object, otherwise false
+ */
+const utils_isEmptyObject = (val) => {
+ // Early return for non-objects or Buffers to prevent RangeError
+ if (!utils_isObject(val) || isBuffer(val)) {
+ return false;
+ }
+
+ try {
+ return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
+ } catch (e) {
+ // Fallback for any other objects that might cause RangeError with Object.keys()
+ return false;
+ }
+};
+
+/**
+ * Determine if a value is a Date
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a Date, otherwise false
+ */
+const isDate = kindOfTest('Date');
+
+/**
+ * Determine if a value is a File
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a File, otherwise false
+ */
+const isFile = kindOfTest('File');
+
+/**
+ * Determine if a value is a React Native Blob
+ * React Native "blob": an object with a `uri` attribute. Optionally, it can
+ * also have a `name` and `type` attribute to specify filename and content type
+ *
+ * @see https://github.com/facebook/react-native/blob/26684cf3adf4094eb6c405d345a75bf8c7c0bf88/Libraries/Network/FormData.js#L68-L71
+ *
+ * @param {*} value The value to test
+ *
+ * @returns {boolean} True if value is a React Native Blob, otherwise false
+ */
+const isReactNativeBlob = (value) => {
+ return !!(value && typeof value.uri !== 'undefined');
+};
+
+/**
+ * Determine if environment is React Native
+ * ReactNative `FormData` has a non-standard `getParts()` method
+ *
+ * @param {*} formData The formData to test
+ *
+ * @returns {boolean} True if environment is React Native, otherwise false
+ */
+const utils_isReactNative = (formData) => formData && typeof formData.getParts !== 'undefined';
+
+/**
+ * Determine if a value is a Blob
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a Blob, otherwise false
+ */
+const utils_isBlob = kindOfTest('Blob');
+
+/**
+ * Determine if a value is a FileList
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a FileList, otherwise false
+ */
+const isFileList = kindOfTest('FileList');
+
+/**
+ * Determine if a value is a Stream
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a Stream, otherwise false
+ */
+const isStream = (val) => utils_isObject(val) && isFunction(val.pipe);
+
+/**
+ * Determine if a value is a FormData
+ *
+ * @param {*} thing The value to test
+ *
+ * @returns {boolean} True if value is an FormData, otherwise false
+ */
+function getGlobal() {
+ if (typeof globalThis !== 'undefined') return globalThis;
+ if (typeof self !== 'undefined') return self;
+ if (typeof window !== 'undefined') return window;
+ if (typeof global !== 'undefined') return global;
+ return {};
+}
+
+const G = getGlobal();
+const FormDataCtor = typeof G.FormData !== 'undefined' ? G.FormData : undefined;
+
+const isFormData = (thing) => {
+ if (!thing) return false;
+ if (FormDataCtor && thing instanceof FormDataCtor) return true;
+ // Reject plain objects inheriting directly from Object.prototype so prototype-pollution gadgets can't spoof FormData.
+ const proto = getPrototypeOf(thing);
+ if (!proto || proto === Object.prototype) return false;
+ if (!isFunction(thing.append)) return false;
+ const kind = kindOf(thing);
+ return (
+ kind === 'formdata' ||
+ // detect form-data instance
+ (kind === 'object' && isFunction(thing.toString) && thing.toString() === '[object FormData]')
+ );
+};
+
+/**
+ * Determine if a value is a URLSearchParams object
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a URLSearchParams object, otherwise false
+ */
+const isURLSearchParams = kindOfTest('URLSearchParams');
+
+const [utils_isReadableStream, isRequest, isResponse, isHeaders] = [
+ 'ReadableStream',
+ 'Request',
+ 'Response',
+ 'Headers',
+].map(kindOfTest);
+
+/**
+ * Trim excess whitespace off the beginning and end of a string
+ *
+ * @param {String} str The String to trim
+ *
+ * @returns {String} The String freed of excess whitespace
+ */
+const trim = (str) => {
+ return str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
+};
+/**
+ * Iterate over an Array or an Object invoking a function for each item.
+ *
+ * If `obj` is an Array callback will be called passing
+ * the value, index, and complete array for each item.
+ *
+ * If 'obj' is an Object callback will be called passing
+ * the value, key, and complete object for each property.
+ *
+ * @param {Object|Array} obj The object to iterate
+ * @param {Function} fn The callback to invoke for each item
+ *
+ * @param {Object} [options]
+ * @param {Boolean} [options.allOwnKeys = false]
+ * @returns {any}
+ */
+function forEach(obj, fn, { allOwnKeys = false } = {}) {
+ // Don't bother if no value provided
+ if (obj === null || typeof obj === 'undefined') {
+ return;
+ }
+
+ let i;
+ let l;
+
+ // Force an array if not already something iterable
+ if (typeof obj !== 'object') {
+ /*eslint no-param-reassign:0*/
+ obj = [obj];
+ }
+
+ if (isArray(obj)) {
+ // Iterate over array values
+ for (i = 0, l = obj.length; i < l; i++) {
+ fn.call(null, obj[i], i, obj);
+ }
+ } else {
+ // Buffer check
+ if (isBuffer(obj)) {
+ return;
+ }
+
+ // Iterate over object keys
+ const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
+ const len = keys.length;
+ let key;
+
+ for (i = 0; i < len; i++) {
+ key = keys[i];
+ fn.call(null, obj[key], key, obj);
+ }
+ }
+}
+
+/**
+ * Finds a key in an object, case-insensitive, returning the actual key name.
+ * Returns null if the object is a Buffer or if no match is found.
+ *
+ * @param {Object} obj - The object to search.
+ * @param {string} key - The key to find (case-insensitive).
+ * @returns {?string} The actual key name if found, otherwise null.
+ */
+function findKey(obj, key) {
+ if (isBuffer(obj)) {
+ return null;
+ }
+
+ key = key.toLowerCase();
+ const keys = Object.keys(obj);
+ let i = keys.length;
+ let _key;
+ while (i-- > 0) {
+ _key = keys[i];
+ if (key === _key.toLowerCase()) {
+ return _key;
+ }
+ }
+ return null;
+}
+
+const _global = (() => {
+ /*eslint no-undef:0*/
+ if (typeof globalThis !== 'undefined') return globalThis;
+ return typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : global;
+})();
+
+const isContextDefined = (context) => !isUndefined(context) && context !== _global;
+
+/**
+ * Accepts varargs expecting each argument to be an object, then
+ * immutably merges the properties of each object and returns result.
+ *
+ * When multiple objects contain the same key the later object in
+ * the arguments list will take precedence.
+ *
+ * Example:
+ *
+ * ```js
+ * const result = merge({foo: 123}, {foo: 456});
+ * console.log(result.foo); // outputs 456
+ * ```
+ *
+ * @param {Object} obj1 Object to merge
+ *
+ * @returns {Object} Result of all merge properties
+ */
+function utils_merge(...objs) {
+ const { caseless, skipUndefined } = (isContextDefined(this) && this) || {};
+ const result = {};
+ const assignValue = (val, key) => {
+ // Skip dangerous property names to prevent prototype pollution
+ if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+ return;
+ }
+
+ // findKey lowercases the key, so caseless lookup only applies to strings —
+ // symbol keys are identity-matched.
+ const targetKey = (caseless && typeof key === 'string' && findKey(result, key)) || key;
+ // Read via own-prop only — a bare `result[targetKey]` walks the prototype
+ // chain, so a polluted Object.prototype value could surface here and get
+ // copied into the merged result.
+ const existing = utils_hasOwnProperty(result, targetKey) ? result[targetKey] : undefined;
+ if (utils_isPlainObject(existing) && utils_isPlainObject(val)) {
+ result[targetKey] = utils_merge(existing, val);
+ } else if (utils_isPlainObject(val)) {
+ result[targetKey] = utils_merge({}, val);
+ } else if (isArray(val)) {
+ result[targetKey] = val.slice();
+ } else if (!skipUndefined || !isUndefined(val)) {
+ result[targetKey] = val;
+ }
+ };
+
+ for (let i = 0, l = objs.length; i < l; i++) {
+ const source = objs[i];
+ if (!source || isBuffer(source)) {
+ continue;
+ }
+
+ forEach(source, assignValue);
+
+ if (typeof source !== 'object' || isArray(source)) {
+ continue;
+ }
+
+ const symbols = Object.getOwnPropertySymbols(source);
+ for (let j = 0; j < symbols.length; j++) {
+ const symbol = symbols[j];
+ if (propertyIsEnumerable.call(source, symbol)) {
+ assignValue(source[symbol], symbol);
+ }
+ }
+ }
+ return result;
+}
+
+/**
+ * Extends object a by mutably adding to it the properties of object b.
+ *
+ * @param {Object} a The object to be extended
+ * @param {Object} b The object to copy properties from
+ * @param {Object} thisArg The object to bind function to
+ *
+ * @param {Object} [options]
+ * @param {Boolean} [options.allOwnKeys]
+ * @returns {Object} The resulting value of object a
+ */
+const utils_extend = (a, b, thisArg, { allOwnKeys } = {}) => {
+ forEach(
+ b,
+ (val, key) => {
+ if (thisArg && isFunction(val)) {
+ Object.defineProperty(a, key, {
+ // Null-proto descriptor so a polluted Object.prototype.get cannot
+ // hijack defineProperty's accessor-vs-data resolution.
+ __proto__: null,
+ value: bind_bind(val, thisArg),
+ writable: true,
+ enumerable: true,
+ configurable: true,
+ });
+ } else {
+ Object.defineProperty(a, key, {
+ __proto__: null,
+ value: val,
+ writable: true,
+ enumerable: true,
+ configurable: true,
+ });
+ }
+ },
+ { allOwnKeys }
+ );
+ return a;
+};
+
+/**
+ * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
+ *
+ * @param {string} content with BOM
+ *
+ * @returns {string} content value without BOM
+ */
+const stripBOM = (content) => {
+ if (content.charCodeAt(0) === 0xfeff) {
+ content = content.slice(1);
+ }
+ return content;
+};
+
+/**
+ * Inherit the prototype methods from one constructor into another
+ * @param {function} constructor
+ * @param {function} superConstructor
+ * @param {object} [props]
+ * @param {object} [descriptors]
+ *
+ * @returns {void}
+ */
+const inherits = (constructor, superConstructor, props, descriptors) => {
+ constructor.prototype = Object.create(superConstructor.prototype, descriptors);
+ Object.defineProperty(constructor.prototype, 'constructor', {
+ __proto__: null,
+ value: constructor,
+ writable: true,
+ enumerable: false,
+ configurable: true,
+ });
+ Object.defineProperty(constructor, 'super', {
+ __proto__: null,
+ value: superConstructor.prototype,
+ });
+ props && Object.assign(constructor.prototype, props);
+};
+
+/**
+ * Resolve object with deep prototype chain to a flat object
+ * @param {Object} sourceObj source object
+ * @param {Object} [destObj]
+ * @param {Function|Boolean} [filter]
+ * @param {Function} [propFilter]
+ *
+ * @returns {Object}
+ */
+const toFlatObject = (sourceObj, destObj, filter, propFilter) => {
+ let props;
+ let i;
+ let prop;
+ const merged = {};
+
+ destObj = destObj || {};
+ // eslint-disable-next-line no-eq-null,eqeqeq
+ if (sourceObj == null) return destObj;
+
+ do {
+ props = Object.getOwnPropertyNames(sourceObj);
+ i = props.length;
+ while (i-- > 0) {
+ prop = props[i];
+ if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {
+ destObj[prop] = sourceObj[prop];
+ merged[prop] = true;
+ }
+ }
+ sourceObj = filter !== false && getPrototypeOf(sourceObj);
+ } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
+
+ return destObj;
+};
+
+/**
+ * Determines whether a string ends with the characters of a specified string
+ *
+ * @param {String} str
+ * @param {String} searchString
+ * @param {Number} [position= 0]
+ *
+ * @returns {boolean}
+ */
+const endsWith = (str, searchString, position) => {
+ str = String(str);
+ if (position === undefined || position > str.length) {
+ position = str.length;
+ }
+ position -= searchString.length;
+ const lastIndex = str.indexOf(searchString, position);
+ return lastIndex !== -1 && lastIndex === position;
+};
+
+/**
+ * Returns new array from array like object or null if failed
+ *
+ * @param {*} [thing]
+ *
+ * @returns {?Array}
+ */
+const toArray = (thing) => {
+ if (!thing) return null;
+ if (isArray(thing)) return thing;
+ let i = thing.length;
+ if (!isNumber(i)) return null;
+ const arr = new Array(i);
+ while (i-- > 0) {
+ arr[i] = thing[i];
+ }
+ return arr;
+};
+
+/**
+ * Checking if the Uint8Array exists and if it does, it returns a function that checks if the
+ * thing passed in is an instance of Uint8Array
+ *
+ * @param {TypedArray}
+ *
+ * @returns {Array}
+ */
+// eslint-disable-next-line func-names
+const isTypedArray = ((TypedArray) => {
+ // eslint-disable-next-line func-names
+ return (thing) => {
+ return TypedArray && thing instanceof TypedArray;
+ };
+})(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array));
+
+/**
+ * For each entry in the object, call the function with the key and value.
+ *
+ * @param {Object} obj - The object to iterate over.
+ * @param {Function} fn - The function to call for each entry.
+ *
+ * @returns {void}
+ */
+const forEachEntry = (obj, fn) => {
+ const generator = obj && obj[utils_iterator];
+
+ const _iterator = generator.call(obj);
+
+ let result;
+
+ while ((result = _iterator.next()) && !result.done) {
+ const pair = result.value;
+ fn.call(obj, pair[0], pair[1]);
+ }
+};
+
+/**
+ * It takes a regular expression and a string, and returns an array of all the matches
+ *
+ * @param {string} regExp - The regular expression to match against.
+ * @param {string} str - The string to search.
+ *
+ * @returns {Array}
+ */
+const matchAll = (regExp, str) => {
+ let matches;
+ const arr = [];
+
+ while ((matches = regExp.exec(str)) !== null) {
+ arr.push(matches);
+ }
+
+ return arr;
+};
+
+/* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */
+const isHTMLForm = kindOfTest('HTMLFormElement');
+
+const toCamelCase = (str) => {
+ return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function replacer(m, p1, p2) {
+ return p1.toUpperCase() + p2;
+ });
+};
+
+const { propertyIsEnumerable } = Object.prototype;
+
+/**
+ * Determine if a value is a RegExp object
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a RegExp object, otherwise false
+ */
+const isRegExp = kindOfTest('RegExp');
+
+const reduceDescriptors = (obj, reducer) => {
+ const descriptors = Object.getOwnPropertyDescriptors(obj);
+ const reducedDescriptors = {};
+
+ forEach(descriptors, (descriptor, name) => {
+ let ret;
+ if ((ret = reducer(descriptor, name, obj)) !== false) {
+ reducedDescriptors[name] = ret || descriptor;
+ }
+ });
+
+ Object.defineProperties(obj, reducedDescriptors);
+};
+
+/**
+ * Makes all methods read-only
+ * @param {Object} obj
+ */
+
+const freezeMethods = (obj) => {
+ reduceDescriptors(obj, (descriptor, name) => {
+ // skip restricted props in strict mode
+ if (isFunction(obj) && ['arguments', 'caller', 'callee'].includes(name)) {
+ return false;
+ }
+
+ const value = obj[name];
+
+ if (!isFunction(value)) return;
+
+ descriptor.enumerable = false;
+
+ if ('writable' in descriptor) {
+ descriptor.writable = false;
+ return;
+ }
+
+ if (!descriptor.set) {
+ descriptor.set = () => {
+ throw Error("Can not rewrite read-only method '" + name + "'");
+ };
+ }
+ });
+};
+
+/**
+ * Converts an array or a delimited string into an object set with values as keys and true as values.
+ * Useful for fast membership checks.
+ *
+ * @param {Array|string} arrayOrString - The array or string to convert.
+ * @param {string} delimiter - The delimiter to use if input is a string.
+ * @returns {Object} An object with keys from the array or string, values set to true.
+ */
+const toObjectSet = (arrayOrString, delimiter) => {
+ const obj = {};
+
+ const define = (arr) => {
+ arr.forEach((value) => {
+ obj[value] = true;
+ });
+ };
+
+ isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));
+
+ return obj;
+};
+
+const utils_noop = () => {};
+
+const toFiniteNumber = (value, defaultValue) => {
+ return value != null && Number.isFinite((value = +value)) ? value : defaultValue;
+};
+
+/**
+ * If the thing is a FormData object, return true, otherwise return false.
+ *
+ * @param {unknown} thing - The thing to check.
+ *
+ * @returns {boolean}
+ */
+function isSpecCompliantForm(thing) {
+ return !!(
+ thing &&
+ isFunction(thing.append) &&
+ thing[toStringTag] === 'FormData' &&
+ thing[utils_iterator]
+ );
+}
+
+/**
+ * Recursively converts an object to a JSON-compatible object, handling circular references and Buffers.
+ *
+ * @param {Object} obj - The object to convert.
+ * @returns {Object} The JSON-compatible object.
+ */
+const toJSONObject = (obj) => {
+ const visited = new WeakSet();
+
+ const visit = (source) => {
+ if (utils_isObject(source)) {
+ if (visited.has(source)) {
+ return;
+ }
+
+ //Buffer check
+ if (isBuffer(source)) {
+ return source;
+ }
+
+ if (!('toJSON' in source)) {
+ // add-on descent / delete-on-ascent: preserves path semantics, so DAG nodes serialise at every occurrence (see #7230).
+ visited.add(source);
+ const target = isArray(source) ? [] : {};
+
+ forEach(source, (value, key) => {
+ const reducedValue = visit(value);
+ !isUndefined(reducedValue) && (target[key] = reducedValue);
+ });
+
+ visited.delete(source);
+
+ return target;
+ }
+ }
+
+ return source;
+ };
+
+ return visit(obj);
+};
+
+/**
+ * Determines if a value is an async function.
+ *
+ * @param {*} thing - The value to test.
+ * @returns {boolean} True if value is an async function, otherwise false.
+ */
+const isAsyncFn = kindOfTest('AsyncFunction');
+
+/**
+ * Determines if a value is thenable (has then and catch methods).
+ *
+ * @param {*} thing - The value to test.
+ * @returns {boolean} True if value is thenable, otherwise false.
+ */
+const isThenable = (thing) =>
+ thing &&
+ (utils_isObject(thing) || isFunction(thing)) &&
+ isFunction(thing.then) &&
+ isFunction(thing.catch);
+
+// original code
+// https://github.com/DigitalBrainJS/AxiosPromise/blob/16deab13710ec09779922131f3fa5954320f83ab/lib/utils.js#L11-L34
+
+/**
+ * Provides a cross-platform setImmediate implementation.
+ * Uses native setImmediate if available, otherwise falls back to postMessage or setTimeout.
+ *
+ * @param {boolean} setImmediateSupported - Whether setImmediate is supported.
+ * @param {boolean} postMessageSupported - Whether postMessage is supported.
+ * @returns {Function} A function to schedule a callback asynchronously.
+ */
+const _setImmediate = ((setImmediateSupported, postMessageSupported) => {
+ if (setImmediateSupported) {
+ return setImmediate;
+ }
+
+ return postMessageSupported
+ ? ((token, callbacks) => {
+ _global.addEventListener(
+ 'message',
+ ({ source, data }) => {
+ if (source === _global && data === token) {
+ callbacks.length && callbacks.shift()();
+ }
+ },
+ false
+ );
+
+ return (cb) => {
+ callbacks.push(cb);
+ _global.postMessage(token, '*');
+ };
+ })(`axios@${Math.random()}`, [])
+ : (cb) => setTimeout(cb);
+})(typeof setImmediate === 'function', isFunction(_global.postMessage));
+
+/**
+ * Schedules a microtask or asynchronous callback as soon as possible.
+ * Uses queueMicrotask if available, otherwise falls back to process.nextTick or _setImmediate.
+ *
+ * @type {Function}
+ */
+const asap =
+ typeof queueMicrotask !== 'undefined'
+ ? queueMicrotask.bind(_global)
+ : (typeof process !== 'undefined' && process.nextTick) || _setImmediate;
+
+// *********************
+
+const isIterable = (thing) => thing != null && isFunction(thing[utils_iterator]);
+
+/**
+ * Determine if a value is iterable via an iterator that is NOT sourced solely
+ * from a polluted Object.prototype. Use this instead of `isIterable` whenever
+ * the iterable comes from untrusted input (e.g. user-supplied header sources),
+ * so `Object.prototype[Symbol.iterator] = ...` cannot turn an ordinary object
+ * into an attacker-controlled entries iterator.
+ *
+ * @param {*} thing The value to test
+ *
+ * @returns {boolean} True if value has a non-polluted iterator
+ */
+const isSafeIterable = (thing) =>
+ thing != null && hasOwnInPrototypeChain(thing, utils_iterator) && isIterable(thing);
+
+/* harmony default export */ const lib_utils = ({
+ isArray,
+ isArrayBuffer: utils_isArrayBuffer,
+ isBuffer,
+ isFormData,
+ isArrayBufferView,
+ isString,
+ isNumber,
+ isBoolean,
+ isObject: utils_isObject,
+ isPlainObject: utils_isPlainObject,
+ isEmptyObject: utils_isEmptyObject,
+ isReadableStream: utils_isReadableStream,
+ isRequest,
+ isResponse,
+ isHeaders,
+ isUndefined,
+ isDate,
+ isFile,
+ isReactNativeBlob,
+ isReactNative: utils_isReactNative,
+ isBlob: utils_isBlob,
+ isRegExp,
+ isFunction,
+ isStream,
+ isURLSearchParams,
+ isTypedArray,
+ isFileList,
+ forEach,
+ merge: utils_merge,
+ extend: utils_extend,
+ trim,
+ stripBOM,
+ inherits,
+ toFlatObject,
+ kindOf,
+ kindOfTest,
+ endsWith,
+ toArray,
+ forEachEntry,
+ matchAll,
+ isHTMLForm,
+ hasOwnProperty: utils_hasOwnProperty,
+ hasOwnProp: utils_hasOwnProperty, // an alias to avoid ESLint no-prototype-builtins detection
+ hasOwnInPrototypeChain,
+ getSafeProp,
+ reduceDescriptors,
+ freezeMethods,
+ toObjectSet,
+ toCamelCase,
+ noop: utils_noop,
+ toFiniteNumber,
+ findKey,
+ global: _global,
+ isContextDefined,
+ isSpecCompliantForm,
+ toJSONObject,
+ isAsyncFn,
+ isThenable,
+ setImmediate: _setImmediate,
+ asap,
+ isIterable,
+ isSafeIterable,
+});
+
+;// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/parseHeaders.js
+
+
+
+
+// RawAxiosHeaders whose duplicates are ignored by node
+// c.f. https://nodejs.org/api/http.html#http_message_headers
+const ignoreDuplicateOf = lib_utils.toObjectSet([
+ 'age',
+ 'authorization',
+ 'content-length',
+ 'content-type',
+ 'etag',
+ 'expires',
+ 'from',
+ 'host',
+ 'if-modified-since',
+ 'if-unmodified-since',
+ 'last-modified',
+ 'location',
+ 'max-forwards',
+ 'proxy-authorization',
+ 'referer',
+ 'retry-after',
+ 'user-agent',
+]);
+
+/**
+ * Parse headers into an object
+ *
+ * ```
+ * Date: Wed, 27 Aug 2014 08:58:49 GMT
+ * Content-Type: application/json
+ * Connection: keep-alive
+ * Transfer-Encoding: chunked
+ * ```
+ *
+ * @param {String} rawHeaders Headers needing to be parsed
+ *
+ * @returns {Object} Headers parsed into an object
+ */
+/* harmony default export */ const parseHeaders = ((rawHeaders) => {
+ const parsed = {};
+ let key;
+ let val;
+ let i;
+
+ rawHeaders &&
+ rawHeaders.split('\n').forEach(function parser(line) {
+ i = line.indexOf(':');
+ key = line.substring(0, i).trim().toLowerCase();
+ val = line.substring(i + 1).trim();
+
+ if (!key || (parsed[key] && ignoreDuplicateOf[key])) {
+ return;
+ }
+
+ if (key === 'set-cookie') {
+ if (parsed[key]) {
+ parsed[key].push(val);
+ } else {
+ parsed[key] = [val];
+ }
+ } else {
+ parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
+ }
+ });
+
+ return parsed;
+});
+
+;// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/sanitizeHeaderValue.js
+
+
+
+
+function trimSPorHTAB(str) {
+ let start = 0;
+ let end = str.length;
+
+ while (start < end) {
+ const code = str.charCodeAt(start);
+
+ if (code !== 0x09 && code !== 0x20) {
+ break;
+ }
+
+ start += 1;
+ }
+
+ while (end > start) {
+ const code = str.charCodeAt(end - 1);
+
+ if (code !== 0x09 && code !== 0x20) {
+ break;
+ }
+
+ end -= 1;
+ }
+
+ return start === 0 && end === str.length ? str : str.slice(start, end);
+}
+
+// The control-code ranges are intentional: header sanitization strips C0/DEL bytes.
+// eslint-disable-next-line no-control-regex
+const INVALID_UNICODE_HEADER_VALUE_CHARS = new RegExp('[\\u0000-\\u0008\\u000a-\\u001f\\u007f]+', 'g');
+// eslint-disable-next-line no-control-regex
+const INVALID_BYTE_STRING_HEADER_VALUE_CHARS = new RegExp('[^\\u0009\\u0020-\\u007e\\u0080-\\u00ff]+', 'g');
+
+function sanitizeValue(value, invalidChars) {
+ if (lib_utils.isArray(value)) {
+ return value.map((item) => sanitizeValue(item, invalidChars));
+ }
+
+ return trimSPorHTAB(String(value).replace(invalidChars, ''));
+}
+
+const sanitizeHeaderValue = (value) =>
+ sanitizeValue(value, INVALID_UNICODE_HEADER_VALUE_CHARS);
+
+const sanitizeByteStringHeaderValue = (value) =>
+ sanitizeValue(value, INVALID_BYTE_STRING_HEADER_VALUE_CHARS);
+
+function toByteStringHeaderObject(headers) {
+ const byteStringHeaders = Object.create(null);
+
+ lib_utils.forEach(headers.toJSON(), (value, header) => {
+ byteStringHeaders[header] = sanitizeByteStringHeaderValue(value);
+ });
+
+ return byteStringHeaders;
+}
+
+;// CONCATENATED MODULE: ./node_modules/axios/lib/core/AxiosHeaders.js
+
+
+
+
+
+
+const $internals = Symbol('internals');
+
+function normalizeHeader(header) {
+ return header && String(header).trim().toLowerCase();
+}
+
+function normalizeValue(value) {
+ if (value === false || value == null) {
+ return value;
+ }
+
+ return lib_utils.isArray(value) ? value.map(normalizeValue) : sanitizeHeaderValue(String(value));
+}
+
+function parseTokens(str) {
+ const tokens = Object.create(null);
+ const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
+ let match;
+
+ while ((match = tokensRE.exec(str))) {
+ tokens[match[1]] = match[2];
+ }
+
+ return tokens;
+}
+
+const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
+
+function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
+ if (lib_utils.isFunction(filter)) {
+ return filter.call(this, value, header);
+ }
+
+ if (isHeaderNameFilter) {
+ value = header;
+ }
+
+ if (!lib_utils.isString(value)) return;
+
+ if (lib_utils.isString(filter)) {
+ return value.indexOf(filter) !== -1;
+ }
+
+ if (lib_utils.isRegExp(filter)) {
+ return filter.test(value);
+ }
+}
+
+function formatHeader(header) {
+ return header
+ .trim()
+ .toLowerCase()
+ .replace(/([a-z\d])(\w*)/g, (w, char, str) => {
+ return char.toUpperCase() + str;
+ });
+}
+
+function buildAccessors(obj, header) {
+ const accessorName = lib_utils.toCamelCase(' ' + header);
+
+ ['get', 'set', 'has'].forEach((methodName) => {
+ Object.defineProperty(obj, methodName + accessorName, {
+ // Null-proto descriptor so a polluted Object.prototype.get cannot turn
+ // this data descriptor into an accessor descriptor on the way in.
+ __proto__: null,
+ value: function (arg1, arg2, arg3) {
+ return this[methodName].call(this, header, arg1, arg2, arg3);
+ },
+ configurable: true,
+ });
+ });
+}
+
+class AxiosHeaders {
+ constructor(headers) {
+ headers && this.set(headers);
+ }
+
+ set(header, valueOrRewrite, rewrite) {
+ const self = this;
+
+ function setHeader(_value, _header, _rewrite) {
+ const lHeader = normalizeHeader(_header);
+
+ if (!lHeader) {
+ return;
+ }
+
+ const key = lib_utils.findKey(self, lHeader);
+
+ if (
+ !key ||
+ self[key] === undefined ||
+ _rewrite === true ||
+ (_rewrite === undefined && self[key] !== false)
+ ) {
+ self[key || _header] = normalizeValue(_value);
+ }
+ }
+
+ const setHeaders = (headers, _rewrite) =>
+ lib_utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
+
+ if (lib_utils.isPlainObject(header) || header instanceof this.constructor) {
+ setHeaders(header, valueOrRewrite);
+ } else if (lib_utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
+ setHeaders(parseHeaders(header), valueOrRewrite);
+ } else if (lib_utils.isObject(header) && lib_utils.isSafeIterable(header)) {
+ let obj = Object.create(null),
+ dest,
+ key;
+ for (const entry of header) {
+ if (!lib_utils.isArray(entry)) {
+ throw new TypeError('Object iterator must return a key-value pair');
+ }
+
+ key = entry[0];
+
+ if (lib_utils.hasOwnProp(obj, key)) {
+ dest = obj[key];
+ obj[key] = lib_utils.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]];
+ } else {
+ obj[key] = entry[1];
+ }
+ }
+
+ setHeaders(obj, valueOrRewrite);
+ } else {
+ header != null && setHeader(valueOrRewrite, header, rewrite);
+ }
+
+ return this;
+ }
+
+ get(header, parser) {
+ header = normalizeHeader(header);
+
+ if (header) {
+ const key = lib_utils.findKey(this, header);
+
+ if (key) {
+ const value = this[key];
+
+ if (!parser) {
+ return value;
+ }
+
+ if (parser === true) {
+ return parseTokens(value);
+ }
+
+ if (lib_utils.isFunction(parser)) {
+ return parser.call(this, value, key);
+ }
+
+ if (lib_utils.isRegExp(parser)) {
+ return parser.exec(value);
+ }
+
+ throw new TypeError('parser must be boolean|regexp|function');
+ }
+ }
+ }
+
+ has(header, matcher) {
+ header = normalizeHeader(header);
+
+ if (header) {
+ const key = lib_utils.findKey(this, header);
+
+ return !!(
+ key &&
+ this[key] !== undefined &&
+ (!matcher || matchHeaderValue(this, this[key], key, matcher))
+ );
+ }
+
+ return false;
+ }
+
+ delete(header, matcher) {
+ const self = this;
+ let deleted = false;
+
+ function deleteHeader(_header) {
+ _header = normalizeHeader(_header);
+
+ if (_header) {
+ const key = lib_utils.findKey(self, _header);
+
+ if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {
+ delete self[key];
+
+ deleted = true;
+ }
+ }
+ }
+
+ if (lib_utils.isArray(header)) {
+ header.forEach(deleteHeader);
+ } else {
+ deleteHeader(header);
+ }
+
+ return deleted;
+ }
+
+ clear(matcher) {
+ const keys = Object.keys(this);
+ let i = keys.length;
+ let deleted = false;
+
+ while (i--) {
+ const key = keys[i];
+ if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
+ delete this[key];
+ deleted = true;
+ }
+ }
+
+ return deleted;
+ }
+
+ normalize(format) {
+ const self = this;
+ const headers = {};
+
+ lib_utils.forEach(this, (value, header) => {
+ const key = lib_utils.findKey(headers, header);
+
+ if (key) {
+ self[key] = normalizeValue(value);
+ delete self[header];
+ return;
+ }
+
+ const normalized = format ? formatHeader(header) : String(header).trim();
+
+ if (normalized !== header) {
+ delete self[header];
+ }
+
+ self[normalized] = normalizeValue(value);
+
+ headers[normalized] = true;
+ });
+
+ return this;
+ }
+
+ concat(...targets) {
+ return this.constructor.concat(this, ...targets);
+ }
+
+ toJSON(asStrings) {
+ const obj = Object.create(null);
+
+ lib_utils.forEach(this, (value, header) => {
+ value != null &&
+ value !== false &&
+ (obj[header] = asStrings && lib_utils.isArray(value) ? value.join(', ') : value);
+ });
+
+ return obj;
+ }
+
+ [Symbol.iterator]() {
+ return Object.entries(this.toJSON())[Symbol.iterator]();
+ }
+
+ toString() {
+ return Object.entries(this.toJSON())
+ .map(([header, value]) => header + ': ' + value)
+ .join('\n');
+ }
+
+ getSetCookie() {
+ return this.get('set-cookie') || [];
+ }
+
+ get [Symbol.toStringTag]() {
+ return 'AxiosHeaders';
+ }
+
+ static from(thing) {
+ return thing instanceof this ? thing : new this(thing);
+ }
+
+ static concat(first, ...targets) {
+ const computed = new this(first);
+
+ targets.forEach((target) => computed.set(target));
+
+ return computed;
+ }
+
+ static accessor(header) {
+ const internals =
+ (this[$internals] =
+ this[$internals] =
+ {
+ accessors: {},
+ });
+
+ const accessors = internals.accessors;
+ const prototype = this.prototype;
+
+ function defineAccessor(_header) {
+ const lHeader = normalizeHeader(_header);
+
+ if (!accessors[lHeader]) {
+ buildAccessors(prototype, _header);
+ accessors[lHeader] = true;
+ }
+ }
+
+ lib_utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
+
+ return this;
+ }
+}
+
+AxiosHeaders.accessor([
+ 'Content-Type',
+ 'Content-Length',
+ 'Accept',
+ 'Accept-Encoding',
+ 'User-Agent',
+ 'Authorization',
+]);
+
+// reserved names hotfix
+lib_utils.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key) => {
+ let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`
+ return {
+ get: () => value,
+ set(headerValue) {
+ this[mapped] = headerValue;
+ },
+ };
+});
+
+lib_utils.freezeMethods(AxiosHeaders);
+
+/* harmony default export */ const core_AxiosHeaders = (AxiosHeaders);
+
+;// CONCATENATED MODULE: ./node_modules/axios/lib/core/AxiosError.js
+
+
+
+
+
+const REDACTED = '[REDACTED ****]';
+
+function hasOwnOrPrototypeToJSON(source) {
+ if (lib_utils.hasOwnProp(source, 'toJSON')) {
+ return true;
+ }
+
+ let prototype = Object.getPrototypeOf(source);
+
+ while (prototype && prototype !== Object.prototype) {
+ if (lib_utils.hasOwnProp(prototype, 'toJSON')) {
+ return true;
+ }
+
+ prototype = Object.getPrototypeOf(prototype);
+ }
+
+ return false;
+}
+
+// Build a plain-object snapshot of `config` and replace the value of any key
+// (case-insensitive) listed in `redactKeys` with REDACTED. Walks through arrays
+// and AxiosHeaders, and short-circuits on circular references.
+function redactConfig(config, redactKeys) {
+ const lowerKeys = new Set(redactKeys.map((k) => String(k).toLowerCase()));
+ const seen = [];
+
+ const visit = (source) => {
+ if (source === null || typeof source !== 'object') return source;
+ if (lib_utils.isBuffer(source)) return source;
+ if (seen.indexOf(source) !== -1) return undefined;
+
+ if (source instanceof core_AxiosHeaders) {
+ source = source.toJSON();
+ }
+
+ seen.push(source);
+
+ let result;
+ if (lib_utils.isArray(source)) {
+ result = [];
+ source.forEach((v, i) => {
+ const reducedValue = visit(v);
+ if (!lib_utils.isUndefined(reducedValue)) {
+ result[i] = reducedValue;
+ }
+ });
+ } else {
+ if (!lib_utils.isPlainObject(source) && hasOwnOrPrototypeToJSON(source)) {
+ seen.pop();
+ return source;
+ }
+
+ result = Object.create(null);
+ for (const [key, value] of Object.entries(source)) {
+ const reducedValue = lowerKeys.has(key.toLowerCase()) ? REDACTED : visit(value);
+ if (!lib_utils.isUndefined(reducedValue)) {
+ result[key] = reducedValue;
+ }
+ }
+ }
+
+ seen.pop();
+ return result;
+ };
+
+ return visit(config);
+}
+
+class AxiosError extends Error {
+ static from(error, code, config, request, response, customProps) {
+ const axiosError = new AxiosError(error.message, code || error.code, config, request, response);
+ // Match native `Error` `cause` semantics: non-enumerable. The wrapped
+ // error often carries circular internals (sockets, requests, agents), so
+ // an enumerable `cause` makes structured loggers (pino/winston) and any
+ // own-property walk throw "Converting circular structure to JSON".
+ // Regression from #6982; see #7205. `__proto__: null` mirrors the
+ // `message` descriptor below (prototype-pollution-safe descriptor).
+ Object.defineProperty(axiosError, 'cause', {
+ __proto__: null,
+ value: error,
+ writable: true,
+ enumerable: false,
+ configurable: true,
+ });
+ axiosError.name = error.name;
+
+ // Preserve status from the original error if not already set from response
+ if (error.status != null && axiosError.status == null) {
+ axiosError.status = error.status;
+ }
+
+ customProps && Object.assign(axiosError, customProps);
+ return axiosError;
+ }
+
+ /**
+ * Create an Error with the specified message, config, error code, request and response.
+ *
+ * @param {string} message The error message.
+ * @param {string} [code] The error code (for example, 'ECONNABORTED').
+ * @param {Object} [config] The config.
+ * @param {Object} [request] The request.
+ * @param {Object} [response] The response.
+ *
+ * @returns {Error} The created error.
+ */
+ constructor(message, code, config, request, response) {
+ super(message);
+
+ // Make message enumerable to maintain backward compatibility
+ // The native Error constructor sets message as non-enumerable,
+ // but axios < v1.13.3 had it as enumerable
+ Object.defineProperty(this, 'message', {
+ // Null-proto descriptor so a polluted Object.prototype.get cannot turn
+ // this data descriptor into an accessor descriptor on the way in.
+ __proto__: null,
+ value: message,
+ enumerable: true,
+ writable: true,
+ configurable: true,
+ });
+
+ this.name = 'AxiosError';
+ this.isAxiosError = true;
+ code && (this.code = code);
+ config && (this.config = config);
+ request && (this.request = request);
+ if (response) {
+ this.response = response;
+ this.status = response.status;
+ }
+ }
+
+ toJSON() {
+ // Opt-in redaction: when the request config carries a `redact` array, the
+ // value of any matching key (case-insensitive, at any depth) is replaced
+ // with REDACTED in the serialized snapshot. Undefined or empty leaves the
+ // existing serialization behavior unchanged.
+ const config = this.config;
+ const redactKeys = config && lib_utils.hasOwnProp(config, 'redact') ? config.redact : undefined;
+ const serializedConfig =
+ lib_utils.isArray(redactKeys) && redactKeys.length > 0
+ ? redactConfig(config, redactKeys)
+ : lib_utils.toJSONObject(config);
+
+ return {
+ // Standard
+ message: this.message,
+ name: this.name,
+ // Microsoft
+ description: this.description,
+ number: this.number,
+ // Mozilla
+ fileName: this.fileName,
+ lineNumber: this.lineNumber,
+ columnNumber: this.columnNumber,
+ stack: this.stack,
+ // Axios
+ config: serializedConfig,
+ code: this.code,
+ status: this.status,
+ };
+ }
+}
+
+// This can be changed to static properties as soon as the parser options in .eslint.cjs are updated.
+AxiosError.ERR_BAD_OPTION_VALUE = 'ERR_BAD_OPTION_VALUE';
+AxiosError.ERR_BAD_OPTION = 'ERR_BAD_OPTION';
+AxiosError.ECONNABORTED = 'ECONNABORTED';
+AxiosError.ETIMEDOUT = 'ETIMEDOUT';
+AxiosError.ECONNREFUSED = 'ECONNREFUSED';
+AxiosError.ERR_NETWORK = 'ERR_NETWORK';
+AxiosError.ERR_FR_TOO_MANY_REDIRECTS = 'ERR_FR_TOO_MANY_REDIRECTS';
+AxiosError.ERR_DEPRECATED = 'ERR_DEPRECATED';
+AxiosError.ERR_BAD_RESPONSE = 'ERR_BAD_RESPONSE';
+AxiosError.ERR_BAD_REQUEST = 'ERR_BAD_REQUEST';
+AxiosError.ERR_CANCELED = 'ERR_CANCELED';
+AxiosError.ERR_NOT_SUPPORT = 'ERR_NOT_SUPPORT';
+AxiosError.ERR_INVALID_URL = 'ERR_INVALID_URL';
+AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED = 'ERR_FORM_DATA_DEPTH_EXCEEDED';
+
+/* harmony default export */ const core_AxiosError = (AxiosError);
+
+// EXTERNAL MODULE: ./node_modules/form-data/lib/form_data.js
+var form_data = __nccwpck_require__(6454);
+;// CONCATENATED MODULE: ./node_modules/axios/lib/platform/node/classes/FormData.js
+
+
+/* harmony default export */ const classes_FormData = (form_data);
+
+;// CONCATENATED MODULE: ./node_modules/axios/lib/helpers/toFormData.js
+
+
+
+
+// temporary hotfix to avoid circular references until AxiosURLSearchParams is refactored
+
+
+// Default nesting limit shared with the inverse transform (formDataToJSON) so
+// the FormData <-> JSON round-trip stays symmetric.
+const DEFAULT_FORM_DATA_MAX_DEPTH = 100;
+
+/**
+ * Determines if the given thing is a array or js object.
+ *
+ * @param {string} thing - The object or array to be visited.
+ *
+ * @returns {boolean}
+ */
+function isVisitable(thing) {
+ return lib_utils.isPlainObject(thing) || lib_utils.isArray(thing);
+}
+
+/**
+ * It removes the brackets from the end of a string
+ *
+ * @param {string} key - The key of the parameter.
+ *
+ * @returns {string} the key without the brackets.
+ */
+function removeBrackets(key) {
+ return lib_utils.endsWith(key, '[]') ? key.slice(0, -2) : key;
+}
+
+/**
+ * It takes a path, a key, and a boolean, and returns a string
+ *
+ * @param {string} path - The path to the current key.
+ * @param {string} key - The key of the current object being iterated over.
+ * @param {string} dots - If true, the key will be rendered with dots instead of brackets.
+ *
+ * @returns {string} The path to the current key.
+ */
+function renderKey(path, key, dots) {
+ if (!path) return key;
+ return path
+ .concat(key)
+ .map(function each(token, i) {
+ // eslint-disable-next-line no-param-reassign
+ token = removeBrackets(token);
+ return !dots && i ? '[' + token + ']' : token;
+ })
+ .join(dots ? '.' : '');
+}
+
+/**
+ * If the array is an array and none of its elements are visitable, then it's a flat array.
+ *
+ * @param {Array} arr - The array to check
+ *
+ * @returns {boolean}
+ */
+function isFlatArray(arr) {
+ return lib_utils.isArray(arr) && !arr.some(isVisitable);
+}
+
+const predicates = lib_utils.toFlatObject(lib_utils, {}, null, function filter(prop) {
+ return /^is[A-Z]/.test(prop);
+});
+
+/**
+ * Convert a data object to FormData
+ *
+ * @param {Object} obj
+ * @param {?Object} [formData]
+ * @param {?Object} [options]
+ * @param {Function} [options.visitor]
+ * @param {Boolean} [options.metaTokens = true]
+ * @param {Boolean} [options.dots = false]
+ * @param {?Boolean} [options.indexes = false]
+ *
+ * @returns {Object}
+ **/
+
+/**
+ * It converts an object into a FormData object
+ *
+ * @param {Object} obj - The object to convert to form data.
+ * @param {string} formData - The FormData object to append to.
+ * @param {Object} options
+ *
+ * @returns
+ */
+function toFormData(obj, formData, options) {
+ if (!lib_utils.isObject(obj)) {
+ throw new TypeError('target must be an object');
+ }
+
+ // eslint-disable-next-line no-param-reassign
+ formData = formData || new (classes_FormData || FormData)();
+
+ // eslint-disable-next-line no-param-reassign
+ options = lib_utils.toFlatObject(
+ options,
+ {
+ metaTokens: true,
+ dots: false,
+ indexes: false,
+ },
+ false,
+ function defined(option, source) {
+ // eslint-disable-next-line no-eq-null,eqeqeq
+ return !lib_utils.isUndefined(source[option]);
+ }
+ );
+
+ const metaTokens = options.metaTokens;
+ // eslint-disable-next-line no-use-before-define
+ const visitor = options.visitor || defaultVisitor;
+ const dots = options.dots;
+ const indexes = options.indexes;
+ const _Blob = options.Blob || (typeof Blob !== 'undefined' && Blob);
+ const maxDepth = options.maxDepth === undefined ? DEFAULT_FORM_DATA_MAX_DEPTH : options.maxDepth;
+ const useBlob = _Blob && lib_utils.isSpecCompliantForm(formData);
+ const stack = [];
+
+ if (!lib_utils.isFunction(visitor)) {
+ throw new TypeError('visitor must be a function');
+ }
+
+ function convertValue(value) {
+ if (value === null) return '';
+
+ if (lib_utils.isDate(value)) {
+ return value.toISOString();
+ }
+
+ if (lib_utils.isBoolean(value)) {
+ return value.toString();
+ }
+
+ if (!useBlob && lib_utils.isBlob(value)) {
+ throw new core_AxiosError('Blob is not supported. Use a Buffer instead.');
+ }
+
+ if (lib_utils.isArrayBuffer(value) || lib_utils.isTypedArray(value)) {
+ if (useBlob && typeof _Blob === 'function') {
+ return new _Blob([value]);
+ }
+ if (typeof Buffer !== 'undefined') {
+ return Buffer.from(value);
+ }
+ throw new core_AxiosError('Blob is not supported. Use a Buffer instead.', core_AxiosError.ERR_NOT_SUPPORT);
+ }
+
+ return value;
+ }
+
+ function throwIfMaxDepthExceeded(depth) {
+ if (depth > maxDepth) {
+ throw new core_AxiosError(
+ 'Object is too deeply nested (' + depth + ' levels). Max depth: ' + maxDepth,
+ core_AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED
+ );
+ }
+ }
+
+ function stringifyWithDepthLimit(value, depth) {
+ if (maxDepth === Infinity) {
+ return JSON.stringify(value);
+ }
+
+ const ancestors = [];
+
+ return JSON.stringify(value, function limitDepth(_key, currentValue) {
+ if (!lib_utils.isObject(currentValue)) {
+ return currentValue;
+ }
+
+ while (ancestors.length && ancestors[ancestors.length - 1] !== this) {
+ ancestors.pop();
+ }
+
+ ancestors.push(currentValue);
+ throwIfMaxDepthExceeded(depth + ancestors.length - 1);
+
+ return currentValue;
+ });
+ }
+
+ /**
+ * Default visitor.
+ *
+ * @param {*} value
+ * @param {String|Number} key
+ * @param {Array