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++;
+ }
+ 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;
+ parts.splice(gs, 1);
+ const other = parts.slice(0);
+ other[gs] = "**";
+ globParts.push(other);
+ gs--;
+ }
+ if (!this.preserveMultipleSlashes) {
+ for (let i2 = 1; i2 < parts.length - 1; i2++) {
+ const p = parts[i2];
+ if (i2 === 1 && p === "" && parts[0] === "")
+ continue;
+ if (p === "." || p === "") {
+ didSomething = true;
+ parts.splice(i2, 1);
+ i2--;
+ }
+ }
+ 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 i2 = 0; i2 < globParts.length - 1; i2++) {
+ for (let j = i2 + 1; j < globParts.length; j++) {
+ const matched = this.partsMatch(globParts[i2], globParts[j], !this.preserveMultipleSlashes);
+ if (matched) {
+ globParts[i2] = [];
+ globParts[j] = matched;
+ break;
+ }
+ }
+ }
+ return globParts.filter((gs) => gs.length);
+ }
+ partsMatch(a2, b, emptyGSMatch = false) {
+ let ai = 0;
+ let bi = 0;
+ let result = [];
+ let which = "";
+ while (ai < a2.length && bi < b.length) {
+ if (a2[ai] === b[bi]) {
+ result.push(which === "b" ? b[bi] : a2[ai]);
+ ai++;
+ bi++;
+ } else if (emptyGSMatch && a2[ai] === "**" && b[bi] === a2[ai + 1]) {
+ result.push(a2[ai]);
+ ai++;
+ } else if (emptyGSMatch && b[bi] === "**" && a2[ai] === b[bi + 1]) {
+ result.push(b[bi]);
+ bi++;
+ } else if (a2[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
+ if (which === "b")
+ return false;
+ which = "a";
+ result.push(a2[ai]);
+ ai++;
+ bi++;
+ } else if (b[bi] === "*" && a2[ai] && (this.options.dot || !a2[ai].startsWith(".")) && a2[ai] !== "**") {
+ if (which === "a")
+ return false;
+ which = "b";
+ result.push(b[bi]);
+ ai++;
+ bi++;
+ } else {
+ return false;
+ }
+ }
+ return a2.length === b.length && result;
+ }
+ parseNegate() {
+ if (this.nonegate)
+ return;
+ const pattern = this.pattern;
+ let negate = false;
+ let negateOffset = 0;
+ for (let i2 = 0; i2 < pattern.length && pattern.charAt(i2) === "!"; i2++) {
+ 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;
+ 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 : void 0;
+ const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
+ if (typeof fdi === "number" && typeof pdi === "number") {
+ const [fd, pd] = [
+ file[fdi],
+ pattern[pdi]
+ ];
+ if (fd.toLowerCase() === pd.toLowerCase()) {
+ pattern[pdi] = fd;
+ patternStartIndex = pdi;
+ fileStartIndex = fdi;
+ }
+ }
+ }
+ const { optimizationLevel = 1 } = this.options;
+ if (optimizationLevel >= 2) {
+ file = this.levelTwoFileOptimize(file);
+ }
+ if (pattern.includes(exports2.GLOBSTAR)) {
+ return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);
+ }
+ return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);
+ }
+ #matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
+ const firstgs = pattern.indexOf(exports2.GLOBSTAR, patternIndex);
+ const lastgs = pattern.lastIndexOf(exports2.GLOBSTAR);
+ 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)
+ ];
+ 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;
+ }
+ let fileTailMatch = 0;
+ if (tail.length) {
+ if (tail.length + fileIndex > file.length)
+ return false;
+ let tailStart = file.length - tail.length;
+ if (this.#matchOne(file, tail, partial, tailStart, 0)) {
+ fileTailMatch = tail.length;
+ } else {
+ 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;
+ }
+ }
+ if (!body.length) {
+ let sawSome = !!fileTailMatch;
+ for (let i3 = fileIndex; i3 < file.length - fileTailMatch; i3++) {
+ const f = String(file[i3]);
+ sawSome = true;
+ if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
+ return false;
+ }
+ }
+ return partial || sawSome;
+ }
+ const bodySegments = [[[], 0]];
+ let currentBody = bodySegments[0];
+ let nonGsParts = 0;
+ const nonGsPartsSums = [0];
+ for (const b of body) {
+ if (b === exports2.GLOBSTAR) {
+ nonGsPartsSums.push(nonGsParts);
+ currentBody = [[], 0];
+ bodySegments.push(currentBody);
+ } else {
+ currentBody[0].push(b);
+ nonGsParts++;
+ }
+ }
+ let i2 = bodySegments.length - 1;
+ const fileLength = file.length - fileTailMatch;
+ for (const b of bodySegments) {
+ b[1] = fileLength - (nonGsPartsSums[i2--] + 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, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
+ const bs = bodySegments[bodyIndex];
+ if (!bs) {
+ for (let i2 = fileIndex; i2 < file.length; i2++) {
+ sawTail = true;
+ const f = file[i2];
+ if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
+ return false;
+ }
+ }
+ return sawTail;
+ }
+ const [body, after] = bs;
+ while (fileIndex <= after) {
+ const m = this.#matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);
+ if (m && globStarDepth < this.maxGlobstarRecursion) {
+ 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++;
+ }
+ 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);
+ if (p === false || p === exports2.GLOBSTAR) {
+ return false;
+ }
+ 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;
+ }
+ if (fi === fl && pi === pl) {
+ return true;
+ } else if (fi === fl) {
+ return partial;
+ } else if (pi === pl) {
+ return fi === fl - 1 && file[fi] === "";
+ } else {
+ throw new Error("wtf?");
+ }
+ }
+ braceExpand() {
+ return (0, exports2.braceExpand)(this.pattern, this.options);
+ }
+ parse(pattern) {
+ (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
+ const options = this.options;
+ if (pattern === "**")
+ return exports2.GLOBSTAR;
+ if (pattern === "")
+ return "";
+ 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_js_1.AST.fromGlob(pattern, this.options).toMMPattern();
+ if (fastTest && typeof re === "object") {
+ Reflect.defineProperty(re, "test", { value: fastTest });
+ }
+ return re;
+ }
+ makeRe() {
+ if (this.regexp || this.regexp === false)
+ return this.regexp;
+ const set = this.set;
+ if (!set.length) {
+ this.regexp = false;
+ return this.regexp;
+ }
+ const options = this.options;
+ const twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
+ const flags = new Set(options.nocase ? ["i"] : []);
+ 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" ? regExpEscape(p) : p === exports2.GLOBSTAR ? exports2.GLOBSTAR : p._src;
+ });
+ pp.forEach((p, i2) => {
+ const next = pp[i2 + 1];
+ const prev = pp[i2 - 1];
+ if (p !== exports2.GLOBSTAR || prev === exports2.GLOBSTAR) {
+ return;
+ }
+ if (prev === void 0) {
+ if (next !== void 0 && next !== exports2.GLOBSTAR) {
+ pp[i2 + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
+ } else {
+ pp[i2] = twoStar;
+ }
+ } else if (next === void 0) {
+ pp[i2 - 1] = prev + "(?:\\/|\\/" + twoStar + ")?";
+ } else if (next !== exports2.GLOBSTAR) {
+ pp[i2 - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
+ pp[i2 + 1] = exports2.GLOBSTAR;
+ }
+ });
+ const filtered = pp.filter((p) => p !== exports2.GLOBSTAR);
+ if (this.partial && filtered.length >= 1) {
+ const prefixes = [];
+ for (let i2 = 1; i2 <= filtered.length; i2++) {
+ prefixes.push(filtered.slice(0, i2).join("/"));
+ }
+ return "(?:" + prefixes.join("|") + ")";
+ }
+ return filtered.join("/");
+ }).join("|");
+ const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
+ re = "^" + open + re + close + "$";
+ if (this.partial) {
+ re = "^(?:\\/|" + open + re.slice(1, -1) + close + ")$";
+ }
+ if (this.negate)
+ re = "^(?!" + re + ").+$";
+ try {
+ this.regexp = new RegExp(re, [...flags].join(""));
+ } catch {
+ this.regexp = false;
+ }
+ return this.regexp;
+ }
+ slashSplit(p) {
+ if (this.preserveMultipleSlashes) {
+ return p.split("/");
+ } else if (this.isWindows && /^\/\/[^/]+/.test(p)) {
+ return ["", ...p.split(/\/+/)];
+ } else {
+ return p.split(/\/+/);
+ }
+ }
+ match(f, partial = this.partial) {
+ this.debug("match", f, this.pattern);
+ if (this.comment) {
+ return false;
+ }
+ if (this.empty) {
+ return f === "";
+ }
+ if (f === "/" && partial) {
+ return true;
+ }
+ const options = this.options;
+ if (this.isWindows) {
+ f = f.split("\\").join("/");
+ }
+ const ff = this.slashSplit(f);
+ this.debug(this.pattern, "split", ff);
+ const set = this.set;
+ this.debug(this.pattern, "set", set);
+ let filename = ff[ff.length - 1];
+ if (!filename) {
+ for (let i2 = ff.length - 2; !filename && i2 >= 0; i2--) {
+ filename = ff[i2];
+ }
+ }
+ 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;
+ }
+ }
+ if (options.flipNegate) {
+ return false;
+ }
+ return this.negate;
+ }
+ static defaults(def) {
+ return exports2.minimatch.defaults(def).Minimatch;
+ }
+ };
+ exports2.Minimatch = Minimatch;
+ var ast_js_2 = require_ast();
+ Object.defineProperty(exports2, "AST", { enumerable: true, get: function() {
+ return ast_js_2.AST;
+ } });
+ var escape_js_2 = require_escape();
+ Object.defineProperty(exports2, "escape", { enumerable: true, get: function() {
+ return escape_js_2.escape;
+ } });
+ var unescape_js_2 = require_unescape();
+ Object.defineProperty(exports2, "unescape", { enumerable: true, get: function() {
+ return unescape_js_2.unescape;
+ } });
+ exports2.minimatch.AST = ast_js_1.AST;
+ exports2.minimatch.Minimatch = Minimatch;
+ exports2.minimatch.escape = escape_js_1.escape;
+ exports2.minimatch.unescape = unescape_js_1.unescape;
+ }
+});
+
+// node_modules/.pnpm/@actions+glob@0.5.1/node_modules/@actions/glob/lib/internal-path.js
+var require_internal_path = __commonJS({
+ "node_modules/.pnpm/@actions+glob@0.5.1/node_modules/@actions/glob/lib/internal-path.js"(exports2) {
+ "use strict";
+ var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o2, m, k, k2) {
+ if (k2 === void 0) k2 = k;
+ var desc = Object.getOwnPropertyDescriptor(m, k);
+ if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+ desc = { enumerable: true, get: function() {
+ return m[k];
+ } };
+ }
+ Object.defineProperty(o2, k2, desc);
+ } : function(o2, m, k, k2) {
+ if (k2 === void 0) k2 = k;
+ o2[k2] = m[k];
+ });
+ var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v) {
+ Object.defineProperty(o2, "default", { enumerable: true, value: v });
+ } : function(o2, v) {
+ o2["default"] = v;
+ });
+ var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
+ var ownKeys = function(o2) {
+ ownKeys = Object.getOwnPropertyNames || function(o3) {
+ var ar = [];
+ for (var k in o3) if (Object.prototype.hasOwnProperty.call(o3, k)) ar[ar.length] = k;
+ return ar;
+ };
+ return ownKeys(o2);
+ };
+ return function(mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) {
+ for (var k = ownKeys(mod), i2 = 0; i2 < k.length; i2++) if (k[i2] !== "default") __createBinding(result, mod, k[i2]);
+ }
+ __setModuleDefault(result, mod);
+ return result;
+ };
+ }();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.Path = void 0;
+ var path7 = __importStar(require("path"));
+ var pathHelper = __importStar(require_internal_path_helper());
+ var assert_1 = __importDefault(require("assert"));
+ var IS_WINDOWS = process.platform === "win32";
+ var Path = class {
+ /**
+ * Constructs a Path
+ * @param itemPath Path or array of segments
+ */
+ constructor(itemPath) {
+ this.segments = [];
+ if (typeof itemPath === "string") {
+ (0, assert_1.default)(itemPath, `Parameter 'itemPath' must not be empty`);
+ itemPath = pathHelper.safeTrimTrailingSeparator(itemPath);
+ if (!pathHelper.hasRoot(itemPath)) {
+ this.segments = itemPath.split(path7.sep);
+ } else {
+ let remaining = itemPath;
+ let dir = pathHelper.dirname(remaining);
+ while (dir !== remaining) {
+ const basename = path7.basename(remaining);
+ this.segments.unshift(basename);
+ remaining = dir;
+ dir = pathHelper.dirname(remaining);
+ }
+ this.segments.unshift(remaining);
+ }
+ } else {
+ (0, assert_1.default)(itemPath.length > 0, `Parameter 'itemPath' must not be an empty array`);
+ for (let i2 = 0; i2 < itemPath.length; i2++) {
+ let segment = itemPath[i2];
+ (0, assert_1.default)(segment, `Parameter 'itemPath' must not contain any empty segments`);
+ segment = pathHelper.normalizeSeparators(itemPath[i2]);
+ if (i2 === 0 && pathHelper.hasRoot(segment)) {
+ segment = pathHelper.safeTrimTrailingSeparator(segment);
+ (0, assert_1.default)(segment === pathHelper.dirname(segment), `Parameter 'itemPath' root segment contains information for multiple segments`);
+ this.segments.push(segment);
+ } else {
+ (0, assert_1.default)(!segment.includes(path7.sep), `Parameter 'itemPath' contains unexpected path separators`);
+ this.segments.push(segment);
+ }
+ }
+ }
+ }
+ /**
+ * Converts the path to it's string representation
+ */
+ toString() {
+ let result = this.segments[0];
+ let skipSlash = result.endsWith(path7.sep) || IS_WINDOWS && /^[A-Z]:$/i.test(result);
+ for (let i2 = 1; i2 < this.segments.length; i2++) {
+ if (skipSlash) {
+ skipSlash = false;
+ } else {
+ result += path7.sep;
+ }
+ result += this.segments[i2];
+ }
+ return result;
+ }
+ };
+ exports2.Path = Path;
+ }
+});
+
+// node_modules/.pnpm/@actions+glob@0.5.1/node_modules/@actions/glob/lib/internal-pattern.js
+var require_internal_pattern = __commonJS({
+ "node_modules/.pnpm/@actions+glob@0.5.1/node_modules/@actions/glob/lib/internal-pattern.js"(exports2) {
+ "use strict";
+ var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o2, m, k, k2) {
+ if (k2 === void 0) k2 = k;
+ var desc = Object.getOwnPropertyDescriptor(m, k);
+ if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+ desc = { enumerable: true, get: function() {
+ return m[k];
+ } };
+ }
+ Object.defineProperty(o2, k2, desc);
+ } : function(o2, m, k, k2) {
+ if (k2 === void 0) k2 = k;
+ o2[k2] = m[k];
+ });
+ var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v) {
+ Object.defineProperty(o2, "default", { enumerable: true, value: v });
+ } : function(o2, v) {
+ o2["default"] = v;
+ });
+ var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
+ var ownKeys = function(o2) {
+ ownKeys = Object.getOwnPropertyNames || function(o3) {
+ var ar = [];
+ for (var k in o3) if (Object.prototype.hasOwnProperty.call(o3, k)) ar[ar.length] = k;
+ return ar;
+ };
+ return ownKeys(o2);
+ };
+ return function(mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) {
+ for (var k = ownKeys(mod), i2 = 0; i2 < k.length; i2++) if (k[i2] !== "default") __createBinding(result, mod, k[i2]);
+ }
+ __setModuleDefault(result, mod);
+ return result;
+ };
+ }();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.Pattern = void 0;
+ var os = __importStar(require("os"));
+ var path7 = __importStar(require("path"));
+ var pathHelper = __importStar(require_internal_path_helper());
+ var assert_1 = __importDefault(require("assert"));
+ var minimatch_1 = require_commonjs3();
+ var internal_match_kind_1 = require_internal_match_kind();
+ var internal_path_1 = require_internal_path();
+ var IS_WINDOWS = process.platform === "win32";
+ var Pattern = class _Pattern {
+ constructor(patternOrNegate, isImplicitPattern = false, segments, homedir) {
+ this.negate = false;
+ let pattern;
+ if (typeof patternOrNegate === "string") {
+ pattern = patternOrNegate.trim();
+ } else {
+ segments = segments || [];
+ (0, assert_1.default)(segments.length, `Parameter 'segments' must not empty`);
+ const root = _Pattern.getLiteral(segments[0]);
+ (0, assert_1.default)(root && pathHelper.hasAbsoluteRoot(root), `Parameter 'segments' first element must be a root path`);
+ pattern = new internal_path_1.Path(segments).toString().trim();
+ if (patternOrNegate) {
+ pattern = `!${pattern}`;
+ }
+ }
+ while (pattern.startsWith("!")) {
+ this.negate = !this.negate;
+ pattern = pattern.substr(1).trim();
+ }
+ pattern = _Pattern.fixupPattern(pattern, homedir);
+ this.segments = new internal_path_1.Path(pattern).segments;
+ this.trailingSeparator = pathHelper.normalizeSeparators(pattern).endsWith(path7.sep);
+ pattern = pathHelper.safeTrimTrailingSeparator(pattern);
+ let foundGlob = false;
+ const searchSegments = this.segments.map((x) => _Pattern.getLiteral(x)).filter((x) => !foundGlob && !(foundGlob = x === ""));
+ this.searchPath = new internal_path_1.Path(searchSegments).toString();
+ this.rootRegExp = new RegExp(_Pattern.regExpEscape(searchSegments[0]), IS_WINDOWS ? "i" : "");
+ this.isImplicitPattern = isImplicitPattern;
+ const minimatchOptions = {
+ dot: true,
+ nobrace: true,
+ nocase: IS_WINDOWS,
+ nocomment: true,
+ noext: true,
+ nonegate: true
+ };
+ pattern = IS_WINDOWS ? pattern.replace(/\\/g, "/") : pattern;
+ this.minimatch = new minimatch_1.Minimatch(pattern, minimatchOptions);
+ }
+ /**
+ * Matches the pattern against the specified path
+ */
+ match(itemPath) {
+ if (this.segments[this.segments.length - 1] === "**") {
+ itemPath = pathHelper.normalizeSeparators(itemPath);
+ if (!itemPath.endsWith(path7.sep) && this.isImplicitPattern === false) {
+ itemPath = `${itemPath}${path7.sep}`;
+ }
+ } else {
+ itemPath = pathHelper.safeTrimTrailingSeparator(itemPath);
+ }
+ if (this.minimatch.match(itemPath)) {
+ return this.trailingSeparator ? internal_match_kind_1.MatchKind.Directory : internal_match_kind_1.MatchKind.All;
+ }
+ return internal_match_kind_1.MatchKind.None;
+ }
+ /**
+ * Indicates whether the pattern may match descendants of the specified path
+ */
+ partialMatch(itemPath) {
+ itemPath = pathHelper.safeTrimTrailingSeparator(itemPath);
+ if (pathHelper.dirname(itemPath) === itemPath) {
+ return this.rootRegExp.test(itemPath);
+ }
+ return this.minimatch.matchOne(itemPath.split(IS_WINDOWS ? /\\+/ : /\/+/), this.minimatch.set[0], true);
+ }
+ /**
+ * Escapes glob patterns within a path
+ */
+ static globEscape(s) {
+ return (IS_WINDOWS ? s : s.replace(/\\/g, "\\\\")).replace(/(\[)(?=[^/]+\])/g, "[[]").replace(/\?/g, "[?]").replace(/\*/g, "[*]");
+ }
+ /**
+ * Normalizes slashes and ensures absolute root
+ */
+ static fixupPattern(pattern, homedir) {
+ (0, assert_1.default)(pattern, "pattern cannot be empty");
+ const literalSegments = new internal_path_1.Path(pattern).segments.map((x) => _Pattern.getLiteral(x));
+ (0, assert_1.default)(literalSegments.every((x, i2) => (x !== "." || i2 === 0) && x !== ".."), `Invalid pattern '${pattern}'. Relative pathing '.' and '..' is not allowed.`);
+ (0, assert_1.default)(!pathHelper.hasRoot(pattern) || literalSegments[0], `Invalid pattern '${pattern}'. Root segment must not contain globs.`);
+ pattern = pathHelper.normalizeSeparators(pattern);
+ if (pattern === "." || pattern.startsWith(`.${path7.sep}`)) {
+ pattern = _Pattern.globEscape(process.cwd()) + pattern.substr(1);
+ } else if (pattern === "~" || pattern.startsWith(`~${path7.sep}`)) {
+ homedir = homedir || os.homedir();
+ (0, assert_1.default)(homedir, "Unable to determine HOME directory");
+ (0, assert_1.default)(pathHelper.hasAbsoluteRoot(homedir), `Expected HOME directory to be a rooted path. Actual '${homedir}'`);
+ pattern = _Pattern.globEscape(homedir) + pattern.substr(1);
+ } else if (IS_WINDOWS && (pattern.match(/^[A-Z]:$/i) || pattern.match(/^[A-Z]:[^\\]/i))) {
+ let root = pathHelper.ensureAbsoluteRoot("C:\\dummy-root", pattern.substr(0, 2));
+ if (pattern.length > 2 && !root.endsWith("\\")) {
+ root += "\\";
+ }
+ pattern = _Pattern.globEscape(root) + pattern.substr(2);
+ } else if (IS_WINDOWS && (pattern === "\\" || pattern.match(/^\\[^\\]/))) {
+ let root = pathHelper.ensureAbsoluteRoot("C:\\dummy-root", "\\");
+ if (!root.endsWith("\\")) {
+ root += "\\";
+ }
+ pattern = _Pattern.globEscape(root) + pattern.substr(1);
+ } else {
+ pattern = pathHelper.ensureAbsoluteRoot(_Pattern.globEscape(process.cwd()), pattern);
+ }
+ return pathHelper.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 i2 = 0; i2 < segment.length; i2++) {
+ const c3 = segment[i2];
+ if (c3 === "\\" && !IS_WINDOWS && i2 + 1 < segment.length) {
+ literal += segment[++i2];
+ continue;
+ } else if (c3 === "*" || c3 === "?") {
+ return "";
+ } else if (c3 === "[" && i2 + 1 < segment.length) {
+ let set = "";
+ let closed = -1;
+ for (let i22 = i2 + 1; i22 < segment.length; i22++) {
+ const c22 = segment[i22];
+ if (c22 === "\\" && !IS_WINDOWS && i22 + 1 < segment.length) {
+ set += segment[++i22];
+ continue;
+ } else if (c22 === "]") {
+ closed = i22;
+ break;
+ } else {
+ set += c22;
+ }
+ }
+ if (closed >= 0) {
+ if (set.length > 1) {
+ return "";
+ }
+ if (set) {
+ literal += set;
+ i2 = closed;
+ continue;
+ }
+ }
+ }
+ literal += c3;
+ }
+ return literal;
+ }
+ /**
+ * Escapes regexp special characters
+ * https://javascript.info/regexp-escaping
+ */
+ static regExpEscape(s) {
+ return s.replace(/[[\\^$.|?*+()]/g, "\\$&");
+ }
+ };
+ exports2.Pattern = Pattern;
+ }
+});
+
+// node_modules/.pnpm/@actions+glob@0.5.1/node_modules/@actions/glob/lib/internal-search-state.js
+var require_internal_search_state = __commonJS({
+ "node_modules/.pnpm/@actions+glob@0.5.1/node_modules/@actions/glob/lib/internal-search-state.js"(exports2) {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.SearchState = void 0;
+ var SearchState = class {
+ constructor(path7, level) {
+ this.path = path7;
+ this.level = level;
+ }
+ };
+ exports2.SearchState = SearchState;
+ }
+});
+
+// node_modules/.pnpm/@actions+glob@0.5.1/node_modules/@actions/glob/lib/internal-globber.js
+var require_internal_globber = __commonJS({
+ "node_modules/.pnpm/@actions+glob@0.5.1/node_modules/@actions/glob/lib/internal-globber.js"(exports2) {
+ "use strict";
+ var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o2, m, k, k2) {
+ if (k2 === void 0) k2 = k;
+ var desc = Object.getOwnPropertyDescriptor(m, k);
+ if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+ desc = { enumerable: true, get: function() {
+ return m[k];
+ } };
+ }
+ Object.defineProperty(o2, k2, desc);
+ } : function(o2, m, k, k2) {
+ if (k2 === void 0) k2 = k;
+ o2[k2] = m[k];
+ });
+ var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v) {
+ Object.defineProperty(o2, "default", { enumerable: true, value: v });
+ } : function(o2, v) {
+ o2["default"] = v;
+ });
+ var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
+ var ownKeys = function(o2) {
+ ownKeys = Object.getOwnPropertyNames || function(o3) {
+ var ar = [];
+ for (var k in o3) if (Object.prototype.hasOwnProperty.call(o3, k)) ar[ar.length] = k;
+ return ar;
+ };
+ return ownKeys(o2);
+ };
+ return function(mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) {
+ for (var k = ownKeys(mod), i2 = 0; i2 < k.length; i2++) if (k[i2] !== "default") __createBinding(result, mod, k[i2]);
+ }
+ __setModuleDefault(result, mod);
+ return result;
+ };
+ }();
+ var __awaiter = exports2 && exports2.__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 __asyncValues = exports2 && exports2.__asyncValues || function(o2) {
+ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+ var m = o2[Symbol.asyncIterator], i2;
+ return m ? m.call(o2) : (o2 = typeof __values === "function" ? __values(o2) : o2[Symbol.iterator](), i2 = {}, verb("next"), verb("throw"), verb("return"), i2[Symbol.asyncIterator] = function() {
+ return this;
+ }, i2);
+ function verb(n2) {
+ i2[n2] = o2[n2] && function(v) {
+ return new Promise(function(resolve, reject) {
+ v = o2[n2](v), settle(resolve, reject, v.done, v.value);
+ });
+ };
+ }
+ function settle(resolve, reject, d, v) {
+ Promise.resolve(v).then(function(v2) {
+ resolve({ value: v2, done: d });
+ }, reject);
+ }
+ };
+ var __await = exports2 && exports2.__await || function(v) {
+ return this instanceof __await ? (this.v = v, this) : new __await(v);
+ };
+ var __asyncGenerator = exports2 && exports2.__asyncGenerator || function(thisArg, _arguments, generator) {
+ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+ var g = generator.apply(thisArg, _arguments || []), i2, q = [];
+ return i2 = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i2[Symbol.asyncIterator] = function() {
+ return this;
+ }, i2;
+ function awaitReturn(f) {
+ return function(v) {
+ return Promise.resolve(v).then(f, reject);
+ };
+ }
+ function verb(n2, f) {
+ if (g[n2]) {
+ i2[n2] = function(v) {
+ return new Promise(function(a2, b) {
+ q.push([n2, v, a2, b]) > 1 || resume(n2, v);
+ });
+ };
+ if (f) i2[n2] = f(i2[n2]);
+ }
+ }
+ function resume(n2, v) {
+ try {
+ step(g[n2](v));
+ } catch (e) {
+ settle(q[0][3], e);
+ }
+ }
+ function step(r) {
+ r.value instanceof __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]);
+ }
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.DefaultGlobber = void 0;
+ var core6 = __importStar(require_core());
+ var fs = __importStar(require("fs"));
+ var globOptionsHelper = __importStar(require_internal_glob_options_helper());
+ var path7 = __importStar(require("path"));
+ var patternHelper = __importStar(require_internal_pattern_helper());
+ var internal_match_kind_1 = require_internal_match_kind();
+ var internal_pattern_1 = require_internal_pattern();
+ var internal_search_state_1 = require_internal_search_state();
+ var IS_WINDOWS = process.platform === "win32";
+ var DefaultGlobber = class _DefaultGlobber {
+ constructor(options) {
+ this.patterns = [];
+ this.searchPaths = [];
+ this.options = globOptionsHelper.getOptions(options);
+ }
+ getSearchPaths() {
+ return this.searchPaths.slice();
+ }
+ glob() {
+ return __awaiter(this, void 0, void 0, function* () {
+ var _a, e_1, _b, _c;
+ const result = [];
+ try {
+ for (var _d = true, _e = __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 __asyncGenerator(this, arguments, function* globGenerator_1() {
+ const options = globOptionsHelper.getOptions(this.options);
+ 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 internal_pattern_1.Pattern(pattern.negate, true, pattern.segments.concat("**")));
+ }
+ }
+ const stack = [];
+ for (const searchPath of patternHelper.getSearchPaths(patterns)) {
+ core6.debug(`Search path '${searchPath}'`);
+ try {
+ yield __await(fs.promises.lstat(searchPath));
+ } catch (err) {
+ if (err.code === "ENOENT") {
+ continue;
+ }
+ throw err;
+ }
+ stack.unshift(new internal_search_state_1.SearchState(searchPath, 1));
+ }
+ const traversalChain = [];
+ while (stack.length) {
+ const item = stack.pop();
+ const match = patternHelper.match(patterns, item.path);
+ const partialMatch = !!match || patternHelper.partialMatch(patterns, item.path);
+ if (!match && !partialMatch) {
+ continue;
+ }
+ const stats = yield __await(
+ _DefaultGlobber.stat(item, options, traversalChain)
+ // Broken symlink, or symlink cycle detected, or no longer exists
+ );
+ if (!stats) {
+ continue;
+ }
+ if (options.excludeHiddenFiles && path7.basename(item.path).match(/^\./)) {
+ continue;
+ }
+ if (stats.isDirectory()) {
+ if (match & internal_match_kind_1.MatchKind.Directory && options.matchDirectories) {
+ yield yield __await(item.path);
+ } else if (!partialMatch) {
+ continue;
+ }
+ const childLevel = item.level + 1;
+ const childItems = (yield __await(fs.promises.readdir(item.path))).map((x) => new internal_search_state_1.SearchState(path7.join(item.path, x), childLevel));
+ stack.push(...childItems.reverse());
+ } else if (match & internal_match_kind_1.MatchKind.File) {
+ yield yield __await(item.path);
+ }
+ }
+ });
+ }
+ /**
+ * Constructs a DefaultGlobber
+ */
+ static create(patterns, options) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const result = new _DefaultGlobber(options);
+ if (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) {
+ if (!line || line.startsWith("#")) {
+ continue;
+ } else {
+ result.patterns.push(new internal_pattern_1.Pattern(line));
+ }
+ }
+ result.searchPaths.push(...patternHelper.getSearchPaths(result.patterns));
+ return result;
+ });
+ }
+ static stat(item, options, traversalChain) {
+ return __awaiter(this, void 0, void 0, function* () {
+ let stats;
+ if (options.followSymbolicLinks) {
+ try {
+ stats = yield fs.promises.stat(item.path);
+ } catch (err) {
+ if (err.code === "ENOENT") {
+ if (options.omitBrokenSymbolicLinks) {
+ core6.debug(`Broken symlink '${item.path}'`);
+ return void 0;
+ }
+ throw new Error(`No information found for the path '${item.path}'. This may indicate a broken symbolic link.`);
+ }
+ throw err;
+ }
+ } else {
+ stats = yield fs.promises.lstat(item.path);
+ }
+ if (stats.isDirectory() && options.followSymbolicLinks) {
+ const realPath = yield fs.promises.realpath(item.path);
+ while (traversalChain.length >= item.level) {
+ traversalChain.pop();
+ }
+ if (traversalChain.some((x) => x === realPath)) {
+ core6.debug(`Symlink cycle detected for path '${item.path}' and realpath '${realPath}'`);
+ return void 0;
+ }
+ traversalChain.push(realPath);
+ }
+ return stats;
+ });
+ }
+ };
+ exports2.DefaultGlobber = DefaultGlobber;
+ }
+});
+
+// node_modules/.pnpm/@actions+glob@0.5.1/node_modules/@actions/glob/lib/internal-hash-files.js
+var require_internal_hash_files = __commonJS({
+ "node_modules/.pnpm/@actions+glob@0.5.1/node_modules/@actions/glob/lib/internal-hash-files.js"(exports2) {
+ "use strict";
+ var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o2, m, k, k2) {
+ if (k2 === void 0) k2 = k;
+ var desc = Object.getOwnPropertyDescriptor(m, k);
+ if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+ desc = { enumerable: true, get: function() {
+ return m[k];
+ } };
+ }
+ Object.defineProperty(o2, k2, desc);
+ } : function(o2, m, k, k2) {
+ if (k2 === void 0) k2 = k;
+ o2[k2] = m[k];
+ });
+ var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v) {
+ Object.defineProperty(o2, "default", { enumerable: true, value: v });
+ } : function(o2, v) {
+ o2["default"] = v;
+ });
+ var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
+ var ownKeys = function(o2) {
+ ownKeys = Object.getOwnPropertyNames || function(o3) {
+ var ar = [];
+ for (var k in o3) if (Object.prototype.hasOwnProperty.call(o3, k)) ar[ar.length] = k;
+ return ar;
+ };
+ return ownKeys(o2);
+ };
+ return function(mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) {
+ for (var k = ownKeys(mod), i2 = 0; i2 < k.length; i2++) if (k[i2] !== "default") __createBinding(result, mod, k[i2]);
+ }
+ __setModuleDefault(result, mod);
+ return result;
+ };
+ }();
+ var __awaiter = exports2 && exports2.__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 __asyncValues = exports2 && exports2.__asyncValues || function(o2) {
+ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+ var m = o2[Symbol.asyncIterator], i2;
+ return m ? m.call(o2) : (o2 = typeof __values === "function" ? __values(o2) : o2[Symbol.iterator](), i2 = {}, verb("next"), verb("throw"), verb("return"), i2[Symbol.asyncIterator] = function() {
+ return this;
+ }, i2);
+ function verb(n2) {
+ i2[n2] = o2[n2] && function(v) {
+ return new Promise(function(resolve, reject) {
+ v = o2[n2](v), settle(resolve, reject, v.done, v.value);
+ });
+ };
+ }
+ function settle(resolve, reject, d, v) {
+ Promise.resolve(v).then(function(v2) {
+ resolve({ value: v2, done: d });
+ }, reject);
+ }
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.hashFiles = hashFiles;
+ var crypto = __importStar(require("crypto"));
+ var core6 = __importStar(require_core());
+ var fs = __importStar(require("fs"));
+ var stream = __importStar(require("stream"));
+ var util = __importStar(require("util"));
+ var path7 = __importStar(require("path"));
+ function hashFiles(globber_1, currentWorkspace_1) {
+ return __awaiter(this, arguments, void 0, function* (globber, currentWorkspace, verbose = false) {
+ var _a, e_1, _b, _c;
+ var _d;
+ const writeDelegate = verbose ? core6.info : core6.debug;
+ let hasMatch = false;
+ const githubWorkspace = currentWorkspace ? currentWorkspace : (_d = process.env["GITHUB_WORKSPACE"]) !== null && _d !== void 0 ? _d : process.cwd();
+ const result = crypto.createHash("sha256");
+ let count2 = 0;
+ try {
+ for (var _e = true, _f = __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}${path7.sep}`)) {
+ writeDelegate(`Ignore '${file}' since it is not under GITHUB_WORKSPACE.`);
+ continue;
+ }
+ if (fs.statSync(file).isDirectory()) {
+ writeDelegate(`Skip directory '${file}'.`);
+ continue;
+ }
+ const hash = crypto.createHash("sha256");
+ const pipeline = util.promisify(stream.pipeline);
+ yield pipeline(fs.createReadStream(file), hash);
+ result.write(hash.digest());
+ count2++;
+ 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 ${count2} files to hash.`);
+ return result.digest("hex");
+ } else {
+ writeDelegate(`No matches found for glob`);
+ return "";
+ }
+ });
+ }
+ }
+});
+
+// node_modules/.pnpm/@actions+glob@0.5.1/node_modules/@actions/glob/lib/glob.js
+var require_glob = __commonJS({
+ "node_modules/.pnpm/@actions+glob@0.5.1/node_modules/@actions/glob/lib/glob.js"(exports2) {
+ "use strict";
+ var __awaiter = exports2 && exports2.__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());
+ });
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.create = create2;
+ exports2.hashFiles = hashFiles;
+ var internal_globber_1 = require_internal_globber();
+ var internal_hash_files_1 = require_internal_hash_files();
+ function create2(patterns, options) {
+ return __awaiter(this, void 0, void 0, function* () {
+ return yield internal_globber_1.DefaultGlobber.create(patterns, options);
+ });
+ }
+ function hashFiles(patterns_1) {
+ return __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 create2(patterns, { followSymbolicLinks });
+ return (0, internal_hash_files_1.hashFiles)(globber, currentWorkspace, verbose);
+ });
+ }
+ }
+});
+
+// node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js
+var require_utils6 = __commonJS({
+ "node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js"(exports2) {
+ "use strict";
+ exports2.isInteger = (num) => {
+ if (typeof num === "number") {
+ return Number.isInteger(num);
+ }
+ if (typeof num === "string" && num.trim() !== "") {
+ return Number.isInteger(Number(num));
+ }
+ return false;
+ };
+ exports2.find = (node, type) => node.nodes.find((node2) => node2.type === type);
+ exports2.exceedsLimit = (min, max, step = 1, limit) => {
+ if (limit === false) return false;
+ if (!exports2.isInteger(min) || !exports2.isInteger(max)) return false;
+ return (Number(max) - Number(min)) / Number(step) >= limit;
+ };
+ exports2.escapeNode = (block, n2 = 0, type) => {
+ const node = block.nodes[n2];
+ if (!node) return;
+ if (type && node.type === type || node.type === "open" || node.type === "close") {
+ if (node.escaped !== true) {
+ node.value = "\\" + node.value;
+ node.escaped = true;
+ }
+ }
+ };
+ exports2.encloseBrace = (node) => {
+ if (node.type !== "brace") return false;
+ if (node.commas >> 0 + node.ranges >> 0 === 0) {
+ node.invalid = true;
+ return true;
+ }
+ return false;
+ };
+ exports2.isInvalidBrace = (block) => {
+ if (block.type !== "brace") return false;
+ if (block.invalid === true || block.dollar) return true;
+ if (block.commas >> 0 + block.ranges >> 0 === 0) {
+ block.invalid = true;
+ return true;
+ }
+ if (block.open !== true || block.close !== true) {
+ block.invalid = true;
+ return true;
+ }
+ return false;
+ };
+ exports2.isOpenOrClose = (node) => {
+ if (node.type === "open" || node.type === "close") {
+ return true;
+ }
+ return node.open === true || node.close === true;
+ };
+ exports2.reduce = (nodes) => nodes.reduce((acc, node) => {
+ if (node.type === "text") acc.push(node.value);
+ if (node.type === "range") node.type = "text";
+ return acc;
+ }, []);
+ exports2.flatten = (...args) => {
+ const result = [];
+ const flat = (arr) => {
+ for (let i2 = 0; i2 < arr.length; i2++) {
+ const ele = arr[i2];
+ if (Array.isArray(ele)) {
+ flat(ele);
+ continue;
+ }
+ if (ele !== void 0) {
+ result.push(ele);
+ }
+ }
+ return result;
+ };
+ flat(args);
+ return result;
+ };
+ }
+});
+
+// node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js
+var require_stringify = __commonJS({
+ "node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js"(exports2, module2) {
+ "use strict";
+ var utils = require_utils6();
+ module2.exports = (ast, options = {}) => {
+ const stringify = (node, parent = {}) => {
+ const invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
+ const invalidNode = node.invalid === true && options.escapeInvalid === true;
+ let output = "";
+ if (node.value) {
+ if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {
+ return "\\" + node.value;
+ }
+ return node.value;
+ }
+ if (node.value) {
+ return node.value;
+ }
+ if (node.nodes) {
+ for (const child of node.nodes) {
+ output += stringify(child);
+ }
+ }
+ return output;
+ };
+ return stringify(ast);
+ };
+ }
+});
+
+// node_modules/.pnpm/is-number@7.0.0/node_modules/is-number/index.js
+var require_is_number = __commonJS({
+ "node_modules/.pnpm/is-number@7.0.0/node_modules/is-number/index.js"(exports2, module2) {
+ "use strict";
+ module2.exports = function(num) {
+ if (typeof num === "number") {
+ return num - num === 0;
+ }
+ if (typeof num === "string" && num.trim() !== "") {
+ return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
+ }
+ return false;
+ };
+ }
+});
+
+// node_modules/.pnpm/to-regex-range@5.0.1/node_modules/to-regex-range/index.js
+var require_to_regex_range = __commonJS({
+ "node_modules/.pnpm/to-regex-range@5.0.1/node_modules/to-regex-range/index.js"(exports2, module2) {
+ "use strict";
+ var isNumber = require_is_number();
+ var toRegexRange = (min, max, options) => {
+ if (isNumber(min) === false) {
+ throw new TypeError("toRegexRange: expected the first argument to be a number");
+ }
+ if (max === void 0 || min === max) {
+ return String(min);
+ }
+ if (isNumber(max) === false) {
+ throw new TypeError("toRegexRange: expected the second argument to be a number.");
+ }
+ let opts = { relaxZeros: true, ...options };
+ if (typeof opts.strictZeros === "boolean") {
+ opts.relaxZeros = opts.strictZeros === false;
+ }
+ let relax = String(opts.relaxZeros);
+ let shorthand = String(opts.shorthand);
+ let capture = String(opts.capture);
+ let wrap = String(opts.wrap);
+ let cacheKey = min + ":" + max + "=" + relax + shorthand + capture + wrap;
+ if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
+ return toRegexRange.cache[cacheKey].result;
+ }
+ let a2 = Math.min(min, max);
+ let b = Math.max(min, max);
+ if (Math.abs(a2 - b) === 1) {
+ let result = min + "|" + max;
+ if (opts.capture) {
+ return `(${result})`;
+ }
+ if (opts.wrap === false) {
+ return result;
+ }
+ return `(?:${result})`;
+ }
+ let isPadded = hasPadding(min) || hasPadding(max);
+ let state = { min, max, a: a2, b };
+ let positives = [];
+ let negatives = [];
+ if (isPadded) {
+ state.isPadded = isPadded;
+ state.maxLen = String(state.max).length;
+ }
+ if (a2 < 0) {
+ let newMin = b < 0 ? Math.abs(b) : 1;
+ negatives = splitToPatterns(newMin, Math.abs(a2), state, opts);
+ a2 = state.a = 0;
+ }
+ if (b >= 0) {
+ positives = splitToPatterns(a2, b, state, opts);
+ }
+ state.negatives = negatives;
+ state.positives = positives;
+ state.result = collatePatterns(negatives, positives, opts);
+ if (opts.capture === true) {
+ state.result = `(${state.result})`;
+ } else if (opts.wrap !== false && positives.length + negatives.length > 1) {
+ state.result = `(?:${state.result})`;
+ }
+ toRegexRange.cache[cacheKey] = state;
+ return state.result;
+ };
+ function collatePatterns(neg, pos, options) {
+ let onlyNegative = filterPatterns(neg, pos, "-", false, options) || [];
+ let onlyPositive = filterPatterns(pos, neg, "", false, options) || [];
+ let intersected = filterPatterns(neg, pos, "-?", true, options) || [];
+ let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
+ return subpatterns.join("|");
+ }
+ function splitToRanges(min, max) {
+ let nines = 1;
+ let zeros = 1;
+ let stop = countNines(min, nines);
+ let stops = /* @__PURE__ */ new Set([max]);
+ while (min <= stop && stop <= max) {
+ stops.add(stop);
+ nines += 1;
+ stop = countNines(min, nines);
+ }
+ stop = countZeros(max + 1, zeros) - 1;
+ while (min < stop && stop <= max) {
+ stops.add(stop);
+ zeros += 1;
+ stop = countZeros(max + 1, zeros) - 1;
+ }
+ stops = [...stops];
+ stops.sort(compare);
+ return stops;
+ }
+ function rangeToPattern(start, stop, options) {
+ if (start === stop) {
+ return { pattern: start, count: [], digits: 0 };
+ }
+ let zipped = zip(start, stop);
+ let digits = zipped.length;
+ let pattern = "";
+ let count2 = 0;
+ for (let i2 = 0; i2 < digits; i2++) {
+ let [startDigit, stopDigit] = zipped[i2];
+ if (startDigit === stopDigit) {
+ pattern += startDigit;
+ } else if (startDigit !== "0" || stopDigit !== "9") {
+ pattern += toCharacterClass(startDigit, stopDigit, options);
+ } else {
+ count2++;
+ }
+ }
+ if (count2) {
+ pattern += options.shorthand === true ? "\\d" : "[0-9]";
+ }
+ return { pattern, count: [count2], digits };
+ }
+ function splitToPatterns(min, max, tok, options) {
+ let ranges = splitToRanges(min, max);
+ let tokens = [];
+ let start = min;
+ let prev;
+ for (let i2 = 0; i2 < ranges.length; i2++) {
+ let max2 = ranges[i2];
+ let obj = rangeToPattern(String(start), String(max2), options);
+ let zeros = "";
+ if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+ if (prev.count.length > 1) {
+ prev.count.pop();
+ }
+ prev.count.push(obj.count[0]);
+ prev.string = prev.pattern + toQuantifier(prev.count);
+ start = max2 + 1;
+ continue;
+ }
+ if (tok.isPadded) {
+ zeros = padZeros(max2, tok, options);
+ }
+ obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+ tokens.push(obj);
+ start = max2 + 1;
+ prev = obj;
+ }
+ return tokens;
+ }
+ function filterPatterns(arr, comparison, prefix, intersection, options) {
+ let result = [];
+ for (let ele of arr) {
+ let { string } = ele;
+ if (!intersection && !contains(comparison, "string", string)) {
+ result.push(prefix + string);
+ }
+ if (intersection && contains(comparison, "string", string)) {
+ result.push(prefix + string);
+ }
+ }
+ return result;
+ }
+ function zip(a2, b) {
+ let arr = [];
+ for (let i2 = 0; i2 < a2.length; i2++) arr.push([a2[i2], b[i2]]);
+ return arr;
+ }
+ function compare(a2, b) {
+ return a2 > b ? 1 : b > a2 ? -1 : 0;
+ }
+ function contains(arr, key, val) {
+ return arr.some((ele) => ele[key] === val);
+ }
+ function countNines(min, len) {
+ return Number(String(min).slice(0, -len) + "9".repeat(len));
+ }
+ function countZeros(integer, zeros) {
+ return integer - integer % Math.pow(10, zeros);
+ }
+ function toQuantifier(digits) {
+ let [start = 0, stop = ""] = digits;
+ if (stop || start > 1) {
+ return `{${start + (stop ? "," + stop : "")}}`;
+ }
+ return "";
+ }
+ function toCharacterClass(a2, b, options) {
+ return `[${a2}${b - a2 === 1 ? "" : "-"}${b}]`;
+ }
+ function hasPadding(str) {
+ return /^-?(0+)\d/.test(str);
+ }
+ function padZeros(value, tok, options) {
+ if (!tok.isPadded) {
+ return value;
+ }
+ let diff = Math.abs(tok.maxLen - String(value).length);
+ let relax = options.relaxZeros !== false;
+ switch (diff) {
+ case 0:
+ return "";
+ case 1:
+ return relax ? "0?" : "0";
+ case 2:
+ return relax ? "0{0,2}" : "00";
+ default: {
+ return relax ? `0{0,${diff}}` : `0{${diff}}`;
+ }
+ }
+ }
+ toRegexRange.cache = {};
+ toRegexRange.clearCache = () => toRegexRange.cache = {};
+ module2.exports = toRegexRange;
+ }
+});
+
+// node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js
+var require_fill_range = __commonJS({
+ "node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js"(exports2, module2) {
+ "use strict";
+ var util = require("util");
+ var toRegexRange = require_to_regex_range();
+ var isObject2 = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+ var transform = (toNumber) => {
+ return (value) => toNumber === true ? Number(value) : String(value);
+ };
+ var isValidValue = (value) => {
+ return typeof value === "number" || typeof value === "string" && value !== "";
+ };
+ var isNumber = (num) => Number.isInteger(+num);
+ var zeros = (input) => {
+ let value = `${input}`;
+ let index = -1;
+ if (value[0] === "-") value = value.slice(1);
+ if (value === "0") return false;
+ while (value[++index] === "0") ;
+ return index > 0;
+ };
+ var stringify = (start, end, options) => {
+ if (typeof start === "string" || typeof end === "string") {
+ return true;
+ }
+ return options.stringify === true;
+ };
+ var pad = (input, maxLength, toNumber) => {
+ if (maxLength > 0) {
+ let dash = input[0] === "-" ? "-" : "";
+ if (dash) input = input.slice(1);
+ input = dash + input.padStart(dash ? maxLength - 1 : maxLength, "0");
+ }
+ if (toNumber === false) {
+ return String(input);
+ }
+ return input;
+ };
+ var toMaxLen = (input, maxLength) => {
+ let negative = input[0] === "-" ? "-" : "";
+ if (negative) {
+ input = input.slice(1);
+ maxLength--;
+ }
+ while (input.length < maxLength) input = "0" + input;
+ return negative ? "-" + input : input;
+ };
+ var toSequence = (parts, options, maxLen) => {
+ parts.negatives.sort((a2, b) => a2 < b ? -1 : a2 > b ? 1 : 0);
+ parts.positives.sort((a2, b) => a2 < b ? -1 : a2 > b ? 1 : 0);
+ let prefix = options.capture ? "" : "?:";
+ let positives = "";
+ let negatives = "";
+ let result;
+ if (parts.positives.length) {
+ positives = parts.positives.map((v) => toMaxLen(String(v), maxLen)).join("|");
+ }
+ if (parts.negatives.length) {
+ negatives = `-(${prefix}${parts.negatives.map((v) => toMaxLen(String(v), maxLen)).join("|")})`;
+ }
+ if (positives && negatives) {
+ result = `${positives}|${negatives}`;
+ } else {
+ result = positives || negatives;
+ }
+ if (options.wrap) {
+ return `(${prefix}${result})`;
+ }
+ return result;
+ };
+ var toRange = (a2, b, isNumbers, options) => {
+ if (isNumbers) {
+ return toRegexRange(a2, b, { wrap: false, ...options });
+ }
+ let start = String.fromCharCode(a2);
+ if (a2 === b) return start;
+ let stop = String.fromCharCode(b);
+ return `[${start}-${stop}]`;
+ };
+ var toRegex = (start, end, options) => {
+ if (Array.isArray(start)) {
+ let wrap = options.wrap === true;
+ let prefix = options.capture ? "" : "?:";
+ return wrap ? `(${prefix}${start.join("|")})` : start.join("|");
+ }
+ return toRegexRange(start, end, options);
+ };
+ var rangeError = (...args) => {
+ return new RangeError("Invalid range arguments: " + util.inspect(...args));
+ };
+ var invalidRange = (start, end, options) => {
+ if (options.strictRanges === true) throw rangeError([start, end]);
+ return [];
+ };
+ var invalidStep = (step, options) => {
+ if (options.strictRanges === true) {
+ throw new TypeError(`Expected step "${step}" to be a number`);
+ }
+ return [];
+ };
+ var fillNumbers = (start, end, step = 1, options = {}) => {
+ let a2 = Number(start);
+ let b = Number(end);
+ if (!Number.isInteger(a2) || !Number.isInteger(b)) {
+ if (options.strictRanges === true) throw rangeError([start, end]);
+ return [];
+ }
+ if (a2 === 0) a2 = 0;
+ if (b === 0) b = 0;
+ let descending = a2 > b;
+ let startString = String(start);
+ let endString = String(end);
+ let stepString = String(step);
+ step = Math.max(Math.abs(step), 1);
+ let padded = zeros(startString) || zeros(endString) || zeros(stepString);
+ let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
+ let toNumber = padded === false && stringify(start, end, options) === false;
+ let format2 = options.transform || transform(toNumber);
+ if (options.toRegex && step === 1) {
+ return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+ }
+ let parts = { negatives: [], positives: [] };
+ let push = (num) => parts[num < 0 ? "negatives" : "positives"].push(Math.abs(num));
+ let range = [];
+ let index = 0;
+ while (descending ? a2 >= b : a2 <= b) {
+ if (options.toRegex === true && step > 1) {
+ push(a2);
+ } else {
+ range.push(pad(format2(a2, index), maxLen, toNumber));
+ }
+ a2 = descending ? a2 - step : a2 + step;
+ index++;
+ }
+ if (options.toRegex === true) {
+ return step > 1 ? toSequence(parts, options, maxLen) : toRegex(range, null, { wrap: false, ...options });
+ }
+ return range;
+ };
+ var fillLetters = (start, end, step = 1, options = {}) => {
+ if (!isNumber(start) && start.length > 1 || !isNumber(end) && end.length > 1) {
+ return invalidRange(start, end, options);
+ }
+ let format2 = options.transform || ((val) => String.fromCharCode(val));
+ let a2 = `${start}`.charCodeAt(0);
+ let b = `${end}`.charCodeAt(0);
+ let descending = a2 > b;
+ let min = Math.min(a2, b);
+ let max = Math.max(a2, b);
+ if (options.toRegex && step === 1) {
+ return toRange(min, max, false, options);
+ }
+ let range = [];
+ let index = 0;
+ while (descending ? a2 >= b : a2 <= b) {
+ range.push(format2(a2, index));
+ a2 = descending ? a2 - step : a2 + step;
+ index++;
+ }
+ if (options.toRegex === true) {
+ return toRegex(range, null, { wrap: false, options });
+ }
+ return range;
+ };
+ var fill = (start, end, step, options = {}) => {
+ if (end == null && isValidValue(start)) {
+ return [start];
+ }
+ if (!isValidValue(start) || !isValidValue(end)) {
+ return invalidRange(start, end, options);
+ }
+ if (typeof step === "function") {
+ return fill(start, end, 1, { transform: step });
+ }
+ if (isObject2(step)) {
+ return fill(start, end, 0, step);
+ }
+ let opts = { ...options };
+ if (opts.capture === true) opts.wrap = true;
+ step = step || opts.step || 1;
+ if (!isNumber(step)) {
+ if (step != null && !isObject2(step)) return invalidStep(step, opts);
+ return fill(start, end, 1, step);
+ }
+ if (isNumber(start) && isNumber(end)) {
+ return fillNumbers(start, end, step, opts);
+ }
+ return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
+ };
+ module2.exports = fill;
+ }
+});
+
+// node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/compile.js
+var require_compile = __commonJS({
+ "node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/compile.js"(exports2, module2) {
+ "use strict";
+ var fill = require_fill_range();
+ var utils = require_utils6();
+ var compile = (ast, options = {}) => {
+ const walk = (node, parent = {}) => {
+ const invalidBlock = utils.isInvalidBrace(parent);
+ const invalidNode = node.invalid === true && options.escapeInvalid === true;
+ const invalid = invalidBlock === true || invalidNode === true;
+ const prefix = options.escapeInvalid === true ? "\\" : "";
+ let output = "";
+ if (node.isOpen === true) {
+ return prefix + node.value;
+ }
+ if (node.isClose === true) {
+ console.log("node.isClose", prefix, node.value);
+ return prefix + node.value;
+ }
+ if (node.type === "open") {
+ return invalid ? prefix + node.value : "(";
+ }
+ if (node.type === "close") {
+ return invalid ? prefix + node.value : ")";
+ }
+ if (node.type === "comma") {
+ return node.prev.type === "comma" ? "" : invalid ? node.value : "|";
+ }
+ if (node.value) {
+ return node.value;
+ }
+ if (node.nodes && node.ranges > 0) {
+ const args = utils.reduce(node.nodes);
+ const range = fill(...args, { ...options, wrap: false, toRegex: true, strictZeros: true });
+ if (range.length !== 0) {
+ return args.length > 1 && range.length > 1 ? `(${range})` : range;
+ }
+ }
+ if (node.nodes) {
+ for (const child of node.nodes) {
+ output += walk(child, node);
+ }
+ }
+ return output;
+ };
+ return walk(ast);
+ };
+ module2.exports = compile;
+ }
+});
+
+// node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/expand.js
+var require_expand = __commonJS({
+ "node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/expand.js"(exports2, module2) {
+ "use strict";
+ var fill = require_fill_range();
+ var stringify = require_stringify();
+ var utils = require_utils6();
+ var append = (queue = "", stash = "", enclose = false) => {
+ const result = [];
+ queue = [].concat(queue);
+ stash = [].concat(stash);
+ if (!stash.length) return queue;
+ if (!queue.length) {
+ return enclose ? utils.flatten(stash).map((ele) => `{${ele}}`) : stash;
+ }
+ for (const item of queue) {
+ if (Array.isArray(item)) {
+ for (const value of item) {
+ result.push(append(value, stash, enclose));
+ }
+ } else {
+ for (let ele of stash) {
+ if (enclose === true && typeof ele === "string") ele = `{${ele}}`;
+ result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele);
+ }
+ }
+ }
+ return utils.flatten(result);
+ };
+ var expand2 = (ast, options = {}) => {
+ const rangeLimit = options.rangeLimit === void 0 ? 1e3 : options.rangeLimit;
+ const walk = (node, parent = {}) => {
+ node.queue = [];
+ let p = parent;
+ let q = parent.queue;
+ while (p.type !== "brace" && p.type !== "root" && p.parent) {
+ p = p.parent;
+ q = p.queue;
+ }
+ if (node.invalid || node.dollar) {
+ q.push(append(q.pop(), stringify(node, options)));
+ return;
+ }
+ if (node.type === "brace" && node.invalid !== true && node.nodes.length === 2) {
+ q.push(append(q.pop(), ["{}"]));
+ return;
+ }
+ if (node.nodes && node.ranges > 0) {
+ const args = utils.reduce(node.nodes);
+ if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
+ throw new RangeError("expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.");
+ }
+ let range = fill(...args, options);
+ if (range.length === 0) {
+ range = stringify(node, options);
+ }
+ q.push(append(q.pop(), range));
+ node.nodes = [];
+ return;
+ }
+ const enclose = utils.encloseBrace(node);
+ let queue = node.queue;
+ let block = node;
+ while (block.type !== "brace" && block.type !== "root" && block.parent) {
+ block = block.parent;
+ queue = block.queue;
+ }
+ for (let i2 = 0; i2 < node.nodes.length; i2++) {
+ const child = node.nodes[i2];
+ if (child.type === "comma" && node.type === "brace") {
+ if (i2 === 1) queue.push("");
+ queue.push("");
+ continue;
+ }
+ if (child.type === "close") {
+ q.push(append(q.pop(), queue, enclose));
+ continue;
+ }
+ if (child.value && child.type !== "open") {
+ queue.push(append(queue.pop(), child.value));
+ continue;
+ }
+ if (child.nodes) {
+ walk(child, node);
+ }
+ }
+ return queue;
+ };
+ return utils.flatten(walk(ast));
+ };
+ module2.exports = expand2;
+ }
+});
+
+// node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/constants.js
+var require_constants11 = __commonJS({
+ "node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/constants.js"(exports2, module2) {
+ "use strict";
+ module2.exports = {
+ MAX_LENGTH: 1e4,
+ // Digits
+ CHAR_0: "0",
+ /* 0 */
+ CHAR_9: "9",
+ /* 9 */
+ // Alphabet chars.
+ CHAR_UPPERCASE_A: "A",
+ /* A */
+ CHAR_LOWERCASE_A: "a",
+ /* a */
+ CHAR_UPPERCASE_Z: "Z",
+ /* Z */
+ CHAR_LOWERCASE_Z: "z",
+ /* z */
+ CHAR_LEFT_PARENTHESES: "(",
+ /* ( */
+ CHAR_RIGHT_PARENTHESES: ")",
+ /* ) */
+ CHAR_ASTERISK: "*",
+ /* * */
+ // Non-alphabetic chars.
+ CHAR_AMPERSAND: "&",
+ /* & */
+ CHAR_AT: "@",
+ /* @ */
+ CHAR_BACKSLASH: "\\",
+ /* \ */
+ CHAR_BACKTICK: "`",
+ /* ` */
+ CHAR_CARRIAGE_RETURN: "\r",
+ /* \r */
+ CHAR_CIRCUMFLEX_ACCENT: "^",
+ /* ^ */
+ CHAR_COLON: ":",
+ /* : */
+ CHAR_COMMA: ",",
+ /* , */
+ CHAR_DOLLAR: "$",
+ /* . */
+ CHAR_DOT: ".",
+ /* . */
+ CHAR_DOUBLE_QUOTE: '"',
+ /* " */
+ CHAR_EQUAL: "=",
+ /* = */
+ CHAR_EXCLAMATION_MARK: "!",
+ /* ! */
+ CHAR_FORM_FEED: "\f",
+ /* \f */
+ CHAR_FORWARD_SLASH: "/",
+ /* / */
+ CHAR_HASH: "#",
+ /* # */
+ CHAR_HYPHEN_MINUS: "-",
+ /* - */
+ CHAR_LEFT_ANGLE_BRACKET: "<",
+ /* < */
+ CHAR_LEFT_CURLY_BRACE: "{",
+ /* { */
+ CHAR_LEFT_SQUARE_BRACKET: "[",
+ /* [ */
+ CHAR_LINE_FEED: "\n",
+ /* \n */
+ CHAR_NO_BREAK_SPACE: "\xA0",
+ /* \u00A0 */
+ CHAR_PERCENT: "%",
+ /* % */
+ CHAR_PLUS: "+",
+ /* + */
+ CHAR_QUESTION_MARK: "?",
+ /* ? */
+ CHAR_RIGHT_ANGLE_BRACKET: ">",
+ /* > */
+ CHAR_RIGHT_CURLY_BRACE: "}",
+ /* } */
+ CHAR_RIGHT_SQUARE_BRACKET: "]",
+ /* ] */
+ CHAR_SEMICOLON: ";",
+ /* ; */
+ CHAR_SINGLE_QUOTE: "'",
+ /* ' */
+ CHAR_SPACE: " ",
+ /* */
+ CHAR_TAB: " ",
+ /* \t */
+ CHAR_UNDERSCORE: "_",
+ /* _ */
+ CHAR_VERTICAL_LINE: "|",
+ /* | */
+ CHAR_ZERO_WIDTH_NOBREAK_SPACE: "\uFEFF"
+ /* \uFEFF */
+ };
+ }
+});
+
+// node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/parse.js
+var require_parse3 = __commonJS({
+ "node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/parse.js"(exports2, module2) {
+ "use strict";
+ var stringify = require_stringify();
+ var {
+ MAX_LENGTH,
+ CHAR_BACKSLASH,
+ /* \ */
+ CHAR_BACKTICK,
+ /* ` */
+ CHAR_COMMA,
+ /* , */
+ CHAR_DOT,
+ /* . */
+ CHAR_LEFT_PARENTHESES,
+ /* ( */
+ CHAR_RIGHT_PARENTHESES,
+ /* ) */
+ CHAR_LEFT_CURLY_BRACE,
+ /* { */
+ CHAR_RIGHT_CURLY_BRACE,
+ /* } */
+ CHAR_LEFT_SQUARE_BRACKET,
+ /* [ */
+ CHAR_RIGHT_SQUARE_BRACKET,
+ /* ] */
+ CHAR_DOUBLE_QUOTE,
+ /* " */
+ CHAR_SINGLE_QUOTE,
+ /* ' */
+ CHAR_NO_BREAK_SPACE,
+ CHAR_ZERO_WIDTH_NOBREAK_SPACE
+ } = require_constants11();
+ var parse2 = (input, options = {}) => {
+ if (typeof input !== "string") {
+ throw new TypeError("Expected a string");
+ }
+ const opts = options || {};
+ const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+ if (input.length > max) {
+ throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
+ }
+ const ast = { type: "root", input, nodes: [] };
+ const stack = [ast];
+ let block = ast;
+ let prev = ast;
+ let brackets = 0;
+ const length = input.length;
+ let index = 0;
+ let depth = 0;
+ let value;
+ const advance = () => input[index++];
+ const push = (node) => {
+ if (node.type === "text" && prev.type === "dot") {
+ prev.type = "text";
+ }
+ if (prev && prev.type === "text" && node.type === "text") {
+ prev.value += node.value;
+ return;
+ }
+ block.nodes.push(node);
+ node.parent = block;
+ node.prev = prev;
+ prev = node;
+ return node;
+ };
+ push({ type: "bos" });
+ while (index < length) {
+ block = stack[stack.length - 1];
+ value = advance();
+ if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
+ continue;
+ }
+ if (value === CHAR_BACKSLASH) {
+ push({ type: "text", value: (options.keepEscaping ? value : "") + advance() });
+ continue;
+ }
+ if (value === CHAR_RIGHT_SQUARE_BRACKET) {
+ push({ type: "text", value: "\\" + value });
+ continue;
+ }
+ if (value === CHAR_LEFT_SQUARE_BRACKET) {
+ brackets++;
+ let next;
+ while (index < length && (next = advance())) {
+ value += next;
+ if (next === CHAR_LEFT_SQUARE_BRACKET) {
+ brackets++;
+ continue;
+ }
+ if (next === CHAR_BACKSLASH) {
+ value += advance();
+ continue;
+ }
+ if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+ brackets--;
+ if (brackets === 0) {
+ break;
+ }
+ }
+ }
+ push({ type: "text", value });
+ continue;
+ }
+ if (value === CHAR_LEFT_PARENTHESES) {
+ block = push({ type: "paren", nodes: [] });
+ stack.push(block);
+ push({ type: "text", value });
+ continue;
+ }
+ if (value === CHAR_RIGHT_PARENTHESES) {
+ if (block.type !== "paren") {
+ push({ type: "text", value });
+ continue;
+ }
+ block = stack.pop();
+ push({ type: "text", value });
+ block = stack[stack.length - 1];
+ continue;
+ }
+ if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
+ const open = value;
+ let next;
+ if (options.keepQuotes !== true) {
+ value = "";
+ }
+ while (index < length && (next = advance())) {
+ if (next === CHAR_BACKSLASH) {
+ value += next + advance();
+ continue;
+ }
+ if (next === open) {
+ if (options.keepQuotes === true) value += next;
+ break;
+ }
+ value += next;
+ }
+ push({ type: "text", value });
+ continue;
+ }
+ if (value === CHAR_LEFT_CURLY_BRACE) {
+ depth++;
+ const dollar = prev.value && prev.value.slice(-1) === "$" || block.dollar === true;
+ const brace = {
+ type: "brace",
+ open: true,
+ close: false,
+ dollar,
+ depth,
+ commas: 0,
+ ranges: 0,
+ nodes: []
+ };
+ block = push(brace);
+ stack.push(block);
+ push({ type: "open", value });
+ continue;
+ }
+ if (value === CHAR_RIGHT_CURLY_BRACE) {
+ if (block.type !== "brace") {
+ push({ type: "text", value });
+ continue;
+ }
+ const type = "close";
+ block = stack.pop();
+ block.close = true;
+ push({ type, value });
+ depth--;
+ block = stack[stack.length - 1];
+ continue;
+ }
+ if (value === CHAR_COMMA && depth > 0) {
+ if (block.ranges > 0) {
+ block.ranges = 0;
+ const open = block.nodes.shift();
+ block.nodes = [open, { type: "text", value: stringify(block) }];
+ }
+ push({ type: "comma", value });
+ block.commas++;
+ continue;
+ }
+ if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
+ const siblings = block.nodes;
+ if (depth === 0 || siblings.length === 0) {
+ push({ type: "text", value });
+ continue;
+ }
+ if (prev.type === "dot") {
+ block.range = [];
+ prev.value += value;
+ prev.type = "range";
+ if (block.nodes.length !== 3 && block.nodes.length !== 5) {
+ block.invalid = true;
+ block.ranges = 0;
+ prev.type = "text";
+ continue;
+ }
+ block.ranges++;
+ block.args = [];
+ continue;
+ }
+ if (prev.type === "range") {
+ siblings.pop();
+ const before = siblings[siblings.length - 1];
+ before.value += prev.value + value;
+ prev = before;
+ block.ranges--;
+ continue;
+ }
+ push({ type: "dot", value });
+ continue;
+ }
+ push({ type: "text", value });
+ }
+ do {
+ block = stack.pop();
+ if (block.type !== "root") {
+ block.nodes.forEach((node) => {
+ if (!node.nodes) {
+ if (node.type === "open") node.isOpen = true;
+ if (node.type === "close") node.isClose = true;
+ if (!node.nodes) node.type = "text";
+ node.invalid = true;
+ }
+ });
+ const parent = stack[stack.length - 1];
+ const index2 = parent.nodes.indexOf(block);
+ parent.nodes.splice(index2, 1, ...block.nodes);
+ }
+ } while (stack.length > 0);
+ push({ type: "eos" });
+ return ast;
+ };
+ module2.exports = parse2;
+ }
+});
+
+// node_modules/.pnpm/braces@3.0.3/node_modules/braces/index.js
+var require_braces = __commonJS({
+ "node_modules/.pnpm/braces@3.0.3/node_modules/braces/index.js"(exports2, module2) {
+ "use strict";
+ var stringify = require_stringify();
+ var compile = require_compile();
+ var expand2 = require_expand();
+ var parse2 = require_parse3();
+ var braces = (input, options = {}) => {
+ let output = [];
+ if (Array.isArray(input)) {
+ for (const pattern of input) {
+ const result = braces.create(pattern, options);
+ if (Array.isArray(result)) {
+ output.push(...result);
+ } else {
+ output.push(result);
+ }
+ }
+ } else {
+ output = [].concat(braces.create(input, options));
+ }
+ if (options && options.expand === true && options.nodupes === true) {
+ output = [...new Set(output)];
+ }
+ return output;
+ };
+ braces.parse = (input, options = {}) => parse2(input, options);
+ braces.stringify = (input, options = {}) => {
+ if (typeof input === "string") {
+ return stringify(braces.parse(input, options), options);
+ }
+ return stringify(input, options);
+ };
+ braces.compile = (input, options = {}) => {
+ if (typeof input === "string") {
+ input = braces.parse(input, options);
+ }
+ return compile(input, options);
+ };
+ braces.expand = (input, options = {}) => {
+ if (typeof input === "string") {
+ input = braces.parse(input, options);
+ }
+ let result = expand2(input, options);
+ if (options.noempty === true) {
+ result = result.filter(Boolean);
+ }
+ if (options.nodupes === true) {
+ result = [...new Set(result)];
+ }
+ return result;
+ };
+ braces.create = (input, options = {}) => {
+ if (input === "" || input.length < 3) {
+ return [input];
+ }
+ return options.expand !== true ? braces.compile(input, options) : braces.expand(input, options);
+ };
+ module2.exports = braces;
+ }
+});
+
+// node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js
+var require_constants12 = __commonJS({
+ "node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js"(exports2, module2) {
+ "use strict";
+ var path7 = require("path");
+ var WIN_SLASH = "\\\\/";
+ var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+ var DOT_LITERAL = "\\.";
+ var PLUS_LITERAL = "\\+";
+ var QMARK_LITERAL = "\\?";
+ var SLASH_LITERAL = "\\/";
+ var ONE_CHAR = "(?=.)";
+ var QMARK = "[^/]";
+ var END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+ var START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+ var DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+ var NO_DOT = `(?!${DOT_LITERAL})`;
+ var NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+ var NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+ var NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+ var QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+ var STAR = `${QMARK}*?`;
+ var POSIX_CHARS = {
+ DOT_LITERAL,
+ PLUS_LITERAL,
+ QMARK_LITERAL,
+ SLASH_LITERAL,
+ ONE_CHAR,
+ QMARK,
+ END_ANCHOR,
+ DOTS_SLASH,
+ NO_DOT,
+ NO_DOTS,
+ NO_DOT_SLASH,
+ NO_DOTS_SLASH,
+ QMARK_NO_DOT,
+ STAR,
+ START_ANCHOR
+ };
+ var WINDOWS_CHARS = {
+ ...POSIX_CHARS,
+ SLASH_LITERAL: `[${WIN_SLASH}]`,
+ QMARK: WIN_NO_SLASH,
+ STAR: `${WIN_NO_SLASH}*?`,
+ DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+ NO_DOT: `(?!${DOT_LITERAL})`,
+ NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+ NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+ NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+ QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+ START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+ END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+ };
+ var POSIX_REGEX_SOURCE = {
+ alnum: "a-zA-Z0-9",
+ alpha: "a-zA-Z",
+ ascii: "\\x00-\\x7F",
+ blank: " \\t",
+ cntrl: "\\x00-\\x1F\\x7F",
+ digit: "0-9",
+ graph: "\\x21-\\x7E",
+ lower: "a-z",
+ print: "\\x20-\\x7E ",
+ punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+ space: " \\t\\r\\n\\v\\f",
+ upper: "A-Z",
+ word: "A-Za-z0-9_",
+ xdigit: "A-Fa-f0-9"
+ };
+ module2.exports = {
+ MAX_LENGTH: 1024 * 64,
+ POSIX_REGEX_SOURCE,
+ // regular expressions
+ REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+ REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+ REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+ REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+ REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+ REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+ // Replace globs with equivalent patterns to reduce parsing time.
+ REPLACEMENTS: {
+ "***": "*",
+ "**/**": "**",
+ "**/**/**": "**"
+ },
+ // Digits
+ CHAR_0: 48,
+ /* 0 */
+ CHAR_9: 57,
+ /* 9 */
+ // Alphabet chars.
+ CHAR_UPPERCASE_A: 65,
+ /* A */
+ CHAR_LOWERCASE_A: 97,
+ /* a */
+ CHAR_UPPERCASE_Z: 90,
+ /* Z */
+ CHAR_LOWERCASE_Z: 122,
+ /* z */
+ CHAR_LEFT_PARENTHESES: 40,
+ /* ( */
+ CHAR_RIGHT_PARENTHESES: 41,
+ /* ) */
+ CHAR_ASTERISK: 42,
+ /* * */
+ // Non-alphabetic chars.
+ CHAR_AMPERSAND: 38,
+ /* & */
+ CHAR_AT: 64,
+ /* @ */
+ CHAR_BACKWARD_SLASH: 92,
+ /* \ */
+ CHAR_CARRIAGE_RETURN: 13,
+ /* \r */
+ CHAR_CIRCUMFLEX_ACCENT: 94,
+ /* ^ */
+ CHAR_COLON: 58,
+ /* : */
+ CHAR_COMMA: 44,
+ /* , */
+ CHAR_DOT: 46,
+ /* . */
+ CHAR_DOUBLE_QUOTE: 34,
+ /* " */
+ CHAR_EQUAL: 61,
+ /* = */
+ CHAR_EXCLAMATION_MARK: 33,
+ /* ! */
+ CHAR_FORM_FEED: 12,
+ /* \f */
+ CHAR_FORWARD_SLASH: 47,
+ /* / */
+ CHAR_GRAVE_ACCENT: 96,
+ /* ` */
+ CHAR_HASH: 35,
+ /* # */
+ CHAR_HYPHEN_MINUS: 45,
+ /* - */
+ CHAR_LEFT_ANGLE_BRACKET: 60,
+ /* < */
+ CHAR_LEFT_CURLY_BRACE: 123,
+ /* { */
+ CHAR_LEFT_SQUARE_BRACKET: 91,
+ /* [ */
+ CHAR_LINE_FEED: 10,
+ /* \n */
+ CHAR_NO_BREAK_SPACE: 160,
+ /* \u00A0 */
+ CHAR_PERCENT: 37,
+ /* % */
+ CHAR_PLUS: 43,
+ /* + */
+ CHAR_QUESTION_MARK: 63,
+ /* ? */
+ CHAR_RIGHT_ANGLE_BRACKET: 62,
+ /* > */
+ CHAR_RIGHT_CURLY_BRACE: 125,
+ /* } */
+ CHAR_RIGHT_SQUARE_BRACKET: 93,
+ /* ] */
+ CHAR_SEMICOLON: 59,
+ /* ; */
+ CHAR_SINGLE_QUOTE: 39,
+ /* ' */
+ CHAR_SPACE: 32,
+ /* */
+ CHAR_TAB: 9,
+ /* \t */
+ CHAR_UNDERSCORE: 95,
+ /* _ */
+ CHAR_VERTICAL_LINE: 124,
+ /* | */
+ CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+ /* \uFEFF */
+ SEP: path7.sep,
+ /**
+ * Create EXTGLOB_CHARS
+ */
+ extglobChars(chars) {
+ return {
+ "!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` },
+ "?": { type: "qmark", open: "(?:", close: ")?" },
+ "+": { type: "plus", open: "(?:", close: ")+" },
+ "*": { type: "star", open: "(?:", close: ")*" },
+ "@": { type: "at", open: "(?:", close: ")" }
+ };
+ },
+ /**
+ * Create GLOB_CHARS
+ */
+ globChars(win32) {
+ return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+ }
+ };
+ }
+});
+
+// node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js
+var require_utils7 = __commonJS({
+ "node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js"(exports2) {
+ "use strict";
+ var path7 = require("path");
+ var win32 = process.platform === "win32";
+ var {
+ REGEX_BACKSLASH,
+ REGEX_REMOVE_BACKSLASH,
+ REGEX_SPECIAL_CHARS,
+ REGEX_SPECIAL_CHARS_GLOBAL
+ } = require_constants12();
+ exports2.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+ exports2.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+ exports2.isRegexChar = (str) => str.length === 1 && exports2.hasRegexChars(str);
+ exports2.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+ exports2.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+ exports2.removeBackslashes = (str) => {
+ return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+ return match === "\\" ? "" : match;
+ });
+ };
+ exports2.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;
+ };
+ exports2.isWindows = (options) => {
+ if (options && typeof options.windows === "boolean") {
+ return options.windows;
+ }
+ return win32 === true || path7.sep === "\\";
+ };
+ exports2.escapeLast = (input, char, lastIdx) => {
+ const idx = input.lastIndexOf(char, lastIdx);
+ if (idx === -1) return input;
+ if (input[idx - 1] === "\\") return exports2.escapeLast(input, char, idx - 1);
+ return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+ };
+ exports2.removePrefix = (input, state = {}) => {
+ let output = input;
+ if (output.startsWith("./")) {
+ output = output.slice(2);
+ state.prefix = "./";
+ }
+ return output;
+ };
+ exports2.wrapOutput = (input, state = {}, options = {}) => {
+ const prepend = options.contains ? "" : "^";
+ const append = options.contains ? "" : "$";
+ let output = `${prepend}(?:${input})${append}`;
+ if (state.negated === true) {
+ output = `(?:^(?!${output}).*$)`;
+ }
+ return output;
+ };
+ }
+});
+
+// node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/scan.js
+var require_scan = __commonJS({
+ "node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/scan.js"(exports2, module2) {
+ "use strict";
+ var utils = require_utils7();
+ var {
+ CHAR_ASTERISK,
+ /* * */
+ CHAR_AT,
+ /* @ */
+ CHAR_BACKWARD_SLASH,
+ /* \ */
+ CHAR_COMMA,
+ /* , */
+ CHAR_DOT,
+ /* . */
+ CHAR_EXCLAMATION_MARK,
+ /* ! */
+ CHAR_FORWARD_SLASH,
+ /* / */
+ CHAR_LEFT_CURLY_BRACE,
+ /* { */
+ CHAR_LEFT_PARENTHESES,
+ /* ( */
+ CHAR_LEFT_SQUARE_BRACKET,
+ /* [ */
+ CHAR_PLUS,
+ /* + */
+ CHAR_QUESTION_MARK,
+ /* ? */
+ CHAR_RIGHT_CURLY_BRACE,
+ /* } */
+ CHAR_RIGHT_PARENTHESES,
+ /* ) */
+ CHAR_RIGHT_SQUARE_BRACKET
+ /* ] */
+ } = require_constants12();
+ var isPathSeparator = (code) => {
+ return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+ };
+ var depth = (token) => {
+ if (token.isPrefix !== true) {
+ token.depth = token.isGlobstar ? Infinity : 1;
+ }
+ };
+ var scan = (input, options) => {
+ const opts = options || {};
+ const length = input.length - 1;
+ const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+ const slashes = [];
+ const tokens = [];
+ const parts = [];
+ let str = input;
+ let index = -1;
+ let start = 0;
+ let lastIndex = 0;
+ let isBrace = false;
+ let isBracket = false;
+ let isGlob = false;
+ let isExtglob = false;
+ let isGlobstar = false;
+ let braceEscaped = false;
+ let backslashes = false;
+ let negated = false;
+ let negatedExtglob = false;
+ let finished7 = false;
+ let braces = 0;
+ let prev;
+ let code;
+ let token = { value: "", depth: 0, isGlob: false };
+ const eos = () => index >= length;
+ const peek = () => str.charCodeAt(index + 1);
+ const advance = () => {
+ prev = code;
+ return str.charCodeAt(++index);
+ };
+ while (index < length) {
+ code = advance();
+ let next;
+ if (code === CHAR_BACKWARD_SLASH) {
+ backslashes = token.backslashes = true;
+ code = advance();
+ if (code === CHAR_LEFT_CURLY_BRACE) {
+ braceEscaped = true;
+ }
+ continue;
+ }
+ if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+ braces++;
+ while (eos() !== true && (code = advance())) {
+ if (code === CHAR_BACKWARD_SLASH) {
+ backslashes = token.backslashes = true;
+ advance();
+ continue;
+ }
+ if (code === CHAR_LEFT_CURLY_BRACE) {
+ braces++;
+ continue;
+ }
+ if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+ isBrace = token.isBrace = true;
+ isGlob = token.isGlob = true;
+ finished7 = true;
+ if (scanToEnd === true) {
+ continue;
+ }
+ break;
+ }
+ if (braceEscaped !== true && code === CHAR_COMMA) {
+ isBrace = token.isBrace = true;
+ isGlob = token.isGlob = true;
+ finished7 = true;
+ if (scanToEnd === true) {
+ continue;
+ }
+ break;
+ }
+ if (code === CHAR_RIGHT_CURLY_BRACE) {
+ braces--;
+ if (braces === 0) {
+ braceEscaped = false;
+ isBrace = token.isBrace = true;
+ finished7 = true;
+ break;
+ }
+ }
+ }
+ if (scanToEnd === true) {
+ continue;
+ }
+ break;
+ }
+ if (code === CHAR_FORWARD_SLASH) {
+ slashes.push(index);
+ tokens.push(token);
+ token = { value: "", depth: 0, isGlob: false };
+ if (finished7 === true) continue;
+ if (prev === CHAR_DOT && index === start + 1) {
+ start += 2;
+ continue;
+ }
+ lastIndex = index + 1;
+ continue;
+ }
+ if (opts.noext !== true) {
+ const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+ if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+ isGlob = token.isGlob = true;
+ isExtglob = token.isExtglob = true;
+ finished7 = true;
+ if (code === CHAR_EXCLAMATION_MARK && index === start) {
+ negatedExtglob = true;
+ }
+ if (scanToEnd === true) {
+ while (eos() !== true && (code = advance())) {
+ if (code === CHAR_BACKWARD_SLASH) {
+ backslashes = token.backslashes = true;
+ code = advance();
+ continue;
+ }
+ if (code === CHAR_RIGHT_PARENTHESES) {
+ isGlob = token.isGlob = true;
+ finished7 = true;
+ break;
+ }
+ }
+ continue;
+ }
+ break;
+ }
+ }
+ if (code === CHAR_ASTERISK) {
+ if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+ isGlob = token.isGlob = true;
+ finished7 = true;
+ if (scanToEnd === true) {
+ continue;
+ }
+ break;
+ }
+ if (code === CHAR_QUESTION_MARK) {
+ isGlob = token.isGlob = true;
+ finished7 = true;
+ if (scanToEnd === true) {
+ continue;
+ }
+ break;
+ }
+ if (code === CHAR_LEFT_SQUARE_BRACKET) {
+ while (eos() !== true && (next = advance())) {
+ if (next === CHAR_BACKWARD_SLASH) {
+ backslashes = token.backslashes = true;
+ advance();
+ continue;
+ }
+ if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+ isBracket = token.isBracket = true;
+ isGlob = token.isGlob = true;
+ finished7 = true;
+ break;
+ }
+ }
+ if (scanToEnd === true) {
+ continue;
+ }
+ break;
+ }
+ if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+ negated = token.negated = true;
+ start++;
+ continue;
+ }
+ if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+ isGlob = token.isGlob = true;
+ if (scanToEnd === true) {
+ while (eos() !== true && (code = advance())) {
+ if (code === CHAR_LEFT_PARENTHESES) {
+ backslashes = token.backslashes = true;
+ code = advance();
+ continue;
+ }
+ if (code === CHAR_RIGHT_PARENTHESES) {
+ finished7 = true;
+ break;
+ }
+ }
+ continue;
+ }
+ break;
+ }
+ if (isGlob === true) {
+ finished7 = true;
+ if (scanToEnd === true) {
+ continue;
+ }
+ break;
+ }
+ }
+ if (opts.noext === true) {
+ isExtglob = false;
+ isGlob = false;
+ }
+ let base = str;
+ let prefix = "";
+ let glob2 = "";
+ if (start > 0) {
+ prefix = str.slice(0, start);
+ str = str.slice(start);
+ lastIndex -= start;
+ }
+ if (base && isGlob === true && lastIndex > 0) {
+ base = str.slice(0, lastIndex);
+ glob2 = str.slice(lastIndex);
+ } else if (isGlob === true) {
+ base = "";
+ glob2 = str;
+ } else {
+ base = str;
+ }
+ if (base && base !== "" && base !== "/" && base !== str) {
+ if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+ base = base.slice(0, -1);
+ }
+ }
+ if (opts.unescape === true) {
+ if (glob2) glob2 = utils.removeBackslashes(glob2);
+ if (base && backslashes === true) {
+ base = utils.removeBackslashes(base);
+ }
+ }
+ const state = {
+ prefix,
+ input,
+ start,
+ base,
+ glob: glob2,
+ isBrace,
+ isBracket,
+ isGlob,
+ isExtglob,
+ isGlobstar,
+ negated,
+ negatedExtglob
+ };
+ if (opts.tokens === true) {
+ state.maxDepth = 0;
+ if (!isPathSeparator(code)) {
+ tokens.push(token);
+ }
+ state.tokens = tokens;
+ }
+ if (opts.parts === true || opts.tokens === true) {
+ let prevIndex;
+ for (let idx = 0; idx < slashes.length; idx++) {
+ const n2 = prevIndex ? prevIndex + 1 : start;
+ const i2 = slashes[idx];
+ const value = input.slice(n2, i2);
+ if (opts.tokens) {
+ if (idx === 0 && start !== 0) {
+ tokens[idx].isPrefix = true;
+ tokens[idx].value = prefix;
+ } else {
+ tokens[idx].value = value;
+ }
+ depth(tokens[idx]);
+ state.maxDepth += tokens[idx].depth;
+ }
+ if (idx !== 0 || value !== "") {
+ parts.push(value);
+ }
+ prevIndex = i2;
+ }
+ if (prevIndex && prevIndex + 1 < input.length) {
+ const value = input.slice(prevIndex + 1);
+ parts.push(value);
+ if (opts.tokens) {
+ tokens[tokens.length - 1].value = value;
+ depth(tokens[tokens.length - 1]);
+ state.maxDepth += tokens[tokens.length - 1].depth;
+ }
+ }
+ state.slashes = slashes;
+ state.parts = parts;
+ }
+ return state;
+ };
+ module2.exports = scan;
+ }
+});
+
+// node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js
+var require_parse4 = __commonJS({
+ "node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js"(exports2, module2) {
+ "use strict";
+ var constants4 = require_constants12();
+ var utils = require_utils7();
+ var {
+ MAX_LENGTH,
+ POSIX_REGEX_SOURCE,
+ REGEX_NON_SPECIAL_CHARS,
+ REGEX_SPECIAL_CHARS_BACKREF,
+ REPLACEMENTS
+ } = constants4;
+ var expandRange = (args, options) => {
+ if (typeof options.expandRange === "function") {
+ return options.expandRange(...args, options);
+ }
+ args.sort();
+ const value = `[${args.join("-")}]`;
+ try {
+ new RegExp(value);
+ } catch (ex) {
+ return args.map((v) => utils.escapeRegex(v)).join("..");
+ }
+ return value;
+ };
+ var syntaxError = (type, char) => {
+ return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+ };
+ var parse2 = (input, options) => {
+ if (typeof input !== "string") {
+ throw new TypeError("Expected a string");
+ }
+ input = REPLACEMENTS[input] || input;
+ const opts = { ...options };
+ const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+ let len = input.length;
+ if (len > max) {
+ throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+ }
+ const bos = { type: "bos", value: "", output: opts.prepend || "" };
+ const tokens = [bos];
+ const capture = opts.capture ? "" : "?:";
+ const win32 = utils.isWindows(options);
+ const PLATFORM_CHARS = constants4.globChars(win32);
+ const EXTGLOB_CHARS = constants4.extglobChars(PLATFORM_CHARS);
+ const {
+ DOT_LITERAL,
+ PLUS_LITERAL,
+ SLASH_LITERAL,
+ ONE_CHAR,
+ DOTS_SLASH,
+ NO_DOT,
+ NO_DOT_SLASH,
+ NO_DOTS_SLASH,
+ QMARK,
+ QMARK_NO_DOT,
+ STAR,
+ START_ANCHOR
+ } = PLATFORM_CHARS;
+ const globstar = (opts2) => {
+ return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+ };
+ const nodot = opts.dot ? "" : NO_DOT;
+ const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+ let star = opts.bash === true ? globstar(opts) : STAR;
+ if (opts.capture) {
+ star = `(${star})`;
+ }
+ if (typeof opts.noext === "boolean") {
+ opts.noextglob = opts.noext;
+ }
+ const state = {
+ input,
+ index: -1,
+ start: 0,
+ dot: opts.dot === true,
+ consumed: "",
+ output: "",
+ prefix: "",
+ backtrack: false,
+ negated: false,
+ brackets: 0,
+ braces: 0,
+ parens: 0,
+ quotes: 0,
+ globstar: false,
+ tokens
+ };
+ input = utils.removePrefix(input, state);
+ len = input.length;
+ const extglobs = [];
+ const braces = [];
+ const stack = [];
+ let prev = bos;
+ let value;
+ const eos = () => state.index === len - 1;
+ const peek = state.peek = (n2 = 1) => input[state.index + n2];
+ const advance = state.advance = () => input[++state.index] || "";
+ const remaining = () => input.slice(state.index + 1);
+ const consume = (value2 = "", num = 0) => {
+ state.consumed += value2;
+ state.index += num;
+ };
+ const append = (token) => {
+ state.output += token.output != null ? token.output : token.value;
+ consume(token.value);
+ };
+ const negate = () => {
+ let count2 = 1;
+ while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+ advance();
+ state.start++;
+ count2++;
+ }
+ if (count2 % 2 === 0) {
+ return false;
+ }
+ state.negated = true;
+ state.start++;
+ return true;
+ };
+ const increment2 = (type) => {
+ state[type]++;
+ stack.push(type);
+ };
+ const decrement = (type) => {
+ state[type]--;
+ stack.pop();
+ };
+ const push = (tok) => {
+ if (prev.type === "globstar") {
+ const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+ const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+ if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+ state.output = state.output.slice(0, -prev.output.length);
+ prev.type = "star";
+ prev.value = "*";
+ prev.output = star;
+ state.output += prev.output;
+ }
+ }
+ if (extglobs.length && tok.type !== "paren") {
+ extglobs[extglobs.length - 1].inner += tok.value;
+ }
+ if (tok.value || tok.output) append(tok);
+ if (prev && prev.type === "text" && tok.type === "text") {
+ prev.value += tok.value;
+ prev.output = (prev.output || "") + tok.value;
+ return;
+ }
+ tok.prev = prev;
+ tokens.push(tok);
+ prev = tok;
+ };
+ const extglobOpen = (type, value2) => {
+ const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
+ token.prev = prev;
+ token.parens = state.parens;
+ token.output = state.output;
+ const output = (opts.capture ? "(" : "") + token.open;
+ increment2("parens");
+ push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
+ push({ type: "paren", extglob: true, value: advance(), output });
+ extglobs.push(token);
+ };
+ const extglobClose = (token) => {
+ let output = token.close + (opts.capture ? ")" : "");
+ let rest;
+ if (token.type === "negate") {
+ let extglobStar = star;
+ if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
+ extglobStar = globstar(opts);
+ }
+ if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+ output = token.close = `)$))${extglobStar}`;
+ }
+ if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+ const expression = parse2(rest, { ...options, fastpaths: false }).output;
+ output = token.close = `)${expression})${extglobStar})`;
+ }
+ if (token.prev.type === "bos") {
+ state.negatedExtglob = true;
+ }
+ }
+ push({ type: "paren", extglob: true, value, output });
+ decrement("parens");
+ };
+ if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+ let backslashes = false;
+ let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+ if (first === "\\") {
+ backslashes = true;
+ return m;
+ }
+ if (first === "?") {
+ if (esc) {
+ return esc + first + (rest ? QMARK.repeat(rest.length) : "");
+ }
+ if (index === 0) {
+ return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
+ }
+ return QMARK.repeat(chars.length);
+ }
+ if (first === ".") {
+ return DOT_LITERAL.repeat(chars.length);
+ }
+ if (first === "*") {
+ if (esc) {
+ return esc + first + (rest ? star : "");
+ }
+ return star;
+ }
+ return esc ? m : `\\${m}`;
+ });
+ if (backslashes === true) {
+ if (opts.unescape === true) {
+ output = output.replace(/\\/g, "");
+ } else {
+ output = output.replace(/\\+/g, (m) => {
+ return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+ });
+ }
+ }
+ if (output === input && opts.contains === true) {
+ state.output = input;
+ return state;
+ }
+ state.output = utils.wrapOutput(output, state, options);
+ return state;
+ }
+ while (!eos()) {
+ value = advance();
+ if (value === "\0") {
+ continue;
+ }
+ if (value === "\\") {
+ const next = peek();
+ if (next === "/" && opts.bash !== true) {
+ continue;
+ }
+ if (next === "." || next === ";") {
+ continue;
+ }
+ if (!next) {
+ value += "\\";
+ push({ type: "text", value });
+ continue;
+ }
+ const match = /^\\+/.exec(remaining());
+ let slashes = 0;
+ if (match && match[0].length > 2) {
+ slashes = match[0].length;
+ state.index += slashes;
+ if (slashes % 2 !== 0) {
+ value += "\\";
+ }
+ }
+ if (opts.unescape === true) {
+ value = advance();
+ } else {
+ value += advance();
+ }
+ if (state.brackets === 0) {
+ push({ type: "text", value });
+ continue;
+ }
+ }
+ if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+ if (opts.posix !== false && value === ":") {
+ const inner = prev.value.slice(1);
+ if (inner.includes("[")) {
+ prev.posix = true;
+ if (inner.includes(":")) {
+ const idx = prev.value.lastIndexOf("[");
+ const pre = prev.value.slice(0, idx);
+ const rest2 = prev.value.slice(idx + 2);
+ const posix = POSIX_REGEX_SOURCE[rest2];
+ if (posix) {
+ prev.value = pre + posix;
+ state.backtrack = true;
+ advance();
+ if (!bos.output && tokens.indexOf(prev) === 1) {
+ bos.output = ONE_CHAR;
+ }
+ continue;
+ }
+ }
+ }
+ }
+ if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
+ value = `\\${value}`;
+ }
+ if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
+ value = `\\${value}`;
+ }
+ if (opts.posix === true && value === "!" && prev.value === "[") {
+ value = "^";
+ }
+ prev.value += value;
+ append({ value });
+ continue;
+ }
+ if (state.quotes === 1 && value !== '"') {
+ value = utils.escapeRegex(value);
+ prev.value += value;
+ append({ value });
+ continue;
+ }
+ if (value === '"') {
+ state.quotes = state.quotes === 1 ? 0 : 1;
+ if (opts.keepQuotes === true) {
+ push({ type: "text", value });
+ }
+ continue;
+ }
+ if (value === "(") {
+ increment2("parens");
+ push({ type: "paren", value });
+ continue;
+ }
+ if (value === ")") {
+ if (state.parens === 0 && opts.strictBrackets === true) {
+ throw new SyntaxError(syntaxError("opening", "("));
+ }
+ const extglob = extglobs[extglobs.length - 1];
+ if (extglob && state.parens === extglob.parens + 1) {
+ extglobClose(extglobs.pop());
+ continue;
+ }
+ push({ type: "paren", value, output: state.parens ? ")" : "\\)" });
+ decrement("parens");
+ continue;
+ }
+ if (value === "[") {
+ if (opts.nobracket === true || !remaining().includes("]")) {
+ if (opts.nobracket !== true && opts.strictBrackets === true) {
+ throw new SyntaxError(syntaxError("closing", "]"));
+ }
+ value = `\\${value}`;
+ } else {
+ increment2("brackets");
+ }
+ push({ type: "bracket", value });
+ continue;
+ }
+ if (value === "]") {
+ if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+ push({ type: "text", value, output: `\\${value}` });
+ continue;
+ }
+ if (state.brackets === 0) {
+ if (opts.strictBrackets === true) {
+ throw new SyntaxError(syntaxError("opening", "["));
+ }
+ push({ type: "text", value, output: `\\${value}` });
+ continue;
+ }
+ decrement("brackets");
+ const prevValue = prev.value.slice(1);
+ if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
+ value = `/${value}`;
+ }
+ prev.value += value;
+ append({ value });
+ if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+ continue;
+ }
+ const escaped = utils.escapeRegex(prev.value);
+ state.output = state.output.slice(0, -prev.value.length);
+ if (opts.literalBrackets === true) {
+ state.output += escaped;
+ prev.value = escaped;
+ continue;
+ }
+ prev.value = `(${capture}${escaped}|${prev.value})`;
+ state.output += prev.value;
+ continue;
+ }
+ if (value === "{" && opts.nobrace !== true) {
+ increment2("braces");
+ const open = {
+ type: "brace",
+ value,
+ output: "(",
+ outputIndex: state.output.length,
+ tokensIndex: state.tokens.length
+ };
+ braces.push(open);
+ push(open);
+ continue;
+ }
+ if (value === "}") {
+ const brace = braces[braces.length - 1];
+ if (opts.nobrace === true || !brace) {
+ push({ type: "text", value, output: value });
+ continue;
+ }
+ let output = ")";
+ if (brace.dots === true) {
+ const arr = tokens.slice();
+ const range = [];
+ for (let i2 = arr.length - 1; i2 >= 0; i2--) {
+ tokens.pop();
+ if (arr[i2].type === "brace") {
+ break;
+ }
+ if (arr[i2].type !== "dots") {
+ range.unshift(arr[i2].value);
+ }
+ }
+ output = expandRange(range, opts);
+ state.backtrack = true;
+ }
+ if (brace.comma !== true && brace.dots !== true) {
+ const out = state.output.slice(0, brace.outputIndex);
+ const toks = state.tokens.slice(brace.tokensIndex);
+ brace.value = brace.output = "\\{";
+ value = output = "\\}";
+ state.output = out;
+ for (const t of toks) {
+ state.output += t.output || t.value;
+ }
+ }
+ push({ type: "brace", value, output });
+ decrement("braces");
+ braces.pop();
+ continue;
+ }
+ if (value === "|") {
+ if (extglobs.length > 0) {
+ extglobs[extglobs.length - 1].conditions++;
+ }
+ push({ type: "text", value });
+ continue;
+ }
+ if (value === ",") {
+ let output = value;
+ const brace = braces[braces.length - 1];
+ if (brace && stack[stack.length - 1] === "braces") {
+ brace.comma = true;
+ output = "|";
+ }
+ push({ type: "comma", value, output });
+ continue;
+ }
+ if (value === "/") {
+ if (prev.type === "dot" && state.index === state.start + 1) {
+ state.start = state.index + 1;
+ state.consumed = "";
+ state.output = "";
+ tokens.pop();
+ prev = bos;
+ continue;
+ }
+ push({ type: "slash", value, output: SLASH_LITERAL });
+ continue;
+ }
+ if (value === ".") {
+ if (state.braces > 0 && prev.type === "dot") {
+ if (prev.value === ".") prev.output = DOT_LITERAL;
+ const brace = braces[braces.length - 1];
+ prev.type = "dots";
+ prev.output += value;
+ prev.value += value;
+ brace.dots = true;
+ continue;
+ }
+ if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+ push({ type: "text", value, output: DOT_LITERAL });
+ continue;
+ }
+ push({ type: "dot", value, output: DOT_LITERAL });
+ continue;
+ }
+ if (value === "?") {
+ const isGroup = prev && prev.value === "(";
+ if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+ extglobOpen("qmark", value);
+ continue;
+ }
+ if (prev && prev.type === "paren") {
+ 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}`;
+ }
+ push({ type: "text", value, output });
+ continue;
+ }
+ if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+ push({ type: "qmark", value, output: QMARK_NO_DOT });
+ continue;
+ }
+ push({ type: "qmark", value, output: QMARK });
+ continue;
+ }
+ if (value === "!") {
+ if (opts.noextglob !== true && peek() === "(") {
+ if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+ extglobOpen("negate", value);
+ continue;
+ }
+ }
+ if (opts.nonegate !== true && state.index === 0) {
+ negate();
+ continue;
+ }
+ }
+ if (value === "+") {
+ if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+ extglobOpen("plus", value);
+ continue;
+ }
+ if (prev && prev.value === "(" || opts.regex === false) {
+ push({ type: "plus", value, output: PLUS_LITERAL });
+ continue;
+ }
+ if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+ push({ type: "plus", value });
+ continue;
+ }
+ push({ type: "plus", value: PLUS_LITERAL });
+ continue;
+ }
+ if (value === "@") {
+ if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+ push({ type: "at", extglob: true, value, output: "" });
+ continue;
+ }
+ push({ type: "text", value });
+ continue;
+ }
+ if (value !== "*") {
+ if (value === "$" || value === "^") {
+ value = `\\${value}`;
+ }
+ const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+ if (match) {
+ value += match[0];
+ state.index += match[0].length;
+ }
+ push({ type: "text", value });
+ continue;
+ }
+ if (prev && (prev.type === "globstar" || prev.star === true)) {
+ prev.type = "star";
+ prev.star = true;
+ prev.value += value;
+ prev.output = star;
+ state.backtrack = true;
+ state.globstar = true;
+ consume(value);
+ continue;
+ }
+ let rest = remaining();
+ if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+ extglobOpen("star", value);
+ continue;
+ }
+ if (prev.type === "star") {
+ if (opts.noglobstar === true) {
+ consume(value);
+ continue;
+ }
+ const prior = prev.prev;
+ const before = prior.prev;
+ const isStart = prior.type === "slash" || prior.type === "bos";
+ const afterStar = before && (before.type === "star" || before.type === "globstar");
+ if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+ push({ type: "star", value, output: "" });
+ continue;
+ }
+ const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+ const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+ if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+ push({ type: "star", value, output: "" });
+ continue;
+ }
+ while (rest.slice(0, 3) === "/**") {
+ const after = input[state.index + 4];
+ if (after && after !== "/") {
+ break;
+ }
+ rest = rest.slice(3);
+ consume("/**", 3);
+ }
+ if (prior.type === "bos" && eos()) {
+ prev.type = "globstar";
+ prev.value += value;
+ prev.output = globstar(opts);
+ state.output = prev.output;
+ state.globstar = true;
+ consume(value);
+ continue;
+ }
+ if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+ state.output = state.output.slice(0, -(prior.output + prev.output).length);
+ prior.output = `(?:${prior.output}`;
+ prev.type = "globstar";
+ prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+ prev.value += value;
+ state.globstar = true;
+ state.output += prior.output + prev.output;
+ consume(value);
+ continue;
+ }
+ if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+ const end = rest[1] !== void 0 ? "|$" : "";
+ state.output = state.output.slice(0, -(prior.output + prev.output).length);
+ prior.output = `(?:${prior.output}`;
+ prev.type = "globstar";
+ prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+ prev.value += value;
+ state.output += prior.output + prev.output;
+ state.globstar = true;
+ consume(value + advance());
+ push({ type: "slash", value: "/", output: "" });
+ continue;
+ }
+ if (prior.type === "bos" && rest[0] === "/") {
+ prev.type = "globstar";
+ prev.value += value;
+ prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+ state.output = prev.output;
+ state.globstar = true;
+ consume(value + advance());
+ push({ type: "slash", value: "/", output: "" });
+ continue;
+ }
+ state.output = state.output.slice(0, -prev.output.length);
+ prev.type = "globstar";
+ prev.output = globstar(opts);
+ prev.value += value;
+ state.output += prev.output;
+ state.globstar = true;
+ consume(value);
+ continue;
+ }
+ const token = { type: "star", value, output: star };
+ if (opts.bash === true) {
+ token.output = ".*?";
+ if (prev.type === "bos" || prev.type === "slash") {
+ token.output = nodot + token.output;
+ }
+ push(token);
+ continue;
+ }
+ if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+ token.output = value;
+ push(token);
+ continue;
+ }
+ if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+ if (prev.type === "dot") {
+ state.output += NO_DOT_SLASH;
+ prev.output += NO_DOT_SLASH;
+ } else if (opts.dot === true) {
+ state.output += NO_DOTS_SLASH;
+ prev.output += NO_DOTS_SLASH;
+ } else {
+ state.output += nodot;
+ prev.output += nodot;
+ }
+ if (peek() !== "*") {
+ state.output += ONE_CHAR;
+ prev.output += ONE_CHAR;
+ }
+ }
+ push(token);
+ }
+ while (state.brackets > 0) {
+ if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+ state.output = utils.escapeLast(state.output, "[");
+ decrement("brackets");
+ }
+ while (state.parens > 0) {
+ if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
+ state.output = utils.escapeLast(state.output, "(");
+ decrement("parens");
+ }
+ while (state.braces > 0) {
+ if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
+ state.output = utils.escapeLast(state.output, "{");
+ decrement("braces");
+ }
+ if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
+ push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
+ }
+ if (state.backtrack === true) {
+ state.output = "";
+ for (const token of state.tokens) {
+ state.output += token.output != null ? token.output : token.value;
+ if (token.suffix) {
+ state.output += token.suffix;
+ }
+ }
+ }
+ return state;
+ };
+ parse2.fastpaths = (input, options) => {
+ const opts = { ...options };
+ const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+ const len = input.length;
+ if (len > max) {
+ throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+ }
+ input = REPLACEMENTS[input] || input;
+ const win32 = utils.isWindows(options);
+ const {
+ DOT_LITERAL,
+ SLASH_LITERAL,
+ ONE_CHAR,
+ DOTS_SLASH,
+ NO_DOT,
+ NO_DOTS,
+ NO_DOTS_SLASH,
+ STAR,
+ START_ANCHOR
+ } = constants4.globChars(win32);
+ const nodot = opts.dot ? NO_DOTS : NO_DOT;
+ const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+ const capture = opts.capture ? "" : "?:";
+ const state = { negated: false, prefix: "" };
+ let star = opts.bash === true ? ".*?" : STAR;
+ if (opts.capture) {
+ star = `(${star})`;
+ }
+ const globstar = (opts2) => {
+ if (opts2.noglobstar === true) return star;
+ return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+ };
+ const create2 = (str) => {
+ switch (str) {
+ case "*":
+ return `${nodot}${ONE_CHAR}${star}`;
+ case ".*":
+ return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+ case "*.*":
+ return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+ case "*/*":
+ return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+ case "**":
+ return nodot + globstar(opts);
+ case "**/*":
+ return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+ case "**/*.*":
+ return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+ case "**/.*":
+ return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+ default: {
+ const match = /^(.*?)\.(\w+)$/.exec(str);
+ if (!match) return;
+ const source2 = create2(match[1]);
+ if (!source2) return;
+ return source2 + DOT_LITERAL + match[2];
+ }
+ }
+ };
+ const output = utils.removePrefix(input, state);
+ let source = create2(output);
+ if (source && opts.strictSlashes !== true) {
+ source += `${SLASH_LITERAL}?`;
+ }
+ return source;
+ };
+ module2.exports = parse2;
+ }
+});
+
+// node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js
+var require_picomatch = __commonJS({
+ "node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js"(exports2, module2) {
+ "use strict";
+ var path7 = require("path");
+ var scan = require_scan();
+ var parse2 = require_parse4();
+ var utils = require_utils7();
+ var constants4 = require_constants12();
+ var isObject2 = (val) => val && typeof val === "object" && !Array.isArray(val);
+ var picomatch = (glob2, options, returnState = false) => {
+ if (Array.isArray(glob2)) {
+ const fns = glob2.map((input) => picomatch(input, options, returnState));
+ const arrayMatcher = (str) => {
+ for (const isMatch of fns) {
+ const state2 = isMatch(str);
+ if (state2) return state2;
+ }
+ return false;
+ };
+ return arrayMatcher;
+ }
+ const isState = isObject2(glob2) && glob2.tokens && glob2.input;
+ if (glob2 === "" || typeof glob2 !== "string" && !isState) {
+ throw new TypeError("Expected pattern to be a non-empty string");
+ }
+ const opts = options || {};
+ const posix = utils.isWindows(options);
+ const regex = isState ? picomatch.compileRe(glob2, options) : picomatch.makeRe(glob2, options, false, true);
+ const state = regex.state;
+ delete regex.state;
+ let isIgnored = () => false;
+ if (opts.ignore) {
+ const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+ isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+ }
+ const matcher = (input, returnObject = false) => {
+ const { isMatch, match, output } = picomatch.test(input, regex, options, { glob: glob2, posix });
+ const result = { glob: glob2, state, regex, posix, input, output, match, isMatch };
+ if (typeof opts.onResult === "function") {
+ opts.onResult(result);
+ }
+ if (isMatch === false) {
+ result.isMatch = false;
+ return returnObject ? result : false;
+ }
+ if (isIgnored(input)) {
+ if (typeof opts.onIgnore === "function") {
+ opts.onIgnore(result);
+ }
+ result.isMatch = false;
+ return returnObject ? result : false;
+ }
+ if (typeof opts.onMatch === "function") {
+ opts.onMatch(result);
+ }
+ return returnObject ? result : true;
+ };
+ if (returnState) {
+ matcher.state = state;
+ }
+ return matcher;
+ };
+ picomatch.test = (input, regex, options, { glob: glob2, posix } = {}) => {
+ if (typeof input !== "string") {
+ throw new TypeError("Expected input to be a string");
+ }
+ if (input === "") {
+ return { isMatch: false, output: "" };
+ }
+ const opts = options || {};
+ const format2 = opts.format || (posix ? utils.toPosixSlashes : null);
+ let match = input === glob2;
+ let output = match && format2 ? format2(input) : input;
+ if (match === false) {
+ output = format2 ? format2(input) : input;
+ match = output === glob2;
+ }
+ if (match === false || opts.capture === true) {
+ if (opts.matchBase === true || opts.basename === true) {
+ match = picomatch.matchBase(input, regex, options, posix);
+ } else {
+ match = regex.exec(output);
+ }
+ }
+ return { isMatch: Boolean(match), match, output };
+ };
+ picomatch.matchBase = (input, glob2, options, posix = utils.isWindows(options)) => {
+ const regex = glob2 instanceof RegExp ? glob2 : picomatch.makeRe(glob2, options);
+ return regex.test(path7.basename(input));
+ };
+ picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+ picomatch.parse = (pattern, options) => {
+ if (Array.isArray(pattern)) return pattern.map((p) => picomatch.parse(p, options));
+ return parse2(pattern, { ...options, fastpaths: false });
+ };
+ picomatch.scan = (input, options) => scan(input, options);
+ picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+ if (returnOutput === true) {
+ return state.output;
+ }
+ const opts = options || {};
+ const prepend = opts.contains ? "" : "^";
+ const append = opts.contains ? "" : "$";
+ let source = `${prepend}(?:${state.output})${append}`;
+ if (state && state.negated === true) {
+ source = `^(?!${source}).*$`;
+ }
+ const regex = picomatch.toRegex(source, options);
+ if (returnState === true) {
+ regex.state = state;
+ }
+ return regex;
+ };
+ picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+ if (!input || typeof input !== "string") {
+ throw new TypeError("Expected a non-empty string");
+ }
+ let parsed = { negated: false, fastpaths: true };
+ if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
+ parsed.output = parse2.fastpaths(input, options);
+ }
+ if (!parsed.output) {
+ parsed = parse2(input, options);
+ }
+ return picomatch.compileRe(parsed, options, returnOutput, returnState);
+ };
+ picomatch.toRegex = (source, options) => {
+ try {
+ const opts = options || {};
+ return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
+ } catch (err) {
+ if (options && options.debug === true) throw err;
+ return /$^/;
+ }
+ };
+ picomatch.constants = constants4;
+ module2.exports = picomatch;
+ }
+});
+
+// node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js
+var require_picomatch2 = __commonJS({
+ "node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js"(exports2, module2) {
+ "use strict";
+ module2.exports = require_picomatch();
+ }
+});
+
+// node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js
+var require_micromatch = __commonJS({
+ "node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js"(exports2, module2) {
+ "use strict";
+ var util = require("util");
+ var braces = require_braces();
+ var picomatch = require_picomatch2();
+ var utils = require_utils7();
+ var isEmptyString = (v) => v === "" || v === "./";
+ var hasBraces = (v) => {
+ const index = v.indexOf("{");
+ return index > -1 && v.indexOf("}", index) > -1;
+ };
+ var micromatch2 = (list, patterns, options) => {
+ patterns = [].concat(patterns);
+ list = [].concat(list);
+ let omit2 = /* @__PURE__ */ new Set();
+ let keep = /* @__PURE__ */ new Set();
+ let items = /* @__PURE__ */ new Set();
+ let negatives = 0;
+ let onResult = (state) => {
+ items.add(state.output);
+ if (options && options.onResult) {
+ options.onResult(state);
+ }
+ };
+ for (let i2 = 0; i2 < patterns.length; i2++) {
+ let isMatch = picomatch(String(patterns[i2]), { ...options, onResult }, true);
+ let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
+ if (negated) negatives++;
+ for (let item of list) {
+ let matched = isMatch(item, true);
+ let match = negated ? !matched.isMatch : matched.isMatch;
+ if (!match) continue;
+ if (negated) {
+ omit2.add(matched.output);
+ } else {
+ omit2.delete(matched.output);
+ keep.add(matched.output);
+ }
+ }
+ }
+ let result = negatives === patterns.length ? [...items] : [...keep];
+ let matches = result.filter((item) => !omit2.has(item));
+ if (options && matches.length === 0) {
+ if (options.failglob === true) {
+ throw new Error(`No matches found for "${patterns.join(", ")}"`);
+ }
+ if (options.nonull === true || options.nullglob === true) {
+ return options.unescape ? patterns.map((p) => p.replace(/\\/g, "")) : patterns;
+ }
+ }
+ return matches;
+ };
+ micromatch2.match = micromatch2;
+ micromatch2.matcher = (pattern, options) => picomatch(pattern, options);
+ micromatch2.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+ micromatch2.any = micromatch2.isMatch;
+ micromatch2.not = (list, patterns, options = {}) => {
+ patterns = [].concat(patterns).map(String);
+ let result = /* @__PURE__ */ new Set();
+ let items = [];
+ let onResult = (state) => {
+ if (options.onResult) options.onResult(state);
+ items.push(state.output);
+ };
+ let matches = new Set(micromatch2(list, patterns, { ...options, onResult }));
+ for (let item of items) {
+ if (!matches.has(item)) {
+ result.add(item);
+ }
+ }
+ return [...result];
+ };
+ micromatch2.contains = (str, pattern, options) => {
+ if (typeof str !== "string") {
+ throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+ }
+ if (Array.isArray(pattern)) {
+ return pattern.some((p) => micromatch2.contains(str, p, options));
+ }
+ if (typeof pattern === "string") {
+ if (isEmptyString(str) || isEmptyString(pattern)) {
+ return false;
+ }
+ if (str.includes(pattern) || str.startsWith("./") && str.slice(2).includes(pattern)) {
+ return true;
+ }
+ }
+ return micromatch2.isMatch(str, pattern, { ...options, contains: true });
+ };
+ micromatch2.matchKeys = (obj, patterns, options) => {
+ if (!utils.isObject(obj)) {
+ throw new TypeError("Expected the first argument to be an object");
+ }
+ let keys = micromatch2(Object.keys(obj), patterns, options);
+ let res = {};
+ for (let key of keys) res[key] = obj[key];
+ return res;
+ };
+ micromatch2.some = (list, patterns, options) => {
+ let items = [].concat(list);
+ for (let pattern of [].concat(patterns)) {
+ let isMatch = picomatch(String(pattern), options);
+ if (items.some((item) => isMatch(item))) {
+ return true;
+ }
+ }
+ return false;
+ };
+ micromatch2.every = (list, patterns, options) => {
+ let items = [].concat(list);
+ for (let pattern of [].concat(patterns)) {
+ let isMatch = picomatch(String(pattern), options);
+ if (!items.every((item) => isMatch(item))) {
+ return false;
+ }
+ }
+ return true;
+ };
+ micromatch2.all = (str, patterns, options) => {
+ if (typeof str !== "string") {
+ throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+ }
+ return [].concat(patterns).every((p) => picomatch(p, options)(str));
+ };
+ micromatch2.capture = (glob2, input, options) => {
+ let posix = utils.isWindows(options);
+ let regex = picomatch.makeRe(String(glob2), { ...options, capture: true });
+ let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
+ if (match) {
+ return match.slice(1).map((v) => v === void 0 ? "" : v);
+ }
+ };
+ micromatch2.makeRe = (...args) => picomatch.makeRe(...args);
+ micromatch2.scan = (...args) => picomatch.scan(...args);
+ micromatch2.parse = (patterns, options) => {
+ let res = [];
+ for (let pattern of [].concat(patterns || [])) {
+ for (let str of braces(String(pattern), options)) {
+ res.push(picomatch.parse(str, options));
+ }
+ }
+ return res;
+ };
+ micromatch2.braces = (pattern, options) => {
+ if (typeof pattern !== "string") throw new TypeError("Expected a string");
+ if (options && options.nobrace === true || !hasBraces(pattern)) {
+ return [pattern];
+ }
+ return braces(pattern, options);
+ };
+ micromatch2.braceExpand = (pattern, options) => {
+ if (typeof pattern !== "string") throw new TypeError("Expected a string");
+ return micromatch2.braces(pattern, { ...options, expand: true });
+ };
+ micromatch2.hasBraces = hasBraces;
+ module2.exports = micromatch2;
+ }
+});
+
+// node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = __commonJS({
+ "node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports2, module2) {
+ "use strict";
+ module2.exports = isexe;
+ isexe.sync = sync;
+ var fs = require("fs");
+ function checkPathExt(path7, options) {
+ var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+ if (!pathext) {
+ return true;
+ }
+ pathext = pathext.split(";");
+ if (pathext.indexOf("") !== -1) {
+ return true;
+ }
+ for (var i2 = 0; i2 < pathext.length; i2++) {
+ var p = pathext[i2].toLowerCase();
+ if (p && path7.substr(-p.length).toLowerCase() === p) {
+ return true;
+ }
+ }
+ return false;
+ }
+ function checkStat(stat, path7, options) {
+ if (!stat.isSymbolicLink() && !stat.isFile()) {
+ return false;
+ }
+ return checkPathExt(path7, options);
+ }
+ function isexe(path7, options, cb) {
+ fs.stat(path7, function(er, stat) {
+ cb(er, er ? false : checkStat(stat, path7, options));
+ });
+ }
+ function sync(path7, options) {
+ return checkStat(fs.statSync(path7), path7, options);
+ }
+ }
+});
+
+// node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode = __commonJS({
+ "node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports2, module2) {
+ "use strict";
+ module2.exports = isexe;
+ isexe.sync = sync;
+ var fs = require("fs");
+ function isexe(path7, options, cb) {
+ fs.stat(path7, function(er, stat) {
+ cb(er, er ? false : checkStat(stat, options));
+ });
+ }
+ function sync(path7, options) {
+ return checkStat(fs.statSync(path7), options);
+ }
+ function checkStat(stat, options) {
+ return stat.isFile() && checkMode(stat, options);
+ }
+ function checkMode(stat, options) {
+ var mod = stat.mode;
+ var uid = stat.uid;
+ var gid = stat.gid;
+ var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+ var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+ var u2 = parseInt("100", 8);
+ var g = parseInt("010", 8);
+ var o2 = parseInt("001", 8);
+ var ug = u2 | g;
+ var ret = mod & o2 || mod & g && gid === myGid || mod & u2 && uid === myUid || mod & ug && myUid === 0;
+ return ret;
+ }
+ }
+});
+
+// node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = __commonJS({
+ "node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports2, module2) {
+ "use strict";
+ var fs = require("fs");
+ var core6;
+ if (process.platform === "win32" || global.TESTING_WINDOWS) {
+ core6 = require_windows();
+ } else {
+ core6 = require_mode();
+ }
+ module2.exports = isexe;
+ isexe.sync = sync;
+ function isexe(path7, options, cb) {
+ if (typeof options === "function") {
+ cb = options;
+ options = {};
+ }
+ if (!cb) {
+ if (typeof Promise !== "function") {
+ throw new TypeError("callback not provided");
+ }
+ return new Promise(function(resolve, reject) {
+ isexe(path7, options || {}, function(er, is) {
+ if (er) {
+ reject(er);
+ } else {
+ resolve(is);
+ }
+ });
+ });
+ }
+ core6(path7, options || {}, function(er, is) {
+ if (er) {
+ if (er.code === "EACCES" || options && options.ignoreErrors) {
+ er = null;
+ is = false;
+ }
+ }
+ cb(er, is);
+ });
+ }
+ function sync(path7, options) {
+ try {
+ return core6.sync(path7, options || {});
+ } catch (er) {
+ if (options && options.ignoreErrors || er.code === "EACCES") {
+ return false;
+ } else {
+ throw er;
+ }
+ }
+ }
+ }
+});
+
+// node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
+var require_which = __commonJS({
+ "node_modules/.pnpm/which@2.0.2/node_modules/which/which.js"(exports2, module2) {
+ "use strict";
+ var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+ var path7 = require("path");
+ var COLON = isWindows ? ";" : ":";
+ var isexe = require_isexe();
+ var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+ var getPathInfo = (cmd, opt) => {
+ const colon = opt.colon || COLON;
+ const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+ // windows always checks the cwd first
+ ...isWindows ? [process.cwd()] : [],
+ ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
+ "").split(colon)
+ ];
+ const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+ const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+ if (isWindows) {
+ if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+ pathExt.unshift("");
+ }
+ return {
+ pathEnv,
+ pathExt,
+ pathExtExe
+ };
+ };
+ var which = (cmd, opt, cb) => {
+ if (typeof opt === "function") {
+ cb = opt;
+ opt = {};
+ }
+ if (!opt)
+ opt = {};
+ const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+ const found = [];
+ const step = (i2) => new Promise((resolve, reject) => {
+ if (i2 === pathEnv.length)
+ return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+ const ppRaw = pathEnv[i2];
+ const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+ const pCmd = path7.join(pathPart, cmd);
+ const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+ resolve(subStep(p, i2, 0));
+ });
+ const subStep = (p, i2, ii) => new Promise((resolve, reject) => {
+ if (ii === pathExt.length)
+ return resolve(step(i2 + 1));
+ const ext = pathExt[ii];
+ isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+ if (!er && is) {
+ if (opt.all)
+ found.push(p + ext);
+ else
+ return resolve(p + ext);
+ }
+ return resolve(subStep(p, i2, ii + 1));
+ });
+ });
+ return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+ };
+ var whichSync = (cmd, opt) => {
+ opt = opt || {};
+ const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+ const found = [];
+ for (let i2 = 0; i2 < pathEnv.length; i2++) {
+ const ppRaw = pathEnv[i2];
+ const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+ const pCmd = path7.join(pathPart, cmd);
+ const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+ for (let j = 0; j < pathExt.length; j++) {
+ const cur = p + pathExt[j];
+ try {
+ const is = isexe.sync(cur, { pathExt: pathExtExe });
+ if (is) {
+ if (opt.all)
+ found.push(cur);
+ else
+ return cur;
+ }
+ } catch (ex) {
+ }
+ }
+ }
+ if (opt.all && found.length)
+ return found;
+ if (opt.nothrow)
+ return null;
+ throw getNotFoundError(cmd);
+ };
+ module2.exports = which;
+ which.sync = whichSync;
+ }
+});
+
+// node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key = __commonJS({
+ "node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js"(exports2, module2) {
+ "use strict";
+ var pathKey2 = (options = {}) => {
+ const environment = options.env || process.env;
+ const platform2 = options.platform || process.platform;
+ if (platform2 !== "win32") {
+ return "PATH";
+ }
+ return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+ };
+ module2.exports = pathKey2;
+ module2.exports.default = pathKey2;
+ }
+});
+
+// node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS({
+ "node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports2, module2) {
+ "use strict";
+ var path7 = require("path");
+ var which = require_which();
+ var getPathKey = require_path_key();
+ function resolveCommandAttempt(parsed, withoutPathExt) {
+ const env = parsed.options.env || process.env;
+ const cwd = process.cwd();
+ const hasCustomCwd = parsed.options.cwd != null;
+ const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+ if (shouldSwitchCwd) {
+ try {
+ process.chdir(parsed.options.cwd);
+ } catch (err) {
+ }
+ }
+ let resolved;
+ try {
+ resolved = which.sync(parsed.command, {
+ path: env[getPathKey({ env })],
+ pathExt: withoutPathExt ? path7.delimiter : void 0
+ });
+ } catch (e) {
+ } finally {
+ if (shouldSwitchCwd) {
+ process.chdir(cwd);
+ }
+ }
+ if (resolved) {
+ resolved = path7.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+ }
+ return resolved;
+ }
+ function resolveCommand(parsed) {
+ return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+ }
+ module2.exports = resolveCommand;
+ }
+});
+
+// node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape2 = __commonJS({
+ "node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js"(exports2, module2) {
+ "use strict";
+ var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+ function escapeCommand(arg) {
+ arg = arg.replace(metaCharsRegExp, "^$1");
+ return arg;
+ }
+ function escapeArgument(arg, doubleEscapeMetaChars) {
+ arg = `${arg}`;
+ arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+ arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+ arg = `"${arg}"`;
+ arg = arg.replace(metaCharsRegExp, "^$1");
+ if (doubleEscapeMetaChars) {
+ arg = arg.replace(metaCharsRegExp, "^$1");
+ }
+ return arg;
+ }
+ module2.exports.command = escapeCommand;
+ module2.exports.argument = escapeArgument;
+ }
+});
+
+// node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS({
+ "node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js"(exports2, module2) {
+ "use strict";
+ module2.exports = /^#!(.*)/;
+ }
+});
+
+// node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS({
+ "node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js"(exports2, module2) {
+ "use strict";
+ var shebangRegex = require_shebang_regex();
+ module2.exports = (string = "") => {
+ const match = string.match(shebangRegex);
+ if (!match) {
+ return null;
+ }
+ const [path7, argument] = match[0].replace(/#! ?/, "").split(" ");
+ const binary = path7.split("/").pop();
+ if (binary === "env") {
+ return argument;
+ }
+ return argument ? `${binary} ${argument}` : binary;
+ };
+ }
+});
+
+// node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS({
+ "node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
+ "use strict";
+ var fs = require("fs");
+ var shebangCommand = require_shebang_command();
+ function readShebang(command) {
+ const size = 150;
+ const buffer = Buffer.alloc(size);
+ let fd;
+ try {
+ fd = fs.openSync(command, "r");
+ fs.readSync(fd, buffer, 0, size, 0);
+ fs.closeSync(fd);
+ } catch (e) {
+ }
+ return shebangCommand(buffer.toString());
+ }
+ module2.exports = readShebang;
+ }
+});
+
+// node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse5 = __commonJS({
+ "node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js"(exports2, module2) {
+ "use strict";
+ var path7 = require("path");
+ var resolveCommand = require_resolveCommand();
+ var escape = require_escape2();
+ var readShebang = require_readShebang();
+ var isWin = process.platform === "win32";
+ var isExecutableRegExp = /\.(?:com|exe)$/i;
+ var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+ function detectShebang(parsed) {
+ parsed.file = resolveCommand(parsed);
+ const shebang = parsed.file && readShebang(parsed.file);
+ if (shebang) {
+ parsed.args.unshift(parsed.file);
+ parsed.command = shebang;
+ return resolveCommand(parsed);
+ }
+ return parsed.file;
+ }
+ function parseNonShell(parsed) {
+ if (!isWin) {
+ return parsed;
+ }
+ const commandFile = detectShebang(parsed);
+ const needsShell = !isExecutableRegExp.test(commandFile);
+ if (parsed.options.forceShell || needsShell) {
+ const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+ parsed.command = path7.normalize(parsed.command);
+ parsed.command = escape.command(parsed.command);
+ parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+ const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+ parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+ parsed.command = process.env.comspec || "cmd.exe";
+ parsed.options.windowsVerbatimArguments = true;
+ }
+ return parsed;
+ }
+ function parse2(command, args, options) {
+ if (args && !Array.isArray(args)) {
+ options = args;
+ args = null;
+ }
+ args = args ? args.slice(0) : [];
+ options = Object.assign({}, options);
+ const parsed = {
+ command,
+ args,
+ options,
+ file: void 0,
+ original: {
+ command,
+ args
+ }
+ };
+ return options.shell ? parsed : parseNonShell(parsed);
+ }
+ module2.exports = parse2;
+ }
+});
+
+// node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS({
+ "node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js"(exports2, module2) {
+ "use strict";
+ var isWin = process.platform === "win32";
+ function notFoundError(original, syscall) {
+ return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+ code: "ENOENT",
+ errno: "ENOENT",
+ syscall: `${syscall} ${original.command}`,
+ path: original.command,
+ spawnargs: original.args
+ });
+ }
+ function hookChildProcess(cp, parsed) {
+ if (!isWin) {
+ return;
+ }
+ const originalEmit = cp.emit;
+ cp.emit = function(name, arg1) {
+ if (name === "exit") {
+ const err = verifyENOENT(arg1, parsed);
+ if (err) {
+ return originalEmit.call(cp, "error", err);
+ }
+ }
+ return originalEmit.apply(cp, arguments);
+ };
+ }
+ function verifyENOENT(status, parsed) {
+ if (isWin && status === 1 && !parsed.file) {
+ return notFoundError(parsed.original, "spawn");
+ }
+ return null;
+ }
+ function verifyENOENTSync(status, parsed) {
+ if (isWin && status === 1 && !parsed.file) {
+ return notFoundError(parsed.original, "spawnSync");
+ }
+ return null;
+ }
+ module2.exports = {
+ hookChildProcess,
+ verifyENOENT,
+ verifyENOENTSync,
+ notFoundError
+ };
+ }
+});
+
+// node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS({
+ "node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js"(exports2, module2) {
+ "use strict";
+ var cp = require("child_process");
+ var parse2 = require_parse5();
+ var enoent = require_enoent();
+ function spawn2(command, args, options) {
+ const parsed = parse2(command, args, options);
+ const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+ enoent.hookChildProcess(spawned, parsed);
+ return spawned;
+ }
+ function spawnSync2(command, args, options) {
+ const parsed = parse2(command, args, options);
+ const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+ result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+ return result;
+ }
+ module2.exports = spawn2;
+ module2.exports.spawn = spawn2;
+ module2.exports.sync = spawnSync2;
+ module2.exports._parse = parse2;
+ module2.exports._enoent = enoent;
+ }
+});
+
+// actions/changed-roots/src/run.ts
+var core5 = __toESM(require_core());
+var github3 = __toESM(require_github());
+
+// actions/changed-roots/src/run-inputs.ts
+var core = __toESM(require_core());
+var github2 = __toESM(require_github());
+
+// actions/changed-roots/src/event.ts
+var github = __toESM(require_github());
+function getEventData() {
+ const { context: context3 } = github;
+ switch (context3.eventName) {
+ case "pull_request":
+ const prEvent = context3.payload.pull_request;
+ if (!prEvent.number) {
+ throw new Error("Pull request number not found in event payload.");
+ }
+ return {
+ eventName: "pull_request",
+ prNumber: prEvent.number
+ };
+ case "push":
+ const pushEvent = github.context.payload;
+ if (!pushEvent.before || !pushEvent.after) {
+ throw new Error("Push event payload missing 'before' or 'after' SHAs.");
+ }
+ return {
+ eventName: "push",
+ base: pushEvent.before,
+ head: pushEvent.after
+ };
+ case "merge_group":
+ const mgEvent = github.context.payload;
+ if (!mgEvent.merge_group.base_sha || !mgEvent.merge_group.head_sha) {
+ throw new Error(
+ "Merge group event payload missing 'base_sha' or 'head_sha'."
+ );
+ }
+ return {
+ eventName: "merge_group",
+ base: mgEvent.merge_group.base_sha,
+ head: mgEvent.merge_group.head_sha
+ };
+ case "schedule":
+ case "workflow_dispatch":
+ return {
+ eventName: "no-change"
+ };
+ default:
+ throw new Error(`Unsupported event type: ${context3.eventName}`);
+ }
+}
+
+// actions/changed-roots/src/run-inputs.ts
+function getInputs() {
+ core.info("Getting inputs for run.");
+ const inputs = {
+ repositoryRoot: getRunInputString("repositoryRoot", true),
+ rootFile: getRunInputString("rootFile", true),
+ filePatterns: getRunInputStringArray("filePatterns", true),
+ rootPatterns: getRunInputStringArray("rootPatterns", true),
+ noChangeBehaviour: getRunInputString(
+ "noChangeBehaviour",
+ true
+ )
+ };
+ core.info(`Inputs: ${JSON.stringify(inputs)}`);
+ return inputs;
+}
+function getInvokeContext() {
+ const { owner, repo } = github2.context.repo;
+ const token = process.env.GITHUB_TOKEN || core.getInput("github-token", {
+ required: true
+ });
+ if (!token) {
+ core.setFailed("GitHub token is not set.");
+ return process.exit(1);
+ }
+ const event = getEventData();
+ core.info(
+ `Invoke context: ${JSON.stringify({ token: "****", owner, repo, event }, null, 2)}`
+ );
+ return { token, owner, repo, event };
+}
+var runInputsConfiguration = {
+ repositoryRoot: {
+ parameter: "repository-root",
+ localParameter: "REPOSITORY_ROOT"
+ },
+ rootFile: {
+ parameter: "root-file",
+ localParameter: "ROOT_FILE"
+ },
+ filePatterns: {
+ parameter: "file-patterns",
+ localParameter: "FILE_PATTERNS"
+ },
+ rootPatterns: {
+ parameter: "root-patterns",
+ localParameter: "ROOT_PATTERNS"
+ },
+ noChangeBehaviour: {
+ parameter: "no-change-behaviour",
+ localParameter: "NO_CHANGE_BEHAVIOUR",
+ validator: validateNoChangeBehaviourInput
+ }
+};
+function getRunInputString(input, required = true) {
+ const inputKey = getInputKey(input);
+ const inputValue = core.getInput(inputKey, {
+ required
+ });
+ const validator = runInputsConfiguration[input]?.validator;
+ if (inputValue && validator && !validator(inputValue)) {
+ throw new Error(`Invalid value for input ${inputKey}: ${inputValue}`);
+ }
+ return inputValue;
+}
+function getRunInputStringArray(input, required = false) {
+ const inputKey = getInputKey(input);
+ const inputValue = core.getInput(inputKey, {
+ required
+ });
+ if (!inputValue) {
+ return [];
+ }
+ const seperator = inputValue.includes(",") ? "," : "\n";
+ core.info(
+ `Parsing input ${inputKey} as string array using separator '${seperator}'`
+ );
+ return inputValue.split(seperator).map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function getInputKey(input) {
+ const config = runInputsConfiguration[input];
+ if (!config) {
+ throw new Error(`No configuration found for input: ${input}`);
+ }
+ const isLocalDebug = process.env.CL_LOCAL_DEBUG;
+ const inputKey = isLocalDebug ? config.localParameter : config.parameter;
+ return inputKey;
+}
+function validateNoChangeBehaviourInput(value) {
+ return value === "all" || value === "none" || value === "root" || value === "latest-commit";
+}
+
+// actions/changed-roots/src/path-ops.ts
+var core2 = __toESM(require_core());
+var glob = __toESM(require_glob());
+var path = __toESM(require("path"));
+var import_micromatch = __toESM(require_micromatch());
+function normalizePath(p) {
+ let s = p.replace(/\\/g, "/");
+ if (s === "." || s === "./") return ".";
+ s = s.replace(/^.\//, "").replace(/\/+$/, "");
+ return s;
+}
+function sortDeepestFirst(mods) {
+ return [...new Set(mods)].sort((a2, b) => {
+ const da = a2 === "." ? 0 : a2.split("/").length;
+ const db = b === "." ? 0 : b.split("/").length;
+ if (db !== da) return db - da;
+ return b.length - a2.length;
+ });
+}
+function matchModule(file, moduleDirectories) {
+ const fileNorm = normalizePath(file);
+ for (const mod of moduleDirectories) {
+ if (mod === ".") {
+ return ".";
+ }
+ const patterns = [mod, `${mod}/**`];
+ if (import_micromatch.default.isMatch(fileNorm, patterns, { dot: true })) {
+ return mod;
+ }
+ }
+ return "";
+}
+function matchModules(files, moduleDirectories) {
+ core2.startGroup("Matching modified files to modules");
+ const normalizedFiles = files.map(normalizePath);
+ const normalizedModules = sortDeepestFirst(
+ moduleDirectories.map(normalizePath)
+ );
+ const results = [];
+ for (const file of normalizedFiles) {
+ const matched = matchModule(file, normalizedModules);
+ if (!matched) {
+ core2.info(`No matching module directory found for file: ${file}`);
+ continue;
+ }
+ core2.info(`Matched ${file} to module directory: ${matched}`);
+ results.push([file, matched]);
+ }
+ core2.endGroup();
+ return results;
+}
+async function getAllRoots(rootFile, directory = ".") {
+ core2.startGroup(`Finding all ${rootFile} files within ${directory}`);
+ const pattern = `${directory}/**/${rootFile}`;
+ try {
+ const globber = await glob.create(pattern);
+ const files = await globber.glob();
+ if (files.length === 0) {
+ core2.warning(`No ${rootFile} files found within ${directory}`);
+ return [];
+ }
+ core2.info(`Found ${files.length} ${rootFile} files.`);
+ core2.info(`Found ${rootFile} files: ${JSON.stringify(files)}`);
+ const directories = files.map((f) => {
+ const relativePath = path.relative(directory, f);
+ return path.dirname(relativePath);
+ });
+ core2.info(`Found root directories: ${JSON.stringify(directories)}`);
+ return directories;
+ } catch (error) {
+ throw new Error(`failed to get ${rootFile} files: ${error}`);
+ } finally {
+ core2.endGroup();
+ }
+}
+function filterPaths(paths, filePatterns) {
+ core2.info(
+ `Checking ${paths.length} paths against ${filePatterns.length} patterns.`
+ );
+ if (filePatterns.length === 0) {
+ core2.info(
+ "No include patterns specified, defaulting to include all paths."
+ );
+ filePatterns.push("**");
+ }
+ core2.debug(`Initial paths: ${JSON.stringify(paths)}`);
+ core2.debug(`File patterns: ${JSON.stringify(filePatterns)}`);
+ const includePatterns = filePatterns.filter((p) => !p.startsWith("!"));
+ const excludePatterns = filePatterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
+ const normalizeDotForMatch = (p) => p === "." ? "__ROOT__" : p;
+ const filteredPaths = paths.filter((rawPath) => {
+ const path7 = normalizeDotForMatch(rawPath);
+ const isExcluded = excludePatterns.length > 0 && import_micromatch.default.isMatch(path7, excludePatterns, { dot: true });
+ if (isExcluded) {
+ core2.debug(`Excluded by negation: ${rawPath}`);
+ return false;
+ }
+ const isIncluded = includePatterns.length === 0 || import_micromatch.default.isMatch(path7, includePatterns, { dot: true });
+ core2.debug(`Path: ${rawPath}, included: ${isIncluded}`);
+ return isIncluded;
+ });
+ core2.info(`After filtering, ${filteredPaths.length} paths remain.`);
+ core2.debug(`Filtered paths: ${JSON.stringify(filteredPaths)}`);
+ return filteredPaths;
+}
+
+// actions/changed-roots/src/git.ts
+var core3 = __toESM(require_core());
+
+// node_modules/.pnpm/is-plain-obj@4.1.0/node_modules/is-plain-obj/index.js
+function isPlainObject3(value) {
+ if (typeof value !== "object" || value === null) {
+ return false;
+ }
+ const prototype = Object.getPrototypeOf(value);
+ return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/arguments/file-url.js
+var import_node_url = require("node:url");
+var safeNormalizeFileUrl = (file, name) => {
+ const fileString = normalizeFileUrl(normalizeDenoExecPath(file));
+ if (typeof fileString !== "string") {
+ throw new TypeError(`${name} must be a string or a file URL: ${fileString}.`);
+ }
+ return fileString;
+};
+var normalizeDenoExecPath = (file) => isDenoExecPath(file) ? file.toString() : file;
+var isDenoExecPath = (file) => typeof file !== "string" && file && Object.getPrototypeOf(file) === String.prototype;
+var normalizeFileUrl = (file) => file instanceof URL ? (0, import_node_url.fileURLToPath)(file) : file;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/methods/parameters.js
+var normalizeParameters = (rawFile, rawArguments = [], rawOptions = {}) => {
+ const filePath = safeNormalizeFileUrl(rawFile, "First argument");
+ const [commandArguments, options] = isPlainObject3(rawArguments) ? [[], rawArguments] : [rawArguments, rawOptions];
+ if (!Array.isArray(commandArguments)) {
+ throw new TypeError(`Second argument must be either an array of arguments or an options object: ${commandArguments}`);
+ }
+ if (commandArguments.some((commandArgument) => typeof commandArgument === "object" && commandArgument !== null)) {
+ throw new TypeError(`Second argument must be an array of strings: ${commandArguments}`);
+ }
+ const normalizedArguments = commandArguments.map(String);
+ const nullByteArgument = normalizedArguments.find((normalizedArgument) => normalizedArgument.includes("\0"));
+ if (nullByteArgument !== void 0) {
+ throw new TypeError(`Arguments cannot contain null bytes ("\\0"): ${nullByteArgument}`);
+ }
+ if (!isPlainObject3(options)) {
+ throw new TypeError(`Last argument must be an options object: ${options}`);
+ }
+ return [filePath, normalizedArguments, options];
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/methods/template.js
+var import_node_child_process = require("node:child_process");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/utils/uint-array.js
+var import_node_string_decoder = require("node:string_decoder");
+var { toString: objectToString } = Object.prototype;
+var isArrayBuffer = (value) => objectToString.call(value) === "[object ArrayBuffer]";
+var isUint8Array = (value) => objectToString.call(value) === "[object Uint8Array]";
+var bufferToUint8Array = (buffer) => new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+var textEncoder = new TextEncoder();
+var stringToUint8Array = (string) => textEncoder.encode(string);
+var textDecoder = new TextDecoder();
+var uint8ArrayToString = (uint8Array) => textDecoder.decode(uint8Array);
+var joinToString = (uint8ArraysOrStrings, encoding) => {
+ const strings = uint8ArraysToStrings(uint8ArraysOrStrings, encoding);
+ return strings.join("");
+};
+var uint8ArraysToStrings = (uint8ArraysOrStrings, encoding) => {
+ if (encoding === "utf8" && uint8ArraysOrStrings.every((uint8ArrayOrString) => typeof uint8ArrayOrString === "string")) {
+ return uint8ArraysOrStrings;
+ }
+ const decoder = new import_node_string_decoder.StringDecoder(encoding);
+ const strings = uint8ArraysOrStrings.map((uint8ArrayOrString) => typeof uint8ArrayOrString === "string" ? stringToUint8Array(uint8ArrayOrString) : uint8ArrayOrString).map((uint8Array) => decoder.write(uint8Array));
+ const finalString = decoder.end();
+ return finalString === "" ? strings : [...strings, finalString];
+};
+var joinToUint8Array = (uint8ArraysOrStrings) => {
+ if (uint8ArraysOrStrings.length === 1 && isUint8Array(uint8ArraysOrStrings[0])) {
+ return uint8ArraysOrStrings[0];
+ }
+ return concatUint8Arrays(stringsToUint8Arrays(uint8ArraysOrStrings));
+};
+var stringsToUint8Arrays = (uint8ArraysOrStrings) => uint8ArraysOrStrings.map((uint8ArrayOrString) => typeof uint8ArrayOrString === "string" ? stringToUint8Array(uint8ArrayOrString) : uint8ArrayOrString);
+var concatUint8Arrays = (uint8Arrays) => {
+ const result = new Uint8Array(getJoinLength(uint8Arrays));
+ let index = 0;
+ for (const uint8Array of uint8Arrays) {
+ result.set(uint8Array, index);
+ index += uint8Array.length;
+ }
+ return result;
+};
+var getJoinLength = (uint8Arrays) => {
+ let joinLength = 0;
+ for (const uint8Array of uint8Arrays) {
+ joinLength += uint8Array.length;
+ }
+ return joinLength;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/methods/template.js
+var isTemplateString = (templates) => Array.isArray(templates) && Array.isArray(templates.raw);
+var parseTemplates = (templates, expressions) => {
+ let tokens = [];
+ for (const [index, template] of templates.entries()) {
+ tokens = parseTemplate({
+ templates,
+ expressions,
+ tokens,
+ index,
+ template
+ });
+ }
+ if (tokens.length === 0) {
+ throw new TypeError("Template script must not be empty");
+ }
+ const [file, ...commandArguments] = tokens;
+ return [file, commandArguments, {}];
+};
+var parseTemplate = ({ templates, expressions, tokens, index, template }) => {
+ if (template === void 0) {
+ throw new TypeError(`Invalid backslash sequence: ${templates.raw[index]}`);
+ }
+ const { nextTokens, leadingWhitespaces, trailingWhitespaces } = splitByWhitespaces(template, templates.raw[index]);
+ const newTokens = concatTokens(tokens, nextTokens, leadingWhitespaces);
+ if (index === expressions.length) {
+ return newTokens;
+ }
+ const expression = expressions[index];
+ const expressionTokens = Array.isArray(expression) ? expression.map((expression2) => parseExpression(expression2)) : [parseExpression(expression)];
+ return concatTokens(newTokens, expressionTokens, trailingWhitespaces);
+};
+var splitByWhitespaces = (template, rawTemplate) => {
+ if (rawTemplate.length === 0) {
+ return { nextTokens: [], leadingWhitespaces: false, trailingWhitespaces: false };
+ }
+ const nextTokens = [];
+ let templateStart = 0;
+ const leadingWhitespaces = DELIMITERS.has(rawTemplate[0]);
+ for (let templateIndex = 0, rawIndex = 0; templateIndex < template.length; templateIndex += 1, rawIndex += 1) {
+ const rawCharacter = rawTemplate[rawIndex];
+ if (DELIMITERS.has(rawCharacter)) {
+ if (templateStart !== templateIndex) {
+ nextTokens.push(template.slice(templateStart, templateIndex));
+ }
+ templateStart = templateIndex + 1;
+ } else if (rawCharacter === "\\") {
+ const nextRawCharacter = rawTemplate[rawIndex + 1];
+ if (nextRawCharacter === "\n") {
+ templateIndex -= 1;
+ rawIndex += 1;
+ } else if (nextRawCharacter === "u" && rawTemplate[rawIndex + 2] === "{") {
+ rawIndex = rawTemplate.indexOf("}", rawIndex + 3);
+ } else {
+ rawIndex += ESCAPE_LENGTH[nextRawCharacter] ?? 1;
+ }
+ }
+ }
+ const trailingWhitespaces = templateStart === template.length;
+ if (!trailingWhitespaces) {
+ nextTokens.push(template.slice(templateStart));
+ }
+ return { nextTokens, leadingWhitespaces, trailingWhitespaces };
+};
+var DELIMITERS = /* @__PURE__ */ new Set([" ", " ", "\r", "\n"]);
+var ESCAPE_LENGTH = { x: 3, u: 5 };
+var concatTokens = (tokens, nextTokens, isSeparated) => isSeparated || tokens.length === 0 || nextTokens.length === 0 ? [...tokens, ...nextTokens] : [
+ ...tokens.slice(0, -1),
+ `${tokens.at(-1)}${nextTokens[0]}`,
+ ...nextTokens.slice(1)
+];
+var parseExpression = (expression) => {
+ const typeOfExpression = typeof expression;
+ if (typeOfExpression === "string") {
+ return expression;
+ }
+ if (typeOfExpression === "number") {
+ return String(expression);
+ }
+ if (isPlainObject3(expression) && ("stdout" in expression || "isMaxBuffer" in expression)) {
+ return getSubprocessResult(expression);
+ }
+ if (expression instanceof import_node_child_process.ChildProcess || Object.prototype.toString.call(expression) === "[object Promise]") {
+ throw new TypeError("Unexpected subprocess in template expression. Please use ${await subprocess} instead of ${subprocess}.");
+ }
+ throw new TypeError(`Unexpected "${typeOfExpression}" in template expression`);
+};
+var getSubprocessResult = ({ stdout }) => {
+ if (typeof stdout === "string") {
+ return stdout;
+ }
+ if (isUint8Array(stdout)) {
+ return uint8ArrayToString(stdout);
+ }
+ if (stdout === void 0) {
+ throw new TypeError(`Missing result.stdout in template expression. This is probably due to the previous subprocess' "stdout" option.`);
+ }
+ throw new TypeError(`Unexpected "${typeof stdout}" stdout in template expression`);
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/methods/main-sync.js
+var import_node_child_process3 = require("node:child_process");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/arguments/specific.js
+var import_node_util = require("node:util");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/utils/standard-stream.js
+var import_node_process = __toESM(require("node:process"), 1);
+var isStandardStream = (stream) => STANDARD_STREAMS.includes(stream);
+var STANDARD_STREAMS = [import_node_process.default.stdin, import_node_process.default.stdout, import_node_process.default.stderr];
+var STANDARD_STREAMS_ALIASES = ["stdin", "stdout", "stderr"];
+var getStreamName = (fdNumber) => STANDARD_STREAMS_ALIASES[fdNumber] ?? `stdio[${fdNumber}]`;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/arguments/specific.js
+var normalizeFdSpecificOptions = (options) => {
+ const optionsCopy = { ...options };
+ for (const optionName of FD_SPECIFIC_OPTIONS) {
+ optionsCopy[optionName] = normalizeFdSpecificOption(options, optionName);
+ }
+ return optionsCopy;
+};
+var normalizeFdSpecificOption = (options, optionName) => {
+ const optionBaseArray = Array.from({ length: getStdioLength(options) + 1 });
+ const optionArray = normalizeFdSpecificValue(options[optionName], optionBaseArray, optionName);
+ return addDefaultValue(optionArray, optionName);
+};
+var getStdioLength = ({ stdio }) => Array.isArray(stdio) ? Math.max(stdio.length, STANDARD_STREAMS_ALIASES.length) : STANDARD_STREAMS_ALIASES.length;
+var normalizeFdSpecificValue = (optionValue, optionArray, optionName) => isPlainObject3(optionValue) ? normalizeOptionObject(optionValue, optionArray, optionName) : optionArray.fill(optionValue);
+var normalizeOptionObject = (optionValue, optionArray, optionName) => {
+ for (const fdName of Object.keys(optionValue).sort(compareFdName)) {
+ for (const fdNumber of parseFdName(fdName, optionName, optionArray)) {
+ optionArray[fdNumber] = optionValue[fdName];
+ }
+ }
+ return optionArray;
+};
+var compareFdName = (fdNameA, fdNameB) => getFdNameOrder(fdNameA) < getFdNameOrder(fdNameB) ? 1 : -1;
+var getFdNameOrder = (fdName) => {
+ if (fdName === "stdout" || fdName === "stderr") {
+ return 0;
+ }
+ return fdName === "all" ? 2 : 1;
+};
+var parseFdName = (fdName, optionName, optionArray) => {
+ if (fdName === "ipc") {
+ return [optionArray.length - 1];
+ }
+ const fdNumber = parseFd(fdName);
+ if (fdNumber === void 0 || fdNumber === 0) {
+ throw new TypeError(`"${optionName}.${fdName}" is invalid.
+It must be "${optionName}.stdout", "${optionName}.stderr", "${optionName}.all", "${optionName}.ipc", or "${optionName}.fd3", "${optionName}.fd4" (and so on).`);
+ }
+ if (fdNumber >= optionArray.length) {
+ throw new TypeError(`"${optionName}.${fdName}" is invalid: that file descriptor does not exist.
+Please set the "stdio" option to ensure that file descriptor exists.`);
+ }
+ return fdNumber === "all" ? [1, 2] : [fdNumber];
+};
+var parseFd = (fdName) => {
+ if (fdName === "all") {
+ return fdName;
+ }
+ if (STANDARD_STREAMS_ALIASES.includes(fdName)) {
+ return STANDARD_STREAMS_ALIASES.indexOf(fdName);
+ }
+ const regexpResult = FD_REGEXP.exec(fdName);
+ if (regexpResult !== null) {
+ return Number(regexpResult[1]);
+ }
+};
+var FD_REGEXP = /^fd(\d+)$/;
+var addDefaultValue = (optionArray, optionName) => optionArray.map((optionValue) => optionValue === void 0 ? DEFAULT_OPTIONS[optionName] : optionValue);
+var verboseDefault = (0, import_node_util.debuglog)("execa").enabled ? "full" : "none";
+var DEFAULT_OPTIONS = {
+ lines: false,
+ buffer: true,
+ maxBuffer: 1e3 * 1e3 * 100,
+ verbose: verboseDefault,
+ stripFinalNewline: true
+};
+var FD_SPECIFIC_OPTIONS = ["lines", "buffer", "maxBuffer", "verbose", "stripFinalNewline"];
+var getFdSpecificValue = (optionArray, fdNumber) => fdNumber === "ipc" ? optionArray.at(-1) : optionArray[fdNumber];
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/verbose/values.js
+var isVerbose = ({ verbose }, fdNumber) => getFdVerbose(verbose, fdNumber) !== "none";
+var isFullVerbose = ({ verbose }, fdNumber) => !["none", "short"].includes(getFdVerbose(verbose, fdNumber));
+var getVerboseFunction = ({ verbose }, fdNumber) => {
+ const fdVerbose = getFdVerbose(verbose, fdNumber);
+ return isVerboseFunction(fdVerbose) ? fdVerbose : void 0;
+};
+var getFdVerbose = (verbose, fdNumber) => fdNumber === void 0 ? getFdGenericVerbose(verbose) : getFdSpecificValue(verbose, fdNumber);
+var getFdGenericVerbose = (verbose) => verbose.find((fdVerbose) => isVerboseFunction(fdVerbose)) ?? VERBOSE_VALUES.findLast((fdVerbose) => verbose.includes(fdVerbose));
+var isVerboseFunction = (fdVerbose) => typeof fdVerbose === "function";
+var VERBOSE_VALUES = ["none", "short", "full"];
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/verbose/log.js
+var import_node_util3 = require("node:util");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/arguments/escape.js
+var import_node_process2 = require("node:process");
+var import_node_util2 = require("node:util");
+var joinCommand = (filePath, rawArguments) => {
+ const fileAndArguments = [filePath, ...rawArguments];
+ const command = fileAndArguments.join(" ");
+ const escapedCommand = fileAndArguments.map((fileAndArgument) => quoteString(escapeControlCharacters(fileAndArgument))).join(" ");
+ return { command, escapedCommand };
+};
+var escapeLines = (lines) => (0, import_node_util2.stripVTControlCharacters)(lines).split("\n").map((line) => escapeControlCharacters(line)).join("\n");
+var escapeControlCharacters = (line) => line.replaceAll(SPECIAL_CHAR_REGEXP, (character) => escapeControlCharacter(character));
+var escapeControlCharacter = (character) => {
+ const commonEscape = COMMON_ESCAPES[character];
+ if (commonEscape !== void 0) {
+ return commonEscape;
+ }
+ const codepoint = character.codePointAt(0);
+ const codepointHex = codepoint.toString(16);
+ return codepoint <= ASTRAL_START ? `\\u${codepointHex.padStart(4, "0")}` : `\\U${codepointHex}`;
+};
+var getSpecialCharRegExp = () => {
+ try {
+ return new RegExp("\\p{Separator}|\\p{Other}", "gu");
+ } catch {
+ return /[\s\u0000-\u001F\u007F-\u009F\u00AD]/g;
+ }
+};
+var SPECIAL_CHAR_REGEXP = getSpecialCharRegExp();
+var COMMON_ESCAPES = {
+ " ": " ",
+ "\b": "\\b",
+ "\f": "\\f",
+ "\n": "\\n",
+ "\r": "\\r",
+ " ": "\\t"
+};
+var ASTRAL_START = 65535;
+var quoteString = (escapedArgument) => {
+ if (NO_ESCAPE_REGEXP.test(escapedArgument)) {
+ return escapedArgument;
+ }
+ return import_node_process2.platform === "win32" ? `"${escapedArgument.replaceAll('"', '""')}"` : `'${escapedArgument.replaceAll("'", "'\\''")}'`;
+};
+var NO_ESCAPE_REGEXP = /^[\w./-]+$/;
+
+// node_modules/.pnpm/is-unicode-supported@2.1.0/node_modules/is-unicode-supported/index.js
+var import_node_process3 = __toESM(require("node:process"), 1);
+function isUnicodeSupported() {
+ const { env } = import_node_process3.default;
+ const { TERM, TERM_PROGRAM } = env;
+ if (import_node_process3.default.platform !== "win32") {
+ return TERM !== "linux";
+ }
+ return Boolean(env.WT_SESSION) || Boolean(env.TERMINUS_SUBLIME) || env.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+
+// node_modules/.pnpm/figures@6.1.0/node_modules/figures/index.js
+var common = {
+ circleQuestionMark: "(?)",
+ questionMarkPrefix: "(?)",
+ square: "\u2588",
+ squareDarkShade: "\u2593",
+ squareMediumShade: "\u2592",
+ squareLightShade: "\u2591",
+ squareTop: "\u2580",
+ squareBottom: "\u2584",
+ squareLeft: "\u258C",
+ squareRight: "\u2590",
+ squareCenter: "\u25A0",
+ bullet: "\u25CF",
+ dot: "\u2024",
+ ellipsis: "\u2026",
+ pointerSmall: "\u203A",
+ triangleUp: "\u25B2",
+ triangleUpSmall: "\u25B4",
+ triangleDown: "\u25BC",
+ triangleDownSmall: "\u25BE",
+ triangleLeftSmall: "\u25C2",
+ triangleRightSmall: "\u25B8",
+ home: "\u2302",
+ heart: "\u2665",
+ musicNote: "\u266A",
+ musicNoteBeamed: "\u266B",
+ arrowUp: "\u2191",
+ arrowDown: "\u2193",
+ arrowLeft: "\u2190",
+ arrowRight: "\u2192",
+ arrowLeftRight: "\u2194",
+ arrowUpDown: "\u2195",
+ almostEqual: "\u2248",
+ notEqual: "\u2260",
+ lessOrEqual: "\u2264",
+ greaterOrEqual: "\u2265",
+ identical: "\u2261",
+ infinity: "\u221E",
+ subscriptZero: "\u2080",
+ subscriptOne: "\u2081",
+ subscriptTwo: "\u2082",
+ subscriptThree: "\u2083",
+ subscriptFour: "\u2084",
+ subscriptFive: "\u2085",
+ subscriptSix: "\u2086",
+ subscriptSeven: "\u2087",
+ subscriptEight: "\u2088",
+ subscriptNine: "\u2089",
+ oneHalf: "\xBD",
+ oneThird: "\u2153",
+ oneQuarter: "\xBC",
+ oneFifth: "\u2155",
+ oneSixth: "\u2159",
+ oneEighth: "\u215B",
+ twoThirds: "\u2154",
+ twoFifths: "\u2156",
+ threeQuarters: "\xBE",
+ threeFifths: "\u2157",
+ threeEighths: "\u215C",
+ fourFifths: "\u2158",
+ fiveSixths: "\u215A",
+ fiveEighths: "\u215D",
+ sevenEighths: "\u215E",
+ line: "\u2500",
+ lineBold: "\u2501",
+ lineDouble: "\u2550",
+ lineDashed0: "\u2504",
+ lineDashed1: "\u2505",
+ lineDashed2: "\u2508",
+ lineDashed3: "\u2509",
+ lineDashed4: "\u254C",
+ lineDashed5: "\u254D",
+ lineDashed6: "\u2574",
+ lineDashed7: "\u2576",
+ lineDashed8: "\u2578",
+ lineDashed9: "\u257A",
+ lineDashed10: "\u257C",
+ lineDashed11: "\u257E",
+ lineDashed12: "\u2212",
+ lineDashed13: "\u2013",
+ lineDashed14: "\u2010",
+ lineDashed15: "\u2043",
+ lineVertical: "\u2502",
+ lineVerticalBold: "\u2503",
+ lineVerticalDouble: "\u2551",
+ lineVerticalDashed0: "\u2506",
+ lineVerticalDashed1: "\u2507",
+ lineVerticalDashed2: "\u250A",
+ lineVerticalDashed3: "\u250B",
+ lineVerticalDashed4: "\u254E",
+ lineVerticalDashed5: "\u254F",
+ lineVerticalDashed6: "\u2575",
+ lineVerticalDashed7: "\u2577",
+ lineVerticalDashed8: "\u2579",
+ lineVerticalDashed9: "\u257B",
+ lineVerticalDashed10: "\u257D",
+ lineVerticalDashed11: "\u257F",
+ lineDownLeft: "\u2510",
+ lineDownLeftArc: "\u256E",
+ lineDownBoldLeftBold: "\u2513",
+ lineDownBoldLeft: "\u2512",
+ lineDownLeftBold: "\u2511",
+ lineDownDoubleLeftDouble: "\u2557",
+ lineDownDoubleLeft: "\u2556",
+ lineDownLeftDouble: "\u2555",
+ lineDownRight: "\u250C",
+ lineDownRightArc: "\u256D",
+ lineDownBoldRightBold: "\u250F",
+ lineDownBoldRight: "\u250E",
+ lineDownRightBold: "\u250D",
+ lineDownDoubleRightDouble: "\u2554",
+ lineDownDoubleRight: "\u2553",
+ lineDownRightDouble: "\u2552",
+ lineUpLeft: "\u2518",
+ lineUpLeftArc: "\u256F",
+ lineUpBoldLeftBold: "\u251B",
+ lineUpBoldLeft: "\u251A",
+ lineUpLeftBold: "\u2519",
+ lineUpDoubleLeftDouble: "\u255D",
+ lineUpDoubleLeft: "\u255C",
+ lineUpLeftDouble: "\u255B",
+ lineUpRight: "\u2514",
+ lineUpRightArc: "\u2570",
+ lineUpBoldRightBold: "\u2517",
+ lineUpBoldRight: "\u2516",
+ lineUpRightBold: "\u2515",
+ lineUpDoubleRightDouble: "\u255A",
+ lineUpDoubleRight: "\u2559",
+ lineUpRightDouble: "\u2558",
+ lineUpDownLeft: "\u2524",
+ lineUpBoldDownBoldLeftBold: "\u252B",
+ lineUpBoldDownBoldLeft: "\u2528",
+ lineUpDownLeftBold: "\u2525",
+ lineUpBoldDownLeftBold: "\u2529",
+ lineUpDownBoldLeftBold: "\u252A",
+ lineUpDownBoldLeft: "\u2527",
+ lineUpBoldDownLeft: "\u2526",
+ lineUpDoubleDownDoubleLeftDouble: "\u2563",
+ lineUpDoubleDownDoubleLeft: "\u2562",
+ lineUpDownLeftDouble: "\u2561",
+ lineUpDownRight: "\u251C",
+ lineUpBoldDownBoldRightBold: "\u2523",
+ lineUpBoldDownBoldRight: "\u2520",
+ lineUpDownRightBold: "\u251D",
+ lineUpBoldDownRightBold: "\u2521",
+ lineUpDownBoldRightBold: "\u2522",
+ lineUpDownBoldRight: "\u251F",
+ lineUpBoldDownRight: "\u251E",
+ lineUpDoubleDownDoubleRightDouble: "\u2560",
+ lineUpDoubleDownDoubleRight: "\u255F",
+ lineUpDownRightDouble: "\u255E",
+ lineDownLeftRight: "\u252C",
+ lineDownBoldLeftBoldRightBold: "\u2533",
+ lineDownLeftBoldRightBold: "\u252F",
+ lineDownBoldLeftRight: "\u2530",
+ lineDownBoldLeftBoldRight: "\u2531",
+ lineDownBoldLeftRightBold: "\u2532",
+ lineDownLeftRightBold: "\u252E",
+ lineDownLeftBoldRight: "\u252D",
+ lineDownDoubleLeftDoubleRightDouble: "\u2566",
+ lineDownDoubleLeftRight: "\u2565",
+ lineDownLeftDoubleRightDouble: "\u2564",
+ lineUpLeftRight: "\u2534",
+ lineUpBoldLeftBoldRightBold: "\u253B",
+ lineUpLeftBoldRightBold: "\u2537",
+ lineUpBoldLeftRight: "\u2538",
+ lineUpBoldLeftBoldRight: "\u2539",
+ lineUpBoldLeftRightBold: "\u253A",
+ lineUpLeftRightBold: "\u2536",
+ lineUpLeftBoldRight: "\u2535",
+ lineUpDoubleLeftDoubleRightDouble: "\u2569",
+ lineUpDoubleLeftRight: "\u2568",
+ lineUpLeftDoubleRightDouble: "\u2567",
+ lineUpDownLeftRight: "\u253C",
+ lineUpBoldDownBoldLeftBoldRightBold: "\u254B",
+ lineUpDownBoldLeftBoldRightBold: "\u2548",
+ lineUpBoldDownLeftBoldRightBold: "\u2547",
+ lineUpBoldDownBoldLeftRightBold: "\u254A",
+ lineUpBoldDownBoldLeftBoldRight: "\u2549",
+ lineUpBoldDownLeftRight: "\u2540",
+ lineUpDownBoldLeftRight: "\u2541",
+ lineUpDownLeftBoldRight: "\u253D",
+ lineUpDownLeftRightBold: "\u253E",
+ lineUpBoldDownBoldLeftRight: "\u2542",
+ lineUpDownLeftBoldRightBold: "\u253F",
+ lineUpBoldDownLeftBoldRight: "\u2543",
+ lineUpBoldDownLeftRightBold: "\u2544",
+ lineUpDownBoldLeftBoldRight: "\u2545",
+ lineUpDownBoldLeftRightBold: "\u2546",
+ lineUpDoubleDownDoubleLeftDoubleRightDouble: "\u256C",
+ lineUpDoubleDownDoubleLeftRight: "\u256B",
+ lineUpDownLeftDoubleRightDouble: "\u256A",
+ lineCross: "\u2573",
+ lineBackslash: "\u2572",
+ lineSlash: "\u2571"
+};
+var specialMainSymbols = {
+ tick: "\u2714",
+ info: "\u2139",
+ warning: "\u26A0",
+ cross: "\u2718",
+ squareSmall: "\u25FB",
+ squareSmallFilled: "\u25FC",
+ circle: "\u25EF",
+ circleFilled: "\u25C9",
+ circleDotted: "\u25CC",
+ circleDouble: "\u25CE",
+ circleCircle: "\u24DE",
+ circleCross: "\u24E7",
+ circlePipe: "\u24BE",
+ radioOn: "\u25C9",
+ radioOff: "\u25EF",
+ checkboxOn: "\u2612",
+ checkboxOff: "\u2610",
+ checkboxCircleOn: "\u24E7",
+ checkboxCircleOff: "\u24BE",
+ pointer: "\u276F",
+ triangleUpOutline: "\u25B3",
+ triangleLeft: "\u25C0",
+ triangleRight: "\u25B6",
+ lozenge: "\u25C6",
+ lozengeOutline: "\u25C7",
+ hamburger: "\u2630",
+ smiley: "\u32E1",
+ mustache: "\u0DF4",
+ star: "\u2605",
+ play: "\u25B6",
+ nodejs: "\u2B22",
+ oneSeventh: "\u2150",
+ oneNinth: "\u2151",
+ oneTenth: "\u2152"
+};
+var specialFallbackSymbols = {
+ tick: "\u221A",
+ info: "i",
+ warning: "\u203C",
+ cross: "\xD7",
+ squareSmall: "\u25A1",
+ squareSmallFilled: "\u25A0",
+ circle: "( )",
+ circleFilled: "(*)",
+ circleDotted: "( )",
+ circleDouble: "( )",
+ circleCircle: "(\u25CB)",
+ circleCross: "(\xD7)",
+ circlePipe: "(\u2502)",
+ radioOn: "(*)",
+ radioOff: "( )",
+ checkboxOn: "[\xD7]",
+ checkboxOff: "[ ]",
+ checkboxCircleOn: "(\xD7)",
+ checkboxCircleOff: "( )",
+ pointer: ">",
+ triangleUpOutline: "\u2206",
+ triangleLeft: "\u25C4",
+ triangleRight: "\u25BA",
+ lozenge: "\u2666",
+ lozengeOutline: "\u25CA",
+ hamburger: "\u2261",
+ smiley: "\u263A",
+ mustache: "\u250C\u2500\u2510",
+ star: "\u2736",
+ play: "\u25BA",
+ nodejs: "\u2666",
+ oneSeventh: "1/7",
+ oneNinth: "1/9",
+ oneTenth: "1/10"
+};
+var mainSymbols = { ...common, ...specialMainSymbols };
+var fallbackSymbols = { ...common, ...specialFallbackSymbols };
+var shouldUseMain = isUnicodeSupported();
+var figures = shouldUseMain ? mainSymbols : fallbackSymbols;
+var figures_default = figures;
+var replacements = Object.entries(specialMainSymbols);
+
+// node_modules/.pnpm/yoctocolors@2.1.1/node_modules/yoctocolors/base.js
+var import_node_tty = __toESM(require("node:tty"), 1);
+var hasColors = import_node_tty.default?.WriteStream?.prototype?.hasColors?.() ?? false;
+var format = (open, close) => {
+ if (!hasColors) {
+ return (input) => input;
+ }
+ const openCode = `\x1B[${open}m`;
+ const closeCode = `\x1B[${close}m`;
+ return (input) => {
+ const string = input + "";
+ let index = string.indexOf(closeCode);
+ if (index === -1) {
+ return openCode + string + closeCode;
+ }
+ let result = openCode;
+ let lastIndex = 0;
+ while (index !== -1) {
+ result += string.slice(lastIndex, index) + openCode;
+ lastIndex = index + closeCode.length;
+ index = string.indexOf(closeCode, lastIndex);
+ }
+ result += string.slice(lastIndex) + closeCode;
+ return result;
+ };
+};
+var reset = format(0, 0);
+var bold = format(1, 22);
+var dim = format(2, 22);
+var italic = format(3, 23);
+var underline = format(4, 24);
+var overline = format(53, 55);
+var inverse = format(7, 27);
+var hidden = format(8, 28);
+var strikethrough = format(9, 29);
+var black = format(30, 39);
+var red = format(31, 39);
+var green = format(32, 39);
+var yellow = format(33, 39);
+var blue = format(34, 39);
+var magenta = format(35, 39);
+var cyan = format(36, 39);
+var white = format(37, 39);
+var gray = format(90, 39);
+var bgBlack = format(40, 49);
+var bgRed = format(41, 49);
+var bgGreen = format(42, 49);
+var bgYellow = format(43, 49);
+var bgBlue = format(44, 49);
+var bgMagenta = format(45, 49);
+var bgCyan = format(46, 49);
+var bgWhite = format(47, 49);
+var bgGray = format(100, 49);
+var redBright = format(91, 39);
+var greenBright = format(92, 39);
+var yellowBright = format(93, 39);
+var blueBright = format(94, 39);
+var magentaBright = format(95, 39);
+var cyanBright = format(96, 39);
+var whiteBright = format(97, 39);
+var bgRedBright = format(101, 49);
+var bgGreenBright = format(102, 49);
+var bgYellowBright = format(103, 49);
+var bgBlueBright = format(104, 49);
+var bgMagentaBright = format(105, 49);
+var bgCyanBright = format(106, 49);
+var bgWhiteBright = format(107, 49);
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/verbose/default.js
+var defaultVerboseFunction = ({
+ type,
+ message,
+ timestamp,
+ piped,
+ commandId,
+ result: { failed = false } = {},
+ options: { reject = true }
+}) => {
+ const timestampString = serializeTimestamp(timestamp);
+ const icon = ICONS[type]({ failed, reject, piped });
+ const color = COLORS[type]({ reject });
+ return `${gray(`[${timestampString}]`)} ${gray(`[${commandId}]`)} ${color(icon)} ${color(message)}`;
+};
+var serializeTimestamp = (timestamp) => `${padField(timestamp.getHours(), 2)}:${padField(timestamp.getMinutes(), 2)}:${padField(timestamp.getSeconds(), 2)}.${padField(timestamp.getMilliseconds(), 3)}`;
+var padField = (field, padding) => String(field).padStart(padding, "0");
+var getFinalIcon = ({ failed, reject }) => {
+ if (!failed) {
+ return figures_default.tick;
+ }
+ return reject ? figures_default.cross : figures_default.warning;
+};
+var ICONS = {
+ command: ({ piped }) => piped ? "|" : "$",
+ output: () => " ",
+ ipc: () => "*",
+ error: getFinalIcon,
+ duration: getFinalIcon
+};
+var identity = (string) => string;
+var COLORS = {
+ command: () => bold,
+ output: () => identity,
+ ipc: () => identity,
+ error: ({ reject }) => reject ? redBright : yellowBright,
+ duration: () => gray
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/verbose/custom.js
+var applyVerboseOnLines = (printedLines, verboseInfo, fdNumber) => {
+ const verboseFunction = getVerboseFunction(verboseInfo, fdNumber);
+ return printedLines.map(({ verboseLine, verboseObject }) => applyVerboseFunction(verboseLine, verboseObject, verboseFunction)).filter((printedLine) => printedLine !== void 0).map((printedLine) => appendNewline(printedLine)).join("");
+};
+var applyVerboseFunction = (verboseLine, verboseObject, verboseFunction) => {
+ if (verboseFunction === void 0) {
+ return verboseLine;
+ }
+ const printedLine = verboseFunction(verboseLine, verboseObject);
+ if (typeof printedLine === "string") {
+ return printedLine;
+ }
+};
+var appendNewline = (printedLine) => printedLine.endsWith("\n") ? printedLine : `${printedLine}
+`;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/verbose/log.js
+var verboseLog = ({ type, verboseMessage, fdNumber, verboseInfo, result }) => {
+ const verboseObject = getVerboseObject({ type, result, verboseInfo });
+ const printedLines = getPrintedLines(verboseMessage, verboseObject);
+ const finalLines = applyVerboseOnLines(printedLines, verboseInfo, fdNumber);
+ if (finalLines !== "") {
+ console.warn(finalLines.slice(0, -1));
+ }
+};
+var getVerboseObject = ({
+ type,
+ result,
+ verboseInfo: { escapedCommand, commandId, rawOptions: { piped = false, ...options } }
+}) => ({
+ type,
+ escapedCommand,
+ commandId: `${commandId}`,
+ timestamp: /* @__PURE__ */ new Date(),
+ piped,
+ result,
+ options
+});
+var getPrintedLines = (verboseMessage, verboseObject) => verboseMessage.split("\n").map((message) => getPrintedLine({ ...verboseObject, message }));
+var getPrintedLine = (verboseObject) => {
+ const verboseLine = defaultVerboseFunction(verboseObject);
+ return { verboseLine, verboseObject };
+};
+var serializeVerboseMessage = (message) => {
+ const messageString = typeof message === "string" ? message : (0, import_node_util3.inspect)(message);
+ const escapedMessage = escapeLines(messageString);
+ return escapedMessage.replaceAll(" ", " ".repeat(TAB_SIZE));
+};
+var TAB_SIZE = 2;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/verbose/start.js
+var logCommand = (escapedCommand, verboseInfo) => {
+ if (!isVerbose(verboseInfo)) {
+ return;
+ }
+ verboseLog({
+ type: "command",
+ verboseMessage: escapedCommand,
+ verboseInfo
+ });
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/verbose/info.js
+var getVerboseInfo = (verbose, escapedCommand, rawOptions) => {
+ validateVerbose(verbose);
+ const commandId = getCommandId(verbose);
+ return {
+ verbose,
+ escapedCommand,
+ commandId,
+ rawOptions
+ };
+};
+var getCommandId = (verbose) => isVerbose({ verbose }) ? COMMAND_ID++ : void 0;
+var COMMAND_ID = 0n;
+var validateVerbose = (verbose) => {
+ for (const fdVerbose of verbose) {
+ if (fdVerbose === false) {
+ throw new TypeError(`The "verbose: false" option was renamed to "verbose: 'none'".`);
+ }
+ if (fdVerbose === true) {
+ throw new TypeError(`The "verbose: true" option was renamed to "verbose: 'short'".`);
+ }
+ if (!VERBOSE_VALUES.includes(fdVerbose) && !isVerboseFunction(fdVerbose)) {
+ const allowedValues = VERBOSE_VALUES.map((allowedValue) => `'${allowedValue}'`).join(", ");
+ throw new TypeError(`The "verbose" option must not be ${fdVerbose}. Allowed values are: ${allowedValues} or a function.`);
+ }
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/return/duration.js
+var import_node_process4 = require("node:process");
+var getStartTime = () => import_node_process4.hrtime.bigint();
+var getDurationMs = (startTime) => Number(import_node_process4.hrtime.bigint() - startTime) / 1e6;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/arguments/command.js
+var handleCommand = (filePath, rawArguments, rawOptions) => {
+ const startTime = getStartTime();
+ const { command, escapedCommand } = joinCommand(filePath, rawArguments);
+ const verbose = normalizeFdSpecificOption(rawOptions, "verbose");
+ const verboseInfo = getVerboseInfo(verbose, escapedCommand, { ...rawOptions });
+ logCommand(escapedCommand, verboseInfo);
+ return {
+ command,
+ escapedCommand,
+ startTime,
+ verboseInfo
+ };
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/arguments/options.js
+var import_node_path5 = __toESM(require("node:path"), 1);
+var import_node_process8 = __toESM(require("node:process"), 1);
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+
+// node_modules/.pnpm/npm-run-path@6.0.0/node_modules/npm-run-path/index.js
+var import_node_process5 = __toESM(require("node:process"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+
+// node_modules/.pnpm/path-key@4.0.0/node_modules/path-key/index.js
+function pathKey(options = {}) {
+ const {
+ env = process.env,
+ platform: platform2 = process.platform
+ } = options;
+ if (platform2 !== "win32") {
+ return "PATH";
+ }
+ return Object.keys(env).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+}
+
+// node_modules/.pnpm/unicorn-magic@0.3.0/node_modules/unicorn-magic/node.js
+var import_node_util4 = require("node:util");
+var import_node_child_process2 = require("node:child_process");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url2 = require("node:url");
+var execFileOriginal = (0, import_node_util4.promisify)(import_node_child_process2.execFile);
+function toPath(urlOrPath) {
+ return urlOrPath instanceof URL ? (0, import_node_url2.fileURLToPath)(urlOrPath) : urlOrPath;
+}
+function traversePathUp(startPath) {
+ return {
+ *[Symbol.iterator]() {
+ let currentPath = import_node_path.default.resolve(toPath(startPath));
+ let previousPath;
+ while (previousPath !== currentPath) {
+ yield currentPath;
+ previousPath = currentPath;
+ currentPath = import_node_path.default.resolve(currentPath, "..");
+ }
+ }
+ };
+}
+var TEN_MEGABYTES_IN_BYTES = 10 * 1024 * 1024;
+
+// node_modules/.pnpm/npm-run-path@6.0.0/node_modules/npm-run-path/index.js
+var npmRunPath = ({
+ cwd = import_node_process5.default.cwd(),
+ path: pathOption = import_node_process5.default.env[pathKey()],
+ preferLocal = true,
+ execPath: execPath2 = import_node_process5.default.execPath,
+ addExecPath = true
+} = {}) => {
+ const cwdPath = import_node_path2.default.resolve(toPath(cwd));
+ const result = [];
+ const pathParts = pathOption.split(import_node_path2.default.delimiter);
+ if (preferLocal) {
+ applyPreferLocal(result, pathParts, cwdPath);
+ }
+ if (addExecPath) {
+ applyExecPath(result, pathParts, execPath2, cwdPath);
+ }
+ return pathOption === "" || pathOption === import_node_path2.default.delimiter ? `${result.join(import_node_path2.default.delimiter)}${pathOption}` : [...result, pathOption].join(import_node_path2.default.delimiter);
+};
+var applyPreferLocal = (result, pathParts, cwdPath) => {
+ for (const directory of traversePathUp(cwdPath)) {
+ const pathPart = import_node_path2.default.join(directory, "node_modules/.bin");
+ if (!pathParts.includes(pathPart)) {
+ result.push(pathPart);
+ }
+ }
+};
+var applyExecPath = (result, pathParts, execPath2, cwdPath) => {
+ const pathPart = import_node_path2.default.resolve(cwdPath, toPath(execPath2), "..");
+ if (!pathParts.includes(pathPart)) {
+ result.push(pathPart);
+ }
+};
+var npmRunPathEnv = ({ env = import_node_process5.default.env, ...options } = {}) => {
+ env = { ...env };
+ const pathName = pathKey({ env });
+ options.path = env[pathName];
+ env[pathName] = npmRunPath(options);
+ return env;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/terminate/kill.js
+var import_promises = require("node:timers/promises");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/return/final-error.js
+var getFinalError = (originalError, message, isSync) => {
+ const ErrorClass = isSync ? ExecaSyncError : ExecaError;
+ const options = originalError instanceof DiscardedError ? {} : { cause: originalError };
+ return new ErrorClass(message, options);
+};
+var DiscardedError = class extends Error {
+};
+var setErrorName = (ErrorClass, value) => {
+ Object.defineProperty(ErrorClass.prototype, "name", {
+ value,
+ writable: true,
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(ErrorClass.prototype, execaErrorSymbol, {
+ value: true,
+ writable: false,
+ enumerable: false,
+ configurable: false
+ });
+};
+var isExecaError = (error) => isErrorInstance(error) && execaErrorSymbol in error;
+var execaErrorSymbol = Symbol("isExecaError");
+var isErrorInstance = (value) => Object.prototype.toString.call(value) === "[object Error]";
+var ExecaError = class extends Error {
+};
+setErrorName(ExecaError, ExecaError.name);
+var ExecaSyncError = class extends Error {
+};
+setErrorName(ExecaSyncError, ExecaSyncError.name);
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/terminate/signal.js
+var import_node_os3 = require("node:os");
+
+// node_modules/.pnpm/human-signals@8.0.1/node_modules/human-signals/build/src/main.js
+var import_node_os2 = require("node:os");
+
+// node_modules/.pnpm/human-signals@8.0.1/node_modules/human-signals/build/src/realtime.js
+var getRealtimeSignals = () => {
+ const length = SIGRTMAX - SIGRTMIN + 1;
+ return Array.from({ length }, getRealtimeSignal);
+};
+var getRealtimeSignal = (value, index) => ({
+ name: `SIGRT${index + 1}`,
+ number: SIGRTMIN + index,
+ action: "terminate",
+ description: "Application-specific signal (realtime)",
+ standard: "posix"
+});
+var SIGRTMIN = 34;
+var SIGRTMAX = 64;
+
+// node_modules/.pnpm/human-signals@8.0.1/node_modules/human-signals/build/src/signals.js
+var import_node_os = require("node:os");
+
+// node_modules/.pnpm/human-signals@8.0.1/node_modules/human-signals/build/src/core.js
+var SIGNALS = [
+ {
+ name: "SIGHUP",
+ number: 1,
+ action: "terminate",
+ description: "Terminal closed",
+ standard: "posix"
+ },
+ {
+ name: "SIGINT",
+ number: 2,
+ action: "terminate",
+ description: "User interruption with CTRL-C",
+ standard: "ansi"
+ },
+ {
+ name: "SIGQUIT",
+ number: 3,
+ action: "core",
+ description: "User interruption with CTRL-\\",
+ standard: "posix"
+ },
+ {
+ name: "SIGILL",
+ number: 4,
+ action: "core",
+ description: "Invalid machine instruction",
+ standard: "ansi"
+ },
+ {
+ name: "SIGTRAP",
+ number: 5,
+ action: "core",
+ description: "Debugger breakpoint",
+ standard: "posix"
+ },
+ {
+ name: "SIGABRT",
+ number: 6,
+ action: "core",
+ description: "Aborted",
+ standard: "ansi"
+ },
+ {
+ name: "SIGIOT",
+ number: 6,
+ action: "core",
+ description: "Aborted",
+ standard: "bsd"
+ },
+ {
+ name: "SIGBUS",
+ number: 7,
+ action: "core",
+ description: "Bus error due to misaligned, non-existing address or paging error",
+ standard: "bsd"
+ },
+ {
+ name: "SIGEMT",
+ number: 7,
+ action: "terminate",
+ description: "Command should be emulated but is not implemented",
+ standard: "other"
+ },
+ {
+ name: "SIGFPE",
+ number: 8,
+ action: "core",
+ description: "Floating point arithmetic error",
+ standard: "ansi"
+ },
+ {
+ name: "SIGKILL",
+ number: 9,
+ action: "terminate",
+ description: "Forced termination",
+ standard: "posix",
+ forced: true
+ },
+ {
+ name: "SIGUSR1",
+ number: 10,
+ action: "terminate",
+ description: "Application-specific signal",
+ standard: "posix"
+ },
+ {
+ name: "SIGSEGV",
+ number: 11,
+ action: "core",
+ description: "Segmentation fault",
+ standard: "ansi"
+ },
+ {
+ name: "SIGUSR2",
+ number: 12,
+ action: "terminate",
+ description: "Application-specific signal",
+ standard: "posix"
+ },
+ {
+ name: "SIGPIPE",
+ number: 13,
+ action: "terminate",
+ description: "Broken pipe or socket",
+ standard: "posix"
+ },
+ {
+ name: "SIGALRM",
+ number: 14,
+ action: "terminate",
+ description: "Timeout or timer",
+ standard: "posix"
+ },
+ {
+ name: "SIGTERM",
+ number: 15,
+ action: "terminate",
+ description: "Termination",
+ standard: "ansi"
+ },
+ {
+ name: "SIGSTKFLT",
+ number: 16,
+ action: "terminate",
+ description: "Stack is empty or overflowed",
+ standard: "other"
+ },
+ {
+ name: "SIGCHLD",
+ number: 17,
+ action: "ignore",
+ description: "Child process terminated, paused or unpaused",
+ standard: "posix"
+ },
+ {
+ name: "SIGCLD",
+ number: 17,
+ action: "ignore",
+ description: "Child process terminated, paused or unpaused",
+ standard: "other"
+ },
+ {
+ name: "SIGCONT",
+ number: 18,
+ action: "unpause",
+ description: "Unpaused",
+ standard: "posix",
+ forced: true
+ },
+ {
+ name: "SIGSTOP",
+ number: 19,
+ action: "pause",
+ description: "Paused",
+ standard: "posix",
+ forced: true
+ },
+ {
+ name: "SIGTSTP",
+ number: 20,
+ action: "pause",
+ description: 'Paused using CTRL-Z or "suspend"',
+ standard: "posix"
+ },
+ {
+ name: "SIGTTIN",
+ number: 21,
+ action: "pause",
+ description: "Background process cannot read terminal input",
+ standard: "posix"
+ },
+ {
+ name: "SIGBREAK",
+ number: 21,
+ action: "terminate",
+ description: "User interruption with CTRL-BREAK",
+ standard: "other"
+ },
+ {
+ name: "SIGTTOU",
+ number: 22,
+ action: "pause",
+ description: "Background process cannot write to terminal output",
+ standard: "posix"
+ },
+ {
+ name: "SIGURG",
+ number: 23,
+ action: "ignore",
+ description: "Socket received out-of-band data",
+ standard: "bsd"
+ },
+ {
+ name: "SIGXCPU",
+ number: 24,
+ action: "core",
+ description: "Process timed out",
+ standard: "bsd"
+ },
+ {
+ name: "SIGXFSZ",
+ number: 25,
+ action: "core",
+ description: "File too big",
+ standard: "bsd"
+ },
+ {
+ name: "SIGVTALRM",
+ number: 26,
+ action: "terminate",
+ description: "Timeout or timer",
+ standard: "bsd"
+ },
+ {
+ name: "SIGPROF",
+ number: 27,
+ action: "terminate",
+ description: "Timeout or timer",
+ standard: "bsd"
+ },
+ {
+ name: "SIGWINCH",
+ number: 28,
+ action: "ignore",
+ description: "Terminal window size changed",
+ standard: "bsd"
+ },
+ {
+ name: "SIGIO",
+ number: 29,
+ action: "terminate",
+ description: "I/O is available",
+ standard: "other"
+ },
+ {
+ name: "SIGPOLL",
+ number: 29,
+ action: "terminate",
+ description: "Watched event",
+ standard: "other"
+ },
+ {
+ name: "SIGINFO",
+ number: 29,
+ action: "ignore",
+ description: "Request for process information",
+ standard: "other"
+ },
+ {
+ name: "SIGPWR",
+ number: 30,
+ action: "terminate",
+ description: "Device running out of power",
+ standard: "systemv"
+ },
+ {
+ name: "SIGSYS",
+ number: 31,
+ action: "core",
+ description: "Invalid system call",
+ standard: "other"
+ },
+ {
+ name: "SIGUNUSED",
+ number: 31,
+ action: "terminate",
+ description: "Invalid system call",
+ standard: "other"
+ }
+];
+
+// node_modules/.pnpm/human-signals@8.0.1/node_modules/human-signals/build/src/signals.js
+var getSignals = () => {
+ const realtimeSignals = getRealtimeSignals();
+ const signals2 = [...SIGNALS, ...realtimeSignals].map(normalizeSignal);
+ return signals2;
+};
+var normalizeSignal = ({
+ name,
+ number: defaultNumber,
+ description,
+ action,
+ forced = false,
+ standard
+}) => {
+ const {
+ signals: { [name]: constantSignal }
+ } = import_node_os.constants;
+ const supported = constantSignal !== void 0;
+ const number = supported ? constantSignal : defaultNumber;
+ return { name, number, description, supported, action, forced, standard };
+};
+
+// node_modules/.pnpm/human-signals@8.0.1/node_modules/human-signals/build/src/main.js
+var getSignalsByName = () => {
+ const signals2 = getSignals();
+ return Object.fromEntries(signals2.map(getSignalByName));
+};
+var getSignalByName = ({
+ name,
+ number,
+ description,
+ supported,
+ action,
+ forced,
+ standard
+}) => [name, { name, number, description, supported, action, forced, standard }];
+var signalsByName = getSignalsByName();
+var getSignalsByNumber = () => {
+ const signals2 = getSignals();
+ const length = SIGRTMAX + 1;
+ const signalsA = Array.from(
+ { length },
+ (value, number) => getSignalByNumber(number, signals2)
+ );
+ return Object.assign({}, ...signalsA);
+};
+var getSignalByNumber = (number, signals2) => {
+ const signal = findSignalByNumber(number, signals2);
+ if (signal === void 0) {
+ return {};
+ }
+ const { name, description, supported, action, forced, standard } = signal;
+ return {
+ [number]: {
+ name,
+ number,
+ description,
+ supported,
+ action,
+ forced,
+ standard
+ }
+ };
+};
+var findSignalByNumber = (number, signals2) => {
+ const signal = signals2.find(({ name }) => import_node_os2.constants.signals[name] === number);
+ if (signal !== void 0) {
+ return signal;
+ }
+ return signals2.find((signalA) => signalA.number === number);
+};
+var signalsByNumber = getSignalsByNumber();
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/terminate/signal.js
+var normalizeKillSignal = (killSignal) => {
+ const optionName = "option `killSignal`";
+ if (killSignal === 0) {
+ throw new TypeError(`Invalid ${optionName}: 0 cannot be used.`);
+ }
+ return normalizeSignal2(killSignal, optionName);
+};
+var normalizeSignalArgument = (signal) => signal === 0 ? signal : normalizeSignal2(signal, "`subprocess.kill()`'s argument");
+var normalizeSignal2 = (signalNameOrInteger, optionName) => {
+ if (Number.isInteger(signalNameOrInteger)) {
+ return normalizeSignalInteger(signalNameOrInteger, optionName);
+ }
+ if (typeof signalNameOrInteger === "string") {
+ return normalizeSignalName(signalNameOrInteger, optionName);
+ }
+ throw new TypeError(`Invalid ${optionName} ${String(signalNameOrInteger)}: it must be a string or an integer.
+${getAvailableSignals()}`);
+};
+var normalizeSignalInteger = (signalInteger, optionName) => {
+ if (signalsIntegerToName.has(signalInteger)) {
+ return signalsIntegerToName.get(signalInteger);
+ }
+ throw new TypeError(`Invalid ${optionName} ${signalInteger}: this signal integer does not exist.
+${getAvailableSignals()}`);
+};
+var getSignalsIntegerToName = () => new Map(Object.entries(import_node_os3.constants.signals).reverse().map(([signalName, signalInteger]) => [signalInteger, signalName]));
+var signalsIntegerToName = getSignalsIntegerToName();
+var normalizeSignalName = (signalName, optionName) => {
+ if (signalName in import_node_os3.constants.signals) {
+ return signalName;
+ }
+ if (signalName.toUpperCase() in import_node_os3.constants.signals) {
+ throw new TypeError(`Invalid ${optionName} '${signalName}': please rename it to '${signalName.toUpperCase()}'.`);
+ }
+ throw new TypeError(`Invalid ${optionName} '${signalName}': this signal name does not exist.
+${getAvailableSignals()}`);
+};
+var getAvailableSignals = () => `Available signal names: ${getAvailableSignalNames()}.
+Available signal numbers: ${getAvailableSignalIntegers()}.`;
+var getAvailableSignalNames = () => Object.keys(import_node_os3.constants.signals).sort().map((signalName) => `'${signalName}'`).join(", ");
+var getAvailableSignalIntegers = () => [...new Set(Object.values(import_node_os3.constants.signals).sort((signalInteger, signalIntegerTwo) => signalInteger - signalIntegerTwo))].join(", ");
+var getSignalDescription = (signal) => signalsByName[signal].description;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/terminate/kill.js
+var normalizeForceKillAfterDelay = (forceKillAfterDelay) => {
+ if (forceKillAfterDelay === false) {
+ return forceKillAfterDelay;
+ }
+ if (forceKillAfterDelay === true) {
+ return DEFAULT_FORCE_KILL_TIMEOUT;
+ }
+ if (!Number.isFinite(forceKillAfterDelay) || forceKillAfterDelay < 0) {
+ throw new TypeError(`Expected the \`forceKillAfterDelay\` option to be a non-negative integer, got \`${forceKillAfterDelay}\` (${typeof forceKillAfterDelay})`);
+ }
+ return forceKillAfterDelay;
+};
+var DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
+var subprocessKill = ({ kill, options: { forceKillAfterDelay, killSignal }, onInternalError, context: context3, controller }, signalOrError, errorArgument) => {
+ const { signal, error } = parseKillArguments(signalOrError, errorArgument, killSignal);
+ emitKillError(error, onInternalError);
+ const killResult = kill(signal);
+ setKillTimeout({
+ kill,
+ signal,
+ forceKillAfterDelay,
+ killSignal,
+ killResult,
+ context: context3,
+ controller
+ });
+ return killResult;
+};
+var parseKillArguments = (signalOrError, errorArgument, killSignal) => {
+ const [signal = killSignal, error] = isErrorInstance(signalOrError) ? [void 0, signalOrError] : [signalOrError, errorArgument];
+ if (typeof signal !== "string" && !Number.isInteger(signal)) {
+ throw new TypeError(`The first argument must be an error instance or a signal name string/integer: ${String(signal)}`);
+ }
+ if (error !== void 0 && !isErrorInstance(error)) {
+ throw new TypeError(`The second argument is optional. If specified, it must be an error instance: ${error}`);
+ }
+ return { signal: normalizeSignalArgument(signal), error };
+};
+var emitKillError = (error, onInternalError) => {
+ if (error !== void 0) {
+ onInternalError.reject(error);
+ }
+};
+var setKillTimeout = async ({ kill, signal, forceKillAfterDelay, killSignal, killResult, context: context3, controller }) => {
+ if (signal === killSignal && killResult) {
+ killOnTimeout({
+ kill,
+ forceKillAfterDelay,
+ context: context3,
+ controllerSignal: controller.signal
+ });
+ }
+};
+var killOnTimeout = async ({ kill, forceKillAfterDelay, context: context3, controllerSignal }) => {
+ if (forceKillAfterDelay === false) {
+ return;
+ }
+ try {
+ await (0, import_promises.setTimeout)(forceKillAfterDelay, void 0, { signal: controllerSignal });
+ if (kill("SIGKILL")) {
+ context3.isForcefullyTerminated ??= true;
+ }
+ } catch {
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/utils/abort-signal.js
+var import_node_events = require("node:events");
+var onAbortedSignal = async (mainSignal, stopSignal) => {
+ if (!mainSignal.aborted) {
+ await (0, import_node_events.once)(mainSignal, "abort", { signal: stopSignal });
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/terminate/cancel.js
+var validateCancelSignal = ({ cancelSignal }) => {
+ if (cancelSignal !== void 0 && Object.prototype.toString.call(cancelSignal) !== "[object AbortSignal]") {
+ throw new Error(`The \`cancelSignal\` option must be an AbortSignal: ${String(cancelSignal)}`);
+ }
+};
+var throwOnCancel = ({ subprocess, cancelSignal, gracefulCancel, context: context3, controller }) => cancelSignal === void 0 || gracefulCancel ? [] : [terminateOnCancel(subprocess, cancelSignal, context3, controller)];
+var terminateOnCancel = async (subprocess, cancelSignal, context3, { signal }) => {
+ await onAbortedSignal(cancelSignal, signal);
+ context3.terminationReason ??= "cancel";
+ subprocess.kill();
+ throw cancelSignal.reason;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/graceful.js
+var import_promises3 = require("node:timers/promises");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/send.js
+var import_node_util5 = require("node:util");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/validation.js
+var validateIpcMethod = ({ methodName, isSubprocess, ipc, isConnected: isConnected2 }) => {
+ validateIpcOption(methodName, isSubprocess, ipc);
+ validateConnection(methodName, isSubprocess, isConnected2);
+};
+var validateIpcOption = (methodName, isSubprocess, ipc) => {
+ if (!ipc) {
+ throw new Error(`${getMethodName(methodName, isSubprocess)} can only be used if the \`ipc\` option is \`true\`.`);
+ }
+};
+var validateConnection = (methodName, isSubprocess, isConnected2) => {
+ if (!isConnected2) {
+ throw new Error(`${getMethodName(methodName, isSubprocess)} cannot be used: the ${getOtherProcessName(isSubprocess)} has already exited or disconnected.`);
+ }
+};
+var throwOnEarlyDisconnect = (isSubprocess) => {
+ throw new Error(`${getMethodName("getOneMessage", isSubprocess)} could not complete: the ${getOtherProcessName(isSubprocess)} exited or disconnected.`);
+};
+var throwOnStrictDeadlockError = (isSubprocess) => {
+ throw new Error(`${getMethodName("sendMessage", isSubprocess)} failed: the ${getOtherProcessName(isSubprocess)} is sending a message too, instead of listening to incoming messages.
+This can be fixed by both sending a message and listening to incoming messages at the same time:
+
+const [receivedMessage] = await Promise.all([
+ ${getMethodName("getOneMessage", isSubprocess)},
+ ${getMethodName("sendMessage", isSubprocess, "message, {strict: true}")},
+]);`);
+};
+var getStrictResponseError = (error, isSubprocess) => new Error(`${getMethodName("sendMessage", isSubprocess)} failed when sending an acknowledgment response to the ${getOtherProcessName(isSubprocess)}.`, { cause: error });
+var throwOnMissingStrict = (isSubprocess) => {
+ throw new Error(`${getMethodName("sendMessage", isSubprocess)} failed: the ${getOtherProcessName(isSubprocess)} is not listening to incoming messages.`);
+};
+var throwOnStrictDisconnect = (isSubprocess) => {
+ throw new Error(`${getMethodName("sendMessage", isSubprocess)} failed: the ${getOtherProcessName(isSubprocess)} exited without listening to incoming messages.`);
+};
+var getAbortDisconnectError = () => new Error(`\`cancelSignal\` aborted: the ${getOtherProcessName(true)} disconnected.`);
+var throwOnMissingParent = () => {
+ throw new Error("`getCancelSignal()` cannot be used without setting the `cancelSignal` subprocess option.");
+};
+var handleEpipeError = ({ error, methodName, isSubprocess }) => {
+ if (error.code === "EPIPE") {
+ throw new Error(`${getMethodName(methodName, isSubprocess)} cannot be used: the ${getOtherProcessName(isSubprocess)} is disconnecting.`, { cause: error });
+ }
+};
+var handleSerializationError = ({ error, methodName, isSubprocess, message }) => {
+ if (isSerializationError(error)) {
+ throw new Error(`${getMethodName(methodName, isSubprocess)}'s argument type is invalid: the message cannot be serialized: ${String(message)}.`, { cause: error });
+ }
+};
+var isSerializationError = ({ code, message }) => SERIALIZATION_ERROR_CODES.has(code) || SERIALIZATION_ERROR_MESSAGES.some((serializationErrorMessage) => message.includes(serializationErrorMessage));
+var SERIALIZATION_ERROR_CODES = /* @__PURE__ */ new Set([
+ // Message is `undefined`
+ "ERR_MISSING_ARGS",
+ // Message is a function, a bigint, a symbol
+ "ERR_INVALID_ARG_TYPE"
+]);
+var SERIALIZATION_ERROR_MESSAGES = [
+ // Message is a promise or a proxy, with `serialization: 'advanced'`
+ "could not be cloned",
+ // Message has cycles, with `serialization: 'json'`
+ "circular structure",
+ // Message has cycles inside toJSON(), with `serialization: 'json'`
+ "call stack size exceeded"
+];
+var getMethodName = (methodName, isSubprocess, parameters = "") => methodName === "cancelSignal" ? "`cancelSignal`'s `controller.abort()`" : `${getNamespaceName(isSubprocess)}${methodName}(${parameters})`;
+var getNamespaceName = (isSubprocess) => isSubprocess ? "" : "subprocess.";
+var getOtherProcessName = (isSubprocess) => isSubprocess ? "parent process" : "subprocess";
+var disconnect = (anyProcess) => {
+ if (anyProcess.connected) {
+ anyProcess.disconnect();
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/utils/deferred.js
+var createDeferred = () => {
+ const methods = {};
+ const promise = new Promise((resolve, reject) => {
+ Object.assign(methods, { resolve, reject });
+ });
+ return Object.assign(promise, methods);
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/arguments/fd-options.js
+var getToStream = (destination, to = "stdin") => {
+ const isWritable = true;
+ const { options, fileDescriptors } = SUBPROCESS_OPTIONS.get(destination);
+ const fdNumber = getFdNumber(fileDescriptors, to, isWritable);
+ const destinationStream = destination.stdio[fdNumber];
+ if (destinationStream === null) {
+ throw new TypeError(getInvalidStdioOptionMessage(fdNumber, to, options, isWritable));
+ }
+ return destinationStream;
+};
+var getFromStream = (source, from = "stdout") => {
+ const isWritable = false;
+ const { options, fileDescriptors } = SUBPROCESS_OPTIONS.get(source);
+ const fdNumber = getFdNumber(fileDescriptors, from, isWritable);
+ const sourceStream = fdNumber === "all" ? source.all : source.stdio[fdNumber];
+ if (sourceStream === null || sourceStream === void 0) {
+ throw new TypeError(getInvalidStdioOptionMessage(fdNumber, from, options, isWritable));
+ }
+ return sourceStream;
+};
+var SUBPROCESS_OPTIONS = /* @__PURE__ */ new WeakMap();
+var getFdNumber = (fileDescriptors, fdName, isWritable) => {
+ const fdNumber = parseFdNumber(fdName, isWritable);
+ validateFdNumber(fdNumber, fdName, isWritable, fileDescriptors);
+ return fdNumber;
+};
+var parseFdNumber = (fdName, isWritable) => {
+ const fdNumber = parseFd(fdName);
+ if (fdNumber !== void 0) {
+ return fdNumber;
+ }
+ const { validOptions, defaultValue } = isWritable ? { validOptions: '"stdin"', defaultValue: "stdin" } : { validOptions: '"stdout", "stderr", "all"', defaultValue: "stdout" };
+ throw new TypeError(`"${getOptionName(isWritable)}" must not be "${fdName}".
+It must be ${validOptions} or "fd3", "fd4" (and so on).
+It is optional and defaults to "${defaultValue}".`);
+};
+var validateFdNumber = (fdNumber, fdName, isWritable, fileDescriptors) => {
+ const fileDescriptor = fileDescriptors[getUsedDescriptor(fdNumber)];
+ if (fileDescriptor === void 0) {
+ throw new TypeError(`"${getOptionName(isWritable)}" must not be ${fdName}. That file descriptor does not exist.
+Please set the "stdio" option to ensure that file descriptor exists.`);
+ }
+ if (fileDescriptor.direction === "input" && !isWritable) {
+ throw new TypeError(`"${getOptionName(isWritable)}" must not be ${fdName}. It must be a readable stream, not writable.`);
+ }
+ if (fileDescriptor.direction !== "input" && isWritable) {
+ throw new TypeError(`"${getOptionName(isWritable)}" must not be ${fdName}. It must be a writable stream, not readable.`);
+ }
+};
+var getInvalidStdioOptionMessage = (fdNumber, fdName, options, isWritable) => {
+ if (fdNumber === "all" && !options.all) {
+ return `The "all" option must be true to use "from: 'all'".`;
+ }
+ const { optionName, optionValue } = getInvalidStdioOption(fdNumber, options);
+ return `The "${optionName}: ${serializeOptionValue(optionValue)}" option is incompatible with using "${getOptionName(isWritable)}: ${serializeOptionValue(fdName)}".
+Please set this option with "pipe" instead.`;
+};
+var getInvalidStdioOption = (fdNumber, { stdin, stdout, stderr, stdio }) => {
+ const usedDescriptor = getUsedDescriptor(fdNumber);
+ if (usedDescriptor === 0 && stdin !== void 0) {
+ return { optionName: "stdin", optionValue: stdin };
+ }
+ if (usedDescriptor === 1 && stdout !== void 0) {
+ return { optionName: "stdout", optionValue: stdout };
+ }
+ if (usedDescriptor === 2 && stderr !== void 0) {
+ return { optionName: "stderr", optionValue: stderr };
+ }
+ return { optionName: `stdio[${usedDescriptor}]`, optionValue: stdio[usedDescriptor] };
+};
+var getUsedDescriptor = (fdNumber) => fdNumber === "all" ? 1 : fdNumber;
+var getOptionName = (isWritable) => isWritable ? "to" : "from";
+var serializeOptionValue = (value) => {
+ if (typeof value === "string") {
+ return `'${value}'`;
+ }
+ return typeof value === "number" ? `${value}` : "Stream";
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/strict.js
+var import_node_events5 = require("node:events");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/utils/max-listeners.js
+var import_node_events2 = require("node:events");
+var incrementMaxListeners = (eventEmitter, maxListenersIncrement, signal) => {
+ const maxListeners = eventEmitter.getMaxListeners();
+ if (maxListeners === 0 || maxListeners === Number.POSITIVE_INFINITY) {
+ return;
+ }
+ eventEmitter.setMaxListeners(maxListeners + maxListenersIncrement);
+ (0, import_node_events2.addAbortListener)(signal, () => {
+ eventEmitter.setMaxListeners(eventEmitter.getMaxListeners() - maxListenersIncrement);
+ });
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/forward.js
+var import_node_events4 = require("node:events");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/incoming.js
+var import_node_events3 = require("node:events");
+var import_promises2 = require("node:timers/promises");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/reference.js
+var addReference = (channel, reference) => {
+ if (reference) {
+ addReferenceCount(channel);
+ }
+};
+var addReferenceCount = (channel) => {
+ channel.refCounted();
+};
+var removeReference = (channel, reference) => {
+ if (reference) {
+ removeReferenceCount(channel);
+ }
+};
+var removeReferenceCount = (channel) => {
+ channel.unrefCounted();
+};
+var undoAddedReferences = (channel, isSubprocess) => {
+ if (isSubprocess) {
+ removeReferenceCount(channel);
+ removeReferenceCount(channel);
+ }
+};
+var redoAddedReferences = (channel, isSubprocess) => {
+ if (isSubprocess) {
+ addReferenceCount(channel);
+ addReferenceCount(channel);
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/incoming.js
+var onMessage = async ({ anyProcess, channel, isSubprocess, ipcEmitter }, wrappedMessage) => {
+ if (handleStrictResponse(wrappedMessage) || handleAbort(wrappedMessage)) {
+ return;
+ }
+ if (!INCOMING_MESSAGES.has(anyProcess)) {
+ INCOMING_MESSAGES.set(anyProcess, []);
+ }
+ const incomingMessages = INCOMING_MESSAGES.get(anyProcess);
+ incomingMessages.push(wrappedMessage);
+ if (incomingMessages.length > 1) {
+ return;
+ }
+ while (incomingMessages.length > 0) {
+ await waitForOutgoingMessages(anyProcess, ipcEmitter, wrappedMessage);
+ await import_promises2.scheduler.yield();
+ const message = await handleStrictRequest({
+ wrappedMessage: incomingMessages[0],
+ anyProcess,
+ channel,
+ isSubprocess,
+ ipcEmitter
+ });
+ incomingMessages.shift();
+ ipcEmitter.emit("message", message);
+ ipcEmitter.emit("message:done");
+ }
+};
+var onDisconnect = async ({ anyProcess, channel, isSubprocess, ipcEmitter, boundOnMessage }) => {
+ abortOnDisconnect();
+ const incomingMessages = INCOMING_MESSAGES.get(anyProcess);
+ while (incomingMessages?.length > 0) {
+ await (0, import_node_events3.once)(ipcEmitter, "message:done");
+ }
+ anyProcess.removeListener("message", boundOnMessage);
+ redoAddedReferences(channel, isSubprocess);
+ ipcEmitter.connected = false;
+ ipcEmitter.emit("disconnect");
+};
+var INCOMING_MESSAGES = /* @__PURE__ */ new WeakMap();
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/forward.js
+var getIpcEmitter = (anyProcess, channel, isSubprocess) => {
+ if (IPC_EMITTERS.has(anyProcess)) {
+ return IPC_EMITTERS.get(anyProcess);
+ }
+ const ipcEmitter = new import_node_events4.EventEmitter();
+ ipcEmitter.connected = true;
+ IPC_EMITTERS.set(anyProcess, ipcEmitter);
+ forwardEvents({
+ ipcEmitter,
+ anyProcess,
+ channel,
+ isSubprocess
+ });
+ return ipcEmitter;
+};
+var IPC_EMITTERS = /* @__PURE__ */ new WeakMap();
+var forwardEvents = ({ ipcEmitter, anyProcess, channel, isSubprocess }) => {
+ const boundOnMessage = onMessage.bind(void 0, {
+ anyProcess,
+ channel,
+ isSubprocess,
+ ipcEmitter
+ });
+ anyProcess.on("message", boundOnMessage);
+ anyProcess.once("disconnect", onDisconnect.bind(void 0, {
+ anyProcess,
+ channel,
+ isSubprocess,
+ ipcEmitter,
+ boundOnMessage
+ }));
+ undoAddedReferences(channel, isSubprocess);
+};
+var isConnected = (anyProcess) => {
+ const ipcEmitter = IPC_EMITTERS.get(anyProcess);
+ return ipcEmitter === void 0 ? anyProcess.channel !== null : ipcEmitter.connected;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/strict.js
+var handleSendStrict = ({ anyProcess, channel, isSubprocess, message, strict }) => {
+ if (!strict) {
+ return message;
+ }
+ const ipcEmitter = getIpcEmitter(anyProcess, channel, isSubprocess);
+ const hasListeners = hasMessageListeners(anyProcess, ipcEmitter);
+ return {
+ id: count++,
+ type: REQUEST_TYPE,
+ message,
+ hasListeners
+ };
+};
+var count = 0n;
+var validateStrictDeadlock = (outgoingMessages, wrappedMessage) => {
+ if (wrappedMessage?.type !== REQUEST_TYPE || wrappedMessage.hasListeners) {
+ return;
+ }
+ for (const { id } of outgoingMessages) {
+ if (id !== void 0) {
+ STRICT_RESPONSES[id].resolve({ isDeadlock: true, hasListeners: false });
+ }
+ }
+};
+var handleStrictRequest = async ({ wrappedMessage, anyProcess, channel, isSubprocess, ipcEmitter }) => {
+ if (wrappedMessage?.type !== REQUEST_TYPE || !anyProcess.connected) {
+ return wrappedMessage;
+ }
+ const { id, message } = wrappedMessage;
+ const response = { id, type: RESPONSE_TYPE, message: hasMessageListeners(anyProcess, ipcEmitter) };
+ try {
+ await sendMessage({
+ anyProcess,
+ channel,
+ isSubprocess,
+ ipc: true
+ }, response);
+ } catch (error) {
+ ipcEmitter.emit("strict:error", error);
+ }
+ return message;
+};
+var handleStrictResponse = (wrappedMessage) => {
+ if (wrappedMessage?.type !== RESPONSE_TYPE) {
+ return false;
+ }
+ const { id, message: hasListeners } = wrappedMessage;
+ STRICT_RESPONSES[id]?.resolve({ isDeadlock: false, hasListeners });
+ return true;
+};
+var waitForStrictResponse = async (wrappedMessage, anyProcess, isSubprocess) => {
+ if (wrappedMessage?.type !== REQUEST_TYPE) {
+ return;
+ }
+ const deferred = createDeferred();
+ STRICT_RESPONSES[wrappedMessage.id] = deferred;
+ const controller = new AbortController();
+ try {
+ const { isDeadlock, hasListeners } = await Promise.race([
+ deferred,
+ throwOnDisconnect(anyProcess, isSubprocess, controller)
+ ]);
+ if (isDeadlock) {
+ throwOnStrictDeadlockError(isSubprocess);
+ }
+ if (!hasListeners) {
+ throwOnMissingStrict(isSubprocess);
+ }
+ } finally {
+ controller.abort();
+ delete STRICT_RESPONSES[wrappedMessage.id];
+ }
+};
+var STRICT_RESPONSES = {};
+var throwOnDisconnect = async (anyProcess, isSubprocess, { signal }) => {
+ incrementMaxListeners(anyProcess, 1, signal);
+ await (0, import_node_events5.once)(anyProcess, "disconnect", { signal });
+ throwOnStrictDisconnect(isSubprocess);
+};
+var REQUEST_TYPE = "execa:ipc:request";
+var RESPONSE_TYPE = "execa:ipc:response";
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/outgoing.js
+var startSendMessage = (anyProcess, wrappedMessage, strict) => {
+ if (!OUTGOING_MESSAGES.has(anyProcess)) {
+ OUTGOING_MESSAGES.set(anyProcess, /* @__PURE__ */ new Set());
+ }
+ const outgoingMessages = OUTGOING_MESSAGES.get(anyProcess);
+ const onMessageSent = createDeferred();
+ const id = strict ? wrappedMessage.id : void 0;
+ const outgoingMessage = { onMessageSent, id };
+ outgoingMessages.add(outgoingMessage);
+ return { outgoingMessages, outgoingMessage };
+};
+var endSendMessage = ({ outgoingMessages, outgoingMessage }) => {
+ outgoingMessages.delete(outgoingMessage);
+ outgoingMessage.onMessageSent.resolve();
+};
+var waitForOutgoingMessages = async (anyProcess, ipcEmitter, wrappedMessage) => {
+ while (!hasMessageListeners(anyProcess, ipcEmitter) && OUTGOING_MESSAGES.get(anyProcess)?.size > 0) {
+ const outgoingMessages = [...OUTGOING_MESSAGES.get(anyProcess)];
+ validateStrictDeadlock(outgoingMessages, wrappedMessage);
+ await Promise.all(outgoingMessages.map(({ onMessageSent }) => onMessageSent));
+ }
+};
+var OUTGOING_MESSAGES = /* @__PURE__ */ new WeakMap();
+var hasMessageListeners = (anyProcess, ipcEmitter) => ipcEmitter.listenerCount("message") > getMinListenerCount(anyProcess);
+var getMinListenerCount = (anyProcess) => SUBPROCESS_OPTIONS.has(anyProcess) && !getFdSpecificValue(SUBPROCESS_OPTIONS.get(anyProcess).options.buffer, "ipc") ? 1 : 0;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/send.js
+var sendMessage = ({ anyProcess, channel, isSubprocess, ipc }, message, { strict = false } = {}) => {
+ const methodName = "sendMessage";
+ validateIpcMethod({
+ methodName,
+ isSubprocess,
+ ipc,
+ isConnected: anyProcess.connected
+ });
+ return sendMessageAsync({
+ anyProcess,
+ channel,
+ methodName,
+ isSubprocess,
+ message,
+ strict
+ });
+};
+var sendMessageAsync = async ({ anyProcess, channel, methodName, isSubprocess, message, strict }) => {
+ const wrappedMessage = handleSendStrict({
+ anyProcess,
+ channel,
+ isSubprocess,
+ message,
+ strict
+ });
+ const outgoingMessagesState = startSendMessage(anyProcess, wrappedMessage, strict);
+ try {
+ await sendOneMessage({
+ anyProcess,
+ methodName,
+ isSubprocess,
+ wrappedMessage,
+ message
+ });
+ } catch (error) {
+ disconnect(anyProcess);
+ throw error;
+ } finally {
+ endSendMessage(outgoingMessagesState);
+ }
+};
+var sendOneMessage = async ({ anyProcess, methodName, isSubprocess, wrappedMessage, message }) => {
+ const sendMethod = getSendMethod(anyProcess);
+ try {
+ await Promise.all([
+ waitForStrictResponse(wrappedMessage, anyProcess, isSubprocess),
+ sendMethod(wrappedMessage)
+ ]);
+ } catch (error) {
+ handleEpipeError({ error, methodName, isSubprocess });
+ handleSerializationError({
+ error,
+ methodName,
+ isSubprocess,
+ message
+ });
+ throw error;
+ }
+};
+var getSendMethod = (anyProcess) => {
+ if (PROCESS_SEND_METHODS.has(anyProcess)) {
+ return PROCESS_SEND_METHODS.get(anyProcess);
+ }
+ const sendMethod = (0, import_node_util5.promisify)(anyProcess.send.bind(anyProcess));
+ PROCESS_SEND_METHODS.set(anyProcess, sendMethod);
+ return sendMethod;
+};
+var PROCESS_SEND_METHODS = /* @__PURE__ */ new WeakMap();
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/graceful.js
+var sendAbort = (subprocess, message) => {
+ const methodName = "cancelSignal";
+ validateConnection(methodName, false, subprocess.connected);
+ return sendOneMessage({
+ anyProcess: subprocess,
+ methodName,
+ isSubprocess: false,
+ wrappedMessage: { type: GRACEFUL_CANCEL_TYPE, message },
+ message
+ });
+};
+var getCancelSignal = async ({ anyProcess, channel, isSubprocess, ipc }) => {
+ await startIpc({
+ anyProcess,
+ channel,
+ isSubprocess,
+ ipc
+ });
+ return cancelController.signal;
+};
+var startIpc = async ({ anyProcess, channel, isSubprocess, ipc }) => {
+ if (cancelListening) {
+ return;
+ }
+ cancelListening = true;
+ if (!ipc) {
+ throwOnMissingParent();
+ return;
+ }
+ if (channel === null) {
+ abortOnDisconnect();
+ return;
+ }
+ getIpcEmitter(anyProcess, channel, isSubprocess);
+ await import_promises3.scheduler.yield();
+};
+var cancelListening = false;
+var handleAbort = (wrappedMessage) => {
+ if (wrappedMessage?.type !== GRACEFUL_CANCEL_TYPE) {
+ return false;
+ }
+ cancelController.abort(wrappedMessage.message);
+ return true;
+};
+var GRACEFUL_CANCEL_TYPE = "execa:ipc:cancel";
+var abortOnDisconnect = () => {
+ cancelController.abort(getAbortDisconnectError());
+};
+var cancelController = new AbortController();
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/terminate/graceful.js
+var validateGracefulCancel = ({ gracefulCancel, cancelSignal, ipc, serialization }) => {
+ if (!gracefulCancel) {
+ return;
+ }
+ if (cancelSignal === void 0) {
+ throw new Error("The `cancelSignal` option must be defined when setting the `gracefulCancel` option.");
+ }
+ if (!ipc) {
+ throw new Error("The `ipc` option cannot be false when setting the `gracefulCancel` option.");
+ }
+ if (serialization === "json") {
+ throw new Error("The `serialization` option cannot be 'json' when setting the `gracefulCancel` option.");
+ }
+};
+var throwOnGracefulCancel = ({
+ subprocess,
+ cancelSignal,
+ gracefulCancel,
+ forceKillAfterDelay,
+ context: context3,
+ controller
+}) => gracefulCancel ? [sendOnAbort({
+ subprocess,
+ cancelSignal,
+ forceKillAfterDelay,
+ context: context3,
+ controller
+})] : [];
+var sendOnAbort = async ({ subprocess, cancelSignal, forceKillAfterDelay, context: context3, controller: { signal } }) => {
+ await onAbortedSignal(cancelSignal, signal);
+ const reason = getReason(cancelSignal);
+ await sendAbort(subprocess, reason);
+ killOnTimeout({
+ kill: subprocess.kill,
+ forceKillAfterDelay,
+ context: context3,
+ controllerSignal: signal
+ });
+ context3.terminationReason ??= "gracefulCancel";
+ throw cancelSignal.reason;
+};
+var getReason = ({ reason }) => {
+ if (!(reason instanceof DOMException)) {
+ return reason;
+ }
+ const error = new Error(reason.message);
+ Object.defineProperty(error, "stack", {
+ value: reason.stack,
+ enumerable: false,
+ configurable: true,
+ writable: true
+ });
+ return error;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/terminate/timeout.js
+var import_promises4 = require("node:timers/promises");
+var validateTimeout = ({ timeout }) => {
+ if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) {
+ throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
+ }
+};
+var throwOnTimeout = (subprocess, timeout, context3, controller) => timeout === 0 || timeout === void 0 ? [] : [killAfterTimeout(subprocess, timeout, context3, controller)];
+var killAfterTimeout = async (subprocess, timeout, context3, { signal }) => {
+ await (0, import_promises4.setTimeout)(timeout, void 0, { signal });
+ context3.terminationReason ??= "timeout";
+ subprocess.kill();
+ throw new DiscardedError();
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/methods/node.js
+var import_node_process6 = require("node:process");
+var import_node_path3 = __toESM(require("node:path"), 1);
+var mapNode = ({ options }) => {
+ if (options.node === false) {
+ throw new TypeError('The "node" option cannot be false with `execaNode()`.');
+ }
+ return { options: { ...options, node: true } };
+};
+var handleNodeOption = (file, commandArguments, {
+ node: shouldHandleNode = false,
+ nodePath = import_node_process6.execPath,
+ nodeOptions = import_node_process6.execArgv.filter((nodeOption) => !nodeOption.startsWith("--inspect")),
+ cwd,
+ execPath: formerNodePath,
+ ...options
+}) => {
+ if (formerNodePath !== void 0) {
+ throw new TypeError('The "execPath" option has been removed. Please use the "nodePath" option instead.');
+ }
+ const normalizedNodePath = safeNormalizeFileUrl(nodePath, 'The "nodePath" option');
+ const resolvedNodePath = import_node_path3.default.resolve(cwd, normalizedNodePath);
+ const newOptions = {
+ ...options,
+ nodePath: resolvedNodePath,
+ node: shouldHandleNode,
+ cwd
+ };
+ if (!shouldHandleNode) {
+ return [file, commandArguments, newOptions];
+ }
+ if (import_node_path3.default.basename(file, ".exe") === "node") {
+ throw new TypeError('When the "node" option is true, the first argument does not need to be "node".');
+ }
+ return [
+ resolvedNodePath,
+ [...nodeOptions, file, ...commandArguments],
+ { ipc: true, ...newOptions, shell: false }
+ ];
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/ipc-input.js
+var import_node_v8 = require("node:v8");
+var validateIpcInputOption = ({ ipcInput, ipc, serialization }) => {
+ if (ipcInput === void 0) {
+ return;
+ }
+ if (!ipc) {
+ throw new Error("The `ipcInput` option cannot be set unless the `ipc` option is `true`.");
+ }
+ validateIpcInput[serialization](ipcInput);
+};
+var validateAdvancedInput = (ipcInput) => {
+ try {
+ (0, import_node_v8.serialize)(ipcInput);
+ } catch (error) {
+ throw new Error("The `ipcInput` option is not serializable with a structured clone.", { cause: error });
+ }
+};
+var validateJsonInput = (ipcInput) => {
+ try {
+ JSON.stringify(ipcInput);
+ } catch (error) {
+ throw new Error("The `ipcInput` option is not serializable with JSON.", { cause: error });
+ }
+};
+var validateIpcInput = {
+ advanced: validateAdvancedInput,
+ json: validateJsonInput
+};
+var sendIpcInput = async (subprocess, ipcInput) => {
+ if (ipcInput === void 0) {
+ return;
+ }
+ await subprocess.sendMessage(ipcInput);
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/arguments/encoding-option.js
+var validateEncoding = ({ encoding }) => {
+ if (ENCODINGS.has(encoding)) {
+ return;
+ }
+ const correctEncoding = getCorrectEncoding(encoding);
+ if (correctEncoding !== void 0) {
+ throw new TypeError(`Invalid option \`encoding: ${serializeEncoding(encoding)}\`.
+Please rename it to ${serializeEncoding(correctEncoding)}.`);
+ }
+ const correctEncodings = [...ENCODINGS].map((correctEncoding2) => serializeEncoding(correctEncoding2)).join(", ");
+ throw new TypeError(`Invalid option \`encoding: ${serializeEncoding(encoding)}\`.
+Please rename it to one of: ${correctEncodings}.`);
+};
+var TEXT_ENCODINGS = /* @__PURE__ */ new Set(["utf8", "utf16le"]);
+var BINARY_ENCODINGS = /* @__PURE__ */ new Set(["buffer", "hex", "base64", "base64url", "latin1", "ascii"]);
+var ENCODINGS = /* @__PURE__ */ new Set([...TEXT_ENCODINGS, ...BINARY_ENCODINGS]);
+var getCorrectEncoding = (encoding) => {
+ if (encoding === null) {
+ return "buffer";
+ }
+ if (typeof encoding !== "string") {
+ return;
+ }
+ const lowerEncoding = encoding.toLowerCase();
+ if (lowerEncoding in ENCODING_ALIASES) {
+ return ENCODING_ALIASES[lowerEncoding];
+ }
+ if (ENCODINGS.has(lowerEncoding)) {
+ return lowerEncoding;
+ }
+};
+var ENCODING_ALIASES = {
+ // eslint-disable-next-line unicorn/text-encoding-identifier-case
+ "utf-8": "utf8",
+ "utf-16le": "utf16le",
+ "ucs-2": "utf16le",
+ ucs2: "utf16le",
+ binary: "latin1"
+};
+var serializeEncoding = (encoding) => typeof encoding === "string" ? `"${encoding}"` : String(encoding);
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/arguments/cwd.js
+var import_node_fs = require("node:fs");
+var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_process7 = __toESM(require("node:process"), 1);
+var normalizeCwd = (cwd = getDefaultCwd()) => {
+ const cwdString = safeNormalizeFileUrl(cwd, 'The "cwd" option');
+ return import_node_path4.default.resolve(cwdString);
+};
+var getDefaultCwd = () => {
+ try {
+ return import_node_process7.default.cwd();
+ } catch (error) {
+ error.message = `The current directory does not exist.
+${error.message}`;
+ throw error;
+ }
+};
+var fixCwdError = (originalMessage, cwd) => {
+ if (cwd === getDefaultCwd()) {
+ return originalMessage;
+ }
+ let cwdStat;
+ try {
+ cwdStat = (0, import_node_fs.statSync)(cwd);
+ } catch (error) {
+ return `The "cwd" option is invalid: ${cwd}.
+${error.message}
+${originalMessage}`;
+ }
+ if (!cwdStat.isDirectory()) {
+ return `The "cwd" option is not a directory: ${cwd}.
+${originalMessage}`;
+ }
+ return originalMessage;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/arguments/options.js
+var normalizeOptions = (filePath, rawArguments, rawOptions) => {
+ rawOptions.cwd = normalizeCwd(rawOptions.cwd);
+ const [processedFile, processedArguments, processedOptions] = handleNodeOption(filePath, rawArguments, rawOptions);
+ const { command: file, args: commandArguments, options: initialOptions } = import_cross_spawn.default._parse(processedFile, processedArguments, processedOptions);
+ const fdOptions = normalizeFdSpecificOptions(initialOptions);
+ const options = addDefaultOptions(fdOptions);
+ validateTimeout(options);
+ validateEncoding(options);
+ validateIpcInputOption(options);
+ validateCancelSignal(options);
+ validateGracefulCancel(options);
+ options.shell = normalizeFileUrl(options.shell);
+ options.env = getEnv(options);
+ options.killSignal = normalizeKillSignal(options.killSignal);
+ options.forceKillAfterDelay = normalizeForceKillAfterDelay(options.forceKillAfterDelay);
+ options.lines = options.lines.map((lines, fdNumber) => lines && !BINARY_ENCODINGS.has(options.encoding) && options.buffer[fdNumber]);
+ if (import_node_process8.default.platform === "win32" && import_node_path5.default.basename(file, ".exe") === "cmd") {
+ commandArguments.unshift("/q");
+ }
+ return { file, commandArguments, options };
+};
+var addDefaultOptions = ({
+ extendEnv = true,
+ preferLocal = false,
+ cwd,
+ localDir: localDirectory = cwd,
+ encoding = "utf8",
+ reject = true,
+ cleanup = true,
+ all = false,
+ windowsHide = true,
+ killSignal = "SIGTERM",
+ forceKillAfterDelay = true,
+ gracefulCancel = false,
+ ipcInput,
+ ipc = ipcInput !== void 0 || gracefulCancel,
+ serialization = "advanced",
+ ...options
+}) => ({
+ ...options,
+ extendEnv,
+ preferLocal,
+ cwd,
+ localDirectory,
+ encoding,
+ reject,
+ cleanup,
+ all,
+ windowsHide,
+ killSignal,
+ forceKillAfterDelay,
+ gracefulCancel,
+ ipcInput,
+ ipc,
+ serialization
+});
+var getEnv = ({ env: envOption, extendEnv, preferLocal, node, localDirectory, nodePath }) => {
+ const env = extendEnv ? { ...import_node_process8.default.env, ...envOption } : envOption;
+ if (preferLocal || node) {
+ return npmRunPathEnv({
+ env,
+ cwd: localDirectory,
+ execPath: nodePath,
+ preferLocal,
+ addExecPath: node
+ });
+ }
+ return env;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/arguments/shell.js
+var concatenateShell = (file, commandArguments, options) => options.shell && commandArguments.length > 0 ? [[file, ...commandArguments].join(" "), [], options] : [file, commandArguments, options];
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/return/message.js
+var import_node_util6 = require("node:util");
+
+// node_modules/.pnpm/strip-final-newline@4.0.0/node_modules/strip-final-newline/index.js
+function stripFinalNewline(input) {
+ if (typeof input === "string") {
+ return stripFinalNewlineString(input);
+ }
+ if (!(ArrayBuffer.isView(input) && input.BYTES_PER_ELEMENT === 1)) {
+ throw new Error("Input must be a string or a Uint8Array");
+ }
+ return stripFinalNewlineBinary(input);
+}
+var stripFinalNewlineString = (input) => input.at(-1) === LF ? input.slice(0, input.at(-2) === CR ? -2 : -1) : input;
+var stripFinalNewlineBinary = (input) => input.at(-1) === LF_BINARY ? input.subarray(0, input.at(-2) === CR_BINARY ? -2 : -1) : input;
+var LF = "\n";
+var LF_BINARY = LF.codePointAt(0);
+var CR = "\r";
+var CR_BINARY = CR.codePointAt(0);
+
+// node_modules/.pnpm/get-stream@9.0.1/node_modules/get-stream/source/index.js
+var import_node_events6 = require("node:events");
+var import_promises5 = require("node:stream/promises");
+
+// node_modules/.pnpm/is-stream@4.0.1/node_modules/is-stream/index.js
+function isStream(stream, { checkOpen = true } = {}) {
+ return stream !== null && typeof stream === "object" && (stream.writable || stream.readable || !checkOpen || stream.writable === void 0 && stream.readable === void 0) && typeof stream.pipe === "function";
+}
+function isWritableStream(stream, { checkOpen = true } = {}) {
+ return isStream(stream, { checkOpen }) && (stream.writable || !checkOpen) && typeof stream.write === "function" && typeof stream.end === "function" && typeof stream.writable === "boolean" && typeof stream.writableObjectMode === "boolean" && typeof stream.destroy === "function" && typeof stream.destroyed === "boolean";
+}
+function isReadableStream(stream, { checkOpen = true } = {}) {
+ return isStream(stream, { checkOpen }) && (stream.readable || !checkOpen) && typeof stream.read === "function" && typeof stream.readable === "boolean" && typeof stream.readableObjectMode === "boolean" && typeof stream.destroy === "function" && typeof stream.destroyed === "boolean";
+}
+function isDuplexStream(stream, options) {
+ return isWritableStream(stream, options) && isReadableStream(stream, options);
+}
+
+// node_modules/.pnpm/@sec-ant+readable-stream@0.4.1/node_modules/@sec-ant/readable-stream/dist/ponyfill/asyncIterator.js
+var a = Object.getPrototypeOf(
+ Object.getPrototypeOf(
+ /* istanbul ignore next */
+ async function* () {
+ }
+ ).prototype
+);
+var c = class {
+ #t;
+ #n;
+ #r = false;
+ #e = void 0;
+ constructor(e, t) {
+ this.#t = e, this.#n = t;
+ }
+ next() {
+ const e = () => this.#s();
+ return this.#e = this.#e ? this.#e.then(e, e) : e(), this.#e;
+ }
+ return(e) {
+ const t = () => this.#i(e);
+ return this.#e ? this.#e.then(t, t) : t();
+ }
+ async #s() {
+ if (this.#r)
+ return {
+ done: true,
+ value: void 0
+ };
+ let e;
+ try {
+ e = await this.#t.read();
+ } catch (t) {
+ throw this.#e = void 0, this.#r = true, this.#t.releaseLock(), t;
+ }
+ return e.done && (this.#e = void 0, this.#r = true, this.#t.releaseLock()), e;
+ }
+ async #i(e) {
+ if (this.#r)
+ return {
+ done: true,
+ value: e
+ };
+ if (this.#r = true, !this.#n) {
+ const t = this.#t.cancel(e);
+ return this.#t.releaseLock(), await t, {
+ done: true,
+ value: e
+ };
+ }
+ return this.#t.releaseLock(), {
+ done: true,
+ value: e
+ };
+ }
+};
+var n = Symbol();
+function i() {
+ return this[n].next();
+}
+Object.defineProperty(i, "name", { value: "next" });
+function o(r) {
+ return this[n].return(r);
+}
+Object.defineProperty(o, "name", { value: "return" });
+var u = Object.create(a, {
+ next: {
+ enumerable: true,
+ configurable: true,
+ writable: true,
+ value: i
+ },
+ return: {
+ enumerable: true,
+ configurable: true,
+ writable: true,
+ value: o
+ }
+});
+function h({ preventCancel: r = false } = {}) {
+ const e = this.getReader(), t = new c(
+ e,
+ r
+ ), s = Object.create(u);
+ return s[n] = t, s;
+}
+
+// node_modules/.pnpm/get-stream@9.0.1/node_modules/get-stream/source/stream.js
+var getAsyncIterable = (stream) => {
+ if (isReadableStream(stream, { checkOpen: false }) && nodeImports.on !== void 0) {
+ return getStreamIterable(stream);
+ }
+ if (typeof stream?.[Symbol.asyncIterator] === "function") {
+ return stream;
+ }
+ if (toString.call(stream) === "[object ReadableStream]") {
+ return h.call(stream);
+ }
+ throw new TypeError("The first argument must be a Readable, a ReadableStream, or an async iterable.");
+};
+var { toString } = Object.prototype;
+var getStreamIterable = async function* (stream) {
+ const controller = new AbortController();
+ const state = {};
+ handleStreamEnd(stream, controller, state);
+ try {
+ for await (const [chunk] of nodeImports.on(stream, "data", { signal: controller.signal })) {
+ yield chunk;
+ }
+ } catch (error) {
+ if (state.error !== void 0) {
+ throw state.error;
+ } else if (!controller.signal.aborted) {
+ throw error;
+ }
+ } finally {
+ stream.destroy();
+ }
+};
+var handleStreamEnd = async (stream, controller, state) => {
+ try {
+ await nodeImports.finished(stream, {
+ cleanup: true,
+ readable: true,
+ writable: false,
+ error: false
+ });
+ } catch (error) {
+ state.error = error;
+ } finally {
+ controller.abort();
+ }
+};
+var nodeImports = {};
+
+// node_modules/.pnpm/get-stream@9.0.1/node_modules/get-stream/source/contents.js
+var getStreamContents = async (stream, { init, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, finalize }, { maxBuffer = Number.POSITIVE_INFINITY } = {}) => {
+ const asyncIterable = getAsyncIterable(stream);
+ const state = init();
+ state.length = 0;
+ try {
+ for await (const chunk of asyncIterable) {
+ const chunkType = getChunkType(chunk);
+ const convertedChunk = convertChunk[chunkType](chunk, state);
+ appendChunk({
+ convertedChunk,
+ state,
+ getSize,
+ truncateChunk,
+ addChunk,
+ maxBuffer
+ });
+ }
+ appendFinalChunk({
+ state,
+ convertChunk,
+ getSize,
+ truncateChunk,
+ addChunk,
+ getFinalChunk,
+ maxBuffer
+ });
+ return finalize(state);
+ } catch (error) {
+ const normalizedError = typeof error === "object" && error !== null ? error : new Error(error);
+ normalizedError.bufferedData = finalize(state);
+ throw normalizedError;
+ }
+};
+var appendFinalChunk = ({ state, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer }) => {
+ const convertedChunk = getFinalChunk(state);
+ if (convertedChunk !== void 0) {
+ appendChunk({
+ convertedChunk,
+ state,
+ getSize,
+ truncateChunk,
+ addChunk,
+ maxBuffer
+ });
+ }
+};
+var appendChunk = ({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer }) => {
+ const chunkSize = getSize(convertedChunk);
+ const newLength = state.length + chunkSize;
+ if (newLength <= maxBuffer) {
+ addNewChunk(convertedChunk, state, addChunk, newLength);
+ return;
+ }
+ const truncatedChunk = truncateChunk(convertedChunk, maxBuffer - state.length);
+ if (truncatedChunk !== void 0) {
+ addNewChunk(truncatedChunk, state, addChunk, maxBuffer);
+ }
+ throw new MaxBufferError();
+};
+var addNewChunk = (convertedChunk, state, addChunk, newLength) => {
+ state.contents = addChunk(convertedChunk, state, newLength);
+ state.length = newLength;
+};
+var getChunkType = (chunk) => {
+ const typeOfChunk = typeof chunk;
+ if (typeOfChunk === "string") {
+ return "string";
+ }
+ if (typeOfChunk !== "object" || chunk === null) {
+ return "others";
+ }
+ if (globalThis.Buffer?.isBuffer(chunk)) {
+ return "buffer";
+ }
+ const prototypeName = objectToString2.call(chunk);
+ if (prototypeName === "[object ArrayBuffer]") {
+ return "arrayBuffer";
+ }
+ if (prototypeName === "[object DataView]") {
+ return "dataView";
+ }
+ if (Number.isInteger(chunk.byteLength) && Number.isInteger(chunk.byteOffset) && objectToString2.call(chunk.buffer) === "[object ArrayBuffer]") {
+ return "typedArray";
+ }
+ return "others";
+};
+var { toString: objectToString2 } = Object.prototype;
+var MaxBufferError = class extends Error {
+ name = "MaxBufferError";
+ constructor() {
+ super("maxBuffer exceeded");
+ }
+};
+
+// node_modules/.pnpm/get-stream@9.0.1/node_modules/get-stream/source/utils.js
+var identity2 = (value) => value;
+var noop3 = () => void 0;
+var getContentsProperty = ({ contents }) => contents;
+var throwObjectStream = (chunk) => {
+ throw new Error(`Streams in object mode are not supported: ${String(chunk)}`);
+};
+var getLengthProperty = (convertedChunk) => convertedChunk.length;
+
+// node_modules/.pnpm/get-stream@9.0.1/node_modules/get-stream/source/array.js
+async function getStreamAsArray(stream, options) {
+ return getStreamContents(stream, arrayMethods, options);
+}
+var initArray = () => ({ contents: [] });
+var increment = () => 1;
+var addArrayChunk = (convertedChunk, { contents }) => {
+ contents.push(convertedChunk);
+ return contents;
+};
+var arrayMethods = {
+ init: initArray,
+ convertChunk: {
+ string: identity2,
+ buffer: identity2,
+ arrayBuffer: identity2,
+ dataView: identity2,
+ typedArray: identity2,
+ others: identity2
+ },
+ getSize: increment,
+ truncateChunk: noop3,
+ addChunk: addArrayChunk,
+ getFinalChunk: noop3,
+ finalize: getContentsProperty
+};
+
+// node_modules/.pnpm/get-stream@9.0.1/node_modules/get-stream/source/array-buffer.js
+async function getStreamAsArrayBuffer(stream, options) {
+ return getStreamContents(stream, arrayBufferMethods, options);
+}
+var initArrayBuffer = () => ({ contents: new ArrayBuffer(0) });
+var useTextEncoder = (chunk) => textEncoder2.encode(chunk);
+var textEncoder2 = new TextEncoder();
+var useUint8Array = (chunk) => new Uint8Array(chunk);
+var useUint8ArrayWithOffset = (chunk) => new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+var truncateArrayBufferChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize);
+var addArrayBufferChunk = (convertedChunk, { contents, length: previousLength }, length) => {
+ const newContents = hasArrayBufferResize() ? resizeArrayBuffer(contents, length) : resizeArrayBufferSlow(contents, length);
+ new Uint8Array(newContents).set(convertedChunk, previousLength);
+ return newContents;
+};
+var resizeArrayBufferSlow = (contents, length) => {
+ if (length <= contents.byteLength) {
+ return contents;
+ }
+ const arrayBuffer = new ArrayBuffer(getNewContentsLength(length));
+ new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
+ return arrayBuffer;
+};
+var resizeArrayBuffer = (contents, length) => {
+ if (length <= contents.maxByteLength) {
+ contents.resize(length);
+ return contents;
+ }
+ const arrayBuffer = new ArrayBuffer(length, { maxByteLength: getNewContentsLength(length) });
+ new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
+ return arrayBuffer;
+};
+var getNewContentsLength = (length) => SCALE_FACTOR ** Math.ceil(Math.log(length) / Math.log(SCALE_FACTOR));
+var SCALE_FACTOR = 2;
+var finalizeArrayBuffer = ({ contents, length }) => hasArrayBufferResize() ? contents : contents.slice(0, length);
+var hasArrayBufferResize = () => "resize" in ArrayBuffer.prototype;
+var arrayBufferMethods = {
+ init: initArrayBuffer,
+ convertChunk: {
+ string: useTextEncoder,
+ buffer: useUint8Array,
+ arrayBuffer: useUint8Array,
+ dataView: useUint8ArrayWithOffset,
+ typedArray: useUint8ArrayWithOffset,
+ others: throwObjectStream
+ },
+ getSize: getLengthProperty,
+ truncateChunk: truncateArrayBufferChunk,
+ addChunk: addArrayBufferChunk,
+ getFinalChunk: noop3,
+ finalize: finalizeArrayBuffer
+};
+
+// node_modules/.pnpm/get-stream@9.0.1/node_modules/get-stream/source/string.js
+async function getStreamAsString(stream, options) {
+ return getStreamContents(stream, stringMethods, options);
+}
+var initString = () => ({ contents: "", textDecoder: new TextDecoder() });
+var useTextDecoder = (chunk, { textDecoder: textDecoder2 }) => textDecoder2.decode(chunk, { stream: true });
+var addStringChunk = (convertedChunk, { contents }) => contents + convertedChunk;
+var truncateStringChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize);
+var getFinalStringChunk = ({ textDecoder: textDecoder2 }) => {
+ const finalChunk = textDecoder2.decode();
+ return finalChunk === "" ? void 0 : finalChunk;
+};
+var stringMethods = {
+ init: initString,
+ convertChunk: {
+ string: identity2,
+ buffer: useTextDecoder,
+ arrayBuffer: useTextDecoder,
+ dataView: useTextDecoder,
+ typedArray: useTextDecoder,
+ others: throwObjectStream
+ },
+ getSize: getLengthProperty,
+ truncateChunk: truncateStringChunk,
+ addChunk: addStringChunk,
+ getFinalChunk: getFinalStringChunk,
+ finalize: getContentsProperty
+};
+
+// node_modules/.pnpm/get-stream@9.0.1/node_modules/get-stream/source/index.js
+Object.assign(nodeImports, { on: import_node_events6.on, finished: import_promises5.finished });
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/io/max-buffer.js
+var handleMaxBuffer = ({ error, stream, readableObjectMode, lines, encoding, fdNumber }) => {
+ if (!(error instanceof MaxBufferError)) {
+ throw error;
+ }
+ if (fdNumber === "all") {
+ return error;
+ }
+ const unit = getMaxBufferUnit(readableObjectMode, lines, encoding);
+ error.maxBufferInfo = { fdNumber, unit };
+ stream.destroy();
+ throw error;
+};
+var getMaxBufferUnit = (readableObjectMode, lines, encoding) => {
+ if (readableObjectMode) {
+ return "objects";
+ }
+ if (lines) {
+ return "lines";
+ }
+ if (encoding === "buffer") {
+ return "bytes";
+ }
+ return "characters";
+};
+var checkIpcMaxBuffer = (subprocess, ipcOutput, maxBuffer) => {
+ if (ipcOutput.length !== maxBuffer) {
+ return;
+ }
+ const error = new MaxBufferError();
+ error.maxBufferInfo = { fdNumber: "ipc" };
+ throw error;
+};
+var getMaxBufferMessage = (error, maxBuffer) => {
+ const { streamName, threshold, unit } = getMaxBufferInfo(error, maxBuffer);
+ return `Command's ${streamName} was larger than ${threshold} ${unit}`;
+};
+var getMaxBufferInfo = (error, maxBuffer) => {
+ if (error?.maxBufferInfo === void 0) {
+ return { streamName: "output", threshold: maxBuffer[1], unit: "bytes" };
+ }
+ const { maxBufferInfo: { fdNumber, unit } } = error;
+ delete error.maxBufferInfo;
+ const threshold = getFdSpecificValue(maxBuffer, fdNumber);
+ if (fdNumber === "ipc") {
+ return { streamName: "IPC output", threshold, unit: "messages" };
+ }
+ return { streamName: getStreamName(fdNumber), threshold, unit };
+};
+var isMaxBufferSync = (resultError, output, maxBuffer) => resultError?.code === "ENOBUFS" && output !== null && output.some((result) => result !== null && result.length > getMaxBufferSync(maxBuffer));
+var truncateMaxBufferSync = (result, isMaxBuffer, maxBuffer) => {
+ if (!isMaxBuffer) {
+ return result;
+ }
+ const maxBufferValue = getMaxBufferSync(maxBuffer);
+ return result.length > maxBufferValue ? result.slice(0, maxBufferValue) : result;
+};
+var getMaxBufferSync = ([, stdoutMaxBuffer]) => stdoutMaxBuffer;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/return/message.js
+var createMessages = ({
+ stdio,
+ all,
+ ipcOutput,
+ originalError,
+ signal,
+ signalDescription,
+ exitCode,
+ escapedCommand,
+ timedOut,
+ isCanceled,
+ isGracefullyCanceled,
+ isMaxBuffer,
+ isForcefullyTerminated,
+ forceKillAfterDelay,
+ killSignal,
+ maxBuffer,
+ timeout,
+ cwd
+}) => {
+ const errorCode = originalError?.code;
+ const prefix = getErrorPrefix({
+ originalError,
+ timedOut,
+ timeout,
+ isMaxBuffer,
+ maxBuffer,
+ errorCode,
+ signal,
+ signalDescription,
+ exitCode,
+ isCanceled,
+ isGracefullyCanceled,
+ isForcefullyTerminated,
+ forceKillAfterDelay,
+ killSignal
+ });
+ const originalMessage = getOriginalMessage(originalError, cwd);
+ const suffix = originalMessage === void 0 ? "" : `
+${originalMessage}`;
+ const shortMessage = `${prefix}: ${escapedCommand}${suffix}`;
+ const messageStdio = all === void 0 ? [stdio[2], stdio[1]] : [all];
+ const message = [
+ shortMessage,
+ ...messageStdio,
+ ...stdio.slice(3),
+ ipcOutput.map((ipcMessage) => serializeIpcMessage(ipcMessage)).join("\n")
+ ].map((messagePart) => escapeLines(stripFinalNewline(serializeMessagePart(messagePart)))).filter(Boolean).join("\n\n");
+ return { originalMessage, shortMessage, message };
+};
+var getErrorPrefix = ({
+ originalError,
+ timedOut,
+ timeout,
+ isMaxBuffer,
+ maxBuffer,
+ errorCode,
+ signal,
+ signalDescription,
+ exitCode,
+ isCanceled,
+ isGracefullyCanceled,
+ isForcefullyTerminated,
+ forceKillAfterDelay,
+ killSignal
+}) => {
+ const forcefulSuffix = getForcefulSuffix(isForcefullyTerminated, forceKillAfterDelay);
+ if (timedOut) {
+ return `Command timed out after ${timeout} milliseconds${forcefulSuffix}`;
+ }
+ if (isGracefullyCanceled) {
+ if (signal === void 0) {
+ return `Command was gracefully canceled with exit code ${exitCode}`;
+ }
+ return isForcefullyTerminated ? `Command was gracefully canceled${forcefulSuffix}` : `Command was gracefully canceled with ${signal} (${signalDescription})`;
+ }
+ if (isCanceled) {
+ return `Command was canceled${forcefulSuffix}`;
+ }
+ if (isMaxBuffer) {
+ return `${getMaxBufferMessage(originalError, maxBuffer)}${forcefulSuffix}`;
+ }
+ if (errorCode !== void 0) {
+ return `Command failed with ${errorCode}${forcefulSuffix}`;
+ }
+ if (isForcefullyTerminated) {
+ return `Command was killed with ${killSignal} (${getSignalDescription(killSignal)})${forcefulSuffix}`;
+ }
+ if (signal !== void 0) {
+ return `Command was killed with ${signal} (${signalDescription})`;
+ }
+ if (exitCode !== void 0) {
+ return `Command failed with exit code ${exitCode}`;
+ }
+ return "Command failed";
+};
+var getForcefulSuffix = (isForcefullyTerminated, forceKillAfterDelay) => isForcefullyTerminated ? ` and was forcefully terminated after ${forceKillAfterDelay} milliseconds` : "";
+var getOriginalMessage = (originalError, cwd) => {
+ if (originalError instanceof DiscardedError) {
+ return;
+ }
+ const originalMessage = isExecaError(originalError) ? originalError.originalMessage : String(originalError?.message ?? originalError);
+ const escapedOriginalMessage = escapeLines(fixCwdError(originalMessage, cwd));
+ return escapedOriginalMessage === "" ? void 0 : escapedOriginalMessage;
+};
+var serializeIpcMessage = (ipcMessage) => typeof ipcMessage === "string" ? ipcMessage : (0, import_node_util6.inspect)(ipcMessage);
+var serializeMessagePart = (messagePart) => Array.isArray(messagePart) ? messagePart.map((messageItem) => stripFinalNewline(serializeMessageItem(messageItem))).filter(Boolean).join("\n") : serializeMessageItem(messagePart);
+var serializeMessageItem = (messageItem) => {
+ if (typeof messageItem === "string") {
+ return messageItem;
+ }
+ if (isUint8Array(messageItem)) {
+ return uint8ArrayToString(messageItem);
+ }
+ return "";
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/return/result.js
+var makeSuccessResult = ({
+ command,
+ escapedCommand,
+ stdio,
+ all,
+ ipcOutput,
+ options: { cwd },
+ startTime
+}) => omitUndefinedProperties({
+ command,
+ escapedCommand,
+ cwd,
+ durationMs: getDurationMs(startTime),
+ failed: false,
+ timedOut: false,
+ isCanceled: false,
+ isGracefullyCanceled: false,
+ isTerminated: false,
+ isMaxBuffer: false,
+ isForcefullyTerminated: false,
+ exitCode: 0,
+ stdout: stdio[1],
+ stderr: stdio[2],
+ all,
+ stdio,
+ ipcOutput,
+ pipedFrom: []
+});
+var makeEarlyError = ({
+ error,
+ command,
+ escapedCommand,
+ fileDescriptors,
+ options,
+ startTime,
+ isSync
+}) => makeError({
+ error,
+ command,
+ escapedCommand,
+ startTime,
+ timedOut: false,
+ isCanceled: false,
+ isGracefullyCanceled: false,
+ isMaxBuffer: false,
+ isForcefullyTerminated: false,
+ stdio: Array.from({ length: fileDescriptors.length }),
+ ipcOutput: [],
+ options,
+ isSync
+});
+var makeError = ({
+ error: originalError,
+ command,
+ escapedCommand,
+ startTime,
+ timedOut,
+ isCanceled,
+ isGracefullyCanceled,
+ isMaxBuffer,
+ isForcefullyTerminated,
+ exitCode: rawExitCode,
+ signal: rawSignal,
+ stdio,
+ all,
+ ipcOutput,
+ options: {
+ timeoutDuration,
+ timeout = timeoutDuration,
+ forceKillAfterDelay,
+ killSignal,
+ cwd,
+ maxBuffer
+ },
+ isSync
+}) => {
+ const { exitCode, signal, signalDescription } = normalizeExitPayload(rawExitCode, rawSignal);
+ const { originalMessage, shortMessage, message } = createMessages({
+ stdio,
+ all,
+ ipcOutput,
+ originalError,
+ signal,
+ signalDescription,
+ exitCode,
+ escapedCommand,
+ timedOut,
+ isCanceled,
+ isGracefullyCanceled,
+ isMaxBuffer,
+ isForcefullyTerminated,
+ forceKillAfterDelay,
+ killSignal,
+ maxBuffer,
+ timeout,
+ cwd
+ });
+ const error = getFinalError(originalError, message, isSync);
+ Object.assign(error, getErrorProperties({
+ error,
+ command,
+ escapedCommand,
+ startTime,
+ timedOut,
+ isCanceled,
+ isGracefullyCanceled,
+ isMaxBuffer,
+ isForcefullyTerminated,
+ exitCode,
+ signal,
+ signalDescription,
+ stdio,
+ all,
+ ipcOutput,
+ cwd,
+ originalMessage,
+ shortMessage
+ }));
+ return error;
+};
+var getErrorProperties = ({
+ error,
+ command,
+ escapedCommand,
+ startTime,
+ timedOut,
+ isCanceled,
+ isGracefullyCanceled,
+ isMaxBuffer,
+ isForcefullyTerminated,
+ exitCode,
+ signal,
+ signalDescription,
+ stdio,
+ all,
+ ipcOutput,
+ cwd,
+ originalMessage,
+ shortMessage
+}) => omitUndefinedProperties({
+ shortMessage,
+ originalMessage,
+ command,
+ escapedCommand,
+ cwd,
+ durationMs: getDurationMs(startTime),
+ failed: true,
+ timedOut,
+ isCanceled,
+ isGracefullyCanceled,
+ isTerminated: signal !== void 0,
+ isMaxBuffer,
+ isForcefullyTerminated,
+ exitCode,
+ signal,
+ signalDescription,
+ code: error.cause?.code,
+ stdout: stdio[1],
+ stderr: stdio[2],
+ all,
+ stdio,
+ ipcOutput,
+ pipedFrom: []
+});
+var omitUndefinedProperties = (result) => Object.fromEntries(Object.entries(result).filter(([, value]) => value !== void 0));
+var normalizeExitPayload = (rawExitCode, rawSignal) => {
+ const exitCode = rawExitCode === null ? void 0 : rawExitCode;
+ const signal = rawSignal === null ? void 0 : rawSignal;
+ const signalDescription = signal === void 0 ? void 0 : getSignalDescription(rawSignal);
+ return { exitCode, signal, signalDescription };
+};
+
+// node_modules/.pnpm/parse-ms@4.0.0/node_modules/parse-ms/index.js
+var toZeroIfInfinity = (value) => Number.isFinite(value) ? value : 0;
+function parseNumber(milliseconds) {
+ return {
+ days: Math.trunc(milliseconds / 864e5),
+ hours: Math.trunc(milliseconds / 36e5 % 24),
+ minutes: Math.trunc(milliseconds / 6e4 % 60),
+ seconds: Math.trunc(milliseconds / 1e3 % 60),
+ milliseconds: Math.trunc(milliseconds % 1e3),
+ microseconds: Math.trunc(toZeroIfInfinity(milliseconds * 1e3) % 1e3),
+ nanoseconds: Math.trunc(toZeroIfInfinity(milliseconds * 1e6) % 1e3)
+ };
+}
+function parseBigint(milliseconds) {
+ return {
+ days: milliseconds / 86400000n,
+ hours: milliseconds / 3600000n % 24n,
+ minutes: milliseconds / 60000n % 60n,
+ seconds: milliseconds / 1000n % 60n,
+ milliseconds: milliseconds % 1000n,
+ microseconds: 0n,
+ nanoseconds: 0n
+ };
+}
+function parseMilliseconds(milliseconds) {
+ switch (typeof milliseconds) {
+ case "number": {
+ if (Number.isFinite(milliseconds)) {
+ return parseNumber(milliseconds);
+ }
+ break;
+ }
+ case "bigint": {
+ return parseBigint(milliseconds);
+ }
+ }
+ throw new TypeError("Expected a finite number or bigint");
+}
+
+// node_modules/.pnpm/pretty-ms@9.2.0/node_modules/pretty-ms/index.js
+var isZero = (value) => value === 0 || value === 0n;
+var pluralize = (word, count2) => count2 === 1 || count2 === 1n ? word : `${word}s`;
+var SECOND_ROUNDING_EPSILON = 1e-7;
+var ONE_DAY_IN_MILLISECONDS = 24n * 60n * 60n * 1000n;
+function prettyMilliseconds(milliseconds, options) {
+ const isBigInt = typeof milliseconds === "bigint";
+ if (!isBigInt && !Number.isFinite(milliseconds)) {
+ throw new TypeError("Expected a finite number or bigint");
+ }
+ options = { ...options };
+ const sign = milliseconds < 0 ? "-" : "";
+ milliseconds = milliseconds < 0 ? -milliseconds : milliseconds;
+ if (options.colonNotation) {
+ options.compact = false;
+ options.formatSubMilliseconds = false;
+ options.separateMilliseconds = false;
+ options.verbose = false;
+ }
+ if (options.compact) {
+ options.unitCount = 1;
+ options.secondsDecimalDigits = 0;
+ options.millisecondsDecimalDigits = 0;
+ }
+ let result = [];
+ const floorDecimals = (value, decimalDigits) => {
+ const flooredInterimValue = Math.floor(value * 10 ** decimalDigits + SECOND_ROUNDING_EPSILON);
+ const flooredValue = Math.round(flooredInterimValue) / 10 ** decimalDigits;
+ return flooredValue.toFixed(decimalDigits);
+ };
+ const add = (value, long, short, valueString) => {
+ if ((result.length === 0 || !options.colonNotation) && isZero(value) && !(options.colonNotation && short === "m")) {
+ return;
+ }
+ valueString ??= String(value);
+ if (options.colonNotation) {
+ const wholeDigits = valueString.includes(".") ? valueString.split(".")[0].length : valueString.length;
+ const minLength = result.length > 0 ? 2 : 1;
+ valueString = "0".repeat(Math.max(0, minLength - wholeDigits)) + valueString;
+ } else {
+ valueString += options.verbose ? " " + pluralize(long, value) : short;
+ }
+ result.push(valueString);
+ };
+ const parsed = parseMilliseconds(milliseconds);
+ const days = BigInt(parsed.days);
+ if (options.hideYearAndDays) {
+ add(BigInt(days) * 24n + BigInt(parsed.hours), "hour", "h");
+ } else {
+ if (options.hideYear) {
+ add(days, "day", "d");
+ } else {
+ add(days / 365n, "year", "y");
+ add(days % 365n, "day", "d");
+ }
+ add(Number(parsed.hours), "hour", "h");
+ }
+ add(Number(parsed.minutes), "minute", "m");
+ if (!options.hideSeconds) {
+ if (options.separateMilliseconds || options.formatSubMilliseconds || !options.colonNotation && milliseconds < 1e3) {
+ const seconds = Number(parsed.seconds);
+ const milliseconds2 = Number(parsed.milliseconds);
+ const microseconds = Number(parsed.microseconds);
+ const nanoseconds = Number(parsed.nanoseconds);
+ add(seconds, "second", "s");
+ if (options.formatSubMilliseconds) {
+ add(milliseconds2, "millisecond", "ms");
+ add(microseconds, "microsecond", "\xB5s");
+ add(nanoseconds, "nanosecond", "ns");
+ } else {
+ const millisecondsAndBelow = milliseconds2 + microseconds / 1e3 + nanoseconds / 1e6;
+ const millisecondsDecimalDigits = typeof options.millisecondsDecimalDigits === "number" ? options.millisecondsDecimalDigits : 0;
+ const roundedMilliseconds = millisecondsAndBelow >= 1 ? Math.round(millisecondsAndBelow) : Math.ceil(millisecondsAndBelow);
+ const millisecondsString = millisecondsDecimalDigits ? millisecondsAndBelow.toFixed(millisecondsDecimalDigits) : roundedMilliseconds;
+ add(
+ Number.parseFloat(millisecondsString),
+ "millisecond",
+ "ms",
+ millisecondsString
+ );
+ }
+ } else {
+ const seconds = (isBigInt ? Number(milliseconds % ONE_DAY_IN_MILLISECONDS) : milliseconds) / 1e3 % 60;
+ const secondsDecimalDigits = typeof options.secondsDecimalDigits === "number" ? options.secondsDecimalDigits : 1;
+ const secondsFixed = floorDecimals(seconds, secondsDecimalDigits);
+ const secondsString = options.keepDecimalsOnWholeSeconds ? secondsFixed : secondsFixed.replace(/\.0+$/, "");
+ add(Number.parseFloat(secondsString), "second", "s", secondsString);
+ }
+ }
+ if (result.length === 0) {
+ return sign + "0" + (options.verbose ? " milliseconds" : "ms");
+ }
+ const separator = options.colonNotation ? ":" : " ";
+ if (typeof options.unitCount === "number") {
+ result = result.slice(0, Math.max(options.unitCount, 1));
+ }
+ return sign + result.join(separator);
+}
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/verbose/error.js
+var logError = (result, verboseInfo) => {
+ if (result.failed) {
+ verboseLog({
+ type: "error",
+ verboseMessage: result.shortMessage,
+ verboseInfo,
+ result
+ });
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/verbose/complete.js
+var logResult = (result, verboseInfo) => {
+ if (!isVerbose(verboseInfo)) {
+ return;
+ }
+ logError(result, verboseInfo);
+ logDuration(result, verboseInfo);
+};
+var logDuration = (result, verboseInfo) => {
+ const verboseMessage = `(done in ${prettyMilliseconds(result.durationMs)})`;
+ verboseLog({
+ type: "duration",
+ verboseMessage,
+ verboseInfo,
+ result
+ });
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/return/reject.js
+var handleResult = (result, verboseInfo, { reject }) => {
+ logResult(result, verboseInfo);
+ if (result.failed && reject) {
+ throw result;
+ }
+ return result;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/stdio/handle-sync.js
+var import_node_fs3 = require("node:fs");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/stdio/type.js
+var getStdioItemType = (value, optionName) => {
+ if (isAsyncGenerator(value)) {
+ return "asyncGenerator";
+ }
+ if (isSyncGenerator(value)) {
+ return "generator";
+ }
+ if (isUrl(value)) {
+ return "fileUrl";
+ }
+ if (isFilePathObject(value)) {
+ return "filePath";
+ }
+ if (isWebStream(value)) {
+ return "webStream";
+ }
+ if (isStream(value, { checkOpen: false })) {
+ return "native";
+ }
+ if (isUint8Array(value)) {
+ return "uint8Array";
+ }
+ if (isAsyncIterableObject(value)) {
+ return "asyncIterable";
+ }
+ if (isIterableObject(value)) {
+ return "iterable";
+ }
+ if (isTransformStream(value)) {
+ return getTransformStreamType({ transform: value }, optionName);
+ }
+ if (isTransformOptions(value)) {
+ return getTransformObjectType(value, optionName);
+ }
+ return "native";
+};
+var getTransformObjectType = (value, optionName) => {
+ if (isDuplexStream(value.transform, { checkOpen: false })) {
+ return getDuplexType(value, optionName);
+ }
+ if (isTransformStream(value.transform)) {
+ return getTransformStreamType(value, optionName);
+ }
+ return getGeneratorObjectType(value, optionName);
+};
+var getDuplexType = (value, optionName) => {
+ validateNonGeneratorType(value, optionName, "Duplex stream");
+ return "duplex";
+};
+var getTransformStreamType = (value, optionName) => {
+ validateNonGeneratorType(value, optionName, "web TransformStream");
+ return "webTransform";
+};
+var validateNonGeneratorType = ({ final, binary, objectMode }, optionName, typeName) => {
+ checkUndefinedOption(final, `${optionName}.final`, typeName);
+ checkUndefinedOption(binary, `${optionName}.binary`, typeName);
+ checkBooleanOption(objectMode, `${optionName}.objectMode`);
+};
+var checkUndefinedOption = (value, optionName, typeName) => {
+ if (value !== void 0) {
+ throw new TypeError(`The \`${optionName}\` option can only be defined when using a generator, not a ${typeName}.`);
+ }
+};
+var getGeneratorObjectType = ({ transform, final, binary, objectMode }, optionName) => {
+ if (transform !== void 0 && !isGenerator(transform)) {
+ throw new TypeError(`The \`${optionName}.transform\` option must be a generator, a Duplex stream or a web TransformStream.`);
+ }
+ if (isDuplexStream(final, { checkOpen: false })) {
+ throw new TypeError(`The \`${optionName}.final\` option must not be a Duplex stream.`);
+ }
+ if (isTransformStream(final)) {
+ throw new TypeError(`The \`${optionName}.final\` option must not be a web TransformStream.`);
+ }
+ if (final !== void 0 && !isGenerator(final)) {
+ throw new TypeError(`The \`${optionName}.final\` option must be a generator.`);
+ }
+ checkBooleanOption(binary, `${optionName}.binary`);
+ checkBooleanOption(objectMode, `${optionName}.objectMode`);
+ return isAsyncGenerator(transform) || isAsyncGenerator(final) ? "asyncGenerator" : "generator";
+};
+var checkBooleanOption = (value, optionName) => {
+ if (value !== void 0 && typeof value !== "boolean") {
+ throw new TypeError(`The \`${optionName}\` option must use a boolean.`);
+ }
+};
+var isGenerator = (value) => isAsyncGenerator(value) || isSyncGenerator(value);
+var isAsyncGenerator = (value) => Object.prototype.toString.call(value) === "[object AsyncGeneratorFunction]";
+var isSyncGenerator = (value) => Object.prototype.toString.call(value) === "[object GeneratorFunction]";
+var isTransformOptions = (value) => isPlainObject3(value) && (value.transform !== void 0 || value.final !== void 0);
+var isUrl = (value) => Object.prototype.toString.call(value) === "[object URL]";
+var isRegularUrl = (value) => isUrl(value) && value.protocol !== "file:";
+var isFilePathObject = (value) => isPlainObject3(value) && Object.keys(value).length > 0 && Object.keys(value).every((key) => FILE_PATH_KEYS.has(key)) && isFilePathString(value.file);
+var FILE_PATH_KEYS = /* @__PURE__ */ new Set(["file", "append"]);
+var isFilePathString = (file) => typeof file === "string";
+var isUnknownStdioString = (type, value) => type === "native" && typeof value === "string" && !KNOWN_STDIO_STRINGS.has(value);
+var KNOWN_STDIO_STRINGS = /* @__PURE__ */ new Set(["ipc", "ignore", "inherit", "overlapped", "pipe"]);
+var isReadableStream2 = (value) => Object.prototype.toString.call(value) === "[object ReadableStream]";
+var isWritableStream2 = (value) => Object.prototype.toString.call(value) === "[object WritableStream]";
+var isWebStream = (value) => isReadableStream2(value) || isWritableStream2(value);
+var isTransformStream = (value) => isReadableStream2(value?.readable) && isWritableStream2(value?.writable);
+var isAsyncIterableObject = (value) => isObject(value) && typeof value[Symbol.asyncIterator] === "function";
+var isIterableObject = (value) => isObject(value) && typeof value[Symbol.iterator] === "function";
+var isObject = (value) => typeof value === "object" && value !== null;
+var TRANSFORM_TYPES = /* @__PURE__ */ new Set(["generator", "asyncGenerator", "duplex", "webTransform"]);
+var FILE_TYPES = /* @__PURE__ */ new Set(["fileUrl", "filePath", "fileNumber"]);
+var SPECIAL_DUPLICATE_TYPES_SYNC = /* @__PURE__ */ new Set(["fileUrl", "filePath"]);
+var SPECIAL_DUPLICATE_TYPES = /* @__PURE__ */ new Set([...SPECIAL_DUPLICATE_TYPES_SYNC, "webStream", "nodeStream"]);
+var FORBID_DUPLICATE_TYPES = /* @__PURE__ */ new Set(["webTransform", "duplex"]);
+var TYPE_TO_MESSAGE = {
+ generator: "a generator",
+ asyncGenerator: "an async generator",
+ fileUrl: "a file URL",
+ filePath: "a file path string",
+ fileNumber: "a file descriptor number",
+ webStream: "a web stream",
+ nodeStream: "a Node.js stream",
+ webTransform: "a web TransformStream",
+ duplex: "a Duplex stream",
+ native: "any value",
+ iterable: "an iterable",
+ asyncIterable: "an async iterable",
+ string: "a string",
+ uint8Array: "a Uint8Array"
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/transform/object-mode.js
+var getTransformObjectModes = (objectMode, index, newTransforms, direction) => direction === "output" ? getOutputObjectModes(objectMode, index, newTransforms) : getInputObjectModes(objectMode, index, newTransforms);
+var getOutputObjectModes = (objectMode, index, newTransforms) => {
+ const writableObjectMode = index !== 0 && newTransforms[index - 1].value.readableObjectMode;
+ const readableObjectMode = objectMode ?? writableObjectMode;
+ return { writableObjectMode, readableObjectMode };
+};
+var getInputObjectModes = (objectMode, index, newTransforms) => {
+ const writableObjectMode = index === 0 ? objectMode === true : newTransforms[index - 1].value.readableObjectMode;
+ const readableObjectMode = index !== newTransforms.length - 1 && (objectMode ?? writableObjectMode);
+ return { writableObjectMode, readableObjectMode };
+};
+var getFdObjectMode = (stdioItems, direction) => {
+ const lastTransform = stdioItems.findLast(({ type }) => TRANSFORM_TYPES.has(type));
+ if (lastTransform === void 0) {
+ return false;
+ }
+ return direction === "input" ? lastTransform.value.writableObjectMode : lastTransform.value.readableObjectMode;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/transform/normalize.js
+var normalizeTransforms = (stdioItems, optionName, direction, options) => [
+ ...stdioItems.filter(({ type }) => !TRANSFORM_TYPES.has(type)),
+ ...getTransforms(stdioItems, optionName, direction, options)
+];
+var getTransforms = (stdioItems, optionName, direction, { encoding }) => {
+ const transforms = stdioItems.filter(({ type }) => TRANSFORM_TYPES.has(type));
+ const newTransforms = Array.from({ length: transforms.length });
+ for (const [index, stdioItem] of Object.entries(transforms)) {
+ newTransforms[index] = normalizeTransform({
+ stdioItem,
+ index: Number(index),
+ newTransforms,
+ optionName,
+ direction,
+ encoding
+ });
+ }
+ return sortTransforms(newTransforms, direction);
+};
+var normalizeTransform = ({ stdioItem, stdioItem: { type }, index, newTransforms, optionName, direction, encoding }) => {
+ if (type === "duplex") {
+ return normalizeDuplex({ stdioItem, optionName });
+ }
+ if (type === "webTransform") {
+ return normalizeTransformStream({
+ stdioItem,
+ index,
+ newTransforms,
+ direction
+ });
+ }
+ return normalizeGenerator({
+ stdioItem,
+ index,
+ newTransforms,
+ direction,
+ encoding
+ });
+};
+var normalizeDuplex = ({
+ stdioItem,
+ stdioItem: {
+ value: {
+ transform,
+ transform: { writableObjectMode, readableObjectMode },
+ objectMode = readableObjectMode
+ }
+ },
+ optionName
+}) => {
+ if (objectMode && !readableObjectMode) {
+ throw new TypeError(`The \`${optionName}.objectMode\` option can only be \`true\` if \`new Duplex({objectMode: true})\` is used.`);
+ }
+ if (!objectMode && readableObjectMode) {
+ throw new TypeError(`The \`${optionName}.objectMode\` option cannot be \`false\` if \`new Duplex({objectMode: true})\` is used.`);
+ }
+ return {
+ ...stdioItem,
+ value: { transform, writableObjectMode, readableObjectMode }
+ };
+};
+var normalizeTransformStream = ({ stdioItem, stdioItem: { value }, index, newTransforms, direction }) => {
+ const { transform, objectMode } = isPlainObject3(value) ? value : { transform: value };
+ const { writableObjectMode, readableObjectMode } = getTransformObjectModes(objectMode, index, newTransforms, direction);
+ return {
+ ...stdioItem,
+ value: { transform, writableObjectMode, readableObjectMode }
+ };
+};
+var normalizeGenerator = ({ stdioItem, stdioItem: { value }, index, newTransforms, direction, encoding }) => {
+ const {
+ transform,
+ final,
+ binary: binaryOption = false,
+ preserveNewlines = false,
+ objectMode
+ } = isPlainObject3(value) ? value : { transform: value };
+ const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
+ const { writableObjectMode, readableObjectMode } = getTransformObjectModes(objectMode, index, newTransforms, direction);
+ return {
+ ...stdioItem,
+ value: {
+ transform,
+ final,
+ binary,
+ preserveNewlines,
+ writableObjectMode,
+ readableObjectMode
+ }
+ };
+};
+var sortTransforms = (newTransforms, direction) => direction === "input" ? newTransforms.reverse() : newTransforms;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/stdio/direction.js
+var import_node_process9 = __toESM(require("node:process"), 1);
+var getStreamDirection = (stdioItems, fdNumber, optionName) => {
+ const directions = stdioItems.map((stdioItem) => getStdioItemDirection(stdioItem, fdNumber));
+ if (directions.includes("input") && directions.includes("output")) {
+ throw new TypeError(`The \`${optionName}\` option must not be an array of both readable and writable values.`);
+ }
+ return directions.find(Boolean) ?? DEFAULT_DIRECTION;
+};
+var getStdioItemDirection = ({ type, value }, fdNumber) => KNOWN_DIRECTIONS[fdNumber] ?? guessStreamDirection[type](value);
+var KNOWN_DIRECTIONS = ["input", "output", "output"];
+var anyDirection = () => void 0;
+var alwaysInput = () => "input";
+var guessStreamDirection = {
+ generator: anyDirection,
+ asyncGenerator: anyDirection,
+ fileUrl: anyDirection,
+ filePath: anyDirection,
+ iterable: alwaysInput,
+ asyncIterable: alwaysInput,
+ uint8Array: alwaysInput,
+ webStream: (value) => isWritableStream2(value) ? "output" : "input",
+ nodeStream(value) {
+ if (!isReadableStream(value, { checkOpen: false })) {
+ return "output";
+ }
+ return isWritableStream(value, { checkOpen: false }) ? void 0 : "input";
+ },
+ webTransform: anyDirection,
+ duplex: anyDirection,
+ native(value) {
+ const standardStreamDirection = getStandardStreamDirection(value);
+ if (standardStreamDirection !== void 0) {
+ return standardStreamDirection;
+ }
+ if (isStream(value, { checkOpen: false })) {
+ return guessStreamDirection.nodeStream(value);
+ }
+ }
+};
+var getStandardStreamDirection = (value) => {
+ if ([0, import_node_process9.default.stdin].includes(value)) {
+ return "input";
+ }
+ if ([1, 2, import_node_process9.default.stdout, import_node_process9.default.stderr].includes(value)) {
+ return "output";
+ }
+};
+var DEFAULT_DIRECTION = "output";
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/array.js
+var normalizeIpcStdioArray = (stdioArray, ipc) => ipc && !stdioArray.includes("ipc") ? [...stdioArray, "ipc"] : stdioArray;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/stdio/stdio-option.js
+var normalizeStdioOption = ({ stdio, ipc, buffer, ...options }, verboseInfo, isSync) => {
+ const stdioArray = getStdioArray(stdio, options).map((stdioOption, fdNumber) => addDefaultValue2(stdioOption, fdNumber));
+ return isSync ? normalizeStdioSync(stdioArray, buffer, verboseInfo) : normalizeIpcStdioArray(stdioArray, ipc);
+};
+var getStdioArray = (stdio, options) => {
+ if (stdio === void 0) {
+ return STANDARD_STREAMS_ALIASES.map((alias) => options[alias]);
+ }
+ if (hasAlias(options)) {
+ throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${STANDARD_STREAMS_ALIASES.map((alias) => `\`${alias}\``).join(", ")}`);
+ }
+ if (typeof stdio === "string") {
+ return [stdio, stdio, stdio];
+ }
+ if (!Array.isArray(stdio)) {
+ throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
+ }
+ const length = Math.max(stdio.length, STANDARD_STREAMS_ALIASES.length);
+ return Array.from({ length }, (_, fdNumber) => stdio[fdNumber]);
+};
+var hasAlias = (options) => STANDARD_STREAMS_ALIASES.some((alias) => options[alias] !== void 0);
+var addDefaultValue2 = (stdioOption, fdNumber) => {
+ if (Array.isArray(stdioOption)) {
+ return stdioOption.map((item) => addDefaultValue2(item, fdNumber));
+ }
+ if (stdioOption === null || stdioOption === void 0) {
+ return fdNumber >= STANDARD_STREAMS_ALIASES.length ? "ignore" : "pipe";
+ }
+ return stdioOption;
+};
+var normalizeStdioSync = (stdioArray, buffer, verboseInfo) => stdioArray.map((stdioOption, fdNumber) => !buffer[fdNumber] && fdNumber !== 0 && !isFullVerbose(verboseInfo, fdNumber) && isOutputPipeOnly(stdioOption) ? "ignore" : stdioOption);
+var isOutputPipeOnly = (stdioOption) => stdioOption === "pipe" || Array.isArray(stdioOption) && stdioOption.every((item) => item === "pipe");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/stdio/native.js
+var import_node_fs2 = require("node:fs");
+var import_node_tty2 = __toESM(require("node:tty"), 1);
+var handleNativeStream = ({ stdioItem, stdioItem: { type }, isStdioArray, fdNumber, direction, isSync }) => {
+ if (!isStdioArray || type !== "native") {
+ return stdioItem;
+ }
+ return isSync ? handleNativeStreamSync({ stdioItem, fdNumber, direction }) : handleNativeStreamAsync({ stdioItem, fdNumber });
+};
+var handleNativeStreamSync = ({ stdioItem, stdioItem: { value, optionName }, fdNumber, direction }) => {
+ const targetFd = getTargetFd({
+ value,
+ optionName,
+ fdNumber,
+ direction
+ });
+ if (targetFd !== void 0) {
+ return targetFd;
+ }
+ if (isStream(value, { checkOpen: false })) {
+ throw new TypeError(`The \`${optionName}: Stream\` option cannot both be an array and include a stream with synchronous methods.`);
+ }
+ return stdioItem;
+};
+var getTargetFd = ({ value, optionName, fdNumber, direction }) => {
+ const targetFdNumber = getTargetFdNumber(value, fdNumber);
+ if (targetFdNumber === void 0) {
+ return;
+ }
+ if (direction === "output") {
+ return { type: "fileNumber", value: targetFdNumber, optionName };
+ }
+ if (import_node_tty2.default.isatty(targetFdNumber)) {
+ throw new TypeError(`The \`${optionName}: ${serializeOptionValue(value)}\` option is invalid: it cannot be a TTY with synchronous methods.`);
+ }
+ return { type: "uint8Array", value: bufferToUint8Array((0, import_node_fs2.readFileSync)(targetFdNumber)), optionName };
+};
+var getTargetFdNumber = (value, fdNumber) => {
+ if (value === "inherit") {
+ return fdNumber;
+ }
+ if (typeof value === "number") {
+ return value;
+ }
+ const standardStreamIndex = STANDARD_STREAMS.indexOf(value);
+ if (standardStreamIndex !== -1) {
+ return standardStreamIndex;
+ }
+};
+var handleNativeStreamAsync = ({ stdioItem, stdioItem: { value, optionName }, fdNumber }) => {
+ if (value === "inherit") {
+ return { type: "nodeStream", value: getStandardStream(fdNumber, value, optionName), optionName };
+ }
+ if (typeof value === "number") {
+ return { type: "nodeStream", value: getStandardStream(value, value, optionName), optionName };
+ }
+ if (isStream(value, { checkOpen: false })) {
+ return { type: "nodeStream", value, optionName };
+ }
+ return stdioItem;
+};
+var getStandardStream = (fdNumber, value, optionName) => {
+ const standardStream = STANDARD_STREAMS[fdNumber];
+ if (standardStream === void 0) {
+ throw new TypeError(`The \`${optionName}: ${value}\` option is invalid: no such standard stream.`);
+ }
+ return standardStream;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/stdio/input-option.js
+var handleInputOptions = ({ input, inputFile }, fdNumber) => fdNumber === 0 ? [
+ ...handleInputOption(input),
+ ...handleInputFileOption(inputFile)
+] : [];
+var handleInputOption = (input) => input === void 0 ? [] : [{
+ type: getInputType(input),
+ value: input,
+ optionName: "input"
+}];
+var getInputType = (input) => {
+ if (isReadableStream(input, { checkOpen: false })) {
+ return "nodeStream";
+ }
+ if (typeof input === "string") {
+ return "string";
+ }
+ if (isUint8Array(input)) {
+ return "uint8Array";
+ }
+ throw new Error("The `input` option must be a string, a Uint8Array or a Node.js Readable stream.");
+};
+var handleInputFileOption = (inputFile) => inputFile === void 0 ? [] : [{
+ ...getInputFileType(inputFile),
+ optionName: "inputFile"
+}];
+var getInputFileType = (inputFile) => {
+ if (isUrl(inputFile)) {
+ return { type: "fileUrl", value: inputFile };
+ }
+ if (isFilePathString(inputFile)) {
+ return { type: "filePath", value: { file: inputFile } };
+ }
+ throw new Error("The `inputFile` option must be a file path string or a file URL.");
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/stdio/duplicate.js
+var filterDuplicates = (stdioItems) => stdioItems.filter((stdioItemOne, indexOne) => stdioItems.every((stdioItemTwo, indexTwo) => stdioItemOne.value !== stdioItemTwo.value || indexOne >= indexTwo || stdioItemOne.type === "generator" || stdioItemOne.type === "asyncGenerator"));
+var getDuplicateStream = ({ stdioItem: { type, value, optionName }, direction, fileDescriptors, isSync }) => {
+ const otherStdioItems = getOtherStdioItems(fileDescriptors, type);
+ if (otherStdioItems.length === 0) {
+ return;
+ }
+ if (isSync) {
+ validateDuplicateStreamSync({
+ otherStdioItems,
+ type,
+ value,
+ optionName,
+ direction
+ });
+ return;
+ }
+ if (SPECIAL_DUPLICATE_TYPES.has(type)) {
+ return getDuplicateStreamInstance({
+ otherStdioItems,
+ type,
+ value,
+ optionName,
+ direction
+ });
+ }
+ if (FORBID_DUPLICATE_TYPES.has(type)) {
+ validateDuplicateTransform({
+ otherStdioItems,
+ type,
+ value,
+ optionName
+ });
+ }
+};
+var getOtherStdioItems = (fileDescriptors, type) => fileDescriptors.flatMap(({ direction, stdioItems }) => stdioItems.filter((stdioItem) => stdioItem.type === type).map((stdioItem) => ({ ...stdioItem, direction })));
+var validateDuplicateStreamSync = ({ otherStdioItems, type, value, optionName, direction }) => {
+ if (SPECIAL_DUPLICATE_TYPES_SYNC.has(type)) {
+ getDuplicateStreamInstance({
+ otherStdioItems,
+ type,
+ value,
+ optionName,
+ direction
+ });
+ }
+};
+var getDuplicateStreamInstance = ({ otherStdioItems, type, value, optionName, direction }) => {
+ const duplicateStdioItems = otherStdioItems.filter((stdioItem) => hasSameValue(stdioItem, value));
+ if (duplicateStdioItems.length === 0) {
+ return;
+ }
+ const differentStdioItem = duplicateStdioItems.find((stdioItem) => stdioItem.direction !== direction);
+ throwOnDuplicateStream(differentStdioItem, optionName, type);
+ return direction === "output" ? duplicateStdioItems[0].stream : void 0;
+};
+var hasSameValue = ({ type, value }, secondValue) => {
+ if (type === "filePath") {
+ return value.file === secondValue.file;
+ }
+ if (type === "fileUrl") {
+ return value.href === secondValue.href;
+ }
+ return value === secondValue;
+};
+var validateDuplicateTransform = ({ otherStdioItems, type, value, optionName }) => {
+ const duplicateStdioItem = otherStdioItems.find(({ value: { transform } }) => transform === value.transform);
+ throwOnDuplicateStream(duplicateStdioItem, optionName, type);
+};
+var throwOnDuplicateStream = (stdioItem, optionName, type) => {
+ if (stdioItem !== void 0) {
+ throw new TypeError(`The \`${stdioItem.optionName}\` and \`${optionName}\` options must not target ${TYPE_TO_MESSAGE[type]} that is the same.`);
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/stdio/handle.js
+var handleStdio = (addProperties3, options, verboseInfo, isSync) => {
+ const stdio = normalizeStdioOption(options, verboseInfo, isSync);
+ const initialFileDescriptors = stdio.map((stdioOption, fdNumber) => getFileDescriptor({
+ stdioOption,
+ fdNumber,
+ options,
+ isSync
+ }));
+ const fileDescriptors = getFinalFileDescriptors({
+ initialFileDescriptors,
+ addProperties: addProperties3,
+ options,
+ isSync
+ });
+ options.stdio = fileDescriptors.map(({ stdioItems }) => forwardStdio(stdioItems));
+ return fileDescriptors;
+};
+var getFileDescriptor = ({ stdioOption, fdNumber, options, isSync }) => {
+ const optionName = getStreamName(fdNumber);
+ const { stdioItems: initialStdioItems, isStdioArray } = initializeStdioItems({
+ stdioOption,
+ fdNumber,
+ options,
+ optionName
+ });
+ const direction = getStreamDirection(initialStdioItems, fdNumber, optionName);
+ const stdioItems = initialStdioItems.map((stdioItem) => handleNativeStream({
+ stdioItem,
+ isStdioArray,
+ fdNumber,
+ direction,
+ isSync
+ }));
+ const normalizedStdioItems = normalizeTransforms(stdioItems, optionName, direction, options);
+ const objectMode = getFdObjectMode(normalizedStdioItems, direction);
+ validateFileObjectMode(normalizedStdioItems, objectMode);
+ return { direction, objectMode, stdioItems: normalizedStdioItems };
+};
+var initializeStdioItems = ({ stdioOption, fdNumber, options, optionName }) => {
+ const values = Array.isArray(stdioOption) ? stdioOption : [stdioOption];
+ const initialStdioItems = [
+ ...values.map((value) => initializeStdioItem(value, optionName)),
+ ...handleInputOptions(options, fdNumber)
+ ];
+ const stdioItems = filterDuplicates(initialStdioItems);
+ const isStdioArray = stdioItems.length > 1;
+ validateStdioArray(stdioItems, isStdioArray, optionName);
+ validateStreams(stdioItems);
+ return { stdioItems, isStdioArray };
+};
+var initializeStdioItem = (value, optionName) => ({
+ type: getStdioItemType(value, optionName),
+ value,
+ optionName
+});
+var validateStdioArray = (stdioItems, isStdioArray, optionName) => {
+ if (stdioItems.length === 0) {
+ throw new TypeError(`The \`${optionName}\` option must not be an empty array.`);
+ }
+ if (!isStdioArray) {
+ return;
+ }
+ for (const { value, optionName: optionName2 } of stdioItems) {
+ if (INVALID_STDIO_ARRAY_OPTIONS.has(value)) {
+ throw new Error(`The \`${optionName2}\` option must not include \`${value}\`.`);
+ }
+ }
+};
+var INVALID_STDIO_ARRAY_OPTIONS = /* @__PURE__ */ new Set(["ignore", "ipc"]);
+var validateStreams = (stdioItems) => {
+ for (const stdioItem of stdioItems) {
+ validateFileStdio(stdioItem);
+ }
+};
+var validateFileStdio = ({ type, value, optionName }) => {
+ if (isRegularUrl(value)) {
+ throw new TypeError(`The \`${optionName}: URL\` option must use the \`file:\` scheme.
+For example, you can use the \`pathToFileURL()\` method of the \`url\` core module.`);
+ }
+ if (isUnknownStdioString(type, value)) {
+ throw new TypeError(`The \`${optionName}: { file: '...' }\` option must be used instead of \`${optionName}: '...'\`.`);
+ }
+};
+var validateFileObjectMode = (stdioItems, objectMode) => {
+ if (!objectMode) {
+ return;
+ }
+ const fileStdioItem = stdioItems.find(({ type }) => FILE_TYPES.has(type));
+ if (fileStdioItem !== void 0) {
+ throw new TypeError(`The \`${fileStdioItem.optionName}\` option cannot use both files and transforms in objectMode.`);
+ }
+};
+var getFinalFileDescriptors = ({ initialFileDescriptors, addProperties: addProperties3, options, isSync }) => {
+ const fileDescriptors = [];
+ try {
+ for (const fileDescriptor of initialFileDescriptors) {
+ fileDescriptors.push(getFinalFileDescriptor({
+ fileDescriptor,
+ fileDescriptors,
+ addProperties: addProperties3,
+ options,
+ isSync
+ }));
+ }
+ return fileDescriptors;
+ } catch (error) {
+ cleanupCustomStreams(fileDescriptors);
+ throw error;
+ }
+};
+var getFinalFileDescriptor = ({
+ fileDescriptor: { direction, objectMode, stdioItems },
+ fileDescriptors,
+ addProperties: addProperties3,
+ options,
+ isSync
+}) => {
+ const finalStdioItems = stdioItems.map((stdioItem) => addStreamProperties({
+ stdioItem,
+ addProperties: addProperties3,
+ direction,
+ options,
+ fileDescriptors,
+ isSync
+ }));
+ return { direction, objectMode, stdioItems: finalStdioItems };
+};
+var addStreamProperties = ({ stdioItem, addProperties: addProperties3, direction, options, fileDescriptors, isSync }) => {
+ const duplicateStream = getDuplicateStream({
+ stdioItem,
+ direction,
+ fileDescriptors,
+ isSync
+ });
+ if (duplicateStream !== void 0) {
+ return { ...stdioItem, stream: duplicateStream };
+ }
+ return {
+ ...stdioItem,
+ ...addProperties3[direction][stdioItem.type](stdioItem, options)
+ };
+};
+var cleanupCustomStreams = (fileDescriptors) => {
+ for (const { stdioItems } of fileDescriptors) {
+ for (const { stream } of stdioItems) {
+ if (stream !== void 0 && !isStandardStream(stream)) {
+ stream.destroy();
+ }
+ }
+ }
+};
+var forwardStdio = (stdioItems) => {
+ if (stdioItems.length > 1) {
+ return stdioItems.some(({ value: value2 }) => value2 === "overlapped") ? "overlapped" : "pipe";
+ }
+ const [{ type, value }] = stdioItems;
+ return type === "native" ? value : "pipe";
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/stdio/handle-sync.js
+var handleStdioSync = (options, verboseInfo) => handleStdio(addPropertiesSync, options, verboseInfo, true);
+var forbiddenIfSync = ({ type, optionName }) => {
+ throwInvalidSyncValue(optionName, TYPE_TO_MESSAGE[type]);
+};
+var forbiddenNativeIfSync = ({ optionName, value }) => {
+ if (value === "ipc" || value === "overlapped") {
+ throwInvalidSyncValue(optionName, `"${value}"`);
+ }
+ return {};
+};
+var throwInvalidSyncValue = (optionName, value) => {
+ throw new TypeError(`The \`${optionName}\` option cannot be ${value} with synchronous methods.`);
+};
+var addProperties = {
+ generator() {
+ },
+ asyncGenerator: forbiddenIfSync,
+ webStream: forbiddenIfSync,
+ nodeStream: forbiddenIfSync,
+ webTransform: forbiddenIfSync,
+ duplex: forbiddenIfSync,
+ asyncIterable: forbiddenIfSync,
+ native: forbiddenNativeIfSync
+};
+var addPropertiesSync = {
+ input: {
+ ...addProperties,
+ fileUrl: ({ value }) => ({ contents: [bufferToUint8Array((0, import_node_fs3.readFileSync)(value))] }),
+ filePath: ({ value: { file } }) => ({ contents: [bufferToUint8Array((0, import_node_fs3.readFileSync)(file))] }),
+ fileNumber: forbiddenIfSync,
+ iterable: ({ value }) => ({ contents: [...value] }),
+ string: ({ value }) => ({ contents: [value] }),
+ uint8Array: ({ value }) => ({ contents: [value] })
+ },
+ output: {
+ ...addProperties,
+ fileUrl: ({ value }) => ({ path: value }),
+ filePath: ({ value: { file, append } }) => ({ path: file, append }),
+ fileNumber: ({ value }) => ({ path: value }),
+ iterable: forbiddenIfSync,
+ string: forbiddenIfSync,
+ uint8Array: forbiddenIfSync
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/io/strip-newline.js
+var stripNewline = (value, { stripFinalNewline: stripFinalNewline2 }, fdNumber) => getStripFinalNewline(stripFinalNewline2, fdNumber) && value !== void 0 && !Array.isArray(value) ? stripFinalNewline(value) : value;
+var getStripFinalNewline = (stripFinalNewline2, fdNumber) => fdNumber === "all" ? stripFinalNewline2[1] || stripFinalNewline2[2] : stripFinalNewline2[fdNumber];
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/transform/generator.js
+var import_node_stream = require("node:stream");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/transform/split.js
+var getSplitLinesGenerator = (binary, preserveNewlines, skipped, state) => binary || skipped ? void 0 : initializeSplitLines(preserveNewlines, state);
+var splitLinesSync = (chunk, preserveNewlines, objectMode) => objectMode ? chunk.flatMap((item) => splitLinesItemSync(item, preserveNewlines)) : splitLinesItemSync(chunk, preserveNewlines);
+var splitLinesItemSync = (chunk, preserveNewlines) => {
+ const { transform, final } = initializeSplitLines(preserveNewlines, {});
+ return [...transform(chunk), ...final()];
+};
+var initializeSplitLines = (preserveNewlines, state) => {
+ state.previousChunks = "";
+ return {
+ transform: splitGenerator.bind(void 0, state, preserveNewlines),
+ final: linesFinal.bind(void 0, state)
+ };
+};
+var splitGenerator = function* (state, preserveNewlines, chunk) {
+ if (typeof chunk !== "string") {
+ yield chunk;
+ return;
+ }
+ let { previousChunks } = state;
+ let start = -1;
+ for (let end = 0; end < chunk.length; end += 1) {
+ if (chunk[end] === "\n") {
+ const newlineLength = getNewlineLength(chunk, end, preserveNewlines, state);
+ let line = chunk.slice(start + 1, end + 1 - newlineLength);
+ if (previousChunks.length > 0) {
+ line = concatString(previousChunks, line);
+ previousChunks = "";
+ }
+ yield line;
+ start = end;
+ }
+ }
+ if (start !== chunk.length - 1) {
+ previousChunks = concatString(previousChunks, chunk.slice(start + 1));
+ }
+ state.previousChunks = previousChunks;
+};
+var getNewlineLength = (chunk, end, preserveNewlines, state) => {
+ if (preserveNewlines) {
+ return 0;
+ }
+ state.isWindowsNewline = end !== 0 && chunk[end - 1] === "\r";
+ return state.isWindowsNewline ? 2 : 1;
+};
+var linesFinal = function* ({ previousChunks }) {
+ if (previousChunks.length > 0) {
+ yield previousChunks;
+ }
+};
+var getAppendNewlineGenerator = ({ binary, preserveNewlines, readableObjectMode, state }) => binary || preserveNewlines || readableObjectMode ? void 0 : { transform: appendNewlineGenerator.bind(void 0, state) };
+var appendNewlineGenerator = function* ({ isWindowsNewline = false }, chunk) {
+ const { unixNewline, windowsNewline, LF: LF2, concatBytes } = typeof chunk === "string" ? linesStringInfo : linesUint8ArrayInfo;
+ if (chunk.at(-1) === LF2) {
+ yield chunk;
+ return;
+ }
+ const newline = isWindowsNewline ? windowsNewline : unixNewline;
+ yield concatBytes(chunk, newline);
+};
+var concatString = (firstChunk, secondChunk) => `${firstChunk}${secondChunk}`;
+var linesStringInfo = {
+ windowsNewline: "\r\n",
+ unixNewline: "\n",
+ LF: "\n",
+ concatBytes: concatString
+};
+var concatUint8Array = (firstChunk, secondChunk) => {
+ const chunk = new Uint8Array(firstChunk.length + secondChunk.length);
+ chunk.set(firstChunk, 0);
+ chunk.set(secondChunk, firstChunk.length);
+ return chunk;
+};
+var linesUint8ArrayInfo = {
+ windowsNewline: new Uint8Array([13, 10]),
+ unixNewline: new Uint8Array([10]),
+ LF: 10,
+ concatBytes: concatUint8Array
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/transform/validate.js
+var import_node_buffer = require("node:buffer");
+var getValidateTransformInput = (writableObjectMode, optionName) => writableObjectMode ? void 0 : validateStringTransformInput.bind(void 0, optionName);
+var validateStringTransformInput = function* (optionName, chunk) {
+ if (typeof chunk !== "string" && !isUint8Array(chunk) && !import_node_buffer.Buffer.isBuffer(chunk)) {
+ throw new TypeError(`The \`${optionName}\` option's transform must use "objectMode: true" to receive as input: ${typeof chunk}.`);
+ }
+ yield chunk;
+};
+var getValidateTransformReturn = (readableObjectMode, optionName) => readableObjectMode ? validateObjectTransformReturn.bind(void 0, optionName) : validateStringTransformReturn.bind(void 0, optionName);
+var validateObjectTransformReturn = function* (optionName, chunk) {
+ validateEmptyReturn(optionName, chunk);
+ yield chunk;
+};
+var validateStringTransformReturn = function* (optionName, chunk) {
+ validateEmptyReturn(optionName, chunk);
+ if (typeof chunk !== "string" && !isUint8Array(chunk)) {
+ throw new TypeError(`The \`${optionName}\` option's function must yield a string or an Uint8Array, not ${typeof chunk}.`);
+ }
+ yield chunk;
+};
+var validateEmptyReturn = (optionName, chunk) => {
+ if (chunk === null || chunk === void 0) {
+ throw new TypeError(`The \`${optionName}\` option's function must not call \`yield ${chunk}\`.
+Instead, \`yield\` should either be called with a value, or not be called at all. For example:
+ if (condition) { yield value; }`);
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/transform/encoding-transform.js
+var import_node_buffer2 = require("node:buffer");
+var import_node_string_decoder2 = require("node:string_decoder");
+var getEncodingTransformGenerator = (binary, encoding, skipped) => {
+ if (skipped) {
+ return;
+ }
+ if (binary) {
+ return { transform: encodingUint8ArrayGenerator.bind(void 0, new TextEncoder()) };
+ }
+ const stringDecoder = new import_node_string_decoder2.StringDecoder(encoding);
+ return {
+ transform: encodingStringGenerator.bind(void 0, stringDecoder),
+ final: encodingStringFinal.bind(void 0, stringDecoder)
+ };
+};
+var encodingUint8ArrayGenerator = function* (textEncoder3, chunk) {
+ if (import_node_buffer2.Buffer.isBuffer(chunk)) {
+ yield bufferToUint8Array(chunk);
+ } else if (typeof chunk === "string") {
+ yield textEncoder3.encode(chunk);
+ } else {
+ yield chunk;
+ }
+};
+var encodingStringGenerator = function* (stringDecoder, chunk) {
+ yield isUint8Array(chunk) ? stringDecoder.write(chunk) : chunk;
+};
+var encodingStringFinal = function* (stringDecoder) {
+ const lastChunk = stringDecoder.end();
+ if (lastChunk !== "") {
+ yield lastChunk;
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/transform/run-async.js
+var import_node_util7 = require("node:util");
+var pushChunks = (0, import_node_util7.callbackify)(async (getChunks, state, getChunksArguments, transformStream) => {
+ state.currentIterable = getChunks(...getChunksArguments);
+ try {
+ for await (const chunk of state.currentIterable) {
+ transformStream.push(chunk);
+ }
+ } finally {
+ delete state.currentIterable;
+ }
+});
+var transformChunk = async function* (chunk, generators, index) {
+ if (index === generators.length) {
+ yield chunk;
+ return;
+ }
+ const { transform = identityGenerator } = generators[index];
+ for await (const transformedChunk of transform(chunk)) {
+ yield* transformChunk(transformedChunk, generators, index + 1);
+ }
+};
+var finalChunks = async function* (generators) {
+ for (const [index, { final }] of Object.entries(generators)) {
+ yield* generatorFinalChunks(final, Number(index), generators);
+ }
+};
+var generatorFinalChunks = async function* (final, index, generators) {
+ if (final === void 0) {
+ return;
+ }
+ for await (const finalChunk of final()) {
+ yield* transformChunk(finalChunk, generators, index + 1);
+ }
+};
+var destroyTransform = (0, import_node_util7.callbackify)(async ({ currentIterable }, error) => {
+ if (currentIterable !== void 0) {
+ await (error ? currentIterable.throw(error) : currentIterable.return());
+ return;
+ }
+ if (error) {
+ throw error;
+ }
+});
+var identityGenerator = function* (chunk) {
+ yield chunk;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/transform/run-sync.js
+var pushChunksSync = (getChunksSync, getChunksArguments, transformStream, done) => {
+ try {
+ for (const chunk of getChunksSync(...getChunksArguments)) {
+ transformStream.push(chunk);
+ }
+ done();
+ } catch (error) {
+ done(error);
+ }
+};
+var runTransformSync = (generators, chunks) => [
+ ...chunks.flatMap((chunk) => [...transformChunkSync(chunk, generators, 0)]),
+ ...finalChunksSync(generators)
+];
+var transformChunkSync = function* (chunk, generators, index) {
+ if (index === generators.length) {
+ yield chunk;
+ return;
+ }
+ const { transform = identityGenerator2 } = generators[index];
+ for (const transformedChunk of transform(chunk)) {
+ yield* transformChunkSync(transformedChunk, generators, index + 1);
+ }
+};
+var finalChunksSync = function* (generators) {
+ for (const [index, { final }] of Object.entries(generators)) {
+ yield* generatorFinalChunksSync(final, Number(index), generators);
+ }
+};
+var generatorFinalChunksSync = function* (final, index, generators) {
+ if (final === void 0) {
+ return;
+ }
+ for (const finalChunk of final()) {
+ yield* transformChunkSync(finalChunk, generators, index + 1);
+ }
+};
+var identityGenerator2 = function* (chunk) {
+ yield chunk;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/transform/generator.js
+var generatorToStream = ({
+ value,
+ value: { transform, final, writableObjectMode, readableObjectMode },
+ optionName
+}, { encoding }) => {
+ const state = {};
+ const generators = addInternalGenerators(value, encoding, optionName);
+ const transformAsync = isAsyncGenerator(transform);
+ const finalAsync = isAsyncGenerator(final);
+ const transformMethod = transformAsync ? pushChunks.bind(void 0, transformChunk, state) : pushChunksSync.bind(void 0, transformChunkSync);
+ const finalMethod = transformAsync || finalAsync ? pushChunks.bind(void 0, finalChunks, state) : pushChunksSync.bind(void 0, finalChunksSync);
+ const destroyMethod = transformAsync || finalAsync ? destroyTransform.bind(void 0, state) : void 0;
+ const stream = new import_node_stream.Transform({
+ writableObjectMode,
+ writableHighWaterMark: (0, import_node_stream.getDefaultHighWaterMark)(writableObjectMode),
+ readableObjectMode,
+ readableHighWaterMark: (0, import_node_stream.getDefaultHighWaterMark)(readableObjectMode),
+ transform(chunk, encoding2, done) {
+ transformMethod([chunk, generators, 0], this, done);
+ },
+ flush(done) {
+ finalMethod([generators], this, done);
+ },
+ destroy: destroyMethod
+ });
+ return { stream };
+};
+var runGeneratorsSync = (chunks, stdioItems, encoding, isInput) => {
+ const generators = stdioItems.filter(({ type }) => type === "generator");
+ const reversedGenerators = isInput ? generators.reverse() : generators;
+ for (const { value, optionName } of reversedGenerators) {
+ const generators2 = addInternalGenerators(value, encoding, optionName);
+ chunks = runTransformSync(generators2, chunks);
+ }
+ return chunks;
+};
+var addInternalGenerators = ({ transform, final, binary, writableObjectMode, readableObjectMode, preserveNewlines }, encoding, optionName) => {
+ const state = {};
+ return [
+ { transform: getValidateTransformInput(writableObjectMode, optionName) },
+ getEncodingTransformGenerator(binary, encoding, writableObjectMode),
+ getSplitLinesGenerator(binary, preserveNewlines, writableObjectMode, state),
+ { transform, final },
+ { transform: getValidateTransformReturn(readableObjectMode, optionName) },
+ getAppendNewlineGenerator({
+ binary,
+ preserveNewlines,
+ readableObjectMode,
+ state
+ })
+ ].filter(Boolean);
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/io/input-sync.js
+var addInputOptionsSync = (fileDescriptors, options) => {
+ for (const fdNumber of getInputFdNumbers(fileDescriptors)) {
+ addInputOptionSync(fileDescriptors, fdNumber, options);
+ }
+};
+var getInputFdNumbers = (fileDescriptors) => new Set(Object.entries(fileDescriptors).filter(([, { direction }]) => direction === "input").map(([fdNumber]) => Number(fdNumber)));
+var addInputOptionSync = (fileDescriptors, fdNumber, options) => {
+ const { stdioItems } = fileDescriptors[fdNumber];
+ const allStdioItems = stdioItems.filter(({ contents }) => contents !== void 0);
+ if (allStdioItems.length === 0) {
+ return;
+ }
+ if (fdNumber !== 0) {
+ const [{ type, optionName }] = allStdioItems;
+ throw new TypeError(`Only the \`stdin\` option, not \`${optionName}\`, can be ${TYPE_TO_MESSAGE[type]} with synchronous methods.`);
+ }
+ const allContents = allStdioItems.map(({ contents }) => contents);
+ const transformedContents = allContents.map((contents) => applySingleInputGeneratorsSync(contents, stdioItems));
+ options.input = joinToUint8Array(transformedContents);
+};
+var applySingleInputGeneratorsSync = (contents, stdioItems) => {
+ const newContents = runGeneratorsSync(contents, stdioItems, "utf8", true);
+ validateSerializable(newContents);
+ return joinToUint8Array(newContents);
+};
+var validateSerializable = (newContents) => {
+ const invalidItem = newContents.find((item) => typeof item !== "string" && !isUint8Array(item));
+ if (invalidItem !== void 0) {
+ throw new TypeError(`The \`stdin\` option is invalid: when passing objects as input, a transform must be used to serialize them to strings or Uint8Arrays: ${invalidItem}.`);
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/io/output-sync.js
+var import_node_fs4 = require("node:fs");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/verbose/output.js
+var shouldLogOutput = ({ stdioItems, encoding, verboseInfo, fdNumber }) => fdNumber !== "all" && isFullVerbose(verboseInfo, fdNumber) && !BINARY_ENCODINGS.has(encoding) && fdUsesVerbose(fdNumber) && (stdioItems.some(({ type, value }) => type === "native" && PIPED_STDIO_VALUES.has(value)) || stdioItems.every(({ type }) => TRANSFORM_TYPES.has(type)));
+var fdUsesVerbose = (fdNumber) => fdNumber === 1 || fdNumber === 2;
+var PIPED_STDIO_VALUES = /* @__PURE__ */ new Set(["pipe", "overlapped"]);
+var logLines = async (linesIterable, stream, fdNumber, verboseInfo) => {
+ for await (const line of linesIterable) {
+ if (!isPipingStream(stream)) {
+ logLine(line, fdNumber, verboseInfo);
+ }
+ }
+};
+var logLinesSync = (linesArray, fdNumber, verboseInfo) => {
+ for (const line of linesArray) {
+ logLine(line, fdNumber, verboseInfo);
+ }
+};
+var isPipingStream = (stream) => stream._readableState.pipes.length > 0;
+var logLine = (line, fdNumber, verboseInfo) => {
+ const verboseMessage = serializeVerboseMessage(line);
+ verboseLog({
+ type: "output",
+ verboseMessage,
+ fdNumber,
+ verboseInfo
+ });
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/io/output-sync.js
+var transformOutputSync = ({ fileDescriptors, syncResult: { output }, options, isMaxBuffer, verboseInfo }) => {
+ if (output === null) {
+ return { output: Array.from({ length: 3 }) };
+ }
+ const state = {};
+ const outputFiles = /* @__PURE__ */ new Set([]);
+ const transformedOutput = output.map((result, fdNumber) => transformOutputResultSync({
+ result,
+ fileDescriptors,
+ fdNumber,
+ state,
+ outputFiles,
+ isMaxBuffer,
+ verboseInfo
+ }, options));
+ return { output: transformedOutput, ...state };
+};
+var transformOutputResultSync = ({ result, fileDescriptors, fdNumber, state, outputFiles, isMaxBuffer, verboseInfo }, { buffer, encoding, lines, stripFinalNewline: stripFinalNewline2, maxBuffer }) => {
+ if (result === null) {
+ return;
+ }
+ const truncatedResult = truncateMaxBufferSync(result, isMaxBuffer, maxBuffer);
+ const uint8ArrayResult = bufferToUint8Array(truncatedResult);
+ const { stdioItems, objectMode } = fileDescriptors[fdNumber];
+ const chunks = runOutputGeneratorsSync([uint8ArrayResult], stdioItems, encoding, state);
+ const { serializedResult, finalResult = serializedResult } = serializeChunks({
+ chunks,
+ objectMode,
+ encoding,
+ lines,
+ stripFinalNewline: stripFinalNewline2,
+ fdNumber
+ });
+ logOutputSync({
+ serializedResult,
+ fdNumber,
+ state,
+ verboseInfo,
+ encoding,
+ stdioItems,
+ objectMode
+ });
+ const returnedResult = buffer[fdNumber] ? finalResult : void 0;
+ try {
+ if (state.error === void 0) {
+ writeToFiles(serializedResult, stdioItems, outputFiles);
+ }
+ return returnedResult;
+ } catch (error) {
+ state.error = error;
+ return returnedResult;
+ }
+};
+var runOutputGeneratorsSync = (chunks, stdioItems, encoding, state) => {
+ try {
+ return runGeneratorsSync(chunks, stdioItems, encoding, false);
+ } catch (error) {
+ state.error = error;
+ return chunks;
+ }
+};
+var serializeChunks = ({ chunks, objectMode, encoding, lines, stripFinalNewline: stripFinalNewline2, fdNumber }) => {
+ if (objectMode) {
+ return { serializedResult: chunks };
+ }
+ if (encoding === "buffer") {
+ return { serializedResult: joinToUint8Array(chunks) };
+ }
+ const serializedResult = joinToString(chunks, encoding);
+ if (lines[fdNumber]) {
+ return { serializedResult, finalResult: splitLinesSync(serializedResult, !stripFinalNewline2[fdNumber], objectMode) };
+ }
+ return { serializedResult };
+};
+var logOutputSync = ({ serializedResult, fdNumber, state, verboseInfo, encoding, stdioItems, objectMode }) => {
+ if (!shouldLogOutput({
+ stdioItems,
+ encoding,
+ verboseInfo,
+ fdNumber
+ })) {
+ return;
+ }
+ const linesArray = splitLinesSync(serializedResult, false, objectMode);
+ try {
+ logLinesSync(linesArray, fdNumber, verboseInfo);
+ } catch (error) {
+ state.error ??= error;
+ }
+};
+var writeToFiles = (serializedResult, stdioItems, outputFiles) => {
+ for (const { path: path7, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
+ const pathString = typeof path7 === "string" ? path7 : path7.toString();
+ if (append || outputFiles.has(pathString)) {
+ (0, import_node_fs4.appendFileSync)(path7, serializedResult);
+ } else {
+ outputFiles.add(pathString);
+ (0, import_node_fs4.writeFileSync)(path7, serializedResult);
+ }
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/resolve/all-sync.js
+var getAllSync = ([, stdout, stderr], options) => {
+ if (!options.all) {
+ return;
+ }
+ if (stdout === void 0) {
+ return stderr;
+ }
+ if (stderr === void 0) {
+ return stdout;
+ }
+ if (Array.isArray(stdout)) {
+ return Array.isArray(stderr) ? [...stdout, ...stderr] : [...stdout, stripNewline(stderr, options, "all")];
+ }
+ if (Array.isArray(stderr)) {
+ return [stripNewline(stdout, options, "all"), ...stderr];
+ }
+ if (isUint8Array(stdout) && isUint8Array(stderr)) {
+ return concatUint8Arrays([stdout, stderr]);
+ }
+ return `${stdout}${stderr}`;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/resolve/exit-async.js
+var import_node_events7 = require("node:events");
+var waitForExit = async (subprocess, context3) => {
+ const [exitCode, signal] = await waitForExitOrError(subprocess);
+ context3.isForcefullyTerminated ??= false;
+ return [exitCode, signal];
+};
+var waitForExitOrError = async (subprocess) => {
+ const [spawnPayload, exitPayload] = await Promise.allSettled([
+ (0, import_node_events7.once)(subprocess, "spawn"),
+ (0, import_node_events7.once)(subprocess, "exit")
+ ]);
+ if (spawnPayload.status === "rejected") {
+ return [];
+ }
+ return exitPayload.status === "rejected" ? waitForSubprocessExit(subprocess) : exitPayload.value;
+};
+var waitForSubprocessExit = async (subprocess) => {
+ try {
+ return await (0, import_node_events7.once)(subprocess, "exit");
+ } catch {
+ return waitForSubprocessExit(subprocess);
+ }
+};
+var waitForSuccessfulExit = async (exitPromise) => {
+ const [exitCode, signal] = await exitPromise;
+ if (!isSubprocessErrorExit(exitCode, signal) && isFailedExit(exitCode, signal)) {
+ throw new DiscardedError();
+ }
+ return [exitCode, signal];
+};
+var isSubprocessErrorExit = (exitCode, signal) => exitCode === void 0 && signal === void 0;
+var isFailedExit = (exitCode, signal) => exitCode !== 0 || signal !== null;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/resolve/exit-sync.js
+var getExitResultSync = ({ error, status: exitCode, signal, output }, { maxBuffer }) => {
+ const resultError = getResultError(error, exitCode, signal);
+ const timedOut = resultError?.code === "ETIMEDOUT";
+ const isMaxBuffer = isMaxBufferSync(resultError, output, maxBuffer);
+ return {
+ resultError,
+ exitCode,
+ signal,
+ timedOut,
+ isMaxBuffer
+ };
+};
+var getResultError = (error, exitCode, signal) => {
+ if (error !== void 0) {
+ return error;
+ }
+ return isFailedExit(exitCode, signal) ? new DiscardedError() : void 0;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/methods/main-sync.js
+var execaCoreSync = (rawFile, rawArguments, rawOptions) => {
+ const { file, commandArguments, command, escapedCommand, startTime, verboseInfo, options, fileDescriptors } = handleSyncArguments(rawFile, rawArguments, rawOptions);
+ const result = spawnSubprocessSync({
+ file,
+ commandArguments,
+ options,
+ command,
+ escapedCommand,
+ verboseInfo,
+ fileDescriptors,
+ startTime
+ });
+ return handleResult(result, verboseInfo, options);
+};
+var handleSyncArguments = (rawFile, rawArguments, rawOptions) => {
+ const { command, escapedCommand, startTime, verboseInfo } = handleCommand(rawFile, rawArguments, rawOptions);
+ const syncOptions = normalizeSyncOptions(rawOptions);
+ const { file, commandArguments, options } = normalizeOptions(rawFile, rawArguments, syncOptions);
+ validateSyncOptions(options);
+ const fileDescriptors = handleStdioSync(options, verboseInfo);
+ return {
+ file,
+ commandArguments,
+ command,
+ escapedCommand,
+ startTime,
+ verboseInfo,
+ options,
+ fileDescriptors
+ };
+};
+var normalizeSyncOptions = (options) => options.node && !options.ipc ? { ...options, ipc: false } : options;
+var validateSyncOptions = ({ ipc, ipcInput, detached, cancelSignal }) => {
+ if (ipcInput) {
+ throwInvalidSyncOption("ipcInput");
+ }
+ if (ipc) {
+ throwInvalidSyncOption("ipc: true");
+ }
+ if (detached) {
+ throwInvalidSyncOption("detached: true");
+ }
+ if (cancelSignal) {
+ throwInvalidSyncOption("cancelSignal");
+ }
+};
+var throwInvalidSyncOption = (value) => {
+ throw new TypeError(`The "${value}" option cannot be used with synchronous methods.`);
+};
+var spawnSubprocessSync = ({ file, commandArguments, options, command, escapedCommand, verboseInfo, fileDescriptors, startTime }) => {
+ const syncResult = runSubprocessSync({
+ file,
+ commandArguments,
+ options,
+ command,
+ escapedCommand,
+ fileDescriptors,
+ startTime
+ });
+ if (syncResult.failed) {
+ return syncResult;
+ }
+ const { resultError, exitCode, signal, timedOut, isMaxBuffer } = getExitResultSync(syncResult, options);
+ const { output, error = resultError } = transformOutputSync({
+ fileDescriptors,
+ syncResult,
+ options,
+ isMaxBuffer,
+ verboseInfo
+ });
+ const stdio = output.map((stdioOutput, fdNumber) => stripNewline(stdioOutput, options, fdNumber));
+ const all = stripNewline(getAllSync(output, options), options, "all");
+ return getSyncResult({
+ error,
+ exitCode,
+ signal,
+ timedOut,
+ isMaxBuffer,
+ stdio,
+ all,
+ options,
+ command,
+ escapedCommand,
+ startTime
+ });
+};
+var runSubprocessSync = ({ file, commandArguments, options, command, escapedCommand, fileDescriptors, startTime }) => {
+ try {
+ addInputOptionsSync(fileDescriptors, options);
+ const normalizedOptions = normalizeSpawnSyncOptions(options);
+ return (0, import_node_child_process3.spawnSync)(...concatenateShell(file, commandArguments, normalizedOptions));
+ } catch (error) {
+ return makeEarlyError({
+ error,
+ command,
+ escapedCommand,
+ fileDescriptors,
+ options,
+ startTime,
+ isSync: true
+ });
+ }
+};
+var normalizeSpawnSyncOptions = ({ encoding, maxBuffer, ...options }) => ({ ...options, encoding: "buffer", maxBuffer: getMaxBufferSync(maxBuffer) });
+var getSyncResult = ({ error, exitCode, signal, timedOut, isMaxBuffer, stdio, all, options, command, escapedCommand, startTime }) => error === void 0 ? makeSuccessResult({
+ command,
+ escapedCommand,
+ stdio,
+ all,
+ ipcOutput: [],
+ options,
+ startTime
+}) : makeError({
+ error,
+ command,
+ escapedCommand,
+ timedOut,
+ isCanceled: false,
+ isGracefullyCanceled: false,
+ isMaxBuffer,
+ isForcefullyTerminated: false,
+ exitCode,
+ signal,
+ stdio,
+ all,
+ ipcOutput: [],
+ options,
+ startTime,
+ isSync: true
+});
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/methods/main-async.js
+var import_node_events14 = require("node:events");
+var import_node_child_process5 = require("node:child_process");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/methods.js
+var import_node_process10 = __toESM(require("node:process"), 1);
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/get-one.js
+var import_node_events8 = require("node:events");
+var getOneMessage = ({ anyProcess, channel, isSubprocess, ipc }, { reference = true, filter } = {}) => {
+ validateIpcMethod({
+ methodName: "getOneMessage",
+ isSubprocess,
+ ipc,
+ isConnected: isConnected(anyProcess)
+ });
+ return getOneMessageAsync({
+ anyProcess,
+ channel,
+ isSubprocess,
+ filter,
+ reference
+ });
+};
+var getOneMessageAsync = async ({ anyProcess, channel, isSubprocess, filter, reference }) => {
+ addReference(channel, reference);
+ const ipcEmitter = getIpcEmitter(anyProcess, channel, isSubprocess);
+ const controller = new AbortController();
+ try {
+ return await Promise.race([
+ getMessage(ipcEmitter, filter, controller),
+ throwOnDisconnect2(ipcEmitter, isSubprocess, controller),
+ throwOnStrictError(ipcEmitter, isSubprocess, controller)
+ ]);
+ } catch (error) {
+ disconnect(anyProcess);
+ throw error;
+ } finally {
+ controller.abort();
+ removeReference(channel, reference);
+ }
+};
+var getMessage = async (ipcEmitter, filter, { signal }) => {
+ if (filter === void 0) {
+ const [message] = await (0, import_node_events8.once)(ipcEmitter, "message", { signal });
+ return message;
+ }
+ for await (const [message] of (0, import_node_events8.on)(ipcEmitter, "message", { signal })) {
+ if (filter(message)) {
+ return message;
+ }
+ }
+};
+var throwOnDisconnect2 = async (ipcEmitter, isSubprocess, { signal }) => {
+ await (0, import_node_events8.once)(ipcEmitter, "disconnect", { signal });
+ throwOnEarlyDisconnect(isSubprocess);
+};
+var throwOnStrictError = async (ipcEmitter, isSubprocess, { signal }) => {
+ const [error] = await (0, import_node_events8.once)(ipcEmitter, "strict:error", { signal });
+ throw getStrictResponseError(error, isSubprocess);
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/get-each.js
+var import_node_events9 = require("node:events");
+var getEachMessage = ({ anyProcess, channel, isSubprocess, ipc }, { reference = true } = {}) => loopOnMessages({
+ anyProcess,
+ channel,
+ isSubprocess,
+ ipc,
+ shouldAwait: !isSubprocess,
+ reference
+});
+var loopOnMessages = ({ anyProcess, channel, isSubprocess, ipc, shouldAwait, reference }) => {
+ validateIpcMethod({
+ methodName: "getEachMessage",
+ isSubprocess,
+ ipc,
+ isConnected: isConnected(anyProcess)
+ });
+ addReference(channel, reference);
+ const ipcEmitter = getIpcEmitter(anyProcess, channel, isSubprocess);
+ const controller = new AbortController();
+ const state = {};
+ stopOnDisconnect(anyProcess, ipcEmitter, controller);
+ abortOnStrictError({
+ ipcEmitter,
+ isSubprocess,
+ controller,
+ state
+ });
+ return iterateOnMessages({
+ anyProcess,
+ channel,
+ ipcEmitter,
+ isSubprocess,
+ shouldAwait,
+ controller,
+ state,
+ reference
+ });
+};
+var stopOnDisconnect = async (anyProcess, ipcEmitter, controller) => {
+ try {
+ await (0, import_node_events9.once)(ipcEmitter, "disconnect", { signal: controller.signal });
+ controller.abort();
+ } catch {
+ }
+};
+var abortOnStrictError = async ({ ipcEmitter, isSubprocess, controller, state }) => {
+ try {
+ const [error] = await (0, import_node_events9.once)(ipcEmitter, "strict:error", { signal: controller.signal });
+ state.error = getStrictResponseError(error, isSubprocess);
+ controller.abort();
+ } catch {
+ }
+};
+var iterateOnMessages = async function* ({ anyProcess, channel, ipcEmitter, isSubprocess, shouldAwait, controller, state, reference }) {
+ try {
+ for await (const [message] of (0, import_node_events9.on)(ipcEmitter, "message", { signal: controller.signal })) {
+ throwIfStrictError(state);
+ yield message;
+ }
+ } catch {
+ throwIfStrictError(state);
+ } finally {
+ controller.abort();
+ removeReference(channel, reference);
+ if (!isSubprocess) {
+ disconnect(anyProcess);
+ }
+ if (shouldAwait) {
+ await anyProcess;
+ }
+ }
+};
+var throwIfStrictError = ({ error }) => {
+ if (error) {
+ throw error;
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/methods.js
+var addIpcMethods = (subprocess, { ipc }) => {
+ Object.assign(subprocess, getIpcMethods(subprocess, false, ipc));
+};
+var getIpcExport = () => {
+ const anyProcess = import_node_process10.default;
+ const isSubprocess = true;
+ const ipc = import_node_process10.default.channel !== void 0;
+ return {
+ ...getIpcMethods(anyProcess, isSubprocess, ipc),
+ getCancelSignal: getCancelSignal.bind(void 0, {
+ anyProcess,
+ channel: anyProcess.channel,
+ isSubprocess,
+ ipc
+ })
+ };
+};
+var getIpcMethods = (anyProcess, isSubprocess, ipc) => ({
+ sendMessage: sendMessage.bind(void 0, {
+ anyProcess,
+ channel: anyProcess.channel,
+ isSubprocess,
+ ipc
+ }),
+ getOneMessage: getOneMessage.bind(void 0, {
+ anyProcess,
+ channel: anyProcess.channel,
+ isSubprocess,
+ ipc
+ }),
+ getEachMessage: getEachMessage.bind(void 0, {
+ anyProcess,
+ channel: anyProcess.channel,
+ isSubprocess,
+ ipc
+ })
+});
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/return/early-error.js
+var import_node_child_process4 = require("node:child_process");
+var import_node_stream2 = require("node:stream");
+var handleEarlyError = ({ error, command, escapedCommand, fileDescriptors, options, startTime, verboseInfo }) => {
+ cleanupCustomStreams(fileDescriptors);
+ const subprocess = new import_node_child_process4.ChildProcess();
+ createDummyStreams(subprocess, fileDescriptors);
+ Object.assign(subprocess, { readable, writable, duplex });
+ const earlyError = makeEarlyError({
+ error,
+ command,
+ escapedCommand,
+ fileDescriptors,
+ options,
+ startTime,
+ isSync: false
+ });
+ const promise = handleDummyPromise(earlyError, verboseInfo, options);
+ return { subprocess, promise };
+};
+var createDummyStreams = (subprocess, fileDescriptors) => {
+ const stdin = createDummyStream();
+ const stdout = createDummyStream();
+ const stderr = createDummyStream();
+ const extraStdio = Array.from({ length: fileDescriptors.length - 3 }, createDummyStream);
+ const all = createDummyStream();
+ const stdio = [stdin, stdout, stderr, ...extraStdio];
+ Object.assign(subprocess, {
+ stdin,
+ stdout,
+ stderr,
+ all,
+ stdio
+ });
+};
+var createDummyStream = () => {
+ const stream = new import_node_stream2.PassThrough();
+ stream.end();
+ return stream;
+};
+var readable = () => new import_node_stream2.Readable({ read() {
+} });
+var writable = () => new import_node_stream2.Writable({ write() {
+} });
+var duplex = () => new import_node_stream2.Duplex({ read() {
+}, write() {
+} });
+var handleDummyPromise = async (error, verboseInfo, options) => handleResult(error, verboseInfo, options);
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/stdio/handle-async.js
+var import_node_fs5 = require("node:fs");
+var import_node_buffer3 = require("node:buffer");
+var import_node_stream3 = require("node:stream");
+var handleStdioAsync = (options, verboseInfo) => handleStdio(addPropertiesAsync, options, verboseInfo, false);
+var forbiddenIfAsync = ({ type, optionName }) => {
+ throw new TypeError(`The \`${optionName}\` option cannot be ${TYPE_TO_MESSAGE[type]}.`);
+};
+var addProperties2 = {
+ fileNumber: forbiddenIfAsync,
+ generator: generatorToStream,
+ asyncGenerator: generatorToStream,
+ nodeStream: ({ value }) => ({ stream: value }),
+ webTransform({ value: { transform, writableObjectMode, readableObjectMode } }) {
+ const objectMode = writableObjectMode || readableObjectMode;
+ const stream = import_node_stream3.Duplex.fromWeb(transform, { objectMode });
+ return { stream };
+ },
+ duplex: ({ value: { transform } }) => ({ stream: transform }),
+ native() {
+ }
+};
+var addPropertiesAsync = {
+ input: {
+ ...addProperties2,
+ fileUrl: ({ value }) => ({ stream: (0, import_node_fs5.createReadStream)(value) }),
+ filePath: ({ value: { file } }) => ({ stream: (0, import_node_fs5.createReadStream)(file) }),
+ webStream: ({ value }) => ({ stream: import_node_stream3.Readable.fromWeb(value) }),
+ iterable: ({ value }) => ({ stream: import_node_stream3.Readable.from(value) }),
+ asyncIterable: ({ value }) => ({ stream: import_node_stream3.Readable.from(value) }),
+ string: ({ value }) => ({ stream: import_node_stream3.Readable.from(value) }),
+ uint8Array: ({ value }) => ({ stream: import_node_stream3.Readable.from(import_node_buffer3.Buffer.from(value)) })
+ },
+ output: {
+ ...addProperties2,
+ fileUrl: ({ value }) => ({ stream: (0, import_node_fs5.createWriteStream)(value) }),
+ filePath: ({ value: { file, append } }) => ({ stream: (0, import_node_fs5.createWriteStream)(file, append ? { flags: "a" } : {}) }),
+ webStream: ({ value }) => ({ stream: import_node_stream3.Writable.fromWeb(value) }),
+ iterable: forbiddenIfAsync,
+ asyncIterable: forbiddenIfAsync,
+ string: forbiddenIfAsync,
+ uint8Array: forbiddenIfAsync
+ }
+};
+
+// node_modules/.pnpm/@sindresorhus+merge-streams@4.0.0/node_modules/@sindresorhus/merge-streams/index.js
+var import_node_events10 = require("node:events");
+var import_node_stream4 = require("node:stream");
+var import_promises6 = require("node:stream/promises");
+function mergeStreams(streams) {
+ if (!Array.isArray(streams)) {
+ throw new TypeError(`Expected an array, got \`${typeof streams}\`.`);
+ }
+ for (const stream of streams) {
+ validateStream(stream);
+ }
+ const objectMode = streams.some(({ readableObjectMode }) => readableObjectMode);
+ const highWaterMark = getHighWaterMark(streams, objectMode);
+ const passThroughStream = new MergedStream({
+ objectMode,
+ writableHighWaterMark: highWaterMark,
+ readableHighWaterMark: highWaterMark
+ });
+ for (const stream of streams) {
+ passThroughStream.add(stream);
+ }
+ return passThroughStream;
+}
+var getHighWaterMark = (streams, objectMode) => {
+ if (streams.length === 0) {
+ return (0, import_node_stream4.getDefaultHighWaterMark)(objectMode);
+ }
+ const highWaterMarks = streams.filter(({ readableObjectMode }) => readableObjectMode === objectMode).map(({ readableHighWaterMark }) => readableHighWaterMark);
+ return Math.max(...highWaterMarks);
+};
+var MergedStream = class extends import_node_stream4.PassThrough {
+ #streams = /* @__PURE__ */ new Set([]);
+ #ended = /* @__PURE__ */ new Set([]);
+ #aborted = /* @__PURE__ */ new Set([]);
+ #onFinished;
+ #unpipeEvent = Symbol("unpipe");
+ #streamPromises = /* @__PURE__ */ new WeakMap();
+ add(stream) {
+ validateStream(stream);
+ if (this.#streams.has(stream)) {
+ return;
+ }
+ this.#streams.add(stream);
+ this.#onFinished ??= onMergedStreamFinished(this, this.#streams, this.#unpipeEvent);
+ const streamPromise = endWhenStreamsDone({
+ passThroughStream: this,
+ stream,
+ streams: this.#streams,
+ ended: this.#ended,
+ aborted: this.#aborted,
+ onFinished: this.#onFinished,
+ unpipeEvent: this.#unpipeEvent
+ });
+ this.#streamPromises.set(stream, streamPromise);
+ stream.pipe(this, { end: false });
+ }
+ async remove(stream) {
+ validateStream(stream);
+ if (!this.#streams.has(stream)) {
+ return false;
+ }
+ const streamPromise = this.#streamPromises.get(stream);
+ if (streamPromise === void 0) {
+ return false;
+ }
+ this.#streamPromises.delete(stream);
+ stream.unpipe(this);
+ await streamPromise;
+ return true;
+ }
+};
+var onMergedStreamFinished = async (passThroughStream, streams, unpipeEvent) => {
+ updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_COUNT);
+ const controller = new AbortController();
+ try {
+ await Promise.race([
+ onMergedStreamEnd(passThroughStream, controller),
+ onInputStreamsUnpipe(passThroughStream, streams, unpipeEvent, controller)
+ ]);
+ } finally {
+ controller.abort();
+ updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_COUNT);
+ }
+};
+var onMergedStreamEnd = async (passThroughStream, { signal }) => {
+ try {
+ await (0, import_promises6.finished)(passThroughStream, { signal, cleanup: true });
+ } catch (error) {
+ errorOrAbortStream(passThroughStream, error);
+ throw error;
+ }
+};
+var onInputStreamsUnpipe = async (passThroughStream, streams, unpipeEvent, { signal }) => {
+ for await (const [unpipedStream] of (0, import_node_events10.on)(passThroughStream, "unpipe", { signal })) {
+ if (streams.has(unpipedStream)) {
+ unpipedStream.emit(unpipeEvent);
+ }
+ }
+};
+var validateStream = (stream) => {
+ if (typeof stream?.pipe !== "function") {
+ throw new TypeError(`Expected a readable stream, got: \`${typeof stream}\`.`);
+ }
+};
+var endWhenStreamsDone = async ({ passThroughStream, stream, streams, ended, aborted: aborted2, onFinished, unpipeEvent }) => {
+ updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_PER_STREAM);
+ const controller = new AbortController();
+ try {
+ await Promise.race([
+ afterMergedStreamFinished(onFinished, stream, controller),
+ onInputStreamEnd({
+ passThroughStream,
+ stream,
+ streams,
+ ended,
+ aborted: aborted2,
+ controller
+ }),
+ onInputStreamUnpipe({
+ stream,
+ streams,
+ ended,
+ aborted: aborted2,
+ unpipeEvent,
+ controller
+ })
+ ]);
+ } finally {
+ controller.abort();
+ updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_PER_STREAM);
+ }
+ if (streams.size > 0 && streams.size === ended.size + aborted2.size) {
+ if (ended.size === 0 && aborted2.size > 0) {
+ abortStream(passThroughStream);
+ } else {
+ endStream(passThroughStream);
+ }
+ }
+};
+var afterMergedStreamFinished = async (onFinished, stream, { signal }) => {
+ try {
+ await onFinished;
+ if (!signal.aborted) {
+ abortStream(stream);
+ }
+ } catch (error) {
+ if (!signal.aborted) {
+ errorOrAbortStream(stream, error);
+ }
+ }
+};
+var onInputStreamEnd = async ({ passThroughStream, stream, streams, ended, aborted: aborted2, controller: { signal } }) => {
+ try {
+ await (0, import_promises6.finished)(stream, {
+ signal,
+ cleanup: true,
+ readable: true,
+ writable: false
+ });
+ if (streams.has(stream)) {
+ ended.add(stream);
+ }
+ } catch (error) {
+ if (signal.aborted || !streams.has(stream)) {
+ return;
+ }
+ if (isAbortError(error)) {
+ aborted2.add(stream);
+ } else {
+ errorStream(passThroughStream, error);
+ }
+ }
+};
+var onInputStreamUnpipe = async ({ stream, streams, ended, aborted: aborted2, unpipeEvent, controller: { signal } }) => {
+ await (0, import_node_events10.once)(stream, unpipeEvent, { signal });
+ if (!stream.readable) {
+ return (0, import_node_events10.once)(signal, "abort", { signal });
+ }
+ streams.delete(stream);
+ ended.delete(stream);
+ aborted2.delete(stream);
+};
+var endStream = (stream) => {
+ if (stream.writable) {
+ stream.end();
+ }
+};
+var errorOrAbortStream = (stream, error) => {
+ if (isAbortError(error)) {
+ abortStream(stream);
+ } else {
+ errorStream(stream, error);
+ }
+};
+var isAbortError = (error) => error?.code === "ERR_STREAM_PREMATURE_CLOSE";
+var abortStream = (stream) => {
+ if (stream.readable || stream.writable) {
+ stream.destroy();
+ }
+};
+var errorStream = (stream, error) => {
+ if (!stream.destroyed) {
+ stream.once("error", noop4);
+ stream.destroy(error);
+ }
+};
+var noop4 = () => {
+};
+var updateMaxListeners = (passThroughStream, increment2) => {
+ const maxListeners = passThroughStream.getMaxListeners();
+ if (maxListeners !== 0 && maxListeners !== Number.POSITIVE_INFINITY) {
+ passThroughStream.setMaxListeners(maxListeners + increment2);
+ }
+};
+var PASSTHROUGH_LISTENERS_COUNT = 2;
+var PASSTHROUGH_LISTENERS_PER_STREAM = 1;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/io/pipeline.js
+var import_promises7 = require("node:stream/promises");
+var pipeStreams = (source, destination) => {
+ source.pipe(destination);
+ onSourceFinish(source, destination);
+ onDestinationFinish(source, destination);
+};
+var onSourceFinish = async (source, destination) => {
+ if (isStandardStream(source) || isStandardStream(destination)) {
+ return;
+ }
+ try {
+ await (0, import_promises7.finished)(source, { cleanup: true, readable: true, writable: false });
+ } catch {
+ }
+ endDestinationStream(destination);
+};
+var endDestinationStream = (destination) => {
+ if (destination.writable) {
+ destination.end();
+ }
+};
+var onDestinationFinish = async (source, destination) => {
+ if (isStandardStream(source) || isStandardStream(destination)) {
+ return;
+ }
+ try {
+ await (0, import_promises7.finished)(destination, { cleanup: true, readable: false, writable: true });
+ } catch {
+ }
+ abortSourceStream(source);
+};
+var abortSourceStream = (source) => {
+ if (source.readable) {
+ source.destroy();
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/io/output-async.js
+var pipeOutputAsync = (subprocess, fileDescriptors, controller) => {
+ const pipeGroups = /* @__PURE__ */ new Map();
+ for (const [fdNumber, { stdioItems, direction }] of Object.entries(fileDescriptors)) {
+ for (const { stream } of stdioItems.filter(({ type }) => TRANSFORM_TYPES.has(type))) {
+ pipeTransform(subprocess, stream, direction, fdNumber);
+ }
+ for (const { stream } of stdioItems.filter(({ type }) => !TRANSFORM_TYPES.has(type))) {
+ pipeStdioItem({
+ subprocess,
+ stream,
+ direction,
+ fdNumber,
+ pipeGroups,
+ controller
+ });
+ }
+ }
+ for (const [outputStream, inputStreams] of pipeGroups.entries()) {
+ const inputStream = inputStreams.length === 1 ? inputStreams[0] : mergeStreams(inputStreams);
+ pipeStreams(inputStream, outputStream);
+ }
+};
+var pipeTransform = (subprocess, stream, direction, fdNumber) => {
+ if (direction === "output") {
+ pipeStreams(subprocess.stdio[fdNumber], stream);
+ } else {
+ pipeStreams(stream, subprocess.stdio[fdNumber]);
+ }
+ const streamProperty = SUBPROCESS_STREAM_PROPERTIES[fdNumber];
+ if (streamProperty !== void 0) {
+ subprocess[streamProperty] = stream;
+ }
+ subprocess.stdio[fdNumber] = stream;
+};
+var SUBPROCESS_STREAM_PROPERTIES = ["stdin", "stdout", "stderr"];
+var pipeStdioItem = ({ subprocess, stream, direction, fdNumber, pipeGroups, controller }) => {
+ if (stream === void 0) {
+ return;
+ }
+ setStandardStreamMaxListeners(stream, controller);
+ const [inputStream, outputStream] = direction === "output" ? [stream, subprocess.stdio[fdNumber]] : [subprocess.stdio[fdNumber], stream];
+ const outputStreams = pipeGroups.get(inputStream) ?? [];
+ pipeGroups.set(inputStream, [...outputStreams, outputStream]);
+};
+var setStandardStreamMaxListeners = (stream, { signal }) => {
+ if (isStandardStream(stream)) {
+ incrementMaxListeners(stream, MAX_LISTENERS_INCREMENT, signal);
+ }
+};
+var MAX_LISTENERS_INCREMENT = 2;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/terminate/cleanup.js
+var import_node_events11 = require("node:events");
+
+// node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
+var signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") {
+ signals.push(
+ "SIGALRM",
+ "SIGABRT",
+ "SIGVTALRM",
+ "SIGXCPU",
+ "SIGXFSZ",
+ "SIGUSR2",
+ "SIGTRAP",
+ "SIGSYS",
+ "SIGQUIT",
+ "SIGIOT"
+ // should detect profiler and enable/disable accordingly.
+ // see #21
+ // 'SIGPROF'
+ );
+}
+if (process.platform === "linux") {
+ signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+}
+
+// node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
+var processOk = (process10) => !!process10 && typeof process10 === "object" && typeof process10.removeListener === "function" && typeof process10.emit === "function" && typeof process10.reallyExit === "function" && typeof process10.listeners === "function" && typeof process10.kill === "function" && typeof process10.pid === "number" && typeof process10.on === "function";
+var kExitEmitter = Symbol.for("signal-exit emitter");
+var global2 = globalThis;
+var ObjectDefineProperty = Object.defineProperty.bind(Object);
+var Emitter = class {
+ emitted = {
+ afterExit: false,
+ exit: false
+ };
+ listeners = {
+ afterExit: [],
+ exit: []
+ };
+ count = 0;
+ id = Math.random();
+ constructor() {
+ if (global2[kExitEmitter]) {
+ return global2[kExitEmitter];
+ }
+ ObjectDefineProperty(global2, kExitEmitter, {
+ value: this,
+ writable: false,
+ enumerable: false,
+ configurable: false
+ });
+ }
+ on(ev, fn) {
+ this.listeners[ev].push(fn);
+ }
+ removeListener(ev, fn) {
+ const list = this.listeners[ev];
+ const i2 = list.indexOf(fn);
+ if (i2 === -1) {
+ return;
+ }
+ if (i2 === 0 && list.length === 1) {
+ list.length = 0;
+ } else {
+ list.splice(i2, 1);
+ }
+ }
+ emit(ev, code, signal) {
+ if (this.emitted[ev]) {
+ return false;
+ }
+ this.emitted[ev] = true;
+ let ret = false;
+ for (const fn of this.listeners[ev]) {
+ ret = fn(code, signal) === true || ret;
+ }
+ if (ev === "exit") {
+ ret = this.emit("afterExit", code, signal) || ret;
+ }
+ return ret;
+ }
+};
+var SignalExitBase = class {
+};
+var signalExitWrap = (handler2) => {
+ return {
+ onExit(cb, opts) {
+ return handler2.onExit(cb, opts);
+ },
+ load() {
+ return handler2.load();
+ },
+ unload() {
+ return handler2.unload();
+ }
+ };
+};
+var SignalExitFallback = class extends SignalExitBase {
+ onExit() {
+ return () => {
+ };
+ }
+ load() {
+ }
+ unload() {
+ }
+};
+var SignalExit = class extends SignalExitBase {
+ // "SIGHUP" throws an `ENOSYS` error on Windows,
+ // so use a supported signal instead
+ /* c8 ignore start */
+ #hupSig = process9.platform === "win32" ? "SIGINT" : "SIGHUP";
+ /* c8 ignore stop */
+ #emitter = new Emitter();
+ #process;
+ #originalProcessEmit;
+ #originalProcessReallyExit;
+ #sigListeners = {};
+ #loaded = false;
+ constructor(process10) {
+ super();
+ this.#process = process10;
+ this.#sigListeners = {};
+ for (const sig of signals) {
+ this.#sigListeners[sig] = () => {
+ const listeners = this.#process.listeners(sig);
+ let { count: count2 } = this.#emitter;
+ const p = process10;
+ if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+ count2 += p.__signal_exit_emitter__.count;
+ }
+ if (listeners.length === count2) {
+ this.unload();
+ const ret = this.#emitter.emit("exit", null, sig);
+ const s = sig === "SIGHUP" ? this.#hupSig : sig;
+ if (!ret)
+ process10.kill(process10.pid, s);
+ }
+ };
+ }
+ this.#originalProcessReallyExit = process10.reallyExit;
+ this.#originalProcessEmit = process10.emit;
+ }
+ onExit(cb, opts) {
+ if (!processOk(this.#process)) {
+ return () => {
+ };
+ }
+ if (this.#loaded === false) {
+ this.load();
+ }
+ const ev = opts?.alwaysLast ? "afterExit" : "exit";
+ this.#emitter.on(ev, cb);
+ return () => {
+ this.#emitter.removeListener(ev, cb);
+ if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+ this.unload();
+ }
+ };
+ }
+ load() {
+ if (this.#loaded) {
+ return;
+ }
+ this.#loaded = true;
+ this.#emitter.count += 1;
+ for (const sig of signals) {
+ try {
+ const fn = this.#sigListeners[sig];
+ if (fn)
+ this.#process.on(sig, fn);
+ } catch (_) {
+ }
+ }
+ this.#process.emit = (ev, ...a2) => {
+ return this.#processEmit(ev, ...a2);
+ };
+ this.#process.reallyExit = (code) => {
+ return this.#processReallyExit(code);
+ };
+ }
+ unload() {
+ if (!this.#loaded) {
+ return;
+ }
+ this.#loaded = false;
+ signals.forEach((sig) => {
+ const listener = this.#sigListeners[sig];
+ if (!listener) {
+ throw new Error("Listener not defined for signal: " + sig);
+ }
+ try {
+ this.#process.removeListener(sig, listener);
+ } catch (_) {
+ }
+ });
+ this.#process.emit = this.#originalProcessEmit;
+ this.#process.reallyExit = this.#originalProcessReallyExit;
+ this.#emitter.count -= 1;
+ }
+ #processReallyExit(code) {
+ if (!processOk(this.#process)) {
+ return 0;
+ }
+ this.#process.exitCode = code || 0;
+ this.#emitter.emit("exit", this.#process.exitCode, null);
+ return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+ }
+ #processEmit(ev, ...args) {
+ const og = this.#originalProcessEmit;
+ if (ev === "exit" && processOk(this.#process)) {
+ if (typeof args[0] === "number") {
+ this.#process.exitCode = args[0];
+ }
+ const ret = og.call(this.#process, ev, ...args);
+ this.#emitter.emit("exit", this.#process.exitCode, null);
+ return ret;
+ } else {
+ return og.call(this.#process, ev, ...args);
+ }
+ }
+};
+var process9 = globalThis.process;
+var {
+ /**
+ * Called when the process is exiting, whether via signal, explicit
+ * exit, or running out of stuff to do.
+ *
+ * If the global process object is not suitable for instrumentation,
+ * then this will be a no-op.
+ *
+ * Returns a function that may be used to unload signal-exit.
+ */
+ onExit,
+ /**
+ * Load the listeners. Likely you never need to call this, unless
+ * doing a rather deep integration with signal-exit functionality.
+ * Mostly exposed for the benefit of testing.
+ *
+ * @internal
+ */
+ load,
+ /**
+ * Unload the listeners. Likely you never need to call this, unless
+ * doing a rather deep integration with signal-exit functionality.
+ * Mostly exposed for the benefit of testing.
+ *
+ * @internal
+ */
+ unload
+} = signalExitWrap(processOk(process9) ? new SignalExit(process9) : new SignalExitFallback());
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/terminate/cleanup.js
+var cleanupOnExit = (subprocess, { cleanup, detached }, { signal }) => {
+ if (!cleanup || detached) {
+ return;
+ }
+ const removeExitHandler = onExit(() => {
+ subprocess.kill();
+ });
+ (0, import_node_events11.addAbortListener)(signal, () => {
+ removeExitHandler();
+ });
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/pipe/pipe-arguments.js
+var normalizePipeArguments = ({ source, sourcePromise, boundOptions, createNested }, ...pipeArguments) => {
+ const startTime = getStartTime();
+ const {
+ destination,
+ destinationStream,
+ destinationError,
+ from,
+ unpipeSignal
+ } = getDestinationStream(boundOptions, createNested, pipeArguments);
+ const { sourceStream, sourceError } = getSourceStream(source, from);
+ const { options: sourceOptions, fileDescriptors } = SUBPROCESS_OPTIONS.get(source);
+ return {
+ sourcePromise,
+ sourceStream,
+ sourceOptions,
+ sourceError,
+ destination,
+ destinationStream,
+ destinationError,
+ unpipeSignal,
+ fileDescriptors,
+ startTime
+ };
+};
+var getDestinationStream = (boundOptions, createNested, pipeArguments) => {
+ try {
+ const {
+ destination,
+ pipeOptions: { from, to, unpipeSignal } = {}
+ } = getDestination(boundOptions, createNested, ...pipeArguments);
+ const destinationStream = getToStream(destination, to);
+ return {
+ destination,
+ destinationStream,
+ from,
+ unpipeSignal
+ };
+ } catch (error) {
+ return { destinationError: error };
+ }
+};
+var getDestination = (boundOptions, createNested, firstArgument, ...pipeArguments) => {
+ if (Array.isArray(firstArgument)) {
+ const destination = createNested(mapDestinationArguments, boundOptions)(firstArgument, ...pipeArguments);
+ return { destination, pipeOptions: boundOptions };
+ }
+ if (typeof firstArgument === "string" || firstArgument instanceof URL || isDenoExecPath(firstArgument)) {
+ if (Object.keys(boundOptions).length > 0) {
+ throw new TypeError('Please use .pipe("file", ..., options) or .pipe(execa("file", ..., options)) instead of .pipe(options)("file", ...).');
+ }
+ const [rawFile, rawArguments, rawOptions] = normalizeParameters(firstArgument, ...pipeArguments);
+ const destination = createNested(mapDestinationArguments)(rawFile, rawArguments, rawOptions);
+ return { destination, pipeOptions: rawOptions };
+ }
+ if (SUBPROCESS_OPTIONS.has(firstArgument)) {
+ if (Object.keys(boundOptions).length > 0) {
+ throw new TypeError("Please use .pipe(options)`command` or .pipe($(options)`command`) instead of .pipe(options)($`command`).");
+ }
+ return { destination: firstArgument, pipeOptions: pipeArguments[0] };
+ }
+ throw new TypeError(`The first argument must be a template string, an options object, or an Execa subprocess: ${firstArgument}`);
+};
+var mapDestinationArguments = ({ options }) => ({ options: { ...options, stdin: "pipe", piped: true } });
+var getSourceStream = (source, from) => {
+ try {
+ const sourceStream = getFromStream(source, from);
+ return { sourceStream };
+ } catch (error) {
+ return { sourceError: error };
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/pipe/throw.js
+var handlePipeArgumentsError = ({
+ sourceStream,
+ sourceError,
+ destinationStream,
+ destinationError,
+ fileDescriptors,
+ sourceOptions,
+ startTime
+}) => {
+ const error = getPipeArgumentsError({
+ sourceStream,
+ sourceError,
+ destinationStream,
+ destinationError
+ });
+ if (error !== void 0) {
+ throw createNonCommandError({
+ error,
+ fileDescriptors,
+ sourceOptions,
+ startTime
+ });
+ }
+};
+var getPipeArgumentsError = ({ sourceStream, sourceError, destinationStream, destinationError }) => {
+ if (sourceError !== void 0 && destinationError !== void 0) {
+ return destinationError;
+ }
+ if (destinationError !== void 0) {
+ abortSourceStream(sourceStream);
+ return destinationError;
+ }
+ if (sourceError !== void 0) {
+ endDestinationStream(destinationStream);
+ return sourceError;
+ }
+};
+var createNonCommandError = ({ error, fileDescriptors, sourceOptions, startTime }) => makeEarlyError({
+ error,
+ command: PIPE_COMMAND_MESSAGE,
+ escapedCommand: PIPE_COMMAND_MESSAGE,
+ fileDescriptors,
+ options: sourceOptions,
+ startTime,
+ isSync: false
+});
+var PIPE_COMMAND_MESSAGE = "source.pipe(destination)";
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/pipe/sequence.js
+var waitForBothSubprocesses = async (subprocessPromises) => {
+ const [
+ { status: sourceStatus, reason: sourceReason, value: sourceResult = sourceReason },
+ { status: destinationStatus, reason: destinationReason, value: destinationResult = destinationReason }
+ ] = await subprocessPromises;
+ if (!destinationResult.pipedFrom.includes(sourceResult)) {
+ destinationResult.pipedFrom.push(sourceResult);
+ }
+ if (destinationStatus === "rejected") {
+ throw destinationResult;
+ }
+ if (sourceStatus === "rejected") {
+ throw sourceResult;
+ }
+ return destinationResult;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/pipe/streaming.js
+var import_promises8 = require("node:stream/promises");
+var pipeSubprocessStream = (sourceStream, destinationStream, maxListenersController) => {
+ const mergedStream = MERGED_STREAMS.has(destinationStream) ? pipeMoreSubprocessStream(sourceStream, destinationStream) : pipeFirstSubprocessStream(sourceStream, destinationStream);
+ incrementMaxListeners(sourceStream, SOURCE_LISTENERS_PER_PIPE, maxListenersController.signal);
+ incrementMaxListeners(destinationStream, DESTINATION_LISTENERS_PER_PIPE, maxListenersController.signal);
+ cleanupMergedStreamsMap(destinationStream);
+ return mergedStream;
+};
+var pipeFirstSubprocessStream = (sourceStream, destinationStream) => {
+ const mergedStream = mergeStreams([sourceStream]);
+ pipeStreams(mergedStream, destinationStream);
+ MERGED_STREAMS.set(destinationStream, mergedStream);
+ return mergedStream;
+};
+var pipeMoreSubprocessStream = (sourceStream, destinationStream) => {
+ const mergedStream = MERGED_STREAMS.get(destinationStream);
+ mergedStream.add(sourceStream);
+ return mergedStream;
+};
+var cleanupMergedStreamsMap = async (destinationStream) => {
+ try {
+ await (0, import_promises8.finished)(destinationStream, { cleanup: true, readable: false, writable: true });
+ } catch {
+ }
+ MERGED_STREAMS.delete(destinationStream);
+};
+var MERGED_STREAMS = /* @__PURE__ */ new WeakMap();
+var SOURCE_LISTENERS_PER_PIPE = 2;
+var DESTINATION_LISTENERS_PER_PIPE = 1;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/pipe/abort.js
+var import_node_util8 = require("node:util");
+var unpipeOnAbort = (unpipeSignal, unpipeContext) => unpipeSignal === void 0 ? [] : [unpipeOnSignalAbort(unpipeSignal, unpipeContext)];
+var unpipeOnSignalAbort = async (unpipeSignal, { sourceStream, mergedStream, fileDescriptors, sourceOptions, startTime }) => {
+ await (0, import_node_util8.aborted)(unpipeSignal, sourceStream);
+ await mergedStream.remove(sourceStream);
+ const error = new Error("Pipe canceled by `unpipeSignal` option.");
+ throw createNonCommandError({
+ error,
+ fileDescriptors,
+ sourceOptions,
+ startTime
+ });
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/pipe/setup.js
+var pipeToSubprocess = (sourceInfo, ...pipeArguments) => {
+ if (isPlainObject3(pipeArguments[0])) {
+ return pipeToSubprocess.bind(void 0, {
+ ...sourceInfo,
+ boundOptions: { ...sourceInfo.boundOptions, ...pipeArguments[0] }
+ });
+ }
+ const { destination, ...normalizedInfo } = normalizePipeArguments(sourceInfo, ...pipeArguments);
+ const promise = handlePipePromise({ ...normalizedInfo, destination });
+ promise.pipe = pipeToSubprocess.bind(void 0, {
+ ...sourceInfo,
+ source: destination,
+ sourcePromise: promise,
+ boundOptions: {}
+ });
+ return promise;
+};
+var handlePipePromise = async ({
+ sourcePromise,
+ sourceStream,
+ sourceOptions,
+ sourceError,
+ destination,
+ destinationStream,
+ destinationError,
+ unpipeSignal,
+ fileDescriptors,
+ startTime
+}) => {
+ const subprocessPromises = getSubprocessPromises(sourcePromise, destination);
+ handlePipeArgumentsError({
+ sourceStream,
+ sourceError,
+ destinationStream,
+ destinationError,
+ fileDescriptors,
+ sourceOptions,
+ startTime
+ });
+ const maxListenersController = new AbortController();
+ try {
+ const mergedStream = pipeSubprocessStream(sourceStream, destinationStream, maxListenersController);
+ return await Promise.race([
+ waitForBothSubprocesses(subprocessPromises),
+ ...unpipeOnAbort(unpipeSignal, {
+ sourceStream,
+ mergedStream,
+ sourceOptions,
+ fileDescriptors,
+ startTime
+ })
+ ]);
+ } finally {
+ maxListenersController.abort();
+ }
+};
+var getSubprocessPromises = (sourcePromise, destination) => Promise.allSettled([sourcePromise, destination]);
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/io/contents.js
+var import_promises9 = require("node:timers/promises");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/io/iterate.js
+var import_node_events12 = require("node:events");
+var import_node_stream5 = require("node:stream");
+var iterateOnSubprocessStream = ({ subprocessStdout, subprocess, binary, shouldEncode, encoding, preserveNewlines }) => {
+ const controller = new AbortController();
+ stopReadingOnExit(subprocess, controller);
+ return iterateOnStream({
+ stream: subprocessStdout,
+ controller,
+ binary,
+ shouldEncode: !subprocessStdout.readableObjectMode && shouldEncode,
+ encoding,
+ shouldSplit: !subprocessStdout.readableObjectMode,
+ preserveNewlines
+ });
+};
+var stopReadingOnExit = async (subprocess, controller) => {
+ try {
+ await subprocess;
+ } catch {
+ } finally {
+ controller.abort();
+ }
+};
+var iterateForResult = ({ stream, onStreamEnd, lines, encoding, stripFinalNewline: stripFinalNewline2, allMixed }) => {
+ const controller = new AbortController();
+ stopReadingOnStreamEnd(onStreamEnd, controller, stream);
+ const objectMode = stream.readableObjectMode && !allMixed;
+ return iterateOnStream({
+ stream,
+ controller,
+ binary: encoding === "buffer",
+ shouldEncode: !objectMode,
+ encoding,
+ shouldSplit: !objectMode && lines,
+ preserveNewlines: !stripFinalNewline2
+ });
+};
+var stopReadingOnStreamEnd = async (onStreamEnd, controller, stream) => {
+ try {
+ await onStreamEnd;
+ } catch {
+ stream.destroy();
+ } finally {
+ controller.abort();
+ }
+};
+var iterateOnStream = ({ stream, controller, binary, shouldEncode, encoding, shouldSplit, preserveNewlines }) => {
+ const onStdoutChunk = (0, import_node_events12.on)(stream, "data", {
+ signal: controller.signal,
+ highWaterMark: HIGH_WATER_MARK,
+ // Backward compatibility with older name for this option
+ // See https://github.com/nodejs/node/pull/52080#discussion_r1525227861
+ // @todo Remove after removing support for Node 21
+ highWatermark: HIGH_WATER_MARK
+ });
+ return iterateOnData({
+ onStdoutChunk,
+ controller,
+ binary,
+ shouldEncode,
+ encoding,
+ shouldSplit,
+ preserveNewlines
+ });
+};
+var DEFAULT_OBJECT_HIGH_WATER_MARK = (0, import_node_stream5.getDefaultHighWaterMark)(true);
+var HIGH_WATER_MARK = DEFAULT_OBJECT_HIGH_WATER_MARK;
+var iterateOnData = async function* ({ onStdoutChunk, controller, binary, shouldEncode, encoding, shouldSplit, preserveNewlines }) {
+ const generators = getGenerators({
+ binary,
+ shouldEncode,
+ encoding,
+ shouldSplit,
+ preserveNewlines
+ });
+ try {
+ for await (const [chunk] of onStdoutChunk) {
+ yield* transformChunkSync(chunk, generators, 0);
+ }
+ } catch (error) {
+ if (!controller.signal.aborted) {
+ throw error;
+ }
+ } finally {
+ yield* finalChunksSync(generators);
+ }
+};
+var getGenerators = ({ binary, shouldEncode, encoding, shouldSplit, preserveNewlines }) => [
+ getEncodingTransformGenerator(binary, encoding, !shouldEncode),
+ getSplitLinesGenerator(binary, preserveNewlines, !shouldSplit, {})
+].filter(Boolean);
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/io/contents.js
+var getStreamOutput = async ({ stream, onStreamEnd, fdNumber, encoding, buffer, maxBuffer, lines, allMixed, stripFinalNewline: stripFinalNewline2, verboseInfo, streamInfo }) => {
+ const logPromise = logOutputAsync({
+ stream,
+ onStreamEnd,
+ fdNumber,
+ encoding,
+ allMixed,
+ verboseInfo,
+ streamInfo
+ });
+ if (!buffer) {
+ await Promise.all([resumeStream(stream), logPromise]);
+ return;
+ }
+ const stripFinalNewlineValue = getStripFinalNewline(stripFinalNewline2, fdNumber);
+ const iterable = iterateForResult({
+ stream,
+ onStreamEnd,
+ lines,
+ encoding,
+ stripFinalNewline: stripFinalNewlineValue,
+ allMixed
+ });
+ const [output] = await Promise.all([
+ getStreamContents2({
+ stream,
+ iterable,
+ fdNumber,
+ encoding,
+ maxBuffer,
+ lines
+ }),
+ logPromise
+ ]);
+ return output;
+};
+var logOutputAsync = async ({ stream, onStreamEnd, fdNumber, encoding, allMixed, verboseInfo, streamInfo: { fileDescriptors } }) => {
+ if (!shouldLogOutput({
+ stdioItems: fileDescriptors[fdNumber]?.stdioItems,
+ encoding,
+ verboseInfo,
+ fdNumber
+ })) {
+ return;
+ }
+ const linesIterable = iterateForResult({
+ stream,
+ onStreamEnd,
+ lines: true,
+ encoding,
+ stripFinalNewline: true,
+ allMixed
+ });
+ await logLines(linesIterable, stream, fdNumber, verboseInfo);
+};
+var resumeStream = async (stream) => {
+ await (0, import_promises9.setImmediate)();
+ if (stream.readableFlowing === null) {
+ stream.resume();
+ }
+};
+var getStreamContents2 = async ({ stream, stream: { readableObjectMode }, iterable, fdNumber, encoding, maxBuffer, lines }) => {
+ try {
+ if (readableObjectMode || lines) {
+ return await getStreamAsArray(iterable, { maxBuffer });
+ }
+ if (encoding === "buffer") {
+ return new Uint8Array(await getStreamAsArrayBuffer(iterable, { maxBuffer }));
+ }
+ return await getStreamAsString(iterable, { maxBuffer });
+ } catch (error) {
+ return handleBufferedData(handleMaxBuffer({
+ error,
+ stream,
+ readableObjectMode,
+ lines,
+ encoding,
+ fdNumber
+ }));
+ }
+};
+var getBufferedData = async (streamPromise) => {
+ try {
+ return await streamPromise;
+ } catch (error) {
+ return handleBufferedData(error);
+ }
+};
+var handleBufferedData = ({ bufferedData }) => isArrayBuffer(bufferedData) ? new Uint8Array(bufferedData) : bufferedData;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/resolve/wait-stream.js
+var import_promises10 = require("node:stream/promises");
+var waitForStream = async (stream, fdNumber, streamInfo, { isSameDirection, stopOnExit = false } = {}) => {
+ const state = handleStdinDestroy(stream, streamInfo);
+ const abortController = new AbortController();
+ try {
+ await Promise.race([
+ ...stopOnExit ? [streamInfo.exitPromise] : [],
+ (0, import_promises10.finished)(stream, { cleanup: true, signal: abortController.signal })
+ ]);
+ } catch (error) {
+ if (!state.stdinCleanedUp) {
+ handleStreamError(error, fdNumber, streamInfo, isSameDirection);
+ }
+ } finally {
+ abortController.abort();
+ }
+};
+var handleStdinDestroy = (stream, { originalStreams: [originalStdin], subprocess }) => {
+ const state = { stdinCleanedUp: false };
+ if (stream === originalStdin) {
+ spyOnStdinDestroy(stream, subprocess, state);
+ }
+ return state;
+};
+var spyOnStdinDestroy = (subprocessStdin, subprocess, state) => {
+ const { _destroy } = subprocessStdin;
+ subprocessStdin._destroy = (...destroyArguments) => {
+ setStdinCleanedUp(subprocess, state);
+ _destroy.call(subprocessStdin, ...destroyArguments);
+ };
+};
+var setStdinCleanedUp = ({ exitCode, signalCode }, state) => {
+ if (exitCode !== null || signalCode !== null) {
+ state.stdinCleanedUp = true;
+ }
+};
+var handleStreamError = (error, fdNumber, streamInfo, isSameDirection) => {
+ if (!shouldIgnoreStreamError(error, fdNumber, streamInfo, isSameDirection)) {
+ throw error;
+ }
+};
+var shouldIgnoreStreamError = (error, fdNumber, streamInfo, isSameDirection = true) => {
+ if (streamInfo.propagating) {
+ return isStreamEpipe(error) || isStreamAbort(error);
+ }
+ streamInfo.propagating = true;
+ return isInputFileDescriptor(streamInfo, fdNumber) === isSameDirection ? isStreamEpipe(error) : isStreamAbort(error);
+};
+var isInputFileDescriptor = ({ fileDescriptors }, fdNumber) => fdNumber !== "all" && fileDescriptors[fdNumber].direction === "input";
+var isStreamAbort = (error) => error?.code === "ERR_STREAM_PREMATURE_CLOSE";
+var isStreamEpipe = (error) => error?.code === "EPIPE";
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/resolve/stdio.js
+var waitForStdioStreams = ({ subprocess, encoding, buffer, maxBuffer, lines, stripFinalNewline: stripFinalNewline2, verboseInfo, streamInfo }) => subprocess.stdio.map((stream, fdNumber) => waitForSubprocessStream({
+ stream,
+ fdNumber,
+ encoding,
+ buffer: buffer[fdNumber],
+ maxBuffer: maxBuffer[fdNumber],
+ lines: lines[fdNumber],
+ allMixed: false,
+ stripFinalNewline: stripFinalNewline2,
+ verboseInfo,
+ streamInfo
+}));
+var waitForSubprocessStream = async ({ stream, fdNumber, encoding, buffer, maxBuffer, lines, allMixed, stripFinalNewline: stripFinalNewline2, verboseInfo, streamInfo }) => {
+ if (!stream) {
+ return;
+ }
+ const onStreamEnd = waitForStream(stream, fdNumber, streamInfo);
+ if (isInputFileDescriptor(streamInfo, fdNumber)) {
+ await onStreamEnd;
+ return;
+ }
+ const [output] = await Promise.all([
+ getStreamOutput({
+ stream,
+ onStreamEnd,
+ fdNumber,
+ encoding,
+ buffer,
+ maxBuffer,
+ lines,
+ allMixed,
+ stripFinalNewline: stripFinalNewline2,
+ verboseInfo,
+ streamInfo
+ }),
+ onStreamEnd
+ ]);
+ return output;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/resolve/all-async.js
+var makeAllStream = ({ stdout, stderr }, { all }) => all && (stdout || stderr) ? mergeStreams([stdout, stderr].filter(Boolean)) : void 0;
+var waitForAllStream = ({ subprocess, encoding, buffer, maxBuffer, lines, stripFinalNewline: stripFinalNewline2, verboseInfo, streamInfo }) => waitForSubprocessStream({
+ ...getAllStream(subprocess, buffer),
+ fdNumber: "all",
+ encoding,
+ maxBuffer: maxBuffer[1] + maxBuffer[2],
+ lines: lines[1] || lines[2],
+ allMixed: getAllMixed(subprocess),
+ stripFinalNewline: stripFinalNewline2,
+ verboseInfo,
+ streamInfo
+});
+var getAllStream = ({ stdout, stderr, all }, [, bufferStdout, bufferStderr]) => {
+ const buffer = bufferStdout || bufferStderr;
+ if (!buffer) {
+ return { stream: all, buffer };
+ }
+ if (!bufferStdout) {
+ return { stream: stderr, buffer };
+ }
+ if (!bufferStderr) {
+ return { stream: stdout, buffer };
+ }
+ return { stream: all, buffer };
+};
+var getAllMixed = ({ all, stdout, stderr }) => all && stdout && stderr && stdout.readableObjectMode !== stderr.readableObjectMode;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/resolve/wait-subprocess.js
+var import_node_events13 = require("node:events");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/verbose/ipc.js
+var shouldLogIpc = (verboseInfo) => isFullVerbose(verboseInfo, "ipc");
+var logIpcOutput = (message, verboseInfo) => {
+ const verboseMessage = serializeVerboseMessage(message);
+ verboseLog({
+ type: "ipc",
+ verboseMessage,
+ fdNumber: "ipc",
+ verboseInfo
+ });
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/ipc/buffer-messages.js
+var waitForIpcOutput = async ({
+ subprocess,
+ buffer: bufferArray,
+ maxBuffer: maxBufferArray,
+ ipc,
+ ipcOutput,
+ verboseInfo
+}) => {
+ if (!ipc) {
+ return ipcOutput;
+ }
+ const isVerbose2 = shouldLogIpc(verboseInfo);
+ const buffer = getFdSpecificValue(bufferArray, "ipc");
+ const maxBuffer = getFdSpecificValue(maxBufferArray, "ipc");
+ for await (const message of loopOnMessages({
+ anyProcess: subprocess,
+ channel: subprocess.channel,
+ isSubprocess: false,
+ ipc,
+ shouldAwait: false,
+ reference: true
+ })) {
+ if (buffer) {
+ checkIpcMaxBuffer(subprocess, ipcOutput, maxBuffer);
+ ipcOutput.push(message);
+ }
+ if (isVerbose2) {
+ logIpcOutput(message, verboseInfo);
+ }
+ }
+ return ipcOutput;
+};
+var getBufferedIpcOutput = async (ipcOutputPromise, ipcOutput) => {
+ await Promise.allSettled([ipcOutputPromise]);
+ return ipcOutput;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/resolve/wait-subprocess.js
+var waitForSubprocessResult = async ({
+ subprocess,
+ options: {
+ encoding,
+ buffer,
+ maxBuffer,
+ lines,
+ timeoutDuration: timeout,
+ cancelSignal,
+ gracefulCancel,
+ forceKillAfterDelay,
+ stripFinalNewline: stripFinalNewline2,
+ ipc,
+ ipcInput
+ },
+ context: context3,
+ verboseInfo,
+ fileDescriptors,
+ originalStreams,
+ onInternalError,
+ controller
+}) => {
+ const exitPromise = waitForExit(subprocess, context3);
+ const streamInfo = {
+ originalStreams,
+ fileDescriptors,
+ subprocess,
+ exitPromise,
+ propagating: false
+ };
+ const stdioPromises = waitForStdioStreams({
+ subprocess,
+ encoding,
+ buffer,
+ maxBuffer,
+ lines,
+ stripFinalNewline: stripFinalNewline2,
+ verboseInfo,
+ streamInfo
+ });
+ const allPromise = waitForAllStream({
+ subprocess,
+ encoding,
+ buffer,
+ maxBuffer,
+ lines,
+ stripFinalNewline: stripFinalNewline2,
+ verboseInfo,
+ streamInfo
+ });
+ const ipcOutput = [];
+ const ipcOutputPromise = waitForIpcOutput({
+ subprocess,
+ buffer,
+ maxBuffer,
+ ipc,
+ ipcOutput,
+ verboseInfo
+ });
+ const originalPromises = waitForOriginalStreams(originalStreams, subprocess, streamInfo);
+ const customStreamsEndPromises = waitForCustomStreamsEnd(fileDescriptors, streamInfo);
+ try {
+ return await Promise.race([
+ Promise.all([
+ {},
+ waitForSuccessfulExit(exitPromise),
+ Promise.all(stdioPromises),
+ allPromise,
+ ipcOutputPromise,
+ sendIpcInput(subprocess, ipcInput),
+ ...originalPromises,
+ ...customStreamsEndPromises
+ ]),
+ onInternalError,
+ throwOnSubprocessError(subprocess, controller),
+ ...throwOnTimeout(subprocess, timeout, context3, controller),
+ ...throwOnCancel({
+ subprocess,
+ cancelSignal,
+ gracefulCancel,
+ context: context3,
+ controller
+ }),
+ ...throwOnGracefulCancel({
+ subprocess,
+ cancelSignal,
+ gracefulCancel,
+ forceKillAfterDelay,
+ context: context3,
+ controller
+ })
+ ]);
+ } catch (error) {
+ context3.terminationReason ??= "other";
+ return Promise.all([
+ { error },
+ exitPromise,
+ Promise.all(stdioPromises.map((stdioPromise) => getBufferedData(stdioPromise))),
+ getBufferedData(allPromise),
+ getBufferedIpcOutput(ipcOutputPromise, ipcOutput),
+ Promise.allSettled(originalPromises),
+ Promise.allSettled(customStreamsEndPromises)
+ ]);
+ }
+};
+var waitForOriginalStreams = (originalStreams, subprocess, streamInfo) => originalStreams.map((stream, fdNumber) => stream === subprocess.stdio[fdNumber] ? void 0 : waitForStream(stream, fdNumber, streamInfo));
+var waitForCustomStreamsEnd = (fileDescriptors, streamInfo) => fileDescriptors.flatMap(({ stdioItems }, fdNumber) => stdioItems.filter(({ value, stream = value }) => isStream(stream, { checkOpen: false }) && !isStandardStream(stream)).map(({ type, value, stream = value }) => waitForStream(stream, fdNumber, streamInfo, {
+ isSameDirection: TRANSFORM_TYPES.has(type),
+ stopOnExit: type === "native"
+})));
+var throwOnSubprocessError = async (subprocess, { signal }) => {
+ const [error] = await (0, import_node_events13.once)(subprocess, "error", { signal });
+ throw error;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/convert/concurrent.js
+var initializeConcurrentStreams = () => ({
+ readableDestroy: /* @__PURE__ */ new WeakMap(),
+ writableFinal: /* @__PURE__ */ new WeakMap(),
+ writableDestroy: /* @__PURE__ */ new WeakMap()
+});
+var addConcurrentStream = (concurrentStreams, stream, waitName) => {
+ const weakMap = concurrentStreams[waitName];
+ if (!weakMap.has(stream)) {
+ weakMap.set(stream, []);
+ }
+ const promises = weakMap.get(stream);
+ const promise = createDeferred();
+ promises.push(promise);
+ const resolve = promise.resolve.bind(promise);
+ return { resolve, promises };
+};
+var waitForConcurrentStreams = async ({ resolve, promises }, subprocess) => {
+ resolve();
+ const [isSubprocessExit] = await Promise.race([
+ Promise.allSettled([true, subprocess]),
+ Promise.all([false, ...promises])
+ ]);
+ return !isSubprocessExit;
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/convert/readable.js
+var import_node_stream6 = require("node:stream");
+var import_node_util9 = require("node:util");
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/convert/shared.js
+var import_promises11 = require("node:stream/promises");
+var safeWaitForSubprocessStdin = async (subprocessStdin) => {
+ if (subprocessStdin === void 0) {
+ return;
+ }
+ try {
+ await waitForSubprocessStdin(subprocessStdin);
+ } catch {
+ }
+};
+var safeWaitForSubprocessStdout = async (subprocessStdout) => {
+ if (subprocessStdout === void 0) {
+ return;
+ }
+ try {
+ await waitForSubprocessStdout(subprocessStdout);
+ } catch {
+ }
+};
+var waitForSubprocessStdin = async (subprocessStdin) => {
+ await (0, import_promises11.finished)(subprocessStdin, { cleanup: true, readable: false, writable: true });
+};
+var waitForSubprocessStdout = async (subprocessStdout) => {
+ await (0, import_promises11.finished)(subprocessStdout, { cleanup: true, readable: true, writable: false });
+};
+var waitForSubprocess = async (subprocess, error) => {
+ await subprocess;
+ if (error) {
+ throw error;
+ }
+};
+var destroyOtherStream = (stream, isOpen, error) => {
+ if (error && !isStreamAbort(error)) {
+ stream.destroy(error);
+ } else if (isOpen) {
+ stream.destroy();
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/convert/readable.js
+var createReadable = ({ subprocess, concurrentStreams, encoding }, { from, binary: binaryOption = true, preserveNewlines = true } = {}) => {
+ const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
+ const { subprocessStdout, waitReadableDestroy } = getSubprocessStdout(subprocess, from, concurrentStreams);
+ const { readableEncoding, readableObjectMode, readableHighWaterMark } = getReadableOptions(subprocessStdout, binary);
+ const { read, onStdoutDataDone } = getReadableMethods({
+ subprocessStdout,
+ subprocess,
+ binary,
+ encoding,
+ preserveNewlines
+ });
+ const readable2 = new import_node_stream6.Readable({
+ read,
+ destroy: (0, import_node_util9.callbackify)(onReadableDestroy.bind(void 0, { subprocessStdout, subprocess, waitReadableDestroy })),
+ highWaterMark: readableHighWaterMark,
+ objectMode: readableObjectMode,
+ encoding: readableEncoding
+ });
+ onStdoutFinished({
+ subprocessStdout,
+ onStdoutDataDone,
+ readable: readable2,
+ subprocess
+ });
+ return readable2;
+};
+var getSubprocessStdout = (subprocess, from, concurrentStreams) => {
+ const subprocessStdout = getFromStream(subprocess, from);
+ const waitReadableDestroy = addConcurrentStream(concurrentStreams, subprocessStdout, "readableDestroy");
+ return { subprocessStdout, waitReadableDestroy };
+};
+var getReadableOptions = ({ readableEncoding, readableObjectMode, readableHighWaterMark }, binary) => binary ? { readableEncoding, readableObjectMode, readableHighWaterMark } : { readableEncoding, readableObjectMode: true, readableHighWaterMark: DEFAULT_OBJECT_HIGH_WATER_MARK };
+var getReadableMethods = ({ subprocessStdout, subprocess, binary, encoding, preserveNewlines }) => {
+ const onStdoutDataDone = createDeferred();
+ const onStdoutData = iterateOnSubprocessStream({
+ subprocessStdout,
+ subprocess,
+ binary,
+ shouldEncode: !binary,
+ encoding,
+ preserveNewlines
+ });
+ return {
+ read() {
+ onRead(this, onStdoutData, onStdoutDataDone);
+ },
+ onStdoutDataDone
+ };
+};
+var onRead = async (readable2, onStdoutData, onStdoutDataDone) => {
+ try {
+ const { value, done } = await onStdoutData.next();
+ if (done) {
+ onStdoutDataDone.resolve();
+ } else {
+ readable2.push(value);
+ }
+ } catch {
+ }
+};
+var onStdoutFinished = async ({ subprocessStdout, onStdoutDataDone, readable: readable2, subprocess, subprocessStdin }) => {
+ try {
+ await waitForSubprocessStdout(subprocessStdout);
+ await subprocess;
+ await safeWaitForSubprocessStdin(subprocessStdin);
+ await onStdoutDataDone;
+ if (readable2.readable) {
+ readable2.push(null);
+ }
+ } catch (error) {
+ await safeWaitForSubprocessStdin(subprocessStdin);
+ destroyOtherReadable(readable2, error);
+ }
+};
+var onReadableDestroy = async ({ subprocessStdout, subprocess, waitReadableDestroy }, error) => {
+ if (await waitForConcurrentStreams(waitReadableDestroy, subprocess)) {
+ destroyOtherReadable(subprocessStdout, error);
+ await waitForSubprocess(subprocess, error);
+ }
+};
+var destroyOtherReadable = (stream, error) => {
+ destroyOtherStream(stream, stream.readable, error);
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/convert/writable.js
+var import_node_stream7 = require("node:stream");
+var import_node_util10 = require("node:util");
+var createWritable = ({ subprocess, concurrentStreams }, { to } = {}) => {
+ const { subprocessStdin, waitWritableFinal, waitWritableDestroy } = getSubprocessStdin(subprocess, to, concurrentStreams);
+ const writable2 = new import_node_stream7.Writable({
+ ...getWritableMethods(subprocessStdin, subprocess, waitWritableFinal),
+ destroy: (0, import_node_util10.callbackify)(onWritableDestroy.bind(void 0, {
+ subprocessStdin,
+ subprocess,
+ waitWritableFinal,
+ waitWritableDestroy
+ })),
+ highWaterMark: subprocessStdin.writableHighWaterMark,
+ objectMode: subprocessStdin.writableObjectMode
+ });
+ onStdinFinished(subprocessStdin, writable2);
+ return writable2;
+};
+var getSubprocessStdin = (subprocess, to, concurrentStreams) => {
+ const subprocessStdin = getToStream(subprocess, to);
+ const waitWritableFinal = addConcurrentStream(concurrentStreams, subprocessStdin, "writableFinal");
+ const waitWritableDestroy = addConcurrentStream(concurrentStreams, subprocessStdin, "writableDestroy");
+ return { subprocessStdin, waitWritableFinal, waitWritableDestroy };
+};
+var getWritableMethods = (subprocessStdin, subprocess, waitWritableFinal) => ({
+ write: onWrite.bind(void 0, subprocessStdin),
+ final: (0, import_node_util10.callbackify)(onWritableFinal.bind(void 0, subprocessStdin, subprocess, waitWritableFinal))
+});
+var onWrite = (subprocessStdin, chunk, encoding, done) => {
+ if (subprocessStdin.write(chunk, encoding)) {
+ done();
+ } else {
+ subprocessStdin.once("drain", done);
+ }
+};
+var onWritableFinal = async (subprocessStdin, subprocess, waitWritableFinal) => {
+ if (await waitForConcurrentStreams(waitWritableFinal, subprocess)) {
+ if (subprocessStdin.writable) {
+ subprocessStdin.end();
+ }
+ await subprocess;
+ }
+};
+var onStdinFinished = async (subprocessStdin, writable2, subprocessStdout) => {
+ try {
+ await waitForSubprocessStdin(subprocessStdin);
+ if (writable2.writable) {
+ writable2.end();
+ }
+ } catch (error) {
+ await safeWaitForSubprocessStdout(subprocessStdout);
+ destroyOtherWritable(writable2, error);
+ }
+};
+var onWritableDestroy = async ({ subprocessStdin, subprocess, waitWritableFinal, waitWritableDestroy }, error) => {
+ await waitForConcurrentStreams(waitWritableFinal, subprocess);
+ if (await waitForConcurrentStreams(waitWritableDestroy, subprocess)) {
+ destroyOtherWritable(subprocessStdin, error);
+ await waitForSubprocess(subprocess, error);
+ }
+};
+var destroyOtherWritable = (stream, error) => {
+ destroyOtherStream(stream, stream.writable, error);
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/convert/duplex.js
+var import_node_stream8 = require("node:stream");
+var import_node_util11 = require("node:util");
+var createDuplex = ({ subprocess, concurrentStreams, encoding }, { from, to, binary: binaryOption = true, preserveNewlines = true } = {}) => {
+ const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
+ const { subprocessStdout, waitReadableDestroy } = getSubprocessStdout(subprocess, from, concurrentStreams);
+ const { subprocessStdin, waitWritableFinal, waitWritableDestroy } = getSubprocessStdin(subprocess, to, concurrentStreams);
+ const { readableEncoding, readableObjectMode, readableHighWaterMark } = getReadableOptions(subprocessStdout, binary);
+ const { read, onStdoutDataDone } = getReadableMethods({
+ subprocessStdout,
+ subprocess,
+ binary,
+ encoding,
+ preserveNewlines
+ });
+ const duplex2 = new import_node_stream8.Duplex({
+ read,
+ ...getWritableMethods(subprocessStdin, subprocess, waitWritableFinal),
+ destroy: (0, import_node_util11.callbackify)(onDuplexDestroy.bind(void 0, {
+ subprocessStdout,
+ subprocessStdin,
+ subprocess,
+ waitReadableDestroy,
+ waitWritableFinal,
+ waitWritableDestroy
+ })),
+ readableHighWaterMark,
+ writableHighWaterMark: subprocessStdin.writableHighWaterMark,
+ readableObjectMode,
+ writableObjectMode: subprocessStdin.writableObjectMode,
+ encoding: readableEncoding
+ });
+ onStdoutFinished({
+ subprocessStdout,
+ onStdoutDataDone,
+ readable: duplex2,
+ subprocess,
+ subprocessStdin
+ });
+ onStdinFinished(subprocessStdin, duplex2, subprocessStdout);
+ return duplex2;
+};
+var onDuplexDestroy = async ({ subprocessStdout, subprocessStdin, subprocess, waitReadableDestroy, waitWritableFinal, waitWritableDestroy }, error) => {
+ await Promise.all([
+ onReadableDestroy({ subprocessStdout, subprocess, waitReadableDestroy }, error),
+ onWritableDestroy({
+ subprocessStdin,
+ subprocess,
+ waitWritableFinal,
+ waitWritableDestroy
+ }, error)
+ ]);
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/convert/iterable.js
+var createIterable = (subprocess, encoding, {
+ from,
+ binary: binaryOption = false,
+ preserveNewlines = false
+} = {}) => {
+ const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
+ const subprocessStdout = getFromStream(subprocess, from);
+ const onStdoutData = iterateOnSubprocessStream({
+ subprocessStdout,
+ subprocess,
+ binary,
+ shouldEncode: true,
+ encoding,
+ preserveNewlines
+ });
+ return iterateOnStdoutData(onStdoutData, subprocessStdout, subprocess);
+};
+var iterateOnStdoutData = async function* (onStdoutData, subprocessStdout, subprocess) {
+ try {
+ yield* onStdoutData;
+ } finally {
+ if (subprocessStdout.readable) {
+ subprocessStdout.destroy();
+ }
+ await subprocess;
+ }
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/convert/add.js
+var addConvertedStreams = (subprocess, { encoding }) => {
+ const concurrentStreams = initializeConcurrentStreams();
+ subprocess.readable = createReadable.bind(void 0, { subprocess, concurrentStreams, encoding });
+ subprocess.writable = createWritable.bind(void 0, { subprocess, concurrentStreams });
+ subprocess.duplex = createDuplex.bind(void 0, { subprocess, concurrentStreams, encoding });
+ subprocess.iterable = createIterable.bind(void 0, subprocess, encoding);
+ subprocess[Symbol.asyncIterator] = createIterable.bind(void 0, subprocess, encoding, {});
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/methods/promise.js
+var mergePromise = (subprocess, promise) => {
+ for (const [property, descriptor] of descriptors) {
+ const value = descriptor.value.bind(promise);
+ Reflect.defineProperty(subprocess, property, { ...descriptor, value });
+ }
+};
+var nativePromisePrototype = (async () => {
+})().constructor.prototype;
+var descriptors = ["then", "catch", "finally"].map((property) => [
+ property,
+ Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)
+]);
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/methods/main-async.js
+var execaCoreAsync = (rawFile, rawArguments, rawOptions, createNested) => {
+ const { file, commandArguments, command, escapedCommand, startTime, verboseInfo, options, fileDescriptors } = handleAsyncArguments(rawFile, rawArguments, rawOptions);
+ const { subprocess, promise } = spawnSubprocessAsync({
+ file,
+ commandArguments,
+ options,
+ startTime,
+ verboseInfo,
+ command,
+ escapedCommand,
+ fileDescriptors
+ });
+ subprocess.pipe = pipeToSubprocess.bind(void 0, {
+ source: subprocess,
+ sourcePromise: promise,
+ boundOptions: {},
+ createNested
+ });
+ mergePromise(subprocess, promise);
+ SUBPROCESS_OPTIONS.set(subprocess, { options, fileDescriptors });
+ return subprocess;
+};
+var handleAsyncArguments = (rawFile, rawArguments, rawOptions) => {
+ const { command, escapedCommand, startTime, verboseInfo } = handleCommand(rawFile, rawArguments, rawOptions);
+ const { file, commandArguments, options: normalizedOptions } = normalizeOptions(rawFile, rawArguments, rawOptions);
+ const options = handleAsyncOptions(normalizedOptions);
+ const fileDescriptors = handleStdioAsync(options, verboseInfo);
+ return {
+ file,
+ commandArguments,
+ command,
+ escapedCommand,
+ startTime,
+ verboseInfo,
+ options,
+ fileDescriptors
+ };
+};
+var handleAsyncOptions = ({ timeout, signal, ...options }) => {
+ if (signal !== void 0) {
+ throw new TypeError('The "signal" option has been renamed to "cancelSignal" instead.');
+ }
+ return { ...options, timeoutDuration: timeout };
+};
+var spawnSubprocessAsync = ({ file, commandArguments, options, startTime, verboseInfo, command, escapedCommand, fileDescriptors }) => {
+ let subprocess;
+ try {
+ subprocess = (0, import_node_child_process5.spawn)(...concatenateShell(file, commandArguments, options));
+ } catch (error) {
+ return handleEarlyError({
+ error,
+ command,
+ escapedCommand,
+ fileDescriptors,
+ options,
+ startTime,
+ verboseInfo
+ });
+ }
+ const controller = new AbortController();
+ (0, import_node_events14.setMaxListeners)(Number.POSITIVE_INFINITY, controller.signal);
+ const originalStreams = [...subprocess.stdio];
+ pipeOutputAsync(subprocess, fileDescriptors, controller);
+ cleanupOnExit(subprocess, options, controller);
+ const context3 = {};
+ const onInternalError = createDeferred();
+ subprocess.kill = subprocessKill.bind(void 0, {
+ kill: subprocess.kill.bind(subprocess),
+ options,
+ onInternalError,
+ context: context3,
+ controller
+ });
+ subprocess.all = makeAllStream(subprocess, options);
+ addConvertedStreams(subprocess, options);
+ addIpcMethods(subprocess, options);
+ const promise = handlePromise({
+ subprocess,
+ options,
+ startTime,
+ verboseInfo,
+ fileDescriptors,
+ originalStreams,
+ command,
+ escapedCommand,
+ context: context3,
+ onInternalError,
+ controller
+ });
+ return { subprocess, promise };
+};
+var handlePromise = async ({ subprocess, options, startTime, verboseInfo, fileDescriptors, originalStreams, command, escapedCommand, context: context3, onInternalError, controller }) => {
+ const [
+ errorInfo,
+ [exitCode, signal],
+ stdioResults,
+ allResult,
+ ipcOutput
+ ] = await waitForSubprocessResult({
+ subprocess,
+ options,
+ context: context3,
+ verboseInfo,
+ fileDescriptors,
+ originalStreams,
+ onInternalError,
+ controller
+ });
+ controller.abort();
+ onInternalError.resolve();
+ const stdio = stdioResults.map((stdioResult, fdNumber) => stripNewline(stdioResult, options, fdNumber));
+ const all = stripNewline(allResult, options, "all");
+ const result = getAsyncResult({
+ errorInfo,
+ exitCode,
+ signal,
+ stdio,
+ all,
+ ipcOutput,
+ context: context3,
+ options,
+ command,
+ escapedCommand,
+ startTime
+ });
+ return handleResult(result, verboseInfo, options);
+};
+var getAsyncResult = ({ errorInfo, exitCode, signal, stdio, all, ipcOutput, context: context3, options, command, escapedCommand, startTime }) => "error" in errorInfo ? makeError({
+ error: errorInfo.error,
+ command,
+ escapedCommand,
+ timedOut: context3.terminationReason === "timeout",
+ isCanceled: context3.terminationReason === "cancel" || context3.terminationReason === "gracefulCancel",
+ isGracefullyCanceled: context3.terminationReason === "gracefulCancel",
+ isMaxBuffer: errorInfo.error instanceof MaxBufferError,
+ isForcefullyTerminated: context3.isForcefullyTerminated,
+ exitCode,
+ signal,
+ stdio,
+ all,
+ ipcOutput,
+ options,
+ startTime,
+ isSync: false
+}) : makeSuccessResult({
+ command,
+ escapedCommand,
+ stdio,
+ all,
+ ipcOutput,
+ options,
+ startTime
+});
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/methods/bind.js
+var mergeOptions = (boundOptions, options) => {
+ const newOptions = Object.fromEntries(
+ Object.entries(options).map(([optionName, optionValue]) => [
+ optionName,
+ mergeOption(optionName, boundOptions[optionName], optionValue)
+ ])
+ );
+ return { ...boundOptions, ...newOptions };
+};
+var mergeOption = (optionName, boundOptionValue, optionValue) => {
+ if (DEEP_OPTIONS.has(optionName) && isPlainObject3(boundOptionValue) && isPlainObject3(optionValue)) {
+ return { ...boundOptionValue, ...optionValue };
+ }
+ return optionValue;
+};
+var DEEP_OPTIONS = /* @__PURE__ */ new Set(["env", ...FD_SPECIFIC_OPTIONS]);
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/methods/create.js
+var createExeca = (mapArguments, boundOptions, deepOptions, setBoundExeca) => {
+ const createNested = (mapArguments2, boundOptions2, setBoundExeca2) => createExeca(mapArguments2, boundOptions2, deepOptions, setBoundExeca2);
+ const boundExeca = (...execaArguments) => callBoundExeca({
+ mapArguments,
+ deepOptions,
+ boundOptions,
+ setBoundExeca,
+ createNested
+ }, ...execaArguments);
+ if (setBoundExeca !== void 0) {
+ setBoundExeca(boundExeca, createNested, boundOptions);
+ }
+ return boundExeca;
+};
+var callBoundExeca = ({ mapArguments, deepOptions = {}, boundOptions = {}, setBoundExeca, createNested }, firstArgument, ...nextArguments) => {
+ if (isPlainObject3(firstArgument)) {
+ return createNested(mapArguments, mergeOptions(boundOptions, firstArgument), setBoundExeca);
+ }
+ const { file, commandArguments, options, isSync } = parseArguments({
+ mapArguments,
+ firstArgument,
+ nextArguments,
+ deepOptions,
+ boundOptions
+ });
+ return isSync ? execaCoreSync(file, commandArguments, options) : execaCoreAsync(file, commandArguments, options, createNested);
+};
+var parseArguments = ({ mapArguments, firstArgument, nextArguments, deepOptions, boundOptions }) => {
+ const callArguments = isTemplateString(firstArgument) ? parseTemplates(firstArgument, nextArguments) : [firstArgument, ...nextArguments];
+ const [initialFile, initialArguments, initialOptions] = normalizeParameters(...callArguments);
+ const mergedOptions = mergeOptions(mergeOptions(deepOptions, boundOptions), initialOptions);
+ const {
+ file = initialFile,
+ commandArguments = initialArguments,
+ options = mergedOptions,
+ isSync = false
+ } = mapArguments({ file: initialFile, commandArguments: initialArguments, options: mergedOptions });
+ return {
+ file,
+ commandArguments,
+ options,
+ isSync
+ };
+};
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/methods/command.js
+var mapCommandAsync = ({ file, commandArguments }) => parseCommand(file, commandArguments);
+var mapCommandSync = ({ file, commandArguments }) => ({ ...parseCommand(file, commandArguments), isSync: true });
+var parseCommand = (command, unusedArguments) => {
+ if (unusedArguments.length > 0) {
+ throw new TypeError(`The command and its arguments must be passed as a single string: ${command} ${unusedArguments}.`);
+ }
+ const [file, ...commandArguments] = parseCommandString(command);
+ return { file, commandArguments };
+};
+var parseCommandString = (command) => {
+ if (typeof command !== "string") {
+ throw new TypeError(`The command must be a string: ${String(command)}.`);
+ }
+ const trimmedCommand = command.trim();
+ if (trimmedCommand === "") {
+ return [];
+ }
+ const tokens = [];
+ for (const token of trimmedCommand.split(SPACES_REGEXP)) {
+ const previousToken = tokens.at(-1);
+ if (previousToken && previousToken.endsWith("\\")) {
+ tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
+ } else {
+ tokens.push(token);
+ }
+ }
+ return tokens;
+};
+var SPACES_REGEXP = / +/g;
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/lib/methods/script.js
+var setScriptSync = (boundExeca, createNested, boundOptions) => {
+ boundExeca.sync = createNested(mapScriptSync, boundOptions);
+ boundExeca.s = boundExeca.sync;
+};
+var mapScriptAsync = ({ options }) => getScriptOptions(options);
+var mapScriptSync = ({ options }) => ({ ...getScriptOptions(options), isSync: true });
+var getScriptOptions = (options) => ({ options: { ...getScriptStdinOption(options), ...options } });
+var getScriptStdinOption = ({ input, inputFile, stdio }) => input === void 0 && inputFile === void 0 && stdio === void 0 ? { stdin: "inherit" } : {};
+var deepScriptOptions = { preferLocal: true };
+
+// node_modules/.pnpm/execa@9.6.0/node_modules/execa/index.js
+var execa = createExeca(() => ({}));
+var execaSync = createExeca(() => ({ isSync: true }));
+var execaCommand = createExeca(mapCommandAsync);
+var execaCommandSync = createExeca(mapCommandSync);
+var execaNode = createExeca(mapNode);
+var $ = createExeca(mapScriptAsync, {}, deepScriptOptions, setScriptSync);
+var {
+ sendMessage: sendMessage2,
+ getOneMessage: getOneMessage2,
+ getEachMessage: getEachMessage2,
+ getCancelSignal: getCancelSignal2
+} = getIpcExport();
+
+// actions/changed-roots/src/git.ts
+async function getChangedFilesGit(base, head, directory = process.cwd()) {
+ core3.info(
+ `Getting changed files between ${base} and ${head} in ${directory}`
+ );
+ let resolvedHead = await resolveCommitish(head, directory);
+ if (!resolvedHead) {
+ core3.warning(
+ `Head ref ${head} could not be resolved. Using HEAD as fallback.`
+ );
+ resolvedHead = await resolveCommitish("HEAD", directory);
+ }
+ let resolvedBase = await resolveCommitish(base, directory);
+ if (!resolvedBase) {
+ core3.warning(
+ `Base ref ${base} could not be resolved. Using ${resolvedHead}^ as fallback.`
+ );
+ resolvedBase = await resolveCommitish(`${resolvedHead}^`, directory);
+ }
+ if (!resolvedBase || !resolvedHead) {
+ throw new Error(
+ `One or both git references could not be resolved: base=${base} (${resolvedBase}), head=${head} (${resolvedHead})`
+ );
+ }
+ core3.info(
+ `Using (after fallback logic) - base: ${resolvedBase}, head: ${resolvedHead}`
+ );
+ const { stdout: changedFiles } = await execa(
+ "git",
+ ["diff", "--name-only", resolvedBase, resolvedHead],
+ {
+ cwd: directory
+ }
+ );
+ return changedFiles.split("\n").filter(Boolean);
+}
+async function resolveCommitish(ref, directory) {
+ if (!ref || /\s/.test(ref) || ref.includes("..")) return null;
+ try {
+ const { stdout } = await execa(
+ "git",
+ ["rev-parse", "-q", "--verify", `${ref}^{commit}`],
+ {
+ cwd: directory
+ }
+ );
+ return stdout.trim();
+ } catch {
+ return null;
+ }
+}
+
+// actions/changed-roots/src/github.ts
+var core4 = __toESM(require_core());
+async function getChangedFilesForPR(octokit, owner, repo, prNumber) {
+ core4.debug(`Comparing ${owner}/${repo} for PR ${prNumber}`);
+ const prFiles = await octokit.paginate(octokit.rest.pulls.listFiles, {
+ owner,
+ repo,
+ pull_number: prNumber,
+ per_page: 100
+ });
+ return prFiles;
+}
+
+// actions/changed-roots/src/run.ts
+function setOutputs(outputs) {
+ const csvOut = outputs.changedRoots.join(", ");
+ core5.info(`(output) roots-csv: ${csvOut}`);
+ core5.setOutput("roots-csv", csvOut);
+ const jsonOut = JSON.stringify(outputs.changedRoots);
+ core5.info(`(output) roots-json: ${jsonOut}`);
+ core5.setOutput("roots-json", jsonOut);
+}
+async function run() {
+ try {
+ core5.startGroup("Inputs and Context");
+ const context3 = getInvokeContext();
+ core5.info(
+ `Extracted Context: ${JSON.stringify({ ...context3, token: "" }, null, 2)}`
+ );
+ const inputs = getInputs();
+ core5.info(`Extracted Inputs: ${JSON.stringify(inputs, null, 2)}`);
+ const octokit = github3.getOctokit(context3.token);
+ core5.endGroup();
+ core5.startGroup("Determining roots");
+ const allRoots = await getAllRoots(inputs.rootFile, inputs.repositoryRoot);
+ core5.info(`Found ${allRoots.length} roots.`);
+ core5.debug(`Roots: ${JSON.stringify(allRoots, null, 2)}`);
+ core5.endGroup();
+ core5.startGroup("Filtering roots");
+ const filteredRoots = filterPaths(allRoots, inputs.rootPatterns);
+ core5.info(`After filtering, ${filteredRoots.length} roots remain.`);
+ core5.debug(`Filtered roots: ${JSON.stringify(filteredRoots, null, 2)}`);
+ core5.endGroup();
+ core5.startGroup("Determining changed roots");
+ const changedRoots = await determineChangedRoots(
+ octokit,
+ context3,
+ filteredRoots,
+ inputs
+ );
+ core5.endGroup();
+ core5.info(`Changed roots: ${changedRoots.join(", ")}`);
+ setOutputs({ changedRoots });
+ } catch (error) {
+ core5.endGroup();
+ core5.setFailed(`Action failed: ${error}`);
+ }
+}
+async function determineChangedRoots(octokit, { owner, repo, event }, roots, inputs) {
+ switch (event.eventName) {
+ case "pull_request":
+ core5.info("Determining changed files for Pull Request event.");
+ const files = await getChangedFilesForPR(
+ octokit,
+ owner,
+ repo,
+ event.prNumber
+ );
+ const changedFiles = files.map((f) => f.filename);
+ return determineRootsFromChangedFiles(inputs, changedFiles, roots);
+ case "push":
+ core5.info("Determining changed files for Push event.");
+ const changedFilesPush = await getChangedFilesGit(
+ event.base,
+ event.head,
+ inputs.repositoryRoot
+ );
+ return determineRootsFromChangedFiles(inputs, changedFilesPush, roots);
+ case "merge_group":
+ core5.info("Determining changed files for Merge Group event.");
+ const changedFilesMG = await getChangedFilesGit(
+ event.base,
+ event.head,
+ inputs.repositoryRoot
+ );
+ return determineRootsFromChangedFiles(inputs, changedFilesMG, roots);
+ case "no-change":
+ core5.info('A "no-change" event detected. Handling accordingly.');
+ return determineRootsForNoChangeEvent(inputs, roots);
+ default:
+ event;
+ throw new Error(`Unsupported event ${JSON.stringify(event)}`);
+ }
+}
+function determineRootsFromChangedFiles({ filePatterns }, changedFiles, roots) {
+ const changedFilesFiltered = filterPaths(changedFiles, filePatterns);
+ const filesToRoots = matchModules(changedFilesFiltered, roots);
+ const rootPaths = filesToRoots.map(([_, root]) => root);
+ const uniqueRootPaths = Array.from(new Set(rootPaths));
+ core5.info(`Found ${uniqueRootPaths.length} changed roots.`);
+ core5.debug(`Changed roots: ${JSON.stringify(uniqueRootPaths, null, 2)}`);
+ return uniqueRootPaths;
+}
+async function determineRootsForNoChangeEvent(inputs, roots) {
+ switch (inputs.noChangeBehaviour) {
+ case "all":
+ core5.info(
+ "No-change behaviour set to 'all'. All roots will be considered changed."
+ );
+ return roots;
+ case "none":
+ core5.info(
+ "No-change behaviour set to 'none'. No roots will be considered changed."
+ );
+ return [];
+ case "root":
+ core5.info(
+ "No-change behaviour set to 'root'. Only the root (if exists) will be considered changed."
+ );
+ return roots.includes(".") ? ["."] : [];
+ case "latest-commit":
+ core5.info(
+ "No-change behaviour set to 'latest-commit'. Determining changed files from the latest commit."
+ );
+ const changedFilesPush = await getChangedFilesGit(
+ "HEAD~1",
+ "HEAD",
+ inputs.repositoryRoot
+ );
+ return determineRootsFromChangedFiles(inputs, changedFilesPush, roots);
+ default:
+ inputs.noChangeBehaviour;
+ throw new Error(
+ `Unvalidated/Unhandled no-change behaviour: ${inputs.noChangeBehaviour}`
+ );
+ }
+}
+
+// actions/changed-roots/src/index.ts
+run();
+/*! Bundled license information:
+
+undici/lib/web/fetch/body.js:
+ (*! formdata-polyfill. MIT License. Jimmy Wärting *)
+
+undici/lib/web/websocket/frame.js:
+ (*! ws. MIT License. Einar Otto Stangvik *)
+
+undici/lib/web/fetch/body.js:
+ (*! formdata-polyfill. MIT License. Jimmy Wärting *)
+
+undici/lib/web/websocket/frame.js:
+ (*! ws. MIT License. Einar Otto Stangvik *)
+
+@octokit/request-error/dist-src/index.js:
+ (* v8 ignore else -- @preserve -- Bug with vitest coverage where it sees an else branch that doesn't exist *)
+
+@octokit/request/dist-bundle/index.js:
+ (* v8 ignore next -- @preserve *)
+ (* v8 ignore else -- @preserve *)
+
+is-number/index.js:
+ (*!
+ * is-number
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ *)
+
+to-regex-range/index.js:
+ (*!
+ * to-regex-range
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ *)
+
+fill-range/index.js:
+ (*!
+ * fill-range
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ *)
+*/
diff --git a/actions/changed-roots/package.json b/actions/changed-roots/package.json
new file mode 100644
index 00000000..8fc61025
--- /dev/null
+++ b/actions/changed-roots/package.json
@@ -0,0 +1,27 @@
+{
+ "name": "changed-roots",
+ "version": "1.0.0",
+ "description": "",
+ "private": true,
+ "engines": {
+ "node": ">= 24"
+ },
+ "scripts": {},
+ "author": "@smartcontractkit",
+ "license": "MIT",
+ "dependencies": {
+ "@actions/core": "^2.0.3",
+ "@actions/github": "^8.0.1",
+ "@actions/glob": "^0.5.1",
+ "execa": "^9.6.0",
+ "micromatch": "^4.0.8"
+ },
+ "repository": "https://github.com/smartcontractkit/.github",
+ "devDependencies": {
+ "@octokit/types": "^16.0.0",
+ "@octokit/webhooks-types": "^7.6.1",
+ "@types/micromatch": "^4.0.10",
+ "@types/node": "^24.12.2",
+ "vitest": "^4.0.18"
+ }
+}
diff --git a/actions/changed-roots/project.json b/actions/changed-roots/project.json
new file mode 100644
index 00000000..748822d2
--- /dev/null
+++ b/actions/changed-roots/project.json
@@ -0,0 +1,56 @@
+{
+ "name": "changed-roots",
+ "$schema": "../../node_modules/nx/schemas/project-schema.json",
+ "projectType": "application",
+ "sourceRoot": "actions/changed-roots",
+ "targets": {
+ "build": {
+ "dependsOn": ["build:internal"],
+ "command": "rimraf dist/package.json"
+ },
+ "build:internal": {
+ "executor": "@nx/esbuild:esbuild",
+ "outputs": ["{options.outputPath}"],
+ "defaultConfiguration": "production",
+ "options": {
+ "format": ["cjs"],
+ "thirdParty": true,
+ "outputPath": "actions/changed-roots/dist/",
+ "main": "actions/changed-roots/src/index.ts",
+ "assets": [],
+ "outputFileName": "index.js",
+ "esbuildOptions": {
+ "outExtension": {
+ ".js": ".js"
+ }
+ },
+ "tsConfig": "tsconfig.json",
+ "platform": "node"
+ },
+ "configurations": {
+ "development": {
+ "minify": false
+ },
+ "production": {
+ "minify": false
+ }
+ }
+ },
+ "check-types": {
+ "executor": "nx:run-commands",
+ "options": {
+ "cwd": "{projectRoot}",
+ "color": true,
+ "command": "tsc --noEmit --pretty"
+ }
+ },
+ "test": {
+ "executor": "nx:run-commands",
+ "options": {
+ "cwd": "{projectRoot}",
+ "color": true,
+ "command": "vitest run"
+ }
+ }
+ }
+}
diff --git a/actions/changed-roots/scripts/payload.json b/actions/changed-roots/scripts/payload.json
new file mode 100644
index 00000000..e95044a6
--- /dev/null
+++ b/actions/changed-roots/scripts/payload.json
@@ -0,0 +1,8 @@
+{
+ "action": "synchronize",
+ "after": "10182ba4d545ebb4852835cad9dafdd740764b92",
+ "before": "8be956afcec1effac0bc3aa4fbb7692e8ceea40f",
+ "pull_request": {
+ "number": 20471
+ }
+}
diff --git a/actions/changed-roots/scripts/test.sh b/actions/changed-roots/scripts/test.sh
new file mode 100755
index 00000000..62f64b6b
--- /dev/null
+++ b/actions/changed-roots/scripts/test.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+pnpm nx build changed-roots
+
+export GITHUB_TOKEN=$(gh auth token)
+export GITHUB_ACTOR=$(gh api user --jq .login)
+export GITHUB_REPOSITORY="smartcontractkit/chainlink"
+
+export GITHUB_EVENT_NAME="pull_request"
+export GITHUB_EVENT_PATH="actions/changed-roots/scripts/payload.json"
+
+tmp_file=$(mktemp)
+export GITHUB_STEP_SUMMARY="$tmp_file"
+
+export INPUT_REPOSITORY_ROOT="$HOME/Documents/repos/chainlink"
+export INPUT_FILE_PATTERNS='**/*.go,**/go.mod,**/go.sum'
+export INPUT_MODULE_PATTERNS='**,!core/scripts/cre/environment/examples/workflows/**'
+export INPUT_NO_CHANGE_BEHAVIOUR="all"
+export CL_LOCAL_DEBUG="true"
+
+node actions/changed-roots/dist/index.js
+
+# echo "Summary Output: $tmp_file"
+# cat "$tmp_file"
+# echo "Writing to table.md"
+# cat "$tmp_file" > actions/changed-roots/table.md
diff --git a/actions/changed-roots/src/__tests__/path-ops-filter.test.ts b/actions/changed-roots/src/__tests__/path-ops-filter.test.ts
new file mode 100644
index 00000000..c71eefad
--- /dev/null
+++ b/actions/changed-roots/src/__tests__/path-ops-filter.test.ts
@@ -0,0 +1,247 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+
+import { filterPaths } from "../path-ops";
+
+vi.mock("@actions/core", () => ({
+ startGroup: vi.fn(),
+ info: vi.fn(),
+ debug: vi.fn(),
+ endGroup: vi.fn(),
+}));
+
+describe("filterPaths (files)", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ test("returns all files when no patterns are provided (defaults to include all)", () => {
+ const files = ["src/index.ts", "src/utils/helper.ts"];
+ const filePatterns: string[] = [];
+
+ const result = filterPaths(files, filePatterns);
+
+ expect(result).toEqual(files);
+ });
+
+ test("excludes files via negations", () => {
+ const files = [
+ "src/index.ts",
+ "src/utils/helper.ts",
+ "test/index.test.ts",
+ "README.md",
+ ];
+ // Negate test files and README, include all else by default (no positive includes provided)
+ const filePatterns = ["!**/*.test.ts", "!README.md"];
+
+ const result = filterPaths(files, filePatterns);
+
+ expect(result).toEqual(["src/index.ts", "src/utils/helper.ts"]);
+ });
+
+ test("includes only specific extensions when only positive patterns are provided", () => {
+ const files = ["src/main.ts", "src/other.ts", "src/ignore.js", "README.md"];
+ const filePatterns = ["**/*.ts"];
+
+ const result = filterPaths(files, filePatterns);
+
+ expect(result).toEqual(["src/main.ts", "src/other.ts"]);
+ });
+
+ test("negations override includes (order-independent)", () => {
+ const files = [
+ "src/main.ts",
+ "src/main.test.ts",
+ "src/aux.ts",
+ "docs/README.md",
+ ];
+
+ // Case A: include-then-negate
+ const a = filterPaths(files, ["**/*.ts", "!**/*.test.ts"]);
+ // Case B: negate-then-include (should be identical because negations always win)
+ const b = filterPaths(files, ["!**/*.test.ts", "**/*.ts"]);
+
+ expect(a).toEqual(["src/main.ts", "src/aux.ts"]);
+ expect(b).toEqual(["src/main.ts", "src/aux.ts"]);
+ });
+
+ test("handles multiple negations", () => {
+ const files = [
+ "src/main.ts",
+ "docs/README.md",
+ "scripts/deploy.sh",
+ "scripts/cleanup.sh",
+ ];
+ const filePatterns = ["!**/*.md", "!scripts/*.sh"];
+
+ const result = filterPaths(files, filePatterns);
+
+ expect(result).toEqual(["src/main.ts"]);
+ });
+
+ test("returns empty array when everything is negated", () => {
+ const files = ["a.ts", "b.ts", "c.ts"];
+ const filePatterns = ["!**/*.ts"];
+
+ const result = filterPaths(files, filePatterns);
+
+ expect(result).toEqual([]);
+ });
+
+ test("nested directory negation excludes descendants", () => {
+ const files = [
+ "src/app/main.ts",
+ "src/app/config/settings.ts",
+ "src/app/config/.env",
+ ];
+ const filePatterns = ["!src/app/config/**"];
+
+ const result = filterPaths(files, filePatterns);
+
+ expect(result).toEqual(["src/app/main.ts"]);
+ });
+});
+
+describe("filterPaths (directories/modules)", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ test('matches root module (".") with wildcard patterns', () => {
+ const paths = [".", "services/api", "tools"];
+ const filePatterns = ["**"];
+
+ const result = filterPaths(paths, filePatterns);
+ expect(result).toEqual(paths);
+ });
+
+ test('negates root module (".") correctly', () => {
+ const paths = [".", "services/api", "tools"];
+ const filePatterns = ["!__ROOT__"];
+
+ const result = filterPaths(paths, filePatterns);
+ expect(result).toEqual(["services/api", "tools"]);
+ });
+
+ test("returns all paths when no patterns are provided (defaults to include all)", () => {
+ const paths = [
+ "services/payment",
+ "services/payment/submodule",
+ "services/billing",
+ "tools",
+ ];
+ const filePatterns: string[] = [];
+
+ const result = filterPaths(paths, filePatterns);
+ expect(result).toEqual(paths);
+ });
+
+ test("negates an exact module only (keeps submodules)", () => {
+ const paths = [
+ "services/payment",
+ "services/payment/submodule",
+ "services/payment/submodule/nested",
+ "services/billing",
+ "services/payments", // sibling-like but different
+ "tools",
+ ];
+
+ const filePatterns = ["!services/payment"];
+
+ const result = filterPaths(paths, filePatterns);
+
+ expect(result).toEqual([
+ "services/payment/submodule",
+ "services/payment/submodule/nested",
+ "services/billing",
+ "services/payments",
+ "tools",
+ ]);
+ });
+
+ test("negates a module and all of its submodules", () => {
+ const paths = [
+ "services/payment",
+ "services/payment/submodule",
+ "services/payment/submodule/nested",
+ "services/billing",
+ "services/payments", // sibling-like but different
+ "tools",
+ ];
+
+ const filePatterns = ["!services/payment/**"];
+
+ const result = filterPaths(paths, filePatterns);
+
+ expect(result).toEqual(["services/billing", "services/payments", "tools"]);
+ });
+
+ test("negates only submodules when using `dir/**/*` (root remains)", () => {
+ const paths = [
+ "services/payment",
+ "services/payment/submodule",
+ "services/payment/another",
+ "services/billing",
+ ];
+
+ const filePatterns = ["!services/payment/**/*"];
+
+ const result = filterPaths(paths, filePatterns);
+
+ expect(result).toEqual(["services/payment", "services/billing"]);
+ });
+
+ test("does not accidentally match similar prefixes", () => {
+ const paths = [
+ "services/pay",
+ "services/payment",
+ "services/payroll",
+ "services/pay/sub",
+ ];
+
+ const filePatterns = ["!services/pay/**"];
+
+ const result = filterPaths(paths, filePatterns);
+
+ expect(result).toEqual(["services/payment", "services/payroll"]);
+ });
+
+ test("handles prefixed wildcards for internal folders across the tree", () => {
+ const paths = [
+ "services/payments",
+ "services/payments/internal/crypto",
+ "services/billing",
+ "services/billing/internal/logs",
+ ];
+
+ const filePatterns = ["!**/internal/**"];
+
+ const result = filterPaths(paths, filePatterns);
+
+ expect(result).toEqual(["services/payments", "services/billing"]);
+ });
+
+ test("handles dot-directories with negations (dot: true behavior)", () => {
+ const paths = [".internal", ".internal/crypto", "services/api", ".github"];
+
+ const filePatterns = ["!.internal", "!.internal/**"];
+
+ const result = filterPaths(paths, filePatterns);
+
+ expect(result).toEqual(["services/api", ".github"]);
+ });
+
+ test("includes only a subtree when positive include is given, still allowing negations to exclude inside it", () => {
+ const paths = [
+ "services/payment",
+ "services/payment/internal/crypto",
+ "services/payment/api",
+ "services/billing",
+ ];
+
+ const filePatterns = ["services/payment/**", "!**/internal/**"];
+
+ const result = filterPaths(paths, filePatterns);
+
+ expect(result).toEqual(["services/payment", "services/payment/api"]);
+ });
+});
diff --git a/actions/changed-roots/src/__tests__/path-ops.test.ts b/actions/changed-roots/src/__tests__/path-ops.test.ts
new file mode 100644
index 00000000..8b1814fe
--- /dev/null
+++ b/actions/changed-roots/src/__tests__/path-ops.test.ts
@@ -0,0 +1,309 @@
+import * as core from "@actions/core";
+import * as glob from "@actions/glob";
+import { vi, beforeEach, describe, test, expect } from "vitest";
+
+import * as process from "process";
+import * as path from "path";
+
+import { getAllRoots, matchModule, matchModules } from "../path-ops";
+
+// Mock @actions/core
+vi.mock("@actions/core", () => ({
+ startGroup: vi.fn(),
+ endGroup: vi.fn(),
+ info: vi.fn(),
+ warning: vi.fn(),
+ debug: vi.fn(),
+ error: vi.fn(),
+ addPath: vi.fn(),
+ setFailed: vi.fn(),
+}));
+
+vi.mock("@actions/glob", () => ({
+ create: vi.fn().mockResolvedValue({
+ glob: vi.fn().mockResolvedValue([]),
+ }),
+}));
+
+describe("matchModule", () => {
+ describe("basic functionality", () => {
+ test("should match file in module directory", () => {
+ const moduleDirectories = ["src", "lib", "docs"];
+ const result = matchModule("src/index.ts", moduleDirectories);
+ expect(result).toBe("src");
+ });
+
+ test("should match file in nested module directory", () => {
+ const moduleDirectories = ["apps/web", "packages/ui"];
+ const result = matchModule("apps/web/pages/index.tsx", moduleDirectories);
+ expect(result).toBe("apps/web");
+ });
+
+ test("should walk up directory hierarchy to find parent module", () => {
+ const moduleDirectories = ["packages"];
+ const result = matchModule(
+ "packages/ui/src/components/Button.tsx",
+ moduleDirectories,
+ );
+ expect(result).toBe("packages");
+ });
+ });
+
+ describe("root directory handling", () => {
+ test('should match root directory with "."', () => {
+ const moduleDirectories = ["."];
+ const result = matchModule("src/index.ts", moduleDirectories);
+ expect(result).toBe(".");
+ });
+
+ test('should match root directory with "."', () => {
+ const moduleDirectories = ["."];
+ const result = matchModule("src/index.ts", moduleDirectories);
+ expect(result).toBe(".");
+ });
+
+ test('should prefer "." over "." when both are present', () => {
+ const moduleDirectories = [".", "."];
+ const result = matchModule("src/index.ts", moduleDirectories);
+ expect(result).toBe(".");
+ });
+
+ test("should handle file in root directory", () => {
+ const moduleDirectories = ["."];
+ const result = matchModule("go.mod", moduleDirectories);
+ expect(result).toBe(".");
+ });
+ });
+
+ describe("no match scenarios", () => {
+ test("should return empty string when no module found", () => {
+ const moduleDirectories = ["src", "lib"];
+ const result = matchModule("docs/go.mod", moduleDirectories);
+ expect(result).toBe("");
+ });
+
+ test("should return empty string for empty module directories", () => {
+ const moduleDirectories: string[] = [];
+ const result = matchModule("src/index.ts", moduleDirectories);
+ expect(result).toBe("");
+ });
+ });
+
+ describe("edge cases", () => {
+ test('should handle files without leading "."', () => {
+ const moduleDirectories = ["src", "lib"];
+ const result = matchModule("src/index.ts", moduleDirectories);
+ expect(result).toBe("src");
+ });
+
+ test("should handle deeply nested paths", () => {
+ const moduleDirectories = ["packages/core"];
+ const result = matchModule(
+ "packages/core/src/utils/helpers/string.ts",
+ moduleDirectories,
+ );
+ expect(result).toBe("packages/core");
+ });
+
+ test("should handle single file in directory", () => {
+ const moduleDirectories = ["scripts"];
+ const result = matchModule("scripts/build.js", moduleDirectories);
+ expect(result).toBe("scripts");
+ });
+ });
+});
+
+describe("matchModules", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ describe("basic functionality", () => {
+ test("should match multiple files to their modules", () => {
+ const files = ["src/index.ts", "lib/utils.ts", "docs/go.mod"];
+ const moduleDirectories = ["src", "lib", "docs"];
+
+ const result = matchModules(files, moduleDirectories);
+
+ expect(result).toEqual([
+ ["src/index.ts", "src"],
+ ["lib/utils.ts", "lib"],
+ ["docs/go.mod", "docs"],
+ ]);
+ });
+
+ test("should handle mixed matched and unmatched files", () => {
+ const files = ["src/index.ts", "unknown/file.ts", "lib/utils.ts"];
+ const moduleDirectories = ["src", "lib"];
+
+ const result = matchModules(files, moduleDirectories);
+
+ expect(result).toEqual([
+ ["src/index.ts", "src"],
+ ["lib/utils.ts", "lib"],
+ ]);
+ expect(core.info).toHaveBeenCalledWith(
+ "No matching module directory found for file: unknown/file.ts",
+ );
+ });
+
+ test("should handle files in nested module structures", () => {
+ const files = [
+ "packages/ui/src/Button.tsx",
+ "packages/utils/src/helpers.ts",
+ "apps/web/pages/index.tsx",
+ ];
+ const moduleDirectories = ["packages/ui", "packages/utils", "apps/web"];
+
+ const result = matchModules(files, moduleDirectories);
+
+ expect(result).toEqual([
+ ["packages/ui/src/Button.tsx", "packages/ui"],
+ ["packages/utils/src/helpers.ts", "packages/utils"],
+ ["apps/web/pages/index.tsx", "apps/web"],
+ ]);
+ });
+ });
+
+ describe("edge cases", () => {
+ test("should handle empty file list", () => {
+ const files: string[] = [];
+ const moduleDirectories = ["src", "lib"];
+
+ const result = matchModules(files, moduleDirectories);
+
+ expect(result).toEqual([]);
+ });
+
+ test("should handle empty module directories", () => {
+ const files = ["src/index.ts", "lib/utils.ts"];
+ const moduleDirectories: string[] = [];
+
+ const result = matchModules(files, moduleDirectories);
+
+ expect(result).toEqual([]);
+ expect(core.info).toHaveBeenCalledWith(
+ "No matching module directory found for file: src/index.ts",
+ );
+ expect(core.info).toHaveBeenCalledWith(
+ "No matching module directory found for file: lib/utils.ts",
+ );
+ });
+
+ test("should handle files that walk up to root", () => {
+ const files = ["src/components/Button.tsx", "go.mod"];
+ const moduleDirectories = ["."];
+
+ const result = matchModules(files, moduleDirectories);
+
+ expect(result).toEqual([
+ ["src/components/Button.tsx", "."],
+ ["go.mod", "."],
+ ]);
+ });
+
+ test("should handle duplicate file entries", () => {
+ const files = ["src/index.ts", "src/index.ts", "lib/utils.ts"];
+ const moduleDirectories = ["src", "lib"];
+
+ const result = matchModules(files, moduleDirectories);
+
+ expect(result).toEqual([
+ ["src/index.ts", "src"],
+ ["src/index.ts", "src"],
+ ["lib/utils.ts", "lib"],
+ ]);
+ });
+ });
+
+ describe("complex scenarios", () => {
+ test("should handle monorepo structure with overlapping paths", () => {
+ const files = [
+ "packages/core/src/index.ts",
+ "packages/ui/src/Button.tsx",
+ "packages/utils/index.ts",
+ "apps/web/src/App.tsx",
+ "scripts/build.js",
+ ];
+ const moduleDirectories = [
+ "packages/core",
+ "packages/ui",
+ "packages/utils",
+ "apps/web",
+ ];
+
+ const result = matchModules(files, moduleDirectories);
+
+ expect(result).toEqual([
+ ["packages/core/src/index.ts", "packages/core"],
+ ["packages/ui/src/Button.tsx", "packages/ui"],
+ ["packages/utils/index.ts", "packages/utils"],
+ ["apps/web/src/App.tsx", "apps/web"],
+ ]);
+ expect(core.info).toHaveBeenCalledWith(
+ "No matching module directory found for file: scripts/build.js",
+ );
+ });
+
+ test("should prioritize more specific module matches", () => {
+ const files = [
+ "packages/ui/components/Button.tsx",
+ "packages/ui/utils/helpers.ts",
+ "packages/core/index.ts",
+ ];
+ const moduleDirectories = [
+ "packages",
+ "packages/ui",
+ "packages/ui/components",
+ "packages/core",
+ ];
+
+ const result = matchModules(files, moduleDirectories);
+
+ expect(result).toEqual([
+ ["packages/ui/components/Button.tsx", "packages/ui/components"],
+ ["packages/ui/utils/helpers.ts", "packages/ui"],
+ ["packages/core/index.ts", "packages/core"],
+ ]);
+ });
+ });
+});
+
+describe("getAllRoots", () => {
+ const globMock = vi.mocked(glob);
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ test("should find all go.mod files in a directory", async () => {
+ const cwd = process.cwd();
+ globMock.create = vi.fn().mockResolvedValue({
+ glob: vi
+ .fn()
+ .mockResolvedValue([
+ path.join(cwd, "/path/to/md/file/go.mod"),
+ path.join(cwd, "/path/to/md/file/sub-dir/go.mod"),
+ path.join(cwd, "/path/to/md/file/sub-dir-2/go.mod"),
+ path.join(cwd, "/path/to/md/file/sub-dir/nested/go.mod"),
+ ]),
+ });
+
+ const result = await getAllRoots("go.mod", "./");
+ expect(result).toEqual([
+ "path/to/md/file",
+ "path/to/md/file/sub-dir",
+ "path/to/md/file/sub-dir-2",
+ "path/to/md/file/sub-dir/nested",
+ ]);
+ });
+
+ test("should return an empty array if no root files are found", async () => {
+ globMock.create = vi.fn().mockResolvedValue({
+ glob: vi.fn().mockResolvedValue([]),
+ });
+
+ const result = await getAllRoots("package.json", "./test/empty");
+ expect(result).toEqual([]);
+ });
+});
diff --git a/actions/changed-roots/src/__tests__/run-inputs.test.ts b/actions/changed-roots/src/__tests__/run-inputs.test.ts
new file mode 100644
index 00000000..07574911
--- /dev/null
+++ b/actions/changed-roots/src/__tests__/run-inputs.test.ts
@@ -0,0 +1,90 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+import * as core from "@actions/core";
+import { getRunInputStringArray } from "../run-inputs";
+
+// We'll control what core.getInput returns via this mutable value.
+let mockInputValue = "";
+
+// Mock @actions/core methods we use.
+vi.mock("@actions/core", () => ({
+ info: vi.fn(),
+ // Simulate the GitHub Actions behavior:
+ // - Return `mockInputValue` when present.
+ // - Throw if required=true and value is falsy (empty string).
+ getInput: vi.fn((name: string, opts?: { required?: boolean }) => {
+ if (opts?.required && !mockInputValue) {
+ throw new Error(`Input required and not supplied: ${name}`);
+ }
+ return mockInputValue;
+ }),
+}));
+
+describe("getRunInputStringArray", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockInputValue = "";
+ });
+
+ test("returns [] when no input is provided and required=false", () => {
+ mockInputValue = "";
+ const result = getRunInputStringArray("filePatterns", false);
+ expect(result).toEqual([]);
+ expect(core.info).not.toHaveBeenCalled(); // no parsing log if nothing to parse
+ });
+
+ test("throws when required=true and no input is provided", () => {
+ mockInputValue = "";
+ expect(() => getRunInputStringArray("filePatterns", true)).toThrow(
+ /Input required and not supplied/i,
+ );
+ });
+
+ test("comma-separated values are split by comma and trimmed", () => {
+ mockInputValue = "src/**/*.ts, test/**/*.ts ,docs/**/*.md";
+ const result = getRunInputStringArray("filePatterns", false);
+ expect(result).toEqual(["src/**/*.ts", "test/**/*.ts", "docs/**/*.md"]);
+ expect(core.info).toHaveBeenCalledWith(
+ expect.stringMatching(/separator ','/),
+ );
+ });
+
+ test("newline-separated values are split by newline and trimmed", () => {
+ mockInputValue = "src/**/*.ts\ntest/**/*.ts\n\ndocs/**/*.md ";
+ const result = getRunInputStringArray("filePatterns", false);
+ expect(result).toEqual(["src/**/*.ts", "test/**/*.ts", "docs/**/*.md"]);
+ expect(core.info).toHaveBeenCalledWith(
+ expect.stringMatching(/separator '\n'/),
+ );
+ });
+
+ test("Windows newlines (\\r\\n) are handled via trim when using newline separator", () => {
+ mockInputValue = "a/**/*.ts\r\nb/**/*.ts\r\nc/**/*.ts";
+ const result = getRunInputStringArray("filePatterns", false);
+ expect(result).toEqual(["a/**/*.ts", "b/**/*.ts", "c/**/*.ts"]);
+ expect(core.info).toHaveBeenCalledWith(
+ expect.stringMatching(/separator '\n'/),
+ );
+ });
+
+ test("mixed commas and newlines: chooses comma as separator when any comma exists", () => {
+ // NOTE: Implementation prefers ',' if present at all.
+ mockInputValue = "a/**/*.ts\nb/**/*.ts, c/**/*.ts\nd/**/*.ts";
+ const result = getRunInputStringArray("filePatterns", false);
+ // Because comma is chosen, we split into chunks around commas.
+ // Newlines remain inside items and then are trimmed (but not split further).
+ // After trim, items may still contain '\n' if not at edges.
+ expect(result).toEqual(["a/**/*.ts\nb/**/*.ts", "c/**/*.ts\nd/**/*.ts"]);
+ expect(core.info).toHaveBeenCalledWith(
+ expect.stringMatching(/separator ','/),
+ );
+ });
+
+ test("filters out empty segments after trimming", () => {
+ mockInputValue = "src/**/*.ts,, \n , test/**/*.ts\n\n";
+ // Contains both comma and newline -> comma wins, empty pieces removed.
+ const result = getRunInputStringArray("filePatterns", false);
+ // With comma separator, this becomes ["src/**/*.ts", "", " \n ", " test/**/*.ts\n\n"]
+ // After trimming & filtering empties: ["src/**/*.ts", "test/**/*.ts"]
+ expect(result).toEqual(["src/**/*.ts", "test/**/*.ts"]);
+ });
+});
diff --git a/actions/changed-roots/src/event.ts b/actions/changed-roots/src/event.ts
new file mode 100644
index 00000000..0425f1b4
--- /dev/null
+++ b/actions/changed-roots/src/event.ts
@@ -0,0 +1,82 @@
+import * as github from "@actions/github";
+import {
+ PushEvent,
+ PullRequestEvent,
+ MergeGroupEvent,
+} from "@octokit/webhooks-types";
+
+export type EventData =
+ | PullRequestEventData
+ | PushEventData
+ | MergeGroupEventData
+ | NoChangeEventData;
+
+export interface PullRequestEventData {
+ eventName: "pull_request";
+ prNumber: number;
+}
+
+export interface PushEventData {
+ eventName: "push";
+ base: string;
+ head: string;
+}
+
+export interface MergeGroupEventData {
+ eventName: "merge_group";
+ base: string;
+ head: string;
+}
+
+export interface NoChangeEventData {
+ eventName: "no-change";
+}
+
+/**
+ * This determines the relevant event data from the event payload, used to determine the changed files.
+ */
+export function getEventData(): EventData {
+ const { context } = github;
+
+ switch (context.eventName) {
+ case "pull_request":
+ const prEvent = context.payload.pull_request as PullRequestEvent;
+ if (!prEvent.number) {
+ throw new Error("Pull request number not found in event payload.");
+ }
+ return {
+ eventName: "pull_request",
+ prNumber: prEvent.number,
+ };
+ case "push":
+ const pushEvent = github.context.payload as PushEvent;
+ if (!pushEvent.before || !pushEvent.after) {
+ throw new Error("Push event payload missing 'before' or 'after' SHAs.");
+ }
+ return {
+ eventName: "push",
+ base: pushEvent.before,
+ head: pushEvent.after,
+ };
+
+ case "merge_group":
+ const mgEvent = github.context.payload as MergeGroupEvent;
+ if (!mgEvent.merge_group.base_sha || !mgEvent.merge_group.head_sha) {
+ throw new Error(
+ "Merge group event payload missing 'base_sha' or 'head_sha'.",
+ );
+ }
+ return {
+ eventName: "merge_group",
+ base: mgEvent.merge_group.base_sha,
+ head: mgEvent.merge_group.head_sha,
+ };
+ case "schedule":
+ case "workflow_dispatch":
+ return {
+ eventName: "no-change",
+ };
+ default:
+ throw new Error(`Unsupported event type: ${context.eventName}`);
+ }
+}
diff --git a/actions/changed-roots/src/git.ts b/actions/changed-roots/src/git.ts
new file mode 100644
index 00000000..f3e3621a
--- /dev/null
+++ b/actions/changed-roots/src/git.ts
@@ -0,0 +1,76 @@
+import * as core from "@actions/core";
+import { execa } from "execa";
+
+/**
+ * Returns changed files between two git refs using `git diff --name-only`.
+ * If the refs cannot be resolved, fallback logic is applied:
+ * - If `head` cannot be resolved, `HEAD` is used.
+ * - If `base` cannot be resolved, `head^` is used.
+ */
+export async function getChangedFilesGit(
+ base: string,
+ head: string,
+ directory: string = process.cwd(),
+): Promise {
+ core.info(
+ `Getting changed files between ${base} and ${head} in ${directory}`,
+ );
+
+ let resolvedHead = await resolveCommitish(head, directory);
+ if (!resolvedHead) {
+ core.warning(
+ `Head ref ${head} could not be resolved. Using HEAD as fallback.`,
+ );
+ resolvedHead = await resolveCommitish("HEAD", directory);
+ }
+
+ let resolvedBase = await resolveCommitish(base, directory);
+ if (!resolvedBase) {
+ core.warning(
+ `Base ref ${base} could not be resolved. Using ${resolvedHead}^ as fallback.`,
+ );
+ resolvedBase = await resolveCommitish(`${resolvedHead}^`, directory);
+ }
+
+ if (!resolvedBase || !resolvedHead) {
+ throw new Error(
+ `One or both git references could not be resolved: base=${base} (${resolvedBase}), head=${head} (${resolvedHead})`,
+ );
+ }
+
+ core.info(
+ `Using (after fallback logic) - base: ${resolvedBase}, head: ${resolvedHead}`,
+ );
+ const { stdout: changedFiles } = await execa(
+ "git",
+ ["diff", "--name-only", resolvedBase, resolvedHead],
+ {
+ cwd: directory,
+ },
+ );
+
+ return changedFiles.split("\n").filter(Boolean);
+}
+
+/**
+ * Resolves a git ref (branch, tag, or SHA) to a full commit SHA, or null if it cannot be resolved.
+ */
+async function resolveCommitish(
+ ref: string,
+ directory: string,
+): Promise {
+ if (!ref || /\s/.test(ref) || ref.includes("..")) return null;
+
+ try {
+ const { stdout } = await execa(
+ "git",
+ ["rev-parse", "-q", "--verify", `${ref}^{commit}`],
+ {
+ cwd: directory,
+ },
+ );
+ return stdout.trim(); // resolved full SHA
+ } catch {
+ return null;
+ }
+}
diff --git a/actions/changed-roots/src/github.ts b/actions/changed-roots/src/github.ts
new file mode 100644
index 00000000..7309e17e
--- /dev/null
+++ b/actions/changed-roots/src/github.ts
@@ -0,0 +1,27 @@
+import * as core from "@actions/core";
+import * as github from "@actions/github";
+import { GetResponseTypeFromEndpointMethod } from "@octokit/types";
+
+export type OctokitType = ReturnType;
+type ListFilesResponse = GetResponseTypeFromEndpointMethod<
+ OctokitType["rest"]["pulls"]["listFiles"]
+>;
+export type PRFiles = ListFilesResponse["data"];
+
+export async function getChangedFilesForPR(
+ octokit: OctokitType,
+ owner: string,
+ repo: string,
+ prNumber: number,
+): Promise {
+ core.debug(`Comparing ${owner}/${repo} for PR ${prNumber}`);
+
+ const prFiles = await octokit.paginate(octokit.rest.pulls.listFiles, {
+ owner,
+ repo,
+ pull_number: prNumber,
+ per_page: 100,
+ });
+
+ return prFiles;
+}
diff --git a/actions/changed-roots/src/index.ts b/actions/changed-roots/src/index.ts
new file mode 100644
index 00000000..5ad0499e
--- /dev/null
+++ b/actions/changed-roots/src/index.ts
@@ -0,0 +1,3 @@
+import { run } from "./run";
+
+run();
diff --git a/actions/changed-roots/src/path-ops.ts b/actions/changed-roots/src/path-ops.ts
new file mode 100644
index 00000000..dca54233
--- /dev/null
+++ b/actions/changed-roots/src/path-ops.ts
@@ -0,0 +1,169 @@
+import * as core from "@actions/core";
+import * as glob from "@actions/glob";
+
+import * as path from "path";
+
+import micromatch from "micromatch";
+
+/** Normalize to POSIX-ish repo-relative paths */
+function normalizePath(p: string): string {
+ // convert backslashes to forward slashes
+ let s = p.replace(/\\/g, "/");
+
+ // special-case root
+ if (s === "." || s === "./") return ".";
+
+ // strip leading ./ and extra slashes
+ s = s.replace(/^.\//, "").replace(/\/+$/, "");
+ return s;
+}
+
+/** Sort modules deepest-first so submodules are preferred */
+function sortDeepestFirst(mods: string[]): string[] {
+ return [...new Set(mods)].sort((a, b) => {
+ const da = a === "." ? 0 : a.split("/").length;
+ const db = b === "." ? 0 : b.split("/").length;
+ // deeper first
+ if (db !== da) return db - da;
+ // tie-breaker: longer string first
+ return b.length - a.length;
+ });
+}
+
+/**
+ * Matches a single file path to a module directory.
+ * Ensure moduleDirectories are sorted deepest-first and normalized before calling.
+ */
+export function matchModule(file: string, moduleDirectories: string[]): string {
+ const fileNorm = normalizePath(file);
+
+ for (const mod of moduleDirectories) {
+ if (mod === ".") {
+ // Root module matches anything if present
+ return ".";
+ }
+
+ // Build patterns that include the directory itself and anything under it.
+ // Using dot: true so patterns match dotfiles/dirs like .github/**.
+ const patterns = [mod, `${mod}/**`];
+
+ if (micromatch.isMatch(fileNorm, patterns, { dot: true })) {
+ return mod;
+ }
+ }
+
+ return "";
+}
+
+/**
+ * Map each file to its best-matching module directory.
+ * Skips files that don't belong to any provided module.
+ */
+export function matchModules(
+ files: string[],
+ moduleDirectories: string[],
+): [string, string][] {
+ core.startGroup("Matching modified files to modules");
+
+ // Normalize & pre-sort once
+ const normalizedFiles = files.map(normalizePath);
+ const normalizedModules = sortDeepestFirst(
+ moduleDirectories.map(normalizePath),
+ );
+
+ const results: [string, string][] = [];
+ for (const file of normalizedFiles) {
+ const matched = matchModule(file, normalizedModules);
+ if (!matched) {
+ core.info(`No matching module directory found for file: ${file}`);
+ continue;
+ }
+ core.info(`Matched ${file} to module directory: ${matched}`);
+ results.push([file, matched]);
+ }
+
+ core.endGroup();
+ return results;
+}
+
+/**
+ * Recursively gets the relative paths of all directories containing the given root file.
+ * Note: relative to directory provided.
+ */
+export async function getAllRoots(
+ rootFile: string,
+ directory: string = ".",
+): Promise {
+ core.startGroup(`Finding all ${rootFile} files within ${directory}`);
+ const pattern = `${directory}/**/${rootFile}`;
+ try {
+ const globber = await glob.create(pattern);
+ const files = await globber.glob();
+
+ if (files.length === 0) {
+ core.warning(`No ${rootFile} files found within ${directory}`);
+ return [];
+ }
+ core.info(`Found ${files.length} ${rootFile} files.`);
+ core.info(`Found ${rootFile} files: ${JSON.stringify(files)}`);
+ const directories = files.map((f) => {
+ const relativePath = path.relative(directory, f);
+ return path.dirname(relativePath);
+ });
+ core.info(`Found root directories: ${JSON.stringify(directories)}`);
+ return directories;
+ } catch (error) {
+ throw new Error(`failed to get ${rootFile} files: ${error}`);
+ } finally {
+ core.endGroup();
+ }
+}
+
+export function filterPaths(paths: string[], filePatterns: string[]): string[] {
+ core.info(
+ `Checking ${paths.length} paths against ${filePatterns.length} patterns.`,
+ );
+
+ if (filePatterns.length === 0) {
+ core.info(
+ "No include patterns specified, defaulting to include all paths.",
+ );
+ filePatterns.push("**");
+ }
+
+ core.debug(`Initial paths: ${JSON.stringify(paths)}`);
+ core.debug(`File patterns: ${JSON.stringify(filePatterns)}`);
+
+ // Separate include and exclude patterns explicitly
+ const includePatterns = filePatterns.filter((p) => !p.startsWith("!"));
+ const excludePatterns = filePatterns
+ .filter((p) => p.startsWith("!"))
+ .map((p) => p.slice(1)); // strip the leading '!'
+
+ // normalize '.' to '__ROOT__' for matching purposes. As '*', '**' doesn't match '.'
+ const normalizeDotForMatch = (p: string) => (p === "." ? "__ROOT__" : p);
+ const filteredPaths = paths.filter((rawPath) => {
+ const path = normalizeDotForMatch(rawPath);
+
+ const isExcluded =
+ excludePatterns.length > 0 &&
+ micromatch.isMatch(path, excludePatterns, { dot: true });
+
+ if (isExcluded) {
+ core.debug(`Excluded by negation: ${rawPath}`);
+ return false;
+ }
+
+ const isIncluded =
+ includePatterns.length === 0 ||
+ micromatch.isMatch(path, includePatterns, { dot: true });
+
+ core.debug(`Path: ${rawPath}, included: ${isIncluded}`);
+ return isIncluded;
+ });
+
+ core.info(`After filtering, ${filteredPaths.length} paths remain.`);
+ core.debug(`Filtered paths: ${JSON.stringify(filteredPaths)}`);
+
+ return filteredPaths;
+}
diff --git a/actions/changed-roots/src/run-inputs.ts b/actions/changed-roots/src/run-inputs.ts
new file mode 100644
index 00000000..44ef03f8
--- /dev/null
+++ b/actions/changed-roots/src/run-inputs.ts
@@ -0,0 +1,161 @@
+import * as core from "@actions/core";
+import * as github from "@actions/github";
+
+import { getEventData } from "./event";
+
+export interface RunInputs {
+ repositoryRoot: string;
+ rootFile: string;
+ filePatterns: string[];
+ rootPatterns: string[];
+ noChangeBehaviour: "all" | "none" | "root" | "latest-commit";
+}
+
+export type InvokeContext = ReturnType;
+
+export function getInputs(): RunInputs {
+ core.info("Getting inputs for run.");
+
+ const inputs: RunInputs = {
+ repositoryRoot: getRunInputString("repositoryRoot", true),
+ rootFile: getRunInputString("rootFile", true),
+ filePatterns: getRunInputStringArray("filePatterns", true),
+ rootPatterns: getRunInputStringArray("rootPatterns", true),
+ noChangeBehaviour: getRunInputString(
+ "noChangeBehaviour",
+ true,
+ ) as RunInputs["noChangeBehaviour"],
+ };
+
+ core.info(`Inputs: ${JSON.stringify(inputs)}`);
+ return inputs;
+}
+
+/**
+ * Parses the invoke context from Github Actions' context.
+ * @returns The invoke context
+ */
+export function getInvokeContext() {
+ const { owner, repo } = github.context.repo;
+
+ const token =
+ process.env.GITHUB_TOKEN ||
+ core.getInput("github-token", {
+ required: true,
+ });
+ if (!token) {
+ core.setFailed("GitHub token is not set.");
+ return process.exit(1);
+ }
+
+ const event = getEventData();
+ core.info(
+ `Invoke context: ${JSON.stringify({ token: "****", owner, repo, event }, null, 2)}`,
+ );
+
+ return { token, owner, repo, event };
+}
+
+interface RunInputConfiguration {
+ /**
+ * The parameter name as defined in the action.yml file.
+ */
+ parameter: string;
+ /**
+ * The local environment variable name to use when debugging locally.
+ * This is typically the parameter name with dashes replaced by underscores.
+ * For example, "directory" becomes "DIRECTORY". foo-bar becomes FOO_BAR.
+ */
+ localParameter: string;
+
+ /**
+ * An optional function to validate the input value.
+ */
+ validator?: (value: string) => boolean;
+}
+
+const runInputsConfiguration: {
+ [K in keyof RunInputs]: RunInputConfiguration;
+} = {
+ repositoryRoot: {
+ parameter: "repository-root",
+ localParameter: "REPOSITORY_ROOT",
+ },
+ rootFile: {
+ parameter: "root-file",
+ localParameter: "ROOT_FILE",
+ },
+ filePatterns: {
+ parameter: "file-patterns",
+ localParameter: "FILE_PATTERNS",
+ },
+ rootPatterns: {
+ parameter: "root-patterns",
+ localParameter: "ROOT_PATTERNS",
+ },
+ noChangeBehaviour: {
+ parameter: "no-change-behaviour",
+ localParameter: "NO_CHANGE_BEHAVIOUR",
+ validator: validateNoChangeBehaviourInput,
+ },
+};
+
+function getRunInputString(input: keyof RunInputs, required: boolean = true) {
+ const inputKey = getInputKey(input);
+ const inputValue = core.getInput(inputKey, {
+ required,
+ });
+ const validator = runInputsConfiguration[input]?.validator;
+ if (inputValue && validator && !validator(inputValue)) {
+ throw new Error(`Invalid value for input ${inputKey}: ${inputValue}`);
+ }
+ return inputValue;
+}
+
+/**
+ * Note: Exported for testing purposes.
+ */
+export function getRunInputStringArray(
+ input: keyof RunInputs,
+ required: boolean = false,
+): string[] {
+ const inputKey = getInputKey(input);
+ const inputValue = core.getInput(inputKey, {
+ required,
+ });
+ if (!inputValue) {
+ return [];
+ }
+ const seperator = inputValue.includes(",") ? "," : "\n";
+ core.info(
+ `Parsing input ${inputKey} as string array using separator '${seperator}'`,
+ );
+ return inputValue
+ .split(seperator)
+ .map((s) => s.trim())
+ .filter((s) => s.length > 0);
+}
+
+function getInputKey(input: keyof RunInputs) {
+ const config = runInputsConfiguration[input];
+ if (!config) {
+ // this should never happen due to type safety
+ throw new Error(`No configuration found for input: ${input}`);
+ }
+
+ // Use local debug input key if local debugging is enabled
+ const isLocalDebug = process.env.CL_LOCAL_DEBUG;
+ const inputKey = isLocalDebug ? config.localParameter : config.parameter;
+ return inputKey;
+}
+
+function validateNoChangeBehaviourInput(
+ value: string,
+): value is RunInputs["noChangeBehaviour"] {
+ return (
+ value === "all" ||
+ value === "none" ||
+ value === "root" ||
+ value === "latest-commit"
+ );
+}
diff --git a/actions/changed-roots/src/run.ts b/actions/changed-roots/src/run.ts
new file mode 100644
index 00000000..117052b6
--- /dev/null
+++ b/actions/changed-roots/src/run.ts
@@ -0,0 +1,188 @@
+import * as core from "@actions/core";
+import * as github from "@actions/github";
+
+import { getInvokeContext, getInputs, RunInputs } from "./run-inputs";
+import { getAllRoots, matchModules, filterPaths } from "./path-ops";
+import { getChangedFilesGit } from "./git";
+
+import { getChangedFilesForPR } from "./github";
+
+import type { OctokitType } from "./github";
+import type { InvokeContext } from "./run-inputs";
+
+interface Outputs {
+ changedRoots: string[];
+}
+
+function setOutputs(outputs: Outputs) {
+ const csvOut = outputs.changedRoots.join(", ");
+ core.info(`(output) roots-csv: ${csvOut}`);
+ core.setOutput("roots-csv", csvOut);
+
+ const jsonOut = JSON.stringify(outputs.changedRoots);
+ core.info(`(output) roots-json: ${jsonOut}`);
+ core.setOutput("roots-json", jsonOut);
+}
+
+export async function run(): Promise {
+ try {
+ // 1. Get inputs and context
+ core.startGroup("Inputs and Context");
+ const context = getInvokeContext();
+ core.info(
+ `Extracted Context: ${JSON.stringify({ ...context, token: "" }, null, 2)}`,
+ );
+
+ const inputs = getInputs();
+ core.info(`Extracted Inputs: ${JSON.stringify(inputs, null, 2)}`);
+
+ const octokit = github.getOctokit(context.token);
+ core.endGroup();
+
+ // 2. Find all roots
+ core.startGroup("Determining roots");
+
+ const allRoots = await getAllRoots(inputs.rootFile, inputs.repositoryRoot);
+ core.info(`Found ${allRoots.length} roots.`);
+ core.debug(`Roots: ${JSON.stringify(allRoots, null, 2)}`);
+ core.endGroup();
+
+ // 3. Filter roots based on root patterns
+ core.startGroup("Filtering roots");
+ const filteredRoots = filterPaths(allRoots, inputs.rootPatterns);
+ core.info(`After filtering, ${filteredRoots.length} roots remain.`);
+ core.debug(`Filtered roots: ${JSON.stringify(filteredRoots, null, 2)}`);
+ core.endGroup();
+
+ // 4. Determine changed roots
+ core.startGroup("Determining changed roots");
+ const changedRoots = await determineChangedRoots(
+ octokit,
+ context,
+ filteredRoots,
+ inputs,
+ );
+ core.endGroup();
+
+ core.info(`Changed roots: ${changedRoots.join(", ")}`);
+ setOutputs({ changedRoots });
+ } catch (error) {
+ core.endGroup();
+ core.setFailed(`Action failed: ${error}`);
+ }
+}
+
+/**
+ * Determines the changed roots based on the event type.
+ */
+async function determineChangedRoots(
+ octokit: OctokitType,
+ { owner, repo, event }: InvokeContext,
+ roots: string[],
+ inputs: RunInputs,
+) {
+ switch (event.eventName) {
+ case "pull_request":
+ core.info("Determining changed files for Pull Request event.");
+ const files = await getChangedFilesForPR(
+ octokit,
+ owner,
+ repo,
+ event.prNumber,
+ );
+ const changedFiles = files.map((f) => f.filename);
+ return determineRootsFromChangedFiles(inputs, changedFiles, roots);
+
+ case "push":
+ core.info("Determining changed files for Push event.");
+ const changedFilesPush = await getChangedFilesGit(
+ event.base,
+ event.head,
+ inputs.repositoryRoot,
+ );
+ return determineRootsFromChangedFiles(inputs, changedFilesPush, roots);
+
+ case "merge_group":
+ core.info("Determining changed files for Merge Group event.");
+ const changedFilesMG = await getChangedFilesGit(
+ event.base,
+ event.head,
+ inputs.repositoryRoot,
+ );
+ return determineRootsFromChangedFiles(inputs, changedFilesMG, roots);
+
+ case "no-change":
+ core.info('A "no-change" event detected. Handling accordingly.');
+ return determineRootsForNoChangeEvent(inputs, roots);
+
+ default:
+ event satisfies never; // type guard to ensure all cases are handled
+ throw new Error(`Unsupported event ${JSON.stringify(event)}`);
+ }
+}
+
+/**
+ * Determines the roots affected by the given changed files.
+ */
+function determineRootsFromChangedFiles(
+ { filePatterns }: RunInputs,
+ changedFiles: string[],
+ roots: string[],
+): string[] {
+ const changedFilesFiltered = filterPaths(changedFiles, filePatterns);
+
+ const filesToRoots = matchModules(changedFilesFiltered, roots);
+ const rootPaths = filesToRoots.map(([_, root]) => root);
+ const uniqueRootPaths = Array.from(new Set(rootPaths));
+
+ core.info(`Found ${uniqueRootPaths.length} changed roots.`);
+ core.debug(`Changed roots: ${JSON.stringify(uniqueRootPaths, null, 2)}`);
+
+ return uniqueRootPaths;
+}
+
+/**
+ * Determines the roots affected when a "no-change" event is detected.
+ * A no-change event is one that does not have an associated changeset, such as schedule or workflow_dispatch.
+ */
+async function determineRootsForNoChangeEvent(
+ inputs: RunInputs,
+ roots: string[],
+): Promise {
+ switch (inputs.noChangeBehaviour) {
+ case "all":
+ core.info(
+ "No-change behaviour set to 'all'. All roots will be considered changed.",
+ );
+ return roots;
+
+ case "none":
+ core.info(
+ "No-change behaviour set to 'none'. No roots will be considered changed.",
+ );
+ return [];
+
+ case "root":
+ core.info(
+ "No-change behaviour set to 'root'. Only the root (if exists) will be considered changed.",
+ );
+ return roots.includes(".") ? ["."] : [];
+
+ case "latest-commit":
+ core.info(
+ "No-change behaviour set to 'latest-commit'. Determining changed files from the latest commit.",
+ );
+ const changedFilesPush = await getChangedFilesGit(
+ "HEAD~1",
+ "HEAD",
+ inputs.repositoryRoot,
+ );
+ return determineRootsFromChangedFiles(inputs, changedFilesPush, roots);
+
+ default:
+ inputs.noChangeBehaviour satisfies never; // type guard to ensure all cases are handled
+ throw new Error(
+ `Unvalidated/Unhandled no-change behaviour: ${inputs.noChangeBehaviour}`,
+ );
+ }
+}
diff --git a/actions/changed-roots/tsconfig.json b/actions/changed-roots/tsconfig.json
new file mode 100644
index 00000000..416f4964
--- /dev/null
+++ b/actions/changed-roots/tsconfig.json
@@ -0,0 +1,10 @@
+{
+ "compilerOptions": {
+ "target": "esnext",
+ "module": "commonjs",
+ "noEmit": true,
+ "isolatedModules": true,
+ "strict": true,
+ "esModuleInterop": true
+ }
+}
diff --git a/actions/changed-roots/tsconfig.spec.json b/actions/changed-roots/tsconfig.spec.json
new file mode 100644
index 00000000..22d4b07d
--- /dev/null
+++ b/actions/changed-roots/tsconfig.spec.json
@@ -0,0 +1,13 @@
+{
+ "extends": "./tsconfig.json",
+ "compilerOptions": {
+ "outDir": "../../dist/out-tsc",
+ "types": ["node"]
+ },
+ "include": [
+ "src/**/*.test.ts",
+ "src/**/*.spec.ts",
+ "src/**/*.d.ts",
+ "types/**/*.d.ts"
+ ]
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 673c6864..a9a52dc4 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -215,6 +215,40 @@ importers:
specifier: ^4.0.18
version: 4.0.18(@types/node@24.12.2)(jiti@2.6.1)(jsdom@24.1.0)(tsx@4.19.1)(yaml@2.8.2)
+ actions/changed-roots:
+ dependencies:
+ '@actions/core':
+ specifier: ^2.0.3
+ version: 2.0.3
+ '@actions/github':
+ specifier: ^8.0.1
+ version: 8.0.1
+ '@actions/glob':
+ specifier: ^0.5.1
+ version: 0.5.1
+ execa:
+ specifier: ^9.6.0
+ version: 9.6.0
+ micromatch:
+ specifier: ^4.0.8
+ version: 4.0.8
+ devDependencies:
+ '@octokit/types':
+ specifier: ^16.0.0
+ version: 16.0.0
+ '@octokit/webhooks-types':
+ specifier: ^7.6.1
+ version: 7.6.1
+ '@types/micromatch':
+ specifier: ^4.0.10
+ version: 4.0.10
+ '@types/node':
+ specifier: ^24.12.2
+ version: 24.12.2
+ vitest:
+ specifier: ^4.0.18
+ version: 4.0.18(@types/node@24.12.2)(jiti@2.6.1)(jsdom@24.1.0)(tsx@4.19.1)(yaml@2.8.2)
+
actions/check-git-tag-for-monorepo: {}
actions/check-if-verified: {}
@@ -11617,6 +11651,14 @@ snapshots:
chai: 6.2.2
tinyrainbow: 3.0.3
+ '@vitest/mocker@4.0.18(vite@7.3.1(@types/node@24.12.2)(jiti@2.6.1)(tsx@4.19.1)(yaml@2.4.5))':
+ dependencies:
+ '@vitest/spy': 4.0.18
+ estree-walker: 3.0.3
+ magic-string: 0.30.21
+ optionalDependencies:
+ vite: 7.3.1(@types/node@24.12.2)(jiti@2.6.1)(tsx@4.19.1)(yaml@2.4.5)
+
'@vitest/mocker@4.0.18(vite@7.3.1(@types/node@24.12.2)(jiti@2.6.1)(tsx@4.19.1)(yaml@2.8.2))':
dependencies:
'@vitest/spy': 4.0.18
@@ -11625,6 +11667,14 @@ snapshots:
optionalDependencies:
vite: 7.3.1(@types/node@24.12.2)(jiti@2.6.1)(tsx@4.19.1)(yaml@2.8.2)
+ '@vitest/mocker@4.0.18(vite@7.3.1(@types/node@25.5.0)(jiti@2.6.1)(tsx@4.19.1)(yaml@2.8.2))':
+ dependencies:
+ '@vitest/spy': 4.0.18
+ estree-walker: 3.0.3
+ magic-string: 0.30.21
+ optionalDependencies:
+ vite: 7.3.1(@types/node@25.5.0)(jiti@2.6.1)(tsx@4.19.1)(yaml@2.8.2)
+
'@vitest/pretty-format@4.0.18':
dependencies:
tinyrainbow: 3.0.3
@@ -15594,7 +15644,7 @@ snapshots:
vitest@4.0.18(@types/node@24.12.2)(jiti@2.6.1)(jsdom@24.1.0)(tsx@4.19.1)(yaml@2.4.5):
dependencies:
'@vitest/expect': 4.0.18
- '@vitest/mocker': 4.0.18(vite@7.3.1(@types/node@24.12.2)(jiti@2.6.1)(tsx@4.19.1)(yaml@2.8.2))
+ '@vitest/mocker': 4.0.18(vite@7.3.1(@types/node@24.12.2)(jiti@2.6.1)(tsx@4.19.1)(yaml@2.4.5))
'@vitest/pretty-format': 4.0.18
'@vitest/runner': 4.0.18
'@vitest/snapshot': 4.0.18
@@ -15670,7 +15720,7 @@ snapshots:
vitest@4.0.18(@types/node@25.5.0)(jiti@2.6.1)(jsdom@24.1.0)(tsx@4.19.1)(yaml@2.8.2):
dependencies:
'@vitest/expect': 4.0.18
- '@vitest/mocker': 4.0.18(vite@7.3.1(@types/node@24.12.2)(jiti@2.6.1)(tsx@4.19.1)(yaml@2.8.2))
+ '@vitest/mocker': 4.0.18(vite@7.3.1(@types/node@25.5.0)(jiti@2.6.1)(tsx@4.19.1)(yaml@2.8.2))
'@vitest/pretty-format': 4.0.18
'@vitest/runner': 4.0.18
'@vitest/snapshot': 4.0.18