Preview: index.js
Size: 1.50 MB
/proc/thread-self/root/home/byroehnu/.trash/node_modules11/@prisma/engines/dist/index.js
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// ../../node_modules/.pnpm/ms@2.1.2/node_modules/ms/index.js
var require_ms = __commonJS({
"../../node_modules/.pnpm/ms@2.1.2/node_modules/ms/index.js"(exports, module2) {
var s = 1e3;
var m = s * 60;
var h2 = m * 60;
var d2 = h2 * 24;
var w2 = d2 * 7;
var y2 = d2 * 365.25;
module2.exports = function(val, options2) {
options2 = options2 || {};
var type = typeof val;
if (type === "string" && val.length > 0) {
return parse(val);
} else if (type === "number" && isFinite(val)) {
return options2.long ? fmtLong(val) : fmtShort(val);
}
throw new Error(
"val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
);
};
function parse(str) {
str = String(str);
if (str.length > 100) {
return;
}
var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
str
);
if (!match) {
return;
}
var n2 = parseFloat(match[1]);
var type = (match[2] || "ms").toLowerCase();
switch (type) {
case "years":
case "year":
case "yrs":
case "yr":
case "y":
return n2 * y2;
case "weeks":
case "week":
case "w":
return n2 * w2;
case "days":
case "day":
case "d":
return n2 * d2;
case "hours":
case "hour":
case "hrs":
case "hr":
case "h":
return n2 * h2;
case "minutes":
case "minute":
case "mins":
case "min":
case "m":
return n2 * m;
case "seconds":
case "second":
case "secs":
case "sec":
case "s":
return n2 * s;
case "milliseconds":
case "millisecond":
case "msecs":
case "msec":
case "ms":
return n2;
default:
return void 0;
}
}
function fmtShort(ms) {
var msAbs = Math.abs(ms);
if (msAbs >= d2) {
return Math.round(ms / d2) + "d";
}
if (msAbs >= h2) {
return Math.round(ms / h2) + "h";
}
if (msAbs >= m) {
return Math.round(ms / m) + "m";
}
if (msAbs >= s) {
return Math.round(ms / s) + "s";
}
return ms + "ms";
}
function fmtLong(ms) {
var msAbs = Math.abs(ms);
if (msAbs >= d2) {
return plural(ms, msAbs, d2, "day");
}
if (msAbs >= h2) {
return plural(ms, msAbs, h2, "hour");
}
if (msAbs >= m) {
return plural(ms, msAbs, m, "minute");
}
if (msAbs >= s) {
return plural(ms, msAbs, s, "second");
}
return ms + " ms";
}
function plural(ms, msAbs, n2, name) {
var isPlural = msAbs >= n2 * 1.5;
return Math.round(ms / n2) + " " + name + (isPlural ? "s" : "");
}
}
});
// ../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/common.js
var require_common = __commonJS({
"../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/common.js"(exports, module2) {
function setup(env) {
createDebug.debug = createDebug;
createDebug.default = createDebug;
createDebug.coerce = coerce;
createDebug.disable = disable;
createDebug.enable = enable;
createDebug.enabled = enabled;
createDebug.humanize = require_ms();
createDebug.destroy = destroy;
Object.keys(env).forEach((key) => {
createDebug[key] = env[key];
});
createDebug.names = [];
createDebug.skips = [];
createDebug.formatters = {};
function selectColor(namespace) {
let hash = 0;
for (let i = 0; i < namespace.length; i++) {
hash = (hash << 5) - hash + namespace.charCodeAt(i);
hash |= 0;
}
return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
}
createDebug.selectColor = selectColor;
function createDebug(namespace) {
let prevTime;
let enableOverride = null;
let namespacesCache;
let enabledCache;
function debug9(...args) {
if (!debug9.enabled) {
return;
}
const self = debug9;
const curr = Number(new Date());
const ms = curr - (prevTime || curr);
self.diff = ms;
self.prev = prevTime;
self.curr = curr;
prevTime = curr;
args[0] = createDebug.coerce(args[0]);
if (typeof args[0] !== "string") {
args.unshift("%O");
}
let index = 0;
args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
if (match === "%%") {
return "%";
}
index++;
const formatter = createDebug.formatters[format];
if (typeof formatter === "function") {
const val = args[index];
match = formatter.call(self, val);
args.splice(index, 1);
index--;
}
return match;
});
createDebug.formatArgs.call(self, args);
const logFn = self.log || createDebug.log;
logFn.apply(self, args);
}
debug9.namespace = namespace;
debug9.useColors = createDebug.useColors();
debug9.color = createDebug.selectColor(namespace);
debug9.extend = extend;
debug9.destroy = createDebug.destroy;
Object.defineProperty(debug9, "enabled", {
enumerable: true,
configurable: false,
get: () => {
if (enableOverride !== null) {
return enableOverride;
}
if (namespacesCache !== createDebug.namespaces) {
namespacesCache = createDebug.namespaces;
enabledCache = createDebug.enabled(namespace);
}
return enabledCache;
},
set: (v) => {
enableOverride = v;
}
});
if (typeof createDebug.init === "function") {
createDebug.init(debug9);
}
return debug9;
}
function extend(namespace, delimiter) {
const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
newDebug.log = this.log;
return newDebug;
}
function enable(namespaces) {
createDebug.save(namespaces);
createDebug.namespaces = namespaces;
createDebug.names = [];
createDebug.skips = [];
let i;
const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
const len = split.length;
for (i = 0; i < len; i++) {
if (!split[i]) {
continue;
}
namespaces = split[i].replace(/\*/g, ".*?");
if (namespaces[0] === "-") {
createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$"));
} else {
createDebug.names.push(new RegExp("^" + namespaces + "$"));
}
}
}
function disable() {
const namespaces = [
...createDebug.names.map(toNamespace),
...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace)
].join(",");
createDebug.enable("");
return namespaces;
}
function enabled(name) {
if (name[name.length - 1] === "*") {
return true;
}
let i;
let len;
for (i = 0, len = createDebug.skips.length; i < len; i++) {
if (createDebug.skips[i].test(name)) {
return false;
}
}
for (i = 0, len = createDebug.names.length; i < len; i++) {
if (createDebug.names[i].test(name)) {
return true;
}
}
return false;
}
function toNamespace(regexp) {
return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
}
function coerce(val) {
if (val instanceof Error) {
return val.stack || val.message;
}
return val;
}
function destroy() {
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
}
createDebug.enable(createDebug.load());
return createDebug;
}
module2.exports = setup;
}
});
// ../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/browser.js
var require_browser = __commonJS({
"../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/browser.js"(exports, module2) {
exports.formatArgs = formatArgs;
exports.save = save;
exports.load = load;
exports.useColors = useColors;
exports.storage = localstorage();
exports.destroy = (() => {
let warned = false;
return () => {
if (!warned) {
warned = true;
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
}
};
})();
exports.colors = [
"#0000CC",
"#0000FF",
"#0033CC",
"#0033FF",
"#0066CC",
"#0066FF",
"#0099CC",
"#0099FF",
"#00CC00",
"#00CC33",
"#00CC66",
"#00CC99",
"#00CCCC",
"#00CCFF",
"#3300CC",
"#3300FF",
"#3333CC",
"#3333FF",
"#3366CC",
"#3366FF",
"#3399CC",
"#3399FF",
"#33CC00",
"#33CC33",
"#33CC66",
"#33CC99",
"#33CCCC",
"#33CCFF",
"#6600CC",
"#6600FF",
"#6633CC",
"#6633FF",
"#66CC00",
"#66CC33",
"#9900CC",
"#9900FF",
"#9933CC",
"#9933FF",
"#99CC00",
"#99CC33",
"#CC0000",
"#CC0033",
"#CC0066",
"#CC0099",
"#CC00CC",
"#CC00FF",
"#CC3300",
"#CC3333",
"#CC3366",
"#CC3399",
"#CC33CC",
"#CC33FF",
"#CC6600",
"#CC6633",
"#CC9900",
"#CC9933",
"#CCCC00",
"#CCCC33",
"#FF0000",
"#FF0033",
"#FF0066",
"#FF0099",
"#FF00CC",
"#FF00FF",
"#FF3300",
"#FF3333",
"#FF3366",
"#FF3399",
"#FF33CC",
"#FF33FF",
"#FF6600",
"#FF6633",
"#FF9900",
"#FF9933",
"#FFCC00",
"#FFCC33"
];
function useColors() {
if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
return true;
}
if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
return false;
}
return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
}
function formatArgs(args) {
args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
if (!this.useColors) {
return;
}
const c = "color: " + this.color;
args.splice(1, 0, c, "color: inherit");
let index = 0;
let lastC = 0;
args[0].replace(/%[a-zA-Z%]/g, (match) => {
if (match === "%%") {
return;
}
index++;
if (match === "%c") {
lastC = index;
}
});
args.splice(lastC, 0, c);
}
exports.log = console.debug || console.log || (() => {
});
function save(namespaces) {
try {
if (namespaces) {
exports.storage.setItem("debug", namespaces);
} else {
exports.storage.removeItem("debug");
}
} catch (error) {
}
}
function load() {
let r2;
try {
r2 = exports.storage.getItem("debug");
} catch (error) {
}
if (!r2 && typeof process !== "undefined" && "env" in process) {
r2 = process.env.DEBUG;
}
return r2;
}
function localstorage() {
try {
return localStorage;
} catch (error) {
}
}
module2.exports = require_common()(exports);
var { formatters } = module2.exports;
formatters.j = function(v) {
try {
return JSON.stringify(v);
} catch (error) {
return "[UnexpectedJSONParseError]: " + error.message;
}
};
}
});
// ../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js
var require_has_flag = __commonJS({
"../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js"(exports, module2) {
"use strict";
module2.exports = (flag, argv = process.argv) => {
const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
const position = argv.indexOf(prefix + flag);
const terminatorPosition = argv.indexOf("--");
return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
};
}
});
// ../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js
var require_supports_color = __commonJS({
"../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports, module2) {
"use strict";
var os4 = require("os");
var tty = require("tty");
var hasFlag = require_has_flag();
var { env } = process;
var forceColor;
if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
forceColor = 0;
} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
forceColor = 1;
}
if ("FORCE_COLOR" in env) {
if (env.FORCE_COLOR === "true") {
forceColor = 1;
} else if (env.FORCE_COLOR === "false") {
forceColor = 0;
} else {
forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
}
}
function translateLevel(level) {
if (level === 0) {
return false;
}
return {
level,
hasBasic: true,
has256: level >= 2,
has16m: level >= 3
};
}
function supportsColor(haveStream, streamIsTTY) {
if (forceColor === 0) {
return 0;
}
if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
return 3;
}
if (hasFlag("color=256")) {
return 2;
}
if (haveStream && !streamIsTTY && forceColor === void 0) {
return 0;
}
const min = forceColor || 0;
if (env.TERM === "dumb") {
return min;
}
if (process.platform === "win32") {
const osRelease = os4.release().split(".");
if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
return Number(osRelease[2]) >= 14931 ? 3 : 2;
}
return 1;
}
if ("CI" in env) {
if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
return 1;
}
return min;
}
if ("TEAMCITY_VERSION" in env) {
return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
}
if (env.COLORTERM === "truecolor") {
return 3;
}
if ("TERM_PROGRAM" in env) {
const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
switch (env.TERM_PROGRAM) {
case "iTerm.app":
return version >= 3 ? 3 : 2;
case "Apple_Terminal":
return 2;
}
}
if (/-256(color)?$/i.test(env.TERM)) {
return 2;
}
if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
return 1;
}
if ("COLORTERM" in env) {
return 1;
}
return min;
}
function getSupportLevel(stream) {
const level = supportsColor(stream, stream && stream.isTTY);
return translateLevel(level);
}
module2.exports = {
supportsColor: getSupportLevel,
stdout: translateLevel(supportsColor(true, tty.isatty(1))),
stderr: translateLevel(supportsColor(true, tty.isatty(2)))
};
}
});
// ../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/node.js
var require_node = __commonJS({
"../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/node.js"(exports, module2) {
var tty = require("tty");
var util = require("util");
exports.init = init2;
exports.log = log;
exports.formatArgs = formatArgs;
exports.save = save;
exports.load = load;
exports.useColors = useColors;
exports.destroy = util.deprecate(
() => {
},
"Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
);
exports.colors = [6, 2, 3, 4, 5, 1];
try {
const supportsColor = require_supports_color();
if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
exports.colors = [
20,
21,
26,
27,
32,
33,
38,
39,
40,
41,
42,
43,
44,
45,
56,
57,
62,
63,
68,
69,
74,
75,
76,
77,
78,
79,
80,
81,
92,
93,
98,
99,
112,
113,
128,
129,
134,
135,
148,
149,
160,
161,
162,
163,
164,
165,
166,
167,
168,
169,
170,
171,
172,
173,
178,
179,
184,
185,
196,
197,
198,
199,
200,
201,
202,
203,
204,
205,
206,
207,
208,
209,
214,
215,
220,
221
];
}
} catch (error) {
}
exports.inspectOpts = Object.keys(process.env).filter((key) => {
return /^debug_/i.test(key);
}).reduce((obj, key) => {
const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
return k.toUpperCase();
});
let val = process.env[key];
if (/^(yes|on|true|enabled)$/i.test(val)) {
val = true;
} else if (/^(no|off|false|disabled)$/i.test(val)) {
val = false;
} else if (val === "null") {
val = null;
} else {
val = Number(val);
}
obj[prop] = val;
return obj;
}, {});
function useColors() {
return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
}
function formatArgs(args) {
const { namespace: name, useColors: useColors2 } = this;
if (useColors2) {
const c = this.color;
const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
const prefix = ` ${colorCode};1m${name} \x1B[0m`;
args[0] = prefix + args[0].split("\n").join("\n" + prefix);
args.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m");
} else {
args[0] = getDate() + name + " " + args[0];
}
}
function getDate() {
if (exports.inspectOpts.hideDate) {
return "";
}
return new Date().toISOString() + " ";
}
function log(...args) {
return process.stderr.write(util.format(...args) + "\n");
}
function save(namespaces) {
if (namespaces) {
process.env.DEBUG = namespaces;
} else {
delete process.env.DEBUG;
}
}
function load() {
return process.env.DEBUG;
}
function init2(debug9) {
debug9.inspectOpts = {};
const keys = Object.keys(exports.inspectOpts);
for (let i = 0; i < keys.length; i++) {
debug9.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
}
}
module2.exports = require_common()(exports);
var { formatters } = module2.exports;
formatters.o = function(v) {
this.inspectOpts.colors = this.useColors;
return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
};
formatters.O = function(v) {
this.inspectOpts.colors = this.useColors;
return util.inspect(v, this.inspectOpts);
};
}
});
// ../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/index.js
var require_src = __commonJS({
"../../node_modules/.pnpm/debug@4.3.4/node_modules/debug/src/index.js"(exports, module2) {
if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
module2.exports = require_browser();
} else {
module2.exports = require_node();
}
}
});
// ../../node_modules/.pnpm/@prisma+engines-version@4.17.0-26.6b0aef69b7cdfc787f822ecd7cdc76d5f1991584/node_modules/@prisma/engines-version/package.json
var require_package = __commonJS({
"../../node_modules/.pnpm/@prisma+engines-version@4.17.0-26.6b0aef69b7cdfc787f822ecd7cdc76d5f1991584/node_modules/@prisma/engines-version/package.json"(exports, module2) {
module2.exports = {
name: "@prisma/engines-version",
version: "4.17.0-26.6b0aef69b7cdfc787f822ecd7cdc76d5f1991584",
main: "index.js",
types: "index.d.ts",
license: "Apache-2.0",
author: "Tim Suchanek <suchanek@prisma.io>",
prisma: {
enginesVersion: "6b0aef69b7cdfc787f822ecd7cdc76d5f1991584"
},
repository: {
type: "git",
url: "https://github.com/prisma/engines-wrapper.git",
directory: "packages/engines-version"
},
devDependencies: {
"@types/node": "18.16.19",
typescript: "4.9.5"
},
files: [
"index.js",
"index.d.ts"
],
scripts: {
build: "tsc -d"
}
};
}
});
// ../../node_modules/.pnpm/@prisma+engines-version@4.17.0-26.6b0aef69b7cdfc787f822ecd7cdc76d5f1991584/node_modules/@prisma/engines-version/index.js
var require_engines_version = __commonJS({
"../../node_modules/.pnpm/@prisma+engines-version@4.17.0-26.6b0aef69b7cdfc787f822ecd7cdc76d5f1991584/node_modules/@prisma/engines-version/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.enginesVersion = void 0;
exports.enginesVersion = require_package().prisma.enginesVersion;
}
});
// ../../node_modules/.pnpm/ansi-escapes@4.3.2/node_modules/ansi-escapes/index.js
var require_ansi_escapes = __commonJS({
"../../node_modules/.pnpm/ansi-escapes@4.3.2/node_modules/ansi-escapes/index.js"(exports, module2) {
"use strict";
var ansiEscapes = module2.exports;
module2.exports.default = ansiEscapes;
var ESC = "\x1B[";
var OSC = "\x1B]";
var BEL = "\x07";
var SEP = ";";
var isTerminalApp = process.env.TERM_PROGRAM === "Apple_Terminal";
ansiEscapes.cursorTo = (x, y2) => {
if (typeof x !== "number") {
throw new TypeError("The `x` argument is required");
}
if (typeof y2 !== "number") {
return ESC + (x + 1) + "G";
}
return ESC + (y2 + 1) + ";" + (x + 1) + "H";
};
ansiEscapes.cursorMove = (x, y2) => {
if (typeof x !== "number") {
throw new TypeError("The `x` argument is required");
}
let ret = "";
if (x < 0) {
ret += ESC + -x + "D";
} else if (x > 0) {
ret += ESC + x + "C";
}
if (y2 < 0) {
ret += ESC + -y2 + "A";
} else if (y2 > 0) {
ret += ESC + y2 + "B";
}
return ret;
};
ansiEscapes.cursorUp = (count = 1) => ESC + count + "A";
ansiEscapes.cursorDown = (count = 1) => ESC + count + "B";
ansiEscapes.cursorForward = (count = 1) => ESC + count + "C";
ansiEscapes.cursorBackward = (count = 1) => ESC + count + "D";
ansiEscapes.cursorLeft = ESC + "G";
ansiEscapes.cursorSavePosition = isTerminalApp ? "\x1B7" : ESC + "s";
ansiEscapes.cursorRestorePosition = isTerminalApp ? "\x1B8" : ESC + "u";
ansiEscapes.cursorGetPosition = ESC + "6n";
ansiEscapes.cursorNextLine = ESC + "E";
ansiEscapes.cursorPrevLine = ESC + "F";
ansiEscapes.cursorHide = ESC + "?25l";
ansiEscapes.cursorShow = ESC + "?25h";
ansiEscapes.eraseLines = (count) => {
let clear = "";
for (let i = 0; i < count; i++) {
clear += ansiEscapes.eraseLine + (i < count - 1 ? ansiEscapes.cursorUp() : "");
}
if (count) {
clear += ansiEscapes.cursorLeft;
}
return clear;
};
ansiEscapes.eraseEndLine = ESC + "K";
ansiEscapes.eraseStartLine = ESC + "1K";
ansiEscapes.eraseLine = ESC + "2K";
ansiEscapes.eraseDown = ESC + "J";
ansiEscapes.eraseUp = ESC + "1J";
ansiEscapes.eraseScreen = ESC + "2J";
ansiEscapes.scrollUp = ESC + "S";
ansiEscapes.scrollDown = ESC + "T";
ansiEscapes.clearScreen = "\x1Bc";
ansiEscapes.clearTerminal = process.platform === "win32" ? `${ansiEscapes.eraseScreen}${ESC}0f` : `${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`;
ansiEscapes.beep = BEL;
ansiEscapes.link = (text, url) => {
return [
OSC,
"8",
SEP,
SEP,
url,
BEL,
text,
OSC,
"8",
SEP,
SEP,
BEL
].join("");
};
ansiEscapes.image = (buffer, options2 = {}) => {
let ret = `${OSC}1337;File=inline=1`;
if (options2.width) {
ret += `;width=${options2.width}`;
}
if (options2.height) {
ret += `;height=${options2.height}`;
}
if (options2.preserveAspectRatio === false) {
ret += ";preserveAspectRatio=0";
}
return ret + ":" + buffer.toString("base64") + BEL;
};
ansiEscapes.iTerm = {
setCwd: (cwd = process.cwd()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
annotation: (message, options2 = {}) => {
let ret = `${OSC}1337;`;
const hasX = typeof options2.x !== "undefined";
const hasY = typeof options2.y !== "undefined";
if ((hasX || hasY) && !(hasX && hasY && typeof options2.length !== "undefined")) {
throw new Error("`x`, `y` and `length` must be defined when `x` or `y` is defined");
}
message = message.replace(/\|/g, "");
ret += options2.isHidden ? "AddHiddenAnnotation=" : "AddAnnotation=";
if (options2.length > 0) {
ret += (hasX ? [message, options2.length, options2.x, options2.y] : [options2.length, message]).join("|");
} else {
ret += message;
}
return ret + BEL;
}
};
}
});
// ../../node_modules/.pnpm/supports-hyperlinks@2.3.0/node_modules/supports-hyperlinks/index.js
var require_supports_hyperlinks = __commonJS({
"../../node_modules/.pnpm/supports-hyperlinks@2.3.0/node_modules/supports-hyperlinks/index.js"(exports, module2) {
"use strict";
var supportsColor = require_supports_color();
var hasFlag = require_has_flag();
function parseVersion(versionString) {
if (/^\d{3,4}$/.test(versionString)) {
const m = /(\d{1,2})(\d{2})/.exec(versionString);
return {
major: 0,
minor: parseInt(m[1], 10),
patch: parseInt(m[2], 10)
};
}
const versions = (versionString || "").split(".").map((n2) => parseInt(n2, 10));
return {
major: versions[0],
minor: versions[1],
patch: versions[2]
};
}
function supportsHyperlink(stream) {
const { env } = process;
if ("FORCE_HYPERLINK" in env) {
return !(env.FORCE_HYPERLINK.length > 0 && parseInt(env.FORCE_HYPERLINK, 10) === 0);
}
if (hasFlag("no-hyperlink") || hasFlag("no-hyperlinks") || hasFlag("hyperlink=false") || hasFlag("hyperlink=never")) {
return false;
}
if (hasFlag("hyperlink=true") || hasFlag("hyperlink=always")) {
return true;
}
if ("NETLIFY" in env) {
return true;
}
if (!supportsColor.supportsColor(stream)) {
return false;
}
if (stream && !stream.isTTY) {
return false;
}
if (process.platform === "win32") {
return false;
}
if ("CI" in env) {
return false;
}
if ("TEAMCITY_VERSION" in env) {
return false;
}
if ("TERM_PROGRAM" in env) {
const version = parseVersion(env.TERM_PROGRAM_VERSION);
switch (env.TERM_PROGRAM) {
case "iTerm.app":
if (version.major === 3) {
return version.minor >= 1;
}
return version.major > 3;
case "WezTerm":
return version.major >= 20200620;
case "vscode":
return version.major > 1 || version.major === 1 && version.minor >= 72;
}
}
if ("VTE_VERSION" in env) {
if (env.VTE_VERSION === "0.50.0") {
return false;
}
const version = parseVersion(env.VTE_VERSION);
return version.major > 0 || version.minor >= 50;
}
return false;
}
module2.exports = {
supportsHyperlink,
stdout: supportsHyperlink(process.stdout),
stderr: supportsHyperlink(process.stderr)
};
}
});
// ../../node_modules/.pnpm/terminal-link@2.1.1/node_modules/terminal-link/index.js
var require_terminal_link = __commonJS({
"../../node_modules/.pnpm/terminal-link@2.1.1/node_modules/terminal-link/index.js"(exports, module2) {
"use strict";
var ansiEscapes = require_ansi_escapes();
var supportsHyperlinks = require_supports_hyperlinks();
var terminalLink2 = (text, url, { target = "stdout", ...options2 } = {}) => {
if (!supportsHyperlinks[target]) {
if (options2.fallback === false) {
return text;
}
return typeof options2.fallback === "function" ? options2.fallback(text, url) : `${text} (\u200B${url}\u200B)`;
}
return ansiEscapes.link(text, url);
};
module2.exports = (text, url, options2 = {}) => terminalLink2(text, url, options2);
module2.exports.stderr = (text, url, options2 = {}) => terminalLink2(text, url, { target: "stderr", ...options2 });
module2.exports.isSupported = supportsHyperlinks.stdout;
module2.exports.stderr.isSupported = supportsHyperlinks.stderr;
}
});
// ../../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"(exports, module2) {
module2.exports = isexe;
isexe.sync = sync;
var fs10 = require("fs");
function checkPathExt(path7, options2) {
var pathext = options2.pathExt !== void 0 ? options2.pathExt : process.env.PATHEXT;
if (!pathext) {
return true;
}
pathext = pathext.split(";");
if (pathext.indexOf("") !== -1) {
return true;
}
for (var i = 0; i < pathext.length; i++) {
var p2 = pathext[i].toLowerCase();
if (p2 && path7.substr(-p2.length).toLowerCase() === p2) {
return true;
}
}
return false;
}
function checkStat(stat, path7, options2) {
if (!stat.isSymbolicLink() && !stat.isFile()) {
return false;
}
return checkPathExt(path7, options2);
}
function isexe(path7, options2, cb) {
fs10.stat(path7, function(er, stat) {
cb(er, er ? false : checkStat(stat, path7, options2));
});
}
function sync(path7, options2) {
return checkStat(fs10.statSync(path7), path7, options2);
}
}
});
// ../../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"(exports, module2) {
module2.exports = isexe;
isexe.sync = sync;
var fs10 = require("fs");
function isexe(path7, options2, cb) {
fs10.stat(path7, function(er, stat) {
cb(er, er ? false : checkStat(stat, options2));
});
}
function sync(path7, options2) {
return checkStat(fs10.statSync(path7), options2);
}
function checkStat(stat, options2) {
return stat.isFile() && checkMode(stat, options2);
}
function checkMode(stat, options2) {
var mod = stat.mode;
var uid = stat.uid;
var gid = stat.gid;
var myUid = options2.uid !== void 0 ? options2.uid : process.getuid && process.getuid();
var myGid = options2.gid !== void 0 ? options2.gid : process.getgid && process.getgid();
var u2 = parseInt("100", 8);
var g2 = parseInt("010", 8);
var o = parseInt("001", 8);
var ug = u2 | g2;
var ret = mod & o || mod & g2 && 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"(exports, module2) {
var fs10 = require("fs");
var core;
if (process.platform === "win32" || global.TESTING_WINDOWS) {
core = require_windows();
} else {
core = require_mode();
}
module2.exports = isexe;
isexe.sync = sync;
function isexe(path7, options2, cb) {
if (typeof options2 === "function") {
cb = options2;
options2 = {};
}
if (!cb) {
if (typeof Promise !== "function") {
throw new TypeError("callback not provided");
}
return new Promise(function(resolve, reject) {
isexe(path7, options2 || {}, function(er, is) {
if (er) {
reject(er);
} else {
resolve(is);
}
});
});
}
core(path7, options2 || {}, function(er, is) {
if (er) {
if (er.code === "EACCES" || options2 && options2.ignoreErrors) {
er = null;
is = false;
}
}
cb(er, is);
});
}
function sync(path7, options2) {
try {
return core.sync(path7, options2 || {});
} catch (er) {
if (options2 && options2.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"(exports, module2) {
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(/\\/) ? [""] : [
...isWindows ? [process.cwd()] : [],
...(opt.path || process.env.PATH || "").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 = (i) => new Promise((resolve, reject) => {
if (i === pathEnv.length)
return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
const ppRaw = pathEnv[i];
const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
const pCmd = path7.join(pathPart, cmd);
const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
resolve(subStep(p2, i, 0));
});
const subStep = (p2, i, ii) => new Promise((resolve, reject) => {
if (ii === pathExt.length)
return resolve(step(i + 1));
const ext = pathExt[ii];
isexe(p2 + ext, { pathExt: pathExtExe }, (er, is) => {
if (!er && is) {
if (opt.all)
found.push(p2 + ext);
else
return resolve(p2 + ext);
}
return resolve(subStep(p2, i, 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 i = 0; i < pathEnv.length; i++) {
const ppRaw = pathEnv[i];
const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
const pCmd = path7.join(pathPart, cmd);
const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
for (let j = 0; j < pathExt.length; j++) {
const cur = p2 + 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"(exports, module2) {
"use strict";
var pathKey = (options2 = {}) => {
const environment = options2.env || process.env;
const platform2 = options2.platform || process.platform;
if (platform2 !== "win32") {
return "PATH";
}
return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
};
module2.exports = pathKey;
module2.exports.default = pathKey;
}
});
// ../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/resolveCommand.js
var require_resolveCommand = __commonJS({
"../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, 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 (e2) {
} 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.3/node_modules/cross-spawn/lib/util/escape.js
var require_escape = __commonJS({
"../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/escape.js"(exports, 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(/(\\*)"/g, '$1$1\\"');
arg = arg.replace(/(\\*)$/, "$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"(exports, 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"(exports, 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.3/node_modules/cross-spawn/lib/util/readShebang.js
var require_readShebang = __commonJS({
"../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module2) {
"use strict";
var fs10 = require("fs");
var shebangCommand = require_shebang_command();
function readShebang(command) {
const size = 150;
const buffer = Buffer.alloc(size);
let fd;
try {
fd = fs10.openSync(command, "r");
fs10.readSync(fd, buffer, 0, size, 0);
fs10.closeSync(fd);
} catch (e2) {
}
return shebangCommand(buffer.toString());
}
module2.exports = readShebang;
}
});
// ../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/parse.js
var require_parse = __commonJS({
"../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/parse.js"(exports, module2) {
"use strict";
var path7 = require("path");
var resolveCommand = require_resolveCommand();
var escape = require_escape();
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 parse(command, args, options2) {
if (args && !Array.isArray(args)) {
options2 = args;
args = null;
}
args = args ? args.slice(0) : [];
options2 = Object.assign({}, options2);
const parsed = {
command,
args,
options: options2,
file: void 0,
original: {
command,
args
}
};
return options2.shell ? parsed : parseNonShell(parsed);
}
module2.exports = parse;
}
});
// ../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/enoent.js
var require_enoent = __commonJS({
"../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/enoent.js"(exports, 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(cp2, parsed) {
if (!isWin) {
return;
}
const originalEmit = cp2.emit;
cp2.emit = function(name, arg1) {
if (name === "exit") {
const err = verifyENOENT(arg1, parsed, "spawn");
if (err) {
return originalEmit.call(cp2, "error", err);
}
}
return originalEmit.apply(cp2, 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.3/node_modules/cross-spawn/index.js
var require_cross_spawn = __commonJS({
"../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/index.js"(exports, module2) {
"use strict";
var cp2 = require("child_process");
var parse = require_parse();
var enoent = require_enoent();
function spawn(command, args, options2) {
const parsed = parse(command, args, options2);
const spawned = cp2.spawn(parsed.command, parsed.args, parsed.options);
enoent.hookChildProcess(spawned, parsed);
return spawned;
}
function spawnSync(command, args, options2) {
const parsed = parse(command, args, options2);
const result = cp2.spawnSync(parsed.command, parsed.args, parsed.options);
result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
return result;
}
module2.exports = spawn;
module2.exports.spawn = spawn;
module2.exports.sync = spawnSync;
module2.exports._parse = parse;
module2.exports._enoent = enoent;
}
});
// ../../node_modules/.pnpm/strip-final-newline@2.0.0/node_modules/strip-final-newline/index.js
var require_strip_final_newline = __commonJS({
"../../node_modules/.pnpm/strip-final-newline@2.0.0/node_modules/strip-final-newline/index.js"(exports, module2) {
"use strict";
module2.exports = (input) => {
const LF = typeof input === "string" ? "\n" : "\n".charCodeAt();
const CR = typeof input === "string" ? "\r" : "\r".charCodeAt();
if (input[input.length - 1] === LF) {
input = input.slice(0, input.length - 1);
}
if (input[input.length - 1] === CR) {
input = input.slice(0, input.length - 1);
}
return input;
};
}
});
// ../../node_modules/.pnpm/npm-run-path@4.0.1/node_modules/npm-run-path/index.js
var require_npm_run_path = __commonJS({
"../../node_modules/.pnpm/npm-run-path@4.0.1/node_modules/npm-run-path/index.js"(exports, module2) {
"use strict";
var path7 = require("path");
var pathKey = require_path_key();
var npmRunPath = (options2) => {
options2 = {
cwd: process.cwd(),
path: process.env[pathKey()],
execPath: process.execPath,
...options2
};
let previous;
let cwdPath = path7.resolve(options2.cwd);
const result = [];
while (previous !== cwdPath) {
result.push(path7.join(cwdPath, "node_modules/.bin"));
previous = cwdPath;
cwdPath = path7.resolve(cwdPath, "..");
}
const execPathDir = path7.resolve(options2.cwd, options2.execPath, "..");
result.push(execPathDir);
return result.concat(options2.path).join(path7.delimiter);
};
module2.exports = npmRunPath;
module2.exports.default = npmRunPath;
module2.exports.env = (options2) => {
options2 = {
env: process.env,
...options2
};
const env = { ...options2.env };
const path8 = pathKey({ env });
options2.path = env[path8];
env[path8] = module2.exports(options2);
return env;
};
}
});
// ../../node_modules/.pnpm/mimic-fn@2.1.0/node_modules/mimic-fn/index.js
var require_mimic_fn = __commonJS({
"../../node_modules/.pnpm/mimic-fn@2.1.0/node_modules/mimic-fn/index.js"(exports, module2) {
"use strict";
var mimicFn = (to, from) => {
for (const prop of Reflect.ownKeys(from)) {
Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
}
return to;
};
module2.exports = mimicFn;
module2.exports.default = mimicFn;
}
});
// ../../node_modules/.pnpm/onetime@5.1.2/node_modules/onetime/index.js
var require_onetime = __commonJS({
"../../node_modules/.pnpm/onetime@5.1.2/node_modules/onetime/index.js"(exports, module2) {
"use strict";
var mimicFn = require_mimic_fn();
var calledFunctions = /* @__PURE__ */ new WeakMap();
var onetime = (function_, options2 = {}) => {
if (typeof function_ !== "function") {
throw new TypeError("Expected a function");
}
let returnValue;
let callCount = 0;
const functionName = function_.displayName || function_.name || "<anonymous>";
const onetime2 = function(...arguments_) {
calledFunctions.set(onetime2, ++callCount);
if (callCount === 1) {
returnValue = function_.apply(this, arguments_);
function_ = null;
} else if (options2.throw === true) {
throw new Error(`Function \`${functionName}\` can only be called once`);
}
return returnValue;
};
mimicFn(onetime2, function_);
calledFunctions.set(onetime2, callCount);
return onetime2;
};
module2.exports = onetime;
module2.exports.default = onetime;
module2.exports.callCount = (function_) => {
if (!calledFunctions.has(function_)) {
throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
}
return calledFunctions.get(function_);
};
}
});
// ../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/core.js
var require_core = __commonJS({
"../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/core.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SIGNALS = void 0;
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"
}
];
exports.SIGNALS = SIGNALS;
}
});
// ../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/realtime.js
var require_realtime = __commonJS({
"../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/realtime.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SIGRTMAX = exports.getRealtimeSignals = void 0;
var getRealtimeSignals = function() {
const length = SIGRTMAX - SIGRTMIN + 1;
return Array.from({ length }, getRealtimeSignal);
};
exports.getRealtimeSignals = getRealtimeSignals;
var getRealtimeSignal = function(value, index) {
return {
name: `SIGRT${index + 1}`,
number: SIGRTMIN + index,
action: "terminate",
description: "Application-specific signal (realtime)",
standard: "posix"
};
};
var SIGRTMIN = 34;
var SIGRTMAX = 64;
exports.SIGRTMAX = SIGRTMAX;
}
});
// ../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/signals.js
var require_signals = __commonJS({
"../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/signals.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getSignals = void 0;
var _os = require("os");
var _core = require_core();
var _realtime = require_realtime();
var getSignals = function() {
const realtimeSignals = (0, _realtime.getRealtimeSignals)();
const signals = [..._core.SIGNALS, ...realtimeSignals].map(normalizeSignal);
return signals;
};
exports.getSignals = getSignals;
var normalizeSignal = function({
name,
number: defaultNumber,
description,
action,
forced = false,
standard
}) {
const {
signals: { [name]: constantSignal }
} = _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@2.1.0/node_modules/human-signals/build/src/main.js
var require_main = __commonJS({
"../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/main.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.signalsByNumber = exports.signalsByName = void 0;
var _os = require("os");
var _signals = require_signals();
var _realtime = require_realtime();
var getSignalsByName = function() {
const signals = (0, _signals.getSignals)();
return signals.reduce(getSignalByName, {});
};
var getSignalByName = function(signalByNameMemo, { name, number, description, supported, action, forced, standard }) {
return {
...signalByNameMemo,
[name]: { name, number, description, supported, action, forced, standard }
};
};
var signalsByName = getSignalsByName();
exports.signalsByName = signalsByName;
var getSignalsByNumber = function() {
const signals = (0, _signals.getSignals)();
const length = _realtime.SIGRTMAX + 1;
const signalsA = Array.from({ length }, (value, number) => getSignalByNumber(number, signals));
return Object.assign({}, ...signalsA);
};
var getSignalByNumber = function(number, signals) {
const signal = findSignalByNumber(number, signals);
if (signal === void 0) {
return {};
}
const { name, description, supported, action, forced, standard } = signal;
return {
[number]: {
name,
number,
description,
supported,
action,
forced,
standard
}
};
};
var findSignalByNumber = function(number, signals) {
const signal = signals.find(({ name }) => _os.constants.signals[name] === number);
if (signal !== void 0) {
return signal;
}
return signals.find((signalA) => signalA.number === number);
};
var signalsByNumber = getSignalsByNumber();
exports.signalsByNumber = signalsByNumber;
}
});
// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/error.js
var require_error = __commonJS({
"../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/error.js"(exports, module2) {
"use strict";
var { signalsByName } = require_main();
var getErrorPrefix = ({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled }) => {
if (timedOut) {
return `timed out after ${timeout} milliseconds`;
}
if (isCanceled) {
return "was canceled";
}
if (errorCode !== void 0) {
return `failed with ${errorCode}`;
}
if (signal !== void 0) {
return `was killed with ${signal} (${signalDescription})`;
}
if (exitCode !== void 0) {
return `failed with exit code ${exitCode}`;
}
return "failed";
};
var makeError = ({
stdout,
stderr,
all,
error,
signal,
exitCode,
command,
escapedCommand,
timedOut,
isCanceled,
killed,
parsed: { options: { timeout } }
}) => {
exitCode = exitCode === null ? void 0 : exitCode;
signal = signal === null ? void 0 : signal;
const signalDescription = signal === void 0 ? void 0 : signalsByName[signal].description;
const errorCode = error && error.code;
const prefix = getErrorPrefix({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled });
const execaMessage = `Command ${prefix}: ${command}`;
const isError = Object.prototype.toString.call(error) === "[object Error]";
const shortMessage = isError ? `${execaMessage}
${error.message}` : execaMessage;
const message = [shortMessage, stderr, stdout].filter(Boolean).join("\n");
if (isError) {
error.originalMessage = error.message;
error.message = message;
} else {
error = new Error(message);
}
error.shortMessage = shortMessage;
error.command = command;
error.escapedCommand = escapedCommand;
error.exitCode = exitCode;
error.signal = signal;
error.signalDescription = signalDescription;
error.stdout = stdout;
error.stderr = stderr;
if (all !== void 0) {
error.all = all;
}
if ("bufferedData" in error) {
delete error.bufferedData;
}
error.failed = true;
error.timedOut = Boolean(timedOut);
error.isCanceled = isCanceled;
error.killed = killed && !timedOut;
return error;
};
module2.exports = makeError;
}
});
// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stdio.js
var require_stdio = __commonJS({
"../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stdio.js"(exports, module2) {
"use strict";
var aliases = ["stdin", "stdout", "stderr"];
var hasAlias = (options2) => aliases.some((alias) => options2[alias] !== void 0);
var normalizeStdio = (options2) => {
if (!options2) {
return;
}
const { stdio } = options2;
if (stdio === void 0) {
return aliases.map((alias) => options2[alias]);
}
if (hasAlias(options2)) {
throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map((alias) => `\`${alias}\``).join(", ")}`);
}
if (typeof stdio === "string") {
return 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, aliases.length);
return Array.from({ length }, (value, index) => stdio[index]);
};
module2.exports = normalizeStdio;
module2.exports.node = (options2) => {
const stdio = normalizeStdio(options2);
if (stdio === "ipc") {
return "ipc";
}
if (stdio === void 0 || typeof stdio === "string") {
return [stdio, stdio, stdio, "ipc"];
}
if (stdio.includes("ipc")) {
return stdio;
}
return [...stdio, "ipc"];
};
}
});
// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js
var require_signals2 = __commonJS({
"../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js"(exports, module2) {
module2.exports = [
"SIGABRT",
"SIGALRM",
"SIGHUP",
"SIGINT",
"SIGTERM"
];
if (process.platform !== "win32") {
module2.exports.push(
"SIGVTALRM",
"SIGXCPU",
"SIGXFSZ",
"SIGUSR2",
"SIGTRAP",
"SIGSYS",
"SIGQUIT",
"SIGIOT"
);
}
if (process.platform === "linux") {
module2.exports.push(
"SIGIO",
"SIGPOLL",
"SIGPWR",
"SIGSTKFLT",
"SIGUNUSED"
);
}
}
});
// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js
var require_signal_exit = __commonJS({
"../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports, module2) {
var process2 = global.process;
var processOk = function(process3) {
return process3 && typeof process3 === "object" && typeof process3.removeListener === "function" && typeof process3.emit === "function" && typeof process3.reallyExit === "function" && typeof process3.listeners === "function" && typeof process3.kill === "function" && typeof process3.pid === "number" && typeof process3.on === "function";
};
if (!processOk(process2)) {
module2.exports = function() {
return function() {
};
};
} else {
assert = require("assert");
signals = require_signals2();
isWin = /^win/i.test(process2.platform);
EE = require("events");
if (typeof EE !== "function") {
EE = EE.EventEmitter;
}
if (process2.__signal_exit_emitter__) {
emitter = process2.__signal_exit_emitter__;
} else {
emitter = process2.__signal_exit_emitter__ = new EE();
emitter.count = 0;
emitter.emitted = {};
}
if (!emitter.infinite) {
emitter.setMaxListeners(Infinity);
emitter.infinite = true;
}
module2.exports = function(cb, opts2) {
if (!processOk(global.process)) {
return function() {
};
}
assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
if (loaded === false) {
load();
}
var ev = "exit";
if (opts2 && opts2.alwaysLast) {
ev = "afterexit";
}
var remove = function() {
emitter.removeListener(ev, cb);
if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
unload();
}
};
emitter.on(ev, cb);
return remove;
};
unload = function unload2() {
if (!loaded || !processOk(global.process)) {
return;
}
loaded = false;
signals.forEach(function(sig) {
try {
process2.removeListener(sig, sigListeners[sig]);
} catch (er) {
}
});
process2.emit = originalProcessEmit;
process2.reallyExit = originalProcessReallyExit;
emitter.count -= 1;
};
module2.exports.unload = unload;
emit = function emit2(event, code, signal) {
if (emitter.emitted[event]) {
return;
}
emitter.emitted[event] = true;
emitter.emit(event, code, signal);
};
sigListeners = {};
signals.forEach(function(sig) {
sigListeners[sig] = function listener() {
if (!processOk(global.process)) {
return;
}
var listeners = process2.listeners(sig);
if (listeners.length === emitter.count) {
unload();
emit("exit", null, sig);
emit("afterexit", null, sig);
if (isWin && sig === "SIGHUP") {
sig = "SIGINT";
}
process2.kill(process2.pid, sig);
}
};
});
module2.exports.signals = function() {
return signals;
};
loaded = false;
load = function load2() {
if (loaded || !processOk(global.process)) {
return;
}
loaded = true;
emitter.count += 1;
signals = signals.filter(function(sig) {
try {
process2.on(sig, sigListeners[sig]);
return true;
} catch (er) {
return false;
}
});
process2.emit = processEmit;
process2.reallyExit = processReallyExit;
};
module2.exports.load = load;
originalProcessReallyExit = process2.reallyExit;
processReallyExit = function processReallyExit2(code) {
if (!processOk(global.process)) {
return;
}
process2.exitCode = code || 0;
emit("exit", process2.exitCode, null);
emit("afterexit", process2.exitCode, null);
originalProcessReallyExit.call(process2, process2.exitCode);
};
originalProcessEmit = process2.emit;
processEmit = function processEmit2(ev, arg) {
if (ev === "exit" && processOk(global.process)) {
if (arg !== void 0) {
process2.exitCode = arg;
}
var ret = originalProcessEmit.apply(this, arguments);
emit("exit", process2.exitCode, null);
emit("afterexit", process2.exitCode, null);
return ret;
} else {
return originalProcessEmit.apply(this, arguments);
}
};
}
var assert;
var signals;
var isWin;
var EE;
var emitter;
var unload;
var emit;
var sigListeners;
var loaded;
var load;
var originalProcessReallyExit;
var processReallyExit;
var originalProcessEmit;
var processEmit;
}
});
// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/kill.js
var require_kill = __commonJS({
"../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/kill.js"(exports, module2) {
"use strict";
var os4 = require("os");
var onExit = require_signal_exit();
var DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
var spawnedKill = (kill, signal = "SIGTERM", options2 = {}) => {
const killResult = kill(signal);
setKillTimeout(kill, signal, options2, killResult);
return killResult;
};
var setKillTimeout = (kill, signal, options2, killResult) => {
if (!shouldForceKill(signal, options2, killResult)) {
return;
}
const timeout = getForceKillAfterTimeout(options2);
const t3 = setTimeout(() => {
kill("SIGKILL");
}, timeout);
if (t3.unref) {
t3.unref();
}
};
var shouldForceKill = (signal, { forceKillAfterTimeout }, killResult) => {
return isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
};
var isSigterm = (signal) => {
return signal === os4.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM";
};
var getForceKillAfterTimeout = ({ forceKillAfterTimeout = true }) => {
if (forceKillAfterTimeout === true) {
return DEFAULT_FORCE_KILL_TIMEOUT;
}
if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
}
return forceKillAfterTimeout;
};
var spawnedCancel = (spawned, context) => {
const killResult = spawned.kill();
if (killResult) {
context.isCanceled = true;
}
};
var timeoutKill = (spawned, signal, reject) => {
spawned.kill(signal);
reject(Object.assign(new Error("Timed out"), { timedOut: true, signal }));
};
var setupTimeout = (spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise) => {
if (timeout === 0 || timeout === void 0) {
return spawnedPromise;
}
let timeoutId;
const timeoutPromise = new Promise((resolve, reject) => {
timeoutId = setTimeout(() => {
timeoutKill(spawned, killSignal, reject);
}, timeout);
});
const safeSpawnedPromise = spawnedPromise.finally(() => {
clearTimeout(timeoutId);
});
return Promise.race([timeoutPromise, safeSpawnedPromise]);
};
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 setExitHandler = async (spawned, { cleanup, detached }, timedPromise) => {
if (!cleanup || detached) {
return timedPromise;
}
const removeExitHandler = onExit(() => {
spawned.kill();
});
return timedPromise.finally(() => {
removeExitHandler();
});
};
module2.exports = {
spawnedKill,
spawnedCancel,
setupTimeout,
validateTimeout,
setExitHandler
};
}
});
// ../../node_modules/.pnpm/is-stream@2.0.1/node_modules/is-stream/index.js
var require_is_stream = __commonJS({
"../../node_modules/.pnpm/is-stream@2.0.1/node_modules/is-stream/index.js"(exports, module2) {
"use strict";
var isStream = (stream) => stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
isStream.writable = (stream) => isStream(stream) && stream.writable !== false && typeof stream._write === "function" && typeof stream._writableState === "object";
isStream.readable = (stream) => isStream(stream) && stream.readable !== false && typeof stream._read === "function" && typeof stream._readableState === "object";
isStream.duplex = (stream) => isStream.writable(stream) && isStream.readable(stream);
isStream.transform = (stream) => isStream.duplex(stream) && typeof stream._transform === "function";
module2.exports = isStream;
}
});
// ../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/buffer-stream.js
var require_buffer_stream = __commonJS({
"../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/buffer-stream.js"(exports, module2) {
"use strict";
var { PassThrough: PassThroughStream } = require("stream");
module2.exports = (options2) => {
options2 = { ...options2 };
const { array } = options2;
let { encoding } = options2;
const isBuffer = encoding === "buffer";
let objectMode = false;
if (array) {
objectMode = !(encoding || isBuffer);
} else {
encoding = encoding || "utf8";
}
if (isBuffer) {
encoding = null;
}
const stream = new PassThroughStream({ objectMode });
if (encoding) {
stream.setEncoding(encoding);
}
let length = 0;
const chunks = [];
stream.on("data", (chunk) => {
chunks.push(chunk);
if (objectMode) {
length = chunks.length;
} else {
length += chunk.length;
}
});
stream.getBufferedValue = () => {
if (array) {
return chunks;
}
return isBuffer ? Buffer.concat(chunks, length) : chunks.join("");
};
stream.getBufferedLength = () => length;
return stream;
};
}
});
// ../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/index.js
var require_get_stream = __commonJS({
"../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/index.js"(exports, module2) {
"use strict";
var { constants: BufferConstants } = require("buffer");
var stream = require("stream");
var { promisify: promisify5 } = require("util");
var bufferStream = require_buffer_stream();
var streamPipelinePromisified = promisify5(stream.pipeline);
var MaxBufferError = class extends Error {
constructor() {
super("maxBuffer exceeded");
this.name = "MaxBufferError";
}
};
async function getStream(inputStream, options2) {
if (!inputStream) {
throw new Error("Expected a stream");
}
options2 = {
maxBuffer: Infinity,
...options2
};
const { maxBuffer } = options2;
const stream2 = bufferStream(options2);
await new Promise((resolve, reject) => {
const rejectPromise = (error) => {
if (error && stream2.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
error.bufferedData = stream2.getBufferedValue();
}
reject(error);
};
(async () => {
try {
await streamPipelinePromisified(inputStream, stream2);
resolve();
} catch (error) {
rejectPromise(error);
}
})();
stream2.on("data", () => {
if (stream2.getBufferedLength() > maxBuffer) {
rejectPromise(new MaxBufferError());
}
});
});
return stream2.getBufferedValue();
}
module2.exports = getStream;
module2.exports.buffer = (stream2, options2) => getStream(stream2, { ...options2, encoding: "buffer" });
module2.exports.array = (stream2, options2) => getStream(stream2, { ...options2, array: true });
module2.exports.MaxBufferError = MaxBufferError;
}
});
// ../../node_modules/.pnpm/merge-stream@2.0.0/node_modules/merge-stream/index.js
var require_merge_stream = __commonJS({
"../../node_modules/.pnpm/merge-stream@2.0.0/node_modules/merge-stream/index.js"(exports, module2) {
"use strict";
var { PassThrough: PassThrough2 } = require("stream");
module2.exports = function() {
var sources = [];
var output = new PassThrough2({ objectMode: true });
output.setMaxListeners(0);
output.add = add;
output.isEmpty = isEmpty;
output.on("unpipe", remove);
Array.prototype.slice.call(arguments).forEach(add);
return output;
function add(source) {
if (Array.isArray(source)) {
source.forEach(add);
return this;
}
sources.push(source);
source.once("end", remove.bind(null, source));
source.once("error", output.emit.bind(output, "error"));
source.pipe(output, { end: false });
return this;
}
function isEmpty() {
return sources.length == 0;
}
function remove(source) {
sources = sources.filter(function(it) {
return it !== source;
});
if (!sources.length && output.readable) {
output.end();
}
}
};
}
});
// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stream.js
var require_stream = __commonJS({
"../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stream.js"(exports, module2) {
"use strict";
var isStream = require_is_stream();
var getStream = require_get_stream();
var mergeStream = require_merge_stream();
var handleInput = (spawned, input) => {
if (input === void 0 || spawned.stdin === void 0) {
return;
}
if (isStream(input)) {
input.pipe(spawned.stdin);
} else {
spawned.stdin.end(input);
}
};
var makeAllStream = (spawned, { all }) => {
if (!all || !spawned.stdout && !spawned.stderr) {
return;
}
const mixed = mergeStream();
if (spawned.stdout) {
mixed.add(spawned.stdout);
}
if (spawned.stderr) {
mixed.add(spawned.stderr);
}
return mixed;
};
var getBufferedData = async (stream, streamPromise) => {
if (!stream) {
return;
}
stream.destroy();
try {
return await streamPromise;
} catch (error) {
return error.bufferedData;
}
};
var getStreamPromise = (stream, { encoding, buffer, maxBuffer }) => {
if (!stream || !buffer) {
return;
}
if (encoding) {
return getStream(stream, { encoding, maxBuffer });
}
return getStream.buffer(stream, { maxBuffer });
};
var getSpawnedResult = async ({ stdout, stderr, all }, { encoding, buffer, maxBuffer }, processDone) => {
const stdoutPromise = getStreamPromise(stdout, { encoding, buffer, maxBuffer });
const stderrPromise = getStreamPromise(stderr, { encoding, buffer, maxBuffer });
const allPromise = getStreamPromise(all, { encoding, buffer, maxBuffer: maxBuffer * 2 });
try {
return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
} catch (error) {
return Promise.all([
{ error, signal: error.signal, timedOut: error.timedOut },
getBufferedData(stdout, stdoutPromise),
getBufferedData(stderr, stderrPromise),
getBufferedData(all, allPromise)
]);
}
};
var validateInputSync = ({ input }) => {
if (isStream(input)) {
throw new TypeError("The `input` option cannot be a stream in sync mode");
}
};
module2.exports = {
handleInput,
makeAllStream,
getSpawnedResult,
validateInputSync
};
}
});
// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/promise.js
var require_promise = __commonJS({
"../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/promise.js"(exports, module2) {
"use strict";
var nativePromisePrototype = (async () => {
})().constructor.prototype;
var descriptors = ["then", "catch", "finally"].map((property) => [
property,
Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)
]);
var mergePromise = (spawned, promise) => {
for (const [property, descriptor] of descriptors) {
const value = typeof promise === "function" ? (...args) => Reflect.apply(descriptor.value, promise(), args) : descriptor.value.bind(promise);
Reflect.defineProperty(spawned, property, { ...descriptor, value });
}
return spawned;
};
var getSpawnedPromise = (spawned) => {
return new Promise((resolve, reject) => {
spawned.on("exit", (exitCode, signal) => {
resolve({ exitCode, signal });
});
spawned.on("error", (error) => {
reject(error);
});
if (spawned.stdin) {
spawned.stdin.on("error", (error) => {
reject(error);
});
}
});
};
module2.exports = {
mergePromise,
getSpawnedPromise
};
}
});
// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/command.js
var require_command = __commonJS({
"../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/command.js"(exports, module2) {
"use strict";
var normalizeArgs = (file2, args = []) => {
if (!Array.isArray(args)) {
return [file2];
}
return [file2, ...args];
};
var NO_ESCAPE_REGEXP = /^[\w.-]+$/;
var DOUBLE_QUOTES_REGEXP = /"/g;
var escapeArg = (arg) => {
if (typeof arg !== "string" || NO_ESCAPE_REGEXP.test(arg)) {
return arg;
}
return `"${arg.replace(DOUBLE_QUOTES_REGEXP, '\\"')}"`;
};
var joinCommand = (file2, args) => {
return normalizeArgs(file2, args).join(" ");
};
var getEscapedCommand = (file2, args) => {
return normalizeArgs(file2, args).map((arg) => escapeArg(arg)).join(" ");
};
var SPACES_REGEXP = / +/g;
var parseCommand = (command) => {
const tokens = [];
for (const token of command.trim().split(SPACES_REGEXP)) {
const previousToken = tokens[tokens.length - 1];
if (previousToken && previousToken.endsWith("\\")) {
tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
} else {
tokens.push(token);
}
}
return tokens;
};
module2.exports = {
joinCommand,
getEscapedCommand,
parseCommand
};
}
});
// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/index.js
var require_execa = __commonJS({
"../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/index.js"(exports, module2) {
"use strict";
var path7 = require("path");
var childProcess = require("child_process");
var crossSpawn = require_cross_spawn();
var stripFinalNewline = require_strip_final_newline();
var npmRunPath = require_npm_run_path();
var onetime = require_onetime();
var makeError = require_error();
var normalizeStdio = require_stdio();
var { spawnedKill, spawnedCancel, setupTimeout, validateTimeout, setExitHandler } = require_kill();
var { handleInput, getSpawnedResult, makeAllStream, validateInputSync } = require_stream();
var { mergePromise, getSpawnedPromise } = require_promise();
var { joinCommand, parseCommand, getEscapedCommand } = require_command();
var DEFAULT_MAX_BUFFER = 1e3 * 1e3 * 100;
var getEnv = ({ env: envOption, extendEnv, preferLocal, localDir, execPath }) => {
const env = extendEnv ? { ...process.env, ...envOption } : envOption;
if (preferLocal) {
return npmRunPath.env({ env, cwd: localDir, execPath });
}
return env;
};
var handleArguments = (file2, args, options2 = {}) => {
const parsed = crossSpawn._parse(file2, args, options2);
file2 = parsed.command;
args = parsed.args;
options2 = parsed.options;
options2 = {
maxBuffer: DEFAULT_MAX_BUFFER,
buffer: true,
stripFinalNewline: true,
extendEnv: true,
preferLocal: false,
localDir: options2.cwd || process.cwd(),
execPath: process.execPath,
encoding: "utf8",
reject: true,
cleanup: true,
all: false,
windowsHide: true,
...options2
};
options2.env = getEnv(options2);
options2.stdio = normalizeStdio(options2);
if (process.platform === "win32" && path7.basename(file2, ".exe") === "cmd") {
args.unshift("/q");
}
return { file: file2, args, options: options2, parsed };
};
var handleOutput = (options2, value, error) => {
if (typeof value !== "string" && !Buffer.isBuffer(value)) {
return error === void 0 ? void 0 : "";
}
if (options2.stripFinalNewline) {
return stripFinalNewline(value);
}
return value;
};
var execa2 = (file2, args, options2) => {
const parsed = handleArguments(file2, args, options2);
const command = joinCommand(file2, args);
const escapedCommand = getEscapedCommand(file2, args);
validateTimeout(parsed.options);
let spawned;
try {
spawned = childProcess.spawn(parsed.file, parsed.args, parsed.options);
} catch (error) {
const dummySpawned = new childProcess.ChildProcess();
const errorPromise = Promise.reject(makeError({
error,
stdout: "",
stderr: "",
all: "",
command,
escapedCommand,
parsed,
timedOut: false,
isCanceled: false,
killed: false
}));
return mergePromise(dummySpawned, errorPromise);
}
const spawnedPromise = getSpawnedPromise(spawned);
const timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);
const processDone = setExitHandler(spawned, parsed.options, timedPromise);
const context = { isCanceled: false };
spawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));
spawned.cancel = spawnedCancel.bind(null, spawned, context);
const handlePromise = async () => {
const [{ error, exitCode, signal, timedOut }, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);
const stdout = handleOutput(parsed.options, stdoutResult);
const stderr = handleOutput(parsed.options, stderrResult);
const all = handleOutput(parsed.options, allResult);
if (error || exitCode !== 0 || signal !== null) {
const returnedError = makeError({
error,
exitCode,
signal,
stdout,
stderr,
all,
command,
escapedCommand,
parsed,
timedOut,
isCanceled: context.isCanceled,
killed: spawned.killed
});
if (!parsed.options.reject) {
return returnedError;
}
throw returnedError;
}
return {
command,
escapedCommand,
exitCode: 0,
stdout,
stderr,
all,
failed: false,
timedOut: false,
isCanceled: false,
killed: false
};
};
const handlePromiseOnce = onetime(handlePromise);
handleInput(spawned, parsed.options.input);
spawned.all = makeAllStream(spawned, parsed.options);
return mergePromise(spawned, handlePromiseOnce);
};
module2.exports = execa2;
module2.exports.sync = (file2, args, options2) => {
const parsed = handleArguments(file2, args, options2);
const command = joinCommand(file2, args);
const escapedCommand = getEscapedCommand(file2, args);
validateInputSync(parsed.options);
let result;
try {
result = childProcess.spawnSync(parsed.file, parsed.args, parsed.options);
} catch (error) {
throw makeError({
error,
stdout: "",
stderr: "",
all: "",
command,
escapedCommand,
parsed,
timedOut: false,
isCanceled: false,
killed: false
});
}
const stdout = handleOutput(parsed.options, result.stdout, result.error);
const stderr = handleOutput(parsed.options, result.stderr, result.error);
if (result.error || result.status !== 0 || result.signal !== null) {
const error = makeError({
stdout,
stderr,
error: result.error,
signal: result.signal,
exitCode: result.status,
command,
escapedCommand,
parsed,
timedOut: result.error && result.error.code === "ETIMEDOUT",
isCanceled: false,
killed: result.signal !== null
});
if (!parsed.options.reject) {
return error;
}
throw error;
}
return {
command,
escapedCommand,
exitCode: 0,
stdout,
stderr,
failed: false,
timedOut: false,
isCanceled: false,
killed: false
};
};
module2.exports.command = (command, options2) => {
const [file2, ...args] = parseCommand(command);
return execa2(file2, args, options2);
};
module2.exports.commandSync = (command, options2) => {
const [file2, ...args] = parseCommand(command);
return execa2.sync(file2, args, options2);
};
module2.exports.node = (scriptPath, args, options2 = {}) => {
if (args && !Array.isArray(args) && typeof args === "object") {
options2 = args;
args = [];
}
const stdio = normalizeStdio.node(options2);
const defaultExecArgv = process.execArgv.filter((arg) => !arg.startsWith("--inspect"));
const {
nodePath = process.execPath,
nodeOptions = defaultExecArgv
} = options2;
return execa2(
nodePath,
[
...nodeOptions,
scriptPath,
...Array.isArray(args) ? args : []
],
{
...options2,
stdin: void 0,
stdout: void 0,
stderr: void 0,
stdio,
shell: false
}
);
};
}
});
// ../../node_modules/.pnpm/crypto-random-string@2.0.0/node_modules/crypto-random-string/index.js
var require_crypto_random_string = __commonJS({
"../../node_modules/.pnpm/crypto-random-string@2.0.0/node_modules/crypto-random-string/index.js"(exports, module2) {
"use strict";
var crypto2 = require("crypto");
module2.exports = (length) => {
if (!Number.isFinite(length)) {
throw new TypeError("Expected a finite number");
}
return crypto2.randomBytes(Math.ceil(length / 2)).toString("hex").slice(0, length);
};
}
});
// ../../node_modules/.pnpm/unique-string@2.0.0/node_modules/unique-string/index.js
var require_unique_string = __commonJS({
"../../node_modules/.pnpm/unique-string@2.0.0/node_modules/unique-string/index.js"(exports, module2) {
"use strict";
var cryptoRandomString = require_crypto_random_string();
module2.exports = () => cryptoRandomString(32);
}
});
// ../../node_modules/.pnpm/temp-dir@2.0.0/node_modules/temp-dir/index.js
var require_temp_dir = __commonJS({
"../../node_modules/.pnpm/temp-dir@2.0.0/node_modules/temp-dir/index.js"(exports, module2) {
"use strict";
var fs10 = require("fs");
var os4 = require("os");
var tempDirectorySymbol = Symbol.for("__RESOLVED_TEMP_DIRECTORY__");
if (!global[tempDirectorySymbol]) {
Object.defineProperty(global, tempDirectorySymbol, {
value: fs10.realpathSync(os4.tmpdir())
});
}
module2.exports = global[tempDirectorySymbol];
}
});
// ../../node_modules/.pnpm/array-union@2.1.0/node_modules/array-union/index.js
var require_array_union = __commonJS({
"../../node_modules/.pnpm/array-union@2.1.0/node_modules/array-union/index.js"(exports, module2) {
"use strict";
module2.exports = (...arguments_) => {
return [...new Set([].concat(...arguments_))];
};
}
});
// ../../node_modules/.pnpm/merge2@1.4.1/node_modules/merge2/index.js
var require_merge2 = __commonJS({
"../../node_modules/.pnpm/merge2@1.4.1/node_modules/merge2/index.js"(exports, module2) {
"use strict";
var Stream2 = require("stream");
var PassThrough2 = Stream2.PassThrough;
var slice = Array.prototype.slice;
module2.exports = merge2;
function merge2() {
const streamsQueue = [];
const args = slice.call(arguments);
let merging = false;
let options2 = args[args.length - 1];
if (options2 && !Array.isArray(options2) && options2.pipe == null) {
args.pop();
} else {
options2 = {};
}
const doEnd = options2.end !== false;
const doPipeError = options2.pipeError === true;
if (options2.objectMode == null) {
options2.objectMode = true;
}
if (options2.highWaterMark == null) {
options2.highWaterMark = 64 * 1024;
}
const mergedStream = PassThrough2(options2);
function addStream() {
for (let i = 0, len = arguments.length; i < len; i++) {
streamsQueue.push(pauseStreams(arguments[i], options2));
}
mergeStream();
return this;
}
function mergeStream() {
if (merging) {
return;
}
merging = true;
let streams = streamsQueue.shift();
if (!streams) {
process.nextTick(endStream);
return;
}
if (!Array.isArray(streams)) {
streams = [streams];
}
let pipesCount = streams.length + 1;
function next() {
if (--pipesCount > 0) {
return;
}
merging = false;
mergeStream();
}
function pipe(stream) {
function onend() {
stream.removeListener("merge2UnpipeEnd", onend);
stream.removeListener("end", onend);
if (doPipeError) {
stream.removeListener("error", onerror);
}
next();
}
function onerror(err) {
mergedStream.emit("error", err);
}
if (stream._readableState.endEmitted) {
return next();
}
stream.on("merge2UnpipeEnd", onend);
stream.on("end", onend);
if (doPipeError) {
stream.on("error", onerror);
}
stream.pipe(mergedStream, { end: false });
stream.resume();
}
for (let i = 0; i < streams.length; i++) {
pipe(streams[i]);
}
next();
}
function endStream() {
merging = false;
mergedStream.emit("queueDrain");
if (doEnd) {
mergedStream.end();
}
}
mergedStream.setMaxListeners(0);
mergedStream.add = addStream;
mergedStream.on("unpipe", function(stream) {
stream.emit("merge2UnpipeEnd");
});
if (args.length) {
addStream.apply(null, args);
}
return mergedStream;
}
function pauseStreams(streams, options2) {
if (!Array.isArray(streams)) {
if (!streams._readableState && streams.pipe) {
streams = streams.pipe(PassThrough2(options2));
}
if (!streams._readableState || !streams.pause || !streams.pipe) {
throw new Error("Only readable stream can be merged.");
}
streams.pause();
} else {
for (let i = 0, len = streams.length; i < len; i++) {
streams[i] = pauseStreams(streams[i], options2);
}
}
return streams;
}
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/array.js
var require_array = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/array.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.splitWhen = exports.flatten = void 0;
function flatten(items) {
return items.reduce((collection, item) => [].concat(collection, item), []);
}
exports.flatten = flatten;
function splitWhen(items, predicate) {
const result = [[]];
let groupIndex = 0;
for (const item of items) {
if (predicate(item)) {
groupIndex++;
result[groupIndex] = [];
} else {
result[groupIndex].push(item);
}
}
return result;
}
exports.splitWhen = splitWhen;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/errno.js
var require_errno = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/errno.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.isEnoentCodeError = void 0;
function isEnoentCodeError(error) {
return error.code === "ENOENT";
}
exports.isEnoentCodeError = isEnoentCodeError;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/fs.js
var require_fs = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/fs.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createDirentFromStats = void 0;
var DirentFromStats = class {
constructor(name, stats) {
this.name = name;
this.isBlockDevice = stats.isBlockDevice.bind(stats);
this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
this.isDirectory = stats.isDirectory.bind(stats);
this.isFIFO = stats.isFIFO.bind(stats);
this.isFile = stats.isFile.bind(stats);
this.isSocket = stats.isSocket.bind(stats);
this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
}
};
function createDirentFromStats(name, stats) {
return new DirentFromStats(name, stats);
}
exports.createDirentFromStats = createDirentFromStats;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/path.js
var require_path = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/path.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.convertPosixPathToPattern = exports.convertWindowsPathToPattern = exports.convertPathToPattern = exports.escapePosixPath = exports.escapeWindowsPath = exports.escape = exports.removeLeadingDotSegment = exports.makeAbsolute = exports.unixify = void 0;
var os4 = require("os");
var path7 = require("path");
var IS_WINDOWS_PLATFORM = os4.platform() === "win32";
var LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2;
var POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
var WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([(){}]|^!|[!+@](?=\())/g;
var DOS_DEVICE_PATH_RE = /^\\\\([.?])/;
var WINDOWS_BACKSLASHES_RE = /\\(?![!()+@{}])/g;
function unixify(filepath) {
return filepath.replace(/\\/g, "/");
}
exports.unixify = unixify;
function makeAbsolute(cwd, filepath) {
return path7.resolve(cwd, filepath);
}
exports.makeAbsolute = makeAbsolute;
function removeLeadingDotSegment(entry) {
if (entry.charAt(0) === ".") {
const secondCharactery = entry.charAt(1);
if (secondCharactery === "/" || secondCharactery === "\\") {
return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
}
}
return entry;
}
exports.removeLeadingDotSegment = removeLeadingDotSegment;
exports.escape = IS_WINDOWS_PLATFORM ? escapeWindowsPath : escapePosixPath;
function escapeWindowsPath(pattern) {
return pattern.replace(WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE, "\\$2");
}
exports.escapeWindowsPath = escapeWindowsPath;
function escapePosixPath(pattern) {
return pattern.replace(POSIX_UNESCAPED_GLOB_SYMBOLS_RE, "\\$2");
}
exports.escapePosixPath = escapePosixPath;
exports.convertPathToPattern = IS_WINDOWS_PLATFORM ? convertWindowsPathToPattern : convertPosixPathToPattern;
function convertWindowsPathToPattern(filepath) {
return escapeWindowsPath(filepath).replace(DOS_DEVICE_PATH_RE, "//$1").replace(WINDOWS_BACKSLASHES_RE, "/");
}
exports.convertWindowsPathToPattern = convertWindowsPathToPattern;
function convertPosixPathToPattern(filepath) {
return escapePosixPath(filepath);
}
exports.convertPosixPathToPattern = convertPosixPathToPattern;
}
});
// ../../node_modules/.pnpm/is-extglob@2.1.1/node_modules/is-extglob/index.js
var require_is_extglob = __commonJS({
"../../node_modules/.pnpm/is-extglob@2.1.1/node_modules/is-extglob/index.js"(exports, module2) {
module2.exports = function isExtglob(str) {
if (typeof str !== "string" || str === "") {
return false;
}
var match;
while (match = /(\\).|([@?!+*]\(.*\))/g.exec(str)) {
if (match[2])
return true;
str = str.slice(match.index + match[0].length);
}
return false;
};
}
});
// ../../node_modules/.pnpm/is-glob@4.0.3/node_modules/is-glob/index.js
var require_is_glob = __commonJS({
"../../node_modules/.pnpm/is-glob@4.0.3/node_modules/is-glob/index.js"(exports, module2) {
var isExtglob = require_is_extglob();
var chars = { "{": "}", "(": ")", "[": "]" };
var strictCheck = function(str) {
if (str[0] === "!") {
return true;
}
var index = 0;
var pipeIndex = -2;
var closeSquareIndex = -2;
var closeCurlyIndex = -2;
var closeParenIndex = -2;
var backSlashIndex = -2;
while (index < str.length) {
if (str[index] === "*") {
return true;
}
if (str[index + 1] === "?" && /[\].+)]/.test(str[index])) {
return true;
}
if (closeSquareIndex !== -1 && str[index] === "[" && str[index + 1] !== "]") {
if (closeSquareIndex < index) {
closeSquareIndex = str.indexOf("]", index);
}
if (closeSquareIndex > index) {
if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
return true;
}
backSlashIndex = str.indexOf("\\", index);
if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
return true;
}
}
}
if (closeCurlyIndex !== -1 && str[index] === "{" && str[index + 1] !== "}") {
closeCurlyIndex = str.indexOf("}", index);
if (closeCurlyIndex > index) {
backSlashIndex = str.indexOf("\\", index);
if (backSlashIndex === -1 || backSlashIndex > closeCurlyIndex) {
return true;
}
}
}
if (closeParenIndex !== -1 && str[index] === "(" && str[index + 1] === "?" && /[:!=]/.test(str[index + 2]) && str[index + 3] !== ")") {
closeParenIndex = str.indexOf(")", index);
if (closeParenIndex > index) {
backSlashIndex = str.indexOf("\\", index);
if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
return true;
}
}
}
if (pipeIndex !== -1 && str[index] === "(" && str[index + 1] !== "|") {
if (pipeIndex < index) {
pipeIndex = str.indexOf("|", index);
}
if (pipeIndex !== -1 && str[pipeIndex + 1] !== ")") {
closeParenIndex = str.indexOf(")", pipeIndex);
if (closeParenIndex > pipeIndex) {
backSlashIndex = str.indexOf("\\", pipeIndex);
if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
return true;
}
}
}
}
if (str[index] === "\\") {
var open = str[index + 1];
index += 2;
var close = chars[open];
if (close) {
var n2 = str.indexOf(close, index);
if (n2 !== -1) {
index = n2 + 1;
}
}
if (str[index] === "!") {
return true;
}
} else {
index++;
}
}
return false;
};
var relaxedCheck = function(str) {
if (str[0] === "!") {
return true;
}
var index = 0;
while (index < str.length) {
if (/[*?{}()[\]]/.test(str[index])) {
return true;
}
if (str[index] === "\\") {
var open = str[index + 1];
index += 2;
var close = chars[open];
if (close) {
var n2 = str.indexOf(close, index);
if (n2 !== -1) {
index = n2 + 1;
}
}
if (str[index] === "!") {
return true;
}
} else {
index++;
}
}
return false;
};
module2.exports = function isGlob(str, options2) {
if (typeof str !== "string" || str === "") {
return false;
}
if (isExtglob(str)) {
return true;
}
var check = strictCheck;
if (options2 && options2.strict === false) {
check = relaxedCheck;
}
return check(str);
};
}
});
// ../../node_modules/.pnpm/glob-parent@5.1.2/node_modules/glob-parent/index.js
var require_glob_parent = __commonJS({
"../../node_modules/.pnpm/glob-parent@5.1.2/node_modules/glob-parent/index.js"(exports, module2) {
"use strict";
var isGlob = require_is_glob();
var pathPosixDirname = require("path").posix.dirname;
var isWin32 = require("os").platform() === "win32";
var slash = "/";
var backslash = /\\/g;
var enclosure = /[\{\[].*[\}\]]$/;
var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
module2.exports = function globParent(str, opts2) {
var options2 = Object.assign({ flipBackslashes: true }, opts2);
if (options2.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
str = str.replace(backslash, slash);
}
if (enclosure.test(str)) {
str += slash;
}
str += "a";
do {
str = pathPosixDirname(str);
} while (isGlob(str) || globby.test(str));
return str.replace(escaped, "$1");
};
}
});
// ../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/utils.js
var require_utils = __commonJS({
"../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/utils.js"(exports) {
"use strict";
exports.isInteger = (num) => {
if (typeof num === "number") {
return Number.isInteger(num);
}
if (typeof num === "string" && num.trim() !== "") {
return Number.isInteger(Number(num));
}
return false;
};
exports.find = (node, type) => node.nodes.find((node2) => node2.type === type);
exports.exceedsLimit = (min, max, step = 1, limit) => {
if (limit === false)
return false;
if (!exports.isInteger(min) || !exports.isInteger(max))
return false;
return (Number(max) - Number(min)) / Number(step) >= limit;
};
exports.escapeNode = (block, n2 = 0, type) => {
let 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;
}
}
};
exports.encloseBrace = (node) => {
if (node.type !== "brace")
return false;
if (node.commas >> 0 + node.ranges >> 0 === 0) {
node.invalid = true;
return true;
}
return false;
};
exports.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;
};
exports.isOpenOrClose = (node) => {
if (node.type === "open" || node.type === "close") {
return true;
}
return node.open === true || node.close === true;
};
exports.reduce = (nodes) => nodes.reduce((acc, node) => {
if (node.type === "text")
acc.push(node.value);
if (node.type === "range")
node.type = "text";
return acc;
}, []);
exports.flatten = (...args) => {
const result = [];
const flat = (arr) => {
for (let i = 0; i < arr.length; i++) {
let ele = arr[i];
Array.isArray(ele) ? flat(ele, result) : ele !== void 0 && result.push(ele);
}
return result;
};
flat(args);
return result;
};
}
});
// ../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/stringify.js
var require_stringify = __commonJS({
"../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/stringify.js"(exports, module2) {
"use strict";
var utils = require_utils();
module2.exports = (ast, options2 = {}) => {
let stringify = (node, parent = {}) => {
let invalidBlock = options2.escapeInvalid && utils.isInvalidBrace(parent);
let invalidNode = node.invalid === true && options2.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 (let 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"(exports, 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"(exports, module2) {
"use strict";
var isNumber = require_is_number();
var toRegexRange = (min, max, options2) => {
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 opts2 = { relaxZeros: true, ...options2 };
if (typeof opts2.strictZeros === "boolean") {
opts2.relaxZeros = opts2.strictZeros === false;
}
let relax = String(opts2.relaxZeros);
let shorthand = String(opts2.shorthand);
let capture = String(opts2.capture);
let wrap = String(opts2.wrap);
let cacheKey = min + ":" + max + "=" + relax + shorthand + capture + wrap;
if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
return toRegexRange.cache[cacheKey].result;
}
let a = Math.min(min, max);
let b2 = Math.max(min, max);
if (Math.abs(a - b2) === 1) {
let result = min + "|" + max;
if (opts2.capture) {
return `(${result})`;
}
if (opts2.wrap === false) {
return result;
}
return `(?:${result})`;
}
let isPadded = hasPadding(min) || hasPadding(max);
let state = { min, max, a, b: b2 };
let positives = [];
let negatives = [];
if (isPadded) {
state.isPadded = isPadded;
state.maxLen = String(state.max).length;
}
if (a < 0) {
let newMin = b2 < 0 ? Math.abs(b2) : 1;
negatives = splitToPatterns(newMin, Math.abs(a), state, opts2);
a = state.a = 0;
}
if (b2 >= 0) {
positives = splitToPatterns(a, b2, state, opts2);
}
state.negatives = negatives;
state.positives = positives;
state.result = collatePatterns(negatives, positives, opts2);
if (opts2.capture === true) {
state.result = `(${state.result})`;
} else if (opts2.wrap !== false && positives.length + negatives.length > 1) {
state.result = `(?:${state.result})`;
}
toRegexRange.cache[cacheKey] = state;
return state.result;
};
function collatePatterns(neg, pos, options2) {
let onlyNegative = filterPatterns(neg, pos, "-", false, options2) || [];
let onlyPositive = filterPatterns(pos, neg, "", false, options2) || [];
let intersected = filterPatterns(neg, pos, "-?", true, options2) || [];
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, options2) {
if (start === stop) {
return { pattern: start, count: [], digits: 0 };
}
let zipped = zip(start, stop);
let digits = zipped.length;
let pattern = "";
let count = 0;
for (let i = 0; i < digits; i++) {
let [startDigit, stopDigit] = zipped[i];
if (startDigit === stopDigit) {
pattern += startDigit;
} else if (startDigit !== "0" || stopDigit !== "9") {
pattern += toCharacterClass(startDigit, stopDigit, options2);
} else {
count++;
}
}
if (count) {
pattern += options2.shorthand === true ? "\\d" : "[0-9]";
}
return { pattern, count: [count], digits };
}
function splitToPatterns(min, max, tok, options2) {
let ranges = splitToRanges(min, max);
let tokens = [];
let start = min;
let prev;
for (let i = 0; i < ranges.length; i++) {
let max2 = ranges[i];
let obj = rangeToPattern(String(start), String(max2), options2);
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, options2);
}
obj.string = zeros + obj.pattern + toQuantifier(obj.count);
tokens.push(obj);
start = max2 + 1;
prev = obj;
}
return tokens;
}
function filterPatterns(arr, comparison, prefix, intersection, options2) {
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(a, b2) {
let arr = [];
for (let i = 0; i < a.length; i++)
arr.push([a[i], b2[i]]);
return arr;
}
function compare(a, b2) {
return a > b2 ? 1 : b2 > a ? -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(a, b2, options2) {
return `[${a}${b2 - a === 1 ? "" : "-"}${b2}]`;
}
function hasPadding(str) {
return /^-?(0+)\d/.test(str);
}
function padZeros(value, tok, options2) {
if (!tok.isPadded) {
return value;
}
let diff = Math.abs(tok.maxLen - String(value).length);
let relax = options2.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.0.1/node_modules/fill-range/index.js
var require_fill_range = __commonJS({
"../../node_modules/.pnpm/fill-range@7.0.1/node_modules/fill-range/index.js"(exports, module2) {
"use strict";
var util = require("util");
var toRegexRange = require_to_regex_range();
var isObject = (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, options2) => {
if (typeof start === "string" || typeof end === "string") {
return true;
}
return options2.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, options2) => {
parts.negatives.sort((a, b2) => a < b2 ? -1 : a > b2 ? 1 : 0);
parts.positives.sort((a, b2) => a < b2 ? -1 : a > b2 ? 1 : 0);
let prefix = options2.capture ? "" : "?:";
let positives = "";
let negatives = "";
let result;
if (parts.positives.length) {
positives = parts.positives.join("|");
}
if (parts.negatives.length) {
negatives = `-(${prefix}${parts.negatives.join("|")})`;
}
if (positives && negatives) {
result = `${positives}|${negatives}`;
} else {
result = positives || negatives;
}
if (options2.wrap) {
return `(${prefix}${result})`;
}
return result;
};
var toRange = (a, b2, isNumbers, options2) => {
if (isNumbers) {
return toRegexRange(a, b2, { wrap: false, ...options2 });
}
let start = String.fromCharCode(a);
if (a === b2)
return start;
let stop = String.fromCharCode(b2);
return `[${start}-${stop}]`;
};
var toRegex = (start, end, options2) => {
if (Array.isArray(start)) {
let wrap = options2.wrap === true;
let prefix = options2.capture ? "" : "?:";
return wrap ? `(${prefix}${start.join("|")})` : start.join("|");
}
return toRegexRange(start, end, options2);
};
var rangeError = (...args) => {
return new RangeError("Invalid range arguments: " + util.inspect(...args));
};
var invalidRange = (start, end, options2) => {
if (options2.strictRanges === true)
throw rangeError([start, end]);
return [];
};
var invalidStep = (step, options2) => {
if (options2.strictRanges === true) {
throw new TypeError(`Expected step "${step}" to be a number`);
}
return [];
};
var fillNumbers = (start, end, step = 1, options2 = {}) => {
let a = Number(start);
let b2 = Number(end);
if (!Number.isInteger(a) || !Number.isInteger(b2)) {
if (options2.strictRanges === true)
throw rangeError([start, end]);
return [];
}
if (a === 0)
a = 0;
if (b2 === 0)
b2 = 0;
let descending = a > b2;
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, options2) === false;
let format = options2.transform || transform(toNumber);
if (options2.toRegex && step === 1) {
return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options2);
}
let parts = { negatives: [], positives: [] };
let push = (num) => parts[num < 0 ? "negatives" : "positives"].push(Math.abs(num));
let range = [];
let index = 0;
while (descending ? a >= b2 : a <= b2) {
if (options2.toRegex === true && step > 1) {
push(a);
} else {
range.push(pad(format(a, index), maxLen, toNumber));
}
a = descending ? a - step : a + step;
index++;
}
if (options2.toRegex === true) {
return step > 1 ? toSequence(parts, options2) : toRegex(range, null, { wrap: false, ...options2 });
}
return range;
};
var fillLetters = (start, end, step = 1, options2 = {}) => {
if (!isNumber(start) && start.length > 1 || !isNumber(end) && end.length > 1) {
return invalidRange(start, end, options2);
}
let format = options2.transform || ((val) => String.fromCharCode(val));
let a = `${start}`.charCodeAt(0);
let b2 = `${end}`.charCodeAt(0);
let descending = a > b2;
let min = Math.min(a, b2);
let max = Math.max(a, b2);
if (options2.toRegex && step === 1) {
return toRange(min, max, false, options2);
}
let range = [];
let index = 0;
while (descending ? a >= b2 : a <= b2) {
range.push(format(a, index));
a = descending ? a - step : a + step;
index++;
}
if (options2.toRegex === true) {
return toRegex(range, null, { wrap: false, options: options2 });
}
return range;
};
var fill = (start, end, step, options2 = {}) => {
if (end == null && isValidValue(start)) {
return [start];
}
if (!isValidValue(start) || !isValidValue(end)) {
return invalidRange(start, end, options2);
}
if (typeof step === "function") {
return fill(start, end, 1, { transform: step });
}
if (isObject(step)) {
return fill(start, end, 0, step);
}
let opts2 = { ...options2 };
if (opts2.capture === true)
opts2.wrap = true;
step = step || opts2.step || 1;
if (!isNumber(step)) {
if (step != null && !isObject(step))
return invalidStep(step, opts2);
return fill(start, end, 1, step);
}
if (isNumber(start) && isNumber(end)) {
return fillNumbers(start, end, step, opts2);
}
return fillLetters(start, end, Math.max(Math.abs(step), 1), opts2);
};
module2.exports = fill;
}
});
// ../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/compile.js
var require_compile = __commonJS({
"../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/compile.js"(exports, module2) {
"use strict";
var fill = require_fill_range();
var utils = require_utils();
var compile = (ast, options2 = {}) => {
let walk = (node, parent = {}) => {
let invalidBlock = utils.isInvalidBrace(parent);
let invalidNode = node.invalid === true && options2.escapeInvalid === true;
let invalid = invalidBlock === true || invalidNode === true;
let prefix = options2.escapeInvalid === true ? "\\" : "";
let output = "";
if (node.isOpen === true) {
return prefix + node.value;
}
if (node.isClose === true) {
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) {
let args = utils.reduce(node.nodes);
let range = fill(...args, { ...options2, wrap: false, toRegex: true });
if (range.length !== 0) {
return args.length > 1 && range.length > 1 ? `(${range})` : range;
}
}
if (node.nodes) {
for (let child of node.nodes) {
output += walk(child, node);
}
}
return output;
};
return walk(ast);
};
module2.exports = compile;
}
});
// ../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/expand.js
var require_expand = __commonJS({
"../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/expand.js"(exports, module2) {
"use strict";
var fill = require_fill_range();
var stringify = require_stringify();
var utils = require_utils();
var append = (queue = "", stash = "", enclose = false) => {
let 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 (let item of queue) {
if (Array.isArray(item)) {
for (let 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 expand = (ast, options2 = {}) => {
let rangeLimit = options2.rangeLimit === void 0 ? 1e3 : options2.rangeLimit;
let walk = (node, parent = {}) => {
node.queue = [];
let p2 = parent;
let q = parent.queue;
while (p2.type !== "brace" && p2.type !== "root" && p2.parent) {
p2 = p2.parent;
q = p2.queue;
}
if (node.invalid || node.dollar) {
q.push(append(q.pop(), stringify(node, options2)));
return;
}
if (node.type === "brace" && node.invalid !== true && node.nodes.length === 2) {
q.push(append(q.pop(), ["{}"]));
return;
}
if (node.nodes && node.ranges > 0) {
let args = utils.reduce(node.nodes);
if (utils.exceedsLimit(...args, options2.step, rangeLimit)) {
throw new RangeError("expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.");
}
let range = fill(...args, options2);
if (range.length === 0) {
range = stringify(node, options2);
}
q.push(append(q.pop(), range));
node.nodes = [];
return;
}
let 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 i = 0; i < node.nodes.length; i++) {
let child = node.nodes[i];
if (child.type === "comma" && node.type === "brace") {
if (i === 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 = expand;
}
});
// ../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/constants.js
var require_constants = __commonJS({
"../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/constants.js"(exports, module2) {
"use strict";
module2.exports = {
MAX_LENGTH: 1024 * 64,
CHAR_0: "0",
CHAR_9: "9",
CHAR_UPPERCASE_A: "A",
CHAR_LOWERCASE_A: "a",
CHAR_UPPERCASE_Z: "Z",
CHAR_LOWERCASE_Z: "z",
CHAR_LEFT_PARENTHESES: "(",
CHAR_RIGHT_PARENTHESES: ")",
CHAR_ASTERISK: "*",
CHAR_AMPERSAND: "&",
CHAR_AT: "@",
CHAR_BACKSLASH: "\\",
CHAR_BACKTICK: "`",
CHAR_CARRIAGE_RETURN: "\r",
CHAR_CIRCUMFLEX_ACCENT: "^",
CHAR_COLON: ":",
CHAR_COMMA: ",",
CHAR_DOLLAR: "$",
CHAR_DOT: ".",
CHAR_DOUBLE_QUOTE: '"',
CHAR_EQUAL: "=",
CHAR_EXCLAMATION_MARK: "!",
CHAR_FORM_FEED: "\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",
CHAR_NO_BREAK_SPACE: "\xA0",
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: " ",
CHAR_UNDERSCORE: "_",
CHAR_VERTICAL_LINE: "|",
CHAR_ZERO_WIDTH_NOBREAK_SPACE: "\uFEFF"
};
}
});
// ../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/parse.js
var require_parse2 = __commonJS({
"../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/parse.js"(exports, 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_constants();
var parse = (input, options2 = {}) => {
if (typeof input !== "string") {
throw new TypeError("Expected a string");
}
let opts2 = options2 || {};
let max = typeof opts2.maxLength === "number" ? Math.min(MAX_LENGTH, opts2.maxLength) : MAX_LENGTH;
if (input.length > max) {
throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
}
let ast = { type: "root", input, nodes: [] };
let stack = [ast];
let block = ast;
let prev = ast;
let brackets = 0;
let length = input.length;
let index = 0;
let depth = 0;
let value;
let memo = {};
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: (options2.keepEscaping ? value : "") + advance() });
continue;
}
if (value === CHAR_RIGHT_SQUARE_BRACKET) {
push({ type: "text", value: "\\" + value });
continue;
}
if (value === CHAR_LEFT_SQUARE_BRACKET) {
brackets++;
let closed = true;
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) {
let open = value;
let next;
if (options2.keepQuotes !== true) {
value = "";
}
while (index < length && (next = advance())) {
if (next === CHAR_BACKSLASH) {
value += next + advance();
continue;
}
if (next === open) {
if (options2.keepQuotes === true)
value += next;
break;
}
value += next;
}
push({ type: "text", value });
continue;
}
if (value === CHAR_LEFT_CURLY_BRACE) {
depth++;
let dollar = prev.value && prev.value.slice(-1) === "$" || block.dollar === true;
let 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;
}
let 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;
let 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) {
let 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();
let 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;
}
});
let parent = stack[stack.length - 1];
let index2 = parent.nodes.indexOf(block);
parent.nodes.splice(index2, 1, ...block.nodes);
}
} while (stack.length > 0);
push({ type: "eos" });
return ast;
};
module2.exports = parse;
}
});
// ../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/index.js
var require_braces = __commonJS({
"../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/index.js"(exports, module2) {
"use strict";
var stringify = require_stringify();
var compile = require_compile();
var expand = require_expand();
var parse = require_parse2();
var braces = (input, options2 = {}) => {
let output = [];
if (Array.isArray(input)) {
for (let pattern of input) {
let result = braces.create(pattern, options2);
if (Array.isArray(result)) {
output.push(...result);
} else {
output.push(result);
}
}
} else {
output = [].concat(braces.create(input, options2));
}
if (options2 && options2.expand === true && options2.nodupes === true) {
output = [...new Set(output)];
}
return output;
};
braces.parse = (input, options2 = {}) => parse(input, options2);
braces.stringify = (input, options2 = {}) => {
if (typeof input === "string") {
return stringify(braces.parse(input, options2), options2);
}
return stringify(input, options2);
};
braces.compile = (input, options2 = {}) => {
if (typeof input === "string") {
input = braces.parse(input, options2);
}
return compile(input, options2);
};
braces.expand = (input, options2 = {}) => {
if (typeof input === "string") {
input = braces.parse(input, options2);
}
let result = expand(input, options2);
if (options2.noempty === true) {
result = result.filter(Boolean);
}
if (options2.nodupes === true) {
result = [...new Set(result)];
}
return result;
};
braces.create = (input, options2 = {}) => {
if (input === "" || input.length < 3) {
return [input];
}
return options2.expand !== true ? braces.compile(input, options2) : braces.expand(input, options2);
};
module2.exports = braces;
}
});
// ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js
var require_constants2 = __commonJS({
"../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js"(exports, 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,
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,
REPLACEMENTS: {
"***": "*",
"**/**": "**",
"**/**/**": "**"
},
CHAR_0: 48,
CHAR_9: 57,
CHAR_UPPERCASE_A: 65,
CHAR_LOWERCASE_A: 97,
CHAR_UPPERCASE_Z: 90,
CHAR_LOWERCASE_Z: 122,
CHAR_LEFT_PARENTHESES: 40,
CHAR_RIGHT_PARENTHESES: 41,
CHAR_ASTERISK: 42,
CHAR_AMPERSAND: 38,
CHAR_AT: 64,
CHAR_BACKWARD_SLASH: 92,
CHAR_CARRIAGE_RETURN: 13,
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,
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,
CHAR_NO_BREAK_SPACE: 160,
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,
CHAR_UNDERSCORE: 95,
CHAR_VERTICAL_LINE: 124,
CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
SEP: path7.sep,
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: ")" }
};
},
globChars(win32) {
return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
}
};
}
});
// ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js
var require_utils2 = __commonJS({
"../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js"(exports) {
"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_constants2();
exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str);
exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
exports.removeBackslashes = (str) => {
return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
return match === "\\" ? "" : match;
});
};
exports.supportsLookbehinds = () => {
const segs = process.version.slice(1).split(".").map(Number);
if (segs.length === 3 && segs[0] >= 9 || segs[0] === 8 && segs[1] >= 10) {
return true;
}
return false;
};
exports.isWindows = (options2) => {
if (options2 && typeof options2.windows === "boolean") {
return options2.windows;
}
return win32 === true || path7.sep === "\\";
};
exports.escapeLast = (input, char, lastIdx) => {
const idx = input.lastIndexOf(char, lastIdx);
if (idx === -1)
return input;
if (input[idx - 1] === "\\")
return exports.escapeLast(input, char, idx - 1);
return `${input.slice(0, idx)}\\${input.slice(idx)}`;
};
exports.removePrefix = (input, state = {}) => {
let output = input;
if (output.startsWith("./")) {
output = output.slice(2);
state.prefix = "./";
}
return output;
};
exports.wrapOutput = (input, state = {}, options2 = {}) => {
const prepend = options2.contains ? "" : "^";
const append = options2.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"(exports, module2) {
"use strict";
var utils = require_utils2();
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_constants2();
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, options2) => {
const opts2 = options2 || {};
const length = input.length - 1;
const scanToEnd = opts2.parts === true || opts2.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 finished = 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;
finished = true;
if (scanToEnd === true) {
continue;
}
break;
}
if (braceEscaped !== true && code === CHAR_COMMA) {
isBrace = token.isBrace = true;
isGlob = token.isGlob = true;
finished = true;
if (scanToEnd === true) {
continue;
}
break;
}
if (code === CHAR_RIGHT_CURLY_BRACE) {
braces--;
if (braces === 0) {
braceEscaped = false;
isBrace = token.isBrace = true;
finished = 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 (finished === true)
continue;
if (prev === CHAR_DOT && index === start + 1) {
start += 2;
continue;
}
lastIndex = index + 1;
continue;
}
if (opts2.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;
finished = 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;
finished = true;
break;
}
}
continue;
}
break;
}
}
if (code === CHAR_ASTERISK) {
if (prev === CHAR_ASTERISK)
isGlobstar = token.isGlobstar = true;
isGlob = token.isGlob = true;
finished = true;
if (scanToEnd === true) {
continue;
}
break;
}
if (code === CHAR_QUESTION_MARK) {
isGlob = token.isGlob = true;
finished = 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;
finished = true;
break;
}
}
if (scanToEnd === true) {
continue;
}
break;
}
if (opts2.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
negated = token.negated = true;
start++;
continue;
}
if (opts2.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) {
finished = true;
break;
}
}
continue;
}
break;
}
if (isGlob === true) {
finished = true;
if (scanToEnd === true) {
continue;
}
break;
}
}
if (opts2.noext === true) {
isExtglob = false;
isGlob = false;
}
let base = str;
let prefix = "";
let glob = "";
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);
glob = str.slice(lastIndex);
} else if (isGlob === true) {
base = "";
glob = str;
} else {
base = str;
}
if (base && base !== "" && base !== "/" && base !== str) {
if (isPathSeparator(base.charCodeAt(base.length - 1))) {
base = base.slice(0, -1);
}
}
if (opts2.unescape === true) {
if (glob)
glob = utils.removeBackslashes(glob);
if (base && backslashes === true) {
base = utils.removeBackslashes(base);
}
}
const state = {
prefix,
input,
start,
base,
glob,
isBrace,
isBracket,
isGlob,
isExtglob,
isGlobstar,
negated,
negatedExtglob
};
if (opts2.tokens === true) {
state.maxDepth = 0;
if (!isPathSeparator(code)) {
tokens.push(token);
}
state.tokens = tokens;
}
if (opts2.parts === true || opts2.tokens === true) {
let prevIndex;
for (let idx = 0; idx < slashes.length; idx++) {
const n2 = prevIndex ? prevIndex + 1 : start;
const i = slashes[idx];
const value = input.slice(n2, i);
if (opts2.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 = i;
}
if (prevIndex && prevIndex + 1 < input.length) {
const value = input.slice(prevIndex + 1);
parts.push(value);
if (opts2.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_parse3 = __commonJS({
"../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js"(exports, module2) {
"use strict";
var constants = require_constants2();
var utils = require_utils2();
var {
MAX_LENGTH,
POSIX_REGEX_SOURCE,
REGEX_NON_SPECIAL_CHARS,
REGEX_SPECIAL_CHARS_BACKREF,
REPLACEMENTS
} = constants;
var expandRange = (args, options2) => {
if (typeof options2.expandRange === "function") {
return options2.expandRange(...args, options2);
}
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 parse = (input, options2) => {
if (typeof input !== "string") {
throw new TypeError("Expected a string");
}
input = REPLACEMENTS[input] || input;
const opts2 = { ...options2 };
const max = typeof opts2.maxLength === "number" ? Math.min(MAX_LENGTH, opts2.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: opts2.prepend || "" };
const tokens = [bos];
const capture = opts2.capture ? "" : "?:";
const win32 = utils.isWindows(options2);
const PLATFORM_CHARS = constants.globChars(win32);
const EXTGLOB_CHARS = constants.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 = (opts3) => {
return `(${capture}(?:(?!${START_ANCHOR}${opts3.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
};
const nodot = opts2.dot ? "" : NO_DOT;
const qmarkNoDot = opts2.dot ? QMARK : QMARK_NO_DOT;
let star = opts2.bash === true ? globstar(opts2) : STAR;
if (opts2.capture) {
star = `(${star})`;
}
if (typeof opts2.noext === "boolean") {
opts2.noextglob = opts2.noext;
}
const state = {
input,
index: -1,
start: 0,
dot: opts2.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 count = 1;
while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
advance();
state.start++;
count++;
}
if (count % 2 === 0) {
return false;
}
state.negated = true;
state.start++;
return true;
};
const increment = (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 = (opts2.capture ? "(" : "") + token.open;
increment("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 + (opts2.capture ? ")" : "");
let rest;
if (token.type === "negate") {
let extglobStar = star;
if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
extglobStar = globstar(opts2);
}
if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
output = token.close = `)$))${extglobStar}`;
}
if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
const expression = parse(rest, { ...options2, 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 (opts2.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 (opts2.unescape === true) {
output = output.replace(/\\/g, "");
} else {
output = output.replace(/\\+/g, (m) => {
return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
});
}
}
if (output === input && opts2.contains === true) {
state.output = input;
return state;
}
state.output = utils.wrapOutput(output, state, options2);
return state;
}
while (!eos()) {
value = advance();
if (value === "\0") {
continue;
}
if (value === "\\") {
const next = peek();
if (next === "/" && opts2.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 (opts2.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 (opts2.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 (opts2.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 (opts2.keepQuotes === true) {
push({ type: "text", value });
}
continue;
}
if (value === "(") {
increment("parens");
push({ type: "paren", value });
continue;
}
if (value === ")") {
if (state.parens === 0 && opts2.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 (opts2.nobracket === true || !remaining().includes("]")) {
if (opts2.nobracket !== true && opts2.strictBrackets === true) {
throw new SyntaxError(syntaxError("closing", "]"));
}
value = `\\${value}`;
} else {
increment("brackets");
}
push({ type: "bracket", value });
continue;
}
if (value === "]") {
if (opts2.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
push({ type: "text", value, output: `\\${value}` });
continue;
}
if (state.brackets === 0) {
if (opts2.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 (opts2.literalBrackets === false || utils.hasRegexChars(prevValue)) {
continue;
}
const escaped = utils.escapeRegex(prev.value);
state.output = state.output.slice(0, -prev.value.length);
if (opts2.literalBrackets === true) {
state.output += escaped;
prev.value = escaped;
continue;
}
prev.value = `(${capture}${escaped}|${prev.value})`;
state.output += prev.value;
continue;
}
if (value === "{" && opts2.nobrace !== true) {
increment("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 (opts2.nobrace === true || !brace) {
push({ type: "text", value, output: value });
continue;
}
let output = ")";
if (brace.dots === true) {
const arr = tokens.slice();
const range = [];
for (let i = arr.length - 1; i >= 0; i--) {
tokens.pop();
if (arr[i].type === "brace") {
break;
}
if (arr[i].type !== "dots") {
range.unshift(arr[i].value);
}
}
output = expandRange(range, opts2);
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 t3 of toks) {
state.output += t3.output || t3.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 && opts2.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 (opts2.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 (opts2.noextglob !== true && peek() === "(") {
if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
extglobOpen("negate", value);
continue;
}
}
if (opts2.nonegate !== true && state.index === 0) {
negate();
continue;
}
}
if (value === "+") {
if (opts2.noextglob !== true && peek() === "(" && peek(2) !== "?") {
extglobOpen("plus", value);
continue;
}
if (prev && prev.value === "(" || opts2.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 (opts2.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 (opts2.noextglob !== true && /^\([^?]/.test(rest)) {
extglobOpen("star", value);
continue;
}
if (prev.type === "star") {
if (opts2.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 (opts2.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(opts2);
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(opts2) + (opts2.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(opts2)}${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(opts2)}${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(opts2);
prev.value += value;
state.output += prev.output;
state.globstar = true;
consume(value);
continue;
}
const token = { type: "star", value, output: star };
if (opts2.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") && opts2.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 (opts2.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 (opts2.strictBrackets === true)
throw new SyntaxError(syntaxError("closing", "]"));
state.output = utils.escapeLast(state.output, "[");
decrement("brackets");
}
while (state.parens > 0) {
if (opts2.strictBrackets === true)
throw new SyntaxError(syntaxError("closing", ")"));
state.output = utils.escapeLast(state.output, "(");
decrement("parens");
}
while (state.braces > 0) {
if (opts2.strictBrackets === true)
throw new SyntaxError(syntaxError("closing", "}"));
state.output = utils.escapeLast(state.output, "{");
decrement("braces");
}
if (opts2.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;
};
parse.fastpaths = (input, options2) => {
const opts2 = { ...options2 };
const max = typeof opts2.maxLength === "number" ? Math.min(MAX_LENGTH, opts2.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(options2);
const {
DOT_LITERAL,
SLASH_LITERAL,
ONE_CHAR,
DOTS_SLASH,
NO_DOT,
NO_DOTS,
NO_DOTS_SLASH,
STAR,
START_ANCHOR
} = constants.globChars(win32);
const nodot = opts2.dot ? NO_DOTS : NO_DOT;
const slashDot = opts2.dot ? NO_DOTS_SLASH : NO_DOT;
const capture = opts2.capture ? "" : "?:";
const state = { negated: false, prefix: "" };
let star = opts2.bash === true ? ".*?" : STAR;
if (opts2.capture) {
star = `(${star})`;
}
const globstar = (opts3) => {
if (opts3.noglobstar === true)
return star;
return `(${capture}(?:(?!${START_ANCHOR}${opts3.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
};
const create = (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(opts2);
case "**/*":
return `(?:${nodot}${globstar(opts2)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
case "**/*.*":
return `(?:${nodot}${globstar(opts2)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
case "**/.*":
return `(?:${nodot}${globstar(opts2)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
default: {
const match = /^(.*?)\.(\w+)$/.exec(str);
if (!match)
return;
const source2 = create(match[1]);
if (!source2)
return;
return source2 + DOT_LITERAL + match[2];
}
}
};
const output = utils.removePrefix(input, state);
let source = create(output);
if (source && opts2.strictSlashes !== true) {
source += `${SLASH_LITERAL}?`;
}
return source;
};
module2.exports = parse;
}
});
// ../../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"(exports, module2) {
"use strict";
var path7 = require("path");
var scan = require_scan();
var parse = require_parse3();
var utils = require_utils2();
var constants = require_constants2();
var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
var picomatch = (glob, options2, returnState = false) => {
if (Array.isArray(glob)) {
const fns = glob.map((input) => picomatch(input, options2, returnState));
const arrayMatcher = (str) => {
for (const isMatch of fns) {
const state2 = isMatch(str);
if (state2)
return state2;
}
return false;
};
return arrayMatcher;
}
const isState = isObject(glob) && glob.tokens && glob.input;
if (glob === "" || typeof glob !== "string" && !isState) {
throw new TypeError("Expected pattern to be a non-empty string");
}
const opts2 = options2 || {};
const posix = utils.isWindows(options2);
const regex = isState ? picomatch.compileRe(glob, options2) : picomatch.makeRe(glob, options2, false, true);
const state = regex.state;
delete regex.state;
let isIgnored = () => false;
if (opts2.ignore) {
const ignoreOpts = { ...options2, ignore: null, onMatch: null, onResult: null };
isIgnored = picomatch(opts2.ignore, ignoreOpts, returnState);
}
const matcher = (input, returnObject = false) => {
const { isMatch, match, output } = picomatch.test(input, regex, options2, { glob, posix });
const result = { glob, state, regex, posix, input, output, match, isMatch };
if (typeof opts2.onResult === "function") {
opts2.onResult(result);
}
if (isMatch === false) {
result.isMatch = false;
return returnObject ? result : false;
}
if (isIgnored(input)) {
if (typeof opts2.onIgnore === "function") {
opts2.onIgnore(result);
}
result.isMatch = false;
return returnObject ? result : false;
}
if (typeof opts2.onMatch === "function") {
opts2.onMatch(result);
}
return returnObject ? result : true;
};
if (returnState) {
matcher.state = state;
}
return matcher;
};
picomatch.test = (input, regex, options2, { glob, posix } = {}) => {
if (typeof input !== "string") {
throw new TypeError("Expected input to be a string");
}
if (input === "") {
return { isMatch: false, output: "" };
}
const opts2 = options2 || {};
const format = opts2.format || (posix ? utils.toPosixSlashes : null);
let match = input === glob;
let output = match && format ? format(input) : input;
if (match === false) {
output = format ? format(input) : input;
match = output === glob;
}
if (match === false || opts2.capture === true) {
if (opts2.matchBase === true || opts2.basename === true) {
match = picomatch.matchBase(input, regex, options2, posix);
} else {
match = regex.exec(output);
}
}
return { isMatch: Boolean(match), match, output };
};
picomatch.matchBase = (input, glob, options2, posix = utils.isWindows(options2)) => {
const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options2);
return regex.test(path7.basename(input));
};
picomatch.isMatch = (str, patterns, options2) => picomatch(patterns, options2)(str);
picomatch.parse = (pattern, options2) => {
if (Array.isArray(pattern))
return pattern.map((p2) => picomatch.parse(p2, options2));
return parse(pattern, { ...options2, fastpaths: false });
};
picomatch.scan = (input, options2) => scan(input, options2);
picomatch.compileRe = (state, options2, returnOutput = false, returnState = false) => {
if (returnOutput === true) {
return state.output;
}
const opts2 = options2 || {};
const prepend = opts2.contains ? "" : "^";
const append = opts2.contains ? "" : "$";
let source = `${prepend}(?:${state.output})${append}`;
if (state && state.negated === true) {
source = `^(?!${source}).*$`;
}
const regex = picomatch.toRegex(source, options2);
if (returnState === true) {
regex.state = state;
}
return regex;
};
picomatch.makeRe = (input, options2 = {}, returnOutput = false, returnState = false) => {
if (!input || typeof input !== "string") {
throw new TypeError("Expected a non-empty string");
}
let parsed = { negated: false, fastpaths: true };
if (options2.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
parsed.output = parse.fastpaths(input, options2);
}
if (!parsed.output) {
parsed = parse(input, options2);
}
return picomatch.compileRe(parsed, options2, returnOutput, returnState);
};
picomatch.toRegex = (source, options2) => {
try {
const opts2 = options2 || {};
return new RegExp(source, opts2.flags || (opts2.nocase ? "i" : ""));
} catch (err) {
if (options2 && options2.debug === true)
throw err;
return /$^/;
}
};
picomatch.constants = constants;
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"(exports, module2) {
"use strict";
module2.exports = require_picomatch();
}
});
// ../../node_modules/.pnpm/micromatch@4.0.5/node_modules/micromatch/index.js
var require_micromatch = __commonJS({
"../../node_modules/.pnpm/micromatch@4.0.5/node_modules/micromatch/index.js"(exports, module2) {
"use strict";
var util = require("util");
var braces = require_braces();
var picomatch = require_picomatch2();
var utils = require_utils2();
var isEmptyString = (val) => val === "" || val === "./";
var micromatch = (list, patterns, options2) => {
patterns = [].concat(patterns);
list = [].concat(list);
let omit = /* @__PURE__ */ new Set();
let keep = /* @__PURE__ */ new Set();
let items = /* @__PURE__ */ new Set();
let negatives = 0;
let onResult = (state) => {
items.add(state.output);
if (options2 && options2.onResult) {
options2.onResult(state);
}
};
for (let i = 0; i < patterns.length; i++) {
let isMatch = picomatch(String(patterns[i]), { ...options2, 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) {
omit.add(matched.output);
} else {
omit.delete(matched.output);
keep.add(matched.output);
}
}
}
let result = negatives === patterns.length ? [...items] : [...keep];
let matches = result.filter((item) => !omit.has(item));
if (options2 && matches.length === 0) {
if (options2.failglob === true) {
throw new Error(`No matches found for "${patterns.join(", ")}"`);
}
if (options2.nonull === true || options2.nullglob === true) {
return options2.unescape ? patterns.map((p2) => p2.replace(/\\/g, "")) : patterns;
}
}
return matches;
};
micromatch.match = micromatch;
micromatch.matcher = (pattern, options2) => picomatch(pattern, options2);
micromatch.isMatch = (str, patterns, options2) => picomatch(patterns, options2)(str);
micromatch.any = micromatch.isMatch;
micromatch.not = (list, patterns, options2 = {}) => {
patterns = [].concat(patterns).map(String);
let result = /* @__PURE__ */ new Set();
let items = [];
let onResult = (state) => {
if (options2.onResult)
options2.onResult(state);
items.push(state.output);
};
let matches = new Set(micromatch(list, patterns, { ...options2, onResult }));
for (let item of items) {
if (!matches.has(item)) {
result.add(item);
}
}
return [...result];
};
micromatch.contains = (str, pattern, options2) => {
if (typeof str !== "string") {
throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
}
if (Array.isArray(pattern)) {
return pattern.some((p2) => micromatch.contains(str, p2, options2));
}
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 micromatch.isMatch(str, pattern, { ...options2, contains: true });
};
micromatch.matchKeys = (obj, patterns, options2) => {
if (!utils.isObject(obj)) {
throw new TypeError("Expected the first argument to be an object");
}
let keys = micromatch(Object.keys(obj), patterns, options2);
let res = {};
for (let key of keys)
res[key] = obj[key];
return res;
};
micromatch.some = (list, patterns, options2) => {
let items = [].concat(list);
for (let pattern of [].concat(patterns)) {
let isMatch = picomatch(String(pattern), options2);
if (items.some((item) => isMatch(item))) {
return true;
}
}
return false;
};
micromatch.every = (list, patterns, options2) => {
let items = [].concat(list);
for (let pattern of [].concat(patterns)) {
let isMatch = picomatch(String(pattern), options2);
if (!items.every((item) => isMatch(item))) {
return false;
}
}
return true;
};
micromatch.all = (str, patterns, options2) => {
if (typeof str !== "string") {
throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
}
return [].concat(patterns).every((p2) => picomatch(p2, options2)(str));
};
micromatch.capture = (glob, input, options2) => {
let posix = utils.isWindows(options2);
let regex = picomatch.makeRe(String(glob), { ...options2, capture: true });
let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
if (match) {
return match.slice(1).map((v) => v === void 0 ? "" : v);
}
};
micromatch.makeRe = (...args) => picomatch.makeRe(...args);
micromatch.scan = (...args) => picomatch.scan(...args);
micromatch.parse = (patterns, options2) => {
let res = [];
for (let pattern of [].concat(patterns || [])) {
for (let str of braces(String(pattern), options2)) {
res.push(picomatch.parse(str, options2));
}
}
return res;
};
micromatch.braces = (pattern, options2) => {
if (typeof pattern !== "string")
throw new TypeError("Expected a string");
if (options2 && options2.nobrace === true || !/\{.*\}/.test(pattern)) {
return [pattern];
}
return braces(pattern, options2);
};
micromatch.braceExpand = (pattern, options2) => {
if (typeof pattern !== "string")
throw new TypeError("Expected a string");
return micromatch.braces(pattern, { ...options2, expand: true });
};
module2.exports = micromatch;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/pattern.js
var require_pattern = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/pattern.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.removeDuplicateSlashes = exports.matchAny = exports.convertPatternsToRe = exports.makeRe = exports.getPatternParts = exports.expandBraceExpansion = exports.expandPatternsWithBraceExpansion = exports.isAffectDepthOfReadingPattern = exports.endsWithSlashGlobStar = exports.hasGlobStar = exports.getBaseDirectory = exports.isPatternRelatedToParentDirectory = exports.getPatternsOutsideCurrentDirectory = exports.getPatternsInsideCurrentDirectory = exports.getPositivePatterns = exports.getNegativePatterns = exports.isPositivePattern = exports.isNegativePattern = exports.convertToNegativePattern = exports.convertToPositivePattern = exports.isDynamicPattern = exports.isStaticPattern = void 0;
var path7 = require("path");
var globParent = require_glob_parent();
var micromatch = require_micromatch();
var GLOBSTAR = "**";
var ESCAPE_SYMBOL = "\\";
var COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
var REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/;
var REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
var GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
var BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
var DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
function isStaticPattern(pattern, options2 = {}) {
return !isDynamicPattern(pattern, options2);
}
exports.isStaticPattern = isStaticPattern;
function isDynamicPattern(pattern, options2 = {}) {
if (pattern === "") {
return false;
}
if (options2.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
return true;
}
if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {
return true;
}
if (options2.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
return true;
}
if (options2.braceExpansion !== false && hasBraceExpansion(pattern)) {
return true;
}
return false;
}
exports.isDynamicPattern = isDynamicPattern;
function hasBraceExpansion(pattern) {
const openingBraceIndex = pattern.indexOf("{");
if (openingBraceIndex === -1) {
return false;
}
const closingBraceIndex = pattern.indexOf("}", openingBraceIndex + 1);
if (closingBraceIndex === -1) {
return false;
}
const braceContent = pattern.slice(openingBraceIndex, closingBraceIndex);
return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
}
function convertToPositivePattern(pattern) {
return isNegativePattern(pattern) ? pattern.slice(1) : pattern;
}
exports.convertToPositivePattern = convertToPositivePattern;
function convertToNegativePattern(pattern) {
return "!" + pattern;
}
exports.convertToNegativePattern = convertToNegativePattern;
function isNegativePattern(pattern) {
return pattern.startsWith("!") && pattern[1] !== "(";
}
exports.isNegativePattern = isNegativePattern;
function isPositivePattern(pattern) {
return !isNegativePattern(pattern);
}
exports.isPositivePattern = isPositivePattern;
function getNegativePatterns(patterns) {
return patterns.filter(isNegativePattern);
}
exports.getNegativePatterns = getNegativePatterns;
function getPositivePatterns(patterns) {
return patterns.filter(isPositivePattern);
}
exports.getPositivePatterns = getPositivePatterns;
function getPatternsInsideCurrentDirectory(patterns) {
return patterns.filter((pattern) => !isPatternRelatedToParentDirectory(pattern));
}
exports.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
function getPatternsOutsideCurrentDirectory(patterns) {
return patterns.filter(isPatternRelatedToParentDirectory);
}
exports.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
function isPatternRelatedToParentDirectory(pattern) {
return pattern.startsWith("..") || pattern.startsWith("./..");
}
exports.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
function getBaseDirectory(pattern) {
return globParent(pattern, { flipBackslashes: false });
}
exports.getBaseDirectory = getBaseDirectory;
function hasGlobStar(pattern) {
return pattern.includes(GLOBSTAR);
}
exports.hasGlobStar = hasGlobStar;
function endsWithSlashGlobStar(pattern) {
return pattern.endsWith("/" + GLOBSTAR);
}
exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
function isAffectDepthOfReadingPattern(pattern) {
const basename = path7.basename(pattern);
return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
}
exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
function expandPatternsWithBraceExpansion(patterns) {
return patterns.reduce((collection, pattern) => {
return collection.concat(expandBraceExpansion(pattern));
}, []);
}
exports.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
function expandBraceExpansion(pattern) {
const patterns = micromatch.braces(pattern, { expand: true, nodupes: true });
patterns.sort((a, b2) => a.length - b2.length);
return patterns.filter((pattern2) => pattern2 !== "");
}
exports.expandBraceExpansion = expandBraceExpansion;
function getPatternParts(pattern, options2) {
let { parts } = micromatch.scan(pattern, Object.assign(Object.assign({}, options2), { parts: true }));
if (parts.length === 0) {
parts = [pattern];
}
if (parts[0].startsWith("/")) {
parts[0] = parts[0].slice(1);
parts.unshift("");
}
return parts;
}
exports.getPatternParts = getPatternParts;
function makeRe(pattern, options2) {
return micromatch.makeRe(pattern, options2);
}
exports.makeRe = makeRe;
function convertPatternsToRe(patterns, options2) {
return patterns.map((pattern) => makeRe(pattern, options2));
}
exports.convertPatternsToRe = convertPatternsToRe;
function matchAny(entry, patternsRe) {
return patternsRe.some((patternRe) => patternRe.test(entry));
}
exports.matchAny = matchAny;
function removeDuplicateSlashes(pattern) {
return pattern.replace(DOUBLE_SLASH_RE, "/");
}
exports.removeDuplicateSlashes = removeDuplicateSlashes;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/stream.js
var require_stream2 = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/stream.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.merge = void 0;
var merge2 = require_merge2();
function merge(streams) {
const mergedStream = merge2(streams);
streams.forEach((stream) => {
stream.once("error", (error) => mergedStream.emit("error", error));
});
mergedStream.once("close", () => propagateCloseEventToSources(streams));
mergedStream.once("end", () => propagateCloseEventToSources(streams));
return mergedStream;
}
exports.merge = merge;
function propagateCloseEventToSources(streams) {
streams.forEach((stream) => stream.emit("close"));
}
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/string.js
var require_string = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/string.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.isEmpty = exports.isString = void 0;
function isString(input) {
return typeof input === "string";
}
exports.isString = isString;
function isEmpty(input) {
return input === "";
}
exports.isEmpty = isEmpty;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/index.js
var require_utils3 = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/utils/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.string = exports.stream = exports.pattern = exports.path = exports.fs = exports.errno = exports.array = void 0;
var array = require_array();
exports.array = array;
var errno = require_errno();
exports.errno = errno;
var fs10 = require_fs();
exports.fs = fs10;
var path7 = require_path();
exports.path = path7;
var pattern = require_pattern();
exports.pattern = pattern;
var stream = require_stream2();
exports.stream = stream;
var string = require_string();
exports.string = string;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/managers/tasks.js
var require_tasks = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/managers/tasks.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.convertPatternGroupToTask = exports.convertPatternGroupsToTasks = exports.groupPatternsByBaseDirectory = exports.getNegativePatternsAsPositive = exports.getPositivePatterns = exports.convertPatternsToTasks = exports.generate = void 0;
var utils = require_utils3();
function generate(input, settings) {
const patterns = processPatterns(input, settings);
const ignore = processPatterns(settings.ignore, settings);
const positivePatterns = getPositivePatterns(patterns);
const negativePatterns = getNegativePatternsAsPositive(patterns, ignore);
const staticPatterns = positivePatterns.filter((pattern) => utils.pattern.isStaticPattern(pattern, settings));
const dynamicPatterns = positivePatterns.filter((pattern) => utils.pattern.isDynamicPattern(pattern, settings));
const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, false);
const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, true);
return staticTasks.concat(dynamicTasks);
}
exports.generate = generate;
function processPatterns(input, settings) {
let patterns = input;
if (settings.braceExpansion) {
patterns = utils.pattern.expandPatternsWithBraceExpansion(patterns);
}
if (settings.baseNameMatch) {
patterns = patterns.map((pattern) => pattern.includes("/") ? pattern : `**/${pattern}`);
}
return patterns.map((pattern) => utils.pattern.removeDuplicateSlashes(pattern));
}
function convertPatternsToTasks(positive, negative, dynamic) {
const tasks = [];
const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
if ("." in insideCurrentDirectoryGroup) {
tasks.push(convertPatternGroupToTask(".", patternsInsideCurrentDirectory, negative, dynamic));
} else {
tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
}
return tasks;
}
exports.convertPatternsToTasks = convertPatternsToTasks;
function getPositivePatterns(patterns) {
return utils.pattern.getPositivePatterns(patterns);
}
exports.getPositivePatterns = getPositivePatterns;
function getNegativePatternsAsPositive(patterns, ignore) {
const negative = utils.pattern.getNegativePatterns(patterns).concat(ignore);
const positive = negative.map(utils.pattern.convertToPositivePattern);
return positive;
}
exports.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
function groupPatternsByBaseDirectory(patterns) {
const group = {};
return patterns.reduce((collection, pattern) => {
const base = utils.pattern.getBaseDirectory(pattern);
if (base in collection) {
collection[base].push(pattern);
} else {
collection[base] = [pattern];
}
return collection;
}, group);
}
exports.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
function convertPatternGroupsToTasks(positive, negative, dynamic) {
return Object.keys(positive).map((base) => {
return convertPatternGroupToTask(base, positive[base], negative, dynamic);
});
}
exports.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
function convertPatternGroupToTask(base, positive, negative, dynamic) {
return {
dynamic,
positive,
negative,
base,
patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
};
}
exports.convertPatternGroupToTask = convertPatternGroupToTask;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/providers/async.js
var require_async = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/providers/async.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.read = void 0;
function read(path7, settings, callback) {
settings.fs.lstat(path7, (lstatError, lstat) => {
if (lstatError !== null) {
callFailureCallback(callback, lstatError);
return;
}
if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
callSuccessCallback(callback, lstat);
return;
}
settings.fs.stat(path7, (statError, stat) => {
if (statError !== null) {
if (settings.throwErrorOnBrokenSymbolicLink) {
callFailureCallback(callback, statError);
return;
}
callSuccessCallback(callback, lstat);
return;
}
if (settings.markSymbolicLink) {
stat.isSymbolicLink = () => true;
}
callSuccessCallback(callback, stat);
});
});
}
exports.read = read;
function callFailureCallback(callback, error) {
callback(error);
}
function callSuccessCallback(callback, result) {
callback(null, result);
}
}
});
// ../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/providers/sync.js
var require_sync = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/providers/sync.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.read = void 0;
function read(path7, settings) {
const lstat = settings.fs.lstatSync(path7);
if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
return lstat;
}
try {
const stat = settings.fs.statSync(path7);
if (settings.markSymbolicLink) {
stat.isSymbolicLink = () => true;
}
return stat;
} catch (error) {
if (!settings.throwErrorOnBrokenSymbolicLink) {
return lstat;
}
throw error;
}
}
exports.read = read;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/adapters/fs.js
var require_fs2 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/adapters/fs.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
var fs10 = require("fs");
exports.FILE_SYSTEM_ADAPTER = {
lstat: fs10.lstat,
stat: fs10.stat,
lstatSync: fs10.lstatSync,
statSync: fs10.statSync
};
function createFileSystemAdapter(fsMethods) {
if (fsMethods === void 0) {
return exports.FILE_SYSTEM_ADAPTER;
}
return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
}
exports.createFileSystemAdapter = createFileSystemAdapter;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/settings.js
var require_settings = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/settings.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var fs10 = require_fs2();
var Settings = class {
constructor(_options = {}) {
this._options = _options;
this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
this.fs = fs10.createFileSystemAdapter(this._options.fs);
this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
}
_getValue(option, value) {
return option !== null && option !== void 0 ? option : value;
}
};
exports.default = Settings;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.js
var require_out = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.statSync = exports.stat = exports.Settings = void 0;
var async = require_async();
var sync = require_sync();
var settings_1 = require_settings();
exports.Settings = settings_1.default;
function stat(path7, optionsOrSettingsOrCallback, callback) {
if (typeof optionsOrSettingsOrCallback === "function") {
async.read(path7, getSettings(), optionsOrSettingsOrCallback);
return;
}
async.read(path7, getSettings(optionsOrSettingsOrCallback), callback);
}
exports.stat = stat;
function statSync(path7, optionsOrSettings) {
const settings = getSettings(optionsOrSettings);
return sync.read(path7, settings);
}
exports.statSync = statSync;
function getSettings(settingsOrOptions = {}) {
if (settingsOrOptions instanceof settings_1.default) {
return settingsOrOptions;
}
return new settings_1.default(settingsOrOptions);
}
}
});
// ../../node_modules/.pnpm/queue-microtask@1.2.3/node_modules/queue-microtask/index.js
var require_queue_microtask = __commonJS({
"../../node_modules/.pnpm/queue-microtask@1.2.3/node_modules/queue-microtask/index.js"(exports, module2) {
var promise;
module2.exports = typeof queueMicrotask === "function" ? queueMicrotask.bind(typeof window !== "undefined" ? window : global) : (cb) => (promise || (promise = Promise.resolve())).then(cb).catch((err) => setTimeout(() => {
throw err;
}, 0));
}
});
// ../../node_modules/.pnpm/run-parallel@1.2.0/node_modules/run-parallel/index.js
var require_run_parallel = __commonJS({
"../../node_modules/.pnpm/run-parallel@1.2.0/node_modules/run-parallel/index.js"(exports, module2) {
module2.exports = runParallel;
var queueMicrotask2 = require_queue_microtask();
function runParallel(tasks, cb) {
let results, pending, keys;
let isSync = true;
if (Array.isArray(tasks)) {
results = [];
pending = tasks.length;
} else {
keys = Object.keys(tasks);
results = {};
pending = keys.length;
}
function done(err) {
function end() {
if (cb)
cb(err, results);
cb = null;
}
if (isSync)
queueMicrotask2(end);
else
end();
}
function each(i, err, result) {
results[i] = result;
if (--pending === 0 || err) {
done(err);
}
}
if (!pending) {
done(null);
} else if (keys) {
keys.forEach(function(key) {
tasks[key](function(err, result) {
each(key, err, result);
});
});
} else {
tasks.forEach(function(task, i) {
task(function(err, result) {
each(i, err, result);
});
});
}
isSync = false;
}
}
});
// ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/constants.js
var require_constants3 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/constants.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
var NODE_PROCESS_VERSION_PARTS = process.versions.node.split(".");
if (NODE_PROCESS_VERSION_PARTS[0] === void 0 || NODE_PROCESS_VERSION_PARTS[1] === void 0) {
throw new Error(`Unexpected behavior. The 'process.versions.node' variable has invalid value: ${process.versions.node}`);
}
var MAJOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
var MINOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);
var SUPPORTED_MAJOR_VERSION = 10;
var SUPPORTED_MINOR_VERSION = 10;
var IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION;
var IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION;
exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/utils/fs.js
var require_fs3 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/utils/fs.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createDirentFromStats = void 0;
var DirentFromStats = class {
constructor(name, stats) {
this.name = name;
this.isBlockDevice = stats.isBlockDevice.bind(stats);
this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
this.isDirectory = stats.isDirectory.bind(stats);
this.isFIFO = stats.isFIFO.bind(stats);
this.isFile = stats.isFile.bind(stats);
this.isSocket = stats.isSocket.bind(stats);
this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
}
};
function createDirentFromStats(name, stats) {
return new DirentFromStats(name, stats);
}
exports.createDirentFromStats = createDirentFromStats;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/utils/index.js
var require_utils4 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/utils/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.fs = void 0;
var fs10 = require_fs3();
exports.fs = fs10;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/common.js
var require_common2 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/common.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.joinPathSegments = void 0;
function joinPathSegments(a, b2, separator) {
if (a.endsWith(separator)) {
return a + b2;
}
return a + separator + b2;
}
exports.joinPathSegments = joinPathSegments;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/async.js
var require_async2 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/async.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.readdir = exports.readdirWithFileTypes = exports.read = void 0;
var fsStat = require_out();
var rpl = require_run_parallel();
var constants_1 = require_constants3();
var utils = require_utils4();
var common = require_common2();
function read(directory, settings, callback) {
if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
readdirWithFileTypes(directory, settings, callback);
return;
}
readdir(directory, settings, callback);
}
exports.read = read;
function readdirWithFileTypes(directory, settings, callback) {
settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
if (readdirError !== null) {
callFailureCallback(callback, readdirError);
return;
}
const entries = dirents.map((dirent) => ({
dirent,
name: dirent.name,
path: common.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
}));
if (!settings.followSymbolicLinks) {
callSuccessCallback(callback, entries);
return;
}
const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
rpl(tasks, (rplError, rplEntries) => {
if (rplError !== null) {
callFailureCallback(callback, rplError);
return;
}
callSuccessCallback(callback, rplEntries);
});
});
}
exports.readdirWithFileTypes = readdirWithFileTypes;
function makeRplTaskEntry(entry, settings) {
return (done) => {
if (!entry.dirent.isSymbolicLink()) {
done(null, entry);
return;
}
settings.fs.stat(entry.path, (statError, stats) => {
if (statError !== null) {
if (settings.throwErrorOnBrokenSymbolicLink) {
done(statError);
return;
}
done(null, entry);
return;
}
entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
done(null, entry);
});
};
}
function readdir(directory, settings, callback) {
settings.fs.readdir(directory, (readdirError, names) => {
if (readdirError !== null) {
callFailureCallback(callback, readdirError);
return;
}
const tasks = names.map((name) => {
const path7 = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
return (done) => {
fsStat.stat(path7, settings.fsStatSettings, (error, stats) => {
if (error !== null) {
done(error);
return;
}
const entry = {
name,
path: path7,
dirent: utils.fs.createDirentFromStats(name, stats)
};
if (settings.stats) {
entry.stats = stats;
}
done(null, entry);
});
};
});
rpl(tasks, (rplError, entries) => {
if (rplError !== null) {
callFailureCallback(callback, rplError);
return;
}
callSuccessCallback(callback, entries);
});
});
}
exports.readdir = readdir;
function callFailureCallback(callback, error) {
callback(error);
}
function callSuccessCallback(callback, result) {
callback(null, result);
}
}
});
// ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/sync.js
var require_sync2 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/sync.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.readdir = exports.readdirWithFileTypes = exports.read = void 0;
var fsStat = require_out();
var constants_1 = require_constants3();
var utils = require_utils4();
var common = require_common2();
function read(directory, settings) {
if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
return readdirWithFileTypes(directory, settings);
}
return readdir(directory, settings);
}
exports.read = read;
function readdirWithFileTypes(directory, settings) {
const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
return dirents.map((dirent) => {
const entry = {
dirent,
name: dirent.name,
path: common.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
};
if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) {
try {
const stats = settings.fs.statSync(entry.path);
entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
} catch (error) {
if (settings.throwErrorOnBrokenSymbolicLink) {
throw error;
}
}
}
return entry;
});
}
exports.readdirWithFileTypes = readdirWithFileTypes;
function readdir(directory, settings) {
const names = settings.fs.readdirSync(directory);
return names.map((name) => {
const entryPath = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
const stats = fsStat.statSync(entryPath, settings.fsStatSettings);
const entry = {
name,
path: entryPath,
dirent: utils.fs.createDirentFromStats(name, stats)
};
if (settings.stats) {
entry.stats = stats;
}
return entry;
});
}
exports.readdir = readdir;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/adapters/fs.js
var require_fs4 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/adapters/fs.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
var fs10 = require("fs");
exports.FILE_SYSTEM_ADAPTER = {
lstat: fs10.lstat,
stat: fs10.stat,
lstatSync: fs10.lstatSync,
statSync: fs10.statSync,
readdir: fs10.readdir,
readdirSync: fs10.readdirSync
};
function createFileSystemAdapter(fsMethods) {
if (fsMethods === void 0) {
return exports.FILE_SYSTEM_ADAPTER;
}
return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
}
exports.createFileSystemAdapter = createFileSystemAdapter;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/settings.js
var require_settings2 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/settings.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var path7 = require("path");
var fsStat = require_out();
var fs10 = require_fs4();
var Settings = class {
constructor(_options = {}) {
this._options = _options;
this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
this.fs = fs10.createFileSystemAdapter(this._options.fs);
this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path7.sep);
this.stats = this._getValue(this._options.stats, false);
this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
this.fsStatSettings = new fsStat.Settings({
followSymbolicLink: this.followSymbolicLinks,
fs: this.fs,
throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
});
}
_getValue(option, value) {
return option !== null && option !== void 0 ? option : value;
}
};
exports.default = Settings;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.js
var require_out2 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Settings = exports.scandirSync = exports.scandir = void 0;
var async = require_async2();
var sync = require_sync2();
var settings_1 = require_settings2();
exports.Settings = settings_1.default;
function scandir(path7, optionsOrSettingsOrCallback, callback) {
if (typeof optionsOrSettingsOrCallback === "function") {
async.read(path7, getSettings(), optionsOrSettingsOrCallback);
return;
}
async.read(path7, getSettings(optionsOrSettingsOrCallback), callback);
}
exports.scandir = scandir;
function scandirSync(path7, optionsOrSettings) {
const settings = getSettings(optionsOrSettings);
return sync.read(path7, settings);
}
exports.scandirSync = scandirSync;
function getSettings(settingsOrOptions = {}) {
if (settingsOrOptions instanceof settings_1.default) {
return settingsOrOptions;
}
return new settings_1.default(settingsOrOptions);
}
}
});
// ../../node_modules/.pnpm/reusify@1.0.4/node_modules/reusify/reusify.js
var require_reusify = __commonJS({
"../../node_modules/.pnpm/reusify@1.0.4/node_modules/reusify/reusify.js"(exports, module2) {
"use strict";
function reusify(Constructor) {
var head = new Constructor();
var tail = head;
function get() {
var current = head;
if (current.next) {
head = current.next;
} else {
head = new Constructor();
tail = head;
}
current.next = null;
return current;
}
function release(obj) {
tail.next = obj;
tail = obj;
}
return {
get,
release
};
}
module2.exports = reusify;
}
});
// ../../node_modules/.pnpm/fastq@1.15.0/node_modules/fastq/queue.js
var require_queue = __commonJS({
"../../node_modules/.pnpm/fastq@1.15.0/node_modules/fastq/queue.js"(exports, module2) {
"use strict";
var reusify = require_reusify();
function fastqueue(context, worker, concurrency) {
if (typeof context === "function") {
concurrency = worker;
worker = context;
context = null;
}
if (concurrency < 1) {
throw new Error("fastqueue concurrency must be greater than 1");
}
var cache = reusify(Task);
var queueHead = null;
var queueTail = null;
var _running = 0;
var errorHandler = null;
var self = {
push,
drain: noop,
saturated: noop,
pause,
paused: false,
concurrency,
running,
resume,
idle,
length,
getQueue,
unshift,
empty: noop,
kill,
killAndDrain,
error
};
return self;
function running() {
return _running;
}
function pause() {
self.paused = true;
}
function length() {
var current = queueHead;
var counter = 0;
while (current) {
current = current.next;
counter++;
}
return counter;
}
function getQueue() {
var current = queueHead;
var tasks = [];
while (current) {
tasks.push(current.value);
current = current.next;
}
return tasks;
}
function resume() {
if (!self.paused)
return;
self.paused = false;
for (var i = 0; i < self.concurrency; i++) {
_running++;
release();
}
}
function idle() {
return _running === 0 && self.length() === 0;
}
function push(value, done) {
var current = cache.get();
current.context = context;
current.release = release;
current.value = value;
current.callback = done || noop;
current.errorHandler = errorHandler;
if (_running === self.concurrency || self.paused) {
if (queueTail) {
queueTail.next = current;
queueTail = current;
} else {
queueHead = current;
queueTail = current;
self.saturated();
}
} else {
_running++;
worker.call(context, current.value, current.worked);
}
}
function unshift(value, done) {
var current = cache.get();
current.context = context;
current.release = release;
current.value = value;
current.callback = done || noop;
if (_running === self.concurrency || self.paused) {
if (queueHead) {
current.next = queueHead;
queueHead = current;
} else {
queueHead = current;
queueTail = current;
self.saturated();
}
} else {
_running++;
worker.call(context, current.value, current.worked);
}
}
function release(holder) {
if (holder) {
cache.release(holder);
}
var next = queueHead;
if (next) {
if (!self.paused) {
if (queueTail === queueHead) {
queueTail = null;
}
queueHead = next.next;
next.next = null;
worker.call(context, next.value, next.worked);
if (queueTail === null) {
self.empty();
}
} else {
_running--;
}
} else if (--_running === 0) {
self.drain();
}
}
function kill() {
queueHead = null;
queueTail = null;
self.drain = noop;
}
function killAndDrain() {
queueHead = null;
queueTail = null;
self.drain();
self.drain = noop;
}
function error(handler) {
errorHandler = handler;
}
}
function noop() {
}
function Task() {
this.value = null;
this.callback = noop;
this.next = null;
this.release = noop;
this.context = null;
this.errorHandler = null;
var self = this;
this.worked = function worked(err, result) {
var callback = self.callback;
var errorHandler = self.errorHandler;
var val = self.value;
self.value = null;
self.callback = noop;
if (self.errorHandler) {
errorHandler(err, val);
}
callback.call(self.context, err, result);
self.release(self);
};
}
function queueAsPromised(context, worker, concurrency) {
if (typeof context === "function") {
concurrency = worker;
worker = context;
context = null;
}
function asyncWrapper(arg, cb) {
worker.call(this, arg).then(function(res) {
cb(null, res);
}, cb);
}
var queue = fastqueue(context, asyncWrapper, concurrency);
var pushCb = queue.push;
var unshiftCb = queue.unshift;
queue.push = push;
queue.unshift = unshift;
queue.drained = drained;
return queue;
function push(value) {
var p2 = new Promise(function(resolve, reject) {
pushCb(value, function(err, result) {
if (err) {
reject(err);
return;
}
resolve(result);
});
});
p2.catch(noop);
return p2;
}
function unshift(value) {
var p2 = new Promise(function(resolve, reject) {
unshiftCb(value, function(err, result) {
if (err) {
reject(err);
return;
}
resolve(result);
});
});
p2.catch(noop);
return p2;
}
function drained() {
if (queue.idle()) {
return new Promise(function(resolve) {
resolve();
});
}
var previousDrain = queue.drain;
var p2 = new Promise(function(resolve) {
queue.drain = function() {
previousDrain();
resolve();
};
});
return p2;
}
}
module2.exports = fastqueue;
module2.exports.promise = queueAsPromised;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/common.js
var require_common3 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/common.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.joinPathSegments = exports.replacePathSegmentSeparator = exports.isAppliedFilter = exports.isFatalError = void 0;
function isFatalError(settings, error) {
if (settings.errorFilter === null) {
return true;
}
return !settings.errorFilter(error);
}
exports.isFatalError = isFatalError;
function isAppliedFilter(filter, value) {
return filter === null || filter(value);
}
exports.isAppliedFilter = isAppliedFilter;
function replacePathSegmentSeparator(filepath, separator) {
return filepath.split(/[/\\]/).join(separator);
}
exports.replacePathSegmentSeparator = replacePathSegmentSeparator;
function joinPathSegments(a, b2, separator) {
if (a === "") {
return b2;
}
if (a.endsWith(separator)) {
return a + b2;
}
return a + separator + b2;
}
exports.joinPathSegments = joinPathSegments;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/reader.js
var require_reader = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/reader.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var common = require_common3();
var Reader = class {
constructor(_root, _settings) {
this._root = _root;
this._settings = _settings;
this._root = common.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
}
};
exports.default = Reader;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/async.js
var require_async3 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/async.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var events_1 = require("events");
var fsScandir = require_out2();
var fastq = require_queue();
var common = require_common3();
var reader_1 = require_reader();
var AsyncReader = class extends reader_1.default {
constructor(_root, _settings) {
super(_root, _settings);
this._settings = _settings;
this._scandir = fsScandir.scandir;
this._emitter = new events_1.EventEmitter();
this._queue = fastq(this._worker.bind(this), this._settings.concurrency);
this._isFatalError = false;
this._isDestroyed = false;
this._queue.drain = () => {
if (!this._isFatalError) {
this._emitter.emit("end");
}
};
}
read() {
this._isFatalError = false;
this._isDestroyed = false;
setImmediate(() => {
this._pushToQueue(this._root, this._settings.basePath);
});
return this._emitter;
}
get isDestroyed() {
return this._isDestroyed;
}
destroy() {
if (this._isDestroyed) {
throw new Error("The reader is already destroyed");
}
this._isDestroyed = true;
this._queue.killAndDrain();
}
onEntry(callback) {
this._emitter.on("entry", callback);
}
onError(callback) {
this._emitter.once("error", callback);
}
onEnd(callback) {
this._emitter.once("end", callback);
}
_pushToQueue(directory, base) {
const queueItem = { directory, base };
this._queue.push(queueItem, (error) => {
if (error !== null) {
this._handleError(error);
}
});
}
_worker(item, done) {
this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => {
if (error !== null) {
done(error, void 0);
return;
}
for (const entry of entries) {
this._handleEntry(entry, item.base);
}
done(null, void 0);
});
}
_handleError(error) {
if (this._isDestroyed || !common.isFatalError(this._settings, error)) {
return;
}
this._isFatalError = true;
this._isDestroyed = true;
this._emitter.emit("error", error);
}
_handleEntry(entry, base) {
if (this._isDestroyed || this._isFatalError) {
return;
}
const fullpath = entry.path;
if (base !== void 0) {
entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
}
if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
this._emitEntry(entry);
}
if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
}
}
_emitEntry(entry) {
this._emitter.emit("entry", entry);
}
};
exports.default = AsyncReader;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/providers/async.js
var require_async4 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/providers/async.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var async_1 = require_async3();
var AsyncProvider = class {
constructor(_root, _settings) {
this._root = _root;
this._settings = _settings;
this._reader = new async_1.default(this._root, this._settings);
this._storage = [];
}
read(callback) {
this._reader.onError((error) => {
callFailureCallback(callback, error);
});
this._reader.onEntry((entry) => {
this._storage.push(entry);
});
this._reader.onEnd(() => {
callSuccessCallback(callback, this._storage);
});
this._reader.read();
}
};
exports.default = AsyncProvider;
function callFailureCallback(callback, error) {
callback(error);
}
function callSuccessCallback(callback, entries) {
callback(null, entries);
}
}
});
// ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/providers/stream.js
var require_stream3 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/providers/stream.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var stream_1 = require("stream");
var async_1 = require_async3();
var StreamProvider = class {
constructor(_root, _settings) {
this._root = _root;
this._settings = _settings;
this._reader = new async_1.default(this._root, this._settings);
this._stream = new stream_1.Readable({
objectMode: true,
read: () => {
},
destroy: () => {
if (!this._reader.isDestroyed) {
this._reader.destroy();
}
}
});
}
read() {
this._reader.onError((error) => {
this._stream.emit("error", error);
});
this._reader.onEntry((entry) => {
this._stream.push(entry);
});
this._reader.onEnd(() => {
this._stream.push(null);
});
this._reader.read();
return this._stream;
}
};
exports.default = StreamProvider;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/sync.js
var require_sync3 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/sync.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var fsScandir = require_out2();
var common = require_common3();
var reader_1 = require_reader();
var SyncReader = class extends reader_1.default {
constructor() {
super(...arguments);
this._scandir = fsScandir.scandirSync;
this._storage = [];
this._queue = /* @__PURE__ */ new Set();
}
read() {
this._pushToQueue(this._root, this._settings.basePath);
this._handleQueue();
return this._storage;
}
_pushToQueue(directory, base) {
this._queue.add({ directory, base });
}
_handleQueue() {
for (const item of this._queue.values()) {
this._handleDirectory(item.directory, item.base);
}
}
_handleDirectory(directory, base) {
try {
const entries = this._scandir(directory, this._settings.fsScandirSettings);
for (const entry of entries) {
this._handleEntry(entry, base);
}
} catch (error) {
this._handleError(error);
}
}
_handleError(error) {
if (!common.isFatalError(this._settings, error)) {
return;
}
throw error;
}
_handleEntry(entry, base) {
const fullpath = entry.path;
if (base !== void 0) {
entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
}
if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
this._pushToStorage(entry);
}
if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
}
}
_pushToStorage(entry) {
this._storage.push(entry);
}
};
exports.default = SyncReader;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/providers/sync.js
var require_sync4 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/providers/sync.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var sync_1 = require_sync3();
var SyncProvider = class {
constructor(_root, _settings) {
this._root = _root;
this._settings = _settings;
this._reader = new sync_1.default(this._root, this._settings);
}
read() {
return this._reader.read();
}
};
exports.default = SyncProvider;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/settings.js
var require_settings3 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/settings.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var path7 = require("path");
var fsScandir = require_out2();
var Settings = class {
constructor(_options = {}) {
this._options = _options;
this.basePath = this._getValue(this._options.basePath, void 0);
this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY);
this.deepFilter = this._getValue(this._options.deepFilter, null);
this.entryFilter = this._getValue(this._options.entryFilter, null);
this.errorFilter = this._getValue(this._options.errorFilter, null);
this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path7.sep);
this.fsScandirSettings = new fsScandir.Settings({
followSymbolicLinks: this._options.followSymbolicLinks,
fs: this._options.fs,
pathSegmentSeparator: this._options.pathSegmentSeparator,
stats: this._options.stats,
throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
});
}
_getValue(option, value) {
return option !== null && option !== void 0 ? option : value;
}
};
exports.default = Settings;
}
});
// ../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/index.js
var require_out3 = __commonJS({
"../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Settings = exports.walkStream = exports.walkSync = exports.walk = void 0;
var async_1 = require_async4();
var stream_1 = require_stream3();
var sync_1 = require_sync4();
var settings_1 = require_settings3();
exports.Settings = settings_1.default;
function walk(directory, optionsOrSettingsOrCallback, callback) {
if (typeof optionsOrSettingsOrCallback === "function") {
new async_1.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
return;
}
new async_1.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
}
exports.walk = walk;
function walkSync(directory, optionsOrSettings) {
const settings = getSettings(optionsOrSettings);
const provider = new sync_1.default(directory, settings);
return provider.read();
}
exports.walkSync = walkSync;
function walkStream(directory, optionsOrSettings) {
const settings = getSettings(optionsOrSettings);
const provider = new stream_1.default(directory, settings);
return provider.read();
}
exports.walkStream = walkStream;
function getSettings(settingsOrOptions = {}) {
if (settingsOrOptions instanceof settings_1.default) {
return settingsOrOptions;
}
return new settings_1.default(settingsOrOptions);
}
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/readers/reader.js
var require_reader2 = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/readers/reader.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var path7 = require("path");
var fsStat = require_out();
var utils = require_utils3();
var Reader = class {
constructor(_settings) {
this._settings = _settings;
this._fsStatSettings = new fsStat.Settings({
followSymbolicLink: this._settings.followSymbolicLinks,
fs: this._settings.fs,
throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
});
}
_getFullEntryPath(filepath) {
return path7.resolve(this._settings.cwd, filepath);
}
_makeEntry(stats, pattern) {
const entry = {
name: pattern,
path: pattern,
dirent: utils.fs.createDirentFromStats(pattern, stats)
};
if (this._settings.stats) {
entry.stats = stats;
}
return entry;
}
_isFatalError(error) {
return !utils.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
}
};
exports.default = Reader;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/readers/stream.js
var require_stream4 = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/readers/stream.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var stream_1 = require("stream");
var fsStat = require_out();
var fsWalk = require_out3();
var reader_1 = require_reader2();
var ReaderStream = class extends reader_1.default {
constructor() {
super(...arguments);
this._walkStream = fsWalk.walkStream;
this._stat = fsStat.stat;
}
dynamic(root, options2) {
return this._walkStream(root, options2);
}
static(patterns, options2) {
const filepaths = patterns.map(this._getFullEntryPath, this);
const stream = new stream_1.PassThrough({ objectMode: true });
stream._write = (index, _enc, done) => {
return this._getEntry(filepaths[index], patterns[index], options2).then((entry) => {
if (entry !== null && options2.entryFilter(entry)) {
stream.push(entry);
}
if (index === filepaths.length - 1) {
stream.end();
}
done();
}).catch(done);
};
for (let i = 0; i < filepaths.length; i++) {
stream.write(i);
}
return stream;
}
_getEntry(filepath, pattern, options2) {
return this._getStat(filepath).then((stats) => this._makeEntry(stats, pattern)).catch((error) => {
if (options2.errorFilter(error)) {
return null;
}
throw error;
});
}
_getStat(filepath) {
return new Promise((resolve, reject) => {
this._stat(filepath, this._fsStatSettings, (error, stats) => {
return error === null ? resolve(stats) : reject(error);
});
});
}
};
exports.default = ReaderStream;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/readers/async.js
var require_async5 = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/readers/async.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var fsWalk = require_out3();
var reader_1 = require_reader2();
var stream_1 = require_stream4();
var ReaderAsync = class extends reader_1.default {
constructor() {
super(...arguments);
this._walkAsync = fsWalk.walk;
this._readerStream = new stream_1.default(this._settings);
}
dynamic(root, options2) {
return new Promise((resolve, reject) => {
this._walkAsync(root, options2, (error, entries) => {
if (error === null) {
resolve(entries);
} else {
reject(error);
}
});
});
}
async static(patterns, options2) {
const entries = [];
const stream = this._readerStream.static(patterns, options2);
return new Promise((resolve, reject) => {
stream.once("error", reject);
stream.on("data", (entry) => entries.push(entry));
stream.once("end", () => resolve(entries));
});
}
};
exports.default = ReaderAsync;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/matchers/matcher.js
var require_matcher = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/matchers/matcher.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var utils = require_utils3();
var Matcher = class {
constructor(_patterns, _settings, _micromatchOptions) {
this._patterns = _patterns;
this._settings = _settings;
this._micromatchOptions = _micromatchOptions;
this._storage = [];
this._fillStorage();
}
_fillStorage() {
for (const pattern of this._patterns) {
const segments = this._getPatternSegments(pattern);
const sections = this._splitSegmentsIntoSections(segments);
this._storage.push({
complete: sections.length <= 1,
pattern,
segments,
sections
});
}
}
_getPatternSegments(pattern) {
const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions);
return parts.map((part) => {
const dynamic = utils.pattern.isDynamicPattern(part, this._settings);
if (!dynamic) {
return {
dynamic: false,
pattern: part
};
}
return {
dynamic: true,
pattern: part,
patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
};
});
}
_splitSegmentsIntoSections(segments) {
return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
}
};
exports.default = Matcher;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/matchers/partial.js
var require_partial = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/matchers/partial.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var matcher_1 = require_matcher();
var PartialMatcher = class extends matcher_1.default {
match(filepath) {
const parts = filepath.split("/");
const levels = parts.length;
const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
for (const pattern of patterns) {
const section = pattern.sections[0];
if (!pattern.complete && levels > section.length) {
return true;
}
const match = parts.every((part, index) => {
const segment = pattern.segments[index];
if (segment.dynamic && segment.patternRe.test(part)) {
return true;
}
if (!segment.dynamic && segment.pattern === part) {
return true;
}
return false;
});
if (match) {
return true;
}
}
return false;
}
};
exports.default = PartialMatcher;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/filters/deep.js
var require_deep = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/filters/deep.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var utils = require_utils3();
var partial_1 = require_partial();
var DeepFilter = class {
constructor(_settings, _micromatchOptions) {
this._settings = _settings;
this._micromatchOptions = _micromatchOptions;
}
getFilter(basePath, positive, negative) {
const matcher = this._getMatcher(positive);
const negativeRe = this._getNegativePatternsRe(negative);
return (entry) => this._filter(basePath, entry, matcher, negativeRe);
}
_getMatcher(patterns) {
return new partial_1.default(patterns, this._settings, this._micromatchOptions);
}
_getNegativePatternsRe(patterns) {
const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
}
_filter(basePath, entry, matcher, negativeRe) {
if (this._isSkippedByDeep(basePath, entry.path)) {
return false;
}
if (this._isSkippedSymbolicLink(entry)) {
return false;
}
const filepath = utils.path.removeLeadingDotSegment(entry.path);
if (this._isSkippedByPositivePatterns(filepath, matcher)) {
return false;
}
return this._isSkippedByNegativePatterns(filepath, negativeRe);
}
_isSkippedByDeep(basePath, entryPath) {
if (this._settings.deep === Infinity) {
return false;
}
return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
}
_getEntryLevel(basePath, entryPath) {
const entryPathDepth = entryPath.split("/").length;
if (basePath === "") {
return entryPathDepth;
}
const basePathDepth = basePath.split("/").length;
return entryPathDepth - basePathDepth;
}
_isSkippedSymbolicLink(entry) {
return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
}
_isSkippedByPositivePatterns(entryPath, matcher) {
return !this._settings.baseNameMatch && !matcher.match(entryPath);
}
_isSkippedByNegativePatterns(entryPath, patternsRe) {
return !utils.pattern.matchAny(entryPath, patternsRe);
}
};
exports.default = DeepFilter;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/filters/entry.js
var require_entry = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/filters/entry.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var utils = require_utils3();
var EntryFilter = class {
constructor(_settings, _micromatchOptions) {
this._settings = _settings;
this._micromatchOptions = _micromatchOptions;
this.index = /* @__PURE__ */ new Map();
}
getFilter(positive, negative) {
const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions);
const negativeRe = utils.pattern.convertPatternsToRe(negative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true }));
return (entry) => this._filter(entry, positiveRe, negativeRe);
}
_filter(entry, positiveRe, negativeRe) {
const filepath = utils.path.removeLeadingDotSegment(entry.path);
if (this._settings.unique && this._isDuplicateEntry(filepath)) {
return false;
}
if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
return false;
}
if (this._isSkippedByAbsoluteNegativePatterns(filepath, negativeRe)) {
return false;
}
const isDirectory = entry.dirent.isDirectory();
const isMatched = this._isMatchToPatterns(filepath, positiveRe, isDirectory) && !this._isMatchToPatterns(filepath, negativeRe, isDirectory);
if (this._settings.unique && isMatched) {
this._createIndexRecord(filepath);
}
return isMatched;
}
_isDuplicateEntry(filepath) {
return this.index.has(filepath);
}
_createIndexRecord(filepath) {
this.index.set(filepath, void 0);
}
_onlyFileFilter(entry) {
return this._settings.onlyFiles && !entry.dirent.isFile();
}
_onlyDirectoryFilter(entry) {
return this._settings.onlyDirectories && !entry.dirent.isDirectory();
}
_isSkippedByAbsoluteNegativePatterns(entryPath, patternsRe) {
if (!this._settings.absolute) {
return false;
}
const fullpath = utils.path.makeAbsolute(this._settings.cwd, entryPath);
return utils.pattern.matchAny(fullpath, patternsRe);
}
_isMatchToPatterns(filepath, patternsRe, isDirectory) {
const isMatched = utils.pattern.matchAny(filepath, patternsRe);
if (!isMatched && isDirectory) {
return utils.pattern.matchAny(filepath + "/", patternsRe);
}
return isMatched;
}
};
exports.default = EntryFilter;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/filters/error.js
var require_error2 = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/filters/error.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var utils = require_utils3();
var ErrorFilter = class {
constructor(_settings) {
this._settings = _settings;
}
getFilter() {
return (error) => this._isNonFatalError(error);
}
_isNonFatalError(error) {
return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
}
};
exports.default = ErrorFilter;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/transformers/entry.js
var require_entry2 = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/transformers/entry.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var utils = require_utils3();
var EntryTransformer = class {
constructor(_settings) {
this._settings = _settings;
}
getTransformer() {
return (entry) => this._transform(entry);
}
_transform(entry) {
let filepath = entry.path;
if (this._settings.absolute) {
filepath = utils.path.makeAbsolute(this._settings.cwd, filepath);
filepath = utils.path.unixify(filepath);
}
if (this._settings.markDirectories && entry.dirent.isDirectory()) {
filepath += "/";
}
if (!this._settings.objectMode) {
return filepath;
}
return Object.assign(Object.assign({}, entry), { path: filepath });
}
};
exports.default = EntryTransformer;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/provider.js
var require_provider = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/provider.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var path7 = require("path");
var deep_1 = require_deep();
var entry_1 = require_entry();
var error_1 = require_error2();
var entry_2 = require_entry2();
var Provider = class {
constructor(_settings) {
this._settings = _settings;
this.errorFilter = new error_1.default(this._settings);
this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
this.entryTransformer = new entry_2.default(this._settings);
}
_getRootDirectory(task) {
return path7.resolve(this._settings.cwd, task.base);
}
_getReaderOptions(task) {
const basePath = task.base === "." ? "" : task.base;
return {
basePath,
pathSegmentSeparator: "/",
concurrency: this._settings.concurrency,
deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
errorFilter: this.errorFilter.getFilter(),
followSymbolicLinks: this._settings.followSymbolicLinks,
fs: this._settings.fs,
stats: this._settings.stats,
throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
transform: this.entryTransformer.getTransformer()
};
}
_getMicromatchOptions() {
return {
dot: this._settings.dot,
matchBase: this._settings.baseNameMatch,
nobrace: !this._settings.braceExpansion,
nocase: !this._settings.caseSensitiveMatch,
noext: !this._settings.extglob,
noglobstar: !this._settings.globstar,
posix: true,
strictSlashes: false
};
}
};
exports.default = Provider;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/async.js
var require_async6 = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/async.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var async_1 = require_async5();
var provider_1 = require_provider();
var ProviderAsync = class extends provider_1.default {
constructor() {
super(...arguments);
this._reader = new async_1.default(this._settings);
}
async read(task) {
const root = this._getRootDirectory(task);
const options2 = this._getReaderOptions(task);
const entries = await this.api(root, task, options2);
return entries.map((entry) => options2.transform(entry));
}
api(root, task, options2) {
if (task.dynamic) {
return this._reader.dynamic(root, options2);
}
return this._reader.static(task.patterns, options2);
}
};
exports.default = ProviderAsync;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/stream.js
var require_stream5 = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/stream.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var stream_1 = require("stream");
var stream_2 = require_stream4();
var provider_1 = require_provider();
var ProviderStream = class extends provider_1.default {
constructor() {
super(...arguments);
this._reader = new stream_2.default(this._settings);
}
read(task) {
const root = this._getRootDirectory(task);
const options2 = this._getReaderOptions(task);
const source = this.api(root, task, options2);
const destination = new stream_1.Readable({ objectMode: true, read: () => {
} });
source.once("error", (error) => destination.emit("error", error)).on("data", (entry) => destination.emit("data", options2.transform(entry))).once("end", () => destination.emit("end"));
destination.once("close", () => source.destroy());
return destination;
}
api(root, task, options2) {
if (task.dynamic) {
return this._reader.dynamic(root, options2);
}
return this._reader.static(task.patterns, options2);
}
};
exports.default = ProviderStream;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/readers/sync.js
var require_sync5 = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/readers/sync.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var fsStat = require_out();
var fsWalk = require_out3();
var reader_1 = require_reader2();
var ReaderSync = class extends reader_1.default {
constructor() {
super(...arguments);
this._walkSync = fsWalk.walkSync;
this._statSync = fsStat.statSync;
}
dynamic(root, options2) {
return this._walkSync(root, options2);
}
static(patterns, options2) {
const entries = [];
for (const pattern of patterns) {
const filepath = this._getFullEntryPath(pattern);
const entry = this._getEntry(filepath, pattern, options2);
if (entry === null || !options2.entryFilter(entry)) {
continue;
}
entries.push(entry);
}
return entries;
}
_getEntry(filepath, pattern, options2) {
try {
const stats = this._getStat(filepath);
return this._makeEntry(stats, pattern);
} catch (error) {
if (options2.errorFilter(error)) {
return null;
}
throw error;
}
}
_getStat(filepath) {
return this._statSync(filepath, this._fsStatSettings);
}
};
exports.default = ReaderSync;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/sync.js
var require_sync6 = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/providers/sync.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var sync_1 = require_sync5();
var provider_1 = require_provider();
var ProviderSync = class extends provider_1.default {
constructor() {
super(...arguments);
this._reader = new sync_1.default(this._settings);
}
read(task) {
const root = this._getRootDirectory(task);
const options2 = this._getReaderOptions(task);
const entries = this.api(root, task, options2);
return entries.map(options2.transform);
}
api(root, task, options2) {
if (task.dynamic) {
return this._reader.dynamic(root, options2);
}
return this._reader.static(task.patterns, options2);
}
};
exports.default = ProviderSync;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/settings.js
var require_settings4 = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/settings.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
var fs10 = require("fs");
var os4 = require("os");
var CPU_COUNT = Math.max(os4.cpus().length, 1);
exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
lstat: fs10.lstat,
lstatSync: fs10.lstatSync,
stat: fs10.stat,
statSync: fs10.statSync,
readdir: fs10.readdir,
readdirSync: fs10.readdirSync
};
var Settings = class {
constructor(_options = {}) {
this._options = _options;
this.absolute = this._getValue(this._options.absolute, false);
this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
this.braceExpansion = this._getValue(this._options.braceExpansion, true);
this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);
this.cwd = this._getValue(this._options.cwd, process.cwd());
this.deep = this._getValue(this._options.deep, Infinity);
this.dot = this._getValue(this._options.dot, false);
this.extglob = this._getValue(this._options.extglob, true);
this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
this.fs = this._getFileSystemMethods(this._options.fs);
this.globstar = this._getValue(this._options.globstar, true);
this.ignore = this._getValue(this._options.ignore, []);
this.markDirectories = this._getValue(this._options.markDirectories, false);
this.objectMode = this._getValue(this._options.objectMode, false);
this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
this.onlyFiles = this._getValue(this._options.onlyFiles, true);
this.stats = this._getValue(this._options.stats, false);
this.suppressErrors = this._getValue(this._options.suppressErrors, false);
this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
this.unique = this._getValue(this._options.unique, true);
if (this.onlyDirectories) {
this.onlyFiles = false;
}
if (this.stats) {
this.objectMode = true;
}
}
_getValue(option, value) {
return option === void 0 ? value : option;
}
_getFileSystemMethods(methods = {}) {
return Object.assign(Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER), methods);
}
};
exports.default = Settings;
}
});
// ../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/index.js
var require_out4 = __commonJS({
"../../node_modules/.pnpm/fast-glob@3.3.0/node_modules/fast-glob/out/index.js"(exports, module2) {
"use strict";
var taskManager = require_tasks();
var async_1 = require_async6();
var stream_1 = require_stream5();
var sync_1 = require_sync6();
var settings_1 = require_settings4();
var utils = require_utils3();
async function FastGlob(source, options2) {
assertPatternsInput(source);
const works = getWorks(source, async_1.default, options2);
const result = await Promise.all(works);
return utils.array.flatten(result);
}
(function(FastGlob2) {
FastGlob2.glob = FastGlob2;
FastGlob2.globSync = sync;
FastGlob2.globStream = stream;
FastGlob2.async = FastGlob2;
function sync(source, options2) {
assertPatternsInput(source);
const works = getWorks(source, sync_1.default, options2);
return utils.array.flatten(works);
}
FastGlob2.sync = sync;
function stream(source, options2) {
assertPatternsInput(source);
const works = getWorks(source, stream_1.default, options2);
return utils.stream.merge(works);
}
FastGlob2.stream = stream;
function generateTasks(source, options2) {
assertPatternsInput(source);
const patterns = [].concat(source);
const settings = new settings_1.default(options2);
return taskManager.generate(patterns, settings);
}
FastGlob2.generateTasks = generateTasks;
function isDynamicPattern(source, options2) {
assertPatternsInput(source);
const settings = new settings_1.default(options2);
return utils.pattern.isDynamicPattern(source, settings);
}
FastGlob2.isDynamicPattern = isDynamicPattern;
function escapePath(source) {
assertPatternsInput(source);
return utils.path.escape(source);
}
FastGlob2.escapePath = escapePath;
function convertPathToPattern(source) {
assertPatternsInput(source);
return utils.path.convertPathToPattern(source);
}
FastGlob2.convertPathToPattern = convertPathToPattern;
let posix;
(function(posix2) {
function escapePath2(source) {
assertPatternsInput(source);
return utils.path.escapePosixPath(source);
}
posix2.escapePath = escapePath2;
function convertPathToPattern2(source) {
assertPatternsInput(source);
return utils.path.convertPosixPathToPattern(source);
}
posix2.convertPathToPattern = convertPathToPattern2;
})(posix = FastGlob2.posix || (FastGlob2.posix = {}));
let win32;
(function(win322) {
function escapePath2(source) {
assertPatternsInput(source);
return utils.path.escapeWindowsPath(source);
}
win322.escapePath = escapePath2;
function convertPathToPattern2(source) {
assertPatternsInput(source);
return utils.path.convertWindowsPathToPattern(source);
}
win322.convertPathToPattern = convertPathToPattern2;
})(win32 = FastGlob2.win32 || (FastGlob2.win32 = {}));
})(FastGlob || (FastGlob = {}));
function getWorks(source, _Provider, options2) {
const patterns = [].concat(source);
const settings = new settings_1.default(options2);
const tasks = taskManager.generate(patterns, settings);
const provider = new _Provider(settings);
return tasks.map(provider.read, provider);
}
function assertPatternsInput(input) {
const source = [].concat(input);
const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
if (!isValidSource) {
throw new TypeError("Patterns must be a string (non empty) or an array of strings");
}
}
module2.exports = FastGlob;
}
});
// ../../node_modules/.pnpm/path-type@4.0.0/node_modules/path-type/index.js
var require_path_type = __commonJS({
"../../node_modules/.pnpm/path-type@4.0.0/node_modules/path-type/index.js"(exports) {
"use strict";
var { promisify: promisify5 } = require("util");
var fs10 = require("fs");
async function isType(fsStatType, statsMethodName, filePath) {
if (typeof filePath !== "string") {
throw new TypeError(`Expected a string, got ${typeof filePath}`);
}
try {
const stats = await promisify5(fs10[fsStatType])(filePath);
return stats[statsMethodName]();
} catch (error) {
if (error.code === "ENOENT") {
return false;
}
throw error;
}
}
function isTypeSync(fsStatType, statsMethodName, filePath) {
if (typeof filePath !== "string") {
throw new TypeError(`Expected a string, got ${typeof filePath}`);
}
try {
return fs10[fsStatType](filePath)[statsMethodName]();
} catch (error) {
if (error.code === "ENOENT") {
return false;
}
throw error;
}
}
exports.isFile = isType.bind(null, "stat", "isFile");
exports.isDirectory = isType.bind(null, "stat", "isDirectory");
exports.isSymlink = isType.bind(null, "lstat", "isSymbolicLink");
exports.isFileSync = isTypeSync.bind(null, "statSync", "isFile");
exports.isDirectorySync = isTypeSync.bind(null, "statSync", "isDirectory");
exports.isSymlinkSync = isTypeSync.bind(null, "lstatSync", "isSymbolicLink");
}
});
// ../../node_modules/.pnpm/dir-glob@3.0.1/node_modules/dir-glob/index.js
var require_dir_glob = __commonJS({
"../../node_modules/.pnpm/dir-glob@3.0.1/node_modules/dir-glob/index.js"(exports, module2) {
"use strict";
var path7 = require("path");
var pathType = require_path_type();
var getExtensions = (extensions) => extensions.length > 1 ? `{${extensions.join(",")}}` : extensions[0];
var getPath = (filepath, cwd) => {
const pth = filepath[0] === "!" ? filepath.slice(1) : filepath;
return path7.isAbsolute(pth) ? pth : path7.join(cwd, pth);
};
var addExtensions = (file2, extensions) => {
if (path7.extname(file2)) {
return `**/${file2}`;
}
return `**/${file2}.${getExtensions(extensions)}`;
};
var getGlob = (directory, options2) => {
if (options2.files && !Array.isArray(options2.files)) {
throw new TypeError(`Expected \`files\` to be of type \`Array\` but received type \`${typeof options2.files}\``);
}
if (options2.extensions && !Array.isArray(options2.extensions)) {
throw new TypeError(`Expected \`extensions\` to be of type \`Array\` but received type \`${typeof options2.extensions}\``);
}
if (options2.files && options2.extensions) {
return options2.files.map((x) => path7.posix.join(directory, addExtensions(x, options2.extensions)));
}
if (options2.files) {
return options2.files.map((x) => path7.posix.join(directory, `**/${x}`));
}
if (options2.extensions) {
return [path7.posix.join(directory, `**/*.${getExtensions(options2.extensions)}`)];
}
return [path7.posix.join(directory, "**")];
};
module2.exports = async (input, options2) => {
options2 = {
cwd: process.cwd(),
...options2
};
if (typeof options2.cwd !== "string") {
throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options2.cwd}\``);
}
const globs = await Promise.all([].concat(input).map(async (x) => {
const isDirectory = await pathType.isDirectory(getPath(x, options2.cwd));
return isDirectory ? getGlob(x, options2) : x;
}));
return [].concat.apply([], globs);
};
module2.exports.sync = (input, options2) => {
options2 = {
cwd: process.cwd(),
...options2
};
if (typeof options2.cwd !== "string") {
throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options2.cwd}\``);
}
const globs = [].concat(input).map((x) => pathType.isDirectorySync(getPath(x, options2.cwd)) ? getGlob(x, options2) : x);
return [].concat.apply([], globs);
};
}
});
// ../../node_modules/.pnpm/ignore@5.2.4/node_modules/ignore/index.js
var require_ignore = __commonJS({
"../../node_modules/.pnpm/ignore@5.2.4/node_modules/ignore/index.js"(exports, module2) {
function makeArray(subject) {
return Array.isArray(subject) ? subject : [subject];
}
var EMPTY = "";
var SPACE = " ";
var ESCAPE = "\\";
var REGEX_TEST_BLANK_LINE = /^\s+$/;
var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
var REGEX_SPLITALL_CRLF = /\r?\n/g;
var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
var SLASH = "/";
var TMP_KEY_IGNORE = "node-ignore";
if (typeof Symbol !== "undefined") {
TMP_KEY_IGNORE = Symbol.for("node-ignore");
}
var KEY_IGNORE = TMP_KEY_IGNORE;
var define = (object, key, value) => Object.defineProperty(object, key, { value });
var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
var RETURN_FALSE = () => false;
var sanitizeRange = (range) => range.replace(
REGEX_REGEXP_RANGE,
(match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
);
var cleanRangeBackSlash = (slashes) => {
const { length } = slashes;
return slashes.slice(0, length - length % 2);
};
var REPLACERS = [
[
/\\?\s+$/,
(match) => match.indexOf("\\") === 0 ? SPACE : EMPTY
],
[
/\\\s/g,
() => SPACE
],
[
/[\\$.|*+(){^]/g,
(match) => `\\${match}`
],
[
/(?!\\)\?/g,
() => "[^/]"
],
[
/^\//,
() => "^"
],
[
/\//g,
() => "\\/"
],
[
/^\^*\\\*\\\*\\\//,
() => "^(?:.*\\/)?"
],
[
/^(?=[^^])/,
function startingReplacer() {
return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
}
],
[
/\\\/\\\*\\\*(?=\\\/|$)/g,
(_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
],
[
/(^|[^\\]+)(\\\*)+(?=.+)/g,
(_, p1, p2) => {
const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
return p1 + unescaped;
}
],
[
/\\\\\\(?=[$.|*+(){^])/g,
() => ESCAPE
],
[
/\\\\/g,
() => ESCAPE
],
[
/(\\)?\[([^\]/]*?)(\\*)($|\])/g,
(match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
],
[
/(?:[^*])$/,
(match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
],
[
/(\^|\\\/)?\\\*$/,
(_, p1) => {
const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
return `${prefix}(?=$|\\/$)`;
}
]
];
var regexCache = /* @__PURE__ */ Object.create(null);
var makeRegex = (pattern, ignoreCase) => {
let source = regexCache[pattern];
if (!source) {
source = REPLACERS.reduce(
(prev, current) => prev.replace(current[0], current[1].bind(pattern)),
pattern
);
regexCache[pattern] = source;
}
return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
};
var isString = (subject) => typeof subject === "string";
var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
var IgnoreRule = class {
constructor(origin, pattern, negative, regex) {
this.origin = origin;
this.pattern = pattern;
this.negative = negative;
this.regex = regex;
}
};
var createRule = (pattern, ignoreCase) => {
const origin = pattern;
let negative = false;
if (pattern.indexOf("!") === 0) {
negative = true;
pattern = pattern.substr(1);
}
pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
const regex = makeRegex(pattern, ignoreCase);
return new IgnoreRule(
origin,
pattern,
negative,
regex
);
};
var throwError = (message, Ctor) => {
throw new Ctor(message);
};
var checkPath = (path7, originalPath, doThrow) => {
if (!isString(path7)) {
return doThrow(
`path must be a string, but got \`${originalPath}\``,
TypeError
);
}
if (!path7) {
return doThrow(`path must not be empty`, TypeError);
}
if (checkPath.isNotRelative(path7)) {
const r2 = "`path.relative()`d";
return doThrow(
`path should be a ${r2} string, but got "${originalPath}"`,
RangeError
);
}
return true;
};
var isNotRelative = (path7) => REGEX_TEST_INVALID_PATH.test(path7);
checkPath.isNotRelative = isNotRelative;
checkPath.convert = (p2) => p2;
var Ignore = class {
constructor({
ignorecase = true,
ignoreCase = ignorecase,
allowRelativePaths = false
} = {}) {
define(this, KEY_IGNORE, true);
this._rules = [];
this._ignoreCase = ignoreCase;
this._allowRelativePaths = allowRelativePaths;
this._initCache();
}
_initCache() {
this._ignoreCache = /* @__PURE__ */ Object.create(null);
this._testCache = /* @__PURE__ */ Object.create(null);
}
_addPattern(pattern) {
if (pattern && pattern[KEY_IGNORE]) {
this._rules = this._rules.concat(pattern._rules);
this._added = true;
return;
}
if (checkPattern(pattern)) {
const rule = createRule(pattern, this._ignoreCase);
this._added = true;
this._rules.push(rule);
}
}
add(pattern) {
this._added = false;
makeArray(
isString(pattern) ? splitPattern(pattern) : pattern
).forEach(this._addPattern, this);
if (this._added) {
this._initCache();
}
return this;
}
addPattern(pattern) {
return this.add(pattern);
}
_testOne(path7, checkUnignored) {
let ignored = false;
let unignored = false;
this._rules.forEach((rule) => {
const { negative } = rule;
if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
return;
}
const matched = rule.regex.test(path7);
if (matched) {
ignored = !negative;
unignored = negative;
}
});
return {
ignored,
unignored
};
}
_test(originalPath, cache, checkUnignored, slices) {
const path7 = originalPath && checkPath.convert(originalPath);
checkPath(
path7,
originalPath,
this._allowRelativePaths ? RETURN_FALSE : throwError
);
return this._t(path7, cache, checkUnignored, slices);
}
_t(path7, cache, checkUnignored, slices) {
if (path7 in cache) {
return cache[path7];
}
if (!slices) {
slices = path7.split(SLASH);
}
slices.pop();
if (!slices.length) {
return cache[path7] = this._testOne(path7, checkUnignored);
}
const parent = this._t(
slices.join(SLASH) + SLASH,
cache,
checkUnignored,
slices
);
return cache[path7] = parent.ignored ? parent : this._testOne(path7, checkUnignored);
}
ignores(path7) {
return this._test(path7, this._ignoreCache, false).ignored;
}
createFilter() {
return (path7) => !this.ignores(path7);
}
filter(paths) {
return makeArray(paths).filter(this.createFilter());
}
test(path7) {
return this._test(path7, this._testCache, true);
}
};
var factory = (options2) => new Ignore(options2);
var isPathValid = (path7) => checkPath(path7 && checkPath.convert(path7), path7, RETURN_FALSE);
factory.isPathValid = isPathValid;
factory.default = factory;
module2.exports = factory;
if (typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")) {
const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
checkPath.convert = makePosix;
const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
checkPath.isNotRelative = (path7) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path7) || isNotRelative(path7);
}
}
});
// ../../node_modules/.pnpm/slash@3.0.0/node_modules/slash/index.js
var require_slash = __commonJS({
"../../node_modules/.pnpm/slash@3.0.0/node_modules/slash/index.js"(exports, module2) {
"use strict";
module2.exports = (path7) => {
const isExtendedLengthPath = /^\\\\\?\\/.test(path7);
const hasNonAscii = /[^\u0000-\u0080]+/.test(path7);
if (isExtendedLengthPath || hasNonAscii) {
return path7;
}
return path7.replace(/\\/g, "/");
};
}
});
// ../../node_modules/.pnpm/globby@11.1.0/node_modules/globby/gitignore.js
var require_gitignore = __commonJS({
"../../node_modules/.pnpm/globby@11.1.0/node_modules/globby/gitignore.js"(exports, module2) {
"use strict";
var { promisify: promisify5 } = require("util");
var fs10 = require("fs");
var path7 = require("path");
var fastGlob = require_out4();
var gitIgnore = require_ignore();
var slash = require_slash();
var DEFAULT_IGNORE = [
"**/node_modules/**",
"**/flow-typed/**",
"**/coverage/**",
"**/.git"
];
var readFileP = promisify5(fs10.readFile);
var mapGitIgnorePatternTo = (base) => (ignore) => {
if (ignore.startsWith("!")) {
return "!" + path7.posix.join(base, ignore.slice(1));
}
return path7.posix.join(base, ignore);
};
var parseGitIgnore = (content, options2) => {
const base = slash(path7.relative(options2.cwd, path7.dirname(options2.fileName)));
return content.split(/\r?\n/).filter(Boolean).filter((line) => !line.startsWith("#")).map(mapGitIgnorePatternTo(base));
};
var reduceIgnore = (files) => {
const ignores = gitIgnore();
for (const file2 of files) {
ignores.add(parseGitIgnore(file2.content, {
cwd: file2.cwd,
fileName: file2.filePath
}));
}
return ignores;
};
var ensureAbsolutePathForCwd = (cwd, p2) => {
cwd = slash(cwd);
if (path7.isAbsolute(p2)) {
if (slash(p2).startsWith(cwd)) {
return p2;
}
throw new Error(`Path ${p2} is not in cwd ${cwd}`);
}
return path7.join(cwd, p2);
};
var getIsIgnoredPredecate = (ignores, cwd) => {
return (p2) => ignores.ignores(slash(path7.relative(cwd, ensureAbsolutePathForCwd(cwd, p2.path || p2))));
};
var getFile = async (file2, cwd) => {
const filePath = path7.join(cwd, file2);
const content = await readFileP(filePath, "utf8");
return {
cwd,
filePath,
content
};
};
var getFileSync = (file2, cwd) => {
const filePath = path7.join(cwd, file2);
const content = fs10.readFileSync(filePath, "utf8");
return {
cwd,
filePath,
content
};
};
var normalizeOptions = ({
ignore = [],
cwd = slash(process.cwd())
} = {}) => {
return { ignore, cwd };
};
module2.exports = async (options2) => {
options2 = normalizeOptions(options2);
const paths = await fastGlob("**/.gitignore", {
ignore: DEFAULT_IGNORE.concat(options2.ignore),
cwd: options2.cwd
});
const files = await Promise.all(paths.map((file2) => getFile(file2, options2.cwd)));
const ignores = reduceIgnore(files);
return getIsIgnoredPredecate(ignores, options2.cwd);
};
module2.exports.sync = (options2) => {
options2 = normalizeOptions(options2);
const paths = fastGlob.sync("**/.gitignore", {
ignore: DEFAULT_IGNORE.concat(options2.ignore),
cwd: options2.cwd
});
const files = paths.map((file2) => getFileSync(file2, options2.cwd));
const ignores = reduceIgnore(files);
return getIsIgnoredPredecate(ignores, options2.cwd);
};
}
});
// ../../node_modules/.pnpm/globby@11.1.0/node_modules/globby/stream-utils.js
var require_stream_utils = __commonJS({
"../../node_modules/.pnpm/globby@11.1.0/node_modules/globby/stream-utils.js"(exports, module2) {
"use strict";
var { Transform } = require("stream");
var ObjectTransform = class extends Transform {
constructor() {
super({
objectMode: true
});
}
};
var FilterStream = class extends ObjectTransform {
constructor(filter) {
super();
this._filter = filter;
}
_transform(data, encoding, callback) {
if (this._filter(data)) {
this.push(data);
}
callback();
}
};
var UniqueStream = class extends ObjectTransform {
constructor() {
super();
this._pushed = /* @__PURE__ */ new Set();
}
_transform(data, encoding, callback) {
if (!this._pushed.has(data)) {
this.push(data);
this._pushed.add(data);
}
callback();
}
};
module2.exports = {
FilterStream,
UniqueStream
};
}
});
// ../../node_modules/.pnpm/globby@11.1.0/node_modules/globby/index.js
var require_globby = __commonJS({
"../../node_modules/.pnpm/globby@11.1.0/node_modules/globby/index.js"(exports, module2) {
"use strict";
var fs10 = require("fs");
var arrayUnion = require_array_union();
var merge2 = require_merge2();
var fastGlob = require_out4();
var dirGlob = require_dir_glob();
var gitignore = require_gitignore();
var { FilterStream, UniqueStream } = require_stream_utils();
var DEFAULT_FILTER = () => false;
var isNegative = (pattern) => pattern[0] === "!";
var assertPatternsInput = (patterns) => {
if (!patterns.every((pattern) => typeof pattern === "string")) {
throw new TypeError("Patterns must be a string or an array of strings");
}
};
var checkCwdOption = (options2 = {}) => {
if (!options2.cwd) {
return;
}
let stat;
try {
stat = fs10.statSync(options2.cwd);
} catch {
return;
}
if (!stat.isDirectory()) {
throw new Error("The `cwd` option must be a path to a directory");
}
};
var getPathString = (p2) => p2.stats instanceof fs10.Stats ? p2.path : p2;
var generateGlobTasks = (patterns, taskOptions) => {
patterns = arrayUnion([].concat(patterns));
assertPatternsInput(patterns);
checkCwdOption(taskOptions);
const globTasks = [];
taskOptions = {
ignore: [],
expandDirectories: true,
...taskOptions
};
for (const [index, pattern] of patterns.entries()) {
if (isNegative(pattern)) {
continue;
}
const ignore = patterns.slice(index).filter((pattern2) => isNegative(pattern2)).map((pattern2) => pattern2.slice(1));
const options2 = {
...taskOptions,
ignore: taskOptions.ignore.concat(ignore)
};
globTasks.push({ pattern, options: options2 });
}
return globTasks;
};
var globDirs = (task, fn) => {
let options2 = {};
if (task.options.cwd) {
options2.cwd = task.options.cwd;
}
if (Array.isArray(task.options.expandDirectories)) {
options2 = {
...options2,
files: task.options.expandDirectories
};
} else if (typeof task.options.expandDirectories === "object") {
options2 = {
...options2,
...task.options.expandDirectories
};
}
return fn(task.pattern, options2);
};
var getPattern = (task, fn) => task.options.expandDirectories ? globDirs(task, fn) : [task.pattern];
var getFilterSync = (options2) => {
return options2 && options2.gitignore ? gitignore.sync({ cwd: options2.cwd, ignore: options2.ignore }) : DEFAULT_FILTER;
};
var globToTask = (task) => (glob) => {
const { options: options2 } = task;
if (options2.ignore && Array.isArray(options2.ignore) && options2.expandDirectories) {
options2.ignore = dirGlob.sync(options2.ignore);
}
return {
pattern: glob,
options: options2
};
};
module2.exports = async (patterns, options2) => {
const globTasks = generateGlobTasks(patterns, options2);
const getFilter = async () => {
return options2 && options2.gitignore ? gitignore({ cwd: options2.cwd, ignore: options2.ignore }) : DEFAULT_FILTER;
};
const getTasks = async () => {
const tasks2 = await Promise.all(globTasks.map(async (task) => {
const globs = await getPattern(task, dirGlob);
return Promise.all(globs.map(globToTask(task)));
}));
return arrayUnion(...tasks2);
};
const [filter, tasks] = await Promise.all([getFilter(), getTasks()]);
const paths = await Promise.all(tasks.map((task) => fastGlob(task.pattern, task.options)));
return arrayUnion(...paths).filter((path_) => !filter(getPathString(path_)));
};
module2.exports.sync = (patterns, options2) => {
const globTasks = generateGlobTasks(patterns, options2);
const tasks = [];
for (const task of globTasks) {
const newTask = getPattern(task, dirGlob.sync).map(globToTask(task));
tasks.push(...newTask);
}
const filter = getFilterSync(options2);
let matches = [];
for (const task of tasks) {
matches = arrayUnion(matches, fastGlob.sync(task.pattern, task.options));
}
return matches.filter((path_) => !filter(path_));
};
module2.exports.stream = (patterns, options2) => {
const globTasks = generateGlobTasks(patterns, options2);
const tasks = [];
for (const task of globTasks) {
const newTask = getPattern(task, dirGlob.sync).map(globToTask(task));
tasks.push(...newTask);
}
const filter = getFilterSync(options2);
const filterStream = new FilterStream((p2) => !filter(p2));
const uniqueStream = new UniqueStream();
return merge2(tasks.map((task) => fastGlob.stream(task.pattern, task.options))).pipe(filterStream).pipe(uniqueStream);
};
module2.exports.generateGlobTasks = generateGlobTasks;
module2.exports.hasMagic = (patterns, options2) => [].concat(patterns).some((pattern) => fastGlob.isDynamicPattern(pattern, options2));
module2.exports.gitignore = gitignore;
}
});
// ../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/polyfills.js
var require_polyfills = __commonJS({
"../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/polyfills.js"(exports, module2) {
var constants = require("constants");
var origCwd = process.cwd;
var cwd = null;
var platform2 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
process.cwd = function() {
if (!cwd)
cwd = origCwd.call(process);
return cwd;
};
try {
process.cwd();
} catch (er) {
}
if (typeof process.chdir === "function") {
chdir = process.chdir;
process.chdir = function(d2) {
cwd = null;
chdir.call(process, d2);
};
if (Object.setPrototypeOf)
Object.setPrototypeOf(process.chdir, chdir);
}
var chdir;
module2.exports = patch;
function patch(fs10) {
if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
patchLchmod(fs10);
}
if (!fs10.lutimes) {
patchLutimes(fs10);
}
fs10.chown = chownFix(fs10.chown);
fs10.fchown = chownFix(fs10.fchown);
fs10.lchown = chownFix(fs10.lchown);
fs10.chmod = chmodFix(fs10.chmod);
fs10.fchmod = chmodFix(fs10.fchmod);
fs10.lchmod = chmodFix(fs10.lchmod);
fs10.chownSync = chownFixSync(fs10.chownSync);
fs10.fchownSync = chownFixSync(fs10.fchownSync);
fs10.lchownSync = chownFixSync(fs10.lchownSync);
fs10.chmodSync = chmodFixSync(fs10.chmodSync);
fs10.fchmodSync = chmodFixSync(fs10.fchmodSync);
fs10.lchmodSync = chmodFixSync(fs10.lchmodSync);
fs10.stat = statFix(fs10.stat);
fs10.fstat = statFix(fs10.fstat);
fs10.lstat = statFix(fs10.lstat);
fs10.statSync = statFixSync(fs10.statSync);
fs10.fstatSync = statFixSync(fs10.fstatSync);
fs10.lstatSync = statFixSync(fs10.lstatSync);
if (fs10.chmod && !fs10.lchmod) {
fs10.lchmod = function(path7, mode, cb) {
if (cb)
process.nextTick(cb);
};
fs10.lchmodSync = function() {
};
}
if (fs10.chown && !fs10.lchown) {
fs10.lchown = function(path7, uid, gid, cb) {
if (cb)
process.nextTick(cb);
};
fs10.lchownSync = function() {
};
}
if (platform2 === "win32") {
fs10.rename = typeof fs10.rename !== "function" ? fs10.rename : function(fs$rename) {
function rename(from, to, cb) {
var start = Date.now();
var backoff = 0;
fs$rename(from, to, function CB(er) {
if (er && (er.code === "EACCES" || er.code === "EPERM") && Date.now() - start < 6e4) {
setTimeout(function() {
fs10.stat(to, function(stater, st) {
if (stater && stater.code === "ENOENT")
fs$rename(from, to, CB);
else
cb(er);
});
}, backoff);
if (backoff < 100)
backoff += 10;
return;
}
if (cb)
cb(er);
});
}
if (Object.setPrototypeOf)
Object.setPrototypeOf(rename, fs$rename);
return rename;
}(fs10.rename);
}
fs10.read = typeof fs10.read !== "function" ? fs10.read : function(fs$read) {
function read(fd, buffer, offset, length, position, callback_) {
var callback;
if (callback_ && typeof callback_ === "function") {
var eagCounter = 0;
callback = function(er, _, __) {
if (er && er.code === "EAGAIN" && eagCounter < 10) {
eagCounter++;
return fs$read.call(fs10, fd, buffer, offset, length, position, callback);
}
callback_.apply(this, arguments);
};
}
return fs$read.call(fs10, fd, buffer, offset, length, position, callback);
}
if (Object.setPrototypeOf)
Object.setPrototypeOf(read, fs$read);
return read;
}(fs10.read);
fs10.readSync = typeof fs10.readSync !== "function" ? fs10.readSync : function(fs$readSync) {
return function(fd, buffer, offset, length, position) {
var eagCounter = 0;
while (true) {
try {
return fs$readSync.call(fs10, fd, buffer, offset, length, position);
} catch (er) {
if (er.code === "EAGAIN" && eagCounter < 10) {
eagCounter++;
continue;
}
throw er;
}
}
};
}(fs10.readSync);
function patchLchmod(fs11) {
fs11.lchmod = function(path7, mode, callback) {
fs11.open(
path7,
constants.O_WRONLY | constants.O_SYMLINK,
mode,
function(err, fd) {
if (err) {
if (callback)
callback(err);
return;
}
fs11.fchmod(fd, mode, function(err2) {
fs11.close(fd, function(err22) {
if (callback)
callback(err2 || err22);
});
});
}
);
};
fs11.lchmodSync = function(path7, mode) {
var fd = fs11.openSync(path7, constants.O_WRONLY | constants.O_SYMLINK, mode);
var threw = true;
var ret;
try {
ret = fs11.fchmodSync(fd, mode);
threw = false;
} finally {
if (threw) {
try {
fs11.closeSync(fd);
} catch (er) {
}
} else {
fs11.closeSync(fd);
}
}
return ret;
};
}
function patchLutimes(fs11) {
if (constants.hasOwnProperty("O_SYMLINK") && fs11.futimes) {
fs11.lutimes = function(path7, at, mt, cb) {
fs11.open(path7, constants.O_SYMLINK, function(er, fd) {
if (er) {
if (cb)
cb(er);
return;
}
fs11.futimes(fd, at, mt, function(er2) {
fs11.close(fd, function(er22) {
if (cb)
cb(er2 || er22);
});
});
});
};
fs11.lutimesSync = function(path7, at, mt) {
var fd = fs11.openSync(path7, constants.O_SYMLINK);
var ret;
var threw = true;
try {
ret = fs11.futimesSync(fd, at, mt);
threw = false;
} finally {
if (threw) {
try {
fs11.closeSync(fd);
} catch (er) {
}
} else {
fs11.closeSync(fd);
}
}
return ret;
};
} else if (fs11.futimes) {
fs11.lutimes = function(_a, _b, _c, cb) {
if (cb)
process.nextTick(cb);
};
fs11.lutimesSync = function() {
};
}
}
function chmodFix(orig) {
if (!orig)
return orig;
return function(target, mode, cb) {
return orig.call(fs10, target, mode, function(er) {
if (chownErOk(er))
er = null;
if (cb)
cb.apply(this, arguments);
});
};
}
function chmodFixSync(orig) {
if (!orig)
return orig;
return function(target, mode) {
try {
return orig.call(fs10, target, mode);
} catch (er) {
if (!chownErOk(er))
throw er;
}
};
}
function chownFix(orig) {
if (!orig)
return orig;
return function(target, uid, gid, cb) {
return orig.call(fs10, target, uid, gid, function(er) {
if (chownErOk(er))
er = null;
if (cb)
cb.apply(this, arguments);
});
};
}
function chownFixSync(orig) {
if (!orig)
return orig;
return function(target, uid, gid) {
try {
return orig.call(fs10, target, uid, gid);
} catch (er) {
if (!chownErOk(er))
throw er;
}
};
}
function statFix(orig) {
if (!orig)
return orig;
return function(target, options2, cb) {
if (typeof options2 === "function") {
cb = options2;
options2 = null;
}
function callback(er, stats) {
if (stats) {
if (stats.uid < 0)
stats.uid += 4294967296;
if (stats.gid < 0)
stats.gid += 4294967296;
}
if (cb)
cb.apply(this, arguments);
}
return options2 ? orig.call(fs10, target, options2, callback) : orig.call(fs10, target, callback);
};
}
function statFixSync(orig) {
if (!orig)
return orig;
return function(target, options2) {
var stats = options2 ? orig.call(fs10, target, options2) : orig.call(fs10, target);
if (stats) {
if (stats.uid < 0)
stats.uid += 4294967296;
if (stats.gid < 0)
stats.gid += 4294967296;
}
return stats;
};
}
function chownErOk(er) {
if (!er)
return true;
if (er.code === "ENOSYS")
return true;
var nonroot = !process.getuid || process.getuid() !== 0;
if (nonroot) {
if (er.code === "EINVAL" || er.code === "EPERM")
return true;
}
return false;
}
}
}
});
// ../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/legacy-streams.js
var require_legacy_streams = __commonJS({
"../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/legacy-streams.js"(exports, module2) {
var Stream2 = require("stream").Stream;
module2.exports = legacy;
function legacy(fs10) {
return {
ReadStream,
WriteStream
};
function ReadStream(path7, options2) {
if (!(this instanceof ReadStream))
return new ReadStream(path7, options2);
Stream2.call(this);
var self = this;
this.path = path7;
this.fd = null;
this.readable = true;
this.paused = false;
this.flags = "r";
this.mode = 438;
this.bufferSize = 64 * 1024;
options2 = options2 || {};
var keys = Object.keys(options2);
for (var index = 0, length = keys.length; index < length; index++) {
var key = keys[index];
this[key] = options2[key];
}
if (this.encoding)
this.setEncoding(this.encoding);
if (this.start !== void 0) {
if ("number" !== typeof this.start) {
throw TypeError("start must be a Number");
}
if (this.end === void 0) {
this.end = Infinity;
} else if ("number" !== typeof this.end) {
throw TypeError("end must be a Number");
}
if (this.start > this.end) {
throw new Error("start must be <= end");
}
this.pos = this.start;
}
if (this.fd !== null) {
process.nextTick(function() {
self._read();
});
return;
}
fs10.open(this.path, this.flags, this.mode, function(err, fd) {
if (err) {
self.emit("error", err);
self.readable = false;
return;
}
self.fd = fd;
self.emit("open", fd);
self._read();
});
}
function WriteStream(path7, options2) {
if (!(this instanceof WriteStream))
return new WriteStream(path7, options2);
Stream2.call(this);
this.path = path7;
this.fd = null;
this.writable = true;
this.flags = "w";
this.encoding = "binary";
this.mode = 438;
this.bytesWritten = 0;
options2 = options2 || {};
var keys = Object.keys(options2);
for (var index = 0, length = keys.length; index < length; index++) {
var key = keys[index];
this[key] = options2[key];
}
if (this.start !== void 0) {
if ("number" !== typeof this.start) {
throw TypeError("start must be a Number");
}
if (this.start < 0) {
throw new Error("start must be >= zero");
}
this.pos = this.start;
}
this.busy = false;
this._queue = [];
if (this.fd === null) {
this._open = fs10.open;
this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
this.flush();
}
}
}
}
});
// ../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/clone.js
var require_clone = __commonJS({
"../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/clone.js"(exports, module2) {
"use strict";
module2.exports = clone2;
var getPrototypeOf = Object.getPrototypeOf || function(obj) {
return obj.__proto__;
};
function clone2(obj) {
if (obj === null || typeof obj !== "object")
return obj;
if (obj instanceof Object)
var copy = { __proto__: getPrototypeOf(obj) };
else
var copy = /* @__PURE__ */ Object.create(null);
Object.getOwnPropertyNames(obj).forEach(function(key) {
Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
});
return copy;
}
}
});
// ../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/graceful-fs.js
var require_graceful_fs = __commonJS({
"../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/graceful-fs.js"(exports, module2) {
var fs10 = require("fs");
var polyfills = require_polyfills();
var legacy = require_legacy_streams();
var clone2 = require_clone();
var util = require("util");
var gracefulQueue;
var previousSymbol;
if (typeof Symbol === "function" && typeof Symbol.for === "function") {
gracefulQueue = Symbol.for("graceful-fs.queue");
previousSymbol = Symbol.for("graceful-fs.previous");
} else {
gracefulQueue = "___graceful-fs.queue";
previousSymbol = "___graceful-fs.previous";
}
function noop() {
}
function publishQueue(context, queue2) {
Object.defineProperty(context, gracefulQueue, {
get: function() {
return queue2;
}
});
}
var debug9 = noop;
if (util.debuglog)
debug9 = util.debuglog("gfs4");
else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
debug9 = function() {
var m = util.format.apply(util, arguments);
m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
console.error(m);
};
if (!fs10[gracefulQueue]) {
queue = global[gracefulQueue] || [];
publishQueue(fs10, queue);
fs10.close = function(fs$close) {
function close(fd, cb) {
return fs$close.call(fs10, fd, function(err) {
if (!err) {
resetQueue();
}
if (typeof cb === "function")
cb.apply(this, arguments);
});
}
Object.defineProperty(close, previousSymbol, {
value: fs$close
});
return close;
}(fs10.close);
fs10.closeSync = function(fs$closeSync) {
function closeSync(fd) {
fs$closeSync.apply(fs10, arguments);
resetQueue();
}
Object.defineProperty(closeSync, previousSymbol, {
value: fs$closeSync
});
return closeSync;
}(fs10.closeSync);
if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
process.on("exit", function() {
debug9(fs10[gracefulQueue]);
require("assert").equal(fs10[gracefulQueue].length, 0);
});
}
}
var queue;
if (!global[gracefulQueue]) {
publishQueue(global, fs10[gracefulQueue]);
}
module2.exports = patch(clone2(fs10));
if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs10.__patched) {
module2.exports = patch(fs10);
fs10.__patched = true;
}
function patch(fs11) {
polyfills(fs11);
fs11.gracefulify = patch;
fs11.createReadStream = createReadStream;
fs11.createWriteStream = createWriteStream;
var fs$readFile = fs11.readFile;
fs11.readFile = readFile;
function readFile(path7, options2, cb) {
if (typeof options2 === "function")
cb = options2, options2 = null;
return go$readFile(path7, options2, cb);
function go$readFile(path8, options3, cb2, startTime) {
return fs$readFile(path8, options3, function(err) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([go$readFile, [path8, options3, cb2], err, startTime || Date.now(), Date.now()]);
else {
if (typeof cb2 === "function")
cb2.apply(this, arguments);
}
});
}
}
var fs$writeFile = fs11.writeFile;
fs11.writeFile = writeFile;
function writeFile(path7, data, options2, cb) {
if (typeof options2 === "function")
cb = options2, options2 = null;
return go$writeFile(path7, data, options2, cb);
function go$writeFile(path8, data2, options3, cb2, startTime) {
return fs$writeFile(path8, data2, options3, function(err) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([go$writeFile, [path8, data2, options3, cb2], err, startTime || Date.now(), Date.now()]);
else {
if (typeof cb2 === "function")
cb2.apply(this, arguments);
}
});
}
}
var fs$appendFile = fs11.appendFile;
if (fs$appendFile)
fs11.appendFile = appendFile;
function appendFile(path7, data, options2, cb) {
if (typeof options2 === "function")
cb = options2, options2 = null;
return go$appendFile(path7, data, options2, cb);
function go$appendFile(path8, data2, options3, cb2, startTime) {
return fs$appendFile(path8, data2, options3, function(err) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([go$appendFile, [path8, data2, options3, cb2], err, startTime || Date.now(), Date.now()]);
else {
if (typeof cb2 === "function")
cb2.apply(this, arguments);
}
});
}
}
var fs$copyFile = fs11.copyFile;
if (fs$copyFile)
fs11.copyFile = copyFile;
function copyFile(src, dest, flags, cb) {
if (typeof flags === "function") {
cb = flags;
flags = 0;
}
return go$copyFile(src, dest, flags, cb);
function go$copyFile(src2, dest2, flags2, cb2, startTime) {
return fs$copyFile(src2, dest2, flags2, function(err) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
else {
if (typeof cb2 === "function")
cb2.apply(this, arguments);
}
});
}
}
var fs$readdir = fs11.readdir;
fs11.readdir = readdir;
var noReaddirOptionVersions = /^v[0-5]\./;
function readdir(path7, options2, cb) {
if (typeof options2 === "function")
cb = options2, options2 = null;
var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path8, options3, cb2, startTime) {
return fs$readdir(path8, fs$readdirCallback(
path8,
options3,
cb2,
startTime
));
} : function go$readdir2(path8, options3, cb2, startTime) {
return fs$readdir(path8, options3, fs$readdirCallback(
path8,
options3,
cb2,
startTime
));
};
return go$readdir(path7, options2, cb);
function fs$readdirCallback(path8, options3, cb2, startTime) {
return function(err, files) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([
go$readdir,
[path8, options3, cb2],
err,
startTime || Date.now(),
Date.now()
]);
else {
if (files && files.sort)
files.sort();
if (typeof cb2 === "function")
cb2.call(this, err, files);
}
};
}
}
if (process.version.substr(0, 4) === "v0.8") {
var legStreams = legacy(fs11);
ReadStream = legStreams.ReadStream;
WriteStream = legStreams.WriteStream;
}
var fs$ReadStream = fs11.ReadStream;
if (fs$ReadStream) {
ReadStream.prototype = Object.create(fs$ReadStream.prototype);
ReadStream.prototype.open = ReadStream$open;
}
var fs$WriteStream = fs11.WriteStream;
if (fs$WriteStream) {
WriteStream.prototype = Object.create(fs$WriteStream.prototype);
WriteStream.prototype.open = WriteStream$open;
}
Object.defineProperty(fs11, "ReadStream", {
get: function() {
return ReadStream;
},
set: function(val) {
ReadStream = val;
},
enumerable: true,
configurable: true
});
Object.defineProperty(fs11, "WriteStream", {
get: function() {
return WriteStream;
},
set: function(val) {
WriteStream = val;
},
enumerable: true,
configurable: true
});
var FileReadStream = ReadStream;
Object.defineProperty(fs11, "FileReadStream", {
get: function() {
return FileReadStream;
},
set: function(val) {
FileReadStream = val;
},
enumerable: true,
configurable: true
});
var FileWriteStream = WriteStream;
Object.defineProperty(fs11, "FileWriteStream", {
get: function() {
return FileWriteStream;
},
set: function(val) {
FileWriteStream = val;
},
enumerable: true,
configurable: true
});
function ReadStream(path7, options2) {
if (this instanceof ReadStream)
return fs$ReadStream.apply(this, arguments), this;
else
return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
}
function ReadStream$open() {
var that = this;
open(that.path, that.flags, that.mode, function(err, fd) {
if (err) {
if (that.autoClose)
that.destroy();
that.emit("error", err);
} else {
that.fd = fd;
that.emit("open", fd);
that.read();
}
});
}
function WriteStream(path7, options2) {
if (this instanceof WriteStream)
return fs$WriteStream.apply(this, arguments), this;
else
return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
}
function WriteStream$open() {
var that = this;
open(that.path, that.flags, that.mode, function(err, fd) {
if (err) {
that.destroy();
that.emit("error", err);
} else {
that.fd = fd;
that.emit("open", fd);
}
});
}
function createReadStream(path7, options2) {
return new fs11.ReadStream(path7, options2);
}
function createWriteStream(path7, options2) {
return new fs11.WriteStream(path7, options2);
}
var fs$open = fs11.open;
fs11.open = open;
function open(path7, flags, mode, cb) {
if (typeof mode === "function")
cb = mode, mode = null;
return go$open(path7, flags, mode, cb);
function go$open(path8, flags2, mode2, cb2, startTime) {
return fs$open(path8, flags2, mode2, function(err, fd) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([go$open, [path8, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
else {
if (typeof cb2 === "function")
cb2.apply(this, arguments);
}
});
}
}
return fs11;
}
function enqueue(elem) {
debug9("ENQUEUE", elem[0].name, elem[1]);
fs10[gracefulQueue].push(elem);
retry2();
}
var retryTimer;
function resetQueue() {
var now = Date.now();
for (var i = 0; i < fs10[gracefulQueue].length; ++i) {
if (fs10[gracefulQueue][i].length > 2) {
fs10[gracefulQueue][i][3] = now;
fs10[gracefulQueue][i][4] = now;
}
}
retry2();
}
function retry2() {
clearTimeout(retryTimer);
retryTimer = void 0;
if (fs10[gracefulQueue].length === 0)
return;
var elem = fs10[gracefulQueue].shift();
var fn = elem[0];
var args = elem[1];
var err = elem[2];
var startTime = elem[3];
var lastTime = elem[4];
if (startTime === void 0) {
debug9("RETRY", fn.name, args);
fn.apply(null, args);
} else if (Date.now() - startTime >= 6e4) {
debug9("TIMEOUT", fn.name, args);
var cb = args.pop();
if (typeof cb === "function")
cb.call(null, err);
} else {
var sinceAttempt = Date.now() - lastTime;
var sinceStart = Math.max(lastTime - startTime, 1);
var desiredDelay = Math.min(sinceStart * 1.2, 100);
if (sinceAttempt >= desiredDelay) {
debug9("RETRY", fn.name, args);
fn.apply(null, args.concat([startTime]));
} else {
fs10[gracefulQueue].push(elem);
}
}
if (retryTimer === void 0) {
retryTimer = setTimeout(retry2, 0);
}
}
}
});
// ../../node_modules/.pnpm/is-path-cwd@2.2.0/node_modules/is-path-cwd/index.js
var require_is_path_cwd = __commonJS({
"../../node_modules/.pnpm/is-path-cwd@2.2.0/node_modules/is-path-cwd/index.js"(exports, module2) {
"use strict";
var path7 = require("path");
module2.exports = (path_) => {
let cwd = process.cwd();
path_ = path7.resolve(path_);
if (process.platform === "win32") {
cwd = cwd.toLowerCase();
path_ = path_.toLowerCase();
}
return path_ === cwd;
};
}
});
// ../../node_modules/.pnpm/is-path-inside@3.0.3/node_modules/is-path-inside/index.js
var require_is_path_inside = __commonJS({
"../../node_modules/.pnpm/is-path-inside@3.0.3/node_modules/is-path-inside/index.js"(exports, module2) {
"use strict";
var path7 = require("path");
module2.exports = (childPath, parentPath) => {
const relation = path7.relative(parentPath, childPath);
return Boolean(
relation && relation !== ".." && !relation.startsWith(`..${path7.sep}`) && relation !== path7.resolve(childPath)
);
};
}
});
// ../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js
var require_old = __commonJS({
"../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js"(exports) {
var pathModule = require("path");
var isWindows = process.platform === "win32";
var fs10 = require("fs");
var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
function rethrow() {
var callback;
if (DEBUG) {
var backtrace = new Error();
callback = debugCallback;
} else
callback = missingCallback;
return callback;
function debugCallback(err) {
if (err) {
backtrace.message = err.message;
err = backtrace;
missingCallback(err);
}
}
function missingCallback(err) {
if (err) {
if (process.throwDeprecation)
throw err;
else if (!process.noDeprecation) {
var msg = "fs: missing callback " + (err.stack || err.message);
if (process.traceDeprecation)
console.trace(msg);
else
console.error(msg);
}
}
}
}
function maybeCallback(cb) {
return typeof cb === "function" ? cb : rethrow();
}
var normalize = pathModule.normalize;
if (isWindows) {
nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
} else {
nextPartRe = /(.*?)(?:[\/]+|$)/g;
}
var nextPartRe;
if (isWindows) {
splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
} else {
splitRootRe = /^[\/]*/;
}
var splitRootRe;
exports.realpathSync = function realpathSync(p2, cache) {
p2 = pathModule.resolve(p2);
if (cache && Object.prototype.hasOwnProperty.call(cache, p2)) {
return cache[p2];
}
var original = p2, seenLinks = {}, knownHard = {};
var pos;
var current;
var base;
var previous;
start();
function start() {
var m = splitRootRe.exec(p2);
pos = m[0].length;
current = m[0];
base = m[0];
previous = "";
if (isWindows && !knownHard[base]) {
fs10.lstatSync(base);
knownHard[base] = true;
}
}
while (pos < p2.length) {
nextPartRe.lastIndex = pos;
var result = nextPartRe.exec(p2);
previous = current;
current += result[0];
base = previous + result[1];
pos = nextPartRe.lastIndex;
if (knownHard[base] || cache && cache[base] === base) {
continue;
}
var resolvedLink;
if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
resolvedLink = cache[base];
} else {
var stat = fs10.lstatSync(base);
if (!stat.isSymbolicLink()) {
knownHard[base] = true;
if (cache)
cache[base] = base;
continue;
}
var linkTarget = null;
if (!isWindows) {
var id = stat.dev.toString(32) + ":" + stat.ino.toString(32);
if (seenLinks.hasOwnProperty(id)) {
linkTarget = seenLinks[id];
}
}
if (linkTarget === null) {
fs10.statSync(base);
linkTarget = fs10.readlinkSync(base);
}
resolvedLink = pathModule.resolve(previous, linkTarget);
if (cache)
cache[base] = resolvedLink;
if (!isWindows)
seenLinks[id] = linkTarget;
}
p2 = pathModule.resolve(resolvedLink, p2.slice(pos));
start();
}
if (cache)
cache[original] = p2;
return p2;
};
exports.realpath = function realpath(p2, cache, cb) {
if (typeof cb !== "function") {
cb = maybeCallback(cache);
cache = null;
}
p2 = pathModule.resolve(p2);
if (cache && Object.prototype.hasOwnProperty.call(cache, p2)) {
return process.nextTick(cb.bind(null, null, cache[p2]));
}
var original = p2, seenLinks = {}, knownHard = {};
var pos;
var current;
var base;
var previous;
start();
function start() {
var m = splitRootRe.exec(p2);
pos = m[0].length;
current = m[0];
base = m[0];
previous = "";
if (isWindows && !knownHard[base]) {
fs10.lstat(base, function(err) {
if (err)
return cb(err);
knownHard[base] = true;
LOOP();
});
} else {
process.nextTick(LOOP);
}
}
function LOOP() {
if (pos >= p2.length) {
if (cache)
cache[original] = p2;
return cb(null, p2);
}
nextPartRe.lastIndex = pos;
var result = nextPartRe.exec(p2);
previous = current;
current += result[0];
base = previous + result[1];
pos = nextPartRe.lastIndex;
if (knownHard[base] || cache && cache[base] === base) {
return process.nextTick(LOOP);
}
if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
return gotResolvedLink(cache[base]);
}
return fs10.lstat(base, gotStat);
}
function gotStat(err, stat) {
if (err)
return cb(err);
if (!stat.isSymbolicLink()) {
knownHard[base] = true;
if (cache)
cache[base] = base;
return process.nextTick(LOOP);
}
if (!isWindows) {
var id = stat.dev.toString(32) + ":" + stat.ino.toString(32);
if (seenLinks.hasOwnProperty(id)) {
return gotTarget(null, seenLinks[id], base);
}
}
fs10.stat(base, function(err2) {
if (err2)
return cb(err2);
fs10.readlink(base, function(err3, target) {
if (!isWindows)
seenLinks[id] = target;
gotTarget(err3, target);
});
});
}
function gotTarget(err, target, base2) {
if (err)
return cb(err);
var resolvedLink = pathModule.resolve(previous, target);
if (cache)
cache[base2] = resolvedLink;
gotResolvedLink(resolvedLink);
}
function gotResolvedLink(resolvedLink) {
p2 = pathModule.resolve(resolvedLink, p2.slice(pos));
start();
}
};
}
});
// ../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/index.js
var require_fs5 = __commonJS({
"../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/index.js"(exports, module2) {
module2.exports = realpath;
realpath.realpath = realpath;
realpath.sync = realpathSync;
realpath.realpathSync = realpathSync;
realpath.monkeypatch = monkeypatch;
realpath.unmonkeypatch = unmonkeypatch;
var fs10 = require("fs");
var origRealpath = fs10.realpath;
var origRealpathSync = fs10.realpathSync;
var version = process.version;
var ok = /^v[0-5]\./.test(version);
var old = require_old();
function newError(er) {
return er && er.syscall === "realpath" && (er.code === "ELOOP" || er.code === "ENOMEM" || er.code === "ENAMETOOLONG");
}
function realpath(p2, cache, cb) {
if (ok) {
return origRealpath(p2, cache, cb);
}
if (typeof cache === "function") {
cb = cache;
cache = null;
}
origRealpath(p2, cache, function(er, result) {
if (newError(er)) {
old.realpath(p2, cache, cb);
} else {
cb(er, result);
}
});
}
function realpathSync(p2, cache) {
if (ok) {
return origRealpathSync(p2, cache);
}
try {
return origRealpathSync(p2, cache);
} catch (er) {
if (newError(er)) {
return old.realpathSync(p2, cache);
} else {
throw er;
}
}
}
function monkeypatch() {
fs10.realpath = realpath;
fs10.realpathSync = realpathSync;
}
function unmonkeypatch() {
fs10.realpath = origRealpath;
fs10.realpathSync = origRealpathSync;
}
}
});
// ../../node_modules/.pnpm/concat-map@0.0.1/node_modules/concat-map/index.js
var require_concat_map = __commonJS({
"../../node_modules/.pnpm/concat-map@0.0.1/node_modules/concat-map/index.js"(exports, module2) {
module2.exports = function(xs, fn) {
var res = [];
for (var i = 0; i < xs.length; i++) {
var x = fn(xs[i], i);
if (isArray(x))
res.push.apply(res, x);
else
res.push(x);
}
return res;
};
var isArray = Array.isArray || function(xs) {
return Object.prototype.toString.call(xs) === "[object Array]";
};
}
});
// ../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
var require_balanced_match = __commonJS({
"../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js"(exports, module2) {
"use strict";
module2.exports = balanced;
function balanced(a, b2, str) {
if (a instanceof RegExp)
a = maybeMatch(a, str);
if (b2 instanceof RegExp)
b2 = maybeMatch(b2, str);
var r2 = range(a, b2, str);
return r2 && {
start: r2[0],
end: r2[1],
pre: str.slice(0, r2[0]),
body: str.slice(r2[0] + a.length, r2[1]),
post: str.slice(r2[1] + b2.length)
};
}
function maybeMatch(reg, str) {
var m = str.match(reg);
return m ? m[0] : null;
}
balanced.range = range;
function range(a, b2, str) {
var begs, beg, left, right, result;
var ai = str.indexOf(a);
var bi = str.indexOf(b2, ai + 1);
var i = ai;
if (ai >= 0 && bi > 0) {
if (a === b2) {
return [ai, bi];
}
begs = [];
left = str.length;
while (i >= 0 && !result) {
if (i == ai) {
begs.push(i);
ai = str.indexOf(a, i + 1);
} else if (begs.length == 1) {
result = [begs.pop(), bi];
} else {
beg = begs.pop();
if (beg < left) {
left = beg;
right = bi;
}
bi = str.indexOf(b2, i + 1);
}
i = ai < bi && ai >= 0 ? ai : bi;
}
if (begs.length) {
result = [left, right];
}
}
return result;
}
}
});
// ../../node_modules/.pnpm/brace-expansion@1.1.11/node_modules/brace-expansion/index.js
var require_brace_expansion = __commonJS({
"../../node_modules/.pnpm/brace-expansion@1.1.11/node_modules/brace-expansion/index.js"(exports, module2) {
var concatMap = require_concat_map();
var balanced = require_balanced_match();
module2.exports = expandTop;
var escSlash = "\0SLASH" + Math.random() + "\0";
var escOpen = "\0OPEN" + Math.random() + "\0";
var escClose = "\0CLOSE" + Math.random() + "\0";
var escComma = "\0COMMA" + Math.random() + "\0";
var escPeriod = "\0PERIOD" + Math.random() + "\0";
function numeric(str) {
return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
}
function escapeBraces(str) {
return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
}
function unescapeBraces(str) {
return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
}
function parseCommaParts(str) {
if (!str)
return [""];
var parts = [];
var m = balanced("{", "}", str);
if (!m)
return str.split(",");
var pre = m.pre;
var body = m.body;
var post = m.post;
var p2 = pre.split(",");
p2[p2.length - 1] += "{" + body + "}";
var postParts = parseCommaParts(post);
if (post.length) {
p2[p2.length - 1] += postParts.shift();
p2.push.apply(p2, postParts);
}
parts.push.apply(parts, p2);
return parts;
}
function expandTop(str) {
if (!str)
return [];
if (str.substr(0, 2) === "{}") {
str = "\\{\\}" + str.substr(2);
}
return expand(escapeBraces(str), true).map(unescapeBraces);
}
function embrace(str) {
return "{" + str + "}";
}
function isPadded(el) {
return /^-?0\d/.test(el);
}
function lte(i, y2) {
return i <= y2;
}
function gte(i, y2) {
return i >= y2;
}
function expand(str, isTop) {
var expansions = [];
var m = balanced("{", "}", str);
if (!m || /\$$/.test(m.pre))
return [str];
var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
var isSequence = isNumericSequence || isAlphaSequence;
var isOptions = m.body.indexOf(",") >= 0;
if (!isSequence && !isOptions) {
if (m.post.match(/,.*\}/)) {
str = m.pre + "{" + m.body + escClose + m.post;
return expand(str);
}
return [str];
}
var n2;
if (isSequence) {
n2 = m.body.split(/\.\./);
} else {
n2 = parseCommaParts(m.body);
if (n2.length === 1) {
n2 = expand(n2[0], false).map(embrace);
if (n2.length === 1) {
var post = m.post.length ? expand(m.post, false) : [""];
return post.map(function(p2) {
return m.pre + n2[0] + p2;
});
}
}
}
var pre = m.pre;
var post = m.post.length ? expand(m.post, false) : [""];
var N;
if (isSequence) {
var x = numeric(n2[0]);
var y2 = numeric(n2[1]);
var width = Math.max(n2[0].length, n2[1].length);
var incr = n2.length == 3 ? Math.abs(numeric(n2[2])) : 1;
var test = lte;
var reverse = y2 < x;
if (reverse) {
incr *= -1;
test = gte;
}
var pad = n2.some(isPadded);
N = [];
for (var i = x; test(i, y2); i += incr) {
var c;
if (isAlphaSequence) {
c = String.fromCharCode(i);
if (c === "\\")
c = "";
} else {
c = String(i);
if (pad) {
var need = width - c.length;
if (need > 0) {
var z = new Array(need + 1).join("0");
if (i < 0)
c = "-" + z + c.slice(1);
else
c = z + c;
}
}
}
N.push(c);
}
} else {
N = concatMap(n2, function(el) {
return expand(el, false);
});
}
for (var j = 0; j < N.length; j++) {
for (var k = 0; k < post.length; k++) {
var expansion = pre + N[j] + post[k];
if (!isTop || isSequence || expansion)
expansions.push(expansion);
}
}
return expansions;
}
}
});
// ../../node_modules/.pnpm/minimatch@3.1.2/node_modules/minimatch/minimatch.js
var require_minimatch = __commonJS({
"../../node_modules/.pnpm/minimatch@3.1.2/node_modules/minimatch/minimatch.js"(exports, module2) {
module2.exports = minimatch;
minimatch.Minimatch = Minimatch;
var path7 = function() {
try {
return require("path");
} catch (e2) {
}
}() || {
sep: "/"
};
minimatch.sep = path7.sep;
var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
var expand = require_brace_expansion();
var plTypes = {
"!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
"?": { open: "(?:", close: ")?" },
"+": { open: "(?:", close: ")+" },
"*": { open: "(?:", close: ")*" },
"@": { open: "(?:", close: ")" }
};
var qmark = "[^/]";
var star = qmark + "*?";
var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
var reSpecials = charSet("().*{}+?[]^$\\!");
function charSet(s) {
return s.split("").reduce(function(set, c) {
set[c] = true;
return set;
}, {});
}
var slashSplit = /\/+/;
minimatch.filter = filter;
function filter(pattern, options2) {
options2 = options2 || {};
return function(p2, i, list) {
return minimatch(p2, pattern, options2);
};
}
function ext(a, b2) {
b2 = b2 || {};
var t3 = {};
Object.keys(a).forEach(function(k) {
t3[k] = a[k];
});
Object.keys(b2).forEach(function(k) {
t3[k] = b2[k];
});
return t3;
}
minimatch.defaults = function(def) {
if (!def || typeof def !== "object" || !Object.keys(def).length) {
return minimatch;
}
var orig = minimatch;
var m = function minimatch2(p2, pattern, options2) {
return orig(p2, pattern, ext(def, options2));
};
m.Minimatch = function Minimatch2(pattern, options2) {
return new orig.Minimatch(pattern, ext(def, options2));
};
m.Minimatch.defaults = function defaults(options2) {
return orig.defaults(ext(def, options2)).Minimatch;
};
m.filter = function filter2(pattern, options2) {
return orig.filter(pattern, ext(def, options2));
};
m.defaults = function defaults(options2) {
return orig.defaults(ext(def, options2));
};
m.makeRe = function makeRe2(pattern, options2) {
return orig.makeRe(pattern, ext(def, options2));
};
m.braceExpand = function braceExpand2(pattern, options2) {
return orig.braceExpand(pattern, ext(def, options2));
};
m.match = function(list, pattern, options2) {
return orig.match(list, pattern, ext(def, options2));
};
return m;
};
Minimatch.defaults = function(def) {
return minimatch.defaults(def).Minimatch;
};
function minimatch(p2, pattern, options2) {
assertValidPattern(pattern);
if (!options2)
options2 = {};
if (!options2.nocomment && pattern.charAt(0) === "#") {
return false;
}
return new Minimatch(pattern, options2).match(p2);
}
function Minimatch(pattern, options2) {
if (!(this instanceof Minimatch)) {
return new Minimatch(pattern, options2);
}
assertValidPattern(pattern);
if (!options2)
options2 = {};
pattern = pattern.trim();
if (!options2.allowWindowsEscape && path7.sep !== "/") {
pattern = pattern.split(path7.sep).join("/");
}
this.options = options2;
this.set = [];
this.pattern = pattern;
this.regexp = null;
this.negate = false;
this.comment = false;
this.empty = false;
this.partial = !!options2.partial;
this.make();
}
Minimatch.prototype.debug = function() {
};
Minimatch.prototype.make = make;
function make() {
var pattern = this.pattern;
var options2 = this.options;
if (!options2.nocomment && pattern.charAt(0) === "#") {
this.comment = true;
return;
}
if (!pattern) {
this.empty = true;
return;
}
this.parseNegate();
var set = this.globSet = this.braceExpand();
if (options2.debug)
this.debug = function debug9() {
console.error.apply(console, arguments);
};
this.debug(this.pattern, set);
set = this.globParts = set.map(function(s) {
return s.split(slashSplit);
});
this.debug(this.pattern, set);
set = set.map(function(s, si, set2) {
return s.map(this.parse, this);
}, this);
this.debug(this.pattern, set);
set = set.filter(function(s) {
return s.indexOf(false) === -1;
});
this.debug(this.pattern, set);
this.set = set;
}
Minimatch.prototype.parseNegate = parseNegate;
function parseNegate() {
var pattern = this.pattern;
var negate = false;
var options2 = this.options;
var negateOffset = 0;
if (options2.nonegate)
return;
for (var i = 0, l = pattern.length; i < l && pattern.charAt(i) === "!"; i++) {
negate = !negate;
negateOffset++;
}
if (negateOffset)
this.pattern = pattern.substr(negateOffset);
this.negate = negate;
}
minimatch.braceExpand = function(pattern, options2) {
return braceExpand(pattern, options2);
};
Minimatch.prototype.braceExpand = braceExpand;
function braceExpand(pattern, options2) {
if (!options2) {
if (this instanceof Minimatch) {
options2 = this.options;
} else {
options2 = {};
}
}
pattern = typeof pattern === "undefined" ? this.pattern : pattern;
assertValidPattern(pattern);
if (options2.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
return [pattern];
}
return expand(pattern);
}
var MAX_PATTERN_LENGTH = 1024 * 64;
var assertValidPattern = function(pattern) {
if (typeof pattern !== "string") {
throw new TypeError("invalid pattern");
}
if (pattern.length > MAX_PATTERN_LENGTH) {
throw new TypeError("pattern is too long");
}
};
Minimatch.prototype.parse = parse;
var SUBPARSE = {};
function parse(pattern, isSub) {
assertValidPattern(pattern);
var options2 = this.options;
if (pattern === "**") {
if (!options2.noglobstar)
return GLOBSTAR;
else
pattern = "*";
}
if (pattern === "")
return "";
var re = "";
var hasMagic = !!options2.nocase;
var escaping = false;
var patternListStack = [];
var negativeLists = [];
var stateChar;
var inClass = false;
var reClassStart = -1;
var classStart = -1;
var patternStart = pattern.charAt(0) === "." ? "" : options2.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
var self = this;
function clearStateChar() {
if (stateChar) {
switch (stateChar) {
case "*":
re += star;
hasMagic = true;
break;
case "?":
re += qmark;
hasMagic = true;
break;
default:
re += "\\" + stateChar;
break;
}
self.debug("clearStateChar %j %j", stateChar, re);
stateChar = false;
}
}
for (var i = 0, len = pattern.length, c; i < len && (c = pattern.charAt(i)); i++) {
this.debug("%s %s %s %j", pattern, i, re, c);
if (escaping && reSpecials[c]) {
re += "\\" + c;
escaping = false;
continue;
}
switch (c) {
case "/": {
return false;
}
case "\\":
clearStateChar();
escaping = true;
continue;
case "?":
case "*":
case "+":
case "@":
case "!":
this.debug("%s %s %s %j <-- stateChar", pattern, i, re, c);
if (inClass) {
this.debug(" in class");
if (c === "!" && i === classStart + 1)
c = "^";
re += c;
continue;
}
self.debug("call clearStateChar %j", stateChar);
clearStateChar();
stateChar = c;
if (options2.noext)
clearStateChar();
continue;
case "(":
if (inClass) {
re += "(";
continue;
}
if (!stateChar) {
re += "\\(";
continue;
}
patternListStack.push({
type: stateChar,
start: i - 1,
reStart: re.length,
open: plTypes[stateChar].open,
close: plTypes[stateChar].close
});
re += stateChar === "!" ? "(?:(?!(?:" : "(?:";
this.debug("plType %j %j", stateChar, re);
stateChar = false;
continue;
case ")":
if (inClass || !patternListStack.length) {
re += "\\)";
continue;
}
clearStateChar();
hasMagic = true;
var pl = patternListStack.pop();
re += pl.close;
if (pl.type === "!") {
negativeLists.push(pl);
}
pl.reEnd = re.length;
continue;
case "|":
if (inClass || !patternListStack.length || escaping) {
re += "\\|";
escaping = false;
continue;
}
clearStateChar();
re += "|";
continue;
case "[":
clearStateChar();
if (inClass) {
re += "\\" + c;
continue;
}
inClass = true;
classStart = i;
reClassStart = re.length;
re += c;
continue;
case "]":
if (i === classStart + 1 || !inClass) {
re += "\\" + c;
escaping = false;
continue;
}
var cs = pattern.substring(classStart + 1, i);
try {
RegExp("[" + cs + "]");
} catch (er) {
var sp = this.parse(cs, SUBPARSE);
re = re.substr(0, reClassStart) + "\\[" + sp[0] + "\\]";
hasMagic = hasMagic || sp[1];
inClass = false;
continue;
}
hasMagic = true;
inClass = false;
re += c;
continue;
default:
clearStateChar();
if (escaping) {
escaping = false;
} else if (reSpecials[c] && !(c === "^" && inClass)) {
re += "\\";
}
re += c;
}
}
if (inClass) {
cs = pattern.substr(classStart + 1);
sp = this.parse(cs, SUBPARSE);
re = re.substr(0, reClassStart) + "\\[" + sp[0];
hasMagic = hasMagic || sp[1];
}
for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
var tail = re.slice(pl.reStart + pl.open.length);
this.debug("setting tail", re, pl);
tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function(_, $1, $2) {
if (!$2) {
$2 = "\\";
}
return $1 + $1 + $2 + "|";
});
this.debug("tail=%j\n %s", tail, tail, pl, re);
var t3 = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
hasMagic = true;
re = re.slice(0, pl.reStart) + t3 + "\\(" + tail;
}
clearStateChar();
if (escaping) {
re += "\\\\";
}
var addPatternStart = false;
switch (re.charAt(0)) {
case "[":
case ".":
case "(":
addPatternStart = true;
}
for (var n2 = negativeLists.length - 1; n2 > -1; n2--) {
var nl = negativeLists[n2];
var nlBefore = re.slice(0, nl.reStart);
var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
var nlAfter = re.slice(nl.reEnd);
nlLast += nlAfter;
var openParensBefore = nlBefore.split("(").length - 1;
var cleanAfter = nlAfter;
for (i = 0; i < openParensBefore; i++) {
cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
}
nlAfter = cleanAfter;
var dollar = "";
if (nlAfter === "" && isSub !== SUBPARSE) {
dollar = "$";
}
var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast;
re = newRe;
}
if (re !== "" && hasMagic) {
re = "(?=.)" + re;
}
if (addPatternStart) {
re = patternStart + re;
}
if (isSub === SUBPARSE) {
return [re, hasMagic];
}
if (!hasMagic) {
return globUnescape(pattern);
}
var flags = options2.nocase ? "i" : "";
try {
var regExp = new RegExp("^" + re + "$", flags);
} catch (er) {
return new RegExp("$.");
}
regExp._glob = pattern;
regExp._src = re;
return regExp;
}
minimatch.makeRe = function(pattern, options2) {
return new Minimatch(pattern, options2 || {}).makeRe();
};
Minimatch.prototype.makeRe = makeRe;
function makeRe() {
if (this.regexp || this.regexp === false)
return this.regexp;
var set = this.set;
if (!set.length) {
this.regexp = false;
return this.regexp;
}
var options2 = this.options;
var twoStar = options2.noglobstar ? star : options2.dot ? twoStarDot : twoStarNoDot;
var flags = options2.nocase ? "i" : "";
var re = set.map(function(pattern) {
return pattern.map(function(p2) {
return p2 === GLOBSTAR ? twoStar : typeof p2 === "string" ? regExpEscape(p2) : p2._src;
}).join("\\/");
}).join("|");
re = "^(?:" + re + ")$";
if (this.negate)
re = "^(?!" + re + ").*$";
try {
this.regexp = new RegExp(re, flags);
} catch (ex) {
this.regexp = false;
}
return this.regexp;
}
minimatch.match = function(list, pattern, options2) {
options2 = options2 || {};
var mm = new Minimatch(pattern, options2);
list = list.filter(function(f) {
return mm.match(f);
});
if (mm.options.nonull && !list.length) {
list.push(pattern);
}
return list;
};
Minimatch.prototype.match = function match(f, partial) {
if (typeof partial === "undefined")
partial = this.partial;
this.debug("match", f, this.pattern);
if (this.comment)
return false;
if (this.empty)
return f === "";
if (f === "/" && partial)
return true;
var options2 = this.options;
if (path7.sep !== "/") {
f = f.split(path7.sep).join("/");
}
f = f.split(slashSplit);
this.debug(this.pattern, "split", f);
var set = this.set;
this.debug(this.pattern, "set", set);
var filename;
var i;
for (i = f.length - 1; i >= 0; i--) {
filename = f[i];
if (filename)
break;
}
for (i = 0; i < set.length; i++) {
var pattern = set[i];
var file2 = f;
if (options2.matchBase && pattern.length === 1) {
file2 = [filename];
}
var hit = this.matchOne(file2, pattern, partial);
if (hit) {
if (options2.flipNegate)
return true;
return !this.negate;
}
}
if (options2.flipNegate)
return false;
return this.negate;
};
Minimatch.prototype.matchOne = function(file2, pattern, partial) {
var options2 = this.options;
this.debug(
"matchOne",
{ "this": this, file: file2, pattern }
);
this.debug("matchOne", file2.length, pattern.length);
for (var fi = 0, pi = 0, fl = file2.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
this.debug("matchOne loop");
var p2 = pattern[pi];
var f = file2[fi];
this.debug(pattern, p2, f);
if (p2 === false)
return false;
if (p2 === GLOBSTAR) {
this.debug("GLOBSTAR", [pattern, p2, f]);
var fr = fi;
var pr = pi + 1;
if (pr === pl) {
this.debug("** at the end");
for (; fi < fl; fi++) {
if (file2[fi] === "." || file2[fi] === ".." || !options2.dot && file2[fi].charAt(0) === ".")
return false;
}
return true;
}
while (fr < fl) {
var swallowee = file2[fr];
this.debug("\nglobstar while", file2, fr, pattern, pr, swallowee);
if (this.matchOne(file2.slice(fr), pattern.slice(pr), partial)) {
this.debug("globstar found match!", fr, fl, swallowee);
return true;
} else {
if (swallowee === "." || swallowee === ".." || !options2.dot && swallowee.charAt(0) === ".") {
this.debug("dot detected!", file2, fr, pattern, pr);
break;
}
this.debug("globstar swallow a segment, and continue");
fr++;
}
}
if (partial) {
this.debug("\n>>> no match, partial?", file2, fr, pattern, pr);
if (fr === fl)
return true;
}
return false;
}
var hit;
if (typeof p2 === "string") {
hit = f === p2;
this.debug("string match", p2, f, hit);
} else {
hit = f.match(p2);
this.debug("pattern match", p2, 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 && file2[fi] === "";
}
throw new Error("wtf?");
};
function globUnescape(s) {
return s.replace(/\\(.)/g, "$1");
}
function regExpEscape(s) {
return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
}
}
});
// ../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js
var require_inherits_browser = __commonJS({
"../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js"(exports, module2) {
if (typeof Object.create === "function") {
module2.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor;
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
}
};
} else {
module2.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {
};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
};
}
}
});
// ../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js
var require_inherits = __commonJS({
"../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js"(exports, module2) {
try {
util = require("util");
if (typeof util.inherits !== "function")
throw "";
module2.exports = util.inherits;
} catch (e2) {
module2.exports = require_inherits_browser();
}
var util;
}
});
// ../../node_modules/.pnpm/path-is-absolute@1.0.1/node_modules/path-is-absolute/index.js
var require_path_is_absolute = __commonJS({
"../../node_modules/.pnpm/path-is-absolute@1.0.1/node_modules/path-is-absolute/index.js"(exports, module2) {
"use strict";
function posix(path7) {
return path7.charAt(0) === "/";
}
function win32(path7) {
var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
var result = splitDeviceRe.exec(path7);
var device = result[1] || "";
var isUnc = Boolean(device && device.charAt(1) !== ":");
return Boolean(result[2] || isUnc);
}
module2.exports = process.platform === "win32" ? win32 : posix;
module2.exports.posix = posix;
module2.exports.win32 = win32;
}
});
// ../../node_modules/.pnpm/glob@7.2.3/node_modules/glob/common.js
var require_common4 = __commonJS({
"../../node_modules/.pnpm/glob@7.2.3/node_modules/glob/common.js"(exports) {
exports.setopts = setopts;
exports.ownProp = ownProp;
exports.makeAbs = makeAbs;
exports.finish = finish;
exports.mark = mark;
exports.isIgnored = isIgnored;
exports.childrenIgnored = childrenIgnored;
function ownProp(obj, field) {
return Object.prototype.hasOwnProperty.call(obj, field);
}
var fs10 = require("fs");
var path7 = require("path");
var minimatch = require_minimatch();
var isAbsolute = require_path_is_absolute();
var Minimatch = minimatch.Minimatch;
function alphasort(a, b2) {
return a.localeCompare(b2, "en");
}
function setupIgnores(self, options2) {
self.ignore = options2.ignore || [];
if (!Array.isArray(self.ignore))
self.ignore = [self.ignore];
if (self.ignore.length) {
self.ignore = self.ignore.map(ignoreMap);
}
}
function ignoreMap(pattern) {
var gmatcher = null;
if (pattern.slice(-3) === "/**") {
var gpattern = pattern.replace(/(\/\*\*)+$/, "");
gmatcher = new Minimatch(gpattern, { dot: true });
}
return {
matcher: new Minimatch(pattern, { dot: true }),
gmatcher
};
}
function setopts(self, pattern, options2) {
if (!options2)
options2 = {};
if (options2.matchBase && -1 === pattern.indexOf("/")) {
if (options2.noglobstar) {
throw new Error("base matching requires globstar");
}
pattern = "**/" + pattern;
}
self.silent = !!options2.silent;
self.pattern = pattern;
self.strict = options2.strict !== false;
self.realpath = !!options2.realpath;
self.realpathCache = options2.realpathCache || /* @__PURE__ */ Object.create(null);
self.follow = !!options2.follow;
self.dot = !!options2.dot;
self.mark = !!options2.mark;
self.nodir = !!options2.nodir;
if (self.nodir)
self.mark = true;
self.sync = !!options2.sync;
self.nounique = !!options2.nounique;
self.nonull = !!options2.nonull;
self.nosort = !!options2.nosort;
self.nocase = !!options2.nocase;
self.stat = !!options2.stat;
self.noprocess = !!options2.noprocess;
self.absolute = !!options2.absolute;
self.fs = options2.fs || fs10;
self.maxLength = options2.maxLength || Infinity;
self.cache = options2.cache || /* @__PURE__ */ Object.create(null);
self.statCache = options2.statCache || /* @__PURE__ */ Object.create(null);
self.symlinks = options2.symlinks || /* @__PURE__ */ Object.create(null);
setupIgnores(self, options2);
self.changedCwd = false;
var cwd = process.cwd();
if (!ownProp(options2, "cwd"))
self.cwd = cwd;
else {
self.cwd = path7.resolve(options2.cwd);
self.changedCwd = self.cwd !== cwd;
}
self.root = options2.root || path7.resolve(self.cwd, "/");
self.root = path7.resolve(self.root);
if (process.platform === "win32")
self.root = self.root.replace(/\\/g, "/");
self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
if (process.platform === "win32")
self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
self.nomount = !!options2.nomount;
options2.nonegate = true;
options2.nocomment = true;
options2.allowWindowsEscape = false;
self.minimatch = new Minimatch(pattern, options2);
self.options = self.minimatch.options;
}
function finish(self) {
var nou = self.nounique;
var all = nou ? [] : /* @__PURE__ */ Object.create(null);
for (var i = 0, l = self.matches.length; i < l; i++) {
var matches = self.matches[i];
if (!matches || Object.keys(matches).length === 0) {
if (self.nonull) {
var literal = self.minimatch.globSet[i];
if (nou)
all.push(literal);
else
all[literal] = true;
}
} else {
var m = Object.keys(matches);
if (nou)
all.push.apply(all, m);
else
m.forEach(function(m2) {
all[m2] = true;
});
}
}
if (!nou)
all = Object.keys(all);
if (!self.nosort)
all = all.sort(alphasort);
if (self.mark) {
for (var i = 0; i < all.length; i++) {
all[i] = self._mark(all[i]);
}
if (self.nodir) {
all = all.filter(function(e2) {
var notDir = !/\/$/.test(e2);
var c = self.cache[e2] || self.cache[makeAbs(self, e2)];
if (notDir && c)
notDir = c !== "DIR" && !Array.isArray(c);
return notDir;
});
}
}
if (self.ignore.length)
all = all.filter(function(m2) {
return !isIgnored(self, m2);
});
self.found = all;
}
function mark(self, p2) {
var abs = makeAbs(self, p2);
var c = self.cache[abs];
var m = p2;
if (c) {
var isDir = c === "DIR" || Array.isArray(c);
var slash = p2.slice(-1) === "/";
if (isDir && !slash)
m += "/";
else if (!isDir && slash)
m = m.slice(0, -1);
if (m !== p2) {
var mabs = makeAbs(self, m);
self.statCache[mabs] = self.statCache[abs];
self.cache[mabs] = self.cache[abs];
}
}
return m;
}
function makeAbs(self, f) {
var abs = f;
if (f.charAt(0) === "/") {
abs = path7.join(self.root, f);
} else if (isAbsolute(f) || f === "") {
abs = f;
} else if (self.changedCwd) {
abs = path7.resolve(self.cwd, f);
} else {
abs = path7.resolve(f);
}
if (process.platform === "win32")
abs = abs.replace(/\\/g, "/");
return abs;
}
function isIgnored(self, path8) {
if (!self.ignore.length)
return false;
return self.ignore.some(function(item) {
return item.matcher.match(path8) || !!(item.gmatcher && item.gmatcher.match(path8));
});
}
function childrenIgnored(self, path8) {
if (!self.ignore.length)
return false;
return self.ignore.some(function(item) {
return !!(item.gmatcher && item.gmatcher.match(path8));
});
}
}
});
// ../../node_modules/.pnpm/glob@7.2.3/node_modules/glob/sync.js
var require_sync7 = __commonJS({
"../../node_modules/.pnpm/glob@7.2.3/node_modules/glob/sync.js"(exports, module2) {
module2.exports = globSync;
globSync.GlobSync = GlobSync;
var rp = require_fs5();
var minimatch = require_minimatch();
var Minimatch = minimatch.Minimatch;
var Glob = require_glob().Glob;
var util = require("util");
var path7 = require("path");
var assert = require("assert");
var isAbsolute = require_path_is_absolute();
var common = require_common4();
var setopts = common.setopts;
var ownProp = common.ownProp;
var childrenIgnored = common.childrenIgnored;
var isIgnored = common.isIgnored;
function globSync(pattern, options2) {
if (typeof options2 === "function" || arguments.length === 3)
throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
return new GlobSync(pattern, options2).found;
}
function GlobSync(pattern, options2) {
if (!pattern)
throw new Error("must provide pattern");
if (typeof options2 === "function" || arguments.length === 3)
throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
if (!(this instanceof GlobSync))
return new GlobSync(pattern, options2);
setopts(this, pattern, options2);
if (this.noprocess)
return this;
var n2 = this.minimatch.set.length;
this.matches = new Array(n2);
for (var i = 0; i < n2; i++) {
this._process(this.minimatch.set[i], i, false);
}
this._finish();
}
GlobSync.prototype._finish = function() {
assert.ok(this instanceof GlobSync);
if (this.realpath) {
var self = this;
this.matches.forEach(function(matchset, index) {
var set = self.matches[index] = /* @__PURE__ */ Object.create(null);
for (var p2 in matchset) {
try {
p2 = self._makeAbs(p2);
var real = rp.realpathSync(p2, self.realpathCache);
set[real] = true;
} catch (er) {
if (er.syscall === "stat")
set[self._makeAbs(p2)] = true;
else
throw er;
}
}
});
}
common.finish(this);
};
GlobSync.prototype._process = function(pattern, index, inGlobStar) {
assert.ok(this instanceof GlobSync);
var n2 = 0;
while (typeof pattern[n2] === "string") {
n2++;
}
var prefix;
switch (n2) {
case pattern.length:
this._processSimple(pattern.join("/"), index);
return;
case 0:
prefix = null;
break;
default:
prefix = pattern.slice(0, n2).join("/");
break;
}
var remain = pattern.slice(n2);
var read;
if (prefix === null)
read = ".";
else if (isAbsolute(prefix) || isAbsolute(pattern.map(function(p2) {
return typeof p2 === "string" ? p2 : "[*]";
}).join("/"))) {
if (!prefix || !isAbsolute(prefix))
prefix = "/" + prefix;
read = prefix;
} else
read = prefix;
var abs = this._makeAbs(read);
if (childrenIgnored(this, read))
return;
var isGlobStar = remain[0] === minimatch.GLOBSTAR;
if (isGlobStar)
this._processGlobStar(prefix, read, abs, remain, index, inGlobStar);
else
this._processReaddir(prefix, read, abs, remain, index, inGlobStar);
};
GlobSync.prototype._processReaddir = function(prefix, read, abs, remain, index, inGlobStar) {
var entries = this._readdir(abs, inGlobStar);
if (!entries)
return;
var pn = remain[0];
var negate = !!this.minimatch.negate;
var rawGlob = pn._glob;
var dotOk = this.dot || rawGlob.charAt(0) === ".";
var matchedEntries = [];
for (var i = 0; i < entries.length; i++) {
var e2 = entries[i];
if (e2.charAt(0) !== "." || dotOk) {
var m;
if (negate && !prefix) {
m = !e2.match(pn);
} else {
m = e2.match(pn);
}
if (m)
matchedEntries.push(e2);
}
}
var len = matchedEntries.length;
if (len === 0)
return;
if (remain.length === 1 && !this.mark && !this.stat) {
if (!this.matches[index])
this.matches[index] = /* @__PURE__ */ Object.create(null);
for (var i = 0; i < len; i++) {
var e2 = matchedEntries[i];
if (prefix) {
if (prefix.slice(-1) !== "/")
e2 = prefix + "/" + e2;
else
e2 = prefix + e2;
}
if (e2.charAt(0) === "/" && !this.nomount) {
e2 = path7.join(this.root, e2);
}
this._emitMatch(index, e2);
}
return;
}
remain.shift();
for (var i = 0; i < len; i++) {
var e2 = matchedEntries[i];
var newPattern;
if (prefix)
newPattern = [prefix, e2];
else
newPattern = [e2];
this._process(newPattern.concat(remain), index, inGlobStar);
}
};
GlobSync.prototype._emitMatch = function(index, e2) {
if (isIgnored(this, e2))
return;
var abs = this._makeAbs(e2);
if (this.mark)
e2 = this._mark(e2);
if (this.absolute) {
e2 = abs;
}
if (this.matches[index][e2])
return;
if (this.nodir) {
var c = this.cache[abs];
if (c === "DIR" || Array.isArray(c))
return;
}
this.matches[index][e2] = true;
if (this.stat)
this._stat(e2);
};
GlobSync.prototype._readdirInGlobStar = function(abs) {
if (this.follow)
return this._readdir(abs, false);
var entries;
var lstat;
var stat;
try {
lstat = this.fs.lstatSync(abs);
} catch (er) {
if (er.code === "ENOENT") {
return null;
}
}
var isSym = lstat && lstat.isSymbolicLink();
this.symlinks[abs] = isSym;
if (!isSym && lstat && !lstat.isDirectory())
this.cache[abs] = "FILE";
else
entries = this._readdir(abs, false);
return entries;
};
GlobSync.prototype._readdir = function(abs, inGlobStar) {
var entries;
if (inGlobStar && !ownProp(this.symlinks, abs))
return this._readdirInGlobStar(abs);
if (ownProp(this.cache, abs)) {
var c = this.cache[abs];
if (!c || c === "FILE")
return null;
if (Array.isArray(c))
return c;
}
try {
return this._readdirEntries(abs, this.fs.readdirSync(abs));
} catch (er) {
this._readdirError(abs, er);
return null;
}
};
GlobSync.prototype._readdirEntries = function(abs, entries) {
if (!this.mark && !this.stat) {
for (var i = 0; i < entries.length; i++) {
var e2 = entries[i];
if (abs === "/")
e2 = abs + e2;
else
e2 = abs + "/" + e2;
this.cache[e2] = true;
}
}
this.cache[abs] = entries;
return entries;
};
GlobSync.prototype._readdirError = function(f, er) {
switch (er.code) {
case "ENOTSUP":
case "ENOTDIR":
var abs = this._makeAbs(f);
this.cache[abs] = "FILE";
if (abs === this.cwdAbs) {
var error = new Error(er.code + " invalid cwd " + this.cwd);
error.path = this.cwd;
error.code = er.code;
throw error;
}
break;
case "ENOENT":
case "ELOOP":
case "ENAMETOOLONG":
case "UNKNOWN":
this.cache[this._makeAbs(f)] = false;
break;
default:
this.cache[this._makeAbs(f)] = false;
if (this.strict)
throw er;
if (!this.silent)
console.error("glob error", er);
break;
}
};
GlobSync.prototype._processGlobStar = function(prefix, read, abs, remain, index, inGlobStar) {
var entries = this._readdir(abs, inGlobStar);
if (!entries)
return;
var remainWithoutGlobStar = remain.slice(1);
var gspref = prefix ? [prefix] : [];
var noGlobStar = gspref.concat(remainWithoutGlobStar);
this._process(noGlobStar, index, false);
var len = entries.length;
var isSym = this.symlinks[abs];
if (isSym && inGlobStar)
return;
for (var i = 0; i < len; i++) {
var e2 = entries[i];
if (e2.charAt(0) === "." && !this.dot)
continue;
var instead = gspref.concat(entries[i], remainWithoutGlobStar);
this._process(instead, index, true);
var below = gspref.concat(entries[i], remain);
this._process(below, index, true);
}
};
GlobSync.prototype._processSimple = function(prefix, index) {
var exists2 = this._stat(prefix);
if (!this.matches[index])
this.matches[index] = /* @__PURE__ */ Object.create(null);
if (!exists2)
return;
if (prefix && isAbsolute(prefix) && !this.nomount) {
var trail = /[\/\\]$/.test(prefix);
if (prefix.charAt(0) === "/") {
prefix = path7.join(this.root, prefix);
} else {
prefix = path7.resolve(this.root, prefix);
if (trail)
prefix += "/";
}
}
if (process.platform === "win32")
prefix = prefix.replace(/\\/g, "/");
this._emitMatch(index, prefix);
};
GlobSync.prototype._stat = function(f) {
var abs = this._makeAbs(f);
var needDir = f.slice(-1) === "/";
if (f.length > this.maxLength)
return false;
if (!this.stat && ownProp(this.cache, abs)) {
var c = this.cache[abs];
if (Array.isArray(c))
c = "DIR";
if (!needDir || c === "DIR")
return c;
if (needDir && c === "FILE")
return false;
}
var exists2;
var stat = this.statCache[abs];
if (!stat) {
var lstat;
try {
lstat = this.fs.lstatSync(abs);
} catch (er) {
if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
this.statCache[abs] = false;
return false;
}
}
if (lstat && lstat.isSymbolicLink()) {
try {
stat = this.fs.statSync(abs);
} catch (er) {
stat = lstat;
}
} else {
stat = lstat;
}
}
this.statCache[abs] = stat;
var c = true;
if (stat)
c = stat.isDirectory() ? "DIR" : "FILE";
this.cache[abs] = this.cache[abs] || c;
if (needDir && c === "FILE")
return false;
return c;
};
GlobSync.prototype._mark = function(p2) {
return common.mark(this, p2);
};
GlobSync.prototype._makeAbs = function(f) {
return common.makeAbs(this, f);
};
}
});
// ../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js
var require_wrappy = __commonJS({
"../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js"(exports, module2) {
module2.exports = wrappy;
function wrappy(fn, cb) {
if (fn && cb)
return wrappy(fn)(cb);
if (typeof fn !== "function")
throw new TypeError("need wrapper function");
Object.keys(fn).forEach(function(k) {
wrapper[k] = fn[k];
});
return wrapper;
function wrapper() {
var args = new Array(arguments.length);
for (var i = 0; i < args.length; i++) {
args[i] = arguments[i];
}
var ret = fn.apply(this, args);
var cb2 = args[args.length - 1];
if (typeof ret === "function" && ret !== cb2) {
Object.keys(cb2).forEach(function(k) {
ret[k] = cb2[k];
});
}
return ret;
}
}
}
});
// ../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js
var require_once = __commonJS({
"../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js"(exports, module2) {
var wrappy = require_wrappy();
module2.exports = wrappy(once);
module2.exports.strict = wrappy(onceStrict);
once.proto = once(function() {
Object.defineProperty(Function.prototype, "once", {
value: function() {
return once(this);
},
configurable: true
});
Object.defineProperty(Function.prototype, "onceStrict", {
value: function() {
return onceStrict(this);
},
configurable: true
});
});
function once(fn) {
var f = function() {
if (f.called)
return f.value;
f.called = true;
return f.value = fn.apply(this, arguments);
};
f.called = false;
return f;
}
function onceStrict(fn) {
var f = function() {
if (f.called)
throw new Error(f.onceError);
f.called = true;
return f.value = fn.apply(this, arguments);
};
var name = fn.name || "Function wrapped with `once`";
f.onceError = name + " shouldn't be called more than once";
f.called = false;
return f;
}
}
});
// ../../node_modules/.pnpm/inflight@1.0.6/node_modules/inflight/inflight.js
var require_inflight = __commonJS({
"../../node_modules/.pnpm/inflight@1.0.6/node_modules/inflight/inflight.js"(exports, module2) {
var wrappy = require_wrappy();
var reqs = /* @__PURE__ */ Object.create(null);
var once = require_once();
module2.exports = wrappy(inflight);
function inflight(key, cb) {
if (reqs[key]) {
reqs[key].push(cb);
return null;
} else {
reqs[key] = [cb];
return makeres(key);
}
}
function makeres(key) {
return once(function RES() {
var cbs = reqs[key];
var len = cbs.length;
var args = slice(arguments);
try {
for (var i = 0; i < len; i++) {
cbs[i].apply(null, args);
}
} finally {
if (cbs.length > len) {
cbs.splice(0, len);
process.nextTick(function() {
RES.apply(null, args);
});
} else {
delete reqs[key];
}
}
});
}
function slice(args) {
var length = args.length;
var array = [];
for (var i = 0; i < length; i++)
array[i] = args[i];
return array;
}
}
});
// ../../node_modules/.pnpm/glob@7.2.3/node_modules/glob/glob.js
var require_glob = __commonJS({
"../../node_modules/.pnpm/glob@7.2.3/node_modules/glob/glob.js"(exports, module2) {
module2.exports = glob;
var rp = require_fs5();
var minimatch = require_minimatch();
var Minimatch = minimatch.Minimatch;
var inherits = require_inherits();
var EE = require("events").EventEmitter;
var path7 = require("path");
var assert = require("assert");
var isAbsolute = require_path_is_absolute();
var globSync = require_sync7();
var common = require_common4();
var setopts = common.setopts;
var ownProp = common.ownProp;
var inflight = require_inflight();
var util = require("util");
var childrenIgnored = common.childrenIgnored;
var isIgnored = common.isIgnored;
var once = require_once();
function glob(pattern, options2, cb) {
if (typeof options2 === "function")
cb = options2, options2 = {};
if (!options2)
options2 = {};
if (options2.sync) {
if (cb)
throw new TypeError("callback provided to sync glob");
return globSync(pattern, options2);
}
return new Glob(pattern, options2, cb);
}
glob.sync = globSync;
var GlobSync = glob.GlobSync = globSync.GlobSync;
glob.glob = glob;
function extend(origin, add) {
if (add === null || typeof add !== "object") {
return origin;
}
var keys = Object.keys(add);
var i = keys.length;
while (i--) {
origin[keys[i]] = add[keys[i]];
}
return origin;
}
glob.hasMagic = function(pattern, options_) {
var options2 = extend({}, options_);
options2.noprocess = true;
var g2 = new Glob(pattern, options2);
var set = g2.minimatch.set;
if (!pattern)
return false;
if (set.length > 1)
return true;
for (var j = 0; j < set[0].length; j++) {
if (typeof set[0][j] !== "string")
return true;
}
return false;
};
glob.Glob = Glob;
inherits(Glob, EE);
function Glob(pattern, options2, cb) {
if (typeof options2 === "function") {
cb = options2;
options2 = null;
}
if (options2 && options2.sync) {
if (cb)
throw new TypeError("callback provided to sync glob");
return new GlobSync(pattern, options2);
}
if (!(this instanceof Glob))
return new Glob(pattern, options2, cb);
setopts(this, pattern, options2);
this._didRealPath = false;
var n2 = this.minimatch.set.length;
this.matches = new Array(n2);
if (typeof cb === "function") {
cb = once(cb);
this.on("error", cb);
this.on("end", function(matches) {
cb(null, matches);
});
}
var self = this;
this._processing = 0;
this._emitQueue = [];
this._processQueue = [];
this.paused = false;
if (this.noprocess)
return this;
if (n2 === 0)
return done();
var sync = true;
for (var i = 0; i < n2; i++) {
this._process(this.minimatch.set[i], i, false, done);
}
sync = false;
function done() {
--self._processing;
if (self._processing <= 0) {
if (sync) {
process.nextTick(function() {
self._finish();
});
} else {
self._finish();
}
}
}
}
Glob.prototype._finish = function() {
assert(this instanceof Glob);
if (this.aborted)
return;
if (this.realpath && !this._didRealpath)
return this._realpath();
common.finish(this);
this.emit("end", this.found);
};
Glob.prototype._realpath = function() {
if (this._didRealpath)
return;
this._didRealpath = true;
var n2 = this.matches.length;
if (n2 === 0)
return this._finish();
var self = this;
for (var i = 0; i < this.matches.length; i++)
this._realpathSet(i, next);
function next() {
if (--n2 === 0)
self._finish();
}
};
Glob.prototype._realpathSet = function(index, cb) {
var matchset = this.matches[index];
if (!matchset)
return cb();
var found = Object.keys(matchset);
var self = this;
var n2 = found.length;
if (n2 === 0)
return cb();
var set = this.matches[index] = /* @__PURE__ */ Object.create(null);
found.forEach(function(p2, i) {
p2 = self._makeAbs(p2);
rp.realpath(p2, self.realpathCache, function(er, real) {
if (!er)
set[real] = true;
else if (er.syscall === "stat")
set[p2] = true;
else
self.emit("error", er);
if (--n2 === 0) {
self.matches[index] = set;
cb();
}
});
});
};
Glob.prototype._mark = function(p2) {
return common.mark(this, p2);
};
Glob.prototype._makeAbs = function(f) {
return common.makeAbs(this, f);
};
Glob.prototype.abort = function() {
this.aborted = true;
this.emit("abort");
};
Glob.prototype.pause = function() {
if (!this.paused) {
this.paused = true;
this.emit("pause");
}
};
Glob.prototype.resume = function() {
if (this.paused) {
this.emit("resume");
this.paused = false;
if (this._emitQueue.length) {
var eq = this._emitQueue.slice(0);
this._emitQueue.length = 0;
for (var i = 0; i < eq.length; i++) {
var e2 = eq[i];
this._emitMatch(e2[0], e2[1]);
}
}
if (this._processQueue.length) {
var pq = this._processQueue.slice(0);
this._processQueue.length = 0;
for (var i = 0; i < pq.length; i++) {
var p2 = pq[i];
this._processing--;
this._process(p2[0], p2[1], p2[2], p2[3]);
}
}
}
};
Glob.prototype._process = function(pattern, index, inGlobStar, cb) {
assert(this instanceof Glob);
assert(typeof cb === "function");
if (this.aborted)
return;
this._processing++;
if (this.paused) {
this._processQueue.push([pattern, index, inGlobStar, cb]);
return;
}
var n2 = 0;
while (typeof pattern[n2] === "string") {
n2++;
}
var prefix;
switch (n2) {
case pattern.length:
this._processSimple(pattern.join("/"), index, cb);
return;
case 0:
prefix = null;
break;
default:
prefix = pattern.slice(0, n2).join("/");
break;
}
var remain = pattern.slice(n2);
var read;
if (prefix === null)
read = ".";
else if (isAbsolute(prefix) || isAbsolute(pattern.map(function(p2) {
return typeof p2 === "string" ? p2 : "[*]";
}).join("/"))) {
if (!prefix || !isAbsolute(prefix))
prefix = "/" + prefix;
read = prefix;
} else
read = prefix;
var abs = this._makeAbs(read);
if (childrenIgnored(this, read))
return cb();
var isGlobStar = remain[0] === minimatch.GLOBSTAR;
if (isGlobStar)
this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb);
else
this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
};
Glob.prototype._processReaddir = function(prefix, read, abs, remain, index, inGlobStar, cb) {
var self = this;
this._readdir(abs, inGlobStar, function(er, entries) {
return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
});
};
Glob.prototype._processReaddir2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
if (!entries)
return cb();
var pn = remain[0];
var negate = !!this.minimatch.negate;
var rawGlob = pn._glob;
var dotOk = this.dot || rawGlob.charAt(0) === ".";
var matchedEntries = [];
for (var i = 0; i < entries.length; i++) {
var e2 = entries[i];
if (e2.charAt(0) !== "." || dotOk) {
var m;
if (negate && !prefix) {
m = !e2.match(pn);
} else {
m = e2.match(pn);
}
if (m)
matchedEntries.push(e2);
}
}
var len = matchedEntries.length;
if (len === 0)
return cb();
if (remain.length === 1 && !this.mark && !this.stat) {
if (!this.matches[index])
this.matches[index] = /* @__PURE__ */ Object.create(null);
for (var i = 0; i < len; i++) {
var e2 = matchedEntries[i];
if (prefix) {
if (prefix !== "/")
e2 = prefix + "/" + e2;
else
e2 = prefix + e2;
}
if (e2.charAt(0) === "/" && !this.nomount) {
e2 = path7.join(this.root, e2);
}
this._emitMatch(index, e2);
}
return cb();
}
remain.shift();
for (var i = 0; i < len; i++) {
var e2 = matchedEntries[i];
var newPattern;
if (prefix) {
if (prefix !== "/")
e2 = prefix + "/" + e2;
else
e2 = prefix + e2;
}
this._process([e2].concat(remain), index, inGlobStar, cb);
}
cb();
};
Glob.prototype._emitMatch = function(index, e2) {
if (this.aborted)
return;
if (isIgnored(this, e2))
return;
if (this.paused) {
this._emitQueue.push([index, e2]);
return;
}
var abs = isAbsolute(e2) ? e2 : this._makeAbs(e2);
if (this.mark)
e2 = this._mark(e2);
if (this.absolute)
e2 = abs;
if (this.matches[index][e2])
return;
if (this.nodir) {
var c = this.cache[abs];
if (c === "DIR" || Array.isArray(c))
return;
}
this.matches[index][e2] = true;
var st = this.statCache[abs];
if (st)
this.emit("stat", e2, st);
this.emit("match", e2);
};
Glob.prototype._readdirInGlobStar = function(abs, cb) {
if (this.aborted)
return;
if (this.follow)
return this._readdir(abs, false, cb);
var lstatkey = "lstat\0" + abs;
var self = this;
var lstatcb = inflight(lstatkey, lstatcb_);
if (lstatcb)
self.fs.lstat(abs, lstatcb);
function lstatcb_(er, lstat) {
if (er && er.code === "ENOENT")
return cb();
var isSym = lstat && lstat.isSymbolicLink();
self.symlinks[abs] = isSym;
if (!isSym && lstat && !lstat.isDirectory()) {
self.cache[abs] = "FILE";
cb();
} else
self._readdir(abs, false, cb);
}
};
Glob.prototype._readdir = function(abs, inGlobStar, cb) {
if (this.aborted)
return;
cb = inflight("readdir\0" + abs + "\0" + inGlobStar, cb);
if (!cb)
return;
if (inGlobStar && !ownProp(this.symlinks, abs))
return this._readdirInGlobStar(abs, cb);
if (ownProp(this.cache, abs)) {
var c = this.cache[abs];
if (!c || c === "FILE")
return cb();
if (Array.isArray(c))
return cb(null, c);
}
var self = this;
self.fs.readdir(abs, readdirCb(this, abs, cb));
};
function readdirCb(self, abs, cb) {
return function(er, entries) {
if (er)
self._readdirError(abs, er, cb);
else
self._readdirEntries(abs, entries, cb);
};
}
Glob.prototype._readdirEntries = function(abs, entries, cb) {
if (this.aborted)
return;
if (!this.mark && !this.stat) {
for (var i = 0; i < entries.length; i++) {
var e2 = entries[i];
if (abs === "/")
e2 = abs + e2;
else
e2 = abs + "/" + e2;
this.cache[e2] = true;
}
}
this.cache[abs] = entries;
return cb(null, entries);
};
Glob.prototype._readdirError = function(f, er, cb) {
if (this.aborted)
return;
switch (er.code) {
case "ENOTSUP":
case "ENOTDIR":
var abs = this._makeAbs(f);
this.cache[abs] = "FILE";
if (abs === this.cwdAbs) {
var error = new Error(er.code + " invalid cwd " + this.cwd);
error.path = this.cwd;
error.code = er.code;
this.emit("error", error);
this.abort();
}
break;
case "ENOENT":
case "ELOOP":
case "ENAMETOOLONG":
case "UNKNOWN":
this.cache[this._makeAbs(f)] = false;
break;
default:
this.cache[this._makeAbs(f)] = false;
if (this.strict) {
this.emit("error", er);
this.abort();
}
if (!this.silent)
console.error("glob error", er);
break;
}
return cb();
};
Glob.prototype._processGlobStar = function(prefix, read, abs, remain, index, inGlobStar, cb) {
var self = this;
this._readdir(abs, inGlobStar, function(er, entries) {
self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
});
};
Glob.prototype._processGlobStar2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
if (!entries)
return cb();
var remainWithoutGlobStar = remain.slice(1);
var gspref = prefix ? [prefix] : [];
var noGlobStar = gspref.concat(remainWithoutGlobStar);
this._process(noGlobStar, index, false, cb);
var isSym = this.symlinks[abs];
var len = entries.length;
if (isSym && inGlobStar)
return cb();
for (var i = 0; i < len; i++) {
var e2 = entries[i];
if (e2.charAt(0) === "." && !this.dot)
continue;
var instead = gspref.concat(entries[i], remainWithoutGlobStar);
this._process(instead, index, true, cb);
var below = gspref.concat(entries[i], remain);
this._process(below, index, true, cb);
}
cb();
};
Glob.prototype._processSimple = function(prefix, index, cb) {
var self = this;
this._stat(prefix, function(er, exists2) {
self._processSimple2(prefix, index, er, exists2, cb);
});
};
Glob.prototype._processSimple2 = function(prefix, index, er, exists2, cb) {
if (!this.matches[index])
this.matches[index] = /* @__PURE__ */ Object.create(null);
if (!exists2)
return cb();
if (prefix && isAbsolute(prefix) && !this.nomount) {
var trail = /[\/\\]$/.test(prefix);
if (prefix.charAt(0) === "/") {
prefix = path7.join(this.root, prefix);
} else {
prefix = path7.resolve(this.root, prefix);
if (trail)
prefix += "/";
}
}
if (process.platform === "win32")
prefix = prefix.replace(/\\/g, "/");
this._emitMatch(index, prefix);
cb();
};
Glob.prototype._stat = function(f, cb) {
var abs = this._makeAbs(f);
var needDir = f.slice(-1) === "/";
if (f.length > this.maxLength)
return cb();
if (!this.stat && ownProp(this.cache, abs)) {
var c = this.cache[abs];
if (Array.isArray(c))
c = "DIR";
if (!needDir || c === "DIR")
return cb(null, c);
if (needDir && c === "FILE")
return cb();
}
var exists2;
var stat = this.statCache[abs];
if (stat !== void 0) {
if (stat === false)
return cb(null, stat);
else {
var type = stat.isDirectory() ? "DIR" : "FILE";
if (needDir && type === "FILE")
return cb();
else
return cb(null, type, stat);
}
}
var self = this;
var statcb = inflight("stat\0" + abs, lstatcb_);
if (statcb)
self.fs.lstat(abs, statcb);
function lstatcb_(er, lstat) {
if (lstat && lstat.isSymbolicLink()) {
return self.fs.stat(abs, function(er2, stat2) {
if (er2)
self._stat2(f, abs, null, lstat, cb);
else
self._stat2(f, abs, er2, stat2, cb);
});
} else {
self._stat2(f, abs, er, lstat, cb);
}
}
};
Glob.prototype._stat2 = function(f, abs, er, stat, cb) {
if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
this.statCache[abs] = false;
return cb();
}
var needDir = f.slice(-1) === "/";
this.statCache[abs] = stat;
if (abs.slice(-1) === "/" && stat && !stat.isDirectory())
return cb(null, false, stat);
var c = true;
if (stat)
c = stat.isDirectory() ? "DIR" : "FILE";
this.cache[abs] = this.cache[abs] || c;
if (needDir && c === "FILE")
return cb();
return cb(null, c, stat);
};
}
});
// ../../node_modules/.pnpm/rimraf@3.0.2/node_modules/rimraf/rimraf.js
var require_rimraf = __commonJS({
"../../node_modules/.pnpm/rimraf@3.0.2/node_modules/rimraf/rimraf.js"(exports, module2) {
var assert = require("assert");
var path7 = require("path");
var fs10 = require("fs");
var glob = void 0;
try {
glob = require_glob();
} catch (_err) {
}
var defaultGlobOpts = {
nosort: true,
silent: true
};
var timeout = 0;
var isWindows = process.platform === "win32";
var defaults = (options2) => {
const methods = [
"unlink",
"chmod",
"stat",
"lstat",
"rmdir",
"readdir"
];
methods.forEach((m) => {
options2[m] = options2[m] || fs10[m];
m = m + "Sync";
options2[m] = options2[m] || fs10[m];
});
options2.maxBusyTries = options2.maxBusyTries || 3;
options2.emfileWait = options2.emfileWait || 1e3;
if (options2.glob === false) {
options2.disableGlob = true;
}
if (options2.disableGlob !== true && glob === void 0) {
throw Error("glob dependency not found, set `options.disableGlob = true` if intentional");
}
options2.disableGlob = options2.disableGlob || false;
options2.glob = options2.glob || defaultGlobOpts;
};
var rimraf3 = (p2, options2, cb) => {
if (typeof options2 === "function") {
cb = options2;
options2 = {};
}
assert(p2, "rimraf: missing path");
assert.equal(typeof p2, "string", "rimraf: path should be a string");
assert.equal(typeof cb, "function", "rimraf: callback function required");
assert(options2, "rimraf: invalid options argument provided");
assert.equal(typeof options2, "object", "rimraf: options should be object");
defaults(options2);
let busyTries = 0;
let errState = null;
let n2 = 0;
const next = (er) => {
errState = errState || er;
if (--n2 === 0)
cb(errState);
};
const afterGlob = (er, results) => {
if (er)
return cb(er);
n2 = results.length;
if (n2 === 0)
return cb();
results.forEach((p3) => {
const CB = (er2) => {
if (er2) {
if ((er2.code === "EBUSY" || er2.code === "ENOTEMPTY" || er2.code === "EPERM") && busyTries < options2.maxBusyTries) {
busyTries++;
return setTimeout(() => rimraf_(p3, options2, CB), busyTries * 100);
}
if (er2.code === "EMFILE" && timeout < options2.emfileWait) {
return setTimeout(() => rimraf_(p3, options2, CB), timeout++);
}
if (er2.code === "ENOENT")
er2 = null;
}
timeout = 0;
next(er2);
};
rimraf_(p3, options2, CB);
});
};
if (options2.disableGlob || !glob.hasMagic(p2))
return afterGlob(null, [p2]);
options2.lstat(p2, (er, stat) => {
if (!er)
return afterGlob(null, [p2]);
glob(p2, options2.glob, afterGlob);
});
};
var rimraf_ = (p2, options2, cb) => {
assert(p2);
assert(options2);
assert(typeof cb === "function");
options2.lstat(p2, (er, st) => {
if (er && er.code === "ENOENT")
return cb(null);
if (er && er.code === "EPERM" && isWindows)
fixWinEPERM(p2, options2, er, cb);
if (st && st.isDirectory())
return rmdir(p2, options2, er, cb);
options2.unlink(p2, (er2) => {
if (er2) {
if (er2.code === "ENOENT")
return cb(null);
if (er2.code === "EPERM")
return isWindows ? fixWinEPERM(p2, options2, er2, cb) : rmdir(p2, options2, er2, cb);
if (er2.code === "EISDIR")
return rmdir(p2, options2, er2, cb);
}
return cb(er2);
});
});
};
var fixWinEPERM = (p2, options2, er, cb) => {
assert(p2);
assert(options2);
assert(typeof cb === "function");
options2.chmod(p2, 438, (er2) => {
if (er2)
cb(er2.code === "ENOENT" ? null : er);
else
options2.stat(p2, (er3, stats) => {
if (er3)
cb(er3.code === "ENOENT" ? null : er);
else if (stats.isDirectory())
rmdir(p2, options2, er, cb);
else
options2.unlink(p2, cb);
});
});
};
var fixWinEPERMSync = (p2, options2, er) => {
assert(p2);
assert(options2);
try {
options2.chmodSync(p2, 438);
} catch (er2) {
if (er2.code === "ENOENT")
return;
else
throw er;
}
let stats;
try {
stats = options2.statSync(p2);
} catch (er3) {
if (er3.code === "ENOENT")
return;
else
throw er;
}
if (stats.isDirectory())
rmdirSync(p2, options2, er);
else
options2.unlinkSync(p2);
};
var rmdir = (p2, options2, originalEr, cb) => {
assert(p2);
assert(options2);
assert(typeof cb === "function");
options2.rmdir(p2, (er) => {
if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM"))
rmkids(p2, options2, cb);
else if (er && er.code === "ENOTDIR")
cb(originalEr);
else
cb(er);
});
};
var rmkids = (p2, options2, cb) => {
assert(p2);
assert(options2);
assert(typeof cb === "function");
options2.readdir(p2, (er, files) => {
if (er)
return cb(er);
let n2 = files.length;
if (n2 === 0)
return options2.rmdir(p2, cb);
let errState;
files.forEach((f) => {
rimraf3(path7.join(p2, f), options2, (er2) => {
if (errState)
return;
if (er2)
return cb(errState = er2);
if (--n2 === 0)
options2.rmdir(p2, cb);
});
});
});
};
var rimrafSync = (p2, options2) => {
options2 = options2 || {};
defaults(options2);
assert(p2, "rimraf: missing path");
assert.equal(typeof p2, "string", "rimraf: path should be a string");
assert(options2, "rimraf: missing options");
assert.equal(typeof options2, "object", "rimraf: options should be object");
let results;
if (options2.disableGlob || !glob.hasMagic(p2)) {
results = [p2];
} else {
try {
options2.lstatSync(p2);
results = [p2];
} catch (er) {
results = glob.sync(p2, options2.glob);
}
}
if (!results.length)
return;
for (let i = 0; i < results.length; i++) {
const p3 = results[i];
let st;
try {
st = options2.lstatSync(p3);
} catch (er) {
if (er.code === "ENOENT")
return;
if (er.code === "EPERM" && isWindows)
fixWinEPERMSync(p3, options2, er);
}
try {
if (st && st.isDirectory())
rmdirSync(p3, options2, null);
else
options2.unlinkSync(p3);
} catch (er) {
if (er.code === "ENOENT")
return;
if (er.code === "EPERM")
return isWindows ? fixWinEPERMSync(p3, options2, er) : rmdirSync(p3, options2, er);
if (er.code !== "EISDIR")
throw er;
rmdirSync(p3, options2, er);
}
}
};
var rmdirSync = (p2, options2, originalEr) => {
assert(p2);
assert(options2);
try {
options2.rmdirSync(p2);
} catch (er) {
if (er.code === "ENOENT")
return;
if (er.code === "ENOTDIR")
throw originalEr;
if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")
rmkidsSync(p2, options2);
}
};
var rmkidsSync = (p2, options2) => {
assert(p2);
assert(options2);
options2.readdirSync(p2).forEach((f) => rimrafSync(path7.join(p2, f), options2));
const retries = isWindows ? 100 : 1;
let i = 0;
do {
let threw = true;
try {
const ret = options2.rmdirSync(p2, options2);
threw = false;
return ret;
} finally {
if (++i < retries && threw)
continue;
}
} while (true);
};
module2.exports = rimraf3;
rimraf3.sync = rimrafSync;
}
});
// ../../node_modules/.pnpm/indent-string@4.0.0/node_modules/indent-string/index.js
var require_indent_string = __commonJS({
"../../node_modules/.pnpm/indent-string@4.0.0/node_modules/indent-string/index.js"(exports, module2) {
"use strict";
module2.exports = (string, count = 1, options2) => {
options2 = {
indent: " ",
includeEmptyLines: false,
...options2
};
if (typeof string !== "string") {
throw new TypeError(
`Expected \`input\` to be a \`string\`, got \`${typeof string}\``
);
}
if (typeof count !== "number") {
throw new TypeError(
`Expected \`count\` to be a \`number\`, got \`${typeof count}\``
);
}
if (typeof options2.indent !== "string") {
throw new TypeError(
`Expected \`options.indent\` to be a \`string\`, got \`${typeof options2.indent}\``
);
}
if (count === 0) {
return string;
}
const regex = options2.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
return string.replace(regex, options2.indent.repeat(count));
};
}
});
// ../../node_modules/.pnpm/clean-stack@2.2.0/node_modules/clean-stack/index.js
var require_clean_stack = __commonJS({
"../../node_modules/.pnpm/clean-stack@2.2.0/node_modules/clean-stack/index.js"(exports, module2) {
"use strict";
var os4 = require("os");
var extractPathRegex = /\s+at.*(?:\(|\s)(.*)\)?/;
var pathRegex = /^(?:(?:(?:node|(?:internal\/[\w/]*|.*node_modules\/(?:babel-polyfill|pirates)\/.*)?\w+)\.js:\d+:\d+)|native)/;
var homeDir = typeof os4.homedir === "undefined" ? "" : os4.homedir();
module2.exports = (stack, options2) => {
options2 = Object.assign({ pretty: false }, options2);
return stack.replace(/\\/g, "/").split("\n").filter((line) => {
const pathMatches = line.match(extractPathRegex);
if (pathMatches === null || !pathMatches[1]) {
return true;
}
const match = pathMatches[1];
if (match.includes(".app/Contents/Resources/electron.asar") || match.includes(".app/Contents/Resources/default_app.asar")) {
return false;
}
return !pathRegex.test(match);
}).filter((line) => line.trim() !== "").map((line) => {
if (options2.pretty) {
return line.replace(extractPathRegex, (m, p1) => m.replace(p1, p1.replace(homeDir, "~")));
}
return line;
}).join("\n");
};
}
});
// ../../node_modules/.pnpm/aggregate-error@3.1.0/node_modules/aggregate-error/index.js
var require_aggregate_error = __commonJS({
"../../node_modules/.pnpm/aggregate-error@3.1.0/node_modules/aggregate-error/index.js"(exports, module2) {
"use strict";
var indentString = require_indent_string();
var cleanStack = require_clean_stack();
var cleanInternalStack = (stack) => stack.replace(/\s+at .*aggregate-error\/index.js:\d+:\d+\)?/g, "");
var AggregateError = class extends Error {
constructor(errors) {
if (!Array.isArray(errors)) {
throw new TypeError(`Expected input to be an Array, got ${typeof errors}`);
}
errors = [...errors].map((error) => {
if (error instanceof Error) {
return error;
}
if (error !== null && typeof error === "object") {
return Object.assign(new Error(error.message), error);
}
return new Error(error);
});
let message = errors.map((error) => {
return typeof error.stack === "string" ? cleanInternalStack(cleanStack(error.stack)) : String(error);
}).join("\n");
message = "\n" + indentString(message, 4);
super(message);
this.name = "AggregateError";
Object.defineProperty(this, "_errors", { value: errors });
}
*[Symbol.iterator]() {
for (const error of this._errors) {
yield error;
}
}
};
module2.exports = AggregateError;
}
});
// ../../node_modules/.pnpm/p-map@4.0.0/node_modules/p-map/index.js
var require_p_map = __commonJS({
"../../node_modules/.pnpm/p-map@4.0.0/node_modules/p-map/index.js"(exports, module2) {
"use strict";
var AggregateError = require_aggregate_error();
module2.exports = async (iterable, mapper, {
concurrency = Infinity,
stopOnError = true
} = {}) => {
return new Promise((resolve, reject) => {
if (typeof mapper !== "function") {
throw new TypeError("Mapper function is required");
}
if (!((Number.isSafeInteger(concurrency) || concurrency === Infinity) && concurrency >= 1)) {
throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
}
const result = [];
const errors = [];
const iterator = iterable[Symbol.iterator]();
let isRejected = false;
let isIterableDone = false;
let resolvingCount = 0;
let currentIndex = 0;
const next = () => {
if (isRejected) {
return;
}
const nextItem = iterator.next();
const index = currentIndex;
currentIndex++;
if (nextItem.done) {
isIterableDone = true;
if (resolvingCount === 0) {
if (!stopOnError && errors.length !== 0) {
reject(new AggregateError(errors));
} else {
resolve(result);
}
}
return;
}
resolvingCount++;
(async () => {
try {
const element = await nextItem.value;
result[index] = await mapper(element, index);
resolvingCount--;
next();
} catch (error) {
if (stopOnError) {
isRejected = true;
reject(error);
} else {
errors.push(error);
resolvingCount--;
next();
}
}
})();
};
for (let i = 0; i < concurrency; i++) {
next();
if (isIterableDone) {
break;
}
}
});
};
}
});
// ../../node_modules/.pnpm/del@6.1.1/node_modules/del/index.js
var require_del = __commonJS({
"../../node_modules/.pnpm/del@6.1.1/node_modules/del/index.js"(exports, module2) {
"use strict";
var { promisify: promisify5 } = require("util");
var path7 = require("path");
var globby = require_globby();
var isGlob = require_is_glob();
var slash = require_slash();
var gracefulFs = require_graceful_fs();
var isPathCwd = require_is_path_cwd();
var isPathInside = require_is_path_inside();
var rimraf3 = require_rimraf();
var pMap2 = require_p_map();
var rimrafP = promisify5(rimraf3);
var rimrafOptions = {
glob: false,
unlink: gracefulFs.unlink,
unlinkSync: gracefulFs.unlinkSync,
chmod: gracefulFs.chmod,
chmodSync: gracefulFs.chmodSync,
stat: gracefulFs.stat,
statSync: gracefulFs.statSync,
lstat: gracefulFs.lstat,
lstatSync: gracefulFs.lstatSync,
rmdir: gracefulFs.rmdir,
rmdirSync: gracefulFs.rmdirSync,
readdir: gracefulFs.readdir,
readdirSync: gracefulFs.readdirSync
};
function safeCheck(file2, cwd) {
if (isPathCwd(file2)) {
throw new Error("Cannot delete the current working directory. Can be overridden with the `force` option.");
}
if (!isPathInside(file2, cwd)) {
throw new Error("Cannot delete files/directories outside the current working directory. Can be overridden with the `force` option.");
}
}
function normalizePatterns(patterns) {
patterns = Array.isArray(patterns) ? patterns : [patterns];
patterns = patterns.map((pattern) => {
if (process.platform === "win32" && isGlob(pattern) === false) {
return slash(pattern);
}
return pattern;
});
return patterns;
}
module2.exports = async (patterns, { force, dryRun, cwd = process.cwd(), onProgress = () => {
}, ...options2 } = {}) => {
options2 = {
expandDirectories: false,
onlyFiles: false,
followSymbolicLinks: false,
cwd,
...options2
};
patterns = normalizePatterns(patterns);
const files = (await globby(patterns, options2)).sort((a, b2) => b2.localeCompare(a));
if (files.length === 0) {
onProgress({
totalCount: 0,
deletedCount: 0,
percent: 1
});
}
let deletedCount = 0;
const mapper = async (file2) => {
file2 = path7.resolve(cwd, file2);
if (!force) {
safeCheck(file2, cwd);
}
if (!dryRun) {
await rimrafP(file2, rimrafOptions);
}
deletedCount += 1;
onProgress({
totalCount: files.length,
deletedCount,
percent: deletedCount / files.length
});
return file2;
};
const removedFiles = await pMap2(files, mapper, options2);
removedFiles.sort((a, b2) => a.localeCompare(b2));
return removedFiles;
};
module2.exports.sync = (patterns, { force, dryRun, cwd = process.cwd(), ...options2 } = {}) => {
options2 = {
expandDirectories: false,
onlyFiles: false,
followSymbolicLinks: false,
cwd,
...options2
};
patterns = normalizePatterns(patterns);
const files = globby.sync(patterns, options2).sort((a, b2) => b2.localeCompare(a));
const removedFiles = files.map((file2) => {
file2 = path7.resolve(cwd, file2);
if (!force) {
safeCheck(file2, cwd);
}
if (!dryRun) {
rimraf3.sync(file2, rimrafOptions);
}
return file2;
});
removedFiles.sort((a, b2) => a.localeCompare(b2));
return removedFiles;
};
}
});
// ../../node_modules/.pnpm/tempy@1.0.1/node_modules/tempy/index.js
var require_tempy = __commonJS({
"../../node_modules/.pnpm/tempy@1.0.1/node_modules/tempy/index.js"(exports, module2) {
"use strict";
var fs10 = require("fs");
var path7 = require("path");
var uniqueString = require_unique_string();
var tempDir2 = require_temp_dir();
var isStream = require_is_stream();
var del3 = require_del();
var stream = require("stream");
var { promisify: promisify5 } = require("util");
var pipeline = promisify5(stream.pipeline);
var { writeFile } = fs10.promises;
var getPath = (prefix = "") => path7.join(tempDir2, prefix + uniqueString());
var writeStream = async (filePath, data) => pipeline(data, fs10.createWriteStream(filePath));
var createTask = (tempyFunction, { extraArguments = 0 } = {}) => async (...arguments_) => {
const [callback, options2] = arguments_.slice(extraArguments);
const result = await tempyFunction(...arguments_.slice(0, extraArguments), options2);
try {
return await callback(result);
} finally {
await del3(result, { force: true });
}
};
module2.exports.file = (options2) => {
options2 = {
...options2
};
if (options2.name) {
if (options2.extension !== void 0 && options2.extension !== null) {
throw new Error("The `name` and `extension` options are mutually exclusive");
}
return path7.join(module2.exports.directory(), options2.name);
}
return getPath() + (options2.extension === void 0 || options2.extension === null ? "" : "." + options2.extension.replace(/^\./, ""));
};
module2.exports.file.task = createTask(module2.exports.file);
module2.exports.directory = ({ prefix = "" } = {}) => {
const directory = getPath(prefix);
fs10.mkdirSync(directory);
return directory;
};
module2.exports.directory.task = createTask(module2.exports.directory);
module2.exports.write = async (data, options2) => {
const filename = module2.exports.file(options2);
const write = isStream(data) ? writeStream : writeFile;
await write(filename, data);
return filename;
};
module2.exports.write.task = createTask(module2.exports.write, { extraArguments: 1 });
module2.exports.writeSync = (data, options2) => {
const filename = module2.exports.file(options2);
fs10.writeFileSync(filename, data);
return filename;
};
Object.defineProperty(module2.exports, "root", {
get() {
return tempDir2;
}
});
}
});
// ../../node_modules/.pnpm/universalify@2.0.0/node_modules/universalify/index.js
var require_universalify = __commonJS({
"../../node_modules/.pnpm/universalify@2.0.0/node_modules/universalify/index.js"(exports) {
"use strict";
exports.fromCallback = function(fn) {
return Object.defineProperty(function(...args) {
if (typeof args[args.length - 1] === "function")
fn.apply(this, args);
else {
return new Promise((resolve, reject) => {
fn.call(
this,
...args,
(err, res) => err != null ? reject(err) : resolve(res)
);
});
}
}, "name", { value: fn.name });
};
exports.fromPromise = function(fn) {
return Object.defineProperty(function(...args) {
const cb = args[args.length - 1];
if (typeof cb !== "function")
return fn.apply(this, args);
else
fn.apply(this, args.slice(0, -1)).then((r2) => cb(null, r2), cb);
}, "name", { value: fn.name });
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/fs/index.js
var require_fs6 = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/fs/index.js"(exports) {
"use strict";
var u2 = require_universalify().fromCallback;
var fs10 = require_graceful_fs();
var api = [
"access",
"appendFile",
"chmod",
"chown",
"close",
"copyFile",
"fchmod",
"fchown",
"fdatasync",
"fstat",
"fsync",
"ftruncate",
"futimes",
"lchmod",
"lchown",
"link",
"lstat",
"mkdir",
"mkdtemp",
"open",
"opendir",
"readdir",
"readFile",
"readlink",
"realpath",
"rename",
"rm",
"rmdir",
"stat",
"symlink",
"truncate",
"unlink",
"utimes",
"writeFile"
].filter((key) => {
return typeof fs10[key] === "function";
});
Object.assign(exports, fs10);
api.forEach((method) => {
exports[method] = u2(fs10[method]);
});
exports.exists = function(filename, callback) {
if (typeof callback === "function") {
return fs10.exists(filename, callback);
}
return new Promise((resolve) => {
return fs10.exists(filename, resolve);
});
};
exports.read = function(fd, buffer, offset, length, position, callback) {
if (typeof callback === "function") {
return fs10.read(fd, buffer, offset, length, position, callback);
}
return new Promise((resolve, reject) => {
fs10.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
if (err)
return reject(err);
resolve({ bytesRead, buffer: buffer2 });
});
});
};
exports.write = function(fd, buffer, ...args) {
if (typeof args[args.length - 1] === "function") {
return fs10.write(fd, buffer, ...args);
}
return new Promise((resolve, reject) => {
fs10.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
if (err)
return reject(err);
resolve({ bytesWritten, buffer: buffer2 });
});
});
};
exports.readv = function(fd, buffers, ...args) {
if (typeof args[args.length - 1] === "function") {
return fs10.readv(fd, buffers, ...args);
}
return new Promise((resolve, reject) => {
fs10.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
if (err)
return reject(err);
resolve({ bytesRead, buffers: buffers2 });
});
});
};
exports.writev = function(fd, buffers, ...args) {
if (typeof args[args.length - 1] === "function") {
return fs10.writev(fd, buffers, ...args);
}
return new Promise((resolve, reject) => {
fs10.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
if (err)
return reject(err);
resolve({ bytesWritten, buffers: buffers2 });
});
});
};
if (typeof fs10.realpath.native === "function") {
exports.realpath.native = u2(fs10.realpath.native);
} else {
process.emitWarning(
"fs.realpath.native is not a function. Is fs being monkey-patched?",
"Warning",
"fs-extra-WARN0003"
);
}
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/mkdirs/utils.js
var require_utils5 = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module2) {
"use strict";
var path7 = require("path");
module2.exports.checkPath = function checkPath(pth) {
if (process.platform === "win32") {
const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path7.parse(pth).root, ""));
if (pathHasInvalidWinCharacters) {
const error = new Error(`Path contains invalid characters: ${pth}`);
error.code = "EINVAL";
throw error;
}
}
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/mkdirs/make-dir.js
var require_make_dir = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module2) {
"use strict";
var fs10 = require_fs6();
var { checkPath } = require_utils5();
var getMode = (options2) => {
const defaults = { mode: 511 };
if (typeof options2 === "number")
return options2;
return { ...defaults, ...options2 }.mode;
};
module2.exports.makeDir = async (dir2, options2) => {
checkPath(dir2);
return fs10.mkdir(dir2, {
mode: getMode(options2),
recursive: true
});
};
module2.exports.makeDirSync = (dir2, options2) => {
checkPath(dir2);
return fs10.mkdirSync(dir2, {
mode: getMode(options2),
recursive: true
});
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/mkdirs/index.js
var require_mkdirs = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/mkdirs/index.js"(exports, module2) {
"use strict";
var u2 = require_universalify().fromPromise;
var { makeDir: _makeDir, makeDirSync } = require_make_dir();
var makeDir = u2(_makeDir);
module2.exports = {
mkdirs: makeDir,
mkdirsSync: makeDirSync,
mkdirp: makeDir,
mkdirpSync: makeDirSync,
ensureDir: makeDir,
ensureDirSync: makeDirSync
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/path-exists/index.js
var require_path_exists = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/path-exists/index.js"(exports, module2) {
"use strict";
var u2 = require_universalify().fromPromise;
var fs10 = require_fs6();
function pathExists(path7) {
return fs10.access(path7).then(() => true).catch(() => false);
}
module2.exports = {
pathExists: u2(pathExists),
pathExistsSync: fs10.existsSync
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/util/utimes.js
var require_utimes = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/util/utimes.js"(exports, module2) {
"use strict";
var fs10 = require_graceful_fs();
function utimesMillis(path7, atime, mtime, callback) {
fs10.open(path7, "r+", (err, fd) => {
if (err)
return callback(err);
fs10.futimes(fd, atime, mtime, (futimesErr) => {
fs10.close(fd, (closeErr) => {
if (callback)
callback(futimesErr || closeErr);
});
});
});
}
function utimesMillisSync(path7, atime, mtime) {
const fd = fs10.openSync(path7, "r+");
fs10.futimesSync(fd, atime, mtime);
return fs10.closeSync(fd);
}
module2.exports = {
utimesMillis,
utimesMillisSync
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/util/stat.js
var require_stat = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/util/stat.js"(exports, module2) {
"use strict";
var fs10 = require_fs6();
var path7 = require("path");
var util = require("util");
function getStats(src, dest, opts2) {
const statFunc = opts2.dereference ? (file2) => fs10.stat(file2, { bigint: true }) : (file2) => fs10.lstat(file2, { bigint: true });
return Promise.all([
statFunc(src),
statFunc(dest).catch((err) => {
if (err.code === "ENOENT")
return null;
throw err;
})
]).then(([srcStat, destStat]) => ({ srcStat, destStat }));
}
function getStatsSync(src, dest, opts2) {
let destStat;
const statFunc = opts2.dereference ? (file2) => fs10.statSync(file2, { bigint: true }) : (file2) => fs10.lstatSync(file2, { bigint: true });
const srcStat = statFunc(src);
try {
destStat = statFunc(dest);
} catch (err) {
if (err.code === "ENOENT")
return { srcStat, destStat: null };
throw err;
}
return { srcStat, destStat };
}
function checkPaths(src, dest, funcName, opts2, cb) {
util.callbackify(getStats)(src, dest, opts2, (err, stats) => {
if (err)
return cb(err);
const { srcStat, destStat } = stats;
if (destStat) {
if (areIdentical(srcStat, destStat)) {
const srcBaseName = path7.basename(src);
const destBaseName = path7.basename(dest);
if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
return cb(null, { srcStat, destStat, isChangingCase: true });
}
return cb(new Error("Source and destination must not be the same."));
}
if (srcStat.isDirectory() && !destStat.isDirectory()) {
return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`));
}
if (!srcStat.isDirectory() && destStat.isDirectory()) {
return cb(new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`));
}
}
if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
return cb(new Error(errMsg(src, dest, funcName)));
}
return cb(null, { srcStat, destStat });
});
}
function checkPathsSync(src, dest, funcName, opts2) {
const { srcStat, destStat } = getStatsSync(src, dest, opts2);
if (destStat) {
if (areIdentical(srcStat, destStat)) {
const srcBaseName = path7.basename(src);
const destBaseName = path7.basename(dest);
if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
return { srcStat, destStat, isChangingCase: true };
}
throw new Error("Source and destination must not be the same.");
}
if (srcStat.isDirectory() && !destStat.isDirectory()) {
throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
}
if (!srcStat.isDirectory() && destStat.isDirectory()) {
throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
}
}
if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
throw new Error(errMsg(src, dest, funcName));
}
return { srcStat, destStat };
}
function checkParentPaths(src, srcStat, dest, funcName, cb) {
const srcParent = path7.resolve(path7.dirname(src));
const destParent = path7.resolve(path7.dirname(dest));
if (destParent === srcParent || destParent === path7.parse(destParent).root)
return cb();
fs10.stat(destParent, { bigint: true }, (err, destStat) => {
if (err) {
if (err.code === "ENOENT")
return cb();
return cb(err);
}
if (areIdentical(srcStat, destStat)) {
return cb(new Error(errMsg(src, dest, funcName)));
}
return checkParentPaths(src, srcStat, destParent, funcName, cb);
});
}
function checkParentPathsSync(src, srcStat, dest, funcName) {
const srcParent = path7.resolve(path7.dirname(src));
const destParent = path7.resolve(path7.dirname(dest));
if (destParent === srcParent || destParent === path7.parse(destParent).root)
return;
let destStat;
try {
destStat = fs10.statSync(destParent, { bigint: true });
} catch (err) {
if (err.code === "ENOENT")
return;
throw err;
}
if (areIdentical(srcStat, destStat)) {
throw new Error(errMsg(src, dest, funcName));
}
return checkParentPathsSync(src, srcStat, destParent, funcName);
}
function areIdentical(srcStat, destStat) {
return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
}
function isSrcSubdir(src, dest) {
const srcArr = path7.resolve(src).split(path7.sep).filter((i) => i);
const destArr = path7.resolve(dest).split(path7.sep).filter((i) => i);
return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true);
}
function errMsg(src, dest, funcName) {
return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
}
module2.exports = {
checkPaths,
checkPathsSync,
checkParentPaths,
checkParentPathsSync,
isSrcSubdir,
areIdentical
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/copy/copy.js
var require_copy = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/copy/copy.js"(exports, module2) {
"use strict";
var fs10 = require_graceful_fs();
var path7 = require("path");
var mkdirs = require_mkdirs().mkdirs;
var pathExists = require_path_exists().pathExists;
var utimesMillis = require_utimes().utimesMillis;
var stat = require_stat();
function copy(src, dest, opts2, cb) {
if (typeof opts2 === "function" && !cb) {
cb = opts2;
opts2 = {};
} else if (typeof opts2 === "function") {
opts2 = { filter: opts2 };
}
cb = cb || function() {
};
opts2 = opts2 || {};
opts2.clobber = "clobber" in opts2 ? !!opts2.clobber : true;
opts2.overwrite = "overwrite" in opts2 ? !!opts2.overwrite : opts2.clobber;
if (opts2.preserveTimestamps && process.arch === "ia32") {
process.emitWarning(
"Using the preserveTimestamps option in 32-bit node is not recommended;\n\n see https://github.com/jprichardson/node-fs-extra/issues/269",
"Warning",
"fs-extra-WARN0001"
);
}
stat.checkPaths(src, dest, "copy", opts2, (err, stats) => {
if (err)
return cb(err);
const { srcStat, destStat } = stats;
stat.checkParentPaths(src, srcStat, dest, "copy", (err2) => {
if (err2)
return cb(err2);
runFilter(src, dest, opts2, (err3, include) => {
if (err3)
return cb(err3);
if (!include)
return cb();
checkParentDir(destStat, src, dest, opts2, cb);
});
});
});
}
function checkParentDir(destStat, src, dest, opts2, cb) {
const destParent = path7.dirname(dest);
pathExists(destParent, (err, dirExists) => {
if (err)
return cb(err);
if (dirExists)
return getStats(destStat, src, dest, opts2, cb);
mkdirs(destParent, (err2) => {
if (err2)
return cb(err2);
return getStats(destStat, src, dest, opts2, cb);
});
});
}
function runFilter(src, dest, opts2, cb) {
if (!opts2.filter)
return cb(null, true);
Promise.resolve(opts2.filter(src, dest)).then((include) => cb(null, include), (error) => cb(error));
}
function getStats(destStat, src, dest, opts2, cb) {
const stat2 = opts2.dereference ? fs10.stat : fs10.lstat;
stat2(src, (err, srcStat) => {
if (err)
return cb(err);
if (srcStat.isDirectory())
return onDir(srcStat, destStat, src, dest, opts2, cb);
else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice())
return onFile(srcStat, destStat, src, dest, opts2, cb);
else if (srcStat.isSymbolicLink())
return onLink(destStat, src, dest, opts2, cb);
else if (srcStat.isSocket())
return cb(new Error(`Cannot copy a socket file: ${src}`));
else if (srcStat.isFIFO())
return cb(new Error(`Cannot copy a FIFO pipe: ${src}`));
return cb(new Error(`Unknown file: ${src}`));
});
}
function onFile(srcStat, destStat, src, dest, opts2, cb) {
if (!destStat)
return copyFile(srcStat, src, dest, opts2, cb);
return mayCopyFile(srcStat, src, dest, opts2, cb);
}
function mayCopyFile(srcStat, src, dest, opts2, cb) {
if (opts2.overwrite) {
fs10.unlink(dest, (err) => {
if (err)
return cb(err);
return copyFile(srcStat, src, dest, opts2, cb);
});
} else if (opts2.errorOnExist) {
return cb(new Error(`'${dest}' already exists`));
} else
return cb();
}
function copyFile(srcStat, src, dest, opts2, cb) {
fs10.copyFile(src, dest, (err) => {
if (err)
return cb(err);
if (opts2.preserveTimestamps)
return handleTimestampsAndMode(srcStat.mode, src, dest, cb);
return setDestMode(dest, srcStat.mode, cb);
});
}
function handleTimestampsAndMode(srcMode, src, dest, cb) {
if (fileIsNotWritable(srcMode)) {
return makeFileWritable(dest, srcMode, (err) => {
if (err)
return cb(err);
return setDestTimestampsAndMode(srcMode, src, dest, cb);
});
}
return setDestTimestampsAndMode(srcMode, src, dest, cb);
}
function fileIsNotWritable(srcMode) {
return (srcMode & 128) === 0;
}
function makeFileWritable(dest, srcMode, cb) {
return setDestMode(dest, srcMode | 128, cb);
}
function setDestTimestampsAndMode(srcMode, src, dest, cb) {
setDestTimestamps(src, dest, (err) => {
if (err)
return cb(err);
return setDestMode(dest, srcMode, cb);
});
}
function setDestMode(dest, srcMode, cb) {
return fs10.chmod(dest, srcMode, cb);
}
function setDestTimestamps(src, dest, cb) {
fs10.stat(src, (err, updatedSrcStat) => {
if (err)
return cb(err);
return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb);
});
}
function onDir(srcStat, destStat, src, dest, opts2, cb) {
if (!destStat)
return mkDirAndCopy(srcStat.mode, src, dest, opts2, cb);
return copyDir(src, dest, opts2, cb);
}
function mkDirAndCopy(srcMode, src, dest, opts2, cb) {
fs10.mkdir(dest, (err) => {
if (err)
return cb(err);
copyDir(src, dest, opts2, (err2) => {
if (err2)
return cb(err2);
return setDestMode(dest, srcMode, cb);
});
});
}
function copyDir(src, dest, opts2, cb) {
fs10.readdir(src, (err, items) => {
if (err)
return cb(err);
return copyDirItems(items, src, dest, opts2, cb);
});
}
function copyDirItems(items, src, dest, opts2, cb) {
const item = items.pop();
if (!item)
return cb();
return copyDirItem(items, item, src, dest, opts2, cb);
}
function copyDirItem(items, item, src, dest, opts2, cb) {
const srcItem = path7.join(src, item);
const destItem = path7.join(dest, item);
runFilter(srcItem, destItem, opts2, (err, include) => {
if (err)
return cb(err);
if (!include)
return copyDirItems(items, src, dest, opts2, cb);
stat.checkPaths(srcItem, destItem, "copy", opts2, (err2, stats) => {
if (err2)
return cb(err2);
const { destStat } = stats;
getStats(destStat, srcItem, destItem, opts2, (err3) => {
if (err3)
return cb(err3);
return copyDirItems(items, src, dest, opts2, cb);
});
});
});
}
function onLink(destStat, src, dest, opts2, cb) {
fs10.readlink(src, (err, resolvedSrc) => {
if (err)
return cb(err);
if (opts2.dereference) {
resolvedSrc = path7.resolve(process.cwd(), resolvedSrc);
}
if (!destStat) {
return fs10.symlink(resolvedSrc, dest, cb);
} else {
fs10.readlink(dest, (err2, resolvedDest) => {
if (err2) {
if (err2.code === "EINVAL" || err2.code === "UNKNOWN")
return fs10.symlink(resolvedSrc, dest, cb);
return cb(err2);
}
if (opts2.dereference) {
resolvedDest = path7.resolve(process.cwd(), resolvedDest);
}
if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`));
}
if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`));
}
return copyLink(resolvedSrc, dest, cb);
});
}
});
}
function copyLink(resolvedSrc, dest, cb) {
fs10.unlink(dest, (err) => {
if (err)
return cb(err);
return fs10.symlink(resolvedSrc, dest, cb);
});
}
module2.exports = copy;
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/copy/copy-sync.js
var require_copy_sync = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module2) {
"use strict";
var fs10 = require_graceful_fs();
var path7 = require("path");
var mkdirsSync = require_mkdirs().mkdirsSync;
var utimesMillisSync = require_utimes().utimesMillisSync;
var stat = require_stat();
function copySync(src, dest, opts2) {
if (typeof opts2 === "function") {
opts2 = { filter: opts2 };
}
opts2 = opts2 || {};
opts2.clobber = "clobber" in opts2 ? !!opts2.clobber : true;
opts2.overwrite = "overwrite" in opts2 ? !!opts2.overwrite : opts2.clobber;
if (opts2.preserveTimestamps && process.arch === "ia32") {
process.emitWarning(
"Using the preserveTimestamps option in 32-bit node is not recommended;\n\n see https://github.com/jprichardson/node-fs-extra/issues/269",
"Warning",
"fs-extra-WARN0002"
);
}
const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts2);
stat.checkParentPathsSync(src, srcStat, dest, "copy");
if (opts2.filter && !opts2.filter(src, dest))
return;
const destParent = path7.dirname(dest);
if (!fs10.existsSync(destParent))
mkdirsSync(destParent);
return getStats(destStat, src, dest, opts2);
}
function getStats(destStat, src, dest, opts2) {
const statSync = opts2.dereference ? fs10.statSync : fs10.lstatSync;
const srcStat = statSync(src);
if (srcStat.isDirectory())
return onDir(srcStat, destStat, src, dest, opts2);
else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice())
return onFile(srcStat, destStat, src, dest, opts2);
else if (srcStat.isSymbolicLink())
return onLink(destStat, src, dest, opts2);
else if (srcStat.isSocket())
throw new Error(`Cannot copy a socket file: ${src}`);
else if (srcStat.isFIFO())
throw new Error(`Cannot copy a FIFO pipe: ${src}`);
throw new Error(`Unknown file: ${src}`);
}
function onFile(srcStat, destStat, src, dest, opts2) {
if (!destStat)
return copyFile(srcStat, src, dest, opts2);
return mayCopyFile(srcStat, src, dest, opts2);
}
function mayCopyFile(srcStat, src, dest, opts2) {
if (opts2.overwrite) {
fs10.unlinkSync(dest);
return copyFile(srcStat, src, dest, opts2);
} else if (opts2.errorOnExist) {
throw new Error(`'${dest}' already exists`);
}
}
function copyFile(srcStat, src, dest, opts2) {
fs10.copyFileSync(src, dest);
if (opts2.preserveTimestamps)
handleTimestamps(srcStat.mode, src, dest);
return setDestMode(dest, srcStat.mode);
}
function handleTimestamps(srcMode, src, dest) {
if (fileIsNotWritable(srcMode))
makeFileWritable(dest, srcMode);
return setDestTimestamps(src, dest);
}
function fileIsNotWritable(srcMode) {
return (srcMode & 128) === 0;
}
function makeFileWritable(dest, srcMode) {
return setDestMode(dest, srcMode | 128);
}
function setDestMode(dest, srcMode) {
return fs10.chmodSync(dest, srcMode);
}
function setDestTimestamps(src, dest) {
const updatedSrcStat = fs10.statSync(src);
return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
}
function onDir(srcStat, destStat, src, dest, opts2) {
if (!destStat)
return mkDirAndCopy(srcStat.mode, src, dest, opts2);
return copyDir(src, dest, opts2);
}
function mkDirAndCopy(srcMode, src, dest, opts2) {
fs10.mkdirSync(dest);
copyDir(src, dest, opts2);
return setDestMode(dest, srcMode);
}
function copyDir(src, dest, opts2) {
fs10.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts2));
}
function copyDirItem(item, src, dest, opts2) {
const srcItem = path7.join(src, item);
const destItem = path7.join(dest, item);
if (opts2.filter && !opts2.filter(srcItem, destItem))
return;
const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts2);
return getStats(destStat, srcItem, destItem, opts2);
}
function onLink(destStat, src, dest, opts2) {
let resolvedSrc = fs10.readlinkSync(src);
if (opts2.dereference) {
resolvedSrc = path7.resolve(process.cwd(), resolvedSrc);
}
if (!destStat) {
return fs10.symlinkSync(resolvedSrc, dest);
} else {
let resolvedDest;
try {
resolvedDest = fs10.readlinkSync(dest);
} catch (err) {
if (err.code === "EINVAL" || err.code === "UNKNOWN")
return fs10.symlinkSync(resolvedSrc, dest);
throw err;
}
if (opts2.dereference) {
resolvedDest = path7.resolve(process.cwd(), resolvedDest);
}
if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
}
if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
}
return copyLink(resolvedSrc, dest);
}
}
function copyLink(resolvedSrc, dest) {
fs10.unlinkSync(dest);
return fs10.symlinkSync(resolvedSrc, dest);
}
module2.exports = copySync;
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/copy/index.js
var require_copy2 = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/copy/index.js"(exports, module2) {
"use strict";
var u2 = require_universalify().fromCallback;
module2.exports = {
copy: u2(require_copy()),
copySync: require_copy_sync()
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/remove/index.js
var require_remove = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/remove/index.js"(exports, module2) {
"use strict";
var fs10 = require_graceful_fs();
var u2 = require_universalify().fromCallback;
function remove(path7, callback) {
fs10.rm(path7, { recursive: true, force: true }, callback);
}
function removeSync(path7) {
fs10.rmSync(path7, { recursive: true, force: true });
}
module2.exports = {
remove: u2(remove),
removeSync
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/empty/index.js
var require_empty = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/empty/index.js"(exports, module2) {
"use strict";
var u2 = require_universalify().fromPromise;
var fs10 = require_fs6();
var path7 = require("path");
var mkdir = require_mkdirs();
var remove = require_remove();
var emptyDir = u2(async function emptyDir2(dir2) {
let items;
try {
items = await fs10.readdir(dir2);
} catch {
return mkdir.mkdirs(dir2);
}
return Promise.all(items.map((item) => remove.remove(path7.join(dir2, item))));
});
function emptyDirSync(dir2) {
let items;
try {
items = fs10.readdirSync(dir2);
} catch {
return mkdir.mkdirsSync(dir2);
}
items.forEach((item) => {
item = path7.join(dir2, item);
remove.removeSync(item);
});
}
module2.exports = {
emptyDirSync,
emptydirSync: emptyDirSync,
emptyDir,
emptydir: emptyDir
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/ensure/file.js
var require_file = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/ensure/file.js"(exports, module2) {
"use strict";
var u2 = require_universalify().fromCallback;
var path7 = require("path");
var fs10 = require_graceful_fs();
var mkdir = require_mkdirs();
function createFile(file2, callback) {
function makeFile() {
fs10.writeFile(file2, "", (err) => {
if (err)
return callback(err);
callback();
});
}
fs10.stat(file2, (err, stats) => {
if (!err && stats.isFile())
return callback();
const dir2 = path7.dirname(file2);
fs10.stat(dir2, (err2, stats2) => {
if (err2) {
if (err2.code === "ENOENT") {
return mkdir.mkdirs(dir2, (err3) => {
if (err3)
return callback(err3);
makeFile();
});
}
return callback(err2);
}
if (stats2.isDirectory())
makeFile();
else {
fs10.readdir(dir2, (err3) => {
if (err3)
return callback(err3);
});
}
});
});
}
function createFileSync(file2) {
let stats;
try {
stats = fs10.statSync(file2);
} catch {
}
if (stats && stats.isFile())
return;
const dir2 = path7.dirname(file2);
try {
if (!fs10.statSync(dir2).isDirectory()) {
fs10.readdirSync(dir2);
}
} catch (err) {
if (err && err.code === "ENOENT")
mkdir.mkdirsSync(dir2);
else
throw err;
}
fs10.writeFileSync(file2, "");
}
module2.exports = {
createFile: u2(createFile),
createFileSync
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/ensure/link.js
var require_link = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/ensure/link.js"(exports, module2) {
"use strict";
var u2 = require_universalify().fromCallback;
var path7 = require("path");
var fs10 = require_graceful_fs();
var mkdir = require_mkdirs();
var pathExists = require_path_exists().pathExists;
var { areIdentical } = require_stat();
function createLink(srcpath, dstpath, callback) {
function makeLink(srcpath2, dstpath2) {
fs10.link(srcpath2, dstpath2, (err) => {
if (err)
return callback(err);
callback(null);
});
}
fs10.lstat(dstpath, (_, dstStat) => {
fs10.lstat(srcpath, (err, srcStat) => {
if (err) {
err.message = err.message.replace("lstat", "ensureLink");
return callback(err);
}
if (dstStat && areIdentical(srcStat, dstStat))
return callback(null);
const dir2 = path7.dirname(dstpath);
pathExists(dir2, (err2, dirExists) => {
if (err2)
return callback(err2);
if (dirExists)
return makeLink(srcpath, dstpath);
mkdir.mkdirs(dir2, (err3) => {
if (err3)
return callback(err3);
makeLink(srcpath, dstpath);
});
});
});
});
}
function createLinkSync(srcpath, dstpath) {
let dstStat;
try {
dstStat = fs10.lstatSync(dstpath);
} catch {
}
try {
const srcStat = fs10.lstatSync(srcpath);
if (dstStat && areIdentical(srcStat, dstStat))
return;
} catch (err) {
err.message = err.message.replace("lstat", "ensureLink");
throw err;
}
const dir2 = path7.dirname(dstpath);
const dirExists = fs10.existsSync(dir2);
if (dirExists)
return fs10.linkSync(srcpath, dstpath);
mkdir.mkdirsSync(dir2);
return fs10.linkSync(srcpath, dstpath);
}
module2.exports = {
createLink: u2(createLink),
createLinkSync
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/ensure/symlink-paths.js
var require_symlink_paths = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module2) {
"use strict";
var path7 = require("path");
var fs10 = require_graceful_fs();
var pathExists = require_path_exists().pathExists;
function symlinkPaths(srcpath, dstpath, callback) {
if (path7.isAbsolute(srcpath)) {
return fs10.lstat(srcpath, (err) => {
if (err) {
err.message = err.message.replace("lstat", "ensureSymlink");
return callback(err);
}
return callback(null, {
toCwd: srcpath,
toDst: srcpath
});
});
} else {
const dstdir = path7.dirname(dstpath);
const relativeToDst = path7.join(dstdir, srcpath);
return pathExists(relativeToDst, (err, exists2) => {
if (err)
return callback(err);
if (exists2) {
return callback(null, {
toCwd: relativeToDst,
toDst: srcpath
});
} else {
return fs10.lstat(srcpath, (err2) => {
if (err2) {
err2.message = err2.message.replace("lstat", "ensureSymlink");
return callback(err2);
}
return callback(null, {
toCwd: srcpath,
toDst: path7.relative(dstdir, srcpath)
});
});
}
});
}
}
function symlinkPathsSync(srcpath, dstpath) {
let exists2;
if (path7.isAbsolute(srcpath)) {
exists2 = fs10.existsSync(srcpath);
if (!exists2)
throw new Error("absolute srcpath does not exist");
return {
toCwd: srcpath,
toDst: srcpath
};
} else {
const dstdir = path7.dirname(dstpath);
const relativeToDst = path7.join(dstdir, srcpath);
exists2 = fs10.existsSync(relativeToDst);
if (exists2) {
return {
toCwd: relativeToDst,
toDst: srcpath
};
} else {
exists2 = fs10.existsSync(srcpath);
if (!exists2)
throw new Error("relative srcpath does not exist");
return {
toCwd: srcpath,
toDst: path7.relative(dstdir, srcpath)
};
}
}
}
module2.exports = {
symlinkPaths,
symlinkPathsSync
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/ensure/symlink-type.js
var require_symlink_type = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module2) {
"use strict";
var fs10 = require_graceful_fs();
function symlinkType(srcpath, type, callback) {
callback = typeof type === "function" ? type : callback;
type = typeof type === "function" ? false : type;
if (type)
return callback(null, type);
fs10.lstat(srcpath, (err, stats) => {
if (err)
return callback(null, "file");
type = stats && stats.isDirectory() ? "dir" : "file";
callback(null, type);
});
}
function symlinkTypeSync(srcpath, type) {
let stats;
if (type)
return type;
try {
stats = fs10.lstatSync(srcpath);
} catch {
return "file";
}
return stats && stats.isDirectory() ? "dir" : "file";
}
module2.exports = {
symlinkType,
symlinkTypeSync
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/ensure/symlink.js
var require_symlink = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/ensure/symlink.js"(exports, module2) {
"use strict";
var u2 = require_universalify().fromCallback;
var path7 = require("path");
var fs10 = require_fs6();
var _mkdirs = require_mkdirs();
var mkdirs = _mkdirs.mkdirs;
var mkdirsSync = _mkdirs.mkdirsSync;
var _symlinkPaths = require_symlink_paths();
var symlinkPaths = _symlinkPaths.symlinkPaths;
var symlinkPathsSync = _symlinkPaths.symlinkPathsSync;
var _symlinkType = require_symlink_type();
var symlinkType = _symlinkType.symlinkType;
var symlinkTypeSync = _symlinkType.symlinkTypeSync;
var pathExists = require_path_exists().pathExists;
var { areIdentical } = require_stat();
function createSymlink(srcpath, dstpath, type, callback) {
callback = typeof type === "function" ? type : callback;
type = typeof type === "function" ? false : type;
fs10.lstat(dstpath, (err, stats) => {
if (!err && stats.isSymbolicLink()) {
Promise.all([
fs10.stat(srcpath),
fs10.stat(dstpath)
]).then(([srcStat, dstStat]) => {
if (areIdentical(srcStat, dstStat))
return callback(null);
_createSymlink(srcpath, dstpath, type, callback);
});
} else
_createSymlink(srcpath, dstpath, type, callback);
});
}
function _createSymlink(srcpath, dstpath, type, callback) {
symlinkPaths(srcpath, dstpath, (err, relative) => {
if (err)
return callback(err);
srcpath = relative.toDst;
symlinkType(relative.toCwd, type, (err2, type2) => {
if (err2)
return callback(err2);
const dir2 = path7.dirname(dstpath);
pathExists(dir2, (err3, dirExists) => {
if (err3)
return callback(err3);
if (dirExists)
return fs10.symlink(srcpath, dstpath, type2, callback);
mkdirs(dir2, (err4) => {
if (err4)
return callback(err4);
fs10.symlink(srcpath, dstpath, type2, callback);
});
});
});
});
}
function createSymlinkSync(srcpath, dstpath, type) {
let stats;
try {
stats = fs10.lstatSync(dstpath);
} catch {
}
if (stats && stats.isSymbolicLink()) {
const srcStat = fs10.statSync(srcpath);
const dstStat = fs10.statSync(dstpath);
if (areIdentical(srcStat, dstStat))
return;
}
const relative = symlinkPathsSync(srcpath, dstpath);
srcpath = relative.toDst;
type = symlinkTypeSync(relative.toCwd, type);
const dir2 = path7.dirname(dstpath);
const exists2 = fs10.existsSync(dir2);
if (exists2)
return fs10.symlinkSync(srcpath, dstpath, type);
mkdirsSync(dir2);
return fs10.symlinkSync(srcpath, dstpath, type);
}
module2.exports = {
createSymlink: u2(createSymlink),
createSymlinkSync
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/ensure/index.js
var require_ensure = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/ensure/index.js"(exports, module2) {
"use strict";
var { createFile, createFileSync } = require_file();
var { createLink, createLinkSync } = require_link();
var { createSymlink, createSymlinkSync } = require_symlink();
module2.exports = {
createFile,
createFileSync,
ensureFile: createFile,
ensureFileSync: createFileSync,
createLink,
createLinkSync,
ensureLink: createLink,
ensureLinkSync: createLinkSync,
createSymlink,
createSymlinkSync,
ensureSymlink: createSymlink,
ensureSymlinkSync: createSymlinkSync
};
}
});
// ../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/utils.js
var require_utils6 = __commonJS({
"../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/utils.js"(exports, module2) {
function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
const EOF = finalEOL ? EOL : "";
const str = JSON.stringify(obj, replacer, spaces);
return str.replace(/\n/g, EOL) + EOF;
}
function stripBom(content) {
if (Buffer.isBuffer(content))
content = content.toString("utf8");
return content.replace(/^\uFEFF/, "");
}
module2.exports = { stringify, stripBom };
}
});
// ../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/index.js
var require_jsonfile = __commonJS({
"../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/index.js"(exports, module2) {
var _fs;
try {
_fs = require_graceful_fs();
} catch (_) {
_fs = require("fs");
}
var universalify = require_universalify();
var { stringify, stripBom } = require_utils6();
async function _readFile(file2, options2 = {}) {
if (typeof options2 === "string") {
options2 = { encoding: options2 };
}
const fs10 = options2.fs || _fs;
const shouldThrow = "throws" in options2 ? options2.throws : true;
let data = await universalify.fromCallback(fs10.readFile)(file2, options2);
data = stripBom(data);
let obj;
try {
obj = JSON.parse(data, options2 ? options2.reviver : null);
} catch (err) {
if (shouldThrow) {
err.message = `${file2}: ${err.message}`;
throw err;
} else {
return null;
}
}
return obj;
}
var readFile = universalify.fromPromise(_readFile);
function readFileSync(file2, options2 = {}) {
if (typeof options2 === "string") {
options2 = { encoding: options2 };
}
const fs10 = options2.fs || _fs;
const shouldThrow = "throws" in options2 ? options2.throws : true;
try {
let content = fs10.readFileSync(file2, options2);
content = stripBom(content);
return JSON.parse(content, options2.reviver);
} catch (err) {
if (shouldThrow) {
err.message = `${file2}: ${err.message}`;
throw err;
} else {
return null;
}
}
}
async function _writeFile(file2, obj, options2 = {}) {
const fs10 = options2.fs || _fs;
const str = stringify(obj, options2);
await universalify.fromCallback(fs10.writeFile)(file2, str, options2);
}
var writeFile = universalify.fromPromise(_writeFile);
function writeFileSync(file2, obj, options2 = {}) {
const fs10 = options2.fs || _fs;
const str = stringify(obj, options2);
return fs10.writeFileSync(file2, str, options2);
}
var jsonfile = {
readFile,
readFileSync,
writeFile,
writeFileSync
};
module2.exports = jsonfile;
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/json/jsonfile.js
var require_jsonfile2 = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/json/jsonfile.js"(exports, module2) {
"use strict";
var jsonFile = require_jsonfile();
module2.exports = {
readJson: jsonFile.readFile,
readJsonSync: jsonFile.readFileSync,
writeJson: jsonFile.writeFile,
writeJsonSync: jsonFile.writeFileSync
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/output-file/index.js
var require_output_file = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/output-file/index.js"(exports, module2) {
"use strict";
var u2 = require_universalify().fromCallback;
var fs10 = require_graceful_fs();
var path7 = require("path");
var mkdir = require_mkdirs();
var pathExists = require_path_exists().pathExists;
function outputFile(file2, data, encoding, callback) {
if (typeof encoding === "function") {
callback = encoding;
encoding = "utf8";
}
const dir2 = path7.dirname(file2);
pathExists(dir2, (err, itDoes) => {
if (err)
return callback(err);
if (itDoes)
return fs10.writeFile(file2, data, encoding, callback);
mkdir.mkdirs(dir2, (err2) => {
if (err2)
return callback(err2);
fs10.writeFile(file2, data, encoding, callback);
});
});
}
function outputFileSync(file2, ...args) {
const dir2 = path7.dirname(file2);
if (fs10.existsSync(dir2)) {
return fs10.writeFileSync(file2, ...args);
}
mkdir.mkdirsSync(dir2);
fs10.writeFileSync(file2, ...args);
}
module2.exports = {
outputFile: u2(outputFile),
outputFileSync
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/json/output-json.js
var require_output_json = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/json/output-json.js"(exports, module2) {
"use strict";
var { stringify } = require_utils6();
var { outputFile } = require_output_file();
async function outputJson(file2, data, options2 = {}) {
const str = stringify(data, options2);
await outputFile(file2, str, options2);
}
module2.exports = outputJson;
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/json/output-json-sync.js
var require_output_json_sync = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/json/output-json-sync.js"(exports, module2) {
"use strict";
var { stringify } = require_utils6();
var { outputFileSync } = require_output_file();
function outputJsonSync(file2, data, options2) {
const str = stringify(data, options2);
outputFileSync(file2, str, options2);
}
module2.exports = outputJsonSync;
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/json/index.js
var require_json = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/json/index.js"(exports, module2) {
"use strict";
var u2 = require_universalify().fromPromise;
var jsonFile = require_jsonfile2();
jsonFile.outputJson = u2(require_output_json());
jsonFile.outputJsonSync = require_output_json_sync();
jsonFile.outputJSON = jsonFile.outputJson;
jsonFile.outputJSONSync = jsonFile.outputJsonSync;
jsonFile.writeJSON = jsonFile.writeJson;
jsonFile.writeJSONSync = jsonFile.writeJsonSync;
jsonFile.readJSON = jsonFile.readJson;
jsonFile.readJSONSync = jsonFile.readJsonSync;
module2.exports = jsonFile;
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/move/move.js
var require_move = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/move/move.js"(exports, module2) {
"use strict";
var fs10 = require_graceful_fs();
var path7 = require("path");
var copy = require_copy2().copy;
var remove = require_remove().remove;
var mkdirp = require_mkdirs().mkdirp;
var pathExists = require_path_exists().pathExists;
var stat = require_stat();
function move(src, dest, opts2, cb) {
if (typeof opts2 === "function") {
cb = opts2;
opts2 = {};
}
opts2 = opts2 || {};
const overwrite = opts2.overwrite || opts2.clobber || false;
stat.checkPaths(src, dest, "move", opts2, (err, stats) => {
if (err)
return cb(err);
const { srcStat, isChangingCase = false } = stats;
stat.checkParentPaths(src, srcStat, dest, "move", (err2) => {
if (err2)
return cb(err2);
if (isParentRoot(dest))
return doRename(src, dest, overwrite, isChangingCase, cb);
mkdirp(path7.dirname(dest), (err3) => {
if (err3)
return cb(err3);
return doRename(src, dest, overwrite, isChangingCase, cb);
});
});
});
}
function isParentRoot(dest) {
const parent = path7.dirname(dest);
const parsedPath = path7.parse(parent);
return parsedPath.root === parent;
}
function doRename(src, dest, overwrite, isChangingCase, cb) {
if (isChangingCase)
return rename(src, dest, overwrite, cb);
if (overwrite) {
return remove(dest, (err) => {
if (err)
return cb(err);
return rename(src, dest, overwrite, cb);
});
}
pathExists(dest, (err, destExists) => {
if (err)
return cb(err);
if (destExists)
return cb(new Error("dest already exists."));
return rename(src, dest, overwrite, cb);
});
}
function rename(src, dest, overwrite, cb) {
fs10.rename(src, dest, (err) => {
if (!err)
return cb();
if (err.code !== "EXDEV")
return cb(err);
return moveAcrossDevice(src, dest, overwrite, cb);
});
}
function moveAcrossDevice(src, dest, overwrite, cb) {
const opts2 = {
overwrite,
errorOnExist: true,
preserveTimestamps: true
};
copy(src, dest, opts2, (err) => {
if (err)
return cb(err);
return remove(src, cb);
});
}
module2.exports = move;
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/move/move-sync.js
var require_move_sync = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/move/move-sync.js"(exports, module2) {
"use strict";
var fs10 = require_graceful_fs();
var path7 = require("path");
var copySync = require_copy2().copySync;
var removeSync = require_remove().removeSync;
var mkdirpSync = require_mkdirs().mkdirpSync;
var stat = require_stat();
function moveSync(src, dest, opts2) {
opts2 = opts2 || {};
const overwrite = opts2.overwrite || opts2.clobber || false;
const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts2);
stat.checkParentPathsSync(src, srcStat, dest, "move");
if (!isParentRoot(dest))
mkdirpSync(path7.dirname(dest));
return doRename(src, dest, overwrite, isChangingCase);
}
function isParentRoot(dest) {
const parent = path7.dirname(dest);
const parsedPath = path7.parse(parent);
return parsedPath.root === parent;
}
function doRename(src, dest, overwrite, isChangingCase) {
if (isChangingCase)
return rename(src, dest, overwrite);
if (overwrite) {
removeSync(dest);
return rename(src, dest, overwrite);
}
if (fs10.existsSync(dest))
throw new Error("dest already exists.");
return rename(src, dest, overwrite);
}
function rename(src, dest, overwrite) {
try {
fs10.renameSync(src, dest);
} catch (err) {
if (err.code !== "EXDEV")
throw err;
return moveAcrossDevice(src, dest, overwrite);
}
}
function moveAcrossDevice(src, dest, overwrite) {
const opts2 = {
overwrite,
errorOnExist: true,
preserveTimestamps: true
};
copySync(src, dest, opts2);
return removeSync(src);
}
module2.exports = moveSync;
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/move/index.js
var require_move2 = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/move/index.js"(exports, module2) {
"use strict";
var u2 = require_universalify().fromCallback;
module2.exports = {
move: u2(require_move()),
moveSync: require_move_sync()
};
}
});
// ../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/index.js
var require_lib = __commonJS({
"../../node_modules/.pnpm/fs-extra@11.1.1/node_modules/fs-extra/lib/index.js"(exports, module2) {
"use strict";
module2.exports = {
...require_fs6(),
...require_copy2(),
...require_empty(),
...require_ensure(),
...require_json(),
...require_mkdirs(),
...require_move2(),
...require_output_file(),
...require_path_exists(),
...require_remove()
};
}
});
// ../../node_modules/.pnpm/p-map@2.1.0/node_modules/p-map/index.js
var require_p_map2 = __commonJS({
"../../node_modules/.pnpm/p-map@2.1.0/node_modules/p-map/index.js"(exports, module2) {
"use strict";
var pMap2 = (iterable, mapper, options2) => new Promise((resolve, reject) => {
options2 = Object.assign({
concurrency: Infinity
}, options2);
if (typeof mapper !== "function") {
throw new TypeError("Mapper function is required");
}
const { concurrency } = options2;
if (!(typeof concurrency === "number" && concurrency >= 1)) {
throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${concurrency}\` (${typeof concurrency})`);
}
const ret = [];
const iterator = iterable[Symbol.iterator]();
let isRejected = false;
let isIterableDone = false;
let resolvingCount = 0;
let currentIndex = 0;
const next = () => {
if (isRejected) {
return;
}
const nextItem = iterator.next();
const i = currentIndex;
currentIndex++;
if (nextItem.done) {
isIterableDone = true;
if (resolvingCount === 0) {
resolve(ret);
}
return;
}
resolvingCount++;
Promise.resolve(nextItem.value).then((element) => mapper(element, i)).then(
(value) => {
ret[i] = value;
resolvingCount--;
next();
},
(error) => {
isRejected = true;
reject(error);
}
);
};
for (let i = 0; i < concurrency; i++) {
next();
if (isIterableDone) {
break;
}
}
});
module2.exports = pMap2;
module2.exports.default = pMap2;
}
});
// ../../node_modules/.pnpm/p-filter@2.1.0/node_modules/p-filter/index.js
var require_p_filter = __commonJS({
"../../node_modules/.pnpm/p-filter@2.1.0/node_modules/p-filter/index.js"(exports, module2) {
"use strict";
var pMap2 = require_p_map2();
var pFilter2 = async (iterable, filterer, options2) => {
const values = await pMap2(
iterable,
(element, index) => Promise.all([filterer(element, index), element]),
options2
);
return values.filter((value) => Boolean(value[0])).map((value) => value[1]);
};
module2.exports = pFilter2;
module2.exports.default = pFilter2;
}
});
// ../../node_modules/.pnpm/commondir@1.0.1/node_modules/commondir/index.js
var require_commondir = __commonJS({
"../../node_modules/.pnpm/commondir@1.0.1/node_modules/commondir/index.js"(exports, module2) {
var path7 = require("path");
module2.exports = function(basedir, relfiles) {
if (relfiles) {
var files = relfiles.map(function(r2) {
return path7.resolve(basedir, r2);
});
} else {
var files = basedir;
}
var res = files.slice(1).reduce(function(ps, file2) {
if (!file2.match(/^([A-Za-z]:)?\/|\\/)) {
throw new Error("relative path without a basedir");
}
var xs = file2.split(/\/+|\\+/);
for (var i = 0; ps[i] === xs[i] && i < Math.min(ps.length, xs.length); i++)
;
return ps.slice(0, i);
}, files[0].split(/\/+|\\+/));
return res.length > 1 ? res.join("/") : "/";
};
}
});
// ../../node_modules/.pnpm/p-try@2.2.0/node_modules/p-try/index.js
var require_p_try = __commonJS({
"../../node_modules/.pnpm/p-try@2.2.0/node_modules/p-try/index.js"(exports, module2) {
"use strict";
var pTry = (fn, ...arguments_) => new Promise((resolve) => {
resolve(fn(...arguments_));
});
module2.exports = pTry;
module2.exports.default = pTry;
}
});
// ../../node_modules/.pnpm/p-limit@2.3.0/node_modules/p-limit/index.js
var require_p_limit = __commonJS({
"../../node_modules/.pnpm/p-limit@2.3.0/node_modules/p-limit/index.js"(exports, module2) {
"use strict";
var pTry = require_p_try();
var pLimit = (concurrency) => {
if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
return Promise.reject(new TypeError("Expected `concurrency` to be a number from 1 and up"));
}
const queue = [];
let activeCount = 0;
const next = () => {
activeCount--;
if (queue.length > 0) {
queue.shift()();
}
};
const run = (fn, resolve, ...args) => {
activeCount++;
const result = pTry(fn, ...args);
resolve(result);
result.then(next, next);
};
const enqueue = (fn, resolve, ...args) => {
if (activeCount < concurrency) {
run(fn, resolve, ...args);
} else {
queue.push(run.bind(null, fn, resolve, ...args));
}
};
const generator = (fn, ...args) => new Promise((resolve) => enqueue(fn, resolve, ...args));
Object.defineProperties(generator, {
activeCount: {
get: () => activeCount
},
pendingCount: {
get: () => queue.length
},
clearQueue: {
value: () => {
queue.length = 0;
}
}
});
return generator;
};
module2.exports = pLimit;
module2.exports.default = pLimit;
}
});
// ../../node_modules/.pnpm/p-locate@4.1.0/node_modules/p-locate/index.js
var require_p_locate = __commonJS({
"../../node_modules/.pnpm/p-locate@4.1.0/node_modules/p-locate/index.js"(exports, module2) {
"use strict";
var pLimit = require_p_limit();
var EndError = class extends Error {
constructor(value) {
super();
this.value = value;
}
};
var testElement = async (element, tester) => tester(await element);
var finder = async (element) => {
const values = await Promise.all(element);
if (values[1] === true) {
throw new EndError(values[0]);
}
return false;
};
var pLocate = async (iterable, tester, options2) => {
options2 = {
concurrency: Infinity,
preserveOrder: true,
...options2
};
const limit = pLimit(options2.concurrency);
const items = [...iterable].map((element) => [element, limit(testElement, element, tester)]);
const checkLimit = pLimit(options2.preserveOrder ? 1 : Infinity);
try {
await Promise.all(items.map((element) => checkLimit(finder, element)));
} catch (error) {
if (error instanceof EndError) {
return error.value;
}
throw error;
}
};
module2.exports = pLocate;
module2.exports.default = pLocate;
}
});
// ../../node_modules/.pnpm/locate-path@5.0.0/node_modules/locate-path/index.js
var require_locate_path = __commonJS({
"../../node_modules/.pnpm/locate-path@5.0.0/node_modules/locate-path/index.js"(exports, module2) {
"use strict";
var path7 = require("path");
var fs10 = require("fs");
var { promisify: promisify5 } = require("util");
var pLocate = require_p_locate();
var fsStat = promisify5(fs10.stat);
var fsLStat = promisify5(fs10.lstat);
var typeMappings = {
directory: "isDirectory",
file: "isFile"
};
function checkType({ type }) {
if (type in typeMappings) {
return;
}
throw new Error(`Invalid type specified: ${type}`);
}
var matchType = (type, stat) => type === void 0 || stat[typeMappings[type]]();
module2.exports = async (paths, options2) => {
options2 = {
cwd: process.cwd(),
type: "file",
allowSymlinks: true,
...options2
};
checkType(options2);
const statFn = options2.allowSymlinks ? fsStat : fsLStat;
return pLocate(paths, async (path_) => {
try {
const stat = await statFn(path7.resolve(options2.cwd, path_));
return matchType(options2.type, stat);
} catch (_) {
return false;
}
}, options2);
};
module2.exports.sync = (paths, options2) => {
options2 = {
cwd: process.cwd(),
allowSymlinks: true,
type: "file",
...options2
};
checkType(options2);
const statFn = options2.allowSymlinks ? fs10.statSync : fs10.lstatSync;
for (const path_ of paths) {
try {
const stat = statFn(path7.resolve(options2.cwd, path_));
if (matchType(options2.type, stat)) {
return path_;
}
} catch (_) {
}
}
};
}
});
// ../../node_modules/.pnpm/path-exists@4.0.0/node_modules/path-exists/index.js
var require_path_exists2 = __commonJS({
"../../node_modules/.pnpm/path-exists@4.0.0/node_modules/path-exists/index.js"(exports, module2) {
"use strict";
var fs10 = require("fs");
var { promisify: promisify5 } = require("util");
var pAccess = promisify5(fs10.access);
module2.exports = async (path7) => {
try {
await pAccess(path7);
return true;
} catch (_) {
return false;
}
};
module2.exports.sync = (path7) => {
try {
fs10.accessSync(path7);
return true;
} catch (_) {
return false;
}
};
}
});
// ../../node_modules/.pnpm/find-up@4.1.0/node_modules/find-up/index.js
var require_find_up = __commonJS({
"../../node_modules/.pnpm/find-up@4.1.0/node_modules/find-up/index.js"(exports, module2) {
"use strict";
var path7 = require("path");
var locatePath = require_locate_path();
var pathExists = require_path_exists2();
var stop = Symbol("findUp.stop");
module2.exports = async (name, options2 = {}) => {
let directory = path7.resolve(options2.cwd || "");
const { root } = path7.parse(directory);
const paths = [].concat(name);
const runMatcher = async (locateOptions) => {
if (typeof name !== "function") {
return locatePath(paths, locateOptions);
}
const foundPath = await name(locateOptions.cwd);
if (typeof foundPath === "string") {
return locatePath([foundPath], locateOptions);
}
return foundPath;
};
while (true) {
const foundPath = await runMatcher({ ...options2, cwd: directory });
if (foundPath === stop) {
return;
}
if (foundPath) {
return path7.resolve(directory, foundPath);
}
if (directory === root) {
return;
}
directory = path7.dirname(directory);
}
};
module2.exports.sync = (name, options2 = {}) => {
let directory = path7.resolve(options2.cwd || "");
const { root } = path7.parse(directory);
const paths = [].concat(name);
const runMatcher = (locateOptions) => {
if (typeof name !== "function") {
return locatePath.sync(paths, locateOptions);
}
const foundPath = name(locateOptions.cwd);
if (typeof foundPath === "string") {
return locatePath.sync([foundPath], locateOptions);
}
return foundPath;
};
while (true) {
const foundPath = runMatcher({ ...options2, cwd: directory });
if (foundPath === stop) {
return;
}
if (foundPath) {
return path7.resolve(directory, foundPath);
}
if (directory === root) {
return;
}
directory = path7.dirname(directory);
}
};
module2.exports.exists = pathExists;
module2.exports.sync.exists = pathExists.sync;
module2.exports.stop = stop;
}
});
// ../../node_modules/.pnpm/pkg-dir@4.2.0/node_modules/pkg-dir/index.js
var require_pkg_dir = __commonJS({
"../../node_modules/.pnpm/pkg-dir@4.2.0/node_modules/pkg-dir/index.js"(exports, module2) {
"use strict";
var path7 = require("path");
var findUp = require_find_up();
var pkgDir = async (cwd) => {
const filePath = await findUp("package.json", { cwd });
return filePath && path7.dirname(filePath);
};
module2.exports = pkgDir;
module2.exports.default = pkgDir;
module2.exports.sync = (cwd) => {
const filePath = findUp.sync("package.json", { cwd });
return filePath && path7.dirname(filePath);
};
}
});
// ../../node_modules/.pnpm/semver@6.3.0/node_modules/semver/semver.js
var require_semver = __commonJS({
"../../node_modules/.pnpm/semver@6.3.0/node_modules/semver/semver.js"(exports, module2) {
exports = module2.exports = SemVer;
var debug9;
if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
debug9 = function() {
var args = Array.prototype.slice.call(arguments, 0);
args.unshift("SEMVER");
console.log.apply(console, args);
};
} else {
debug9 = function() {
};
}
exports.SEMVER_SPEC_VERSION = "2.0.0";
var MAX_LENGTH = 256;
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
var MAX_SAFE_COMPONENT_LENGTH = 16;
var re = exports.re = [];
var src = exports.src = [];
var t3 = exports.tokens = {};
var R = 0;
function tok(n2) {
t3[n2] = R++;
}
tok("NUMERICIDENTIFIER");
src[t3.NUMERICIDENTIFIER] = "0|[1-9]\\d*";
tok("NUMERICIDENTIFIERLOOSE");
src[t3.NUMERICIDENTIFIERLOOSE] = "[0-9]+";
tok("NONNUMERICIDENTIFIER");
src[t3.NONNUMERICIDENTIFIER] = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
tok("MAINVERSION");
src[t3.MAINVERSION] = "(" + src[t3.NUMERICIDENTIFIER] + ")\\.(" + src[t3.NUMERICIDENTIFIER] + ")\\.(" + src[t3.NUMERICIDENTIFIER] + ")";
tok("MAINVERSIONLOOSE");
src[t3.MAINVERSIONLOOSE] = "(" + src[t3.NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[t3.NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[t3.NUMERICIDENTIFIERLOOSE] + ")";
tok("PRERELEASEIDENTIFIER");
src[t3.PRERELEASEIDENTIFIER] = "(?:" + src[t3.NUMERICIDENTIFIER] + "|" + src[t3.NONNUMERICIDENTIFIER] + ")";
tok("PRERELEASEIDENTIFIERLOOSE");
src[t3.PRERELEASEIDENTIFIERLOOSE] = "(?:" + src[t3.NUMERICIDENTIFIERLOOSE] + "|" + src[t3.NONNUMERICIDENTIFIER] + ")";
tok("PRERELEASE");
src[t3.PRERELEASE] = "(?:-(" + src[t3.PRERELEASEIDENTIFIER] + "(?:\\." + src[t3.PRERELEASEIDENTIFIER] + ")*))";
tok("PRERELEASELOOSE");
src[t3.PRERELEASELOOSE] = "(?:-?(" + src[t3.PRERELEASEIDENTIFIERLOOSE] + "(?:\\." + src[t3.PRERELEASEIDENTIFIERLOOSE] + ")*))";
tok("BUILDIDENTIFIER");
src[t3.BUILDIDENTIFIER] = "[0-9A-Za-z-]+";
tok("BUILD");
src[t3.BUILD] = "(?:\\+(" + src[t3.BUILDIDENTIFIER] + "(?:\\." + src[t3.BUILDIDENTIFIER] + ")*))";
tok("FULL");
tok("FULLPLAIN");
src[t3.FULLPLAIN] = "v?" + src[t3.MAINVERSION] + src[t3.PRERELEASE] + "?" + src[t3.BUILD] + "?";
src[t3.FULL] = "^" + src[t3.FULLPLAIN] + "$";
tok("LOOSEPLAIN");
src[t3.LOOSEPLAIN] = "[v=\\s]*" + src[t3.MAINVERSIONLOOSE] + src[t3.PRERELEASELOOSE] + "?" + src[t3.BUILD] + "?";
tok("LOOSE");
src[t3.LOOSE] = "^" + src[t3.LOOSEPLAIN] + "$";
tok("GTLT");
src[t3.GTLT] = "((?:<|>)?=?)";
tok("XRANGEIDENTIFIERLOOSE");
src[t3.XRANGEIDENTIFIERLOOSE] = src[t3.NUMERICIDENTIFIERLOOSE] + "|x|X|\\*";
tok("XRANGEIDENTIFIER");
src[t3.XRANGEIDENTIFIER] = src[t3.NUMERICIDENTIFIER] + "|x|X|\\*";
tok("XRANGEPLAIN");
src[t3.XRANGEPLAIN] = "[v=\\s]*(" + src[t3.XRANGEIDENTIFIER] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIER] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIER] + ")(?:" + src[t3.PRERELEASE] + ")?" + src[t3.BUILD] + "?)?)?";
tok("XRANGEPLAINLOOSE");
src[t3.XRANGEPLAINLOOSE] = "[v=\\s]*(" + src[t3.XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIERLOOSE] + ")(?:" + src[t3.PRERELEASELOOSE] + ")?" + src[t3.BUILD] + "?)?)?";
tok("XRANGE");
src[t3.XRANGE] = "^" + src[t3.GTLT] + "\\s*" + src[t3.XRANGEPLAIN] + "$";
tok("XRANGELOOSE");
src[t3.XRANGELOOSE] = "^" + src[t3.GTLT] + "\\s*" + src[t3.XRANGEPLAINLOOSE] + "$";
tok("COERCE");
src[t3.COERCE] = "(^|[^\\d])(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "})(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:$|[^\\d])";
tok("COERCERTL");
re[t3.COERCERTL] = new RegExp(src[t3.COERCE], "g");
tok("LONETILDE");
src[t3.LONETILDE] = "(?:~>?)";
tok("TILDETRIM");
src[t3.TILDETRIM] = "(\\s*)" + src[t3.LONETILDE] + "\\s+";
re[t3.TILDETRIM] = new RegExp(src[t3.TILDETRIM], "g");
var tildeTrimReplace = "$1~";
tok("TILDE");
src[t3.TILDE] = "^" + src[t3.LONETILDE] + src[t3.XRANGEPLAIN] + "$";
tok("TILDELOOSE");
src[t3.TILDELOOSE] = "^" + src[t3.LONETILDE] + src[t3.XRANGEPLAINLOOSE] + "$";
tok("LONECARET");
src[t3.LONECARET] = "(?:\\^)";
tok("CARETTRIM");
src[t3.CARETTRIM] = "(\\s*)" + src[t3.LONECARET] + "\\s+";
re[t3.CARETTRIM] = new RegExp(src[t3.CARETTRIM], "g");
var caretTrimReplace = "$1^";
tok("CARET");
src[t3.CARET] = "^" + src[t3.LONECARET] + src[t3.XRANGEPLAIN] + "$";
tok("CARETLOOSE");
src[t3.CARETLOOSE] = "^" + src[t3.LONECARET] + src[t3.XRANGEPLAINLOOSE] + "$";
tok("COMPARATORLOOSE");
src[t3.COMPARATORLOOSE] = "^" + src[t3.GTLT] + "\\s*(" + src[t3.LOOSEPLAIN] + ")$|^$";
tok("COMPARATOR");
src[t3.COMPARATOR] = "^" + src[t3.GTLT] + "\\s*(" + src[t3.FULLPLAIN] + ")$|^$";
tok("COMPARATORTRIM");
src[t3.COMPARATORTRIM] = "(\\s*)" + src[t3.GTLT] + "\\s*(" + src[t3.LOOSEPLAIN] + "|" + src[t3.XRANGEPLAIN] + ")";
re[t3.COMPARATORTRIM] = new RegExp(src[t3.COMPARATORTRIM], "g");
var comparatorTrimReplace = "$1$2$3";
tok("HYPHENRANGE");
src[t3.HYPHENRANGE] = "^\\s*(" + src[t3.XRANGEPLAIN] + ")\\s+-\\s+(" + src[t3.XRANGEPLAIN] + ")\\s*$";
tok("HYPHENRANGELOOSE");
src[t3.HYPHENRANGELOOSE] = "^\\s*(" + src[t3.XRANGEPLAINLOOSE] + ")\\s+-\\s+(" + src[t3.XRANGEPLAINLOOSE] + ")\\s*$";
tok("STAR");
src[t3.STAR] = "(<|>)?=?\\s*\\*";
for (i = 0; i < R; i++) {
debug9(i, src[i]);
if (!re[i]) {
re[i] = new RegExp(src[i]);
}
}
var i;
exports.parse = parse;
function parse(version, options2) {
if (!options2 || typeof options2 !== "object") {
options2 = {
loose: !!options2,
includePrerelease: false
};
}
if (version instanceof SemVer) {
return version;
}
if (typeof version !== "string") {
return null;
}
if (version.length > MAX_LENGTH) {
return null;
}
var r2 = options2.loose ? re[t3.LOOSE] : re[t3.FULL];
if (!r2.test(version)) {
return null;
}
try {
return new SemVer(version, options2);
} catch (er) {
return null;
}
}
exports.valid = valid;
function valid(version, options2) {
var v = parse(version, options2);
return v ? v.version : null;
}
exports.clean = clean;
function clean(version, options2) {
var s = parse(version.trim().replace(/^[=v]+/, ""), options2);
return s ? s.version : null;
}
exports.SemVer = SemVer;
function SemVer(version, options2) {
if (!options2 || typeof options2 !== "object") {
options2 = {
loose: !!options2,
includePrerelease: false
};
}
if (version instanceof SemVer) {
if (version.loose === options2.loose) {
return version;
} else {
version = version.version;
}
} else if (typeof version !== "string") {
throw new TypeError("Invalid Version: " + version);
}
if (version.length > MAX_LENGTH) {
throw new TypeError("version is longer than " + MAX_LENGTH + " characters");
}
if (!(this instanceof SemVer)) {
return new SemVer(version, options2);
}
debug9("SemVer", version, options2);
this.options = options2;
this.loose = !!options2.loose;
var m = version.trim().match(options2.loose ? re[t3.LOOSE] : re[t3.FULL]);
if (!m) {
throw new TypeError("Invalid Version: " + version);
}
this.raw = version;
this.major = +m[1];
this.minor = +m[2];
this.patch = +m[3];
if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
throw new TypeError("Invalid major version");
}
if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
throw new TypeError("Invalid minor version");
}
if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
throw new TypeError("Invalid patch version");
}
if (!m[4]) {
this.prerelease = [];
} else {
this.prerelease = m[4].split(".").map(function(id) {
if (/^[0-9]+$/.test(id)) {
var num = +id;
if (num >= 0 && num < MAX_SAFE_INTEGER) {
return num;
}
}
return id;
});
}
this.build = m[5] ? m[5].split(".") : [];
this.format();
}
SemVer.prototype.format = function() {
this.version = this.major + "." + this.minor + "." + this.patch;
if (this.prerelease.length) {
this.version += "-" + this.prerelease.join(".");
}
return this.version;
};
SemVer.prototype.toString = function() {
return this.version;
};
SemVer.prototype.compare = function(other) {
debug9("SemVer.compare", this.version, this.options, other);
if (!(other instanceof SemVer)) {
other = new SemVer(other, this.options);
}
return this.compareMain(other) || this.comparePre(other);
};
SemVer.prototype.compareMain = function(other) {
if (!(other instanceof SemVer)) {
other = new SemVer(other, this.options);
}
return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
};
SemVer.prototype.comparePre = function(other) {
if (!(other instanceof SemVer)) {
other = new SemVer(other, this.options);
}
if (this.prerelease.length && !other.prerelease.length) {
return -1;
} else if (!this.prerelease.length && other.prerelease.length) {
return 1;
} else if (!this.prerelease.length && !other.prerelease.length) {
return 0;
}
var i2 = 0;
do {
var a = this.prerelease[i2];
var b2 = other.prerelease[i2];
debug9("prerelease compare", i2, a, b2);
if (a === void 0 && b2 === void 0) {
return 0;
} else if (b2 === void 0) {
return 1;
} else if (a === void 0) {
return -1;
} else if (a === b2) {
continue;
} else {
return compareIdentifiers(a, b2);
}
} while (++i2);
};
SemVer.prototype.compareBuild = function(other) {
if (!(other instanceof SemVer)) {
other = new SemVer(other, this.options);
}
var i2 = 0;
do {
var a = this.build[i2];
var b2 = other.build[i2];
debug9("prerelease compare", i2, a, b2);
if (a === void 0 && b2 === void 0) {
return 0;
} else if (b2 === void 0) {
return 1;
} else if (a === void 0) {
return -1;
} else if (a === b2) {
continue;
} else {
return compareIdentifiers(a, b2);
}
} while (++i2);
};
SemVer.prototype.inc = function(release, identifier) {
switch (release) {
case "premajor":
this.prerelease.length = 0;
this.patch = 0;
this.minor = 0;
this.major++;
this.inc("pre", identifier);
break;
case "preminor":
this.prerelease.length = 0;
this.patch = 0;
this.minor++;
this.inc("pre", identifier);
break;
case "prepatch":
this.prerelease.length = 0;
this.inc("patch", identifier);
this.inc("pre", identifier);
break;
case "prerelease":
if (this.prerelease.length === 0) {
this.inc("patch", identifier);
}
this.inc("pre", identifier);
break;
case "major":
if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
this.major++;
}
this.minor = 0;
this.patch = 0;
this.prerelease = [];
break;
case "minor":
if (this.patch !== 0 || this.prerelease.length === 0) {
this.minor++;
}
this.patch = 0;
this.prerelease = [];
break;
case "patch":
if (this.prerelease.length === 0) {
this.patch++;
}
this.prerelease = [];
break;
case "pre":
if (this.prerelease.length === 0) {
this.prerelease = [0];
} else {
var i2 = this.prerelease.length;
while (--i2 >= 0) {
if (typeof this.prerelease[i2] === "number") {
this.prerelease[i2]++;
i2 = -2;
}
}
if (i2 === -1) {
this.prerelease.push(0);
}
}
if (identifier) {
if (this.prerelease[0] === identifier) {
if (isNaN(this.prerelease[1])) {
this.prerelease = [identifier, 0];
}
} else {
this.prerelease = [identifier, 0];
}
}
break;
default:
throw new Error("invalid increment argument: " + release);
}
this.format();
this.raw = this.version;
return this;
};
exports.inc = inc;
function inc(version, release, loose, identifier) {
if (typeof loose === "string") {
identifier = loose;
loose = void 0;
}
try {
return new SemVer(version, loose).inc(release, identifier).version;
} catch (er) {
return null;
}
}
exports.diff = diff;
function diff(version1, version2) {
if (eq(version1, version2)) {
return null;
} else {
var v1 = parse(version1);
var v2 = parse(version2);
var prefix = "";
if (v1.prerelease.length || v2.prerelease.length) {
prefix = "pre";
var defaultResult = "prerelease";
}
for (var key in v1) {
if (key === "major" || key === "minor" || key === "patch") {
if (v1[key] !== v2[key]) {
return prefix + key;
}
}
}
return defaultResult;
}
}
exports.compareIdentifiers = compareIdentifiers;
var numeric = /^[0-9]+$/;
function compareIdentifiers(a, b2) {
var anum = numeric.test(a);
var bnum = numeric.test(b2);
if (anum && bnum) {
a = +a;
b2 = +b2;
}
return a === b2 ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b2 ? -1 : 1;
}
exports.rcompareIdentifiers = rcompareIdentifiers;
function rcompareIdentifiers(a, b2) {
return compareIdentifiers(b2, a);
}
exports.major = major;
function major(a, loose) {
return new SemVer(a, loose).major;
}
exports.minor = minor;
function minor(a, loose) {
return new SemVer(a, loose).minor;
}
exports.patch = patch;
function patch(a, loose) {
return new SemVer(a, loose).patch;
}
exports.compare = compare;
function compare(a, b2, loose) {
return new SemVer(a, loose).compare(new SemVer(b2, loose));
}
exports.compareLoose = compareLoose;
function compareLoose(a, b2) {
return compare(a, b2, true);
}
exports.compareBuild = compareBuild;
function compareBuild(a, b2, loose) {
var versionA = new SemVer(a, loose);
var versionB = new SemVer(b2, loose);
return versionA.compare(versionB) || versionA.compareBuild(versionB);
}
exports.rcompare = rcompare;
function rcompare(a, b2, loose) {
return compare(b2, a, loose);
}
exports.sort = sort;
function sort(list, loose) {
return list.sort(function(a, b2) {
return exports.compareBuild(a, b2, loose);
});
}
exports.rsort = rsort;
function rsort(list, loose) {
return list.sort(function(a, b2) {
return exports.compareBuild(b2, a, loose);
});
}
exports.gt = gt;
function gt(a, b2, loose) {
return compare(a, b2, loose) > 0;
}
exports.lt = lt;
function lt(a, b2, loose) {
return compare(a, b2, loose) < 0;
}
exports.eq = eq;
function eq(a, b2, loose) {
return compare(a, b2, loose) === 0;
}
exports.neq = neq;
function neq(a, b2, loose) {
return compare(a, b2, loose) !== 0;
}
exports.gte = gte;
function gte(a, b2, loose) {
return compare(a, b2, loose) >= 0;
}
exports.lte = lte;
function lte(a, b2, loose) {
return compare(a, b2, loose) <= 0;
}
exports.cmp = cmp;
function cmp(a, op, b2, loose) {
switch (op) {
case "===":
if (typeof a === "object")
a = a.version;
if (typeof b2 === "object")
b2 = b2.version;
return a === b2;
case "!==":
if (typeof a === "object")
a = a.version;
if (typeof b2 === "object")
b2 = b2.version;
return a !== b2;
case "":
case "=":
case "==":
return eq(a, b2, loose);
case "!=":
return neq(a, b2, loose);
case ">":
return gt(a, b2, loose);
case ">=":
return gte(a, b2, loose);
case "<":
return lt(a, b2, loose);
case "<=":
return lte(a, b2, loose);
default:
throw new TypeError("Invalid operator: " + op);
}
}
exports.Comparator = Comparator;
function Comparator(comp, options2) {
if (!options2 || typeof options2 !== "object") {
options2 = {
loose: !!options2,
includePrerelease: false
};
}
if (comp instanceof Comparator) {
if (comp.loose === !!options2.loose) {
return comp;
} else {
comp = comp.value;
}
}
if (!(this instanceof Comparator)) {
return new Comparator(comp, options2);
}
debug9("comparator", comp, options2);
this.options = options2;
this.loose = !!options2.loose;
this.parse(comp);
if (this.semver === ANY) {
this.value = "";
} else {
this.value = this.operator + this.semver.version;
}
debug9("comp", this);
}
var ANY = {};
Comparator.prototype.parse = function(comp) {
var r2 = this.options.loose ? re[t3.COMPARATORLOOSE] : re[t3.COMPARATOR];
var m = comp.match(r2);
if (!m) {
throw new TypeError("Invalid comparator: " + comp);
}
this.operator = m[1] !== void 0 ? m[1] : "";
if (this.operator === "=") {
this.operator = "";
}
if (!m[2]) {
this.semver = ANY;
} else {
this.semver = new SemVer(m[2], this.options.loose);
}
};
Comparator.prototype.toString = function() {
return this.value;
};
Comparator.prototype.test = function(version) {
debug9("Comparator.test", version, this.options.loose);
if (this.semver === ANY || version === ANY) {
return true;
}
if (typeof version === "string") {
try {
version = new SemVer(version, this.options);
} catch (er) {
return false;
}
}
return cmp(version, this.operator, this.semver, this.options);
};
Comparator.prototype.intersects = function(comp, options2) {
if (!(comp instanceof Comparator)) {
throw new TypeError("a Comparator is required");
}
if (!options2 || typeof options2 !== "object") {
options2 = {
loose: !!options2,
includePrerelease: false
};
}
var rangeTmp;
if (this.operator === "") {
if (this.value === "") {
return true;
}
rangeTmp = new Range(comp.value, options2);
return satisfies(this.value, rangeTmp, options2);
} else if (comp.operator === "") {
if (comp.value === "") {
return true;
}
rangeTmp = new Range(this.value, options2);
return satisfies(comp.semver, rangeTmp, options2);
}
var sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
var sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
var sameSemVer = this.semver.version === comp.semver.version;
var differentDirectionsInclusive = (this.operator === ">=" || this.operator === "<=") && (comp.operator === ">=" || comp.operator === "<=");
var oppositeDirectionsLessThan = cmp(this.semver, "<", comp.semver, options2) && ((this.operator === ">=" || this.operator === ">") && (comp.operator === "<=" || comp.operator === "<"));
var oppositeDirectionsGreaterThan = cmp(this.semver, ">", comp.semver, options2) && ((this.operator === "<=" || this.operator === "<") && (comp.operator === ">=" || comp.operator === ">"));
return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
};
exports.Range = Range;
function Range(range, options2) {
if (!options2 || typeof options2 !== "object") {
options2 = {
loose: !!options2,
includePrerelease: false
};
}
if (range instanceof Range) {
if (range.loose === !!options2.loose && range.includePrerelease === !!options2.includePrerelease) {
return range;
} else {
return new Range(range.raw, options2);
}
}
if (range instanceof Comparator) {
return new Range(range.value, options2);
}
if (!(this instanceof Range)) {
return new Range(range, options2);
}
this.options = options2;
this.loose = !!options2.loose;
this.includePrerelease = !!options2.includePrerelease;
this.raw = range;
this.set = range.split(/\s*\|\|\s*/).map(function(range2) {
return this.parseRange(range2.trim());
}, this).filter(function(c) {
return c.length;
});
if (!this.set.length) {
throw new TypeError("Invalid SemVer Range: " + range);
}
this.format();
}
Range.prototype.format = function() {
this.range = this.set.map(function(comps) {
return comps.join(" ").trim();
}).join("||").trim();
return this.range;
};
Range.prototype.toString = function() {
return this.range;
};
Range.prototype.parseRange = function(range) {
var loose = this.options.loose;
ran
Showing 512.00 KB of 1.50 MB. Use Edit/Download for full content.
Directory Contents
Dirs: 1 × Files: 2