diff --git a/dist/index.js b/dist/index.js index 6ed114c..026376e 100644 --- a/dist/index.js +++ b/dist/index.js @@ -12374,21 +12374,36 @@ function onceStrict (fn) { "use strict"; -module.exports = __nccwpck_require__(3322); +const pico = __nccwpck_require__(3322); +const utils = __nccwpck_require__(479); + +function picomatch(glob, options, returnState = false) { + // default to os.platform() + if (options && (options.windows === null || options.windows === undefined)) { + // don't mutate the original options object + options = { ...options, windows: utils.isWindows() }; + } + + return pico(glob, options, returnState); +} + +Object.assign(picomatch, pico); +module.exports = picomatch; /***/ }), /***/ 6099: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { +/***/ ((module) => { "use strict"; -const path = __nccwpck_require__(1017); const WIN_SLASH = '\\\\/'; const WIN_NO_SLASH = `[^${WIN_SLASH}]`; +const DEFAULT_MAX_EXTGLOB_RECURSION = 0; + /** * Posix glob regex */ @@ -12408,6 +12423,7 @@ const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`; const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`; const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`; const STAR = `${QMARK}*?`; +const SEP = '/'; const POSIX_CHARS = { DOT_LITERAL, @@ -12424,7 +12440,8 @@ const POSIX_CHARS = { NO_DOTS_SLASH, QMARK_NO_DOT, STAR, - START_ANCHOR + START_ANCHOR, + SEP }; /** @@ -12444,7 +12461,8 @@ const WINDOWS_CHARS = { NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, QMARK_NO_DOT: `[^.${WIN_SLASH}]`, START_ANCHOR: `(?:^|[${WIN_SLASH}])`, - END_ANCHOR: `(?:[${WIN_SLASH}]|$)` + END_ANCHOR: `(?:[${WIN_SLASH}]|$)`, + SEP: '\\' }; /** @@ -12452,6 +12470,7 @@ const WINDOWS_CHARS = { */ const POSIX_REGEX_SOURCE = { + __proto__: null, alnum: 'a-zA-Z0-9', alpha: 'a-zA-Z', ascii: '\\x00-\\x7F', @@ -12469,6 +12488,7 @@ const POSIX_REGEX_SOURCE = { }; module.exports = { + DEFAULT_MAX_EXTGLOB_RECURSION, MAX_LENGTH: 1024 * 64, POSIX_REGEX_SOURCE, @@ -12482,6 +12502,7 @@ module.exports = { // Replace globs with equivalent patterns to reduce parsing time. REPLACEMENTS: { + __proto__: null, '***': '*', '**/**': '**', '**/**/**': '**' @@ -12538,8 +12559,6 @@ module.exports = { CHAR_VERTICAL_LINE: 124, /* | */ CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */ - SEP: path.sep, - /** * Create EXTGLOB_CHARS */ @@ -12617,6 +12636,307 @@ const syntaxError = (type, char) => { return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`; }; +const splitTopLevel = input => { + const parts = []; + let bracket = 0; + let paren = 0; + let quote = 0; + let value = ''; + let escaped = false; + + for (const ch of input) { + if (escaped === true) { + value += ch; + escaped = false; + continue; + } + + if (ch === '\\') { + value += ch; + escaped = true; + continue; + } + + if (ch === '"') { + quote = quote === 1 ? 0 : 1; + value += ch; + continue; + } + + if (quote === 0) { + if (ch === '[') { + bracket++; + } else if (ch === ']' && bracket > 0) { + bracket--; + } else if (bracket === 0) { + if (ch === '(') { + paren++; + } else if (ch === ')' && paren > 0) { + paren--; + } else if (ch === '|' && paren === 0) { + parts.push(value); + value = ''; + continue; + } + } + } + + value += ch; + } + + parts.push(value); + return parts; +}; + +const isPlainBranch = branch => { + let escaped = false; + + for (const ch of branch) { + if (escaped === true) { + escaped = false; + continue; + } + + if (ch === '\\') { + escaped = true; + continue; + } + + if (/[?*+@!()[\]{}]/.test(ch)) { + return false; + } + } + + return true; +}; + +const normalizeSimpleBranch = branch => { + let value = branch.trim(); + let changed = true; + + while (changed === true) { + changed = false; + + if (/^@\([^\\()[\]{}|]+\)$/.test(value)) { + value = value.slice(2, -1); + changed = true; + } + } + + if (!isPlainBranch(value)) { + return; + } + + return value.replace(/\\(.)/g, '$1'); +}; + +const hasRepeatedCharPrefixOverlap = branches => { + const values = branches.map(normalizeSimpleBranch).filter(Boolean); + + for (let i = 0; i < values.length; i++) { + for (let j = i + 1; j < values.length; j++) { + const a = values[i]; + const b = values[j]; + const char = a[0]; + + if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) { + continue; + } + + if (a === b || a.startsWith(b) || b.startsWith(a)) { + return true; + } + } + } + + return false; +}; + +const parseRepeatedExtglob = (pattern, requireEnd = true) => { + if ((pattern[0] !== '+' && pattern[0] !== '*') || pattern[1] !== '(') { + return; + } + + let bracket = 0; + let paren = 0; + let quote = 0; + let escaped = false; + + for (let i = 1; i < pattern.length; i++) { + const ch = pattern[i]; + + if (escaped === true) { + escaped = false; + continue; + } + + if (ch === '\\') { + escaped = true; + continue; + } + + if (ch === '"') { + quote = quote === 1 ? 0 : 1; + continue; + } + + if (quote === 1) { + continue; + } + + if (ch === '[') { + bracket++; + continue; + } + + if (ch === ']' && bracket > 0) { + bracket--; + continue; + } + + if (bracket > 0) { + continue; + } + + if (ch === '(') { + paren++; + continue; + } + + if (ch === ')') { + paren--; + + if (paren === 0) { + if (requireEnd === true && i !== pattern.length - 1) { + return; + } + + return { + type: pattern[0], + body: pattern.slice(2, i), + end: i + }; + } + } + } +}; + +const buildCharClassStar = chars => { + const source = chars.length === 1 + ? utils.escapeRegex(chars[0]) + : `[${chars.map(ch => utils.escapeRegex(ch)).join('')}]`; + + return `${source}*`; +}; + +const getStarExtglobSequenceChars = pattern => { + let index = 0; + const chars = []; + + while (index < pattern.length) { + const match = parseRepeatedExtglob(pattern.slice(index), false); + + if (!match || match.type !== '*') { + return; + } + + const branches = splitTopLevel(match.body).map(branch => branch.trim()); + if (branches.length !== 1) { + return; + } + + const branch = normalizeSimpleBranch(branches[0]); + if (!branch || branch.length !== 1) { + return; + } + + chars.push(branch); + index += match.end + 1; + } + + if (chars.length < 1) { + return; + } + + return chars; +}; + +const repeatedExtglobRecursion = pattern => { + let depth = 0; + let value = pattern.trim(); + let match = parseRepeatedExtglob(value); + + while (match) { + depth++; + value = match.body.trim(); + match = parseRepeatedExtglob(value); + } + + return depth; +}; + +const analyzeRepeatedExtglob = (body, options) => { + if (options.maxExtglobRecursion === false) { + return { risky: false }; + } + + const max = + typeof options.maxExtglobRecursion === 'number' + ? options.maxExtglobRecursion + : constants.DEFAULT_MAX_EXTGLOB_RECURSION; + + const branches = splitTopLevel(body).map(branch => branch.trim()); + + if (branches.length > 1) { + if ( + branches.some(branch => branch === '') || + branches.some(branch => /^[*?]+$/.test(branch)) || + hasRepeatedCharPrefixOverlap(branches) + ) { + return { risky: true }; + } + } + + // A repeated extglob is "risky" (prone to catastrophic backtracking) when a + // branch is itself a `*(...)` sequence, since that nests an unbounded quantifier + // inside the outer `+(...)`/`*(...)`. When *every* branch reduces to single + // characters we can emit one flat, ReDoS-safe character class that preserves the + // meaning of ALL branches (e.g. `+(*(a)|*(b))` -> `[ab]*`), rather than dropping + // every branch but the first. + const safeChars = []; + let sawStarSequence = false; + let combinable = true; + + for (const branch of branches) { + const chars = getStarExtglobSequenceChars(branch); + if (chars) { + sawStarSequence = true; + safeChars.push(...chars); + continue; + } + + const literal = normalizeSimpleBranch(branch); + if (literal && literal.length === 1) { + safeChars.push(literal); + continue; + } + + combinable = false; + + if (repeatedExtglobRecursion(branch) > max) { + return { risky: true }; + } + } + + if (sawStarSequence) { + return combinable + ? { risky: true, safeOutput: buildCharClassStar([...new Set(safeChars)]) } + : { risky: true }; + } + + return { risky: false }; +}; + /** * Parse the given input string. * @param {String} input @@ -12643,10 +12963,9 @@ const parse = (input, options) => { const tokens = [bos]; const capture = opts.capture ? '' : '?:'; - const win32 = utils.isWindows(options); // create constants based on platform, for windows or posix - const PLATFORM_CHARS = constants.globChars(win32); + const PLATFORM_CHARS = constants.globChars(opts.windows); const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS); const { @@ -12782,8 +13101,8 @@ const parse = (input, options) => { if (tok.value || tok.output) append(tok); if (prev && prev.type === 'text' && tok.type === 'text') { + prev.output = (prev.output || prev.value) + tok.value; prev.value += tok.value; - prev.output = (prev.output || '') + tok.value; return; } @@ -12798,6 +13117,8 @@ const parse = (input, options) => { token.prev = prev; token.parens = state.parens; token.output = state.output; + token.startIndex = state.index; + token.tokensIndex = tokens.length; const output = (opts.capture ? '(' : '') + token.open; increment('parens'); @@ -12807,6 +13128,34 @@ const parse = (input, options) => { }; const extglobClose = token => { + const literal = input.slice(token.startIndex, state.index + 1); + const body = input.slice(token.startIndex + 2, state.index); + const analysis = analyzeRepeatedExtglob(body, opts); + + if ((token.type === 'plus' || token.type === 'star') && analysis.risky) { + const safeOutput = analysis.safeOutput + ? (token.output ? '' : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) + : undefined; + const open = tokens[token.tokensIndex]; + + open.type = 'text'; + open.value = literal; + open.output = safeOutput || utils.escapeRegex(literal); + + for (let i = token.tokensIndex + 1; i < tokens.length; i++) { + tokens[i].value = ''; + tokens[i].output = ''; + delete tokens[i].suffix; + } + + state.output = token.output + open.output; + state.backtrack = true; + + push({ type: 'paren', extglob: true, value, output: '' }); + decrement('parens'); + return; + } + let output = token.close + (opts.capture ? ')' : ''); let rest; @@ -13271,10 +13620,6 @@ const parse = (input, options) => { const next = peek(); let output = value; - if (next === '<' && !utils.supportsLookbehinds()) { - throw new Error('Node.js v10 or higher is required for regex lookbehinds'); - } - if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) { output = `\\${value}`; } @@ -13421,6 +13766,15 @@ const parse = (input, options) => { consume('/**', 3); } + // A globstar followed only by balanced closing parens is at the logical end of patterns like + // `test(/utils/**)` and `test?(/utils/**)`. Treat it as EOS so the trailing `/**` can match its + // parent path, except in negated extglobs where that would change the exclusion semantics. + const isEnd = eos() || ( + state.parens > 0 + && rest === ')'.repeat(state.parens) + && !extglobs.some(extglob => extglob.type === 'negate') + ); + if (prior.type === 'bos' && eos()) { prev.type = 'globstar'; prev.value += value; @@ -13431,7 +13785,7 @@ const parse = (input, options) => { continue; } - if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) { + if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && isEnd) { state.output = state.output.slice(0, -(prior.output + prev.output).length); prior.output = `(?:${prior.output}`; @@ -13582,7 +13936,6 @@ parse.fastpaths = (input, options) => { } input = REPLACEMENTS[input] || input; - const win32 = utils.isWindows(options); // create constants based on platform, for windows or posix const { @@ -13595,7 +13948,7 @@ parse.fastpaths = (input, options) => { NO_DOTS_SLASH, STAR, START_ANCHOR - } = constants.globChars(win32); + } = constants.globChars(opts.windows); const nodot = opts.dot ? NO_DOTS : NO_DOT; const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT; @@ -13671,7 +14024,6 @@ module.exports = parse; "use strict"; -const path = __nccwpck_require__(1017); const scan = __nccwpck_require__(2429); const parse = __nccwpck_require__(2139); const utils = __nccwpck_require__(479); @@ -13692,6 +14044,18 @@ const isObject = val => val && typeof val === 'object' && !Array.isArray(val); * const isMatch = picomatch('*.!(*a)'); * console.log(isMatch('a.a')); //=> false * console.log(isMatch('a.b')); //=> true + * + * // For environments without `node.js`, `picomatch/posix` provides you a dependency-free matcher, without automatic OS detection. + * const picomatch = require('picomatch/posix'); + * // the same API, defaulting to posix paths + * const isMatch = picomatch('a/*'); + * console.log(isMatch('a\\b')); //=> false + * console.log(isMatch('a/b')); //=> true + * + * // you can still configure the matcher function to accept windows paths + * const isMatch = picomatch('a/*', { options: windows }); + * console.log(isMatch('a\\b')); //=> true + * console.log(isMatch('a/b')); //=> true * ``` * @name picomatch * @param {String|Array} `globs` One or more glob patterns. @@ -13720,7 +14084,7 @@ const picomatch = (glob, options, returnState = false) => { } const opts = options || {}; - const posix = utils.isWindows(options); + const posix = opts.windows; const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true); @@ -13829,9 +14193,9 @@ picomatch.test = (input, regex, options, { glob, posix } = {}) => { * @api public */ -picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => { +picomatch.matchBase = (input, glob, options, posix = options && options.windows) => { const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options); - return regex.test(path.basename(input)); + return regex.test(utils.basename(input, { windows: posix })); }; /** @@ -13905,6 +14269,14 @@ picomatch.scan = (input, options) => scan(input, options); * Compile a regular expression from the `state` object returned by the * [parse()](#parse) method. * + * ```js + * const picomatch = require('picomatch'); + * const state = picomatch.parse('*.js'); + * // picomatch.compileRe(state[, options]); + * + * console.log(picomatch.compileRe(state)); + * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ + * ``` * @param {Object} `state` * @param {Object} `options` * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser. @@ -13940,10 +14312,10 @@ picomatch.compileRe = (state, options, returnOutput = false, returnState = false * * ```js * const picomatch = require('picomatch'); - * const state = picomatch.parse('*.js'); - * // picomatch.compileRe(state[, options]); + * // picomatch.makeRe(state[, options]); * - * console.log(picomatch.compileRe(state)); + * const result = picomatch.makeRe('*.js'); + * console.log(result); * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ * ``` * @param {String} `state` The object returned from the `.parse` method. @@ -14071,7 +14443,7 @@ const scan = (input, options) => { const opts = options || {}; const length = input.length - 1; - const scanToEnd = opts.parts === true || opts.scanToEnd === true; + const scanToEnd = opts.parts === true || opts.tokens === true || opts.scanToEnd === true; const slashes = []; const tokens = []; const parts = []; @@ -14205,15 +14577,21 @@ const scan = (input, options) => { } if (scanToEnd === true) { + let parens = 0; + while (eos() !== true && (code = advance())) { if (code === CHAR_BACKWARD_SLASH) { backslashes = token.backslashes = true; - code = advance(); + advance(); continue; } - if (code === CHAR_RIGHT_PARENTHESES) { - isGlob = token.isGlob = true; + if (code === CHAR_LEFT_PARENTHESES) { + parens++; + continue; + } + + if (code === CHAR_RIGHT_PARENTHESES && --parens === 0) { finished = true; break; } @@ -14278,14 +14656,21 @@ const scan = (input, options) => { isGlob = token.isGlob = true; if (scanToEnd === true) { + let parens = 1; + while (eos() !== true && (code = advance())) { - if (code === CHAR_LEFT_PARENTHESES) { + if (code === CHAR_BACKWARD_SLASH) { backslashes = token.backslashes = true; - code = advance(); + advance(); continue; } - if (code === CHAR_RIGHT_PARENTHESES) { + if (code === CHAR_LEFT_PARENTHESES) { + parens++; + continue; + } + + if (code === CHAR_RIGHT_PARENTHESES && --parens === 0) { finished = true; break; } @@ -14372,7 +14757,7 @@ const scan = (input, options) => { let prevIndex; for (let idx = 0; idx < slashes.length; idx++) { - const n = prevIndex ? prevIndex + 1 : start; + const n = prevIndex !== undefined ? prevIndex + 1 : start; const i = slashes[idx]; const value = input.slice(n, i); if (opts.tokens) { @@ -14385,21 +14770,20 @@ const scan = (input, options) => { depth(tokens[idx]); state.maxDepth += tokens[idx].depth; } - if (idx !== 0 || value !== '') { + if (i >= start) { parts.push(value); + prevIndex = i; } - prevIndex = i; } - if (prevIndex && prevIndex + 1 < input.length) { - const value = input.slice(prevIndex + 1); - parts.push(value); + const n = prevIndex !== undefined ? prevIndex + 1 : start; + const value = input.slice(n); + parts.push(value); - if (opts.tokens) { - tokens[tokens.length - 1].value = value; - depth(tokens[tokens.length - 1]); - state.maxDepth += tokens[tokens.length - 1].depth; - } + if (opts.tokens && prevIndex && prevIndex + 1 < input.length) { + tokens[tokens.length - 1].value = value; + depth(tokens[tokens.length - 1]); + state.maxDepth += tokens[tokens.length - 1].depth; } state.slashes = slashes; @@ -14418,10 +14802,9 @@ module.exports = scan; /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; +/*global navigator*/ -const path = __nccwpck_require__(1017); -const win32 = process.platform === 'win32'; const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, @@ -14435,27 +14818,25 @@ exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str); exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1'); exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/'); +exports.isWindows = () => { + if (typeof navigator !== 'undefined' && navigator.platform) { + const platform = navigator.platform.toLowerCase(); + return platform === 'win32' || platform === 'windows'; + } + + if (typeof process !== 'undefined' && process.platform) { + return process.platform === 'win32'; + } + + return false; +}; + exports.removeBackslashes = str => { return str.replace(REGEX_REMOVE_BACKSLASH, match => { return match === '\\' ? '' : match; }); }; -exports.supportsLookbehinds = () => { - const segs = process.version.slice(1).split('.').map(Number); - if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) { - return true; - } - return false; -}; - -exports.isWindows = options => { - if (options && typeof options.windows === 'boolean') { - return options.windows; - } - return win32 === true || path.sep === '\\'; -}; - exports.escapeLast = (input, char, lastIdx) => { const idx = input.lastIndexOf(char, lastIdx); if (idx === -1) return input; @@ -14483,6 +14864,17 @@ exports.wrapOutput = (input, state = {}, options = {}) => { return output; }; +exports.basename = (path, { windows } = {}) => { + const segs = path.split(windows ? /[\\/]/ : '/'); + const last = segs[segs.length - 1]; + + if (last === '') { + return segs[segs.length - 2]; + } + + return last; +}; + /***/ }), diff --git a/package-lock.json b/package-lock.json index d26a673..f744dc1 100644 --- a/package-lock.json +++ b/package-lock.json @@ -12,14 +12,14 @@ "@actions/core": "^1.10.0", "@actions/exec": "^1.1.1", "@actions/github": "6.0.0", - "picomatch": "^2.3.1" + "picomatch": "^4.0.7" }, "devDependencies": { "@octokit/webhooks-types": "^7.3.1", "@types/jest": "^29.5.11", "@types/js-yaml": "^4.0.9", "@types/node": "^24.0.0", - "@types/picomatch": "^2.3.3", + "@types/picomatch": "^4.0.3", "@typescript-eslint/eslint-plugin": "^6.19.1", "@typescript-eslint/parser": "^6.19.1", "@vercel/ncc": "^0.38.1", @@ -199,7 +199,6 @@ "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.23.7.tgz", "integrity": "sha512-+UpDgowcmqe36d4NwqvKsyPMlOLNGMsfMmQ5WGCu+siCe3t3dfe9njrzGfdN4qq+bcNUt0+Vw6haRxBOycs4dw==", "dev": true, - "peer": true, "dependencies": { "@ampproject/remapping": "^2.2.0", "@babel/code-frame": "^7.23.5", @@ -1391,7 +1390,6 @@ "version": "5.1.0", "resolved": "https://registry.npmjs.org/@octokit/core/-/core-5.1.0.tgz", "integrity": "sha512-BDa2VAMLSh3otEiaMJ/3Y36GU4qf6GI+VivQ/P41NC6GHcdxpKlqV0ikSZ5gdQsmS3ojXeRx5vasgNTinF0Q4g==", - "peer": true, "dependencies": { "@octokit/auth-token": "^4.0.0", "@octokit/graphql": "^7.0.0", @@ -1653,10 +1651,11 @@ } }, "node_modules/@types/picomatch": { - "version": "2.3.3", - "resolved": "https://registry.npmjs.org/@types/picomatch/-/picomatch-2.3.3.tgz", - "integrity": "sha512-Yll76ZHikRFCyz/pffKGjrCwe/le2CDwOP5F210KQo27kpRE46U2rDnzikNlVn6/ezH3Mhn46bJMTfeVTtcYMg==", - "dev": true + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/@types/picomatch/-/picomatch-4.0.3.tgz", + "integrity": "sha512-iG0T6+nYJ9FAPmx9SsUlnwcq1ZVRuCXcVEvWnntoPlrOpwtSTKNDC9uVAxTsC3PUvJ+99n4RpAcNgBbHX3JSnQ==", + "dev": true, + "license": "MIT" }, "node_modules/@types/semver": { "version": "7.5.6", @@ -1895,7 +1894,6 @@ "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.3.tgz", "integrity": "sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==", "dev": true, - "peer": true, "bin": { "acorn": "bin/acorn" }, @@ -1992,6 +1990,19 @@ "node": ">= 8" } }, + "node_modules/anymatch/node_modules/picomatch": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz", + "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, "node_modules/argparse": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", @@ -2336,7 +2347,6 @@ "url": "https://github.com/sponsors/ai" } ], - "peer": true, "dependencies": { "caniuse-lite": "^1.0.30001565", "electron-to-chromium": "^1.4.601", @@ -2883,7 +2893,6 @@ "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.56.0.tgz", "integrity": "sha512-Go19xM6T9puCOWntie1/P997aXxFsOi37JIHRWI514Hc6ZnaHGKY9xFhrU65RT6CcBEzZoGG1e6Nq+DT04ZtZQ==", "dev": true, - "peer": true, "dependencies": { "@eslint-community/eslint-utils": "^4.2.0", "@eslint-community/regexpp": "^4.6.1", @@ -2939,7 +2948,6 @@ "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-9.1.0.tgz", "integrity": "sha512-NSWl5BFQWEPi1j4TjVNItzYV7dZXZ+wP6I6ZhrBGpChQhZRUaElihE9uRRkcbRnNb76UMKDF3r+WTmNcGPKsqw==", "dev": true, - "peer": true, "bin": { "eslint-config-prettier": "bin/cli.js" }, @@ -3114,7 +3122,6 @@ "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.2.4.tgz", "integrity": "sha512-FWu1oLHKCrtpO1ypU6J0SbK2d9Ckwysq6bHj/uaCP26DxrPpppCLQRGVuqAxSTvhF00AcvDRyYrLNW7ocBhFFQ==", "dev": true, - "peer": true, "bin": { "prettier": "bin/prettier.cjs" }, @@ -4622,7 +4629,6 @@ "resolved": "https://registry.npmjs.org/jest/-/jest-29.7.0.tgz", "integrity": "sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw==", "dev": true, - "peer": true, "dependencies": { "@jest/core": "^29.7.0", "@jest/types": "^29.6.3", @@ -5095,6 +5101,19 @@ "node": "^14.15.0 || ^16.10.0 || >=18.0.0" } }, + "node_modules/jest-util/node_modules/picomatch": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz", + "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, "node_modules/jest-validate": { "version": "29.7.0", "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-29.7.0.tgz", @@ -5436,6 +5455,19 @@ "node": ">=8.6" } }, + "node_modules/micromatch/node_modules/picomatch": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz", + "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, "node_modules/mimic-fn": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", @@ -5768,11 +5800,12 @@ "dev": true }, "node_modules/picomatch": { - "version": "2.3.1", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", - "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz", + "integrity": "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==", + "license": "MIT", "engines": { - "node": ">=8.6" + "node": ">=12" }, "funding": { "url": "https://github.com/sponsors/jonschlinkert" @@ -6798,7 +6831,6 @@ "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz", "integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==", "dev": true, - "peer": true, "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" diff --git a/package.json b/package.json index a50dd9b..16785b5 100644 --- a/package.json +++ b/package.json @@ -31,14 +31,14 @@ "@actions/core": "^1.10.0", "@actions/exec": "^1.1.1", "@actions/github": "6.0.0", - "picomatch": "^2.3.1" + "picomatch": "^4.0.7" }, "devDependencies": { "@octokit/webhooks-types": "^7.3.1", "@types/jest": "^29.5.11", "@types/js-yaml": "^4.0.9", "@types/node": "^24.0.0", - "@types/picomatch": "^2.3.3", + "@types/picomatch": "^4.0.3", "@typescript-eslint/eslint-plugin": "^6.19.1", "@typescript-eslint/parser": "^6.19.1", "@vercel/ncc": "^0.38.1",