58f8093689
- Updated all component headers and documentation
- Changed navbar and footer branding
- Updated homepage hero badge
- Modified page title in index.html
- Simplified footer text to 'Built with ❤️'
- Consistent V2 capitalization across all references
2787 lines
87 KiB
JavaScript
2787 lines
87 KiB
JavaScript
"use strict";
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
var chunk_RGVHWUUH_exports = {};
|
|
__export(chunk_RGVHWUUH_exports, {
|
|
require_p_map: () => require_p_map,
|
|
require_rimraf: () => require_rimraf
|
|
});
|
|
module.exports = __toCommonJS(chunk_RGVHWUUH_exports);
|
|
var import_chunk_AH6QHEOA = require("./chunk-AH6QHEOA.js");
|
|
var require_indent_string = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/indent-string@4.0.0/node_modules/indent-string/index.js"(exports, module2) {
|
|
"use strict";
|
|
module2.exports = (string, count = 1, options) => {
|
|
options = {
|
|
indent: " ",
|
|
includeEmptyLines: false,
|
|
...options
|
|
};
|
|
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 options.indent !== "string") {
|
|
throw new TypeError(
|
|
`Expected \`options.indent\` to be a \`string\`, got \`${typeof options.indent}\``
|
|
);
|
|
}
|
|
if (count === 0) {
|
|
return string;
|
|
}
|
|
const regex = options.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
|
|
return string.replace(regex, options.indent.repeat(count));
|
|
};
|
|
}
|
|
});
|
|
var require_clean_stack = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/clean-stack@2.2.0/node_modules/clean-stack/index.js"(exports, module2) {
|
|
"use strict";
|
|
var os = (0, import_chunk_AH6QHEOA.__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 os.homedir === "undefined" ? "" : os.homedir();
|
|
module2.exports = (stack, options) => {
|
|
options = Object.assign({ pretty: false }, options);
|
|
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 (options.pretty) {
|
|
return line.replace(extractPathRegex, (m, p1) => m.replace(p1, p1.replace(homeDir, "~")));
|
|
}
|
|
return line;
|
|
}).join("\n");
|
|
};
|
|
}
|
|
});
|
|
var require_aggregate_error = (0, import_chunk_AH6QHEOA.__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;
|
|
}
|
|
});
|
|
var require_p_map = (0, import_chunk_AH6QHEOA.__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;
|
|
}
|
|
}
|
|
});
|
|
};
|
|
}
|
|
});
|
|
var require_old = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js"(exports) {
|
|
"use strict";
|
|
var pathModule = (0, import_chunk_AH6QHEOA.__require)("path");
|
|
var isWindows = process.platform === "win32";
|
|
var fs = (0, import_chunk_AH6QHEOA.__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(p, cache) {
|
|
p = pathModule.resolve(p);
|
|
if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
|
|
return cache[p];
|
|
}
|
|
var original = p, seenLinks = {}, knownHard = {};
|
|
var pos;
|
|
var current;
|
|
var base;
|
|
var previous;
|
|
start();
|
|
function start() {
|
|
var m = splitRootRe.exec(p);
|
|
pos = m[0].length;
|
|
current = m[0];
|
|
base = m[0];
|
|
previous = "";
|
|
if (isWindows && !knownHard[base]) {
|
|
fs.lstatSync(base);
|
|
knownHard[base] = true;
|
|
}
|
|
}
|
|
while (pos < p.length) {
|
|
nextPartRe.lastIndex = pos;
|
|
var result = nextPartRe.exec(p);
|
|
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 = fs.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) {
|
|
fs.statSync(base);
|
|
linkTarget = fs.readlinkSync(base);
|
|
}
|
|
resolvedLink = pathModule.resolve(previous, linkTarget);
|
|
if (cache) cache[base] = resolvedLink;
|
|
if (!isWindows) seenLinks[id] = linkTarget;
|
|
}
|
|
p = pathModule.resolve(resolvedLink, p.slice(pos));
|
|
start();
|
|
}
|
|
if (cache) cache[original] = p;
|
|
return p;
|
|
};
|
|
exports.realpath = function realpath(p, cache, cb) {
|
|
if (typeof cb !== "function") {
|
|
cb = maybeCallback(cache);
|
|
cache = null;
|
|
}
|
|
p = pathModule.resolve(p);
|
|
if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
|
|
return process.nextTick(cb.bind(null, null, cache[p]));
|
|
}
|
|
var original = p, seenLinks = {}, knownHard = {};
|
|
var pos;
|
|
var current;
|
|
var base;
|
|
var previous;
|
|
start();
|
|
function start() {
|
|
var m = splitRootRe.exec(p);
|
|
pos = m[0].length;
|
|
current = m[0];
|
|
base = m[0];
|
|
previous = "";
|
|
if (isWindows && !knownHard[base]) {
|
|
fs.lstat(base, function(err) {
|
|
if (err) return cb(err);
|
|
knownHard[base] = true;
|
|
LOOP();
|
|
});
|
|
} else {
|
|
process.nextTick(LOOP);
|
|
}
|
|
}
|
|
function LOOP() {
|
|
if (pos >= p.length) {
|
|
if (cache) cache[original] = p;
|
|
return cb(null, p);
|
|
}
|
|
nextPartRe.lastIndex = pos;
|
|
var result = nextPartRe.exec(p);
|
|
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 fs.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);
|
|
}
|
|
}
|
|
fs.stat(base, function(err2) {
|
|
if (err2) return cb(err2);
|
|
fs.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) {
|
|
p = pathModule.resolve(resolvedLink, p.slice(pos));
|
|
start();
|
|
}
|
|
};
|
|
}
|
|
});
|
|
var require_fs = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/index.js"(exports, module2) {
|
|
"use strict";
|
|
module2.exports = realpath;
|
|
realpath.realpath = realpath;
|
|
realpath.sync = realpathSync;
|
|
realpath.realpathSync = realpathSync;
|
|
realpath.monkeypatch = monkeypatch;
|
|
realpath.unmonkeypatch = unmonkeypatch;
|
|
var fs = (0, import_chunk_AH6QHEOA.__require)("fs");
|
|
var origRealpath = fs.realpath;
|
|
var origRealpathSync = fs.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(p, cache, cb) {
|
|
if (ok) {
|
|
return origRealpath(p, cache, cb);
|
|
}
|
|
if (typeof cache === "function") {
|
|
cb = cache;
|
|
cache = null;
|
|
}
|
|
origRealpath(p, cache, function(er, result) {
|
|
if (newError(er)) {
|
|
old.realpath(p, cache, cb);
|
|
} else {
|
|
cb(er, result);
|
|
}
|
|
});
|
|
}
|
|
function realpathSync(p, cache) {
|
|
if (ok) {
|
|
return origRealpathSync(p, cache);
|
|
}
|
|
try {
|
|
return origRealpathSync(p, cache);
|
|
} catch (er) {
|
|
if (newError(er)) {
|
|
return old.realpathSync(p, cache);
|
|
} else {
|
|
throw er;
|
|
}
|
|
}
|
|
}
|
|
function monkeypatch() {
|
|
fs.realpath = realpath;
|
|
fs.realpathSync = realpathSync;
|
|
}
|
|
function unmonkeypatch() {
|
|
fs.realpath = origRealpath;
|
|
fs.realpathSync = origRealpathSync;
|
|
}
|
|
}
|
|
});
|
|
var require_concat_map = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/concat-map@0.0.1/node_modules/concat-map/index.js"(exports, module2) {
|
|
"use strict";
|
|
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]";
|
|
};
|
|
}
|
|
});
|
|
var require_balanced_match = (0, import_chunk_AH6QHEOA.__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, b, str) {
|
|
if (a instanceof RegExp) a = maybeMatch(a, str);
|
|
if (b instanceof RegExp) b = maybeMatch(b, str);
|
|
var r = range(a, b, str);
|
|
return r && {
|
|
start: r[0],
|
|
end: r[1],
|
|
pre: str.slice(0, r[0]),
|
|
body: str.slice(r[0] + a.length, r[1]),
|
|
post: str.slice(r[1] + b.length)
|
|
};
|
|
}
|
|
function maybeMatch(reg, str) {
|
|
var m = str.match(reg);
|
|
return m ? m[0] : null;
|
|
}
|
|
balanced.range = range;
|
|
function range(a, b, str) {
|
|
var begs, beg, left, right, result;
|
|
var ai = str.indexOf(a);
|
|
var bi = str.indexOf(b, ai + 1);
|
|
var i = ai;
|
|
if (ai >= 0 && bi > 0) {
|
|
if (a === b) {
|
|
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(b, i + 1);
|
|
}
|
|
i = ai < bi && ai >= 0 ? ai : bi;
|
|
}
|
|
if (begs.length) {
|
|
result = [left, right];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
});
|
|
var require_brace_expansion = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/brace-expansion@1.1.11/node_modules/brace-expansion/index.js"(exports, module2) {
|
|
"use strict";
|
|
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 p = pre.split(",");
|
|
p[p.length - 1] += "{" + body + "}";
|
|
var postParts = parseCommaParts(post);
|
|
if (post.length) {
|
|
p[p.length - 1] += postParts.shift();
|
|
p.push.apply(p, postParts);
|
|
}
|
|
parts.push.apply(parts, p);
|
|
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, y) {
|
|
return i <= y;
|
|
}
|
|
function gte(i, y) {
|
|
return i >= y;
|
|
}
|
|
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 n;
|
|
if (isSequence) {
|
|
n = m.body.split(/\.\./);
|
|
} else {
|
|
n = parseCommaParts(m.body);
|
|
if (n.length === 1) {
|
|
n = expand(n[0], false).map(embrace);
|
|
if (n.length === 1) {
|
|
var post = m.post.length ? expand(m.post, false) : [""];
|
|
return post.map(function(p) {
|
|
return m.pre + n[0] + p;
|
|
});
|
|
}
|
|
}
|
|
}
|
|
var pre = m.pre;
|
|
var post = m.post.length ? expand(m.post, false) : [""];
|
|
var N;
|
|
if (isSequence) {
|
|
var x = numeric(n[0]);
|
|
var y = numeric(n[1]);
|
|
var width = Math.max(n[0].length, n[1].length);
|
|
var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
|
|
var test = lte;
|
|
var reverse = y < x;
|
|
if (reverse) {
|
|
incr *= -1;
|
|
test = gte;
|
|
}
|
|
var pad = n.some(isPadded);
|
|
N = [];
|
|
for (var i = x; test(i, y); 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(n, 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;
|
|
}
|
|
}
|
|
});
|
|
var require_minimatch = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/minimatch@3.1.2/node_modules/minimatch/minimatch.js"(exports, module2) {
|
|
"use strict";
|
|
module2.exports = minimatch;
|
|
minimatch.Minimatch = Minimatch;
|
|
var path = function() {
|
|
try {
|
|
return (0, import_chunk_AH6QHEOA.__require)("path");
|
|
} catch (e) {
|
|
}
|
|
}() || {
|
|
sep: "/"
|
|
};
|
|
minimatch.sep = path.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, options) {
|
|
options = options || {};
|
|
return function(p, i, list) {
|
|
return minimatch(p, pattern, options);
|
|
};
|
|
}
|
|
function ext(a, b) {
|
|
b = b || {};
|
|
var t = {};
|
|
Object.keys(a).forEach(function(k) {
|
|
t[k] = a[k];
|
|
});
|
|
Object.keys(b).forEach(function(k) {
|
|
t[k] = b[k];
|
|
});
|
|
return t;
|
|
}
|
|
minimatch.defaults = function(def) {
|
|
if (!def || typeof def !== "object" || !Object.keys(def).length) {
|
|
return minimatch;
|
|
}
|
|
var orig = minimatch;
|
|
var m = function minimatch2(p, pattern, options) {
|
|
return orig(p, pattern, ext(def, options));
|
|
};
|
|
m.Minimatch = function Minimatch2(pattern, options) {
|
|
return new orig.Minimatch(pattern, ext(def, options));
|
|
};
|
|
m.Minimatch.defaults = function defaults(options) {
|
|
return orig.defaults(ext(def, options)).Minimatch;
|
|
};
|
|
m.filter = function filter2(pattern, options) {
|
|
return orig.filter(pattern, ext(def, options));
|
|
};
|
|
m.defaults = function defaults(options) {
|
|
return orig.defaults(ext(def, options));
|
|
};
|
|
m.makeRe = function makeRe2(pattern, options) {
|
|
return orig.makeRe(pattern, ext(def, options));
|
|
};
|
|
m.braceExpand = function braceExpand2(pattern, options) {
|
|
return orig.braceExpand(pattern, ext(def, options));
|
|
};
|
|
m.match = function(list, pattern, options) {
|
|
return orig.match(list, pattern, ext(def, options));
|
|
};
|
|
return m;
|
|
};
|
|
Minimatch.defaults = function(def) {
|
|
return minimatch.defaults(def).Minimatch;
|
|
};
|
|
function minimatch(p, pattern, options) {
|
|
assertValidPattern(pattern);
|
|
if (!options) options = {};
|
|
if (!options.nocomment && pattern.charAt(0) === "#") {
|
|
return false;
|
|
}
|
|
return new Minimatch(pattern, options).match(p);
|
|
}
|
|
function Minimatch(pattern, options) {
|
|
if (!(this instanceof Minimatch)) {
|
|
return new Minimatch(pattern, options);
|
|
}
|
|
assertValidPattern(pattern);
|
|
if (!options) options = {};
|
|
pattern = pattern.trim();
|
|
if (!options.allowWindowsEscape && path.sep !== "/") {
|
|
pattern = pattern.split(path.sep).join("/");
|
|
}
|
|
this.options = options;
|
|
this.set = [];
|
|
this.pattern = pattern;
|
|
this.regexp = null;
|
|
this.negate = false;
|
|
this.comment = false;
|
|
this.empty = false;
|
|
this.partial = !!options.partial;
|
|
this.make();
|
|
}
|
|
Minimatch.prototype.debug = function() {
|
|
};
|
|
Minimatch.prototype.make = make;
|
|
function make() {
|
|
var pattern = this.pattern;
|
|
var options = this.options;
|
|
if (!options.nocomment && pattern.charAt(0) === "#") {
|
|
this.comment = true;
|
|
return;
|
|
}
|
|
if (!pattern) {
|
|
this.empty = true;
|
|
return;
|
|
}
|
|
this.parseNegate();
|
|
var set = this.globSet = this.braceExpand();
|
|
if (options.debug) this.debug = function debug() {
|
|
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 options = this.options;
|
|
var negateOffset = 0;
|
|
if (options.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, options) {
|
|
return braceExpand(pattern, options);
|
|
};
|
|
Minimatch.prototype.braceExpand = braceExpand;
|
|
function braceExpand(pattern, options) {
|
|
if (!options) {
|
|
if (this instanceof Minimatch) {
|
|
options = this.options;
|
|
} else {
|
|
options = {};
|
|
}
|
|
}
|
|
pattern = typeof pattern === "undefined" ? this.pattern : pattern;
|
|
assertValidPattern(pattern);
|
|
if (options.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 options = this.options;
|
|
if (pattern === "**") {
|
|
if (!options.noglobstar)
|
|
return GLOBSTAR;
|
|
else
|
|
pattern = "*";
|
|
}
|
|
if (pattern === "") return "";
|
|
var re = "";
|
|
var hasMagic = !!options.nocase;
|
|
var escaping = false;
|
|
var patternListStack = [];
|
|
var negativeLists = [];
|
|
var stateChar;
|
|
var inClass = false;
|
|
var reClassStart = -1;
|
|
var classStart = -1;
|
|
var patternStart = pattern.charAt(0) === "." ? "" : options.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 (options.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 t = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
|
|
hasMagic = true;
|
|
re = re.slice(0, pl.reStart) + t + "\\(" + tail;
|
|
}
|
|
clearStateChar();
|
|
if (escaping) {
|
|
re += "\\\\";
|
|
}
|
|
var addPatternStart = false;
|
|
switch (re.charAt(0)) {
|
|
case "[":
|
|
case ".":
|
|
case "(":
|
|
addPatternStart = true;
|
|
}
|
|
for (var n = negativeLists.length - 1; n > -1; n--) {
|
|
var nl = negativeLists[n];
|
|
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 = options.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, options) {
|
|
return new Minimatch(pattern, options || {}).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 options = this.options;
|
|
var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
|
|
var flags = options.nocase ? "i" : "";
|
|
var re = set.map(function(pattern) {
|
|
return pattern.map(function(p) {
|
|
return p === GLOBSTAR ? twoStar : typeof p === "string" ? regExpEscape(p) : p._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, options) {
|
|
options = options || {};
|
|
var mm = new Minimatch(pattern, options);
|
|
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 options = this.options;
|
|
if (path.sep !== "/") {
|
|
f = f.split(path.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 file = f;
|
|
if (options.matchBase && pattern.length === 1) {
|
|
file = [filename];
|
|
}
|
|
var hit = this.matchOne(file, pattern, partial);
|
|
if (hit) {
|
|
if (options.flipNegate) return true;
|
|
return !this.negate;
|
|
}
|
|
}
|
|
if (options.flipNegate) return false;
|
|
return this.negate;
|
|
};
|
|
Minimatch.prototype.matchOne = function(file, pattern, partial) {
|
|
var options = this.options;
|
|
this.debug(
|
|
"matchOne",
|
|
{ "this": this, file, pattern }
|
|
);
|
|
this.debug("matchOne", file.length, pattern.length);
|
|
for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
|
|
this.debug("matchOne loop");
|
|
var p = pattern[pi];
|
|
var f = file[fi];
|
|
this.debug(pattern, p, f);
|
|
if (p === false) return false;
|
|
if (p === GLOBSTAR) {
|
|
this.debug("GLOBSTAR", [pattern, p, f]);
|
|
var fr = fi;
|
|
var pr = pi + 1;
|
|
if (pr === pl) {
|
|
this.debug("** at the end");
|
|
for (; fi < fl; fi++) {
|
|
if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".") return false;
|
|
}
|
|
return true;
|
|
}
|
|
while (fr < fl) {
|
|
var swallowee = file[fr];
|
|
this.debug("\nglobstar while", file, fr, pattern, pr, swallowee);
|
|
if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
|
|
this.debug("globstar found match!", fr, fl, swallowee);
|
|
return true;
|
|
} else {
|
|
if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
|
|
this.debug("dot detected!", file, fr, pattern, pr);
|
|
break;
|
|
}
|
|
this.debug("globstar swallow a segment, and continue");
|
|
fr++;
|
|
}
|
|
}
|
|
if (partial) {
|
|
this.debug("\n>>> no match, partial?", file, fr, pattern, pr);
|
|
if (fr === fl) return true;
|
|
}
|
|
return false;
|
|
}
|
|
var hit;
|
|
if (typeof p === "string") {
|
|
hit = f === p;
|
|
this.debug("string match", p, f, hit);
|
|
} else {
|
|
hit = f.match(p);
|
|
this.debug("pattern match", p, f, hit);
|
|
}
|
|
if (!hit) return false;
|
|
}
|
|
if (fi === fl && pi === pl) {
|
|
return true;
|
|
} else if (fi === fl) {
|
|
return partial;
|
|
} else if (pi === pl) {
|
|
return fi === fl - 1 && file[fi] === "";
|
|
}
|
|
throw new Error("wtf?");
|
|
};
|
|
function globUnescape(s) {
|
|
return s.replace(/\\(.)/g, "$1");
|
|
}
|
|
function regExpEscape(s) {
|
|
return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
|
|
}
|
|
}
|
|
});
|
|
var require_inherits_browser = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js"(exports, module2) {
|
|
"use strict";
|
|
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;
|
|
}
|
|
};
|
|
}
|
|
}
|
|
});
|
|
var require_inherits = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js"(exports, module2) {
|
|
"use strict";
|
|
try {
|
|
util = (0, import_chunk_AH6QHEOA.__require)("util");
|
|
if (typeof util.inherits !== "function") throw "";
|
|
module2.exports = util.inherits;
|
|
} catch (e) {
|
|
module2.exports = require_inherits_browser();
|
|
}
|
|
var util;
|
|
}
|
|
});
|
|
var require_path_is_absolute = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/path-is-absolute@1.0.1/node_modules/path-is-absolute/index.js"(exports, module2) {
|
|
"use strict";
|
|
function posix(path) {
|
|
return path.charAt(0) === "/";
|
|
}
|
|
function win32(path) {
|
|
var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
|
|
var result = splitDeviceRe.exec(path);
|
|
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;
|
|
}
|
|
});
|
|
var require_common = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/glob@7.2.3/node_modules/glob/common.js"(exports) {
|
|
"use strict";
|
|
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 fs = (0, import_chunk_AH6QHEOA.__require)("fs");
|
|
var path = (0, import_chunk_AH6QHEOA.__require)("path");
|
|
var minimatch = require_minimatch();
|
|
var isAbsolute = require_path_is_absolute();
|
|
var Minimatch = minimatch.Minimatch;
|
|
function alphasort(a, b) {
|
|
return a.localeCompare(b, "en");
|
|
}
|
|
function setupIgnores(self, options) {
|
|
self.ignore = options.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, options) {
|
|
if (!options)
|
|
options = {};
|
|
if (options.matchBase && -1 === pattern.indexOf("/")) {
|
|
if (options.noglobstar) {
|
|
throw new Error("base matching requires globstar");
|
|
}
|
|
pattern = "**/" + pattern;
|
|
}
|
|
self.silent = !!options.silent;
|
|
self.pattern = pattern;
|
|
self.strict = options.strict !== false;
|
|
self.realpath = !!options.realpath;
|
|
self.realpathCache = options.realpathCache || /* @__PURE__ */ Object.create(null);
|
|
self.follow = !!options.follow;
|
|
self.dot = !!options.dot;
|
|
self.mark = !!options.mark;
|
|
self.nodir = !!options.nodir;
|
|
if (self.nodir)
|
|
self.mark = true;
|
|
self.sync = !!options.sync;
|
|
self.nounique = !!options.nounique;
|
|
self.nonull = !!options.nonull;
|
|
self.nosort = !!options.nosort;
|
|
self.nocase = !!options.nocase;
|
|
self.stat = !!options.stat;
|
|
self.noprocess = !!options.noprocess;
|
|
self.absolute = !!options.absolute;
|
|
self.fs = options.fs || fs;
|
|
self.maxLength = options.maxLength || Infinity;
|
|
self.cache = options.cache || /* @__PURE__ */ Object.create(null);
|
|
self.statCache = options.statCache || /* @__PURE__ */ Object.create(null);
|
|
self.symlinks = options.symlinks || /* @__PURE__ */ Object.create(null);
|
|
setupIgnores(self, options);
|
|
self.changedCwd = false;
|
|
var cwd = process.cwd();
|
|
if (!ownProp(options, "cwd"))
|
|
self.cwd = cwd;
|
|
else {
|
|
self.cwd = path.resolve(options.cwd);
|
|
self.changedCwd = self.cwd !== cwd;
|
|
}
|
|
self.root = options.root || path.resolve(self.cwd, "/");
|
|
self.root = path.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 = !!options.nomount;
|
|
options.nonegate = true;
|
|
options.nocomment = true;
|
|
options.allowWindowsEscape = false;
|
|
self.minimatch = new Minimatch(pattern, options);
|
|
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(e) {
|
|
var notDir = !/\/$/.test(e);
|
|
var c = self.cache[e] || self.cache[makeAbs(self, e)];
|
|
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, p) {
|
|
var abs = makeAbs(self, p);
|
|
var c = self.cache[abs];
|
|
var m = p;
|
|
if (c) {
|
|
var isDir = c === "DIR" || Array.isArray(c);
|
|
var slash = p.slice(-1) === "/";
|
|
if (isDir && !slash)
|
|
m += "/";
|
|
else if (!isDir && slash)
|
|
m = m.slice(0, -1);
|
|
if (m !== p) {
|
|
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 = path.join(self.root, f);
|
|
} else if (isAbsolute(f) || f === "") {
|
|
abs = f;
|
|
} else if (self.changedCwd) {
|
|
abs = path.resolve(self.cwd, f);
|
|
} else {
|
|
abs = path.resolve(f);
|
|
}
|
|
if (process.platform === "win32")
|
|
abs = abs.replace(/\\/g, "/");
|
|
return abs;
|
|
}
|
|
function isIgnored(self, path2) {
|
|
if (!self.ignore.length)
|
|
return false;
|
|
return self.ignore.some(function(item) {
|
|
return item.matcher.match(path2) || !!(item.gmatcher && item.gmatcher.match(path2));
|
|
});
|
|
}
|
|
function childrenIgnored(self, path2) {
|
|
if (!self.ignore.length)
|
|
return false;
|
|
return self.ignore.some(function(item) {
|
|
return !!(item.gmatcher && item.gmatcher.match(path2));
|
|
});
|
|
}
|
|
}
|
|
});
|
|
var require_sync = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/glob@7.2.3/node_modules/glob/sync.js"(exports, module2) {
|
|
"use strict";
|
|
module2.exports = globSync;
|
|
globSync.GlobSync = GlobSync;
|
|
var rp = require_fs();
|
|
var minimatch = require_minimatch();
|
|
var Minimatch = minimatch.Minimatch;
|
|
var Glob = require_glob().Glob;
|
|
var util = (0, import_chunk_AH6QHEOA.__require)("util");
|
|
var path = (0, import_chunk_AH6QHEOA.__require)("path");
|
|
var assert = (0, import_chunk_AH6QHEOA.__require)("assert");
|
|
var isAbsolute = require_path_is_absolute();
|
|
var common = require_common();
|
|
var setopts = common.setopts;
|
|
var ownProp = common.ownProp;
|
|
var childrenIgnored = common.childrenIgnored;
|
|
var isIgnored = common.isIgnored;
|
|
function globSync(pattern, options) {
|
|
if (typeof options === "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, options).found;
|
|
}
|
|
function GlobSync(pattern, options) {
|
|
if (!pattern)
|
|
throw new Error("must provide pattern");
|
|
if (typeof options === "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, options);
|
|
setopts(this, pattern, options);
|
|
if (this.noprocess)
|
|
return this;
|
|
var n = this.minimatch.set.length;
|
|
this.matches = new Array(n);
|
|
for (var i = 0; i < n; 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 p in matchset) {
|
|
try {
|
|
p = self._makeAbs(p);
|
|
var real = rp.realpathSync(p, self.realpathCache);
|
|
set[real] = true;
|
|
} catch (er) {
|
|
if (er.syscall === "stat")
|
|
set[self._makeAbs(p)] = true;
|
|
else
|
|
throw er;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
common.finish(this);
|
|
};
|
|
GlobSync.prototype._process = function(pattern, index, inGlobStar) {
|
|
assert.ok(this instanceof GlobSync);
|
|
var n = 0;
|
|
while (typeof pattern[n] === "string") {
|
|
n++;
|
|
}
|
|
var prefix;
|
|
switch (n) {
|
|
case pattern.length:
|
|
this._processSimple(pattern.join("/"), index);
|
|
return;
|
|
case 0:
|
|
prefix = null;
|
|
break;
|
|
default:
|
|
prefix = pattern.slice(0, n).join("/");
|
|
break;
|
|
}
|
|
var remain = pattern.slice(n);
|
|
var read;
|
|
if (prefix === null)
|
|
read = ".";
|
|
else if (isAbsolute(prefix) || isAbsolute(pattern.map(function(p) {
|
|
return typeof p === "string" ? p : "[*]";
|
|
}).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 e = entries[i];
|
|
if (e.charAt(0) !== "." || dotOk) {
|
|
var m;
|
|
if (negate && !prefix) {
|
|
m = !e.match(pn);
|
|
} else {
|
|
m = e.match(pn);
|
|
}
|
|
if (m)
|
|
matchedEntries.push(e);
|
|
}
|
|
}
|
|
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 e = matchedEntries[i];
|
|
if (prefix) {
|
|
if (prefix.slice(-1) !== "/")
|
|
e = prefix + "/" + e;
|
|
else
|
|
e = prefix + e;
|
|
}
|
|
if (e.charAt(0) === "/" && !this.nomount) {
|
|
e = path.join(this.root, e);
|
|
}
|
|
this._emitMatch(index, e);
|
|
}
|
|
return;
|
|
}
|
|
remain.shift();
|
|
for (var i = 0; i < len; i++) {
|
|
var e = matchedEntries[i];
|
|
var newPattern;
|
|
if (prefix)
|
|
newPattern = [prefix, e];
|
|
else
|
|
newPattern = [e];
|
|
this._process(newPattern.concat(remain), index, inGlobStar);
|
|
}
|
|
};
|
|
GlobSync.prototype._emitMatch = function(index, e) {
|
|
if (isIgnored(this, e))
|
|
return;
|
|
var abs = this._makeAbs(e);
|
|
if (this.mark)
|
|
e = this._mark(e);
|
|
if (this.absolute) {
|
|
e = abs;
|
|
}
|
|
if (this.matches[index][e])
|
|
return;
|
|
if (this.nodir) {
|
|
var c = this.cache[abs];
|
|
if (c === "DIR" || Array.isArray(c))
|
|
return;
|
|
}
|
|
this.matches[index][e] = true;
|
|
if (this.stat)
|
|
this._stat(e);
|
|
};
|
|
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 e = entries[i];
|
|
if (abs === "/")
|
|
e = abs + e;
|
|
else
|
|
e = abs + "/" + e;
|
|
this.cache[e] = 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 e = entries[i];
|
|
if (e.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 exists = this._stat(prefix);
|
|
if (!this.matches[index])
|
|
this.matches[index] = /* @__PURE__ */ Object.create(null);
|
|
if (!exists)
|
|
return;
|
|
if (prefix && isAbsolute(prefix) && !this.nomount) {
|
|
var trail = /[\/\\]$/.test(prefix);
|
|
if (prefix.charAt(0) === "/") {
|
|
prefix = path.join(this.root, prefix);
|
|
} else {
|
|
prefix = path.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 exists;
|
|
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(p) {
|
|
return common.mark(this, p);
|
|
};
|
|
GlobSync.prototype._makeAbs = function(f) {
|
|
return common.makeAbs(this, f);
|
|
};
|
|
}
|
|
});
|
|
var require_wrappy = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js"(exports, module2) {
|
|
"use strict";
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
var require_once = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js"(exports, module2) {
|
|
"use strict";
|
|
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;
|
|
}
|
|
}
|
|
});
|
|
var require_inflight = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/inflight@1.0.6/node_modules/inflight/inflight.js"(exports, module2) {
|
|
"use strict";
|
|
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;
|
|
}
|
|
}
|
|
});
|
|
var require_glob = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/glob@7.2.3/node_modules/glob/glob.js"(exports, module2) {
|
|
"use strict";
|
|
module2.exports = glob;
|
|
var rp = require_fs();
|
|
var minimatch = require_minimatch();
|
|
var Minimatch = minimatch.Minimatch;
|
|
var inherits = require_inherits();
|
|
var EE = (0, import_chunk_AH6QHEOA.__require)("events").EventEmitter;
|
|
var path = (0, import_chunk_AH6QHEOA.__require)("path");
|
|
var assert = (0, import_chunk_AH6QHEOA.__require)("assert");
|
|
var isAbsolute = require_path_is_absolute();
|
|
var globSync = require_sync();
|
|
var common = require_common();
|
|
var setopts = common.setopts;
|
|
var ownProp = common.ownProp;
|
|
var inflight = require_inflight();
|
|
var util = (0, import_chunk_AH6QHEOA.__require)("util");
|
|
var childrenIgnored = common.childrenIgnored;
|
|
var isIgnored = common.isIgnored;
|
|
var once = require_once();
|
|
function glob(pattern, options, cb) {
|
|
if (typeof options === "function") cb = options, options = {};
|
|
if (!options) options = {};
|
|
if (options.sync) {
|
|
if (cb)
|
|
throw new TypeError("callback provided to sync glob");
|
|
return globSync(pattern, options);
|
|
}
|
|
return new Glob(pattern, options, 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 options = extend({}, options_);
|
|
options.noprocess = true;
|
|
var g = new Glob(pattern, options);
|
|
var set = g.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, options, cb) {
|
|
if (typeof options === "function") {
|
|
cb = options;
|
|
options = null;
|
|
}
|
|
if (options && options.sync) {
|
|
if (cb)
|
|
throw new TypeError("callback provided to sync glob");
|
|
return new GlobSync(pattern, options);
|
|
}
|
|
if (!(this instanceof Glob))
|
|
return new Glob(pattern, options, cb);
|
|
setopts(this, pattern, options);
|
|
this._didRealPath = false;
|
|
var n = this.minimatch.set.length;
|
|
this.matches = new Array(n);
|
|
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 (n === 0)
|
|
return done();
|
|
var sync = true;
|
|
for (var i = 0; i < n; 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 n = this.matches.length;
|
|
if (n === 0)
|
|
return this._finish();
|
|
var self = this;
|
|
for (var i = 0; i < this.matches.length; i++)
|
|
this._realpathSet(i, next);
|
|
function next() {
|
|
if (--n === 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 n = found.length;
|
|
if (n === 0)
|
|
return cb();
|
|
var set = this.matches[index] = /* @__PURE__ */ Object.create(null);
|
|
found.forEach(function(p, i) {
|
|
p = self._makeAbs(p);
|
|
rp.realpath(p, self.realpathCache, function(er, real) {
|
|
if (!er)
|
|
set[real] = true;
|
|
else if (er.syscall === "stat")
|
|
set[p] = true;
|
|
else
|
|
self.emit("error", er);
|
|
if (--n === 0) {
|
|
self.matches[index] = set;
|
|
cb();
|
|
}
|
|
});
|
|
});
|
|
};
|
|
Glob.prototype._mark = function(p) {
|
|
return common.mark(this, p);
|
|
};
|
|
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 e = eq[i];
|
|
this._emitMatch(e[0], e[1]);
|
|
}
|
|
}
|
|
if (this._processQueue.length) {
|
|
var pq = this._processQueue.slice(0);
|
|
this._processQueue.length = 0;
|
|
for (var i = 0; i < pq.length; i++) {
|
|
var p = pq[i];
|
|
this._processing--;
|
|
this._process(p[0], p[1], p[2], p[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 n = 0;
|
|
while (typeof pattern[n] === "string") {
|
|
n++;
|
|
}
|
|
var prefix;
|
|
switch (n) {
|
|
case pattern.length:
|
|
this._processSimple(pattern.join("/"), index, cb);
|
|
return;
|
|
case 0:
|
|
prefix = null;
|
|
break;
|
|
default:
|
|
prefix = pattern.slice(0, n).join("/");
|
|
break;
|
|
}
|
|
var remain = pattern.slice(n);
|
|
var read;
|
|
if (prefix === null)
|
|
read = ".";
|
|
else if (isAbsolute(prefix) || isAbsolute(pattern.map(function(p) {
|
|
return typeof p === "string" ? p : "[*]";
|
|
}).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 e = entries[i];
|
|
if (e.charAt(0) !== "." || dotOk) {
|
|
var m;
|
|
if (negate && !prefix) {
|
|
m = !e.match(pn);
|
|
} else {
|
|
m = e.match(pn);
|
|
}
|
|
if (m)
|
|
matchedEntries.push(e);
|
|
}
|
|
}
|
|
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 e = matchedEntries[i];
|
|
if (prefix) {
|
|
if (prefix !== "/")
|
|
e = prefix + "/" + e;
|
|
else
|
|
e = prefix + e;
|
|
}
|
|
if (e.charAt(0) === "/" && !this.nomount) {
|
|
e = path.join(this.root, e);
|
|
}
|
|
this._emitMatch(index, e);
|
|
}
|
|
return cb();
|
|
}
|
|
remain.shift();
|
|
for (var i = 0; i < len; i++) {
|
|
var e = matchedEntries[i];
|
|
var newPattern;
|
|
if (prefix) {
|
|
if (prefix !== "/")
|
|
e = prefix + "/" + e;
|
|
else
|
|
e = prefix + e;
|
|
}
|
|
this._process([e].concat(remain), index, inGlobStar, cb);
|
|
}
|
|
cb();
|
|
};
|
|
Glob.prototype._emitMatch = function(index, e) {
|
|
if (this.aborted)
|
|
return;
|
|
if (isIgnored(this, e))
|
|
return;
|
|
if (this.paused) {
|
|
this._emitQueue.push([index, e]);
|
|
return;
|
|
}
|
|
var abs = isAbsolute(e) ? e : this._makeAbs(e);
|
|
if (this.mark)
|
|
e = this._mark(e);
|
|
if (this.absolute)
|
|
e = abs;
|
|
if (this.matches[index][e])
|
|
return;
|
|
if (this.nodir) {
|
|
var c = this.cache[abs];
|
|
if (c === "DIR" || Array.isArray(c))
|
|
return;
|
|
}
|
|
this.matches[index][e] = true;
|
|
var st = this.statCache[abs];
|
|
if (st)
|
|
this.emit("stat", e, st);
|
|
this.emit("match", e);
|
|
};
|
|
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 e = entries[i];
|
|
if (abs === "/")
|
|
e = abs + e;
|
|
else
|
|
e = abs + "/" + e;
|
|
this.cache[e] = 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 e = entries[i];
|
|
if (e.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, exists) {
|
|
self._processSimple2(prefix, index, er, exists, cb);
|
|
});
|
|
};
|
|
Glob.prototype._processSimple2 = function(prefix, index, er, exists, cb) {
|
|
if (!this.matches[index])
|
|
this.matches[index] = /* @__PURE__ */ Object.create(null);
|
|
if (!exists)
|
|
return cb();
|
|
if (prefix && isAbsolute(prefix) && !this.nomount) {
|
|
var trail = /[\/\\]$/.test(prefix);
|
|
if (prefix.charAt(0) === "/") {
|
|
prefix = path.join(this.root, prefix);
|
|
} else {
|
|
prefix = path.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 exists;
|
|
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);
|
|
};
|
|
}
|
|
});
|
|
var require_rimraf = (0, import_chunk_AH6QHEOA.__commonJS)({
|
|
"../../node_modules/.pnpm/rimraf@3.0.2/node_modules/rimraf/rimraf.js"(exports, module2) {
|
|
"use strict";
|
|
var assert = (0, import_chunk_AH6QHEOA.__require)("assert");
|
|
var path = (0, import_chunk_AH6QHEOA.__require)("path");
|
|
var fs = (0, import_chunk_AH6QHEOA.__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 = (options) => {
|
|
const methods = [
|
|
"unlink",
|
|
"chmod",
|
|
"stat",
|
|
"lstat",
|
|
"rmdir",
|
|
"readdir"
|
|
];
|
|
methods.forEach((m) => {
|
|
options[m] = options[m] || fs[m];
|
|
m = m + "Sync";
|
|
options[m] = options[m] || fs[m];
|
|
});
|
|
options.maxBusyTries = options.maxBusyTries || 3;
|
|
options.emfileWait = options.emfileWait || 1e3;
|
|
if (options.glob === false) {
|
|
options.disableGlob = true;
|
|
}
|
|
if (options.disableGlob !== true && glob === void 0) {
|
|
throw Error("glob dependency not found, set `options.disableGlob = true` if intentional");
|
|
}
|
|
options.disableGlob = options.disableGlob || false;
|
|
options.glob = options.glob || defaultGlobOpts;
|
|
};
|
|
var rimraf = (p, options, cb) => {
|
|
if (typeof options === "function") {
|
|
cb = options;
|
|
options = {};
|
|
}
|
|
assert(p, "rimraf: missing path");
|
|
assert.equal(typeof p, "string", "rimraf: path should be a string");
|
|
assert.equal(typeof cb, "function", "rimraf: callback function required");
|
|
assert(options, "rimraf: invalid options argument provided");
|
|
assert.equal(typeof options, "object", "rimraf: options should be object");
|
|
defaults(options);
|
|
let busyTries = 0;
|
|
let errState = null;
|
|
let n = 0;
|
|
const next = (er) => {
|
|
errState = errState || er;
|
|
if (--n === 0)
|
|
cb(errState);
|
|
};
|
|
const afterGlob = (er, results) => {
|
|
if (er)
|
|
return cb(er);
|
|
n = results.length;
|
|
if (n === 0)
|
|
return cb();
|
|
results.forEach((p2) => {
|
|
const CB = (er2) => {
|
|
if (er2) {
|
|
if ((er2.code === "EBUSY" || er2.code === "ENOTEMPTY" || er2.code === "EPERM") && busyTries < options.maxBusyTries) {
|
|
busyTries++;
|
|
return setTimeout(() => rimraf_(p2, options, CB), busyTries * 100);
|
|
}
|
|
if (er2.code === "EMFILE" && timeout < options.emfileWait) {
|
|
return setTimeout(() => rimraf_(p2, options, CB), timeout++);
|
|
}
|
|
if (er2.code === "ENOENT") er2 = null;
|
|
}
|
|
timeout = 0;
|
|
next(er2);
|
|
};
|
|
rimraf_(p2, options, CB);
|
|
});
|
|
};
|
|
if (options.disableGlob || !glob.hasMagic(p))
|
|
return afterGlob(null, [p]);
|
|
options.lstat(p, (er, stat) => {
|
|
if (!er)
|
|
return afterGlob(null, [p]);
|
|
glob(p, options.glob, afterGlob);
|
|
});
|
|
};
|
|
var rimraf_ = (p, options, cb) => {
|
|
assert(p);
|
|
assert(options);
|
|
assert(typeof cb === "function");
|
|
options.lstat(p, (er, st) => {
|
|
if (er && er.code === "ENOENT")
|
|
return cb(null);
|
|
if (er && er.code === "EPERM" && isWindows)
|
|
fixWinEPERM(p, options, er, cb);
|
|
if (st && st.isDirectory())
|
|
return rmdir(p, options, er, cb);
|
|
options.unlink(p, (er2) => {
|
|
if (er2) {
|
|
if (er2.code === "ENOENT")
|
|
return cb(null);
|
|
if (er2.code === "EPERM")
|
|
return isWindows ? fixWinEPERM(p, options, er2, cb) : rmdir(p, options, er2, cb);
|
|
if (er2.code === "EISDIR")
|
|
return rmdir(p, options, er2, cb);
|
|
}
|
|
return cb(er2);
|
|
});
|
|
});
|
|
};
|
|
var fixWinEPERM = (p, options, er, cb) => {
|
|
assert(p);
|
|
assert(options);
|
|
assert(typeof cb === "function");
|
|
options.chmod(p, 438, (er2) => {
|
|
if (er2)
|
|
cb(er2.code === "ENOENT" ? null : er);
|
|
else
|
|
options.stat(p, (er3, stats) => {
|
|
if (er3)
|
|
cb(er3.code === "ENOENT" ? null : er);
|
|
else if (stats.isDirectory())
|
|
rmdir(p, options, er, cb);
|
|
else
|
|
options.unlink(p, cb);
|
|
});
|
|
});
|
|
};
|
|
var fixWinEPERMSync = (p, options, er) => {
|
|
assert(p);
|
|
assert(options);
|
|
try {
|
|
options.chmodSync(p, 438);
|
|
} catch (er2) {
|
|
if (er2.code === "ENOENT")
|
|
return;
|
|
else
|
|
throw er;
|
|
}
|
|
let stats;
|
|
try {
|
|
stats = options.statSync(p);
|
|
} catch (er3) {
|
|
if (er3.code === "ENOENT")
|
|
return;
|
|
else
|
|
throw er;
|
|
}
|
|
if (stats.isDirectory())
|
|
rmdirSync(p, options, er);
|
|
else
|
|
options.unlinkSync(p);
|
|
};
|
|
var rmdir = (p, options, originalEr, cb) => {
|
|
assert(p);
|
|
assert(options);
|
|
assert(typeof cb === "function");
|
|
options.rmdir(p, (er) => {
|
|
if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM"))
|
|
rmkids(p, options, cb);
|
|
else if (er && er.code === "ENOTDIR")
|
|
cb(originalEr);
|
|
else
|
|
cb(er);
|
|
});
|
|
};
|
|
var rmkids = (p, options, cb) => {
|
|
assert(p);
|
|
assert(options);
|
|
assert(typeof cb === "function");
|
|
options.readdir(p, (er, files) => {
|
|
if (er)
|
|
return cb(er);
|
|
let n = files.length;
|
|
if (n === 0)
|
|
return options.rmdir(p, cb);
|
|
let errState;
|
|
files.forEach((f) => {
|
|
rimraf(path.join(p, f), options, (er2) => {
|
|
if (errState)
|
|
return;
|
|
if (er2)
|
|
return cb(errState = er2);
|
|
if (--n === 0)
|
|
options.rmdir(p, cb);
|
|
});
|
|
});
|
|
});
|
|
};
|
|
var rimrafSync = (p, options) => {
|
|
options = options || {};
|
|
defaults(options);
|
|
assert(p, "rimraf: missing path");
|
|
assert.equal(typeof p, "string", "rimraf: path should be a string");
|
|
assert(options, "rimraf: missing options");
|
|
assert.equal(typeof options, "object", "rimraf: options should be object");
|
|
let results;
|
|
if (options.disableGlob || !glob.hasMagic(p)) {
|
|
results = [p];
|
|
} else {
|
|
try {
|
|
options.lstatSync(p);
|
|
results = [p];
|
|
} catch (er) {
|
|
results = glob.sync(p, options.glob);
|
|
}
|
|
}
|
|
if (!results.length)
|
|
return;
|
|
for (let i = 0; i < results.length; i++) {
|
|
const p2 = results[i];
|
|
let st;
|
|
try {
|
|
st = options.lstatSync(p2);
|
|
} catch (er) {
|
|
if (er.code === "ENOENT")
|
|
return;
|
|
if (er.code === "EPERM" && isWindows)
|
|
fixWinEPERMSync(p2, options, er);
|
|
}
|
|
try {
|
|
if (st && st.isDirectory())
|
|
rmdirSync(p2, options, null);
|
|
else
|
|
options.unlinkSync(p2);
|
|
} catch (er) {
|
|
if (er.code === "ENOENT")
|
|
return;
|
|
if (er.code === "EPERM")
|
|
return isWindows ? fixWinEPERMSync(p2, options, er) : rmdirSync(p2, options, er);
|
|
if (er.code !== "EISDIR")
|
|
throw er;
|
|
rmdirSync(p2, options, er);
|
|
}
|
|
}
|
|
};
|
|
var rmdirSync = (p, options, originalEr) => {
|
|
assert(p);
|
|
assert(options);
|
|
try {
|
|
options.rmdirSync(p);
|
|
} catch (er) {
|
|
if (er.code === "ENOENT")
|
|
return;
|
|
if (er.code === "ENOTDIR")
|
|
throw originalEr;
|
|
if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")
|
|
rmkidsSync(p, options);
|
|
}
|
|
};
|
|
var rmkidsSync = (p, options) => {
|
|
assert(p);
|
|
assert(options);
|
|
options.readdirSync(p).forEach((f) => rimrafSync(path.join(p, f), options));
|
|
const retries = isWindows ? 100 : 1;
|
|
let i = 0;
|
|
do {
|
|
let threw = true;
|
|
try {
|
|
const ret = options.rmdirSync(p, options);
|
|
threw = false;
|
|
return ret;
|
|
} finally {
|
|
if (++i < retries && threw)
|
|
continue;
|
|
}
|
|
} while (true);
|
|
};
|
|
module2.exports = rimraf;
|
|
rimraf.sync = rimrafSync;
|
|
}
|
|
});
|