pnpm
Version:
18,801 lines • 671 kB
JavaScript
import { createRequire as _cr } from 'module';const require = _cr(import.meta.url); const __filename = import.meta.filename; const __dirname = import.meta.dirname;var _ew=process.emitWarning;process.emitWarning=function(w,...a){if(String(w).includes('SQLite')&&(a[0]==='ExperimentalWarning'||(a[0]&&a[0].type==='ExperimentalWarning')))return;return _ew.call(process,w,...a)};
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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x + '" is not supported');
});
var __commonJS = (cb, mod) => function __require2() {
try {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
} catch (e) {
throw mod = 0, e;
}
};
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, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
mod
));
// ../../../../../setup-pnpm/store/v11/links/@/graceful-fs/4.2.11/e60a23841f60609f733db41b2b1eced16c30ec8fe2e67c2a9b80e2dab0755700/node_modules/graceful-fs/polyfills.js
var require_polyfills = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/graceful-fs/4.2.11/e60a23841f60609f733db41b2b1eced16c30ec8fe2e67c2a9b80e2dab0755700/node_modules/graceful-fs/polyfills.js"(exports, module) {
var constants2 = __require("constants");
var origCwd = process.cwd;
var cwd = null;
var platform = 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(d) {
cwd = null;
chdir.call(process, d);
};
if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
}
var chdir;
module.exports = patch;
function patch(fs30) {
if (constants2.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
patchLchmod(fs30);
}
if (!fs30.lutimes) {
patchLutimes(fs30);
}
fs30.chown = chownFix(fs30.chown);
fs30.fchown = chownFix(fs30.fchown);
fs30.lchown = chownFix(fs30.lchown);
fs30.chmod = chmodFix(fs30.chmod);
fs30.fchmod = chmodFix(fs30.fchmod);
fs30.lchmod = chmodFix(fs30.lchmod);
fs30.chownSync = chownFixSync(fs30.chownSync);
fs30.fchownSync = chownFixSync(fs30.fchownSync);
fs30.lchownSync = chownFixSync(fs30.lchownSync);
fs30.chmodSync = chmodFixSync(fs30.chmodSync);
fs30.fchmodSync = chmodFixSync(fs30.fchmodSync);
fs30.lchmodSync = chmodFixSync(fs30.lchmodSync);
fs30.stat = statFix(fs30.stat);
fs30.fstat = statFix(fs30.fstat);
fs30.lstat = statFix(fs30.lstat);
fs30.statSync = statFixSync(fs30.statSync);
fs30.fstatSync = statFixSync(fs30.fstatSync);
fs30.lstatSync = statFixSync(fs30.lstatSync);
if (fs30.chmod && !fs30.lchmod) {
fs30.lchmod = function(path31, mode, cb) {
if (cb) process.nextTick(cb);
};
fs30.lchmodSync = function() {
};
}
if (fs30.chown && !fs30.lchown) {
fs30.lchown = function(path31, uid, gid, cb) {
if (cb) process.nextTick(cb);
};
fs30.lchownSync = function() {
};
}
if (platform === "win32") {
fs30.rename = typeof fs30.rename !== "function" ? fs30.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" || er.code === "EBUSY") && Date.now() - start < 6e4) {
setTimeout(function() {
fs30.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;
})(fs30.rename);
}
fs30.read = typeof fs30.read !== "function" ? fs30.read : (function(fs$read) {
function read2(fd, buffer, offset, length, position3, 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(fs30, fd, buffer, offset, length, position3, callback);
}
callback_.apply(this, arguments);
};
}
return fs$read.call(fs30, fd, buffer, offset, length, position3, callback);
}
if (Object.setPrototypeOf) Object.setPrototypeOf(read2, fs$read);
return read2;
})(fs30.read);
fs30.readSync = typeof fs30.readSync !== "function" ? fs30.readSync : /* @__PURE__ */ (function(fs$readSync) {
return function(fd, buffer, offset, length, position3) {
var eagCounter = 0;
while (true) {
try {
return fs$readSync.call(fs30, fd, buffer, offset, length, position3);
} catch (er) {
if (er.code === "EAGAIN" && eagCounter < 10) {
eagCounter++;
continue;
}
throw er;
}
}
};
})(fs30.readSync);
function patchLchmod(fs31) {
fs31.lchmod = function(path31, mode, callback) {
fs31.open(
path31,
constants2.O_WRONLY | constants2.O_SYMLINK,
mode,
function(err, fd) {
if (err) {
if (callback) callback(err);
return;
}
fs31.fchmod(fd, mode, function(err2) {
fs31.close(fd, function(err22) {
if (callback) callback(err2 || err22);
});
});
}
);
};
fs31.lchmodSync = function(path31, mode) {
var fd = fs31.openSync(path31, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
var threw = true;
var ret;
try {
ret = fs31.fchmodSync(fd, mode);
threw = false;
} finally {
if (threw) {
try {
fs31.closeSync(fd);
} catch (er) {
}
} else {
fs31.closeSync(fd);
}
}
return ret;
};
}
function patchLutimes(fs31) {
if (constants2.hasOwnProperty("O_SYMLINK") && fs31.futimes) {
fs31.lutimes = function(path31, at, mt, cb) {
fs31.open(path31, constants2.O_SYMLINK, function(er, fd) {
if (er) {
if (cb) cb(er);
return;
}
fs31.futimes(fd, at, mt, function(er2) {
fs31.close(fd, function(er22) {
if (cb) cb(er2 || er22);
});
});
});
};
fs31.lutimesSync = function(path31, at, mt) {
var fd = fs31.openSync(path31, constants2.O_SYMLINK);
var ret;
var threw = true;
try {
ret = fs31.futimesSync(fd, at, mt);
threw = false;
} finally {
if (threw) {
try {
fs31.closeSync(fd);
} catch (er) {
}
} else {
fs31.closeSync(fd);
}
}
return ret;
};
} else if (fs31.futimes) {
fs31.lutimes = function(_a, _b, _c, cb) {
if (cb) process.nextTick(cb);
};
fs31.lutimesSync = function() {
};
}
}
function chmodFix(orig) {
if (!orig) return orig;
return function(target2, mode, cb) {
return orig.call(fs30, target2, mode, function(er) {
if (chownErOk(er)) er = null;
if (cb) cb.apply(this, arguments);
});
};
}
function chmodFixSync(orig) {
if (!orig) return orig;
return function(target2, mode) {
try {
return orig.call(fs30, target2, mode);
} catch (er) {
if (!chownErOk(er)) throw er;
}
};
}
function chownFix(orig) {
if (!orig) return orig;
return function(target2, uid, gid, cb) {
return orig.call(fs30, target2, uid, gid, function(er) {
if (chownErOk(er)) er = null;
if (cb) cb.apply(this, arguments);
});
};
}
function chownFixSync(orig) {
if (!orig) return orig;
return function(target2, uid, gid) {
try {
return orig.call(fs30, target2, uid, gid);
} catch (er) {
if (!chownErOk(er)) throw er;
}
};
}
function statFix(orig) {
if (!orig) return orig;
return function(target2, options, cb) {
if (typeof options === "function") {
cb = options;
options = 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 options ? orig.call(fs30, target2, options, callback) : orig.call(fs30, target2, callback);
};
}
function statFixSync(orig) {
if (!orig) return orig;
return function(target2, options) {
var stats = options ? orig.call(fs30, target2, options) : orig.call(fs30, target2);
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;
}
}
}
});
// ../../../../../setup-pnpm/store/v11/links/@/graceful-fs/4.2.11/e60a23841f60609f733db41b2b1eced16c30ec8fe2e67c2a9b80e2dab0755700/node_modules/graceful-fs/legacy-streams.js
var require_legacy_streams = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/graceful-fs/4.2.11/e60a23841f60609f733db41b2b1eced16c30ec8fe2e67c2a9b80e2dab0755700/node_modules/graceful-fs/legacy-streams.js"(exports, module) {
var Stream = __require("stream").Stream;
module.exports = legacy;
function legacy(fs30) {
return {
ReadStream,
WriteStream
};
function ReadStream(path31, options) {
if (!(this instanceof ReadStream)) return new ReadStream(path31, options);
Stream.call(this);
var self2 = this;
this.path = path31;
this.fd = null;
this.readable = true;
this.paused = false;
this.flags = "r";
this.mode = 438;
this.bufferSize = 64 * 1024;
options = options || {};
var keys = Object.keys(options);
for (var index = 0, length = keys.length; index < length; index++) {
var key = keys[index];
this[key] = options[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() {
self2._read();
});
return;
}
fs30.open(this.path, this.flags, this.mode, function(err, fd) {
if (err) {
self2.emit("error", err);
self2.readable = false;
return;
}
self2.fd = fd;
self2.emit("open", fd);
self2._read();
});
}
function WriteStream(path31, options) {
if (!(this instanceof WriteStream)) return new WriteStream(path31, options);
Stream.call(this);
this.path = path31;
this.fd = null;
this.writable = true;
this.flags = "w";
this.encoding = "binary";
this.mode = 438;
this.bytesWritten = 0;
options = options || {};
var keys = Object.keys(options);
for (var index = 0, length = keys.length; index < length; index++) {
var key = keys[index];
this[key] = options[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 = fs30.open;
this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
this.flush();
}
}
}
}
});
// ../../../../../setup-pnpm/store/v11/links/@/graceful-fs/4.2.11/e60a23841f60609f733db41b2b1eced16c30ec8fe2e67c2a9b80e2dab0755700/node_modules/graceful-fs/clone.js
var require_clone = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/graceful-fs/4.2.11/e60a23841f60609f733db41b2b1eced16c30ec8fe2e67c2a9b80e2dab0755700/node_modules/graceful-fs/clone.js"(exports, module) {
"use strict";
module.exports = clone;
var getPrototypeOf = Object.getPrototypeOf || function(obj) {
return obj.__proto__;
};
function clone(obj) {
if (obj === null || typeof obj !== "object")
return obj;
if (obj instanceof Object)
var copy2 = { __proto__: getPrototypeOf(obj) };
else
var copy2 = /* @__PURE__ */ Object.create(null);
Object.getOwnPropertyNames(obj).forEach(function(key) {
Object.defineProperty(copy2, key, Object.getOwnPropertyDescriptor(obj, key));
});
return copy2;
}
}
});
// ../../../../../setup-pnpm/store/v11/links/@/graceful-fs/4.2.11/e60a23841f60609f733db41b2b1eced16c30ec8fe2e67c2a9b80e2dab0755700/node_modules/graceful-fs/graceful-fs.js
var require_graceful_fs = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/graceful-fs/4.2.11/e60a23841f60609f733db41b2b1eced16c30ec8fe2e67c2a9b80e2dab0755700/node_modules/graceful-fs/graceful-fs.js"(exports, module) {
var fs30 = __require("fs");
var polyfills = require_polyfills();
var legacy = require_legacy_streams();
var clone = require_clone();
var util2 = __require("util");
var gracefulQueue;
var previousSymbol;
if (typeof Symbol === "function" && typeof Symbol.for === "function") {
gracefulQueue = /* @__PURE__ */ Symbol.for("graceful-fs.queue");
previousSymbol = /* @__PURE__ */ 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 debug = noop;
if (util2.debuglog)
debug = util2.debuglog("gfs4");
else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
debug = function() {
var m = util2.format.apply(util2, arguments);
m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
console.error(m);
};
if (!fs30[gracefulQueue]) {
queue = global[gracefulQueue] || [];
publishQueue(fs30, queue);
fs30.close = (function(fs$close) {
function close(fd, cb) {
return fs$close.call(fs30, fd, function(err) {
if (!err) {
resetQueue();
}
if (typeof cb === "function")
cb.apply(this, arguments);
});
}
Object.defineProperty(close, previousSymbol, {
value: fs$close
});
return close;
})(fs30.close);
fs30.closeSync = (function(fs$closeSync) {
function closeSync(fd) {
fs$closeSync.apply(fs30, arguments);
resetQueue();
}
Object.defineProperty(closeSync, previousSymbol, {
value: fs$closeSync
});
return closeSync;
})(fs30.closeSync);
if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
process.on("exit", function() {
debug(fs30[gracefulQueue]);
__require("assert").equal(fs30[gracefulQueue].length, 0);
});
}
}
var queue;
if (!global[gracefulQueue]) {
publishQueue(global, fs30[gracefulQueue]);
}
module.exports = patch(clone(fs30));
if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs30.__patched) {
module.exports = patch(fs30);
fs30.__patched = true;
}
function patch(fs31) {
polyfills(fs31);
fs31.gracefulify = patch;
fs31.createReadStream = createReadStream3;
fs31.createWriteStream = createWriteStream;
var fs$readFile = fs31.readFile;
fs31.readFile = readFile2;
function readFile2(path31, options, cb) {
if (typeof options === "function")
cb = options, options = null;
return go$readFile(path31, options, cb);
function go$readFile(path32, options2, cb2, startTime) {
return fs$readFile(path32, options2, function(err) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([go$readFile, [path32, options2, cb2], err, startTime || Date.now(), Date.now()]);
else {
if (typeof cb2 === "function")
cb2.apply(this, arguments);
}
});
}
}
var fs$writeFile = fs31.writeFile;
fs31.writeFile = writeFile2;
function writeFile2(path31, data, options, cb) {
if (typeof options === "function")
cb = options, options = null;
return go$writeFile(path31, data, options, cb);
function go$writeFile(path32, data2, options2, cb2, startTime) {
return fs$writeFile(path32, data2, options2, function(err) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([go$writeFile, [path32, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
else {
if (typeof cb2 === "function")
cb2.apply(this, arguments);
}
});
}
}
var fs$appendFile = fs31.appendFile;
if (fs$appendFile)
fs31.appendFile = appendFile;
function appendFile(path31, data, options, cb) {
if (typeof options === "function")
cb = options, options = null;
return go$appendFile(path31, data, options, cb);
function go$appendFile(path32, data2, options2, cb2, startTime) {
return fs$appendFile(path32, data2, options2, function(err) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([go$appendFile, [path32, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
else {
if (typeof cb2 === "function")
cb2.apply(this, arguments);
}
});
}
}
var fs$copyFile = fs31.copyFile;
if (fs$copyFile)
fs31.copyFile = copyFile;
function copyFile(src2, dest, flags, cb) {
if (typeof flags === "function") {
cb = flags;
flags = 0;
}
return go$copyFile(src2, dest, flags, cb);
function go$copyFile(src3, dest2, flags2, cb2, startTime) {
return fs$copyFile(src3, dest2, flags2, function(err) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE" || err.code === "EBUSY"))
enqueue([go$copyFile, [src3, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
else {
if (typeof cb2 === "function")
cb2.apply(this, arguments);
}
});
}
}
var fs$readdir = fs31.readdir;
fs31.readdir = readdir;
var noReaddirOptionVersions = /^v[0-5]\./;
function readdir(path31, options, cb) {
if (typeof options === "function")
cb = options, options = null;
var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path32, options2, cb2, startTime) {
return fs$readdir(path32, fs$readdirCallback(
path32,
options2,
cb2,
startTime
));
} : function go$readdir2(path32, options2, cb2, startTime) {
return fs$readdir(path32, options2, fs$readdirCallback(
path32,
options2,
cb2,
startTime
));
};
return go$readdir(path31, options, cb);
function fs$readdirCallback(path32, options2, cb2, startTime) {
return function(err, files) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([
go$readdir,
[path32, options2, 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(fs31);
ReadStream = legStreams.ReadStream;
WriteStream = legStreams.WriteStream;
}
var fs$ReadStream = fs31.ReadStream;
if (fs$ReadStream) {
ReadStream.prototype = Object.create(fs$ReadStream.prototype);
ReadStream.prototype.open = ReadStream$open;
}
var fs$WriteStream = fs31.WriteStream;
if (fs$WriteStream) {
WriteStream.prototype = Object.create(fs$WriteStream.prototype);
WriteStream.prototype.open = WriteStream$open;
}
Object.defineProperty(fs31, "ReadStream", {
get: function() {
return ReadStream;
},
set: function(val) {
ReadStream = val;
},
enumerable: true,
configurable: true
});
Object.defineProperty(fs31, "WriteStream", {
get: function() {
return WriteStream;
},
set: function(val) {
WriteStream = val;
},
enumerable: true,
configurable: true
});
var FileReadStream = ReadStream;
Object.defineProperty(fs31, "FileReadStream", {
get: function() {
return FileReadStream;
},
set: function(val) {
FileReadStream = val;
},
enumerable: true,
configurable: true
});
var FileWriteStream = WriteStream;
Object.defineProperty(fs31, "FileWriteStream", {
get: function() {
return FileWriteStream;
},
set: function(val) {
FileWriteStream = val;
},
enumerable: true,
configurable: true
});
function ReadStream(path31, options) {
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(path31, options) {
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 createReadStream3(path31, options) {
return new fs31.ReadStream(path31, options);
}
function createWriteStream(path31, options) {
return new fs31.WriteStream(path31, options);
}
var fs$open = fs31.open;
fs31.open = open;
function open(path31, flags, mode, cb) {
if (typeof mode === "function")
cb = mode, mode = null;
return go$open(path31, flags, mode, cb);
function go$open(path32, flags2, mode2, cb2, startTime) {
return fs$open(path32, flags2, mode2, function(err, fd) {
if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
enqueue([go$open, [path32, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
else {
if (typeof cb2 === "function")
cb2.apply(this, arguments);
}
});
}
}
return fs31;
}
function enqueue(elem) {
debug("ENQUEUE", elem[0].name, elem[1]);
fs30[gracefulQueue].push(elem);
retry();
}
var retryTimer;
function resetQueue() {
var now = Date.now();
for (var i = 0; i < fs30[gracefulQueue].length; ++i) {
if (fs30[gracefulQueue][i].length > 2) {
fs30[gracefulQueue][i][3] = now;
fs30[gracefulQueue][i][4] = now;
}
}
retry();
}
function retry() {
clearTimeout(retryTimer);
retryTimer = void 0;
if (fs30[gracefulQueue].length === 0)
return;
var elem = fs30[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) {
debug("RETRY", fn.name, args);
fn.apply(null, args);
} else if (Date.now() - startTime >= 6e4) {
debug("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) {
debug("RETRY", fn.name, args);
fn.apply(null, args.concat([startTime]));
} else {
fs30[gracefulQueue].push(elem);
}
}
if (retryTimer === void 0) {
retryTimer = setTimeout(retry, 0);
}
}
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fast-safe-stringify/2.1.1/71177aa317bf9c10d6ba54feb1e03d154d670845bac275960b4cc587a01d5783/node_modules/fast-safe-stringify/index.js
var require_fast_safe_stringify = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fast-safe-stringify/2.1.1/71177aa317bf9c10d6ba54feb1e03d154d670845bac275960b4cc587a01d5783/node_modules/fast-safe-stringify/index.js"(exports, module) {
module.exports = stringify;
stringify.default = stringify;
stringify.stable = deterministicStringify;
stringify.stableStringify = deterministicStringify;
var LIMIT_REPLACE_NODE = "[...]";
var CIRCULAR_REPLACE_NODE = "[Circular]";
var arr = [];
var replacerStack = [];
function defaultOptions2() {
return {
depthLimit: Number.MAX_SAFE_INTEGER,
edgesLimit: Number.MAX_SAFE_INTEGER
};
}
function stringify(obj, replacer, spacer, options) {
if (typeof options === "undefined") {
options = defaultOptions2();
}
decirc(obj, "", 0, [], void 0, 0, options);
var res;
try {
if (replacerStack.length === 0) {
res = JSON.stringify(obj, replacer, spacer);
} else {
res = JSON.stringify(obj, replaceGetterValues(replacer), spacer);
}
} catch (_) {
return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
} finally {
while (arr.length !== 0) {
var part = arr.pop();
if (part.length === 4) {
Object.defineProperty(part[0], part[1], part[3]);
} else {
part[0][part[1]] = part[2];
}
}
}
return res;
}
function setReplace(replace, val, k, parent) {
var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
if (propertyDescriptor.get !== void 0) {
if (propertyDescriptor.configurable) {
Object.defineProperty(parent, k, { value: replace });
arr.push([parent, k, val, propertyDescriptor]);
} else {
replacerStack.push([val, k, replace]);
}
} else {
parent[k] = replace;
arr.push([parent, k, val]);
}
}
function decirc(val, k, edgeIndex, stack, parent, depth, options) {
depth += 1;
var i;
if (typeof val === "object" && val !== null) {
for (i = 0; i < stack.length; i++) {
if (stack[i] === val) {
setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
return;
}
}
if (typeof options.depthLimit !== "undefined" && depth > options.depthLimit) {
setReplace(LIMIT_REPLACE_NODE, val, k, parent);
return;
}
if (typeof options.edgesLimit !== "undefined" && edgeIndex + 1 > options.edgesLimit) {
setReplace(LIMIT_REPLACE_NODE, val, k, parent);
return;
}
stack.push(val);
if (Array.isArray(val)) {
for (i = 0; i < val.length; i++) {
decirc(val[i], i, i, stack, val, depth, options);
}
} else {
var keys = Object.keys(val);
for (i = 0; i < keys.length; i++) {
var key = keys[i];
decirc(val[key], key, i, stack, val, depth, options);
}
}
stack.pop();
}
}
function compareFunction(a, b) {
if (a < b) {
return -1;
}
if (a > b) {
return 1;
}
return 0;
}
function deterministicStringify(obj, replacer, spacer, options) {
if (typeof options === "undefined") {
options = defaultOptions2();
}
var tmp = deterministicDecirc(obj, "", 0, [], void 0, 0, options) || obj;
var res;
try {
if (replacerStack.length === 0) {
res = JSON.stringify(tmp, replacer, spacer);
} else {
res = JSON.stringify(tmp, replaceGetterValues(replacer), spacer);
}
} catch (_) {
return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
} finally {
while (arr.length !== 0) {
var part = arr.pop();
if (part.length === 4) {
Object.defineProperty(part[0], part[1], part[3]);
} else {
part[0][part[1]] = part[2];
}
}
}
return res;
}
function deterministicDecirc(val, k, edgeIndex, stack, parent, depth, options) {
depth += 1;
var i;
if (typeof val === "object" && val !== null) {
for (i = 0; i < stack.length; i++) {
if (stack[i] === val) {
setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
return;
}
}
try {
if (typeof val.toJSON === "function") {
return;
}
} catch (_) {
return;
}
if (typeof options.depthLimit !== "undefined" && depth > options.depthLimit) {
setReplace(LIMIT_REPLACE_NODE, val, k, parent);
return;
}
if (typeof options.edgesLimit !== "undefined" && edgeIndex + 1 > options.edgesLimit) {
setReplace(LIMIT_REPLACE_NODE, val, k, parent);
return;
}
stack.push(val);
if (Array.isArray(val)) {
for (i = 0; i < val.length; i++) {
deterministicDecirc(val[i], i, i, stack, val, depth, options);
}
} else {
var tmp = {};
var keys = Object.keys(val).sort(compareFunction);
for (i = 0; i < keys.length; i++) {
var key = keys[i];
deterministicDecirc(val[key], key, i, stack, val, depth, options);
tmp[key] = val[key];
}
if (typeof parent !== "undefined") {
arr.push([parent, k, val]);
parent[k] = tmp;
} else {
return tmp;
}
}
stack.pop();
}
}
function replaceGetterValues(replacer) {
replacer = typeof replacer !== "undefined" ? replacer : function(k, v) {
return v;
};
return function(key, val) {
if (replacerStack.length > 0) {
for (var i = 0; i < replacerStack.length; i++) {
var part = replacerStack[i];
if (part[1] === key && part[0] === val) {
val = part[2];
replacerStack.splice(i, 1);
break;
}
}
}
return replacer.call(this, key, val);
};
}
}
});
// ../../../../../setup-pnpm/store/v11/links/@/individual/3.0.0/82ec8ef054bfaf915092db8496dd7cdf5d8a529ff6202ce432d93772b51b5045/node_modules/individual/index.js
var require_individual = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/individual/3.0.0/82ec8ef054bfaf915092db8496dd7cdf5d8a529ff6202ce432d93772b51b5045/node_modules/individual/index.js"(exports, module) {
"use strict";
var root = typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
module.exports = Individual;
function Individual(key, value) {
if (key in root) {
return root[key];
}
root[key] = value;
return value;
}
}
});
// ../../../../../setup-pnpm/store/v11/links/@/bole/5.0.29/6922e0a3a11b46fb67db71b821bacb20a87db33d8d1fb079a84a148dc6373834/node_modules/bole/format.js
var require_format = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/bole/5.0.29/6922e0a3a11b46fb67db71b821bacb20a87db33d8d1fb079a84a148dc6373834/node_modules/bole/format.js"(exports, module) {
var utilformat = __require("util").format;
function format(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) {
if (a16 !== void 0) {
return utilformat(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16);
}
if (a15 !== void 0) {
return utilformat(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
}
if (a14 !== void 0) {
return utilformat(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
}
if (a13 !== void 0) {
return utilformat(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
}
if (a12 !== void 0) {
return utilformat(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
}
if (a11 !== void 0) {
return utilformat(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
}
if (a10 !== void 0) {
return utilformat(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
}
if (a9 !== void 0) {
return utilformat(a1, a2, a3, a4, a5, a6, a7, a8, a9);
}
if (a8 !== void 0) {
return utilformat(a1, a2, a3, a4, a5, a6, a7, a8);
}
if (a7 !== void 0) {
return utilformat(a1, a2, a3, a4, a5, a6, a7);
}
if (a6 !== void 0) {
return utilformat(a1, a2, a3, a4, a5, a6);
}
if (a5 !== void 0) {
return utilformat(a1, a2, a3, a4, a5);
}
if (a4 !== void 0) {
return utilformat(a1, a2, a3, a4);
}
if (a3 !== void 0) {
return utilformat(a1, a2, a3);
}
if (a2 !== void 0) {
return utilformat(a1, a2);
}
return a1;
}
module.exports = format;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/bole/5.0.29/6922e0a3a11b46fb67db71b821bacb20a87db33d8d1fb079a84a148dc6373834/node_modules/bole/bole.js
var require_bole = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/bole/5.0.29/6922e0a3a11b46fb67db71b821bacb20a87db33d8d1fb079a84a148dc6373834/node_modules/bole/bole.js"(exports, module) {
"use strict";
var _stringify = require_fast_safe_stringify();
var individual = require_individual()("$$bole", { fastTime: false });
var format = require_format();
var levels = "debug info warn error".split(" ");
var os2 = __require("os");
var pid = process.pid;
var hasObjMode = false;
var scache = [];
var hostname;
try {
hostname = os2.hostname();
} catch (e) {
hostname = os2.version().indexOf("Windows 7 ") === 0 ? "windows7" : "hostname-unknown";
}
var hostnameSt = _stringify(hostname);
for (const level of levels) {
scache[level] = ',"hostname":' + hostnameSt + ',"pid":' + pid + ',"level":"' + level;
Number(scache[level]);
if (!Array.isArray(individual[level])) {
individual[level] = [];
}
}
function stackToString(e) {
let s = e.stack;
let ce;
if (typeof e.cause === "function" && (ce = e.cause())) {
s += "\nCaused by: " + stackToString(ce);
}
return s;
}
function errorToOut(err, out) {
out.err = {
name: err.name,
message: err.message,
code: err.code,
// perhaps
stack: stackToString(err)
};
}
function requestToOut(req2, out) {
out.req = {
method: req2.method,
url: req2.url,
headers: req2.headers,
remoteAddress: req2.connection.remoteAddress,
remotePort: req2.connection.remotePort
};
}
function objectToOut(obj, out) {
for (const k in obj) {
if (Object.prototype.hasOwnProperty.call(obj, k) && obj[k] !== void 0) {
out[k] = obj[k];
}
}
}
function objectMode(stream) {
return stream._writableState && stream._writableState.objectMode === true;
}
function stringify(level, name, message, obj) {
let s = '{"time":' + (individual.fastTime ? Date.now() : '"' + (/* @__PURE__ */ new Date()).toISOString() + '"') + scache[level] + '","name":' + name + (message !== void 0 ? ',"message":' + _stringify(message) : "");
for (const k in obj) {
s += "," + _stringify(k) + ":" + _stringify(obj[k]);
}
s += "}";
Number(s);
return s;
}
function extend(level, name, message, obj) {
const newObj = {
time: individual.fastTime ? Date.now() : (/* @__PURE__ */ new Date()).toISOString(),
hostname,
pid,
level,
name
};
if (message !== void 0) {
obj.message = message;
}
for (const k in obj) {
newObj[k] = obj[k];
}
return newObj;
}
function levelLogger(level, name) {
const outputs = individual[level];
const nameSt = _stringify(name);
return function namedLevelLogger(inp, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) {
if (outputs.length === 0) {
return;
}
const out = {};
let objectOut;
let i = 0;
const l = outputs.length;
let stringified;
let message;
if (typeof inp === "string" || inp == null) {
if (!(message = format(inp, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16))) {
message = void 0;
}
} else {
if (inp instanceof Error) {
if (typeof a2 === "object") {
objectToOut(a2, out);
errorToOut(inp, out);
if (!(message = format(a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16))) {
message = void 0;
}
} else {
errorToOut(inp, out);
if (!(message = format(a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16))) {
message = void 0;
}
}
} else {
if (!(message = format(a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16))) {
message = void 0;
}
}
if (typeof inp === "boolean") {
message = String(inp);
} else if (typeof inp === "object" && !(inp instanceof Error)) {
if (inp.method && inp.url && inp.headers && inp.socket) {
requestToOut(inp, out);
} else {
objectToOut(inp, out);
}
}
}
if (l === 1 && !hasObjMode) {
outputs[0].write(Buffer.from(stringify(level, nameSt, message, out) + "\n"));
return;
}
for (; i < l; i++) {
if (objectMode(outputs[i])) {
if (objectOut === void 0) {
objectOut = extend(level, name, message, out);
}
outputs[i].write(objectOut);
} else {
if (stringified === void 0) {
stringified = Buffer.from(stringify(level, nameSt, message, out) + "\n");
}
outputs[i].write(stringified);
}
}
};
}
function bole4(name) {
function boleLogger(subname) {
return bole4(name + ":" + subname);
}
function makeLogger(p, level) {
p[level] = levelLogger(level, name);
return p;
}
return levels.reduce(makeLogger, boleLogger);
}
bole4.output = function output(opt) {
let b = false;
if (Array.isArray(opt)) {
opt.forEach(bole4.output);
return bole4;
}
if (typeof opt.level !== "string") {
throw new TypeError('Must provide a "level" option');
}
for (const level of levels) {
if (!b && level === opt.level) {
b = true;
}
if (b) {
if (opt.stream && objectMode(opt.stream)) {
hasObjMode = true;
}
individual[level].push(opt.stream);
}
}
return bole4;
};
bole4.reset = function reset() {
for (const level of levels) {
individual[level].splice(0, individual[level].length);
}
individual.fastTime = false;
return bole4;
};
bole4.setFastTime = function setFastTime(b) {
if (!arguments.length) {
individual.fastTime = true;
} else {
individual.fastTime = b;
}
return bole4;
};
module.exports = bole4;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/split2/4.2.0/40e414c630ab7f443818aa50ee06a670a46fe60cf81f7f81a46733d76a4ce6ba/node_modules/split2/index.js
var require_split2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/split2/4.2.0/40e414c630ab7f443818aa50ee06a670a46fe60cf81f7f81a46733d76a4ce6ba/node_modules/split2/index.js"(exports, module) {
"use strict";
var { Transform } = __require("stream");
var { StringDecoder } = __require("string_decoder");
var kLast = /* @__PURE__ */ Symbol("last");
var kDecoder = /* @__PURE__ */ Symbol("decoder");
function transform(chunk, enc, cb) {
let list;
if (this.overflow) {
const buf = this[kDecoder].write(chunk);
list = buf.split(this.matcher);
if (list.length === 1) return cb();
list.shift();
this.overflow = false;
} else {
this[kLast] += this[kDecoder].write(chunk);
list = this[kLast].split(this.matcher);
}
this[kLast] = list.pop();
for (let i = 0; i < list.length; i++) {
try {
push(this, this.mapper(list[i]));
} catch (error) {
return cb(error);
}
}
this.overflow = this[kLast].length > this.maxLength;
if (this.overflow && !this.skipOverflow) {
cb(new Error("maximum buffer reached"));
return;
}
cb();
}
function flush(cb) {
this[kLast] += this[kDecoder].end();
if (this[kLast]) {
try {
push(this, this.mapper(this[kLast]));
} catch (error) {
return cb(error);
}
}
cb();
}
function push(self2, val) {
if (val !== void 0) {
self2.push(val);
}
}
function noop(incoming) {
return incoming;
}
function split2(matcher, mapper, options) {
matcher = matcher || /\r?\n/;
mapper = mapper || noop;
options = options || {};
switch (arguments.length) {
case 1:
if (typeof matcher === "function") {
mapper = matcher;
matcher = /\r?\n/;
} else if (typeof matcher === "object" && !(matcher instanceof RegExp) && !matcher[Symbol.split]) {
options = matcher;
matcher = /\r?\n/;
}
break;
case 2:
if (typeof matcher === "function") {
options = mapper;
mapper = matcher;
matcher = /\r?\n/;
} else if (typeof mapper === "object") {
options = mapper;
mapper = noop;
}
}
options = Object.assign({}, options);
options.autoDestroy = true;
options.transform = transform;
options.flush = flush;
options.readableObjectMode = true;
const stream = new Transform(options);
stream[kLast] = "";
stream[kDecoder] = new StringDecoder("utf8");
stream.matcher = matcher;
stream.mapper = mapper;
stream.maxLength = options.maxLength;
stream.skipOverflow = options.skipOverflow || false;
stream.overflow = false;
stream._destroy = function(err, cb) {
this._writableState.errorEmitted = false;
cb(err);
};
return stream;
}
module.exports = split2;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/is-windows/1.0.2/8de297753f5a2f0d3154b27e41b774686b53f5e3c186cf9f734f0a5ce4054b2e/node_modules/is-windows/index.js
var require_is_windows = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/is-windows/1.0.2/8de297753f5a2f0d3154b27e41b774686b53f5e3c186cf9f734f0a5ce4054b2e/node_modules/is-windows/index.js"(exports, module) {
(function(factory) {
if (exports && typeof exports === "object" && typeof module !== "undefined") {
module.exports = factory();
} else if (typeof define === "function" && define.amd) {
define([], factory);
} else if (typeof window !== "undefined") {
window.isWindows = factory();
} else if (typeof global !== "undefined") {
global.isWindows = factory();
} else if (typeof self !== "undefined") {
self.isWindows = factory();
} else {
this.isWindows = factory();
}
})(function() {
"use strict";
return function isWindows2() {
return process && (process.platform === "win32" || /^(msys|cygwin)$/.test(process.env.OSTYPE));
};
});
}
});
// ../../../../../setup-pnpm/store/v11/links/@/universalify/2.0.1/3983135594189f71b00fc07b6b17387b476e8a92e19ec2a61c1f0e0d68895f4d/node_modules/universalify/index.js
var require_universalify = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/universalify/2.0.1/3983135594189f71b00fc07b6b17387b476e8a92e19ec2a61c1f0e0d68895f4d/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) => {
args.push((err, res) => err != null ? reject(err) : resolve(res));
fn.apply(this, args);
});
}
}, "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 {
args.pop();
fn.apply(this, args).then((r) => cb(null, r), cb);
}
}, "name", { value: fn.name });
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/fs/index.js
var require_fs = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/fs/index.js"(exports) {
"use strict";
var u = require_universalify().fromCallback;
var fs30 = require_graceful_fs();
var api = [
"access",
"appendFile",
"chmod",
"chown",
"close",
"copyFile",
"cp",
"fchmod",
"fchown",
"fdatasync",
"fstat",
"fsync",
"ftruncate",
"futimes",
"glob",
"lchmod",
"lchown",
"lutimes",
"link",
"lstat",
"mkdir",
"mkdtemp",
"open",
"opendir",
"readdir",
"readFile",
"readlink",
"realpath",
"rename",
"rm",
"rmdir",
"stat",
"statfs",
"symlink",
"truncate",
"unlink",
"utimes",
"writeFile"
].filter((key) => {
return typeof fs30[key] === "function";
});
Object.assign(exports, fs30);
api.forEach((method) => {
exports[method] = u(fs30[method]);
});
exports.exists = function(filename, callback) {
if (typeof callback === "function") {
return fs30.exists(filename, callback);
}
return new Promise((resolve) => {
return fs30.exists(filename, resolve);
});
};
exports.read = function(fd, buffer, offset, length, position3, callback) {
if (typeof callback === "function") {
return fs30.read(fd, buffer, offset, length, position3, callback);
}
return new Promise((resolve, reject) => {
fs30.read(fd, buffer, offset, length, position3, (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 fs30.write(fd, buffer, ...args);
}
return new Promise((resolve, reject) => {
fs30.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 fs30.readv(fd, buffers, ...args);
}
return new Promise((resolve, reject) => {
fs30.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 fs30.writev(fd, buffers, ...args);
}
return new Promise((resolve, reject) => {
fs30.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
if (err) return reject(err);
resolve({ bytesWritten, buffers: buffers2 });
});
});
};
if (typeof fs30.realpath.native === "function") {
exports.realpath.native = u(fs30.realpath.native);
} else {
process.emitWarning(
"fs.realpath.native is not a function. Is fs being monkey-patched?",
"Warning",
"fs-extra-WARN0003"
);
}
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/mkdirs/utils.js
var require_utils = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module) {
"use strict";
var path31 = __require("path");
module.exports.checkPath = function checkPath(pth) {
if (process.platform === "win32") {
const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path31.parse(pth).root, ""));
if (pathHasInvalidWinCharacters) {
const error = new Error(`Path contains invalid characters: ${pth}`);
error.code = "EINVAL";
throw error;
}
}
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/mkdirs/make-dir.js
var require_make_dir = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module) {
"use strict";
var fs30 = require_fs();
var { checkPath } = require_utils();
var getMode = (options) => {
const defaults = { mode: 511 };
if (typeof options === "number") return options;
return { ...defaults, ...options }.mode;
};
module.exports.makeDir = async (dir, options) => {
checkPath(dir);
return fs30.mkdir(dir, {
mode: getMode(options),
recursive: true
});
};
module.exports.makeDirSync = (dir, options) => {
checkPath(dir);
return fs30.mkdirSync(dir, {
mode: getMode(options),
recursive: true
});
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/mkdirs/index.js
var require_mkdirs = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/mkdirs/index.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var { makeDir: _makeDir, makeDirSync } = require_make_dir();
var makeDir = u(_makeDir);
module.exports = {
mkdirs: makeDir,
mkdirsSync: makeDirSync,
// alias
mkdirp: makeDir,
mkdirpSync: makeDirSync,
ensureDir: makeDir,
ensureDirSync: makeDirSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/path-exists/index.js
var require_path_exists = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/path-exists/index.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var fs30 = require_fs();
function pathExists(path31) {
return fs30.access(path31).then(() => true).catch(() => false);
}
module.exports = {
pathExists: u(pathExists),
pathExistsSync: fs30.existsSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/util/utimes.js
var require_utimes = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/util/utimes.js"(exports, module) {
"use strict";
var fs30 = require_fs();
var u = require_universalify().fromPromise;
async function utimesMillis(path31, atime, mtime) {
const fd = await fs30.open(path31, "r+");
let closeErr = null;
try {
await fs30.futimes(fd, atime, mtime);
} finally {
try {
await fs30.close(fd);
} catch (e) {
closeErr = e;
}
}
if (closeErr) {
throw closeErr;
}
}
function utimesMillisSync(path31, atime, mtime) {
const fd = fs30.openSync(path31, "r+");
fs30.futimesSync(fd, atime, mtime);
return fs30.closeSync(fd);
}
module.exports = {
utimesMillis: u(utimesMillis),
utimesMillisSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/util/stat.js
var require_stat = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/util/stat.js"(exports, module) {
"use strict";
var fs30 = require_fs();
var path31 = __require("path");
var u = require_universalify().fromPromise;
function getStats(src2, dest, opts2) {
const statFunc = opts2.dereference ? (file) => fs30.stat(file, { bigint: true }) : (file) => fs30.lstat(file, { bigint: true });
return Promise.all([
statFunc(src2),
statFunc(dest).catch((err) => {
if (err.code === "ENOENT") return null;
throw err;
})
]).then(([srcStat, destStat]) => ({ srcStat, destStat }));
}
function getStatsSync(src2, dest, opts2) {
let destStat;
const statFunc = opts2.dereference ? (file) => fs30.statSync(file, { bigint: true }) : (file) => fs30.lstatSync(file, { bigint: true });
const srcStat = statFunc(src2);
try {
destStat = statFunc(dest);
} catch (err) {
if (err.code === "ENOENT") return { srcStat, destStat: null };
throw err;
}
return { srcStat, destStat };
}
async function checkPaths(src2, dest, funcName, opts2) {
const { srcStat, destStat } = await getStats(src2, dest, opts2);
if (destStat) {
if (areIdentical(srcStat, destStat)) {
const srcBaseName = path31.basename(src2);
const destBaseName = path31.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 '${src2}'.`);
}
if (!srcStat.isDirectory() && destStat.isDirectory()) {
throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src2}'.`);
}
}
if (srcStat.isDirectory() && isSrcSubdir(src2, dest)) {
throw new Error(errMsg(src2, dest, funcName));
}
return { srcStat, destStat };
}
function checkPathsSync(src2, dest, funcName, opts2) {
const { srcStat, destStat } = getStatsSync(src2, dest, opts2);
if (destStat) {
if (areIdentical(srcStat, destStat)) {
const srcBaseName = path31.basename(src2);
const destBaseName = path31.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 '${src2}'.`);
}
if (!srcStat.isDirectory() && destStat.isDirectory()) {
throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src2}'.`);
}
}
if (srcStat.isDirectory() && isSrcSubdir(src2, dest)) {
throw new Error(errMsg(src2, dest, funcName));
}
return { srcStat, destStat };
}
async function checkParentPaths(src2, srcStat, dest, funcName) {
const srcParent = path31.resolve(path31.dirname(src2));
const destParent = path31.resolve(path31.dirname(dest));
if (destParent === srcParent || destParent === path31.parse(destParent).root) return;
let destStat;
try {
destStat = await fs30.stat(destParent, { bigint: true });
} catch (err) {
if (err.code === "ENOENT") return;
throw err;
}
if (areIdentical(srcStat, destStat)) {
throw new Error(errMsg(src2, dest, funcName));
}
return checkParentPaths(src2, srcStat, destParent, funcName);
}
function checkParentPathsSync(src2, srcStat, dest, funcName) {
const srcParent = path31.resolve(path31.dirname(src2));
const destParent = path31.resolve(path31.dirname(dest));
if (destParent === srcParent || destParent === path31.parse(destParent).root) return;
let destStat;
try {
destStat = fs30.statSync(destParent, { bigint: true });
} catch (err) {
if (err.code === "ENOENT") return;
throw err;
}
if (areIdentical(srcStat, destStat)) {
throw new Error(errMsg(src2, dest, funcName));
}
return checkParentPathsSync(src2, srcStat, destParent, funcName);
}
function areIdentical(srcStat, destStat) {
return destStat.ino !== void 0 && destStat.dev !== void 0 && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
}
function isSrcSubdir(src2, dest) {
const srcArr = path31.resolve(src2).split(path31.sep).filter((i) => i);
const destArr = path31.resolve(dest).split(path31.sep).filter((i) => i);
return srcArr.every((cur, i) => destArr[i] === cur);
}
function errMsg(src2, dest, funcName) {
return `Cannot ${funcName} '${src2}' to a subdirectory of itself, '${dest}'.`;
}
module.exports = {
// checkPaths
checkPaths: u(checkPaths),
checkPathsSync,
// checkParent
checkParentPaths: u(checkParentPaths),
checkParentPathsSync,
// Misc
isSrcSubdir,
areIdentical
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/util/async.js
var require_async = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/util/async.js"(exports, module) {
"use strict";
async function asyncIteratorConcurrentProcess(iterator, fn) {
const promises = [];
for await (const item of iterator) {
promises.push(
fn(item).then(
() => null,
(err) => err ?? new Error("unknown error")
)
);
}
await Promise.all(
promises.map(
(promise) => promise.then((possibleErr) => {
if (possibleErr !== null) throw possibleErr;
})
)
);
}
module.exports = {
asyncIteratorConcurrentProcess
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/copy/copy.js
var require_copy = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/copy/copy.js"(exports, module) {
"use strict";
var fs30 = require_fs();
var path31 = __require("path");
var { mkdirs } = require_mkdirs();
var { pathExists } = require_path_exists();
var { utimesMillis } = require_utimes();
var stat = require_stat();
var { asyncIteratorConcurrentProcess } = require_async();
async function copy2(src2, dest, opts2 = {}) {
if (typeof opts2 === "function") {
opts2 = { filter: 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"
);
}
const { srcStat, destStat } = await stat.checkPaths(src2, dest, "copy", opts2);
await stat.checkParentPaths(src2, srcStat, dest, "copy");
const include = await runFilter(src2, dest, opts2);
if (!include) return;
const destParent = path31.dirname(dest);
const dirExists = await pathExists(destParent);
if (!dirExists) {
await mkdirs(destParent);
}
await getStatsAndPerformCopy(destStat, src2, dest, opts2);
}
async function runFilter(src2, dest, opts2) {
if (!opts2.filter) return true;
return opts2.filter(src2, dest);
}
async function getStatsAndPerformCopy(destStat, src2, dest, opts2) {
const statFn = opts2.dereference ? fs30.stat : fs30.lstat;
const srcStat = await statFn(src2);
if (srcStat.isDirectory()) return onDir(srcStat, destStat, src2, dest, opts2);
if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src2, dest, opts2);
if (srcStat.isSymbolicLink()) return onLink(destStat, src2, dest, opts2);
if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src2}`);
if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src2}`);
throw new Error(`Unknown file: ${src2}`);
}
async function onFile(srcStat, destStat, src2, dest, opts2) {
if (!destStat) return copyFile(srcStat, src2, dest, opts2);
if (opts2.overwrite) {
await fs30.unlink(dest);
return copyFile(srcStat, src2, dest, opts2);
}
if (opts2.errorOnExist) {
throw new Error(`'${dest}' already exists`);
}
}
async function copyFile(srcStat, src2, dest, opts2) {
await fs30.copyFile(src2, dest);
if (opts2.preserveTimestamps) {
if (fileIsNotWritable(srcStat.mode)) {
await makeFileWritable(dest, srcStat.mode);
}
const updatedSrcStat = await fs30.stat(src2);
await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
}
return fs30.chmod(dest, srcStat.mode);
}
function fileIsNotWritable(srcMode) {
return (srcMode & 128) === 0;
}
function makeFileWritable(dest, srcMode) {
return fs30.chmod(dest, srcMode | 128);
}
async function onDir(srcStat, destStat, src2, dest, opts2) {
if (!destStat) {
await fs30.mkdir(dest);
}
await asyncIteratorConcurrentProcess(await fs30.opendir(src2), async (item) => {
const srcItem = path31.join(src2, item.name);
const destItem = path31.join(dest, item.name);
const include = await runFilter(srcItem, destItem, opts2);
if (include) {
const { destStat: destStat2 } = await stat.checkPaths(srcItem, destItem, "copy", opts2);
await getStatsAndPerformCopy(destStat2, srcItem, destItem, opts2);
}
});
if (!destStat) {
await fs30.chmod(dest, srcStat.mode);
}
}
async function onLink(destStat, src2, dest, opts2) {
let resolvedSrc = await fs30.readlink(src2);
if (opts2.dereference) {
resolvedSrc = path31.resolve(process.cwd(), resolvedSrc);
}
if (!destStat) {
return fs30.symlink(resolvedSrc, dest);
}
let resolvedDest = null;
try {
resolvedDest = await fs30.readlink(dest);
} catch (e) {
if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs30.symlink(resolvedSrc, dest);
throw e;
}
if (opts2.dereference) {
resolvedDest = path31.resolve(process.cwd(), resolvedDest);
}
if (resolvedSrc !== 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}'.`);
}
}
await fs30.unlink(dest);
return fs30.symlink(resolvedSrc, dest);
}
module.exports = copy2;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/copy/copy-sync.js
var require_copy_sync = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) {
"use strict";
var fs30 = require_graceful_fs();
var path31 = __require("path");
var mkdirsSync = require_mkdirs().mkdirsSync;
var utimesMillisSync = require_utimes().utimesMillisSync;
var stat = require_stat();
function copySync2(src2, 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(src2, dest, "copy", opts2);
stat.checkParentPathsSync(src2, srcStat, dest, "copy");
if (opts2.filter && !opts2.filter(src2, dest)) return;
const destParent = path31.dirname(dest);
if (!fs30.existsSync(destParent)) mkdirsSync(destParent);
return getStats(destStat, src2, dest, opts2);
}
function getStats(destStat, src2, dest, opts2) {
const statSync = opts2.dereference ? fs30.statSync : fs30.lstatSync;
const srcStat = statSync(src2);
if (srcStat.isDirectory()) return onDir(srcStat, destStat, src2, dest, opts2);
else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src2, dest, opts2);
else if (srcStat.isSymbolicLink()) return onLink(destStat, src2, dest, opts2);
else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src2}`);
else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src2}`);
throw new Error(`Unknown file: ${src2}`);
}
function onFile(srcStat, destStat, src2, dest, opts2) {
if (!destStat) return copyFile(srcStat, src2, dest, opts2);
return mayCopyFile(srcStat, src2, dest, opts2);
}
function mayCopyFile(srcStat, src2, dest, opts2) {
if (opts2.overwrite) {
fs30.unlinkSync(dest);
return copyFile(srcStat, src2, dest, opts2);
} else if (opts2.errorOnExist) {
throw new Error(`'${dest}' already exists`);
}
}
function copyFile(srcStat, src2, dest, opts2) {
fs30.copyFileSync(src2, dest);
if (opts2.preserveTimestamps) handleTimestamps(srcStat.mode, src2, dest);
return setDestMode(dest, srcStat.mode);
}
function handleTimestamps(srcMode, src2, dest) {
if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode);
return setDestTimestamps(src2, dest);
}
function fileIsNotWritable(srcMode) {
return (srcMode & 128) === 0;
}
function makeFileWritable(dest, srcMode) {
return setDestMode(dest, srcMode | 128);
}
function setDestMode(dest, srcMode) {
return fs30.chmodSync(dest, srcMode);
}
function setDestTimestamps(src2, dest) {
const updatedSrcStat = fs30.statSync(src2);
return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
}
function onDir(srcStat, destStat, src2, dest, opts2) {
if (!destStat) return mkDirAndCopy(srcStat.mode, src2, dest, opts2);
return copyDir(src2, dest, opts2);
}
function mkDirAndCopy(srcMode, src2, dest, opts2) {
fs30.mkdirSync(dest);
copyDir(src2, dest, opts2);
return setDestMode(dest, srcMode);
}
function copyDir(src2, dest, opts2) {
const dir = fs30.opendirSync(src2);
try {
let dirent;
while ((dirent = dir.readSync()) !== null) {
copyDirItem(dirent.name, src2, dest, opts2);
}
} finally {
dir.closeSync();
}
}
function copyDirItem(item, src2, dest, opts2) {
const srcItem = path31.join(src2, item);
const destItem = path31.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, src2, dest, opts2) {
let resolvedSrc = fs30.readlinkSync(src2);
if (opts2.dereference) {
resolvedSrc = path31.resolve(process.cwd(), resolvedSrc);
}
if (!destStat) {
return fs30.symlinkSync(resolvedSrc, dest);
} else {
let resolvedDest;
try {
resolvedDest = fs30.readlinkSync(dest);
} catch (err) {
if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs30.symlinkSync(resolvedSrc, dest);
throw err;
}
if (opts2.dereference) {
resolvedDest = path31.resolve(process.cwd(), resolvedDest);
}
if (resolvedSrc !== 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) {
fs30.unlinkSync(dest);
return fs30.symlinkSync(resolvedSrc, dest);
}
module.exports = copySync2;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/copy/index.js
var require_copy2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/copy/index.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
module.exports = {
copy: u(require_copy()),
copySync: require_copy_sync()
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/remove/index.js
var require_remove = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/remove/index.js"(exports, module) {
"use strict";
var fs30 = require_graceful_fs();
var u = require_universalify().fromCallback;
function remove(path31, callback) {
fs30.rm(path31, { recursive: true, force: true }, callback);
}
function removeSync(path31) {
fs30.rmSync(path31, { recursive: true, force: true });
}
module.exports = {
remove: u(remove),
removeSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/empty/index.js
var require_empty = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/empty/index.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var fs30 = require_fs();
var path31 = __require("path");
var mkdir = require_mkdirs();
var remove = require_remove();
var emptyDir = u(async function emptyDir2(dir) {
let items;
try {
items = await fs30.readdir(dir);
} catch {
return mkdir.mkdirs(dir);
}
return Promise.all(items.map((item) => remove.remove(path31.join(dir, item))));
});
function emptyDirSync(dir) {
let items;
try {
items = fs30.readdirSync(dir);
} catch {
return mkdir.mkdirsSync(dir);
}
items.forEach((item) => {
item = path31.join(dir, item);
remove.removeSync(item);
});
}
module.exports = {
emptyDirSync,
emptydirSync: emptyDirSync,
emptyDir,
emptydir: emptyDir
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/ensure/file.js
var require_file = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/ensure/file.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var path31 = __require("path");
var fs30 = require_fs();
var mkdir = require_mkdirs();
async function createFile(file) {
let stats;
try {
stats = await fs30.stat(file);
} catch {
}
if (stats && stats.isFile()) return;
const dir = path31.dirname(file);
let dirStats = null;
try {
dirStats = await fs30.stat(dir);
} catch (err) {
if (err.code === "ENOENT") {
await mkdir.mkdirs(dir);
await fs30.writeFile(file, "");
return;
} else {
throw err;
}
}
if (dirStats.isDirectory()) {
await fs30.writeFile(file, "");
} else {
await fs30.readdir(dir);
}
}
function createFileSync(file) {
let stats;
try {
stats = fs30.statSync(file);
} catch {
}
if (stats && stats.isFile()) return;
const dir = path31.dirname(file);
try {
if (!fs30.statSync(dir).isDirectory()) {
fs30.readdirSync(dir);
}
} catch (err) {
if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
else throw err;
}
fs30.writeFileSync(file, "");
}
module.exports = {
createFile: u(createFile),
createFileSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/ensure/link.js
var require_link = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/ensure/link.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var path31 = __require("path");
var fs30 = require_fs();
var mkdir = require_mkdirs();
var { pathExists } = require_path_exists();
var { areIdentical } = require_stat();
async function createLink(srcpath, dstpath) {
let dstStat;
try {
dstStat = await fs30.lstat(dstpath);
} catch {
}
let srcStat;
try {
srcStat = await fs30.lstat(srcpath);
} catch (err) {
err.message = err.message.replace("lstat", "ensureLink");
throw err;
}
if (dstStat && areIdentical(srcStat, dstStat)) return;
const dir = path31.dirname(dstpath);
const dirExists = await pathExists(dir);
if (!dirExists) {
await mkdir.mkdirs(dir);
}
await fs30.link(srcpath, dstpath);
}
function createLinkSync(srcpath, dstpath) {
let dstStat;
try {
dstStat = fs30.lstatSync(dstpath);
} catch {
}
try {
const srcStat = fs30.lstatSync(srcpath);
if (dstStat && areIdentical(srcStat, dstStat)) return;
} catch (err) {
err.message = err.message.replace("lstat", "ensureLink");
throw err;
}
const dir = path31.dirname(dstpath);
const dirExists = fs30.existsSync(dir);
if (dirExists) return fs30.linkSync(srcpath, dstpath);
mkdir.mkdirsSync(dir);
return fs30.linkSync(srcpath, dstpath);
}
module.exports = {
createLink: u(createLink),
createLinkSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/ensure/symlink-paths.js
var require_symlink_paths = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module) {
"use strict";
var path31 = __require("path");
var fs30 = require_fs();
var { pathExists } = require_path_exists();
var u = require_universalify().fromPromise;
async function symlinkPaths(srcpath, dstpath) {
if (path31.isAbsolute(srcpath)) {
try {
await fs30.lstat(srcpath);
} catch (err) {
err.message = err.message.replace("lstat", "ensureSymlink");
throw err;
}
return {
toCwd: srcpath,
toDst: srcpath
};
}
const dstdir = path31.dirname(dstpath);
const relativeToDst = path31.join(dstdir, srcpath);
const exists = await pathExists(relativeToDst);
if (exists) {
return {
toCwd: relativeToDst,
toDst: srcpath
};
}
try {
await fs30.lstat(srcpath);
} catch (err) {
err.message = err.message.replace("lstat", "ensureSymlink");
throw err;
}
return {
toCwd: srcpath,
toDst: path31.relative(dstdir, srcpath)
};
}
function symlinkPathsSync(srcpath, dstpath) {
if (path31.isAbsolute(srcpath)) {
const exists2 = fs30.existsSync(srcpath);
if (!exists2) throw new Error("absolute srcpath does not exist");
return {
toCwd: srcpath,
toDst: srcpath
};
}
const dstdir = path31.dirname(dstpath);
const relativeToDst = path31.join(dstdir, srcpath);
const exists = fs30.existsSync(relativeToDst);
if (exists) {
return {
toCwd: relativeToDst,
toDst: srcpath
};
}
const srcExists = fs30.existsSync(srcpath);
if (!srcExists) throw new Error("relative srcpath does not exist");
return {
toCwd: srcpath,
toDst: path31.relative(dstdir, srcpath)
};
}
module.exports = {
symlinkPaths: u(symlinkPaths),
symlinkPathsSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/ensure/symlink-type.js
var require_symlink_type = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module) {
"use strict";
var fs30 = require_fs();
var u = require_universalify().fromPromise;
async function symlinkType(srcpath, type) {
if (type) return type;
let stats;
try {
stats = await fs30.lstat(srcpath);
} catch {
return "file";
}
return stats && stats.isDirectory() ? "dir" : "file";
}
function symlinkTypeSync(srcpath, type) {
if (type) return type;
let stats;
try {
stats = fs30.lstatSync(srcpath);
} catch {
return "file";
}
return stats && stats.isDirectory() ? "dir" : "file";
}
module.exports = {
symlinkType: u(symlinkType),
symlinkTypeSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/ensure/symlink.js
var require_symlink = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/ensure/symlink.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var path31 = __require("path");
var fs30 = require_fs();
var { mkdirs, mkdirsSync } = require_mkdirs();
var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
var { symlinkType, symlinkTypeSync } = require_symlink_type();
var { pathExists } = require_path_exists();
var { areIdentical } = require_stat();
async function createSymlink(srcpath, dstpath, type) {
let stats;
try {
stats = await fs30.lstat(dstpath);
} catch {
}
if (stats && stats.isSymbolicLink()) {
let srcStat;
if (path31.isAbsolute(srcpath)) {
srcStat = await fs30.stat(srcpath);
} else {
const dstdir = path31.dirname(dstpath);
const relativeToDst = path31.join(dstdir, srcpath);
try {
srcStat = await fs30.stat(relativeToDst);
} catch {
srcStat = await fs30.stat(srcpath);
}
}
const dstStat = await fs30.stat(dstpath);
if (areIdentical(srcStat, dstStat)) return;
}
const relative = await symlinkPaths(srcpath, dstpath);
srcpath = relative.toDst;
const toType = await symlinkType(relative.toCwd, type);
const dir = path31.dirname(dstpath);
if (!await pathExists(dir)) {
await mkdirs(dir);
}
return fs30.symlink(srcpath, dstpath, toType);
}
function createSymlinkSync2(srcpath, dstpath, type) {
let stats;
try {
stats = fs30.lstatSync(dstpath);
} catch {
}
if (stats && stats.isSymbolicLink()) {
let srcStat;
if (path31.isAbsolute(srcpath)) {
srcStat = fs30.statSync(srcpath);
} else {
const dstdir = path31.dirname(dstpath);
const relativeToDst = path31.join(dstdir, srcpath);
try {
srcStat = fs30.statSync(relativeToDst);
} catch {
srcStat = fs30.statSync(srcpath);
}
}
const dstStat = fs30.statSync(dstpath);
if (areIdentical(srcStat, dstStat)) return;
}
const relative = symlinkPathsSync(srcpath, dstpath);
srcpath = relative.toDst;
type = symlinkTypeSync(relative.toCwd, type);
const dir = path31.dirname(dstpath);
const exists = fs30.existsSync(dir);
if (exists) return fs30.symlinkSync(srcpath, dstpath, type);
mkdirsSync(dir);
return fs30.symlinkSync(srcpath, dstpath, type);
}
module.exports = {
createSymlink: u(createSymlink),
createSymlinkSync: createSymlinkSync2
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/ensure/index.js
var require_ensure = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/ensure/index.js"(exports, module) {
"use strict";
var { createFile, createFileSync } = require_file();
var { createLink, createLinkSync } = require_link();
var { createSymlink, createSymlinkSync: createSymlinkSync2 } = require_symlink();
module.exports = {
// file
createFile,
createFileSync,
ensureFile: createFile,
ensureFileSync: createFileSync,
// link
createLink,
createLinkSync,
ensureLink: createLink,
ensureLinkSync: createLinkSync,
// symlink
createSymlink,
createSymlinkSync: createSymlinkSync2,
ensureSymlink: createSymlink,
ensureSymlinkSync: createSymlinkSync2
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/jsonfile/6.2.1/4eef6320b797a6391b2bd057b7f45a61f6df9e0461d95dbbea0e70d498ea3860/node_modules/jsonfile/utils.js
var require_utils2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/jsonfile/6.2.1/4eef6320b797a6391b2bd057b7f45a61f6df9e0461d95dbbea0e70d498ea3860/node_modules/jsonfile/utils.js"(exports, module) {
function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
const EOF = finalEOL ? EOL : "";
const str = JSON.stringify(obj, replacer, spaces);
if (str === void 0) {
throw new TypeError(`Converting ${typeof obj} value to JSON is not supported`);
}
return str.replace(/\n/g, EOL) + EOF;
}
function stripBom2(content) {
if (Buffer.isBuffer(content)) content = content.toString("utf8");
return content.replace(/^\uFEFF/, "");
}
module.exports = { stringify, stripBom: stripBom2 };
}
});
// ../../../../../setup-pnpm/store/v11/links/@/jsonfile/6.2.1/4eef6320b797a6391b2bd057b7f45a61f6df9e0461d95dbbea0e70d498ea3860/node_modules/jsonfile/index.js
var require_jsonfile = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/jsonfile/6.2.1/4eef6320b797a6391b2bd057b7f45a61f6df9e0461d95dbbea0e70d498ea3860/node_modules/jsonfile/index.js"(exports, module) {
var _fs;
try {
_fs = require_graceful_fs();
} catch (_) {
_fs = __require("fs");
}
var universalify = require_universalify();
var { stringify, stripBom: stripBom2 } = require_utils2();
async function _readFile(file, options = {}) {
if (typeof options === "string") {
options = { encoding: options };
}
const fs30 = options.fs || _fs;
const shouldThrow = "throws" in options ? options.throws : true;
let data = await universalify.fromCallback(fs30.readFile)(file, options);
data = stripBom2(data);
let obj;
try {
obj = JSON.parse(data, options ? options.reviver : null);
} catch (err) {
if (shouldThrow) {
err.message = `${file}: ${err.message}`;
throw err;
} else {
return null;
}
}
return obj;
}
var readFile2 = universalify.fromPromise(_readFile);
function readFileSync2(file, options = {}) {
if (typeof options === "string") {
options = { encoding: options };
}
const fs30 = options.fs || _fs;
const shouldThrow = "throws" in options ? options.throws : true;
try {
let content = fs30.readFileSync(file, options);
content = stripBom2(content);
return JSON.parse(content, options.reviver);
} catch (err) {
if (shouldThrow) {
err.message = `${file}: ${err.message}`;
throw err;
} else {
return null;
}
}
}
async function _writeFile(file, obj, options = {}) {
const fs30 = options.fs || _fs;
const str = stringify(obj, options);
await universalify.fromCallback(fs30.writeFile)(file, str, options);
}
var writeFile2 = universalify.fromPromise(_writeFile);
function writeFileSync(file, obj, options = {}) {
const fs30 = options.fs || _fs;
const str = stringify(obj, options);
return fs30.writeFileSync(file, str, options);
}
module.exports = {
readFile: readFile2,
readFileSync: readFileSync2,
writeFile: writeFile2,
writeFileSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/json/jsonfile.js
var require_jsonfile2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/json/jsonfile.js"(exports, module) {
"use strict";
var jsonFile = require_jsonfile();
module.exports = {
// jsonfile exports
readJson: jsonFile.readFile,
readJsonSync: jsonFile.readFileSync,
writeJson: jsonFile.writeFile,
writeJsonSync: jsonFile.writeFileSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/output-file/index.js
var require_output_file = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/output-file/index.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var fs30 = require_fs();
var path31 = __require("path");
var mkdir = require_mkdirs();
var pathExists = require_path_exists().pathExists;
async function outputFile(file, data, encoding = "utf-8") {
const dir = path31.dirname(file);
if (!await pathExists(dir)) {
await mkdir.mkdirs(dir);
}
return fs30.writeFile(file, data, encoding);
}
function outputFileSync(file, ...args) {
const dir = path31.dirname(file);
if (!fs30.existsSync(dir)) {
mkdir.mkdirsSync(dir);
}
fs30.writeFileSync(file, ...args);
}
module.exports = {
outputFile: u(outputFile),
outputFileSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/json/output-json.js
var require_output_json = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/json/output-json.js"(exports, module) {
"use strict";
var { stringify } = require_utils2();
var { outputFile } = require_output_file();
async function outputJson(file, data, options = {}) {
const str = stringify(data, options);
await outputFile(file, str, options);
}
module.exports = outputJson;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/json/output-json-sync.js
var require_output_json_sync = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/json/output-json-sync.js"(exports, module) {
"use strict";
var { stringify } = require_utils2();
var { outputFileSync } = require_output_file();
function outputJsonSync(file, data, options) {
const str = stringify(data, options);
outputFileSync(file, str, options);
}
module.exports = outputJsonSync;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/json/index.js
var require_json = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/json/index.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var jsonFile = require_jsonfile2();
jsonFile.outputJson = u(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;
module.exports = jsonFile;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/move/move.js
var require_move = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/move/move.js"(exports, module) {
"use strict";
var fs30 = require_fs();
var path31 = __require("path");
var { copy: copy2 } = require_copy2();
var { remove } = require_remove();
var { mkdirp } = require_mkdirs();
var { pathExists } = require_path_exists();
var stat = require_stat();
async function move(src2, dest, opts2 = {}) {
const overwrite = opts2.overwrite || opts2.clobber || false;
const { srcStat, isChangingCase = false } = await stat.checkPaths(src2, dest, "move", opts2);
await stat.checkParentPaths(src2, srcStat, dest, "move");
const destParent = path31.dirname(dest);
const parsedParentPath = path31.parse(destParent);
if (parsedParentPath.root !== destParent) {
await mkdirp(destParent);
}
return doRename(src2, dest, overwrite, isChangingCase);
}
async function doRename(src2, dest, overwrite, isChangingCase) {
if (!isChangingCase) {
if (overwrite) {
await remove(dest);
} else if (await pathExists(dest)) {
throw new Error("dest already exists.");
}
}
try {
await fs30.rename(src2, dest);
} catch (err) {
if (err.code !== "EXDEV") {
throw err;
}
await moveAcrossDevice(src2, dest, overwrite);
}
}
async function moveAcrossDevice(src2, dest, overwrite) {
const opts2 = {
overwrite,
errorOnExist: true,
preserveTimestamps: true
};
await copy2(src2, dest, opts2);
return remove(src2);
}
module.exports = move;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/move/move-sync.js
var require_move_sync = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/move/move-sync.js"(exports, module) {
"use strict";
var fs30 = require_graceful_fs();
var path31 = __require("path");
var copySync2 = require_copy2().copySync;
var removeSync = require_remove().removeSync;
var mkdirpSync = require_mkdirs().mkdirpSync;
var stat = require_stat();
function moveSync(src2, dest, opts2) {
opts2 = opts2 || {};
const overwrite = opts2.overwrite || opts2.clobber || false;
const { srcStat, isChangingCase = false } = stat.checkPathsSync(src2, dest, "move", opts2);
stat.checkParentPathsSync(src2, srcStat, dest, "move");
if (!isParentRoot(dest)) mkdirpSync(path31.dirname(dest));
return doRename(src2, dest, overwrite, isChangingCase);
}
function isParentRoot(dest) {
const parent = path31.dirname(dest);
const parsedPath = path31.parse(parent);
return parsedPath.root === parent;
}
function doRename(src2, dest, overwrite, isChangingCase) {
if (isChangingCase) return rename(src2, dest, overwrite);
if (overwrite) {
removeSync(dest);
return rename(src2, dest, overwrite);
}
if (fs30.existsSync(dest)) throw new Error("dest already exists.");
return rename(src2, dest, overwrite);
}
function rename(src2, dest, overwrite) {
try {
fs30.renameSync(src2, dest);
} catch (err) {
if (err.code !== "EXDEV") throw err;
return moveAcrossDevice(src2, dest, overwrite);
}
}
function moveAcrossDevice(src2, dest, overwrite) {
const opts2 = {
overwrite,
errorOnExist: true,
preserveTimestamps: true
};
copySync2(src2, dest, opts2);
return removeSync(src2);
}
module.exports = moveSync;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/move/index.js
var require_move2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/move/index.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
module.exports = {
move: u(require_move()),
moveSync: require_move_sync()
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/index.js
var require_lib = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.3.4/4cb0d718f8660ad2564c0d882d89a7255b59466c803fa7e6007de96d8c5aa18b/node_modules/fs-extra/lib/index.js"(exports, module) {
"use strict";
module.exports = {
// Export promiseified graceful-fs:
...require_fs(),
// Export extra methods:
...require_copy2(),
...require_empty(),
...require_ensure(),
...require_json(),
...require_mkdirs(),
...require_move2(),
...require_output_file(),
...require_path_exists(),
...require_remove()
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/validate-npm-package-name/7.0.2/814dcb947be9900c7df1d25263921c519f02120f3fc85aa99a69894e271e5507/node_modules/validate-npm-package-name/lib/builtin-modules.json
var require_builtin_modules = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/validate-npm-package-name/7.0.2/814dcb947be9900c7df1d25263921c519f02120f3fc85aa99a69894e271e5507/node_modules/validate-npm-package-name/lib/builtin-modules.json"(exports, module) {
module.exports = ["_http_agent", "_http_client", "_http_common", "_http_incoming", "_http_outgoing", "_http_server", "_stream_duplex", "_stream_passthrough", "_stream_readable", "_stream_transform", "_stream_wrap", "_stream_writable", "_tls_common", "_tls_wrap", "assert", "assert/strict", "async_hooks", "buffer", "child_process", "cluster", "console", "constants", "crypto", "dgram", "diagnostics_channel", "dns", "dns/promises", "domain", "events", "fs", "fs/promises", "http", "http2", "https", "inspector", "inspector/promises", "module", "net", "os", "path", "path/posix", "path/win32", "perf_hooks", "process", "punycode", "querystring", "readline", "readline/promises", "repl", "stream", "stream/consumers", "stream/promises", "stream/web", "string_decoder", "sys", "timers", "timers/promises", "tls", "trace_events", "tty", "url", "util", "util/types", "v8", "vm", "wasi", "worker_threads", "zlib", "node:sea", "node:sqlite", "node:test", "node:test/reporters"];
}
});
// ../../../../../setup-pnpm/store/v11/links/@/validate-npm-package-name/7.0.2/814dcb947be9900c7df1d25263921c519f02120f3fc85aa99a69894e271e5507/node_modules/validate-npm-package-name/lib/index.js
var require_lib2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/validate-npm-package-name/7.0.2/814dcb947be9900c7df1d25263921c519f02120f3fc85aa99a69894e271e5507/node_modules/validate-npm-package-name/lib/index.js"(exports, module) {
"use strict";
var builtins = require_builtin_modules();
var scopedPackagePattern = new RegExp("^(?:@([^/]+?)[/])?([^/]+?)$");
var exclusionList = [
"node_modules",
"favicon.ico"
];
function validate(name) {
var warnings = [];
var errors2 = [];
if (name === null) {
errors2.push("name cannot be null");
return done2(warnings, errors2);
}
if (name === void 0) {
errors2.push("name cannot be undefined");
return done2(warnings, errors2);
}
if (typeof name !== "string") {
errors2.push("name must be a string");
return done2(warnings, errors2);
}
if (!name.length) {
errors2.push("name length must be greater than zero");
}
if (name.startsWith(".")) {
errors2.push("name cannot start with a period");
}
if (name.startsWith("-")) {
errors2.push("name cannot start with a hyphen");
}
if (name.match(/^_/)) {
errors2.push("name cannot start with an underscore");
}
if (name.trim() !== name) {
errors2.push("name cannot contain leading or trailing spaces");
}
exclusionList.forEach(function(excludedName) {
if (name.toLowerCase() === excludedName) {
errors2.push(excludedName + " is not a valid package name");
}
});
if (builtins.includes(name.toLowerCase())) {
warnings.push(name + " is a core module name");
}
if (name.length > 214) {
warnings.push("name can no longer contain more than 214 characters");
}
if (name.toLowerCase() !== name) {
warnings.push("name can no longer contain capital letters");
}
if (/[~'!()*]/.test(name.split("/").slice(-1)[0])) {
warnings.push(`name can no longer contain special characters ("~'!()*")`);
}
if (encodeURIComponent(name) !== name) {
var nameMatch = name.match(scopedPackagePattern);
if (nameMatch) {
var user = nameMatch[1];
var pkg = nameMatch[2];
if (pkg.startsWith(".")) {
errors2.push("name cannot start with a period");
}
if (encodeURIComponent(user) === user && encodeURIComponent(pkg) === pkg) {
return done2(warnings, errors2);
}
}
errors2.push("name can only contain URL-friendly characters");
}
return done2(warnings, errors2);
}
var done2 = function(warnings, errors2) {
var result = {
validForNewPackages: errors2.length === 0 && warnings.length === 0,
validForOldPackages: errors2.length === 0,
warnings,
errors: errors2
};
if (!result.warnings.length) {
delete result.warnings;
}
if (!result.errors.length) {
delete result.errors;
}
return result;
};
module.exports = validate;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/is-gzip/2.0.0/82a8e17050fa38e95e62aa7580ddf517da43682e2ea1a94728382ef43c644d04/node_modules/is-gzip/index.js
var require_is_gzip = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/is-gzip/2.0.0/82a8e17050fa38e95e62aa7580ddf517da43682e2ea1a94728382ef43c644d04/node_modules/is-gzip/index.js"(exports, module) {
"use strict";
module.exports = (buf) => {
if (!buf || buf.length < 3) {
return false;
}
return buf[0] === 31 && buf[1] === 139 && buf[2] === 8;
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/seek-bzip/2.0.0/52862053d1ae26b7947ddbe152b0409d9ca82b60423653603f7cd9ed70993fc8/node_modules/seek-bzip/lib/bitreader.js
var require_bitreader = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/seek-bzip/2.0.0/52862053d1ae26b7947ddbe152b0409d9ca82b60423653603f7cd9ed70993fc8/node_modules/seek-bzip/lib/bitreader.js"(exports, module) {
var BITMASK = [0, 1, 3, 7, 15, 31, 63, 127, 255];
var BitReader = function(stream) {
this.stream = stream;
this.bitOffset = 0;
this.curByte = 0;
this.hasByte = false;
};
BitReader.prototype._ensureByte = function() {
if (!this.hasByte) {
this.curByte = this.stream.readByte();
this.hasByte = true;
}
};
BitReader.prototype.read = function(bits) {
var result = 0;
while (bits > 0) {
this._ensureByte();
var remaining = 8 - this.bitOffset;
if (bits >= remaining) {
result <<= remaining;
result |= BITMASK[remaining] & this.curByte;
this.hasByte = false;
this.bitOffset = 0;
bits -= remaining;
} else {
result <<= bits;
var shift = remaining - bits;
result |= (this.curByte & BITMASK[bits] << shift) >> shift;
this.bitOffset += bits;
bits = 0;
}
}
return result;
};
BitReader.prototype.seek = function(pos) {
var n_bit = pos % 8;
var n_byte = (pos - n_bit) / 8;
this.bitOffset = n_bit;
this.stream.seek(n_byte);
this.hasByte = false;
};
BitReader.prototype.pi = function() {
var buf = new Buffer(6), i;
for (i = 0; i < buf.length; i++) {
buf[i] = this.read(8);
}
return buf.toString("hex");
};
module.exports = BitReader;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/seek-bzip/2.0.0/52862053d1ae26b7947ddbe152b0409d9ca82b60423653603f7cd9ed70993fc8/node_modules/seek-bzip/lib/stream.js
var require_stream = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/seek-bzip/2.0.0/52862053d1ae26b7947ddbe152b0409d9ca82b60423653603f7cd9ed70993fc8/node_modules/seek-bzip/lib/stream.js"(exports, module) {
var Stream = function() {
};
Stream.prototype.readByte = function() {
throw new Error("abstract method readByte() not implemented");
};
Stream.prototype.read = function(buffer, bufOffset, length) {
var bytesRead = 0;
while (bytesRead < length) {
var c = this.readByte();
if (c < 0) {
return bytesRead === 0 ? -1 : bytesRead;
}
buffer[bufOffset++] = c;
bytesRead++;
}
return bytesRead;
};
Stream.prototype.seek = function(new_pos) {
throw new Error("abstract method seek() not implemented");
};
Stream.prototype.writeByte = function(_byte) {
throw new Error("abstract method readByte() not implemented");
};
Stream.prototype.write = function(buffer, bufOffset, length) {
var i;
for (i = 0; i < length; i++) {
this.writeByte(buffer[bufOffset++]);
}
return length;
};
Stream.prototype.flush = function() {
};
module.exports = Stream;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/seek-bzip/2.0.0/52862053d1ae26b7947ddbe152b0409d9ca82b60423653603f7cd9ed70993fc8/node_modules/seek-bzip/lib/crc32.js
var require_crc32 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/seek-bzip/2.0.0/52862053d1ae26b7947ddbe152b0409d9ca82b60423653603f7cd9ed70993fc8/node_modules/seek-bzip/lib/crc32.js"(exports, module) {
module.exports = (function() {
var crc32Lookup = new Uint32Array([
0,
79764919,
159529838,
222504665,
319059676,
398814059,
445009330,
507990021,
638119352,
583659535,
797628118,
726387553,
890018660,
835552979,
1015980042,
944750013,
1276238704,
1221641927,
1167319070,
1095957929,
1595256236,
1540665371,
1452775106,
1381403509,
1780037320,
1859660671,
1671105958,
1733955601,
2031960084,
2111593891,
1889500026,
1952343757,
2552477408,
2632100695,
2443283854,
2506133561,
2334638140,
2414271883,
2191915858,
2254759653,
3190512472,
3135915759,
3081330742,
3009969537,
2905550212,
2850959411,
2762807018,
2691435357,
3560074640,
3505614887,
3719321342,
3648080713,
3342211916,
3287746299,
3467911202,
3396681109,
4063920168,
4143685023,
4223187782,
4286162673,
3779000052,
3858754371,
3904687514,
3967668269,
881225847,
809987520,
1023691545,
969234094,
662832811,
591600412,
771767749,
717299826,
311336399,
374308984,
453813921,
533576470,
25881363,
88864420,
134795389,
214552010,
2023205639,
2086057648,
1897238633,
1976864222,
1804852699,
1867694188,
1645340341,
1724971778,
1587496639,
1516133128,
1461550545,
1406951526,
1302016099,
1230646740,
1142491917,
1087903418,
2896545431,
2825181984,
2770861561,
2716262478,
3215044683,
3143675388,
3055782693,
3001194130,
2326604591,
2389456536,
2200899649,
2280525302,
2578013683,
2640855108,
2418763421,
2498394922,
3769900519,
3832873040,
3912640137,
3992402750,
4088425275,
4151408268,
4197601365,
4277358050,
3334271071,
3263032808,
3476998961,
3422541446,
3585640067,
3514407732,
3694837229,
3640369242,
1762451694,
1842216281,
1619975040,
1682949687,
2047383090,
2127137669,
1938468188,
2001449195,
1325665622,
1271206113,
1183200824,
1111960463,
1543535498,
1489069629,
1434599652,
1363369299,
622672798,
568075817,
748617968,
677256519,
907627842,
853037301,
1067152940,
995781531,
51762726,
131386257,
177728840,
240578815,
269590778,
349224269,
429104020,
491947555,
4046411278,
4126034873,
4172115296,
4234965207,
3794477266,
3874110821,
3953728444,
4016571915,
3609705398,
3555108353,
3735388376,
3664026991,
3290680682,
3236090077,
3449943556,
3378572211,
3174993278,
3120533705,
3032266256,
2961025959,
2923101090,
2868635157,
2813903052,
2742672763,
2604032198,
2683796849,
2461293480,
2524268063,
2284983834,
2364738477,
2175806836,
2238787779,
1569362073,
1498123566,
1409854455,
1355396672,
1317987909,
1246755826,
1192025387,
1137557660,
2072149281,
2135122070,
1912620623,
1992383480,
1753615357,
1816598090,
1627664531,
1707420964,
295390185,
358241886,
404320391,
483945776,
43990325,
106832002,
186451547,
266083308,
932423249,
861060070,
1041341759,
986742920,
613929101,
542559546,
756411363,
701822548,
3316196985,
3244833742,
3425377559,
3370778784,
3601682597,
3530312978,
3744426955,
3689838204,
3819031489,
3881883254,
3928223919,
4007849240,
4037393693,
4100235434,
4180117107,
4259748804,
2310601993,
2373574846,
2151335527,
2231098320,
2596047829,
2659030626,
2470359227,
2550115596,
2947551409,
2876312838,
2788305887,
2733848168,
3165939309,
3094707162,
3040238851,
2985771188
]);
var CRC32 = function() {
var crc = 4294967295;
this.getCRC = function() {
return ~crc >>> 0;
};
this.updateCRC = function(value) {
crc = crc << 8 ^ crc32Lookup[(crc >>> 24 ^ value) & 255];
};
this.updateCRCRun = function(value, count) {
while (count-- > 0) {
crc = crc << 8 ^ crc32Lookup[(crc >>> 24 ^ value) & 255];
}
};
};
return CRC32;
})();
}
});
// ../../../../../setup-pnpm/store/v11/links/@/seek-bzip/2.0.0/52862053d1ae26b7947ddbe152b0409d9ca82b60423653603f7cd9ed70993fc8/node_modules/seek-bzip/package.json
var require_package = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/seek-bzip/2.0.0/52862053d1ae26b7947ddbe152b0409d9ca82b60423653603f7cd9ed70993fc8/node_modules/seek-bzip/package.json"(exports, module) {
module.exports = {
name: "seek-bzip",
version: "2.0.0",
contributors: [
"C. Scott Ananian (http://cscott.net)",
"Eli Skeggs",
"Kevin Kwok",
"Rob Landley (http://landley.net)"
],
description: "a pure-JavaScript Node.JS module for random-access decoding bzip2 data",
main: "./lib/index.js",
repository: {
type: "git",
url: "https://github.com/cscott/seek-bzip.git"
},
license: "MIT",
bin: {
"seek-bunzip": "./bin/seek-bunzip",
"seek-table": "./bin/seek-bzip-table"
},
directories: {
test: "test"
},
dependencies: {
commander: "^6.0.0"
},
devDependencies: {
fibers: "^5.0.0",
mocha: "^8.1.0"
},
scripts: {
test: "mocha"
}
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/seek-bzip/2.0.0/52862053d1ae26b7947ddbe152b0409d9ca82b60423653603f7cd9ed70993fc8/node_modules/seek-bzip/lib/index.js
var require_lib3 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/seek-bzip/2.0.0/52862053d1ae26b7947ddbe152b0409d9ca82b60423653603f7cd9ed70993fc8/node_modules/seek-bzip/lib/index.js"(exports, module) {
var BitReader = require_bitreader();
var Stream = require_stream();
var CRC32 = require_crc32();
var pjson = require_package();
var MAX_HUFCODE_BITS = 20;
var MAX_SYMBOLS = 258;
var SYMBOL_RUNA = 0;
var SYMBOL_RUNB = 1;
var MIN_GROUPS = 2;
var MAX_GROUPS = 6;
var GROUP_SIZE = 50;
var WHOLEPI = "314159265359";
var SQRTPI = "177245385090";
var mtf = function(array, index) {
var src2 = array[index], i;
for (i = index; i > 0; i--) {
array[i] = array[i - 1];
}
array[0] = src2;
return src2;
};
var Err = {
OK: 0,
LAST_BLOCK: -1,
NOT_BZIP_DATA: -2,
UNEXPECTED_INPUT_EOF: -3,
UNEXPECTED_OUTPUT_EOF: -4,
DATA_ERROR: -5,
OUT_OF_MEMORY: -6,
OBSOLETE_INPUT: -7,
END_OF_BLOCK: -8
};
var ErrorMessages = {};
ErrorMessages[Err.LAST_BLOCK] = "Bad file checksum";
ErrorMessages[Err.NOT_BZIP_DATA] = "Not bzip data";
ErrorMessages[Err.UNEXPECTED_INPUT_EOF] = "Unexpected input EOF";
ErrorMessages[Err.UNEXPECTED_OUTPUT_EOF] = "Unexpected output EOF";
ErrorMessages[Err.DATA_ERROR] = "Data error";
ErrorMessages[Err.OUT_OF_MEMORY] = "Out of memory";
ErrorMessages[Err.OBSOLETE_INPUT] = "Obsolete (pre 0.9.5) bzip format not supported.";
var _throw = function(status, optDetail) {
var msg = ErrorMessages[status] || "unknown error";
if (optDetail) {
msg += ": " + optDetail;
}
var e = new TypeError(msg);
e.errorCode = status;
throw e;
};
var Bunzip3 = function(inputStream, outputStream) {
this.writePos = this.writeCurrent = this.writeCount = 0;
this._start_bunzip(inputStream, outputStream);
};
Bunzip3.prototype._init_block = function() {
var moreBlocks = this._get_next_block();
if (!moreBlocks) {
this.writeCount = -1;
return false;
}
this.blockCRC = new CRC32();
return true;
};
Bunzip3.prototype._start_bunzip = function(inputStream, outputStream) {
var buf = new Buffer(4);
if (inputStream.read(buf, 0, 4) !== 4 || String.fromCharCode(buf[0], buf[1], buf[2]) !== "BZh")
_throw(Err.NOT_BZIP_DATA, "bad magic");
var level = buf[3] - 48;
if (level < 1 || level > 9)
_throw(Err.NOT_BZIP_DATA, "level out of range");
this.reader = new BitReader(inputStream);
this.dbufSize = 1e5 * level;
this.nextoutput = 0;
this.outputStream = outputStream;
this.streamCRC = 0;
};
Bunzip3.prototype._get_next_block = function() {
var i, j, k;
var reader = this.reader;
var h = reader.pi();
if (h === SQRTPI) {
return false;
}
if (h !== WHOLEPI)
_throw(Err.NOT_BZIP_DATA);
this.targetBlockCRC = reader.read(32) >>> 0;
this.streamCRC = (this.targetBlockCRC ^ (this.streamCRC << 1 | this.streamCRC >>> 31)) >>> 0;
if (reader.read(1))
_throw(Err.OBSOLETE_INPUT);
var origPointer = reader.read(24);
if (origPointer > this.dbufSize)
_throw(Err.DATA_ERROR, "initial position out of bounds");
var t = reader.read(16);
var symToByte = new Buffer(256), symTotal = 0;
for (i = 0; i < 16; i++) {
if (t & 1 << 15 - i) {
var o = i * 16;
k = reader.read(16);
for (j = 0; j < 16; j++)
if (k & 1 << 15 - j)
symToByte[symTotal++] = o + j;
}
}
var groupCount = reader.read(3);
if (groupCount < MIN_GROUPS || groupCount > MAX_GROUPS)
_throw(Err.DATA_ERROR);
var nSelectors = reader.read(15);
if (nSelectors === 0)
_throw(Err.DATA_ERROR);
var mtfSymbol = new Buffer(256);
for (i = 0; i < groupCount; i++)
mtfSymbol[i] = i;
var selectors = new Buffer(nSelectors);
for (i = 0; i < nSelectors; i++) {
for (j = 0; reader.read(1); j++)
if (j >= groupCount) _throw(Err.DATA_ERROR);
selectors[i] = mtf(mtfSymbol, j);
}
var symCount = symTotal + 2;
var groups = [], hufGroup;
for (j = 0; j < groupCount; j++) {
var length = new Buffer(symCount), temp = new Uint16Array(MAX_HUFCODE_BITS + 1);
t = reader.read(5);
for (i = 0; i < symCount; i++) {
for (; ; ) {
if (t < 1 || t > MAX_HUFCODE_BITS) _throw(Err.DATA_ERROR);
if (!reader.read(1))
break;
if (!reader.read(1))
t++;
else
t--;
}
length[i] = t;
}
var minLen, maxLen;
minLen = maxLen = length[0];
for (i = 1; i < symCount; i++) {
if (length[i] > maxLen)
maxLen = length[i];
else if (length[i] < minLen)
minLen = length[i];
}
hufGroup = {};
groups.push(hufGroup);
hufGroup.permute = new Uint16Array(MAX_SYMBOLS);
hufGroup.limit = new Uint32Array(MAX_HUFCODE_BITS + 2);
hufGroup.base = new Uint32Array(MAX_HUFCODE_BITS + 1);
hufGroup.minLen = minLen;
hufGroup.maxLen = maxLen;
var pp = 0;
for (i = minLen; i <= maxLen; i++) {
temp[i] = hufGroup.limit[i] = 0;
for (t = 0; t < symCount; t++)
if (length[t] === i)
hufGroup.permute[pp++] = t;
}
for (i = 0; i < symCount; i++)
temp[length[i]]++;
pp = t = 0;
for (i = minLen; i < maxLen; i++) {
pp += temp[i];
hufGroup.limit[i] = pp - 1;
pp <<= 1;
t += temp[i];
hufGroup.base[i + 1] = pp - t;
}
hufGroup.limit[maxLen + 1] = Number.MAX_VALUE;
hufGroup.limit[maxLen] = pp + temp[maxLen] - 1;
hufGroup.base[minLen] = 0;
}
var byteCount = new Uint32Array(256);
for (i = 0; i < 256; i++)
mtfSymbol[i] = i;
var runPos = 0, dbufCount = 0, selector = 0, uc;
var dbuf = this.dbuf = new Uint32Array(this.dbufSize);
symCount = 0;
for (; ; ) {
if (!symCount--) {
symCount = GROUP_SIZE - 1;
if (selector >= nSelectors) {
_throw(Err.DATA_ERROR);
}
hufGroup = groups[selectors[selector++]];
}
i = hufGroup.minLen;
j = reader.read(i);
for (; ; i++) {
if (i > hufGroup.maxLen) {
_throw(Err.DATA_ERROR);
}
if (j <= hufGroup.limit[i])
break;
j = j << 1 | reader.read(1);
}
j -= hufGroup.base[i];
if (j < 0 || j >= MAX_SYMBOLS) {
_throw(Err.DATA_ERROR);
}
var nextSym = hufGroup.permute[j];
if (nextSym === SYMBOL_RUNA || nextSym === SYMBOL_RUNB) {
if (!runPos) {
runPos = 1;
t = 0;
}
if (nextSym === SYMBOL_RUNA)
t += runPos;
else
t += 2 * runPos;
runPos <<= 1;
continue;
}
if (runPos) {
runPos = 0;
if (dbufCount + t > this.dbufSize) {
_throw(Err.DATA_ERROR);
}
uc = symToByte[mtfSymbol[0]];
byteCount[uc] += t;
while (t--)
dbuf[dbufCount++] = uc;
}
if (nextSym > symTotal)
break;
if (dbufCount >= this.dbufSize) {
_throw(Err.DATA_ERROR);
}
i = nextSym - 1;
uc = mtf(mtfSymbol, i);
uc = symToByte[uc];
byteCount[uc]++;
dbuf[dbufCount++] = uc;
}
if (origPointer < 0 || origPointer >= dbufCount) {
_throw(Err.DATA_ERROR);
}
j = 0;
for (i = 0; i < 256; i++) {
k = j + byteCount[i];
byteCount[i] = j;
j = k;
}
for (i = 0; i < dbufCount; i++) {
uc = dbuf[i] & 255;
dbuf[byteCount[uc]] |= i << 8;
byteCount[uc]++;
}
var pos = 0, current = 0, run = 0;
if (dbufCount) {
pos = dbuf[origPointer];
current = pos & 255;
pos >>= 8;
run = -1;
}
this.writePos = pos;
this.writeCurrent = current;
this.writeCount = dbufCount;
this.writeRun = run;
return true;
};
Bunzip3.prototype._read_bunzip = function(outputBuffer, len) {
var copies, previous, outbyte;
if (this.writeCount < 0) {
return 0;
}
var gotcount = 0;
var dbuf = this.dbuf, pos = this.writePos, current = this.writeCurrent;
var dbufCount = this.writeCount, outputsize = this.outputsize;
var run = this.writeRun;
while (dbufCount) {
dbufCount--;
previous = current;
pos = dbuf[pos];
current = pos & 255;
pos >>= 8;
if (run++ === 3) {
copies = current;
outbyte = previous;
current = -1;
} else {
copies = 1;
outbyte = current;
}
this.blockCRC.updateCRCRun(outbyte, copies);
while (copies--) {
this.outputStream.writeByte(outbyte);
this.nextoutput++;
}
if (current != previous)
run = 0;
}
this.writeCount = dbufCount;
if (this.blockCRC.getCRC() !== this.targetBlockCRC) {
_throw(Err.DATA_ERROR, "Bad block CRC (got " + this.blockCRC.getCRC().toString(16) + " expected " + this.targetBlockCRC.toString(16) + ")");
}
return this.nextoutput;
};
var coerceInputStream = function(input) {
if ("readByte" in input) {
return input;
}
var inputStream = new Stream();
inputStream.pos = 0;
inputStream.readByte = function() {
return input[this.pos++];
};
inputStream.seek = function(pos) {
this.pos = pos;
};
inputStream.eof = function() {
return this.pos >= input.length;
};
return inputStream;
};
var coerceOutputStream = function(output) {
var outputStream = new Stream();
var resizeOk = true;
if (output) {
if (typeof output === "number") {
outputStream.buffer = new Buffer(output);
resizeOk = false;
} else if ("writeByte" in output) {
return output;
} else {
outputStream.buffer = output;
resizeOk = false;
}
} else {
outputStream.buffer = new Buffer(16384);
}
outputStream.pos = 0;
outputStream.writeByte = function(_byte) {
if (resizeOk && this.pos >= this.buffer.length) {
var newBuffer = new Buffer(this.buffer.length * 2);
this.buffer.copy(newBuffer);
this.buffer = newBuffer;
}
this.buffer[this.pos++] = _byte;
};
outputStream.getBuffer = function() {
if (this.pos !== this.buffer.length) {
if (!resizeOk)
throw new TypeError("outputsize does not match decoded input");
var newBuffer = new Buffer(this.pos);
this.buffer.copy(newBuffer, 0, 0, this.pos);
this.buffer = newBuffer;
}
return this.buffer;
};
outputStream._coerced = true;
return outputStream;
};
Bunzip3.Err = Err;
Bunzip3.decode = function(input, output, multistream) {
var inputStream = coerceInputStream(input);
var outputStream = coerceOutputStream(output);
var bz = new Bunzip3(inputStream, outputStream);
while (true) {
if ("eof" in inputStream && inputStream.eof()) break;
if (bz._init_block()) {
bz._read_bunzip();
} else {
var targetStreamCRC = bz.reader.read(32) >>> 0;
if (targetStreamCRC !== bz.streamCRC) {
_throw(Err.DATA_ERROR, "Bad stream CRC (got " + bz.streamCRC.toString(16) + " expected " + targetStreamCRC.toString(16) + ")");
}
if (multistream && "eof" in inputStream && !inputStream.eof()) {
bz._start_bunzip(inputStream, outputStream);
} else break;
}
}
if ("getBuffer" in outputStream)
return outputStream.getBuffer();
};
Bunzip3.decodeBlock = function(input, pos, output) {
var inputStream = coerceInputStream(input);
var outputStream = coerceOutputStream(output);
var bz = new Bunzip3(inputStream, outputStream);
bz.reader.seek(pos);
var moreBlocks = bz._get_next_block();
if (moreBlocks) {
bz.blockCRC = new CRC32();
bz.writeCopies = 0;
bz._read_bunzip();
}
if ("getBuffer" in outputStream)
return outputStream.getBuffer();
};
Bunzip3.table = function(input, callback, multistream) {
var inputStream = new Stream();
inputStream.delegate = coerceInputStream(input);
inputStream.pos = 0;
inputStream.readByte = function() {
this.pos++;
return this.delegate.readByte();
};
if (inputStream.delegate.eof) {
inputStream.eof = inputStream.delegate.eof.bind(inputStream.delegate);
}
var outputStream = new Stream();
outputStream.pos = 0;
outputStream.writeByte = function() {
this.pos++;
};
var bz = new Bunzip3(inputStream, outputStream);
var blockSize = bz.dbufSize;
while (true) {
if ("eof" in inputStream && inputStream.eof()) break;
var position3 = inputStream.pos * 8 + bz.reader.bitOffset;
if (bz.reader.hasByte) {
position3 -= 8;
}
if (bz._init_block()) {
var start = outputStream.pos;
bz._read_bunzip();
callback(position3, outputStream.pos - start);
} else {
var crc = bz.reader.read(32);
if (multistream && "eof" in inputStream && !inputStream.eof()) {
bz._start_bunzip(inputStream, outputStream);
console.assert(
bz.dbufSize === blockSize,
"shouldn't change block size within multistream file"
);
} else break;
}
}
};
Bunzip3.Stream = Stream;
Bunzip3.version = pjson.version;
Bunzip3.license = pjson.license;
module.exports = Bunzip3;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/internal/constants.js
var require_constants = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/internal/constants.js"(exports, module) {
"use strict";
var SEMVER_SPEC_VERSION = "2.0.0";
var MAX_LENGTH = 256;
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
9007199254740991;
var MAX_SAFE_COMPONENT_LENGTH = 16;
var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
var RELEASE_TYPES = [
"major",
"premajor",
"minor",
"preminor",
"patch",
"prepatch",
"prerelease"
];
module.exports = {
MAX_LENGTH,
MAX_SAFE_COMPONENT_LENGTH,
MAX_SAFE_BUILD_LENGTH,
MAX_SAFE_INTEGER,
RELEASE_TYPES,
SEMVER_SPEC_VERSION,
FLAG_INCLUDE_PRERELEASE: 1,
FLAG_LOOSE: 2
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/internal/debug.js
var require_debug = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/internal/debug.js"(exports, module) {
"use strict";
var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
};
module.exports = debug;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/internal/re.js
var require_re = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/internal/re.js"(exports, module) {
"use strict";
var {
MAX_SAFE_COMPONENT_LENGTH,
MAX_SAFE_BUILD_LENGTH,
MAX_LENGTH
} = require_constants();
var debug = require_debug();
exports = module.exports = {};
var re = exports.re = [];
var safeRe = exports.safeRe = [];
var src2 = exports.src = [];
var safeSrc = exports.safeSrc = [];
var t = exports.t = {};
var R = 0;
var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
var safeRegexReplacements = [
["\\s", 1],
["\\d", MAX_LENGTH],
[LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
];
var makeSafeRegex = (value) => {
for (const [token, max] of safeRegexReplacements) {
value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
}
return value;
};
var createToken = (name, value, isGlobal) => {
const safe = makeSafeRegex(value);
const index = R++;
debug(name, index, value);
t[name] = index;
src2[index] = value;
safeSrc[index] = safe;
re[index] = new RegExp(value, isGlobal ? "g" : void 0);
safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
};
createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
createToken("MAINVERSION", `(${src2[t.NUMERICIDENTIFIER]})\\.(${src2[t.NUMERICIDENTIFIER]})\\.(${src2[t.NUMERICIDENTIFIER]})`);
createToken("MAINVERSIONLOOSE", `(${src2[t.NUMERICIDENTIFIERLOOSE]})\\.(${src2[t.NUMERICIDENTIFIERLOOSE]})\\.(${src2[t.NUMERICIDENTIFIERLOOSE]})`);
createToken("PRERELEASEIDENTIFIER", `(?:${src2[t.NONNUMERICIDENTIFIER]}|${src2[t.NUMERICIDENTIFIER]})`);
createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src2[t.NONNUMERICIDENTIFIER]}|${src2[t.NUMERICIDENTIFIERLOOSE]})`);
createToken("PRERELEASE", `(?:-(${src2[t.PRERELEASEIDENTIFIER]}(?:\\.${src2[t.PRERELEASEIDENTIFIER]})*))`);
createToken("PRERELEASELOOSE", `(?:-?(${src2[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src2[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
createToken("BUILD", `(?:\\+(${src2[t.BUILDIDENTIFIER]}(?:\\.${src2[t.BUILDIDENTIFIER]})*))`);
createToken("FULLPLAIN", `v?${src2[t.MAINVERSION]}${src2[t.PRERELEASE]}?${src2[t.BUILD]}?`);
createToken("FULL", `^${src2[t.FULLPLAIN]}$`);
createToken("LOOSEPLAIN", `[v=\\s]*${src2[t.MAINVERSIONLOOSE]}${src2[t.PRERELEASELOOSE]}?${src2[t.BUILD]}?`);
createToken("LOOSE", `^${src2[t.LOOSEPLAIN]}$`);
createToken("GTLT", "((?:<|>)?=?)");
createToken("XRANGEIDENTIFIERLOOSE", `${src2[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
createToken("XRANGEIDENTIFIER", `${src2[t.NUMERICIDENTIFIER]}|x|X|\\*`);
createToken("XRANGEPLAIN", `[v=\\s]*(${src2[t.XRANGEIDENTIFIER]})(?:\\.(${src2[t.XRANGEIDENTIFIER]})(?:\\.(${src2[t.XRANGEIDENTIFIER]})(?:${src2[t.PRERELEASE]})?${src2[t.BUILD]}?)?)?`);
createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src2[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src2[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src2[t.XRANGEIDENTIFIERLOOSE]})(?:${src2[t.PRERELEASELOOSE]})?${src2[t.BUILD]}?)?)?`);
createToken("XRANGE", `^${src2[t.GTLT]}\\s*${src2[t.XRANGEPLAIN]}$`);
createToken("XRANGELOOSE", `^${src2[t.GTLT]}\\s*${src2[t.XRANGEPLAINLOOSE]}$`);
createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
createToken("COERCE", `${src2[t.COERCEPLAIN]}(?:$|[^\\d])`);
createToken("COERCEFULL", src2[t.COERCEPLAIN] + `(?:${src2[t.PRERELEASE]})?(?:${src2[t.BUILD]})?(?:$|[^\\d])`);
createToken("COERCERTL", src2[t.COERCE], true);
createToken("COERCERTLFULL", src2[t.COERCEFULL], true);
createToken("LONETILDE", "(?:~>?)");
createToken("TILDETRIM", `(\\s*)${src2[t.LONETILDE]}\\s+`, true);
exports.tildeTrimReplace = "$1~";
createToken("TILDE", `^${src2[t.LONETILDE]}${src2[t.XRANGEPLAIN]}$`);
createToken("TILDELOOSE", `^${src2[t.LONETILDE]}${src2[t.XRANGEPLAINLOOSE]}$`);
createToken("LONECARET", "(?:\\^)");
createToken("CARETTRIM", `(\\s*)${src2[t.LONECARET]}\\s+`, true);
exports.caretTrimReplace = "$1^";
createToken("CARET", `^${src2[t.LONECARET]}${src2[t.XRANGEPLAIN]}$`);
createToken("CARETLOOSE", `^${src2[t.LONECARET]}${src2[t.XRANGEPLAINLOOSE]}$`);
createToken("COMPARATORLOOSE", `^${src2[t.GTLT]}\\s*(${src2[t.LOOSEPLAIN]})$|^$`);
createToken("COMPARATOR", `^${src2[t.GTLT]}\\s*(${src2[t.FULLPLAIN]})$|^$`);
createToken("COMPARATORTRIM", `(\\s*)${src2[t.GTLT]}\\s*(${src2[t.LOOSEPLAIN]}|${src2[t.XRANGEPLAIN]})`, true);
exports.comparatorTrimReplace = "$1$2$3";
createToken("HYPHENRANGE", `^\\s*(${src2[t.XRANGEPLAIN]})\\s+-\\s+(${src2[t.XRANGEPLAIN]})\\s*$`);
createToken("HYPHENRANGELOOSE", `^\\s*(${src2[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src2[t.XRANGEPLAINLOOSE]})\\s*$`);
createToken("STAR", "(<|>)?=?\\s*\\*");
createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/internal/parse-options.js
var require_parse_options = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/internal/parse-options.js"(exports, module) {
"use strict";
var looseOption = Object.freeze({ loose: true });
var emptyOpts = Object.freeze({});
var parseOptions = (options) => {
if (!options) {
return emptyOpts;
}
if (typeof options !== "object") {
return looseOption;
}
return options;
};
module.exports = parseOptions;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/internal/identifiers.js
var require_identifiers = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/internal/identifiers.js"(exports, module) {
"use strict";
var numeric = /^[0-9]+$/;
var compareIdentifiers = (a, b) => {
if (typeof a === "number" && typeof b === "number") {
return a === b ? 0 : a < b ? -1 : 1;
}
const anum = numeric.test(a);
const bnum = numeric.test(b);
if (anum && bnum) {
a = +a;
b = +b;
}
return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
};
var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
module.exports = {
compareIdentifiers,
rcompareIdentifiers
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/classes/semver.js
var require_semver = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/classes/semver.js"(exports, module) {
"use strict";
var debug = require_debug();
var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
var { safeRe: re, t } = require_re();
var parseOptions = require_parse_options();
var { compareIdentifiers } = require_identifiers();
var isPrereleaseIdentifier = (prerelease, identifier) => {
const identifiers = identifier.split(".");
if (identifiers.length > prerelease.length) {
return false;
}
for (let i = 0; i < identifiers.length; i++) {
if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) {
return false;
}
}
return true;
};
var SemVer = class _SemVer {
constructor(version, options) {
options = parseOptions(options);
if (version instanceof _SemVer) {
if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
return version;
} else {
version = version.version;
}
} else if (typeof version !== "string") {
throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
}
if (version.length > MAX_LENGTH) {
throw new TypeError(
`version is longer than ${MAX_LENGTH} characters`
);
}
debug("SemVer", version, options);
this.options = options;
this.loose = !!options.loose;
this.includePrerelease = !!options.includePrerelease;
const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.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((id) => {
if (/^[0-9]+$/.test(id)) {
const num = +id;
if (num >= 0 && num < MAX_SAFE_INTEGER) {
return num;
}
}
return id;
});
}
this.build = m[5] ? m[5].split(".") : [];
this.format();
}
format() {
this.version = `${this.major}.${this.minor}.${this.patch}`;
if (this.prerelease.length) {
this.version += `-${this.prerelease.join(".")}`;
}
return this.version;
}
toString() {
return this.version;
}
compare(other) {
debug("SemVer.compare", this.version, this.options, other);
if (!(other instanceof _SemVer)) {
if (typeof other === "string" && other === this.version) {
return 0;
}
other = new _SemVer(other, this.options);
}
if (other.version === this.version) {
return 0;
}
return this.compareMain(other) || this.comparePre(other);
}
compareMain(other) {
if (!(other instanceof _SemVer)) {
other = new _SemVer(other, this.options);
}
if (this.major < other.major) {
return -1;
}
if (this.major > other.major) {
return 1;
}
if (this.minor < other.minor) {
return -1;
}
if (this.minor > other.minor) {
return 1;
}
if (this.patch < other.patch) {
return -1;
}
if (this.patch > other.patch) {
return 1;
}
return 0;
}
comparePre(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;
}
let i = 0;
do {
const a = this.prerelease[i];
const b = other.prerelease[i];
debug("prerelease compare", i, a, b);
if (a === void 0 && b === void 0) {
return 0;
} else if (b === void 0) {
return 1;
} else if (a === void 0) {
return -1;
} else if (a === b) {
continue;
} else {
return compareIdentifiers(a, b);
}
} while (++i);
}
compareBuild(other) {
if (!(other instanceof _SemVer)) {
other = new _SemVer(other, this.options);
}
let i = 0;
do {
const a = this.build[i];
const b = other.build[i];
debug("build compare", i, a, b);
if (a === void 0 && b === void 0) {
return 0;
} else if (b === void 0) {
return 1;
} else if (a === void 0) {
return -1;
} else if (a === b) {
continue;
} else {
return compareIdentifiers(a, b);
}
} while (++i);
}
// preminor will bump the version up to the next minor release, and immediately
// down to pre-release. premajor and prepatch work the same way.
inc(release, identifier, identifierBase) {
if (release.startsWith("pre")) {
if (!identifier && identifierBase === false) {
throw new Error("invalid increment argument: identifier is empty");
}
if (identifier) {
const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
if (!match || match[1] !== identifier) {
throw new Error(`invalid identifier: ${identifier}`);
}
}
}
switch (release) {
case "premajor":
this.prerelease.length = 0;
this.patch = 0;
this.minor = 0;
this.major++;
this.inc("pre", identifier, identifierBase);
break;
case "preminor":
this.prerelease.length = 0;
this.patch = 0;
this.minor++;
this.inc("pre", identifier, identifierBase);
break;
case "prepatch":
this.prerelease.length = 0;
this.inc("patch", identifier, identifierBase);
this.inc("pre", identifier, identifierBase);
break;
// If the input is a non-prerelease version, this acts the same as
// prepatch.
case "prerelease":
if (this.prerelease.length === 0) {
this.inc("patch", identifier, identifierBase);
}
this.inc("pre", identifier, identifierBase);
break;
case "release":
if (this.prerelease.length === 0) {
throw new Error(`version ${this.raw} is not a prerelease`);
}
this.prerelease.length = 0;
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;
// This probably shouldn't be used publicly.
// 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
case "pre": {
const base = Number(identifierBase) ? 1 : 0;
if (this.prerelease.length === 0) {
this.prerelease = [base];
} else {
let i = this.prerelease.length;
while (--i >= 0) {
if (typeof this.prerelease[i] === "number") {
this.prerelease[i]++;
i = -2;
}
}
if (i === -1) {
if (identifier === this.prerelease.join(".") && identifierBase === false) {
throw new Error("invalid increment argument: identifier already exists");
}
this.prerelease.push(base);
}
}
if (identifier) {
let prerelease = [identifier, base];
if (identifierBase === false) {
prerelease = [identifier];
}
if (isPrereleaseIdentifier(this.prerelease, identifier)) {
const prereleaseBase = this.prerelease[identifier.split(".").length];
if (isNaN(prereleaseBase)) {
this.prerelease = prerelease;
}
} else {
this.prerelease = prerelease;
}
}
break;
}
default:
throw new Error(`invalid increment argument: ${release}`);
}
this.raw = this.format();
if (this.build.length) {
this.raw += `+${this.build.join(".")}`;
}
return this;
}
};
module.exports = SemVer;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/parse.js
var require_parse = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/parse.js"(exports, module) {
"use strict";
var SemVer = require_semver();
var parse2 = (version, options, throwErrors = false) => {
if (version instanceof SemVer) {
return version;
}
try {
return new SemVer(version, options);
} catch (er) {
if (!throwErrors) {
return null;
}
throw er;
}
};
module.exports = parse2;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/valid.js
var require_valid = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/valid.js"(exports, module) {
"use strict";
var parse2 = require_parse();
var valid = (version, options) => {
const v = parse2(version, options);
return v ? v.version : null;
};
module.exports = valid;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/clean.js
var require_clean = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/clean.js"(exports, module) {
"use strict";
var parse2 = require_parse();
var clean = (version, options) => {
const s = parse2(version.trim().replace(/^[=v]+/, ""), options);
return s ? s.version : null;
};
module.exports = clean;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/inc.js
var require_inc = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/inc.js"(exports, module) {
"use strict";
var SemVer = require_semver();
var inc = (version, release, options, identifier, identifierBase) => {
if (typeof options === "string") {
identifierBase = identifier;
identifier = options;
options = void 0;
}
try {
return new SemVer(
version instanceof SemVer ? version.version : version,
options
).inc(release, identifier, identifierBase).version;
} catch (er) {
return null;
}
};
module.exports = inc;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/diff.js
var require_diff = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/diff.js"(exports, module) {
"use strict";
var parse2 = require_parse();
var diff = (version1, version2) => {
const v1 = parse2(version1, null, true);
const v2 = parse2(version2, null, true);
const comparison = v1.compare(v2);
if (comparison === 0) {
return null;
}
const v1Higher = comparison > 0;
const highVersion = v1Higher ? v1 : v2;
const lowVersion = v1Higher ? v2 : v1;
const highHasPre = !!highVersion.prerelease.length;
const lowHasPre = !!lowVersion.prerelease.length;
if (lowHasPre && !highHasPre) {
if (!lowVersion.patch && !lowVersion.minor) {
return "major";
}
if (lowVersion.compareMain(highVersion) === 0) {
if (lowVersion.minor && !lowVersion.patch) {
return "minor";
}
return "patch";
}
}
const prefix = highHasPre ? "pre" : "";
if (v1.major !== v2.major) {
return prefix + "major";
}
if (v1.minor !== v2.minor) {
return prefix + "minor";
}
if (v1.patch !== v2.patch) {
return prefix + "patch";
}
return "prerelease";
};
module.exports = diff;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/major.js
var require_major = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/major.js"(exports, module) {
"use strict";
var SemVer = require_semver();
var major = (a, loose) => new SemVer(a, loose).major;
module.exports = major;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/minor.js
var require_minor = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/minor.js"(exports, module) {
"use strict";
var SemVer = require_semver();
var minor = (a, loose) => new SemVer(a, loose).minor;
module.exports = minor;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/patch.js
var require_patch = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/patch.js"(exports, module) {
"use strict";
var SemVer = require_semver();
var patch = (a, loose) => new SemVer(a, loose).patch;
module.exports = patch;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/prerelease.js
var require_prerelease = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/prerelease.js"(exports, module) {
"use strict";
var parse2 = require_parse();
var prerelease = (version, options) => {
const parsed = parse2(version, options);
return parsed && parsed.prerelease.length ? parsed.prerelease : null;
};
module.exports = prerelease;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/compare.js
var require_compare = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/compare.js"(exports, module) {
"use strict";
var SemVer = require_semver();
var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
module.exports = compare;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/rcompare.js
var require_rcompare = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/rcompare.js"(exports, module) {
"use strict";
var compare = require_compare();
var rcompare = (a, b, loose) => compare(b, a, loose);
module.exports = rcompare;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/compare-loose.js
var require_compare_loose = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/compare-loose.js"(exports, module) {
"use strict";
var compare = require_compare();
var compareLoose = (a, b) => compare(a, b, true);
module.exports = compareLoose;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/compare-build.js
var require_compare_build = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/compare-build.js"(exports, module) {
"use strict";
var SemVer = require_semver();
var compareBuild = (a, b, loose) => {
const versionA = new SemVer(a, loose);
const versionB = new SemVer(b, loose);
return versionA.compare(versionB) || versionA.compareBuild(versionB);
};
module.exports = compareBuild;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/sort.js
var require_sort = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/sort.js"(exports, module) {
"use strict";
var compareBuild = require_compare_build();
var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
module.exports = sort;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/rsort.js
var require_rsort = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/rsort.js"(exports, module) {
"use strict";
var compareBuild = require_compare_build();
var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
module.exports = rsort;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/gt.js
var require_gt = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/gt.js"(exports, module) {
"use strict";
var compare = require_compare();
var gt = (a, b, loose) => compare(a, b, loose) > 0;
module.exports = gt;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/lt.js
var require_lt = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/lt.js"(exports, module) {
"use strict";
var compare = require_compare();
var lt = (a, b, loose) => compare(a, b, loose) < 0;
module.exports = lt;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/eq.js
var require_eq = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/eq.js"(exports, module) {
"use strict";
var compare = require_compare();
var eq = (a, b, loose) => compare(a, b, loose) === 0;
module.exports = eq;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/neq.js
var require_neq = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/neq.js"(exports, module) {
"use strict";
var compare = require_compare();
var neq = (a, b, loose) => compare(a, b, loose) !== 0;
module.exports = neq;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/gte.js
var require_gte = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/gte.js"(exports, module) {
"use strict";
var compare = require_compare();
var gte = (a, b, loose) => compare(a, b, loose) >= 0;
module.exports = gte;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/lte.js
var require_lte = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/lte.js"(exports, module) {
"use strict";
var compare = require_compare();
var lte = (a, b, loose) => compare(a, b, loose) <= 0;
module.exports = lte;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/cmp.js
var require_cmp = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/cmp.js"(exports, module) {
"use strict";
var eq = require_eq();
var neq = require_neq();
var gt = require_gt();
var gte = require_gte();
var lt = require_lt();
var lte = require_lte();
var cmp = (a, op, b, loose) => {
switch (op) {
case "===":
if (typeof a === "object") {
a = a.version;
}
if (typeof b === "object") {
b = b.version;
}
return a === b;
case "!==":
if (typeof a === "object") {
a = a.version;
}
if (typeof b === "object") {
b = b.version;
}
return a !== b;
case "":
case "=":
case "==":
return eq(a, b, loose);
case "!=":
return neq(a, b, loose);
case ">":
return gt(a, b, loose);
case ">=":
return gte(a, b, loose);
case "<":
return lt(a, b, loose);
case "<=":
return lte(a, b, loose);
default:
throw new TypeError(`Invalid operator: ${op}`);
}
};
module.exports = cmp;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/coerce.js
var require_coerce = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/coerce.js"(exports, module) {
"use strict";
var SemVer = require_semver();
var parse2 = require_parse();
var { safeRe: re, t } = require_re();
var coerce = (version, options) => {
if (version instanceof SemVer) {
return version;
}
if (typeof version === "number") {
version = String(version);
}
if (typeof version !== "string") {
return null;
}
options = options || {};
let match = null;
if (!options.rtl) {
match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
} else {
const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
let next;
while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
if (!match || next.index + next[0].length !== match.index + match[0].length) {
match = next;
}
coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
}
coerceRtlRegex.lastIndex = -1;
}
if (match === null) {
return null;
}
const major = match[2];
const minor = match[3] || "0";
const patch = match[4] || "0";
const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
return parse2(`${major}.${minor}.${patch}${prerelease}${build}`, options);
};
module.exports = coerce;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/truncate.js
var require_truncate = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/truncate.js"(exports, module) {
"use strict";
var parse2 = require_parse();
var constants2 = require_constants();
var SemVer = require_semver();
var truncate = (version, truncation, options) => {
if (!constants2.RELEASE_TYPES.includes(truncation)) {
return null;
}
const clonedVersion = cloneInputVersion(version, options);
return clonedVersion && doTruncation(clonedVersion, truncation);
};
var cloneInputVersion = (version, options) => {
const versionStringToParse = version instanceof SemVer ? version.version : version;
return parse2(versionStringToParse, options);
};
var doTruncation = (version, truncation) => {
if (isPrerelease(truncation)) {
return version.version;
}
version.prerelease = [];
switch (truncation) {
case "major":
version.minor = 0;
version.patch = 0;
break;
case "minor":
version.patch = 0;
break;
}
return version.format();
};
var isPrerelease = (type) => {
return type.startsWith("pre");
};
module.exports = truncate;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/internal/lrucache.js
var require_lrucache = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/internal/lrucache.js"(exports, module) {
"use strict";
var LRUCache = class {
constructor() {
this.max = 1e3;
this.map = /* @__PURE__ */ new Map();
}
get(key) {
const value = this.map.get(key);
if (value === void 0) {
return void 0;
} else {
this.map.delete(key);
this.map.set(key, value);
return value;
}
}
delete(key) {
return this.map.delete(key);
}
set(key, value) {
const deleted = this.delete(key);
if (!deleted && value !== void 0) {
if (this.map.size >= this.max) {
const firstKey = this.map.keys().next().value;
this.delete(firstKey);
}
this.map.set(key, value);
}
return this;
}
};
module.exports = LRUCache;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/classes/range.js
var require_range = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/classes/range.js"(exports, module) {
"use strict";
var SPACE_CHARACTERS = /\s+/g;
var Range = class _Range {
constructor(range, options) {
options = parseOptions(options);
if (range instanceof _Range) {
if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
return range;
} else {
return new _Range(range.raw, options);
}
}
if (range instanceof Comparator) {
this.raw = range.value;
this.set = [[range]];
this.formatted = void 0;
return this;
}
this.options = options;
this.loose = !!options.loose;
this.includePrerelease = !!options.includePrerelease;
this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
if (!this.set.length) {
throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
}
if (this.set.length > 1) {
const first = this.set[0];
this.set = this.set.filter((c) => !isNullSet(c[0]));
if (this.set.length === 0) {
this.set = [first];
} else if (this.set.length > 1) {
for (const c of this.set) {
if (c.length === 1 && isAny(c[0])) {
this.set = [c];
break;
}
}
}
}
this.formatted = void 0;
}
get range() {
if (this.formatted === void 0) {
this.formatted = "";
for (let i = 0; i < this.set.length; i++) {
if (i > 0) {
this.formatted += "||";
}
const comps = this.set[i];
for (let k = 0; k < comps.length; k++) {
if (k > 0) {
this.formatted += " ";
}
this.formatted += comps[k].toString().trim();
}
}
}
return this.formatted;
}
format() {
return this.range;
}
toString() {
return this.range;
}
parseRange(range) {
range = range.replace(BUILDSTRIPRE, "");
const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
const memoKey = memoOpts + ":" + range;
const cached = cache.get(memoKey);
if (cached) {
return cached;
}
const loose = this.options.loose;
const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
debug("hyphen replace", range);
range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
debug("comparator trim", range);
range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
debug("tilde trim", range);
range = range.replace(re[t.CARETTRIM], caretTrimReplace);
debug("caret trim", range);
let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
if (loose) {
rangeList = rangeList.filter((comp) => {
debug("loose invalid filter", comp, this.options);
return !!comp.match(re[t.COMPARATORLOOSE]);
});
}
debug("range list", rangeList);
const rangeMap = /* @__PURE__ */ new Map();
const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
for (const comp of comparators) {
if (isNullSet(comp)) {
return [comp];
}
rangeMap.set(comp.value, comp);
}
if (rangeMap.size > 1 && rangeMap.has("")) {
rangeMap.delete("");
}
const result = [...rangeMap.values()];
cache.set(memoKey, result);
return result;
}
intersects(range, options) {
if (!(range instanceof _Range)) {
throw new TypeError("a Range is required");
}
return this.set.some((thisComparators) => {
return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
return rangeComparators.every((rangeComparator) => {
return thisComparator.intersects(rangeComparator, options);
});
});
});
});
}
// if ANY of the sets match ALL of its comparators, then pass
test(version) {
if (!version) {
return false;
}
if (typeof version === "string") {
try {
version = new SemVer(version, this.options);
} catch (er) {
return false;
}
}
for (let i = 0; i < this.set.length; i++) {
if (testSet(this.set[i], version, this.options)) {
return true;
}
}
return false;
}
};
module.exports = Range;
var LRU = require_lrucache();
var cache = new LRU();
var parseOptions = require_parse_options();
var Comparator = require_comparator();
var debug = require_debug();
var SemVer = require_semver();
var {
safeRe: re,
src: src2,
t,
comparatorTrimReplace,
tildeTrimReplace,
caretTrimReplace
} = require_re();
var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
var BUILDSTRIPRE = new RegExp(src2[t.BUILD], "g");
var isNullSet = (c) => c.value === "<0.0.0-0";
var isAny = (c) => c.value === "";
var isSatisfiable = (comparators, options) => {
let result = true;
const remainingComparators = comparators.slice();
let testComparator = remainingComparators.pop();
while (result && remainingComparators.length) {
result = remainingComparators.every((otherComparator) => {
return testComparator.intersects(otherComparator, options);
});
testComparator = remainingComparators.pop();
}
return result;
};
var parseComparator = (comp, options) => {
comp = comp.replace(re[t.BUILD], "");
debug("comp", comp, options);
comp = replaceCarets(comp, options);
debug("caret", comp);
comp = replaceTildes(comp, options);
debug("tildes", comp);
comp = replaceXRanges(comp, options);
debug("xrange", comp);
comp = replaceStars(comp, options);
debug("stars", comp);
return comp;
};
var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
var invalidXRangeOrder = (M, m, p) => isX(M) && !isX(m) || isX(m) && p && !isX(p);
var replaceTildes = (comp, options) => {
return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
};
var replaceTilde = (comp, options) => {
const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
const z = options.includePrerelease ? "-0" : "";
return comp.replace(r, (_, M, m, p, pr) => {
debug("tilde", comp, _, M, m, p, pr);
let ret;
if (isX(M)) {
ret = "";
} else if (isX(m)) {
ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
} else if (isX(p)) {
ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
} else if (pr) {
debug("replaceTilde pr", pr);
ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
} else {
ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
}
debug("tilde return", ret);
return ret;
});
};
var replaceCarets = (comp, options) => {
return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
};
var replaceCaret = (comp, options) => {
debug("caret", comp, options);
const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
const z = options.includePrerelease ? "-0" : "";
return comp.replace(r, (_, M, m, p, pr) => {
debug("caret", comp, _, M, m, p, pr);
let ret;
if (isX(M)) {
ret = "";
} else if (isX(m)) {
ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
} else if (isX(p)) {
if (M === "0") {
ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
} else {
ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
}
} else if (pr) {
debug("replaceCaret pr", pr);
if (M === "0") {
if (m === "0") {
ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
} else {
ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
}
} else {
ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
}
} else {
debug("no pr");
if (M === "0") {
if (m === "0") {
ret = `>=${M}.${m}.${p} <${M}.${m}.${+p + 1}-0`;
} else {
ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
}
} else {
ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
}
}
debug("caret return", ret);
return ret;
});
};
var replaceXRanges = (comp, options) => {
debug("replaceXRanges", comp, options);
return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
};
var replaceXRange = (comp, options) => {
comp = comp.trim();
const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
debug("xRange", comp, ret, gtlt, M, m, p, pr);
if (invalidXRangeOrder(M, m, p)) {
return comp;
}
const xM = isX(M);
const xm = xM || isX(m);
const xp = xm || isX(p);
const anyX = xp;
if (gtlt === "=" && anyX) {
gtlt = "";
}
pr = options.includePrerelease ? "-0" : "";
if (xM) {
if (gtlt === ">" || gtlt === "<") {
ret = "<0.0.0-0";
} else {
ret = "*";
}
} else if (gtlt && anyX) {
if (xm) {
m = 0;
}
p = 0;
if (gtlt === ">") {
gtlt = ">=";
if (xm) {
M = +M + 1;
m = 0;
p = 0;
} else {
m = +m + 1;
p = 0;
}
} else if (gtlt === "<=") {
gtlt = "<";
if (xm) {
M = +M + 1;
} else {
m = +m + 1;
}
}
if (gtlt === "<") {
pr = "-0";
}
ret = `${gtlt + M}.${m}.${p}${pr}`;
} else if (xm) {
ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
} else if (xp) {
ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
}
debug("xRange return", ret);
return ret;
});
};
var replaceStars = (comp, options) => {
debug("replaceStars", comp, options);
return comp.trim().replace(re[t.STAR], "");
};
var replaceGTE0 = (comp, options) => {
debug("replaceGTE0", comp, options);
return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
};
var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
if (isX(fM)) {
from = "";
} else if (isX(fm)) {
from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
} else if (isX(fp)) {
from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
} else if (fpr) {
from = `>=${from}`;
} else {
from = `>=${from}${incPr ? "-0" : ""}`;
}
if (isX(tM)) {
to = "";
} else if (isX(tm)) {
to = `<${+tM + 1}.0.0-0`;
} else if (isX(tp)) {
to = `<${tM}.${+tm + 1}.0-0`;
} else if (tpr) {
to = `<=${tM}.${tm}.${tp}-${tpr}`;
} else if (incPr) {
to = `<${tM}.${tm}.${+tp + 1}-0`;
} else {
to = `<=${to}`;
}
return `${from} ${to}`.trim();
};
var testSet = (set, version, options) => {
for (let i = 0; i < set.length; i++) {
if (!set[i].test(version)) {
return false;
}
}
if (version.prerelease.length && !options.includePrerelease) {
for (let i = 0; i < set.length; i++) {
debug(set[i].semver);
if (set[i].semver === Comparator.ANY) {
continue;
}
if (set[i].semver.prerelease.length > 0) {
const allowed = set[i].semver;
if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
return true;
}
}
}
return false;
}
return true;
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/classes/comparator.js
var require_comparator = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/classes/comparator.js"(exports, module) {
"use strict";
var ANY = /* @__PURE__ */ Symbol("SemVer ANY");
var Comparator = class _Comparator {
static get ANY() {
return ANY;
}
constructor(comp, options) {
options = parseOptions(options);
if (comp instanceof _Comparator) {
if (comp.loose === !!options.loose) {
return comp;
} else {
comp = comp.value;
}
}
comp = comp.trim().split(/\s+/).join(" ");
debug("comparator", comp, options);
this.options = options;
this.loose = !!options.loose;
this.parse(comp);
if (this.semver === ANY) {
this.value = "";
} else {
this.value = this.operator + this.semver.version;
}
debug("comp", this);
}
parse(comp) {
const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
const m = comp.match(r);
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);
}
}
toString() {
return this.value;
}
test(version) {
debug("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);
}
intersects(comp, options) {
if (!(comp instanceof _Comparator)) {
throw new TypeError("a Comparator is required");
}
if (this.operator === "") {
if (this.value === "") {
return true;
}
return new Range(comp.value, options).test(this.value);
} else if (comp.operator === "") {
if (comp.value === "") {
return true;
}
return new Range(this.value, options).test(comp.semver);
}
options = parseOptions(options);
if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
return false;
}
if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
return false;
}
if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
return true;
}
if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
return true;
}
if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
return true;
}
if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
return true;
}
if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
return true;
}
return false;
}
};
module.exports = Comparator;
var parseOptions = require_parse_options();
var { safeRe: re, t } = require_re();
var cmp = require_cmp();
var debug = require_debug();
var SemVer = require_semver();
var Range = require_range();
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/satisfies.js
var require_satisfies = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/functions/satisfies.js"(exports, module) {
"use strict";
var Range = require_range();
var satisfies = (version, range, options) => {
try {
range = new Range(range, options);
} catch (er) {
return false;
}
return range.test(version);
};
module.exports = satisfies;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/to-comparators.js
var require_to_comparators = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/to-comparators.js"(exports, module) {
"use strict";
var Range = require_range();
var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
module.exports = toComparators;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/max-satisfying.js
var require_max_satisfying = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/max-satisfying.js"(exports, module) {
"use strict";
var SemVer = require_semver();
var Range = require_range();
var maxSatisfying = (versions, range, options) => {
let max = null;
let maxSV = null;
let rangeObj = null;
try {
rangeObj = new Range(range, options);
} catch (er) {
return null;
}
versions.forEach((v) => {
if (rangeObj.test(v)) {
if (!max || maxSV.compare(v) === -1) {
max = v;
maxSV = new SemVer(max, options);
}
}
});
return max;
};
module.exports = maxSatisfying;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/min-satisfying.js
var require_min_satisfying = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/min-satisfying.js"(exports, module) {
"use strict";
var SemVer = require_semver();
var Range = require_range();
var minSatisfying = (versions, range, options) => {
let min = null;
let minSV = null;
let rangeObj = null;
try {
rangeObj = new Range(range, options);
} catch (er) {
return null;
}
versions.forEach((v) => {
if (rangeObj.test(v)) {
if (!min || minSV.compare(v) === 1) {
min = v;
minSV = new SemVer(min, options);
}
}
});
return min;
};
module.exports = minSatisfying;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/min-version.js
var require_min_version = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/min-version.js"(exports, module) {
"use strict";
var SemVer = require_semver();
var Range = require_range();
var gt = require_gt();
var minVersion = (range, loose) => {
range = new Range(range, loose);
let minver = new SemVer("0.0.0");
if (range.test(minver)) {
return minver;
}
minver = new SemVer("0.0.0-0");
if (range.test(minver)) {
return minver;
}
minver = null;
for (let i = 0; i < range.set.length; ++i) {
const comparators = range.set[i];
let setMin = null;
comparators.forEach((comparator) => {
const compver = new SemVer(comparator.semver.version);
switch (comparator.operator) {
case ">":
if (compver.prerelease.length === 0) {
compver.patch++;
} else {
compver.prerelease.push(0);
}
compver.raw = compver.format();
/* fallthrough */
case "":
case ">=":
if (!setMin || gt(compver, setMin)) {
setMin = compver;
}
break;
case "<":
case "<=":
break;
/* istanbul ignore next */
default:
throw new Error(`Unexpected operation: ${comparator.operator}`);
}
});
if (setMin && (!minver || gt(minver, setMin))) {
minver = setMin;
}
}
if (minver && range.test(minver)) {
return minver;
}
return null;
};
module.exports = minVersion;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/valid.js
var require_valid2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/valid.js"(exports, module) {
"use strict";
var Range = require_range();
var validRange = (range, options) => {
try {
return new Range(range, options).range || "*";
} catch (er) {
return null;
}
};
module.exports = validRange;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/outside.js
var require_outside = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/outside.js"(exports, module) {
"use strict";
var SemVer = require_semver();
var Comparator = require_comparator();
var { ANY } = Comparator;
var Range = require_range();
var satisfies = require_satisfies();
var gt = require_gt();
var lt = require_lt();
var lte = require_lte();
var gte = require_gte();
var outside = (version, range, hilo, options) => {
version = new SemVer(version, options);
range = new Range(range, options);
let gtfn, ltefn, ltfn, comp, ecomp;
switch (hilo) {
case ">":
gtfn = gt;
ltefn = lte;
ltfn = lt;
comp = ">";
ecomp = ">=";
break;
case "<":
gtfn = lt;
ltefn = gte;
ltfn = gt;
comp = "<";
ecomp = "<=";
break;
default:
throw new TypeError('Must provide a hilo val of "<" or ">"');
}
if (satisfies(version, range, options)) {
return false;
}
for (let i = 0; i < range.set.length; ++i) {
const comparators = range.set[i];
let high = null;
let low = null;
comparators.forEach((comparator) => {
if (comparator.semver === ANY) {
comparator = new Comparator(">=0.0.0");
}
high = high || comparator;
low = low || comparator;
if (gtfn(comparator.semver, high.semver, options)) {
high = comparator;
} else if (ltfn(comparator.semver, low.semver, options)) {
low = comparator;
}
});
if (high.operator === comp || high.operator === ecomp) {
return false;
}
if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
return false;
} else if (low.operator === ecomp && ltfn(version, low.semver)) {
return false;
}
}
return true;
};
module.exports = outside;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/gtr.js
var require_gtr = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/gtr.js"(exports, module) {
"use strict";
var outside = require_outside();
var gtr = (version, range, options) => outside(version, range, ">", options);
module.exports = gtr;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/ltr.js
var require_ltr = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/ltr.js"(exports, module) {
"use strict";
var outside = require_outside();
var ltr = (version, range, options) => outside(version, range, "<", options);
module.exports = ltr;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/intersects.js
var require_intersects = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/intersects.js"(exports, module) {
"use strict";
var Range = require_range();
var intersects = (r1, r2, options) => {
r1 = new Range(r1, options);
r2 = new Range(r2, options);
return r1.intersects(r2, options);
};
module.exports = intersects;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/simplify.js
var require_simplify = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/simplify.js"(exports, module) {
"use strict";
var satisfies = require_satisfies();
var compare = require_compare();
module.exports = (versions, range, options) => {
const set = [];
let first = null;
let prev = null;
const v = versions.sort((a, b) => compare(a, b, options));
for (const version of v) {
const included = satisfies(version, range, options);
if (included) {
prev = version;
if (!first) {
first = version;
}
} else {
if (prev) {
set.push([first, prev]);
}
prev = null;
first = null;
}
}
if (first) {
set.push([first, null]);
}
const ranges = [];
for (const [min, max] of set) {
if (min === max) {
ranges.push(min);
} else if (!max && min === v[0]) {
ranges.push("*");
} else if (!max) {
ranges.push(`>=${min}`);
} else if (min === v[0]) {
ranges.push(`<=${max}`);
} else {
ranges.push(`${min} - ${max}`);
}
}
const simplified = ranges.join(" || ");
const original = typeof range.raw === "string" ? range.raw : String(range);
return simplified.length < original.length ? simplified : range;
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/subset.js
var require_subset = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/ranges/subset.js"(exports, module) {
"use strict";
var Range = require_range();
var Comparator = require_comparator();
var { ANY } = Comparator;
var satisfies = require_satisfies();
var compare = require_compare();
var subset = (sub, dom, options = {}) => {
if (sub === dom) {
return true;
}
sub = new Range(sub, options);
dom = new Range(dom, options);
let sawNonNull = false;
OUTER: for (const simpleSub of sub.set) {
for (const simpleDom of dom.set) {
const isSub = simpleSubset(simpleSub, simpleDom, options);
sawNonNull = sawNonNull || isSub !== null;
if (isSub) {
continue OUTER;
}
}
if (sawNonNull) {
return false;
}
}
return true;
};
var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
var minimumVersion = [new Comparator(">=0.0.0")];
var simpleSubset = (sub, dom, options) => {
if (sub === dom) {
return true;
}
if (sub.length === 1 && sub[0].semver === ANY) {
if (dom.length === 1 && dom[0].semver === ANY) {
return true;
} else if (options.includePrerelease) {
sub = minimumVersionWithPreRelease;
} else {
sub = minimumVersion;
}
}
if (dom.length === 1 && dom[0].semver === ANY) {
if (options.includePrerelease) {
return true;
} else {
dom = minimumVersion;
}
}
const eqSet = /* @__PURE__ */ new Set();
let gt, lt;
for (const c of sub) {
if (c.operator === ">" || c.operator === ">=") {
gt = higherGT(gt, c, options);
} else if (c.operator === "<" || c.operator === "<=") {
lt = lowerLT(lt, c, options);
} else {
eqSet.add(c.semver);
}
}
if (eqSet.size > 1) {
return null;
}
let gtltComp;
if (gt && lt) {
gtltComp = compare(gt.semver, lt.semver, options);
if (gtltComp > 0) {
return null;
} else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
return null;
}
}
for (const eq of eqSet) {
if (gt && !satisfies(eq, String(gt), options)) {
return null;
}
if (lt && !satisfies(eq, String(lt), options)) {
return null;
}
for (const c of dom) {
if (!satisfies(eq, String(c), options)) {
return false;
}
}
return true;
}
let higher, lower;
let hasDomLT, hasDomGT;
let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
needDomLTPre = false;
}
for (const c of dom) {
hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
if (gt) {
if (needDomGTPre) {
if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
needDomGTPre = false;
}
}
if (c.operator === ">" || c.operator === ">=") {
higher = higherGT(gt, c, options);
if (higher === c && higher !== gt) {
return false;
}
} else if (gt.operator === ">=" && !c.test(gt.semver)) {
return false;
}
}
if (lt) {
if (needDomLTPre) {
if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
needDomLTPre = false;
}
}
if (c.operator === "<" || c.operator === "<=") {
lower = lowerLT(lt, c, options);
if (lower === c && lower !== lt) {
return false;
}
} else if (lt.operator === "<=" && !c.test(lt.semver)) {
return false;
}
}
if (!c.operator && (lt || gt) && gtltComp !== 0) {
return false;
}
}
if (gt && hasDomLT && !lt && gtltComp !== 0) {
return false;
}
if (lt && hasDomGT && !gt && gtltComp !== 0) {
return false;
}
if (needDomGTPre || needDomLTPre) {
return false;
}
return true;
};
var higherGT = (a, b, options) => {
if (!a) {
return b;
}
const comp = compare(a.semver, b.semver, options);
return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
};
var lowerLT = (a, b, options) => {
if (!a) {
return b;
}
const comp = compare(a.semver, b.semver, options);
return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
};
module.exports = subset;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/index.js
var require_semver2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/semver/7.8.5/50b76942b76b1567bb275b07b36d4efd1f7bc678ee222317e6ec7ff2c047c60d/node_modules/semver/index.js"(exports, module) {
"use strict";
var internalRe = require_re();
var constants2 = require_constants();
var SemVer = require_semver();
var identifiers = require_identifiers();
var parse2 = require_parse();
var valid = require_valid();
var clean = require_clean();
var inc = require_inc();
var diff = require_diff();
var major = require_major();
var minor = require_minor();
var patch = require_patch();
var prerelease = require_prerelease();
var compare = require_compare();
var rcompare = require_rcompare();
var compareLoose = require_compare_loose();
var compareBuild = require_compare_build();
var sort = require_sort();
var rsort = require_rsort();
var gt = require_gt();
var lt = require_lt();
var eq = require_eq();
var neq = require_neq();
var gte = require_gte();
var lte = require_lte();
var cmp = require_cmp();
var coerce = require_coerce();
var truncate = require_truncate();
var Comparator = require_comparator();
var Range = require_range();
var satisfies = require_satisfies();
var toComparators = require_to_comparators();
var maxSatisfying = require_max_satisfying();
var minSatisfying = require_min_satisfying();
var minVersion = require_min_version();
var validRange = require_valid2();
var outside = require_outside();
var gtr = require_gtr();
var ltr = require_ltr();
var intersects = require_intersects();
var simplifyRange = require_simplify();
var subset = require_subset();
module.exports = {
parse: parse2,
valid,
clean,
inc,
diff,
major,
minor,
patch,
prerelease,
compare,
rcompare,
compareLoose,
compareBuild,
sort,
rsort,
gt,
lt,
eq,
neq,
gte,
lte,
cmp,
coerce,
truncate,
Comparator,
Range,
satisfies,
toComparators,
maxSatisfying,
minSatisfying,
minVersion,
validRange,
outside,
gtr,
ltr,
intersects,
simplifyRange,
subset,
SemVer,
re: internalRe.re,
src: internalRe.src,
tokens: internalRe.t,
SEMVER_SPEC_VERSION: constants2.SEMVER_SPEC_VERSION,
RELEASE_TYPES: constants2.RELEASE_TYPES,
compareIdentifiers: identifiers.compareIdentifiers,
rcompareIdentifiers: identifiers.rcompareIdentifiers
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/spdx-license-ids/3.0.24/2fc03b49c7b8c13efb62f74badfae1f8ef8ea11e9bc3883fe87e7a30bc40cfce/node_modules/spdx-license-ids/index.json
var require_spdx_license_ids = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/spdx-license-ids/3.0.24/2fc03b49c7b8c13efb62f74badfae1f8ef8ea11e9bc3883fe87e7a30bc40cfce/node_modules/spdx-license-ids/index.json"(exports, module) {
module.exports = [
"0BSD",
"3D-Slicer-1.0",
"AAL",
"ADSL",
"AFL-1.1",
"AFL-1.2",
"AFL-2.0",
"AFL-2.1",
"AFL-3.0",
"AGPL-1.0-only",
"AGPL-1.0-or-later",
"AGPL-3.0-only",
"AGPL-3.0-or-later",
"ALGLIB-Documentation",
"AMD-newlib",
"AMDPLPA",
"AML",
"AML-glslang",
"AMPAS",
"ANTLR-PD",
"ANTLR-PD-fallback",
"APAFML",
"APL-1.0",
"APSL-1.0",
"APSL-1.1",
"APSL-1.2",
"APSL-2.0",
"ASWF-Digital-Assets-1.0",
"ASWF-Digital-Assets-1.1",
"Abstyles",
"AdaCore-doc",
"Adobe-2006",
"Adobe-Display-PostScript",
"Adobe-Glyph",
"Adobe-Utopia",
"Advanced-Cryptics-Dictionary",
"Afmparse",
"Aladdin",
"Apache-1.0",
"Apache-1.1",
"Apache-2.0",
"App-s2p",
"Arphic-1999",
"Artistic-1.0",
"Artistic-1.0-Perl",
"Artistic-1.0-cl8",
"Artistic-2.0",
"Artistic-dist",
"Aspell-RU",
"BOLA-1.1",
"BSD-1-Clause",
"BSD-2-Clause",
"BSD-2-Clause-Darwin",
"BSD-2-Clause-Patent",
"BSD-2-Clause-Views",
"BSD-2-Clause-first-lines",
"BSD-2-Clause-pkgconf-disclaimer",
"BSD-2-Clause-pos-unchanged",
"BSD-3-Clause",
"BSD-3-Clause-Attribution",
"BSD-3-Clause-Clear",
"BSD-3-Clause-HP",
"BSD-3-Clause-LBNL",
"BSD-3-Clause-Modification",
"BSD-3-Clause-No-Military-License",
"BSD-3-Clause-No-Nuclear-License",
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause-No-Nuclear-Warranty",
"BSD-3-Clause-Open-MPI",
"BSD-3-Clause-OpenWebUI",
"BSD-3-Clause-Sun",
"BSD-3-Clause-Tso",
"BSD-3-Clause-acpica",
"BSD-3-Clause-flex",
"BSD-4-Clause",
"BSD-4-Clause-Shortened",
"BSD-4-Clause-UC",
"BSD-4.3RENO",
"BSD-4.3TAHOE",
"BSD-Advertising-Acknowledgement",
"BSD-Attribution-HPND-disclaimer",
"BSD-Inferno-Nettverk",
"BSD-Mark-Modifications",
"BSD-Protection",
"BSD-Source-Code",
"BSD-Source-Code-no-disclaimer",
"BSD-Source-alt-GPL",
"BSD-Source-beginning-file",
"BSD-Systemics",
"BSD-Systemics-W3Works",
"BSD-ask-to-endorse",
"BSL-1.0",
"BUSL-1.1",
"Baekmuk",
"Bahyph",
"Barr",
"Beerware",
"BitTorrent-1.0",
"BitTorrent-1.1",
"Bitstream-Charter",
"Bitstream-Vera",
"BlueOak-1.0.0",
"Boehm-GC",
"Boehm-GC-without-fee",
"Borceux",
"Brian-Gladman-2-Clause",
"Brian-Gladman-3-Clause",
"Brian-Gladman-3-Clause-no-conversion",
"Buddy",
"Bugroff",
"C-UDA-1.0",
"CAL-1.0",
"CAL-1.0-Combined-Work-Exception",
"CAPEC-tou",
"CATOSL-1.1",
"CC-BY-1.0",
"CC-BY-2.0",
"CC-BY-2.5",
"CC-BY-2.5-AU",
"CC-BY-3.0",
"CC-BY-3.0-AT",
"CC-BY-3.0-AU",
"CC-BY-3.0-DE",
"CC-BY-3.0-IGO",
"CC-BY-3.0-NL",
"CC-BY-3.0-US",
"CC-BY-4.0",
"CC-BY-NC-1.0",
"CC-BY-NC-2.0",
"CC-BY-NC-2.5",
"CC-BY-NC-3.0",
"CC-BY-NC-3.0-DE",
"CC-BY-NC-3.0-IGO",
"CC-BY-NC-4.0",
"CC-BY-NC-ND-1.0",
"CC-BY-NC-ND-2.0",
"CC-BY-NC-ND-2.5",
"CC-BY-NC-ND-3.0",
"CC-BY-NC-ND-3.0-DE",
"CC-BY-NC-ND-3.0-IGO",
"CC-BY-NC-ND-4.0",
"CC-BY-NC-SA-1.0",
"CC-BY-NC-SA-2.0",
"CC-BY-NC-SA-2.0-DE",
"CC-BY-NC-SA-2.0-FR",
"CC-BY-NC-SA-2.0-UK",
"CC-BY-NC-SA-2.5",
"CC-BY-NC-SA-3.0",
"CC-BY-NC-SA-3.0-DE",
"CC-BY-NC-SA-3.0-IGO",
"CC-BY-NC-SA-4.0",
"CC-BY-ND-1.0",
"CC-BY-ND-2.0",
"CC-BY-ND-2.5",
"CC-BY-ND-3.0",
"CC-BY-ND-3.0-DE",
"CC-BY-ND-4.0",
"CC-BY-SA-1.0",
"CC-BY-SA-2.0",
"CC-BY-SA-2.0-UK",
"CC-BY-SA-2.1-JP",
"CC-BY-SA-2.5",
"CC-BY-SA-3.0",
"CC-BY-SA-3.0-AT",
"CC-BY-SA-3.0-DE",
"CC-BY-SA-3.0-IGO",
"CC-BY-SA-4.0",
"CC-PDDC",
"CC-PDM-1.0",
"CC-SA-1.0",
"CC0-1.0",
"CDDL-1.0",
"CDDL-1.1",
"CDL-1.0",
"CDLA-Permissive-1.0",
"CDLA-Permissive-2.0",
"CDLA-Sharing-1.0",
"CECILL-1.0",
"CECILL-1.1",
"CECILL-2.0",
"CECILL-2.1",
"CECILL-B",
"CECILL-C",
"CERN-OHL-1.1",
"CERN-OHL-1.2",
"CERN-OHL-P-2.0",
"CERN-OHL-S-2.0",
"CERN-OHL-W-2.0",
"CFITSIO",
"CMU-Mach",
"CMU-Mach-nodoc",
"CNRI-Jython",
"CNRI-Python",
"CNRI-Python-GPL-Compatible",
"COIL-1.0",
"CPAL-1.0",
"CPL-1.0",
"CPOL-1.02",
"CUA-OPL-1.0",
"Caldera",
"Caldera-no-preamble",
"Catharon",
"ClArtistic",
"Clips",
"Community-Spec-1.0",
"Condor-1.1",
"Cornell-Lossless-JPEG",
"Cronyx",
"Crossword",
"CryptoSwift",
"CrystalStacker",
"Cube",
"D-FSL-1.0",
"DEC-3-Clause",
"DL-DE-BY-2.0",
"DL-DE-ZERO-2.0",
"DOC",
"DRL-1.0",
"DRL-1.1",
"DSDP",
"DocBook-DTD",
"DocBook-Schema",
"DocBook-Stylesheet",
"DocBook-XML",
"Dotseqn",
"ECL-1.0",
"ECL-2.0",
"EFL-1.0",
"EFL-2.0",
"EPICS",
"EPL-1.0",
"EPL-2.0",
"ESA-PL-permissive-2.4",
"ESA-PL-strong-copyleft-2.4",
"ESA-PL-weak-copyleft-2.4",
"EUDatagrid",
"EUPL-1.0",
"EUPL-1.1",
"EUPL-1.2",
"Elastic-2.0",
"Entessa",
"ErlPL-1.1",
"Eurosym",
"FBM",
"FDK-AAC",
"FDK-MPEG-H",
"FSFAP",
"FSFAP-no-warranty-disclaimer",
"FSFUL",
"FSFULLR",
"FSFULLRSD",
"FSFULLRWD",
"FSL-1.1-ALv2",
"FSL-1.1-MIT",
"FTL",
"Fair",
"Ferguson-Twofish",
"Frameworx-1.0",
"FreeBSD-DOC",
"FreeImage",
"Furuseth",
"GCR-docs",
"GD",
"GFDL-1.1-invariants-only",
"GFDL-1.1-invariants-or-later",
"GFDL-1.1-no-invariants-only",
"GFDL-1.1-no-invariants-or-later",
"GFDL-1.1-only",
"GFDL-1.1-or-later",
"GFDL-1.2-invariants-only",
"GFDL-1.2-invariants-or-later",
"GFDL-1.2-no-invariants-only",
"GFDL-1.2-no-invariants-or-later",
"GFDL-1.2-only",
"GFDL-1.2-or-later",
"GFDL-1.3-invariants-only",
"GFDL-1.3-invariants-or-later",
"GFDL-1.3-no-invariants-only",
"GFDL-1.3-no-invariants-or-later",
"GFDL-1.3-only",
"GFDL-1.3-or-later",
"GL2PS",
"GLWTPL",
"GPL-1.0-only",
"GPL-1.0-or-later",
"GPL-2.0-only",
"GPL-2.0-or-later",
"GPL-3.0-only",
"GPL-3.0-or-later",
"Game-Programming-Gems",
"Giftware",
"Glide",
"Glulxe",
"Graphics-Gems",
"Gutmann",
"HDF5",
"HIDAPI",
"HP-1986",
"HP-1989",
"HPND",
"HPND-DEC",
"HPND-Fenneberg-Livingston",
"HPND-INRIA-IMAG",
"HPND-Intel",
"HPND-Kevlin-Henney",
"HPND-MIT-disclaimer",
"HPND-Markus-Kuhn",
"HPND-Netrek",
"HPND-Pbmplus",
"HPND-SMC",
"HPND-UC",
"HPND-UC-export-US",
"HPND-doc",
"HPND-doc-sell",
"HPND-export-US",
"HPND-export-US-acknowledgement",
"HPND-export-US-modify",
"HPND-export2-US",
"HPND-merchantability-variant",
"HPND-sell-MIT-disclaimer-xserver",
"HPND-sell-regexpr",
"HPND-sell-variant",
"HPND-sell-variant-MIT-disclaimer",
"HPND-sell-variant-MIT-disclaimer-rev",
"HPND-sell-variant-critical-systems",
"HTMLTIDY",
"HaskellReport",
"Hippocratic-2.1",
"Hippocratic-3.0-core",
"IBM-pibs",
"ICU",
"IEC-Code-Components-EULA",
"IJG",
"IJG-short",
"IPA",
"IPL-1.0",
"ISC",
"ISC-Veillard",
"ISO-permission",
"ImageMagick",
"Imlib2",
"Info-ZIP",
"Informatica",
"Inner-Net-2.0",
"InnoSetup",
"Intel",
"Intel-ACPI",
"Interbase-1.0",
"JPL-image",
"JPNIC",
"JSON",
"Jam",
"JasPer-2.0",
"Kastrup",
"Kazlib",
"Knuth-CTAN",
"LAL-1.2",
"LAL-1.3",
"LGPL-2.0-only",
"LGPL-2.0-or-later",
"LGPL-2.1-only",
"LGPL-2.1-or-later",
"LGPL-3.0-only",
"LGPL-3.0-or-later",
"LGPLLR",
"LOOP",
"LPD-document",
"LPL-1.0",
"LPL-1.02",
"LPPL-1.0",
"LPPL-1.1",
"LPPL-1.2",
"LPPL-1.3a",
"LPPL-1.3c",
"LZMA-SDK-9.11-to-9.20",
"LZMA-SDK-9.22",
"Latex2e",
"Latex2e-translated-notice",
"Leptonica",
"LiLiQ-P-1.1",
"LiLiQ-R-1.1",
"LiLiQ-Rplus-1.1",
"Libpng",
"Linux-OpenIB",
"Linux-man-pages-1-para",
"Linux-man-pages-copyleft",
"Linux-man-pages-copyleft-2-para",
"Linux-man-pages-copyleft-var",
"Lucida-Bitmap-Fonts",
"MIPS",
"MIT",
"MIT-0",
"MIT-CMU",
"MIT-Click",
"MIT-Festival",
"MIT-Khronos-old",
"MIT-Modern-Variant",
"MIT-STK",
"MIT-Wu",
"MIT-advertising",
"MIT-enna",
"MIT-feh",
"MIT-open-group",
"MIT-testregex",
"MITNFA",
"MMIXware",
"MMPL-1.0.1",
"MPEG-SSG",
"MPL-1.0",
"MPL-1.1",
"MPL-2.0",
"MPL-2.0-no-copyleft-exception",
"MS-LPL",
"MS-PL",
"MS-RL",
"MTLL",
"MVT-1.1",
"Mackerras-3-Clause",
"Mackerras-3-Clause-acknowledgment",
"MakeIndex",
"Martin-Birgmeier",
"McPhee-slideshow",
"Minpack",
"MirOS",
"Motosoto",
"MulanPSL-1.0",
"MulanPSL-2.0",
"Multics",
"Mup",
"NAIST-2003",
"NASA-1.3",
"NBPL-1.0",
"NCBI-PD",
"NCGL-UK-2.0",
"NCL",
"NCSA",
"NGPL",
"NICTA-1.0",
"NIST-PD",
"NIST-PD-TNT",
"NIST-PD-fallback",
"NIST-Software",
"NLOD-1.0",
"NLOD-2.0",
"NLPL",
"NOSL",
"NPL-1.0",
"NPL-1.1",
"NPOSL-3.0",
"NRL",
"NTIA-PD",
"NTP",
"NTP-0",
"Naumen",
"NetCDF",
"Newsletr",
"Nokia",
"Noweb",
"O-UDA-1.0",
"OAR",
"OCCT-PL",
"OCLC-2.0",
"ODC-By-1.0",
"ODbL-1.0",
"OFFIS",
"OFL-1.0",
"OFL-1.0-RFN",
"OFL-1.0-no-RFN",
"OFL-1.1",
"OFL-1.1-RFN",
"OFL-1.1-no-RFN",
"OGC-1.0",
"OGDL-Taiwan-1.0",
"OGL-Canada-2.0",
"OGL-UK-1.0",
"OGL-UK-2.0",
"OGL-UK-3.0",
"OGTSL",
"OLDAP-1.1",
"OLDAP-1.2",
"OLDAP-1.3",
"OLDAP-1.4",
"OLDAP-2.0",
"OLDAP-2.0.1",
"OLDAP-2.1",
"OLDAP-2.2",
"OLDAP-2.2.1",
"OLDAP-2.2.2",
"OLDAP-2.3",
"OLDAP-2.4",
"OLDAP-2.5",
"OLDAP-2.6",
"OLDAP-2.7",
"OLDAP-2.8",
"OLFL-1.3",
"OML",
"OPL-1.0",
"OPL-UK-3.0",
"OPUBL-1.0",
"OSC-1.0",
"OSET-PL-2.1",
"OSL-1.0",
"OSL-1.1",
"OSL-2.0",
"OSL-2.1",
"OSL-3.0",
"OSSP",
"OpenMDW-1.0",
"OpenPBS-2.3",
"OpenSSL",
"OpenSSL-standalone",
"OpenVision",
"PADL",
"PDDL-1.0",
"PHP-3.0",
"PHP-3.01",
"PPL",
"PSF-2.0",
"ParaType-Free-Font-1.3",
"Parity-6.0.0",
"Parity-7.0.0",
"Pixar",
"Plexus",
"PolyForm-Noncommercial-1.0.0",
"PolyForm-Small-Business-1.0.0",
"PostgreSQL",
"Python-2.0",
"Python-2.0.1",
"QPL-1.0",
"QPL-1.0-INRIA-2004",
"Qhull",
"RHeCos-1.1",
"RPL-1.1",
"RPL-1.5",
"RPSL-1.0",
"RSA-MD",
"RSCPL",
"Rdisc",
"Ruby",
"Ruby-pty",
"SAX-PD",
"SAX-PD-2.0",
"SCEA",
"SGI-B-1.0",
"SGI-B-1.1",
"SGI-B-2.0",
"SGI-OpenGL",
"SGMLUG-PM",
"SGP4",
"SHL-0.5",
"SHL-0.51",
"SISSL",
"SISSL-1.2",
"SL",
"SMAIL-GPL",
"SMLNJ",
"SMPPL",
"SNIA",
"SOFA",
"SPL-1.0",
"SSH-OpenSSH",
"SSH-short",
"SSLeay-standalone",
"SSPL-1.0",
"SUL-1.0",
"SWL",
"Saxpath",
"SchemeReport",
"Sendmail",
"Sendmail-8.23",
"Sendmail-Open-Source-1.1",
"SimPL-2.0",
"Sleepycat",
"Soundex",
"Spencer-86",
"Spencer-94",
"Spencer-99",
"SugarCRM-1.1.3",
"Sun-PPP",
"Sun-PPP-2000",
"SunPro",
"Symlinks",
"TAPR-OHL-1.0",
"TCL",
"TCP-wrappers",
"TGPPL-1.0",
"TMate",
"TORQUE-1.1",
"TOSL",
"TPDL",
"TPL-1.0",
"TTWL",
"TTYP0",
"TU-Berlin-1.0",
"TU-Berlin-2.0",
"TekHVC",
"TermReadKey",
"ThirdEye",
"TrustedQSL",
"UCAR",
"UCL-1.0",
"UMich-Merit",
"UPL-1.0",
"URT-RLE",
"Ubuntu-font-1.0",
"UnRAR",
"Unicode-3.0",
"Unicode-DFS-2015",
"Unicode-DFS-2016",
"Unicode-TOU",
"UnixCrypt",
"Unlicense",
"Unlicense-libtelnet",
"Unlicense-libwhirlpool",
"VOSTROM",
"VSL-1.0",
"Vim",
"Vixie-Cron",
"W3C",
"W3C-19980720",
"W3C-20150513",
"WTFNMFPL",
"WTFPL",
"Watcom-1.0",
"Widget-Workshop",
"WordNet",
"Wsuipa",
"X11",
"X11-distribute-modifications-variant",
"X11-no-permit-persons",
"X11-swapped",
"XFree86-1.1",
"XSkat",
"Xdebug-1.03",
"Xerox",
"Xfig",
"Xnet",
"YPL-1.0",
"YPL-1.1",
"ZPL-1.1",
"ZPL-2.0",
"ZPL-2.1",
"Zed",
"Zeeff",
"Zend-2.0",
"Zimbra-1.3",
"Zimbra-1.4",
"Zlib",
"any-OSI",
"any-OSI-perl-modules",
"atc-game",
"bcrypt-Solar-Designer",
"blessing",
"bzip2-1.0.6",
"check-cvs",
"checkmk",
"copyleft-next-0.3.0",
"copyleft-next-0.3.1",
"curl",
"cve-tou",
"diffmark",
"dtoa",
"dvipdfm",
"eGenix",
"etalab-2.0",
"fwlw",
"gSOAP-1.3b",
"generic-xts",
"gnuplot",
"gtkbook",
"hdparm",
"hyphen-bulgarian",
"iMatix",
"jove",
"libpng-1.6.35",
"libpng-2.0",
"libselinux-1.0",
"libtiff",
"libutil-David-Nugent",
"lsof",
"magaz",
"mailprio",
"man2html",
"metamail",
"mpi-permissive",
"mpich2",
"mplus",
"ngrep",
"pkgconf",
"pnmstitch",
"psfrag",
"psutils",
"python-ldap",
"radvd",
"snprintf",
"softSurfer",
"ssh-keyscan",
"swrule",
"threeparttable",
"ulem",
"w3m",
"wwl",
"xinetd",
"xkeyboard-config-Zinoviev",
"xlock",
"xpp",
"xzoom",
"zlib-acknowledgement"
];
}
});
// ../../../../../setup-pnpm/store/v11/links/@/spdx-license-ids/3.0.24/2fc03b49c7b8c13efb62f74badfae1f8ef8ea11e9bc3883fe87e7a30bc40cfce/node_modules/spdx-license-ids/deprecated.json
var require_deprecated = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/spdx-license-ids/3.0.24/2fc03b49c7b8c13efb62f74badfae1f8ef8ea11e9bc3883fe87e7a30bc40cfce/node_modules/spdx-license-ids/deprecated.json"(exports, module) {
module.exports = [
"AGPL-1.0",
"AGPL-3.0",
"BSD-2-Clause-FreeBSD",
"BSD-2-Clause-NetBSD",
"GFDL-1.1",
"GFDL-1.2",
"GFDL-1.3",
"GPL-1.0",
"GPL-2.0",
"GPL-2.0-with-GCC-exception",
"GPL-2.0-with-autoconf-exception",
"GPL-2.0-with-bison-exception",
"GPL-2.0-with-classpath-exception",
"GPL-2.0-with-font-exception",
"GPL-3.0",
"GPL-3.0-with-GCC-exception",
"GPL-3.0-with-autoconf-exception",
"LGPL-2.0",
"LGPL-2.1",
"LGPL-3.0",
"Net-SNMP",
"Nunit",
"StandardML-NJ",
"bzip2-1.0.5",
"eCos-2.0",
"wxWindows"
];
}
});
// ../../../../../setup-pnpm/store/v11/links/@/spdx-exceptions/2.5.0/84a4d711f292f8700460e10d3de3b6ded5409912124ca2833bd0aa92a90002ea/node_modules/spdx-exceptions/index.json
var require_spdx_exceptions = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/spdx-exceptions/2.5.0/84a4d711f292f8700460e10d3de3b6ded5409912124ca2833bd0aa92a90002ea/node_modules/spdx-exceptions/index.json"(exports, module) {
module.exports = [
"389-exception",
"Asterisk-exception",
"Autoconf-exception-2.0",
"Autoconf-exception-3.0",
"Autoconf-exception-generic",
"Autoconf-exception-generic-3.0",
"Autoconf-exception-macro",
"Bison-exception-1.24",
"Bison-exception-2.2",
"Bootloader-exception",
"Classpath-exception-2.0",
"CLISP-exception-2.0",
"cryptsetup-OpenSSL-exception",
"DigiRule-FOSS-exception",
"eCos-exception-2.0",
"Fawkes-Runtime-exception",
"FLTK-exception",
"fmt-exception",
"Font-exception-2.0",
"freertos-exception-2.0",
"GCC-exception-2.0",
"GCC-exception-2.0-note",
"GCC-exception-3.1",
"Gmsh-exception",
"GNAT-exception",
"GNOME-examples-exception",
"GNU-compiler-exception",
"gnu-javamail-exception",
"GPL-3.0-interface-exception",
"GPL-3.0-linking-exception",
"GPL-3.0-linking-source-exception",
"GPL-CC-1.0",
"GStreamer-exception-2005",
"GStreamer-exception-2008",
"i2p-gpl-java-exception",
"KiCad-libraries-exception",
"LGPL-3.0-linking-exception",
"libpri-OpenH323-exception",
"Libtool-exception",
"Linux-syscall-note",
"LLGPL",
"LLVM-exception",
"LZMA-exception",
"mif-exception",
"OCaml-LGPL-linking-exception",
"OCCT-exception-1.0",
"OpenJDK-assembly-exception-1.0",
"openvpn-openssl-exception",
"PS-or-PDF-font-exception-20170817",
"QPL-1.0-INRIA-2004-exception",
"Qt-GPL-exception-1.0",
"Qt-LGPL-exception-1.1",
"Qwt-exception-1.0",
"SANE-exception",
"SHL-2.0",
"SHL-2.1",
"stunnel-exception",
"SWI-exception",
"Swift-exception",
"Texinfo-exception",
"u-boot-exception-2.0",
"UBDL-exception",
"Universal-FOSS-exception-1.0",
"vsftpd-openssl-exception",
"WxWindows-exception-3.1",
"x11vnc-openssl-exception"
];
}
});
// ../../../../../setup-pnpm/store/v11/links/@/spdx-expression-parse/3.0.1/b5dd884a37ac2964dfe3313355fb09b389b224b51cd926d801d0407067f96b06/node_modules/spdx-expression-parse/scan.js
var require_scan = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/spdx-expression-parse/3.0.1/b5dd884a37ac2964dfe3313355fb09b389b224b51cd926d801d0407067f96b06/node_modules/spdx-expression-parse/scan.js"(exports, module) {
"use strict";
var licenses = [].concat(require_spdx_license_ids()).concat(require_deprecated());
var exceptions = require_spdx_exceptions();
module.exports = function(source) {
var index = 0;
function hasMore() {
return index < source.length;
}
function read2(value) {
if (value instanceof RegExp) {
var chars = source.slice(index);
var match = chars.match(value);
if (match) {
index += match[0].length;
return match[0];
}
} else {
if (source.indexOf(value, index) === index) {
index += value.length;
return value;
}
}
}
function skipWhitespace() {
read2(/[ ]*/);
}
function operator() {
var string;
var possibilities = ["WITH", "AND", "OR", "(", ")", ":", "+"];
for (var i = 0; i < possibilities.length; i++) {
string = read2(possibilities[i]);
if (string) {
break;
}
}
if (string === "+" && index > 1 && source[index - 2] === " ") {
throw new Error("Space before `+`");
}
return string && {
type: "OPERATOR",
string
};
}
function idstring() {
return read2(/[A-Za-z0-9-.]+/);
}
function expectIdstring() {
var string = idstring();
if (!string) {
throw new Error("Expected idstring at offset " + index);
}
return string;
}
function documentRef() {
if (read2("DocumentRef-")) {
var string = expectIdstring();
return { type: "DOCUMENTREF", string };
}
}
function licenseRef() {
if (read2("LicenseRef-")) {
var string = expectIdstring();
return { type: "LICENSEREF", string };
}
}
function identifier() {
var begin2 = index;
var string = idstring();
if (licenses.indexOf(string) !== -1) {
return {
type: "LICENSE",
string
};
} else if (exceptions.indexOf(string) !== -1) {
return {
type: "EXCEPTION",
string
};
}
index = begin2;
}
function parseToken() {
return operator() || documentRef() || licenseRef() || identifier();
}
var tokens = [];
while (hasMore()) {
skipWhitespace();
if (!hasMore()) {
break;
}
var token = parseToken();
if (!token) {
throw new Error("Unexpected `" + source[index] + "` at offset " + index);
}
tokens.push(token);
}
return tokens;
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/spdx-expression-parse/3.0.1/b5dd884a37ac2964dfe3313355fb09b389b224b51cd926d801d0407067f96b06/node_modules/spdx-expression-parse/parse.js
var require_parse2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/spdx-expression-parse/3.0.1/b5dd884a37ac2964dfe3313355fb09b389b224b51cd926d801d0407067f96b06/node_modules/spdx-expression-parse/parse.js"(exports, module) {
"use strict";
module.exports = function(tokens) {
var index = 0;
function hasMore() {
return index < tokens.length;
}
function token() {
return hasMore() ? tokens[index] : null;
}
function next() {
if (!hasMore()) {
throw new Error();
}
index++;
}
function parseOperator(operator) {
var t = token();
if (t && t.type === "OPERATOR" && operator === t.string) {
next();
return t.string;
}
}
function parseWith() {
if (parseOperator("WITH")) {
var t = token();
if (t && t.type === "EXCEPTION") {
next();
return t.string;
}
throw new Error("Expected exception after `WITH`");
}
}
function parseLicenseRef() {
var begin2 = index;
var string = "";
var t = token();
if (t.type === "DOCUMENTREF") {
next();
string += "DocumentRef-" + t.string + ":";
if (!parseOperator(":")) {
throw new Error("Expected `:` after `DocumentRef-...`");
}
}
t = token();
if (t.type === "LICENSEREF") {
next();
string += "LicenseRef-" + t.string;
return { license: string };
}
index = begin2;
}
function parseLicense() {
var t = token();
if (t && t.type === "LICENSE") {
next();
var node2 = { license: t.string };
if (parseOperator("+")) {
node2.plus = true;
}
var exception = parseWith();
if (exception) {
node2.exception = exception;
}
return node2;
}
}
function parseParenthesizedExpression() {
var left = parseOperator("(");
if (!left) {
return;
}
var expr = parseExpression();
if (!parseOperator(")")) {
throw new Error("Expected `)`");
}
return expr;
}
function parseAtom() {
return parseParenthesizedExpression() || parseLicenseRef() || parseLicense();
}
function makeBinaryOpParser(operator, nextParser) {
return function parseBinaryOp() {
var left = nextParser();
if (!left) {
return;
}
if (!parseOperator(operator)) {
return left;
}
var right = parseBinaryOp();
if (!right) {
throw new Error("Expected expression");
}
return {
left,
conjunction: operator.toLowerCase(),
right
};
};
}
var parseAnd = makeBinaryOpParser("AND", parseAtom);
var parseExpression = makeBinaryOpParser("OR", parseAnd);
var node = parseExpression();
if (!node || hasMore()) {
throw new Error("Syntax error");
}
return node;
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/spdx-expression-parse/3.0.1/b5dd884a37ac2964dfe3313355fb09b389b224b51cd926d801d0407067f96b06/node_modules/spdx-expression-parse/index.js
var require_spdx_expression_parse = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/spdx-expression-parse/3.0.1/b5dd884a37ac2964dfe3313355fb09b389b224b51cd926d801d0407067f96b06/node_modules/spdx-expression-parse/index.js"(exports, module) {
"use strict";
var scan = require_scan();
var parse2 = require_parse2();
module.exports = function(source) {
return parse2(scan(source));
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/spdx-correct/3.2.0/f190025f117686c5677971c9b870b1c52b79bb95bcb3bd643d3ffa2625486542/node_modules/spdx-correct/index.js
var require_spdx_correct = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/spdx-correct/3.2.0/f190025f117686c5677971c9b870b1c52b79bb95bcb3bd643d3ffa2625486542/node_modules/spdx-correct/index.js"(exports, module) {
var parse2 = require_spdx_expression_parse();
var spdxLicenseIds = require_spdx_license_ids();
function valid(string) {
try {
parse2(string);
return true;
} catch (error) {
return false;
}
}
function sortTranspositions(a, b) {
var length = b[0].length - a[0].length;
if (length !== 0) return length;
return a[0].toUpperCase().localeCompare(b[0].toUpperCase());
}
var transpositions = [
["APGL", "AGPL"],
["Gpl", "GPL"],
["GLP", "GPL"],
["APL", "Apache"],
["ISD", "ISC"],
["GLP", "GPL"],
["IST", "ISC"],
["Claude", "Clause"],
[" or later", "+"],
[" International", ""],
["GNU", "GPL"],
["GUN", "GPL"],
["+", ""],
["GNU GPL", "GPL"],
["GNU LGPL", "LGPL"],
["GNU/GPL", "GPL"],
["GNU GLP", "GPL"],
["GNU LESSER GENERAL PUBLIC LICENSE", "LGPL"],
["GNU Lesser General Public License", "LGPL"],
["GNU LESSER GENERAL PUBLIC LICENSE", "LGPL-2.1"],
["GNU Lesser General Public License", "LGPL-2.1"],
["LESSER GENERAL PUBLIC LICENSE", "LGPL"],
["Lesser General Public License", "LGPL"],
["LESSER GENERAL PUBLIC LICENSE", "LGPL-2.1"],
["Lesser General Public License", "LGPL-2.1"],
["GNU General Public License", "GPL"],
["Gnu public license", "GPL"],
["GNU Public License", "GPL"],
["GNU GENERAL PUBLIC LICENSE", "GPL"],
["MTI", "MIT"],
["Mozilla Public License", "MPL"],
["Universal Permissive License", "UPL"],
["WTH", "WTF"],
["WTFGPL", "WTFPL"],
["-License", ""]
].sort(sortTranspositions);
var TRANSPOSED = 0;
var CORRECT = 1;
var transforms = [
// e.g. 'mit'
function(argument) {
return argument.toUpperCase();
},
// e.g. 'MIT '
function(argument) {
return argument.trim();
},
// e.g. 'M.I.T.'
function(argument) {
return argument.replace(/\./g, "");
},
// e.g. 'Apache- 2.0'
function(argument) {
return argument.replace(/\s+/g, "");
},
// e.g. 'CC BY 4.0''
function(argument) {
return argument.replace(/\s+/g, "-");
},
// e.g. 'LGPLv2.1'
function(argument) {
return argument.replace("v", "-");
},
// e.g. 'Apache 2.0'
function(argument) {
return argument.replace(/,?\s*(\d)/, "-$1");
},
// e.g. 'GPL 2'
function(argument) {
return argument.replace(/,?\s*(\d)/, "-$1.0");
},
// e.g. 'Apache Version 2.0'
function(argument) {
return argument.replace(/,?\s*(V\.|v\.|V|v|Version|version)\s*(\d)/, "-$2");
},
// e.g. 'Apache Version 2'
function(argument) {
return argument.replace(/,?\s*(V\.|v\.|V|v|Version|version)\s*(\d)/, "-$2.0");
},
// e.g. 'ZLIB'
function(argument) {
return argument[0].toUpperCase() + argument.slice(1);
},
// e.g. 'MPL/2.0'
function(argument) {
return argument.replace("/", "-");
},
// e.g. 'Apache 2'
function(argument) {
return argument.replace(/\s*V\s*(\d)/, "-$1").replace(/(\d)$/, "$1.0");
},
// e.g. 'GPL-2.0', 'GPL-3.0'
function(argument) {
if (argument.indexOf("3.0") !== -1) {
return argument + "-or-later";
} else {
return argument + "-only";
}
},
// e.g. 'GPL-2.0-'
function(argument) {
return argument + "only";
},
// e.g. 'GPL2'
function(argument) {
return argument.replace(/(\d)$/, "-$1.0");
},
// e.g. 'BSD 3'
function(argument) {
return argument.replace(/(-| )?(\d)$/, "-$2-Clause");
},
// e.g. 'BSD clause 3'
function(argument) {
return argument.replace(/(-| )clause(-| )(\d)/, "-$3-Clause");
},
// e.g. 'New BSD license'
function(argument) {
return argument.replace(/\b(Modified|New|Revised)(-| )?BSD((-| )License)?/i, "BSD-3-Clause");
},
// e.g. 'Simplified BSD license'
function(argument) {
return argument.replace(/\bSimplified(-| )?BSD((-| )License)?/i, "BSD-2-Clause");
},
// e.g. 'Free BSD license'
function(argument) {
return argument.replace(/\b(Free|Net)(-| )?BSD((-| )License)?/i, "BSD-2-Clause-$1BSD");
},
// e.g. 'Clear BSD license'
function(argument) {
return argument.replace(/\bClear(-| )?BSD((-| )License)?/i, "BSD-3-Clause-Clear");
},
// e.g. 'Old BSD License'
function(argument) {
return argument.replace(/\b(Old|Original)(-| )?BSD((-| )License)?/i, "BSD-4-Clause");
},
// e.g. 'BY-NC-4.0'
function(argument) {
return "CC-" + argument;
},
// e.g. 'BY-NC'
function(argument) {
return "CC-" + argument + "-4.0";
},
// e.g. 'Attribution-NonCommercial'
function(argument) {
return argument.replace("Attribution", "BY").replace("NonCommercial", "NC").replace("NoDerivatives", "ND").replace(/ (\d)/, "-$1").replace(/ ?International/, "");
},
// e.g. 'Attribution-NonCommercial'
function(argument) {
return "CC-" + argument.replace("Attribution", "BY").replace("NonCommercial", "NC").replace("NoDerivatives", "ND").replace(/ (\d)/, "-$1").replace(/ ?International/, "") + "-4.0";
}
];
var licensesWithVersions = spdxLicenseIds.map(function(id) {
var match = /^(.*)-\d+\.\d+$/.exec(id);
return match ? [match[0], match[1]] : [id, null];
}).reduce(function(objectMap, item) {
var key = item[1];
objectMap[key] = objectMap[key] || [];
objectMap[key].push(item[0]);
return objectMap;
}, {});
var licensesWithOneVersion = Object.keys(licensesWithVersions).map(function makeEntries(key) {
return [key, licensesWithVersions[key]];
}).filter(function identifySoleVersions(item) {
return (
// Licenses has just one valid version suffix.
item[1].length === 1 && item[0] !== null && // APL will be considered Apache, rather than APL-1.0
item[0] !== "APL"
);
}).map(function createLastResorts(item) {
return [item[0], item[1][0]];
});
licensesWithVersions = void 0;
var lastResorts = [
["UNLI", "Unlicense"],
["WTF", "WTFPL"],
["2 CLAUSE", "BSD-2-Clause"],
["2-CLAUSE", "BSD-2-Clause"],
["3 CLAUSE", "BSD-3-Clause"],
["3-CLAUSE", "BSD-3-Clause"],
["AFFERO", "AGPL-3.0-or-later"],
["AGPL", "AGPL-3.0-or-later"],
["APACHE", "Apache-2.0"],
["ARTISTIC", "Artistic-2.0"],
["Affero", "AGPL-3.0-or-later"],
["BEER", "Beerware"],
["BOOST", "BSL-1.0"],
["BSD", "BSD-2-Clause"],
["CDDL", "CDDL-1.1"],
["ECLIPSE", "EPL-1.0"],
["FUCK", "WTFPL"],
["GNU", "GPL-3.0-or-later"],
["LGPL", "LGPL-3.0-or-later"],
["GPLV1", "GPL-1.0-only"],
["GPL-1", "GPL-1.0-only"],
["GPLV2", "GPL-2.0-only"],
["GPL-2", "GPL-2.0-only"],
["GPL", "GPL-3.0-or-later"],
["MIT +NO-FALSE-ATTRIBS", "MITNFA"],
["MIT", "MIT"],
["MPL", "MPL-2.0"],
["X11", "X11"],
["ZLIB", "Zlib"]
].concat(licensesWithOneVersion).sort(sortTranspositions);
var SUBSTRING = 0;
var IDENTIFIER = 1;
var validTransformation = function(identifier) {
for (var i = 0; i < transforms.length; i++) {
var transformed = transforms[i](identifier).trim();
if (transformed !== identifier && valid(transformed)) {
return transformed;
}
}
return null;
};
var validLastResort = function(identifier) {
var upperCased = identifier.toUpperCase();
for (var i = 0; i < lastResorts.length; i++) {
var lastResort = lastResorts[i];
if (upperCased.indexOf(lastResort[SUBSTRING]) > -1) {
return lastResort[IDENTIFIER];
}
}
return null;
};
var anyCorrection = function(identifier, check) {
for (var i = 0; i < transpositions.length; i++) {
var transposition = transpositions[i];
var transposed = transposition[TRANSPOSED];
if (identifier.indexOf(transposed) > -1) {
var corrected = identifier.replace(
transposed,
transposition[CORRECT]
);
var checked = check(corrected);
if (checked !== null) {
return checked;
}
}
}
return null;
};
module.exports = function(identifier, options) {
options = options || {};
var upgrade = options.upgrade === void 0 ? true : !!options.upgrade;
function postprocess(value) {
return upgrade ? upgradeGPLs(value) : value;
}
var validArugment = typeof identifier === "string" && identifier.trim().length !== 0;
if (!validArugment) {
throw Error("Invalid argument. Expected non-empty string.");
}
identifier = identifier.trim();
if (valid(identifier)) {
return postprocess(identifier);
}
var noPlus = identifier.replace(/\+$/, "").trim();
if (valid(noPlus)) {
return postprocess(noPlus);
}
var transformed = validTransformation(identifier);
if (transformed !== null) {
return postprocess(transformed);
}
transformed = anyCorrection(identifier, function(argument) {
if (valid(argument)) {
return argument;
}
return validTransformation(argument);
});
if (transformed !== null) {
return postprocess(transformed);
}
transformed = validLastResort(identifier);
if (transformed !== null) {
return postprocess(transformed);
}
transformed = anyCorrection(identifier, validLastResort);
if (transformed !== null) {
return postprocess(transformed);
}
return null;
};
function upgradeGPLs(value) {
if ([
"GPL-1.0",
"LGPL-1.0",
"AGPL-1.0",
"GPL-2.0",
"LGPL-2.0",
"AGPL-2.0",
"LGPL-2.1"
].indexOf(value) !== -1) {
return value + "-only";
} else if ([
"GPL-1.0+",
"GPL-2.0+",
"GPL-3.0+",
"LGPL-2.0+",
"LGPL-2.1+",
"LGPL-3.0+",
"AGPL-1.0+",
"AGPL-3.0+"
].indexOf(value) !== -1) {
return value.replace(/\+$/, "-or-later");
} else if (["GPL-3.0", "LGPL-3.0", "AGPL-3.0"].indexOf(value) !== -1) {
return value + "-or-later";
} else {
return value;
}
}
}
});
// ../../../../../setup-pnpm/store/v11/links/@/validate-npm-package-license/3.0.4/466259839a12a11f6ca41519344d55ce17ba84da7a5fa9cc69549b01d3f991f7/node_modules/validate-npm-package-license/index.js
var require_validate_npm_package_license = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/validate-npm-package-license/3.0.4/466259839a12a11f6ca41519344d55ce17ba84da7a5fa9cc69549b01d3f991f7/node_modules/validate-npm-package-license/index.js"(exports, module) {
var parse2 = require_spdx_expression_parse();
var correct = require_spdx_correct();
var genericWarning = 'license should be a valid SPDX license expression (without "LicenseRef"), "UNLICENSED", or "SEE LICENSE IN <filename>"';
var fileReferenceRE = /^SEE LICEN[CS]E IN (.+)$/;
function startsWith(prefix, string) {
return string.slice(0, prefix.length) === prefix;
}
function usesLicenseRef(ast) {
if (ast.hasOwnProperty("license")) {
var license = ast.license;
return startsWith("LicenseRef", license) || startsWith("DocumentRef", license);
} else {
return usesLicenseRef(ast.left) || usesLicenseRef(ast.right);
}
}
module.exports = function(argument) {
var ast;
try {
ast = parse2(argument);
} catch (e) {
var match;
if (argument === "UNLICENSED" || argument === "UNLICENCED") {
return {
validForOldPackages: true,
validForNewPackages: true,
unlicensed: true
};
} else if (match = fileReferenceRE.exec(argument)) {
return {
validForOldPackages: true,
validForNewPackages: true,
inFile: match[1]
};
} else {
var result = {
validForOldPackages: false,
validForNewPackages: false,
warnings: [genericWarning]
};
if (argument.trim().length !== 0) {
var corrected = correct(argument);
if (corrected) {
result.warnings.push(
'license is similar to the valid expression "' + corrected + '"'
);
}
}
return result;
}
}
if (usesLicenseRef(ast)) {
return {
validForNewPackages: false,
validForOldPackages: false,
spdx: true,
warnings: [genericWarning]
};
} else {
return {
validForNewPackages: true,
validForOldPackages: true,
spdx: true
};
}
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/lru-cache/11.5.3/5f933852b2037e33252208b4fa114552d3422c97eca48d9d18f9ecabf26b3c0c/node_modules/lru-cache/dist/commonjs/node/index.min.js
var require_index_min = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/lru-cache/11.5.3/5f933852b2037e33252208b4fa114552d3422c97eca48d9d18f9ecabf26b3c0c/node_modules/lru-cache/dist/commonjs/node/index.min.js"(exports) {
"use strict";
var j = (u, t) => () => (t || u((t = { exports: {} }).exports, t), t.exports);
var I = j((O) => {
"use strict";
Object.defineProperty(O, "__esModule", { value: true });
O.tracing = O.metrics = void 0;
var U = __require("node:diagnostics_channel");
O.metrics = (0, U.channel)("lru-cache:metrics");
O.tracing = (0, U.tracingChannel)("lru-cache");
});
var P = j((R) => {
"use strict";
Object.defineProperty(R, "__esModule", { value: true });
R.defaultPerf = void 0;
R.defaultPerf = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date;
});
Object.defineProperty(exports, "__esModule", { value: true });
exports.LRUCache = void 0;
var g = I();
var N = P();
var C = () => g.metrics.hasSubscribers || g.tracing.hasSubscribers;
var k = /* @__PURE__ */ new Set();
var G = typeof process == "object" && process ? process : {};
var V = (u, t, e, i) => {
typeof G.emitWarning == "function" ? G.emitWarning(u, t, e, i) : console.error(`[${e}] ${t}: ${u}`);
};
var q = (u) => !k.has(u);
var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u);
var H = (u) => T(u) ? u <= Math.pow(2, 8) ? Uint8Array : u <= Math.pow(2, 16) ? Uint16Array : u <= Math.pow(2, 32) ? Uint32Array : u <= Number.MAX_SAFE_INTEGER ? W : null : null;
var W = class extends Array {
constructor(t) {
super(t), this.fill(0);
}
};
var L = class u {
heap;
length;
static #o = false;
static create(t) {
let e = H(t);
if (!e) return [];
u.#o = true;
let i = new u(t, e);
return u.#o = false, i;
}
constructor(t, e) {
if (!u.#o) throw new TypeError("instantiate Stack using Stack.create(n)");
this.heap = new e(t), this.length = 0;
}
push(t) {
this.heap[this.length++] = t;
}
pop() {
return this.heap[--this.length];
}
};
var M = class u {
#o;
#c;
#m;
#W;
#S;
#x;
#j;
#w;
get perf() {
return this.#w;
}
ttl;
ttlResolution;
ttlAutopurge;
updateAgeOnGet;
updateAgeOnHas;
allowStale;
noDisposeOnSet;
noUpdateTTL;
maxEntrySize;
sizeCalculation;
noDeleteOnFetchRejection;
noDeleteOnStaleGet;
allowStaleOnFetchAbort;
allowStaleOnFetchRejection;
ignoreFetchAbort;
backgroundFetchSize;
#n;
#b;
#s;
#i;
#t;
#l;
#u;
#a;
#h;
#_;
#r;
#y;
#F;
#d;
#g;
#T;
#U;
#f;
#R;
static unsafeExposeInternals(t) {
return { starts: t.#F, ttls: t.#d, autopurgeTimers: t.#g, sizes: t.#y, keyMap: t.#s, keyList: t.#i, valList: t.#t, next: t.#l, prev: t.#u, get head() {
return t.#a;
}, get tail() {
return t.#h;
}, free: t.#_, isBackgroundFetch: (e) => t.#e(e), backgroundFetch: (e, i, s, n) => t.#G(e, i, s, n), moveToTail: (e) => t.#M(e), indexes: (e) => t.#A(e), rindexes: (e) => t.#z(e), isStale: (e) => t.#p(e) };
}
get max() {
return this.#o;
}
get maxSize() {
return this.#c;
}
get calculatedSize() {
return this.#b;
}
get size() {
return this.#n;
}
get fetchMethod() {
return this.#x;
}
get memoMethod() {
return this.#j;
}
get dispose() {
return this.#m;
}
get onInsert() {
return this.#W;
}
get disposeAfter() {
return this.#S;
}
constructor(t) {
let { max: e = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: o, updateAgeOnHas: l, allowStale: h, dispose: r, onInsert: c, disposeAfter: w, noDisposeOnSet: y, noUpdateTTL: d, maxSize: p = 0, maxEntrySize: f = 0, sizeCalculation: _, fetchMethod: a, memoMethod: S, noDeleteOnFetchRejection: F, noDeleteOnStaleGet: b, allowStaleOnFetchRejection: m, allowStaleOnFetchAbort: A, ignoreFetchAbort: z, backgroundFetchSize: x = 1, perf: v } = t;
if (this.backgroundFetchSize = x, v !== void 0 && typeof v?.now != "function") throw new TypeError("perf option must have a now() method if specified");
if (this.#w = v ?? N.defaultPerf, e !== 0 && !T(e)) throw new TypeError("max option must be a nonnegative integer");
let E = e ? H(e) : Array;
if (!E) throw new Error("invalid max value: " + e);
if (this.#o = e, this.#c = p, this.maxEntrySize = f || this.#c, this.sizeCalculation = _, this.sizeCalculation) {
if (!this.#c && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
if (typeof this.sizeCalculation != "function") throw new TypeError("sizeCalculation set to non-function");
}
if (S !== void 0 && typeof S != "function") throw new TypeError("memoMethod must be a function if defined");
if (this.#j = S, a !== void 0 && typeof a != "function") throw new TypeError("fetchMethod must be a function if specified");
if (this.#x = a, this.#U = !!a, this.#s = /* @__PURE__ */ new Map(), this.#i = Array.from({ length: e }).fill(void 0), this.#t = Array.from({ length: e }).fill(void 0), this.#l = new E(e), this.#u = new E(e), this.#a = 0, this.#h = 0, this.#_ = L.create(e), this.#n = 0, this.#b = 0, typeof r == "function" && (this.#m = r), typeof c == "function" && (this.#W = c), typeof w == "function" ? (this.#S = w, this.#r = []) : (this.#S = void 0, this.#r = void 0), this.#T = !!this.#m, this.#R = !!this.#W, this.#f = !!this.#S, this.noDisposeOnSet = !!y, this.noUpdateTTL = !!d, this.noDeleteOnFetchRejection = !!F, this.allowStaleOnFetchRejection = !!m, this.allowStaleOnFetchAbort = !!A, this.ignoreFetchAbort = !!z, this.maxEntrySize !== 0) {
if (this.#c !== 0 && !T(this.#c)) throw new TypeError("maxSize must be a positive integer if specified");
if (!T(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
this.#X();
}
if (this.allowStale = !!h, this.noDeleteOnStaleGet = !!b, this.updateAgeOnGet = !!o, this.updateAgeOnHas = !!l, this.ttlResolution = T(s) || s === 0 ? s : 1, this.ttlAutopurge = !!n, this.ttl = i || 0, this.ttl) {
if (!T(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
this.#k();
}
if (this.#o === 0 && this.ttl === 0 && this.#c === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
if (!this.ttlAutopurge && !this.#o && !this.#c) {
let D = "LRU_CACHE_UNBOUNDED";
q(D) && (k.add(D), V("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", D, u));
}
}
getRemainingTTL(t) {
return this.#s.has(t) ? 1 / 0 : 0;
}
#k() {
let t = new W(this.#o), e = new W(this.#o);
this.#d = t, this.#F = e;
let i = this.ttlAutopurge ? Array.from({ length: this.#o }) : void 0;
this.#g = i, this.#H = (h, r, c = this.#w.now()) => {
e[h] = r !== 0 ? c : 0, t[h] = r, s(h, r);
}, this.#D = (h) => {
e[h] = t[h] !== 0 ? this.#w.now() : 0, s(h, t[h]);
};
let s = this.ttlAutopurge ? (h, r) => {
if (i?.[h] && (clearTimeout(i[h]), i[h] = void 0), r && r !== 0 && i) {
let c = setTimeout(() => {
this.#p(h) ? (this.#v(this.#i[h], "expire"), i[h] = void 0) : s(h, l(h));
}, r + 1);
c.unref && c.unref(), i[h] = c;
}
} : () => {
};
this.#E = (h, r) => {
if (t[r]) {
let c = t[r], w = e[r];
if (!c || !w) return;
h.ttl = c, h.start = w, h.now = n || o();
let y = h.now - w;
h.remainingTTL = c - y;
}
};
let n = 0, o = () => {
let h = this.#w.now();
if (this.ttlResolution > 0) {
n = h;
let r = setTimeout(() => n = 0, this.ttlResolution);
r.unref && r.unref();
}
return h;
};
this.getRemainingTTL = (h) => {
let r = this.#s.get(h);
return r === void 0 ? 0 : l(r);
};
let l = (h) => {
let r = t[h], c = e[h];
if (!r || !c) return 1 / 0;
let w = (n || o()) - c;
return r - w;
};
this.#p = (h) => {
let r = e[h], c = t[h];
return !!c && !!r && (n || o()) - r > c;
};
}
#D = () => {
};
#E = () => {
};
#H = () => {
};
#p = () => false;
#X() {
let t = new W(this.#o);
this.#b = 0, this.#y = t, this.#C = (e) => {
this.#b -= t[e], t[e] = 0;
}, this.#N = (e, i, s, n) => {
if (!T(s)) {
if (this.#e(i)) return this.backgroundFetchSize;
if (n) {
if (typeof n != "function") throw new TypeError("sizeCalculation must be a function");
if (s = n(i, e), !T(s)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
} else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
}
return s;
}, this.#I = (e, i, s) => {
if (t[e] = i, this.#c) {
let n = this.#c - t[e];
for (; this.#b > n; ) this.#P(true);
}
this.#b += t[e], s && (s.entrySize = i, s.totalCalculatedSize = this.#b);
};
}
#C = (t) => {
};
#I = (t, e, i) => {
};
#N = (t, e, i, s) => {
if (i || s) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
return 0;
};
*#A({ allowStale: t = this.allowStale } = {}) {
if (this.#n) for (let e = this.#h; this.#V(e) && ((t || !this.#p(e)) && (yield e), e !== this.#a); ) e = this.#u[e];
}
*#z({ allowStale: t = this.allowStale } = {}) {
if (this.#n) for (let e = this.#a; this.#V(e) && ((t || !this.#p(e)) && (yield e), e !== this.#h); ) e = this.#l[e];
}
#V(t) {
return t !== void 0 && this.#s.get(this.#i[t]) === t;
}
*entries() {
for (let t of this.#A()) this.#t[t] !== void 0 && this.#i[t] !== void 0 && !this.#e(this.#t[t]) && (yield [this.#i[t], this.#t[t]]);
}
*rentries() {
for (let t of this.#z()) this.#t[t] !== void 0 && this.#i[t] !== void 0 && !this.#e(this.#t[t]) && (yield [this.#i[t], this.#t[t]]);
}
*keys() {
for (let t of this.#A()) {
let e = this.#i[t];
e !== void 0 && !this.#e(this.#t[t]) && (yield e);
}
}
*rkeys() {
for (let t of this.#z()) {
let e = this.#i[t];
e !== void 0 && !this.#e(this.#t[t]) && (yield e);
}
}
*values() {
for (let t of this.#A()) this.#t[t] !== void 0 && !this.#e(this.#t[t]) && (yield this.#t[t]);
}
*rvalues() {
for (let t of this.#z()) this.#t[t] !== void 0 && !this.#e(this.#t[t]) && (yield this.#t[t]);
}
[Symbol.iterator]() {
return this.entries();
}
[Symbol.toStringTag] = "LRUCache";
find(t, e = {}) {
for (let i of this.#A()) {
let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
if (n !== void 0 && t(n, this.#i[i], this)) return this.#L(this.#i[i], e);
}
}
forEach(t, e = this) {
for (let i of this.#A()) {
let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
n !== void 0 && t.call(e, n, this.#i[i], this);
}
}
rforEach(t, e = this) {
for (let i of this.#z()) {
let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
n !== void 0 && t.call(e, n, this.#i[i], this);
}
}
purgeStale() {
let t = false;
for (let e of this.#z({ allowStale: true })) this.#p(e) && (this.#v(this.#i[e], "expire"), t = true);
return t;
}
info(t) {
let e = this.#s.get(t);
if (e === void 0) return;
let i = this.#t[e], s = this.#e(i) ? i.__staleWhileFetching : i;
if (s === void 0) return;
let n = { value: s };
if (this.#d && this.#F) {
let o = this.#d[e], l = this.#F[e];
if (o && l) {
let h = o - (this.#w.now() - l);
n.ttl = h, n.start = Date.now();
}
}
return this.#y && (n.size = this.#y[e]), n;
}
dump() {
let t = [];
for (let e of this.#A({ allowStale: true })) {
let i = this.#i[e], s = this.#t[e], n = this.#e(s) ? s.__staleWhileFetching : s;
if (n === void 0 || i === void 0) continue;
let o = { value: n };
if (this.#d && this.#F) {
o.ttl = this.#d[e];
let l = this.#w.now() - this.#F[e];
o.start = Math.floor(Date.now() - l);
}
this.#y && (o.size = this.#y[e]), t.unshift([i, o]);
}
return t;
}
load(t) {
this.clear();
for (let [e, i] of t) {
if (i.start) {
let s = Date.now() - i.start;
i.start = this.#w.now() - s;
}
this.#O(e, i.value, i);
}
}
set(t, e, i = {}) {
let { status: s = g.metrics.hasSubscribers ? {} : void 0 } = i;
i.status = s, s && (s.op = "set", s.key = t, e !== void 0 && (s.value = e), s.cache = this);
let n = this.#O(t, e, i);
return s && g.metrics.hasSubscribers && g.metrics.publish(s), n;
}
#O(t, e, i, s) {
let { ttl: n = this.ttl, start: o, noDisposeOnSet: l = this.noDisposeOnSet, sizeCalculation: h = this.sizeCalculation, status: r } = i, c = this.#e(e);
if (e === void 0) return r && (r.set = "deleted"), this.delete(t), this;
let { noUpdateTTL: w = this.noUpdateTTL } = i;
r && !c && (r.value = e);
let y = this.#N(t, e, i.size || 0, h, r);
if (this.maxEntrySize && y > this.maxEntrySize) return this.#v(t, "set"), r && (r.set = "miss", r.maxEntrySizeExceeded = true), this;
let d = this.#n === 0 ? void 0 : this.#s.get(t);
if (d === void 0) d = this.#n === 0 ? this.#h : this.#_.length !== 0 ? this.#_.pop() : this.#n === this.#o ? this.#P(false) : this.#n, this.#i[d] = t, this.#t[d] = e, this.#s.set(t, d), this.#l[this.#h] = d, this.#u[d] = this.#h, this.#h = d, this.#n++, this.#I(d, y, r), r && (r.set = "add"), w = false, this.#R && !c && this.#W?.(e, t, "add");
else {
this.#M(d);
let p = this.#t[d];
if (e !== p) {
if (!l) if (this.#e(p)) {
p !== s && p.__abortController.abort(new Error("replaced"));
let { __staleWhileFetching: f } = p;
f !== void 0 && f !== e && (this.#T && this.#m?.(f, t, "set"), this.#f && this.#r?.push([f, t, "set"]));
} else this.#T && this.#m?.(p, t, "set"), this.#f && this.#r?.push([p, t, "set"]);
if (this.#C(d), this.#I(d, y, r), this.#t[d] = e, !c) {
let f = p && this.#e(p) ? p.__staleWhileFetching : p, _ = f === void 0 ? "add" : e !== f ? "replace" : "update";
r && (r.set = _, f !== void 0 && (r.oldValue = f)), this.#R && this.onInsert?.(e, t, _);
}
} else c || (r && (r.set = "update"), this.#R && this.onInsert?.(e, t, "update"));
}
if (n !== 0 && !this.#d && this.#k(), this.#d && (w || this.#H(d, n, o), r && this.#E(r, d)), !l && this.#f && this.#r) {
let p = this.#r, f;
for (; f = p?.shift(); ) this.#S?.(...f);
}
return this;
}
pop() {
try {
for (; this.#n; ) {
let t = this.#t[this.#a];
if (this.#P(true), this.#e(t)) {
if (t.__staleWhileFetching) return t.__staleWhileFetching;
} else if (t !== void 0) return t;
}
} finally {
if (this.#f && this.#r) {
let t = this.#r, e;
for (; e = t?.shift(); ) this.#S?.(...e);
}
}
}
#P(t) {
let e = this.#a, i = this.#i[e], s = this.#t[e], n = this.#e(s);
n && s.__abortController.abort(new Error("evicted"));
let o = n ? s.__staleWhileFetching : s;
return (this.#T || this.#f) && o !== void 0 && (this.#T && this.#m?.(o, i, "evict"), this.#f && this.#r?.push([o, i, "evict"])), this.#C(e), this.#g?.[e] && (clearTimeout(this.#g[e]), this.#g[e] = void 0), t && (this.#i[e] = void 0, this.#t[e] = void 0, this.#_.push(e)), this.#n === 1 ? (this.#a = this.#h = 0, this.#_.length = 0) : this.#a = this.#l[e], this.#s.delete(i), this.#n--, e;
}
has(t, e = {}) {
let { status: i = g.metrics.hasSubscribers ? {} : void 0 } = e;
e.status = i, i && (i.op = "has", i.key = t, i.cache = this);
let s = this.#Y(t, e);
return g.metrics.hasSubscribers && g.metrics.publish(i), s;
}
#Y(t, e = {}) {
let { updateAgeOnHas: i = this.updateAgeOnHas, status: s } = e, n = this.#s.get(t);
if (n !== void 0) {
let o = this.#t[n];
if (this.#e(o) && o.__staleWhileFetching === void 0) return false;
if (this.#p(n)) s && (s.has = "stale", this.#E(s, n));
else return i && this.#D(n), s && (s.has = "hit", this.#E(s, n)), true;
} else s && (s.has = "miss");
return false;
}
peek(t, e = {}) {
let { status: i = C() ? {} : void 0 } = e;
i && (i.op = "peek", i.key = t, i.cache = this), e.status = i;
let s = this.#J(t, e);
return g.metrics.hasSubscribers && g.metrics.publish(i), s;
}
#J(t, e) {
let { status: i, allowStale: s = this.allowStale } = e, n = this.#s.get(t);
if (n === void 0 || !s && this.#p(n)) {
i && (i.peek = n === void 0 ? "miss" : "stale");
return;
}
let o = this.#t[n], l = this.#e(o) ? o.__staleWhileFetching : o;
return i && (l !== void 0 ? (i.peek = "hit", i.value = l) : i.peek = "miss"), l;
}
#G(t, e, i, s) {
let n = e === void 0 ? void 0 : this.#t[e];
if (this.#e(n)) return n;
let o = new AbortController(), { signal: l } = i;
l?.addEventListener("abort", () => o.abort(l.reason), { signal: o.signal });
let h = { signal: o.signal, options: i, context: s }, r = (f, _ = false) => {
let { aborted: a } = o.signal, S = i.ignoreFetchAbort && f !== void 0, F = i.ignoreFetchAbort || !!(i.allowStaleOnFetchAbort && f !== void 0);
if (i.status && (a && !_ ? (i.status.fetchAborted = true, i.status.fetchError = o.signal.reason, S && (i.status.fetchAbortIgnored = true)) : i.status.fetchResolved = true), a && !S && !_) return w(o.signal.reason, F);
let b = d, m = this.#t[e];
return (m === d || m === void 0 && S && _) && (f === void 0 ? b.__staleWhileFetching !== void 0 ? this.#t[e] = b.__staleWhileFetching : this.#v(t, "fetch") : (i.status && (i.status.fetchUpdated = true), this.#O(t, f, h.options, b))), f;
}, c = (f) => (i.status && (i.status.fetchRejected = true, i.status.fetchError = f), w(f, false)), w = (f, _) => {
let { aborted: a } = o.signal, S = a && i.allowStaleOnFetchAbort, F = S || i.allowStaleOnFetchRejection, b = F || i.noDeleteOnFetchRejection, m = d;
if (this.#t[e] === d && (!b || !_ && m.__staleWhileFetching === void 0 ? this.#v(t, "fetch") : S || (this.#t[e] = m.__staleWhileFetching)), F) return i.status && m.__staleWhileFetching !== void 0 && (i.status.returnedStale = true), m.__staleWhileFetching;
if (m.__returned === m) throw f;
}, y = (f, _) => {
let a = this.#x?.(t, n, h);
o.signal.addEventListener("abort", () => {
(!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) && (f(void 0), i.allowStaleOnFetchAbort && (f = (S) => r(S, true)));
}), a && a instanceof Promise ? a.then((S) => f(S === void 0 ? void 0 : S), _) : a !== void 0 && f(a);
};
i.status && (i.status.fetchDispatched = true);
let d = new Promise(y).then(r, c), p = Object.assign(d, { __abortController: o, __staleWhileFetching: n, __returned: void 0 });
return e === void 0 ? (this.#O(t, p, { ...h.options, status: void 0 }), e = this.#s.get(t)) : this.#t[e] = p, p;
}
#e(t) {
if (!this.#U) return false;
let e = t;
return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof AbortController;
}
fetch(t, e = {}) {
let i = g.tracing.hasSubscribers, { status: s = C() ? {} : void 0 } = e;
e.status = s, s && e.context && (s.context = e.context);
let n = this.#q(t, e);
return s && i && (s.trace = true, g.tracing.tracePromise(() => n, s).catch(() => {
})), n;
}
async #q(t, e = {}) {
let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: o = this.ttl, noDisposeOnSet: l = this.noDisposeOnSet, size: h = 0, sizeCalculation: r = this.sizeCalculation, noUpdateTTL: c = this.noUpdateTTL, noDeleteOnFetchRejection: w = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: y = this.allowStaleOnFetchRejection, ignoreFetchAbort: d = this.ignoreFetchAbort, allowStaleOnFetchAbort: p = this.allowStaleOnFetchAbort, context: f, forceRefresh: _ = false, status: a, signal: S } = e;
if (a && (a.op = "fetch", a.key = t, _ && (a.forceRefresh = true), a.cache = this), !this.#U) return a && (a.fetch = "get"), this.#L(t, { allowStale: i, updateAgeOnGet: s, noDeleteOnStaleGet: n, status: a });
let F = { allowStale: i, updateAgeOnGet: s, noDeleteOnStaleGet: n, ttl: o, noDisposeOnSet: l, size: h, sizeCalculation: r, noUpdateTTL: c, noDeleteOnFetchRejection: w, allowStaleOnFetchRejection: y, allowStaleOnFetchAbort: p, ignoreFetchAbort: d, status: a, signal: S }, b = this.#s.get(t);
if (b === void 0) {
a && (a.fetch = "miss");
let m = this.#G(t, b, F, f);
return m.__returned = m;
} else {
let m = this.#t[b];
if (this.#e(m)) {
let E = i && m.__staleWhileFetching !== void 0;
return a && (a.fetch = "inflight", E && (a.returnedStale = true)), E ? m.__staleWhileFetching : m.__returned = m;
}
let A = this.#p(b);
if (!_ && !A) return a && (a.fetch = "hit"), this.#M(b), s && this.#D(b), a && this.#E(a, b), m;
let z = this.#G(t, b, F, f), v = z.__staleWhileFetching !== void 0 && i;
return a && (a.fetch = A ? "stale" : "refresh", v && A && (a.returnedStale = true)), v ? z.__staleWhileFetching : z.__returned = z;
}
}
forceFetch(t, e = {}) {
let i = g.tracing.hasSubscribers, { status: s = C() ? {} : void 0 } = e;
e.status = s, s && e.context && (s.context = e.context);
let n = this.#K(t, e);
return s && i && (s.trace = true, g.tracing.tracePromise(() => n, s).catch(() => {
})), n;
}
async #K(t, e = {}) {
let i = await this.#q(t, e);
if (i === void 0) throw new Error("fetch() returned undefined");
return i;
}
memo(t, e = {}) {
let { status: i = g.metrics.hasSubscribers ? {} : void 0 } = e;
e.status = i, i && (i.op = "memo", i.key = t, e.context && (i.context = e.context), i.cache = this);
let s = this.#Q(t, e);
return i && (i.value = s), g.metrics.hasSubscribers && g.metrics.publish(i), s;
}
#Q(t, e = {}) {
let i = this.#j;
if (!i) throw new Error("no memoMethod provided to constructor");
let { context: s, status: n, forceRefresh: o, ...l } = e;
n && o && (n.forceRefresh = true);
let h = this.#L(t, l), r = o || h === void 0;
if (n && (n.memo = r ? "miss" : "hit", r || (n.value = h)), !r) return h;
let c = i(t, h, { options: l, context: s });
return n && (n.value = c), this.#O(t, c, l), c;
}
get(t, e = {}) {
let { status: i = g.metrics.hasSubscribers ? {} : void 0 } = e;
e.status = i, i && (i.op = "get", i.key = t, i.cache = this);
let s = this.#L(t, e);
return i && (s !== void 0 && (i.value = s), g.metrics.hasSubscribers && g.metrics.publish(i)), s;
}
#L(t, e = {}) {
let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: o } = e, l = this.#s.get(t);
if (l === void 0) {
o && (o.get = "miss");
return;
}
let h = this.#t[l], r = this.#e(h);
return o && this.#E(o, l), this.#p(l) ? r ? (o && (o.get = "stale-fetching"), i && h.__staleWhileFetching !== void 0 ? (o && (o.returnedStale = true), h.__staleWhileFetching) : void 0) : (n || this.#v(t, "expire"), o && (o.get = "stale"), i ? (o && (o.returnedStale = true), h) : void 0) : (o && (o.get = r ? "fetching" : "hit"), this.#M(l), s && this.#D(l), r ? h.__staleWhileFetching : h);
}
#B(t, e) {
this.#u[e] = t, this.#l[t] = e;
}
#M(t) {
t !== this.#h && (t === this.#a ? this.#a = this.#l[t] : this.#B(this.#u[t], this.#l[t]), this.#B(this.#h, t), this.#h = t);
}
delete(t) {
return this.#v(t, "delete");
}
#v(t, e) {
g.metrics.hasSubscribers && g.metrics.publish({ op: "delete", delete: e, key: t, cache: this });
let i = false;
if (this.#n !== 0) {
let s = this.#s.get(t);
if (s !== void 0) if (this.#g?.[s] && (clearTimeout(this.#g[s]), this.#g[s] = void 0), i = true, this.#n === 1) this.#$(e);
else {
this.#C(s);
let n = this.#t[s];
if (this.#e(n) ? n.__abortController.abort(new Error("deleted")) : (this.#T || this.#f) && (this.#T && this.#m?.(n, t, e), this.#f && this.#r?.push([n, t, e])), this.#s.delete(t), this.#i[s] = void 0, this.#t[s] = void 0, s === this.#h) this.#h = this.#u[s];
else if (s === this.#a) this.#a = this.#l[s];
else {
let o = this.#u[s];
this.#l[o] = this.#l[s];
let l = this.#l[s];
this.#u[l] = this.#u[s];
}
this.#n--, this.#_.push(s);
}
}
if (this.#f && this.#r?.length) {
let s = this.#r, n;
for (; n = s?.shift(); ) this.#S?.(...n);
}
return i;
}
clear() {
return this.#$("delete");
}
#$(t) {
for (let e of this.#z({ allowStale: true })) {
let i = this.#t[e];
if (this.#e(i)) i.__abortController.abort(new Error("deleted"));
else {
let s = this.#i[e];
this.#T && this.#m?.(i, s, t), this.#f && this.#r?.push([i, s, t]);
}
}
if (this.#s.clear(), this.#t.fill(void 0), this.#i.fill(void 0), this.#d && this.#F) {
this.#d.fill(0), this.#F.fill(0);
for (let e of this.#g ?? []) e !== void 0 && clearTimeout(e);
this.#g?.fill(void 0);
}
if (this.#y && this.#y.fill(0), this.#a = 0, this.#h = 0, this.#_.length = 0, this.#b = 0, this.#n = 0, this.#f && this.#r) {
let e = this.#r, i;
for (; i = e?.shift(); ) this.#S?.(...i);
}
}
};
exports.LRUCache = M;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/hosted-git-info/9.0.3/7b58ba3564ceb22d838cd41eebbaf67922270f6295431dafd0b4acc1e9140ab9/node_modules/hosted-git-info/lib/hosts.js
var require_hosts = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/hosted-git-info/9.0.3/7b58ba3564ceb22d838cd41eebbaf67922270f6295431dafd0b4acc1e9140ab9/node_modules/hosted-git-info/lib/hosts.js"(exports, module) {
"use strict";
var maybeJoin = (...args) => args.every((arg) => arg) ? args.join("") : "";
var maybeEncode = (arg) => arg ? encodeURIComponent(arg) : "";
var formatHashFragment = (f) => f.toLowerCase().replace(/^\W+/g, "").replace(/(?<!\W)\W+$/, "").replace(/\//g, "").replace(/\W+/g, "-");
var defaults = {
sshtemplate: ({ domain, user, project, committish }) => `git@${domain}:${user}/${project}.git${maybeJoin("#", committish)}`,
sshurltemplate: ({ domain, user, project, committish }) => `git+ssh://git@${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
edittemplate: ({ domain, user, project, committish, editpath, path: path31 }) => `https://${domain}/${user}/${project}${maybeJoin("/", editpath, "/", maybeEncode(committish || "HEAD"), "/", path31)}`,
browsetemplate: ({ domain, user, project, committish, treepath }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish))}`,
browsetreetemplate: ({ domain, user, project, committish, treepath, path: path31, fragment, hashformat }) => `https://${domain}/${user}/${project}/${treepath}/${maybeEncode(committish || "HEAD")}/${path31}${maybeJoin("#", hashformat(fragment || ""))}`,
browseblobtemplate: ({ domain, user, project, committish, blobpath, path: path31, fragment, hashformat }) => `https://${domain}/${user}/${project}/${blobpath}/${maybeEncode(committish || "HEAD")}/${path31}${maybeJoin("#", hashformat(fragment || ""))}`,
docstemplate: ({ domain, user, project, treepath, committish }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish))}#readme`,
httpstemplate: ({ auth, domain, user, project, committish }) => `git+https://${maybeJoin(auth, "@")}${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
filetemplate: ({ domain, user, project, committish, path: path31 }) => `https://${domain}/${user}/${project}/raw/${maybeEncode(committish || "HEAD")}/${path31}`,
shortcuttemplate: ({ type, user, project, committish }) => `${type}:${user}/${project}${maybeJoin("#", committish)}`,
pathtemplate: ({ user, project, committish }) => `${user}/${project}${maybeJoin("#", committish)}`,
bugstemplate: ({ domain, user, project }) => `https://${domain}/${user}/${project}/issues`,
hashformat: formatHashFragment
};
var hosts = {};
hosts.github = {
// First two are insecure and generally shouldn't be used any more, but
// they are still supported.
protocols: ["git:", "http:", "git+ssh:", "git+https:", "ssh:", "https:"],
domain: "github.com",
treepath: "tree",
blobpath: "blob",
editpath: "edit",
filetemplate: ({ auth, user, project, committish, path: path31 }) => `https://${maybeJoin(auth, "@")}raw.githubusercontent.com/${user}/${project}/${maybeEncode(committish || "HEAD")}/${path31}`,
gittemplate: ({ auth, domain, user, project, committish }) => `git://${maybeJoin(auth, "@")}${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
tarballtemplate: ({ domain, user, project, committish }) => `https://codeload.${domain}/${user}/${project}/tar.gz/${maybeEncode(committish || "HEAD")}`,
extract: (url) => {
let [, user, project, type, committish] = url.pathname.split("/", 5);
if (type && type !== "tree") {
return;
}
if (!type) {
committish = url.hash.slice(1);
}
if (project && project.endsWith(".git")) {
project = project.slice(0, -4);
}
if (!user || !project) {
return;
}
return { user, project, committish };
}
};
hosts.bitbucket = {
protocols: ["git+ssh:", "git+https:", "ssh:", "https:"],
domain: "bitbucket.org",
treepath: "src",
blobpath: "src",
editpath: "?mode=edit",
edittemplate: ({ domain, user, project, committish, treepath, path: path31, editpath }) => `https://${domain}/${user}/${project}${maybeJoin("/", treepath, "/", maybeEncode(committish || "HEAD"), "/", path31, editpath)}`,
tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/get/${maybeEncode(committish || "HEAD")}.tar.gz`,
extract: (url) => {
let [, user, project, aux] = url.pathname.split("/", 4);
if (["get"].includes(aux)) {
return;
}
if (project && project.endsWith(".git")) {
project = project.slice(0, -4);
}
if (!user || !project) {
return;
}
return { user, project, committish: url.hash.slice(1) };
}
};
hosts.gitlab = {
protocols: ["git+ssh:", "git+https:", "ssh:", "https:"],
domain: "gitlab.com",
treepath: "tree",
blobpath: "tree",
editpath: "-/edit",
tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/api/v4/projects/${maybeEncode(user + "/" + project)}/repository/archive.tar.gz?sha=${maybeEncode(committish || "HEAD")}`,
extract: (url) => {
const path31 = url.pathname.slice(1);
if (path31.includes("/-/") || path31.includes("/archive.tar.gz")) {
return;
}
const segments = path31.split("/");
let project = segments.pop();
if (project.endsWith(".git")) {
project = project.slice(0, -4);
}
const user = segments.join("/");
if (!user || !project) {
return;
}
return { user, project, committish: url.hash.slice(1) };
}
};
hosts.gist = {
protocols: ["git:", "git+ssh:", "git+https:", "ssh:", "https:"],
domain: "gist.github.com",
editpath: "edit",
sshtemplate: ({ domain, project, committish }) => `git@${domain}:${project}.git${maybeJoin("#", committish)}`,
sshurltemplate: ({ domain, project, committish }) => `git+ssh://git@${domain}/${project}.git${maybeJoin("#", committish)}`,
edittemplate: ({ domain, user, project, committish, editpath }) => `https://${domain}/${user}/${project}${maybeJoin("/", maybeEncode(committish))}/${editpath}`,
browsetemplate: ({ domain, project, committish }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}`,
browsetreetemplate: ({ domain, project, committish, path: path31, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path31))}`,
browseblobtemplate: ({ domain, project, committish, path: path31, hashformat }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}${maybeJoin("#", hashformat(path31))}`,
docstemplate: ({ domain, project, committish }) => `https://${domain}/${project}${maybeJoin("/", maybeEncode(committish))}`,
httpstemplate: ({ domain, project, committish }) => `git+https://${domain}/${project}.git${maybeJoin("#", committish)}`,
filetemplate: ({ user, project, committish, path: path31 }) => `https://gist.githubusercontent.com/${user}/${project}/raw${maybeJoin("/", maybeEncode(committish))}/${path31}`,
shortcuttemplate: ({ type, project, committish }) => `${type}:${project}${maybeJoin("#", committish)}`,
pathtemplate: ({ project, committish }) => `${project}${maybeJoin("#", committish)}`,
bugstemplate: ({ domain, project }) => `https://${domain}/${project}`,
gittemplate: ({ domain, project, committish }) => `git://${domain}/${project}.git${maybeJoin("#", committish)}`,
tarballtemplate: ({ project, committish }) => `https://codeload.github.com/gist/${project}/tar.gz/${maybeEncode(committish || "HEAD")}`,
extract: (url) => {
let [, user, project, aux] = url.pathname.split("/", 4);
if (aux === "raw") {
return;
}
if (!project) {
if (!user) {
return;
}
project = user;
user = null;
}
if (project.endsWith(".git")) {
project = project.slice(0, -4);
}
return { user, project, committish: url.hash.slice(1) };
},
hashformat: function(fragment) {
return fragment && "file-" + formatHashFragment(fragment);
}
};
hosts.sourcehut = {
protocols: ["git+ssh:", "https:"],
domain: "git.sr.ht",
treepath: "tree",
blobpath: "tree",
filetemplate: ({ domain, user, project, committish, path: path31 }) => `https://${domain}/${user}/${project}/blob/${maybeEncode(committish) || "HEAD"}/${path31}`,
httpstemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}${maybeJoin("#", committish)}`,
tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/archive/${maybeEncode(committish) || "HEAD"}.tar.gz`,
bugstemplate: () => null,
extract: (url) => {
let [, user, project, aux] = url.pathname.split("/", 4);
if (["archive"].includes(aux)) {
return;
}
if (project && project.endsWith(".git")) {
project = project.slice(0, -4);
}
if (!user || !project) {
return;
}
return { user, project, committish: url.hash.slice(1) };
}
};
for (const [name, host] of Object.entries(hosts)) {
hosts[name] = Object.assign({}, defaults, host);
}
module.exports = hosts;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/hosted-git-info/9.0.3/7b58ba3564ceb22d838cd41eebbaf67922270f6295431dafd0b4acc1e9140ab9/node_modules/hosted-git-info/lib/parse-url.js
var require_parse_url = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/hosted-git-info/9.0.3/7b58ba3564ceb22d838cd41eebbaf67922270f6295431dafd0b4acc1e9140ab9/node_modules/hosted-git-info/lib/parse-url.js"(exports, module) {
var url = __require("url");
var lastIndexOfBefore = (str, char, beforeChar) => {
const startPosition = str.indexOf(beforeChar);
return str.lastIndexOf(char, startPosition > -1 ? startPosition : Infinity);
};
var safeUrl = (u) => {
try {
return new url.URL(u);
} catch {
}
};
var correctProtocol = (arg, protocols) => {
const firstColon = arg.indexOf(":");
const proto = arg.slice(0, firstColon + 1);
if (Object.prototype.hasOwnProperty.call(protocols, proto)) {
return arg;
}
if (arg.substr(firstColon, 3) === "://") {
return arg;
}
const firstAt = arg.indexOf("@");
if (firstAt > -1) {
if (firstAt > firstColon) {
return `git+ssh://${arg}`;
} else {
return arg;
}
}
return `${arg.slice(0, firstColon + 1)}//${arg.slice(firstColon + 1)}`;
};
var correctUrl = (giturl) => {
const firstAt = lastIndexOfBefore(giturl, "@", "#");
const lastColonBeforeHash = lastIndexOfBefore(giturl, ":", "#");
if (lastColonBeforeHash > firstAt) {
giturl = giturl.slice(0, lastColonBeforeHash) + "/" + giturl.slice(lastColonBeforeHash + 1);
}
if (lastIndexOfBefore(giturl, ":", "#") === -1 && giturl.indexOf("//") === -1) {
giturl = `git+ssh://${giturl}`;
}
return giturl;
};
module.exports = (giturl, protocols) => {
const withProtocol = protocols ? correctProtocol(giturl, protocols) : giturl;
return safeUrl(withProtocol) || safeUrl(correctUrl(withProtocol));
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/hosted-git-info/9.0.3/7b58ba3564ceb22d838cd41eebbaf67922270f6295431dafd0b4acc1e9140ab9/node_modules/hosted-git-info/lib/from-url.js
var require_from_url = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/hosted-git-info/9.0.3/7b58ba3564ceb22d838cd41eebbaf67922270f6295431dafd0b4acc1e9140ab9/node_modules/hosted-git-info/lib/from-url.js"(exports, module) {
"use strict";
var parseUrl = require_parse_url();
var isGitHubShorthand = (arg) => {
const firstHash = arg.indexOf("#");
const firstSlash = arg.indexOf("/");
const secondSlash = arg.indexOf("/", firstSlash + 1);
const firstColon = arg.indexOf(":");
const firstSpace = /\s/.exec(arg);
const firstAt = arg.indexOf("@");
const spaceOnlyAfterHash = !firstSpace || firstHash > -1 && firstSpace.index > firstHash;
const atOnlyAfterHash = firstAt === -1 || firstHash > -1 && firstAt > firstHash;
const colonOnlyAfterHash = firstColon === -1 || firstHash > -1 && firstColon > firstHash;
const secondSlashOnlyAfterHash = secondSlash === -1 || firstHash > -1 && secondSlash > firstHash;
const hasSlash = firstSlash > 0;
const doesNotEndWithSlash = firstHash > -1 ? arg[firstHash - 1] !== "/" : !arg.endsWith("/");
const doesNotStartWithDot = !arg.startsWith(".");
return spaceOnlyAfterHash && hasSlash && doesNotEndWithSlash && doesNotStartWithDot && atOnlyAfterHash && colonOnlyAfterHash && secondSlashOnlyAfterHash;
};
module.exports = (giturl, opts2, { gitHosts, protocols }) => {
if (!giturl) {
return;
}
const correctedUrl = isGitHubShorthand(giturl) ? `github:${giturl}` : giturl;
const parsed = parseUrl(correctedUrl, protocols);
if (!parsed) {
return;
}
const gitHostShortcut = gitHosts.byShortcut[parsed.protocol];
const gitHostDomain = gitHosts.byDomain[parsed.hostname.startsWith("www.") ? parsed.hostname.slice(4) : parsed.hostname];
const gitHostName = gitHostShortcut || gitHostDomain;
if (!gitHostName) {
return;
}
const gitHostInfo = gitHosts[gitHostShortcut || gitHostDomain];
let auth = null;
if (protocols[parsed.protocol]?.auth && (parsed.username || parsed.password)) {
auth = `${parsed.username}${parsed.password ? ":" + parsed.password : ""}`;
}
let committish = null;
let user = null;
let project = null;
let defaultRepresentation = null;
try {
if (gitHostShortcut) {
let pathname = parsed.pathname.startsWith("/") ? parsed.pathname.slice(1) : parsed.pathname;
const firstAt = pathname.indexOf("@");
if (firstAt > -1) {
pathname = pathname.slice(firstAt + 1);
}
const lastSlash = pathname.lastIndexOf("/");
if (lastSlash > -1) {
user = decodeURIComponent(pathname.slice(0, lastSlash));
if (!user) {
user = null;
}
project = decodeURIComponent(pathname.slice(lastSlash + 1));
} else {
project = decodeURIComponent(pathname);
}
if (project.endsWith(".git")) {
project = project.slice(0, -4);
}
if (parsed.hash) {
committish = decodeURIComponent(parsed.hash.slice(1));
}
defaultRepresentation = "shortcut";
} else {
if (!gitHostInfo.protocols.includes(parsed.protocol)) {
return;
}
const segments = gitHostInfo.extract(parsed);
if (!segments) {
return;
}
user = segments.user && decodeURIComponent(segments.user);
project = decodeURIComponent(segments.project);
committish = decodeURIComponent(segments.committish);
defaultRepresentation = protocols[parsed.protocol]?.name || parsed.protocol.slice(0, -1);
}
} catch (err) {
if (err instanceof URIError) {
return;
} else {
throw err;
}
}
return [gitHostName, user, auth, project, committish, defaultRepresentation, opts2];
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/hosted-git-info/9.0.3/7b58ba3564ceb22d838cd41eebbaf67922270f6295431dafd0b4acc1e9140ab9/node_modules/hosted-git-info/lib/index.js
var require_lib4 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/hosted-git-info/9.0.3/7b58ba3564ceb22d838cd41eebbaf67922270f6295431dafd0b4acc1e9140ab9/node_modules/hosted-git-info/lib/index.js"(exports, module) {
"use strict";
var { LRUCache } = require_index_min();
var hosts = require_hosts();
var fromUrl = require_from_url();
var parseUrl = require_parse_url();
var cache = new LRUCache({ max: 1e3 });
function unknownHostedUrl(url) {
try {
const {
protocol,
hostname,
pathname
} = new URL(url);
if (!hostname) {
return null;
}
const proto = /(?:git\+)http:$/.test(protocol) ? "http:" : "https:";
const path31 = pathname.replace(/\.git$/, "");
return `${proto}//${hostname}${path31}`;
} catch {
return null;
}
}
var GitHost = class _GitHost {
constructor(type, user, auth, project, committish, defaultRepresentation, opts2 = {}) {
Object.assign(this, _GitHost.#gitHosts[type], {
type,
user,
auth,
project,
committish,
default: defaultRepresentation,
opts: opts2
});
}
static #gitHosts = { byShortcut: {}, byDomain: {} };
static #protocols = {
"git+ssh:": { name: "sshurl" },
"ssh:": { name: "sshurl" },
"git+https:": { name: "https", auth: true },
"git:": { auth: true },
"http:": { auth: true },
"https:": { auth: true },
"git+http:": { auth: true }
};
static addHost(name, host) {
_GitHost.#gitHosts[name] = host;
_GitHost.#gitHosts.byDomain[host.domain] = name;
_GitHost.#gitHosts.byShortcut[`${name}:`] = name;
_GitHost.#protocols[`${name}:`] = { name };
}
static fromUrl(giturl, opts2) {
if (typeof giturl !== "string") {
return;
}
const key = giturl + JSON.stringify(opts2 || {});
if (!cache.has(key)) {
const hostArgs = fromUrl(giturl, opts2, {
gitHosts: _GitHost.#gitHosts,
protocols: _GitHost.#protocols
});
cache.set(key, hostArgs ? new _GitHost(...hostArgs) : void 0);
}
return cache.get(key);
}
static fromManifest(manifest, opts2 = {}) {
if (!manifest || typeof manifest !== "object") {
return;
}
const r = manifest.repository;
const rurl = r && (typeof r === "string" ? r : typeof r === "object" && typeof r.url === "string" ? r.url : null);
if (!rurl) {
throw new Error("no repository");
}
const info = rurl && _GitHost.fromUrl(rurl.replace(/^git\+/, ""), opts2) || null;
if (info) {
return info;
}
const unk = unknownHostedUrl(rurl);
return _GitHost.fromUrl(unk, opts2) || unk;
}
static parseUrl(url) {
return parseUrl(url);
}
#fill(template, opts2) {
if (typeof template !== "function") {
return null;
}
const options = { ...this, ...this.opts, ...opts2 };
if (!options.path) {
options.path = "";
}
if (options.path.startsWith("/")) {
options.path = options.path.slice(1);
}
if (options.noCommittish) {
options.committish = null;
}
const result = template(options);
return options.noGitPlus && result.startsWith("git+") ? result.slice(4) : result;
}
hash() {
return this.committish ? `#${this.committish}` : "";
}
ssh(opts2) {
return this.#fill(this.sshtemplate, opts2);
}
sshurl(opts2) {
return this.#fill(this.sshurltemplate, opts2);
}
browse(path31, ...args) {
if (typeof path31 !== "string") {
return this.#fill(this.browsetemplate, path31);
}
if (typeof args[0] !== "string") {
return this.#fill(this.browsetreetemplate, { ...args[0], path: path31 });
}
return this.#fill(this.browsetreetemplate, { ...args[1], fragment: args[0], path: path31 });
}
// If the path is known to be a file, then browseFile should be used. For some hosts
// the url is the same as browse, but for others like GitHub a file can use both `/tree/`
// and `/blob/` in the path. When using a default committish of `HEAD` then the `/tree/`
// path will redirect to a specific commit. Using the `/blob/` path avoids this and
// does not redirect to a different commit.
browseFile(path31, ...args) {
if (typeof args[0] !== "string") {
return this.#fill(this.browseblobtemplate, { ...args[0], path: path31 });
}
return this.#fill(this.browseblobtemplate, { ...args[1], fragment: args[0], path: path31 });
}
docs(opts2) {
return this.#fill(this.docstemplate, opts2);
}
bugs(opts2) {
return this.#fill(this.bugstemplate, opts2);
}
https(opts2) {
return this.#fill(this.httpstemplate, opts2);
}
git(opts2) {
return this.#fill(this.gittemplate, opts2);
}
shortcut(opts2) {
return this.#fill(this.shortcuttemplate, opts2);
}
path(opts2) {
return this.#fill(this.pathtemplate, opts2);
}
tarball(opts2) {
return this.#fill(this.tarballtemplate, { ...opts2, noCommittish: false });
}
file(path31, opts2) {
return this.#fill(this.filetemplate, { ...opts2, path: path31 });
}
edit(path31, opts2) {
return this.#fill(this.edittemplate, { ...opts2, path: path31 });
}
getDefaultRepresentation() {
return this.default;
}
toString(opts2) {
if (this.default && typeof this[this.default] === "function") {
return this[this.default](opts2);
}
return this.sshurl(opts2);
}
};
for (const [name, host] of Object.entries(hosts)) {
GitHost.addHost(name, host);
}
module.exports = GitHost;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/normalize-package-data/8.0.0/7c7b6c281711a72f7ebdc6ea459ed6fb3d2c8cc5875df1d97bd7470e86f904cc/node_modules/normalize-package-data/lib/extract_description.js
var require_extract_description = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/normalize-package-data/8.0.0/7c7b6c281711a72f7ebdc6ea459ed6fb3d2c8cc5875df1d97bd7470e86f904cc/node_modules/normalize-package-data/lib/extract_description.js"(exports, module) {
module.exports = extractDescription;
function extractDescription(d) {
if (!d) {
return;
}
if (d === "ERROR: No README data found!") {
return;
}
d = d.trim().split("\n");
let s = 0;
while (d[s] && d[s].trim().match(/^(#|$)/)) {
s++;
}
const l = d.length;
let e = s + 1;
while (e < l && d[e].trim()) {
e++;
}
return d.slice(s, e).join(" ").trim();
}
}
});
// ../../../../../setup-pnpm/store/v11/links/@/normalize-package-data/8.0.0/7c7b6c281711a72f7ebdc6ea459ed6fb3d2c8cc5875df1d97bd7470e86f904cc/node_modules/normalize-package-data/lib/typos.json
var require_typos = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/normalize-package-data/8.0.0/7c7b6c281711a72f7ebdc6ea459ed6fb3d2c8cc5875df1d97bd7470e86f904cc/node_modules/normalize-package-data/lib/typos.json"(exports, module) {
module.exports = {
topLevel: {
dependancies: "dependencies",
dependecies: "dependencies",
depdenencies: "dependencies",
devEependencies: "devDependencies",
depends: "dependencies",
"dev-dependencies": "devDependencies",
devDependences: "devDependencies",
devDepenencies: "devDependencies",
devdependencies: "devDependencies",
repostitory: "repository",
repo: "repository",
prefereGlobal: "preferGlobal",
hompage: "homepage",
hampage: "homepage",
autohr: "author",
autor: "author",
contributers: "contributors",
publicationConfig: "publishConfig",
script: "scripts"
},
bugs: { web: "url", name: "url" },
script: { server: "start", tests: "test" }
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/normalize-package-data/8.0.0/7c7b6c281711a72f7ebdc6ea459ed6fb3d2c8cc5875df1d97bd7470e86f904cc/node_modules/normalize-package-data/lib/fixer.js
var require_fixer = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/normalize-package-data/8.0.0/7c7b6c281711a72f7ebdc6ea459ed6fb3d2c8cc5875df1d97bd7470e86f904cc/node_modules/normalize-package-data/lib/fixer.js"(exports, module) {
var { URL: URL2 } = __require("node:url");
var isValidSemver = require_valid();
var cleanSemver = require_clean();
var validateLicense = require_validate_npm_package_license();
var hostedGitInfo = require_lib4();
var { isBuiltin } = __require("node:module");
var depTypes = ["dependencies", "devDependencies", "optionalDependencies"];
var extractDescription = require_extract_description();
var typos = require_typos();
var isEmail = (str) => str.includes("@") && str.indexOf("@") < str.lastIndexOf(".");
module.exports = {
// default warning function
warn: function() {
},
fixRepositoryField: function(data) {
if (data.repositories) {
this.warn("repositories");
data.repository = data.repositories[0];
}
if (!data.repository) {
return this.warn("missingRepository");
}
if (typeof data.repository === "string") {
data.repository = {
type: "git",
url: data.repository
};
}
var r = data.repository.url || "";
if (r) {
var hosted = hostedGitInfo.fromUrl(r);
if (hosted) {
r = data.repository.url = hosted.getDefaultRepresentation() === "shortcut" ? hosted.https() : hosted.toString();
}
}
if (r.match(/github.com\/[^/]+\/[^/]+\.git\.git$/)) {
this.warn("brokenGitUrl", r);
}
},
fixTypos: function(data) {
Object.keys(typos.topLevel).forEach(function(d) {
if (Object.prototype.hasOwnProperty.call(data, d)) {
this.warn("typo", d, typos.topLevel[d]);
}
}, this);
},
fixScriptsField: function(data) {
if (!data.scripts) {
return;
}
if (typeof data.scripts !== "object") {
this.warn("nonObjectScripts");
delete data.scripts;
return;
}
Object.keys(data.scripts).forEach(function(k) {
if (typeof data.scripts[k] !== "string") {
this.warn("nonStringScript");
delete data.scripts[k];
} else if (typos.script[k] && !data.scripts[typos.script[k]]) {
this.warn("typo", k, typos.script[k], "scripts");
}
}, this);
},
fixFilesField: function(data) {
var files = data.files;
if (files && !Array.isArray(files)) {
this.warn("nonArrayFiles");
delete data.files;
} else if (data.files) {
data.files = data.files.filter(function(file) {
if (!file || typeof file !== "string") {
this.warn("invalidFilename", file);
return false;
} else {
return true;
}
}, this);
}
},
fixBinField: function(data) {
if (!data.bin) {
return;
}
if (typeof data.bin === "string") {
var b = {};
var match;
if (match = data.name.match(/^@[^/]+[/](.*)$/)) {
b[match[1]] = data.bin;
} else {
b[data.name] = data.bin;
}
data.bin = b;
}
},
fixManField: function(data) {
if (!data.man) {
return;
}
if (typeof data.man === "string") {
data.man = [data.man];
}
},
fixBundleDependenciesField: function(data) {
var bdd = "bundledDependencies";
var bd = "bundleDependencies";
if (data[bdd] && !data[bd]) {
data[bd] = data[bdd];
delete data[bdd];
}
if (data[bd] && !Array.isArray(data[bd])) {
this.warn("nonArrayBundleDependencies");
delete data[bd];
} else if (data[bd]) {
data[bd] = data[bd].filter(function(filtered) {
if (!filtered || typeof filtered !== "string") {
this.warn("nonStringBundleDependency", filtered);
return false;
} else {
if (!data.dependencies) {
data.dependencies = {};
}
if (!Object.prototype.hasOwnProperty.call(data.dependencies, filtered)) {
this.warn("nonDependencyBundleDependency", filtered);
data.dependencies[filtered] = "*";
}
return true;
}
}, this);
}
},
fixDependencies: function(data) {
objectifyDeps(data, this.warn);
addOptionalDepsToDeps(data, this.warn);
this.fixBundleDependenciesField(data);
["dependencies", "devDependencies"].forEach(function(deps) {
if (!(deps in data)) {
return;
}
if (!data[deps] || typeof data[deps] !== "object") {
this.warn("nonObjectDependencies", deps);
delete data[deps];
return;
}
Object.keys(data[deps]).forEach(function(d) {
var r = data[deps][d];
if (typeof r !== "string") {
this.warn("nonStringDependency", d, JSON.stringify(r));
delete data[deps][d];
}
var hosted = hostedGitInfo.fromUrl(data[deps][d]);
if (hosted) {
data[deps][d] = hosted.toString();
}
}, this);
}, this);
},
fixModulesField: function(data) {
if (data.modules) {
this.warn("deprecatedModules");
delete data.modules;
}
},
fixKeywordsField: function(data) {
if (typeof data.keywords === "string") {
data.keywords = data.keywords.split(/,\s+/);
}
if (data.keywords && !Array.isArray(data.keywords)) {
delete data.keywords;
this.warn("nonArrayKeywords");
} else if (data.keywords) {
data.keywords = data.keywords.filter(function(kw) {
if (typeof kw !== "string" || !kw) {
this.warn("nonStringKeyword");
return false;
} else {
return true;
}
}, this);
}
},
fixVersionField: function(data, strict) {
var loose = !strict;
if (!data.version) {
data.version = "";
return true;
}
if (!isValidSemver(data.version, loose)) {
throw new Error('Invalid version: "' + data.version + '"');
}
data.version = cleanSemver(data.version, loose);
return true;
},
fixPeople: function(data) {
modifyPeople(data, unParsePerson);
modifyPeople(data, parsePerson);
},
fixNameField: function(data, options) {
if (typeof options === "boolean") {
options = { strict: options };
} else if (typeof options === "undefined") {
options = {};
}
var strict = options.strict;
if (!data.name && !strict) {
data.name = "";
return;
}
if (typeof data.name !== "string") {
throw new Error("name field must be a string.");
}
if (!strict) {
data.name = data.name.trim();
}
ensureValidName(data.name, strict, options.allowLegacyCase);
if (isBuiltin(data.name)) {
this.warn("conflictingName", data.name);
}
},
fixDescriptionField: function(data) {
if (data.description && typeof data.description !== "string") {
this.warn("nonStringDescription");
delete data.description;
}
if (data.readme && !data.description) {
data.description = extractDescription(data.readme);
}
if (data.description === void 0) {
delete data.description;
}
if (!data.description) {
this.warn("missingDescription");
}
},
fixReadmeField: function(data) {
if (!data.readme) {
this.warn("missingReadme");
data.readme = "ERROR: No README data found!";
}
},
fixBugsField: function(data) {
if (!data.bugs && data.repository && data.repository.url) {
var hosted = hostedGitInfo.fromUrl(data.repository.url);
if (hosted && hosted.bugs()) {
data.bugs = { url: hosted.bugs() };
}
} else if (data.bugs) {
if (typeof data.bugs === "string") {
if (isEmail(data.bugs)) {
data.bugs = { email: data.bugs };
} else if (URL2.canParse(data.bugs)) {
data.bugs = { url: data.bugs };
} else {
this.warn("nonEmailUrlBugsString");
}
} else {
bugsTypos(data.bugs, this.warn);
var oldBugs = data.bugs;
data.bugs = {};
if (oldBugs.url) {
if (URL2.canParse(oldBugs.url)) {
data.bugs.url = oldBugs.url;
} else {
this.warn("nonUrlBugsUrlField");
}
}
if (oldBugs.email) {
if (typeof oldBugs.email === "string" && isEmail(oldBugs.email)) {
data.bugs.email = oldBugs.email;
} else {
this.warn("nonEmailBugsEmailField");
}
}
}
if (!data.bugs.email && !data.bugs.url) {
delete data.bugs;
this.warn("emptyNormalizedBugs");
}
}
},
fixHomepageField: function(data) {
if (!data.homepage && data.repository && data.repository.url) {
var hosted = hostedGitInfo.fromUrl(data.repository.url);
if (hosted && hosted.docs()) {
data.homepage = hosted.docs();
}
}
if (!data.homepage) {
return;
}
if (typeof data.homepage !== "string") {
this.warn("nonUrlHomepage");
return delete data.homepage;
}
if (!URL2.canParse(data.homepage)) {
data.homepage = "http://" + data.homepage;
}
},
fixLicenseField: function(data) {
const license = data.license || data.licence;
if (!license) {
return this.warn("missingLicense");
}
if (typeof license !== "string" || license.length < 1 || license.trim() === "") {
return this.warn("invalidLicense");
}
if (!validateLicense(license).validForNewPackages) {
return this.warn("invalidLicense");
}
}
};
function isValidScopedPackageName(spec) {
if (spec.charAt(0) !== "@") {
return false;
}
var rest = spec.slice(1).split("/");
if (rest.length !== 2) {
return false;
}
return rest[0] && rest[1] && rest[0] === encodeURIComponent(rest[0]) && rest[1] === encodeURIComponent(rest[1]);
}
function isCorrectlyEncodedName(spec) {
return !spec.match(/[/@\s+%:]/) && spec === encodeURIComponent(spec);
}
function ensureValidName(name, strict, allowLegacyCase) {
if (name.charAt(0) === "." || !(isValidScopedPackageName(name) || isCorrectlyEncodedName(name)) || strict && !allowLegacyCase && name !== name.toLowerCase() || name.toLowerCase() === "node_modules" || name.toLowerCase() === "favicon.ico") {
throw new Error("Invalid name: " + JSON.stringify(name));
}
}
function modifyPeople(data, fn) {
if (data.author) {
data.author = fn(data.author);
}
["maintainers", "contributors"].forEach(function(set) {
if (!Array.isArray(data[set])) {
return;
}
data[set] = data[set].map(fn);
});
return data;
}
function unParsePerson(person) {
if (typeof person === "string") {
return person;
}
var name = person.name || "";
var u = person.url || person.web;
var wrappedUrl = u ? " (" + u + ")" : "";
var e = person.email || person.mail;
var wrappedEmail = e ? " <" + e + ">" : "";
return name + wrappedEmail + wrappedUrl;
}
function parsePerson(person) {
if (typeof person !== "string") {
return person;
}
var matchedName = person.match(/^([^(<]+)/);
var matchedUrl = person.match(/\(([^()]+)\)/);
var matchedEmail = person.match(/<([^<>]+)>/);
var obj = {};
if (matchedName && matchedName[0].trim()) {
obj.name = matchedName[0].trim();
}
if (matchedEmail) {
obj.email = matchedEmail[1];
}
if (matchedUrl) {
obj.url = matchedUrl[1];
}
return obj;
}
function addOptionalDepsToDeps(data) {
var o = data.optionalDependencies;
if (!o) {
return;
}
var d = data.dependencies || {};
Object.keys(o).forEach(function(k) {
d[k] = o[k];
});
data.dependencies = d;
}
function depObjectify(deps, type, warn) {
if (!deps) {
return {};
}
if (typeof deps === "string") {
deps = deps.trim().split(/[\n\r\s\t ,]+/);
}
if (!Array.isArray(deps)) {
return deps;
}
warn("deprecatedArrayDependencies", type);
var o = {};
deps.filter(function(d) {
return typeof d === "string";
}).forEach(function(d) {
d = d.trim().split(/(:?[@\s><=])/);
var dn = d.shift();
var dv = d.join("");
dv = dv.trim();
dv = dv.replace(/^@/, "");
o[dn] = dv;
});
return o;
}
function objectifyDeps(data, warn) {
depTypes.forEach(function(type) {
if (!data[type]) {
return;
}
data[type] = depObjectify(data[type], type, warn);
});
}
function bugsTypos(bugs, warn) {
if (!bugs) {
return;
}
Object.keys(bugs).forEach(function(k) {
if (typos.bugs[k]) {
warn("typo", k, typos.bugs[k], "bugs");
bugs[typos.bugs[k]] = bugs[k];
delete bugs[k];
}
});
}
}
});
// ../../../../../setup-pnpm/store/v11/links/@/normalize-package-data/8.0.0/7c7b6c281711a72f7ebdc6ea459ed6fb3d2c8cc5875df1d97bd7470e86f904cc/node_modules/normalize-package-data/lib/warning_messages.json
var require_warning_messages = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/normalize-package-data/8.0.0/7c7b6c281711a72f7ebdc6ea459ed6fb3d2c8cc5875df1d97bd7470e86f904cc/node_modules/normalize-package-data/lib/warning_messages.json"(exports, module) {
module.exports = {
repositories: "'repositories' (plural) Not supported. Please pick one as the 'repository' field",
missingRepository: "No repository field.",
brokenGitUrl: "Probably broken git url: %s",
nonObjectScripts: "scripts must be an object",
nonStringScript: "script values must be string commands",
nonArrayFiles: "Invalid 'files' member",
invalidFilename: "Invalid filename in 'files' list: %s",
nonArrayBundleDependencies: "Invalid 'bundleDependencies' list. Must be array of package names",
nonStringBundleDependency: "Invalid bundleDependencies member: %s",
nonDependencyBundleDependency: "Non-dependency in bundleDependencies: %s",
nonObjectDependencies: "%s field must be an object",
nonStringDependency: "Invalid dependency: %s %s",
deprecatedArrayDependencies: "specifying %s as array is deprecated",
deprecatedModules: "modules field is deprecated",
nonArrayKeywords: "keywords should be an array of strings",
nonStringKeyword: "keywords should be an array of strings",
conflictingName: "%s is also the name of a node core module.",
nonStringDescription: "'description' field should be a string",
missingDescription: "No description",
missingReadme: "No README data",
missingLicense: "No license field.",
nonEmailUrlBugsString: "Bug string field must be url, email, or {email,url}",
nonUrlBugsUrlField: "bugs.url field must be a string url. Deleted.",
nonEmailBugsEmailField: "bugs.email field must be a string email. Deleted.",
emptyNormalizedBugs: "Normalized value of bugs field is an empty object. Deleted.",
nonUrlHomepage: "homepage field must be a string url. Deleted.",
invalidLicense: "license should be a valid SPDX license expression",
typo: "%s should probably be %s."
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/normalize-package-data/8.0.0/7c7b6c281711a72f7ebdc6ea459ed6fb3d2c8cc5875df1d97bd7470e86f904cc/node_modules/normalize-package-data/lib/make_warning.js
var require_make_warning = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/normalize-package-data/8.0.0/7c7b6c281711a72f7ebdc6ea459ed6fb3d2c8cc5875df1d97bd7470e86f904cc/node_modules/normalize-package-data/lib/make_warning.js"(exports, module) {
var util2 = __require("util");
var messages = require_warning_messages();
module.exports = function() {
var args = Array.prototype.slice.call(arguments, 0);
var warningName = args.shift();
if (warningName === "typo") {
return makeTypoWarning.apply(null, args);
} else {
var msgTemplate = messages[warningName] ? messages[warningName] : warningName + ": '%s'";
args.unshift(msgTemplate);
return util2.format.apply(null, args);
}
};
function makeTypoWarning(providedName, probableName, field) {
if (field) {
providedName = field + "['" + providedName + "']";
probableName = field + "['" + probableName + "']";
}
return util2.format(messages.typo, providedName, probableName);
}
}
});
// ../../../../../setup-pnpm/store/v11/links/@/normalize-package-data/8.0.0/7c7b6c281711a72f7ebdc6ea459ed6fb3d2c8cc5875df1d97bd7470e86f904cc/node_modules/normalize-package-data/lib/normalize.js
var require_normalize = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/normalize-package-data/8.0.0/7c7b6c281711a72f7ebdc6ea459ed6fb3d2c8cc5875df1d97bd7470e86f904cc/node_modules/normalize-package-data/lib/normalize.js"(exports, module) {
module.exports = normalize;
var fixer = require_fixer();
normalize.fixer = fixer;
var makeWarning = require_make_warning();
var fieldsToFix = [
"name",
"version",
"description",
"repository",
"modules",
"scripts",
"files",
"bin",
"man",
"bugs",
"keywords",
"readme",
"homepage",
"license"
];
var otherThingsToFix = ["dependencies", "people", "typos"];
var thingsToFix = fieldsToFix.map(function(fieldName) {
return ucFirst(fieldName) + "Field";
});
thingsToFix = thingsToFix.concat(otherThingsToFix);
function normalize(data, warn, strict) {
if (warn === true) {
warn = null;
strict = true;
}
if (!strict) {
strict = false;
}
if (!warn || data.private) {
warn = function() {
};
}
if (data.scripts && data.scripts.install === "node-gyp rebuild" && !data.scripts.preinstall) {
data.gypfile = true;
}
fixer.warn = function() {
warn(makeWarning.apply(null, arguments));
};
thingsToFix.forEach(function(thingName) {
fixer["fix" + ucFirst(thingName)](data, strict);
});
data._id = data.name + "@" + data.version;
}
function ucFirst(string) {
return string.charAt(0).toUpperCase() + string.slice(1);
}
}
});
// ../../../../../setup-pnpm/store/v11/links/@/detect-libc/2.1.2/a1e36129e998f9971b8906296c04a9314f612077e4f1e2a4342793f735c2fb37/node_modules/detect-libc/lib/process.js
var require_process = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/detect-libc/2.1.2/a1e36129e998f9971b8906296c04a9314f612077e4f1e2a4342793f735c2fb37/node_modules/detect-libc/lib/process.js"(exports, module) {
"use strict";
var isLinux = () => process.platform === "linux";
var report = null;
var getReport = () => {
if (!report) {
if (isLinux() && process.report) {
const orig = process.report.excludeNetwork;
process.report.excludeNetwork = true;
report = process.report.getReport();
process.report.excludeNetwork = orig;
} else {
report = {};
}
}
return report;
};
module.exports = { isLinux, getReport };
}
});
// ../../../../../setup-pnpm/store/v11/links/@/detect-libc/2.1.2/a1e36129e998f9971b8906296c04a9314f612077e4f1e2a4342793f735c2fb37/node_modules/detect-libc/lib/filesystem.js
var require_filesystem = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/detect-libc/2.1.2/a1e36129e998f9971b8906296c04a9314f612077e4f1e2a4342793f735c2fb37/node_modules/detect-libc/lib/filesystem.js"(exports, module) {
"use strict";
var fs30 = __require("fs");
var LDD_PATH = "/usr/bin/ldd";
var SELF_PATH = "/proc/self/exe";
var MAX_LENGTH = 2048;
var readFileSync2 = (path31) => {
const fd = fs30.openSync(path31, "r");
const buffer = Buffer.alloc(MAX_LENGTH);
const bytesRead = fs30.readSync(fd, buffer, 0, MAX_LENGTH, 0);
fs30.close(fd, () => {
});
return buffer.subarray(0, bytesRead);
};
var readFile2 = (path31) => new Promise((resolve, reject) => {
fs30.open(path31, "r", (err, fd) => {
if (err) {
reject(err);
} else {
const buffer = Buffer.alloc(MAX_LENGTH);
fs30.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
resolve(buffer.subarray(0, bytesRead));
fs30.close(fd, () => {
});
});
}
});
});
module.exports = {
LDD_PATH,
SELF_PATH,
readFileSync: readFileSync2,
readFile: readFile2
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/detect-libc/2.1.2/a1e36129e998f9971b8906296c04a9314f612077e4f1e2a4342793f735c2fb37/node_modules/detect-libc/lib/elf.js
var require_elf = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/detect-libc/2.1.2/a1e36129e998f9971b8906296c04a9314f612077e4f1e2a4342793f735c2fb37/node_modules/detect-libc/lib/elf.js"(exports, module) {
"use strict";
var interpreterPath = (elf) => {
if (elf.length < 64) {
return null;
}
if (elf.readUInt32BE(0) !== 2135247942) {
return null;
}
if (elf.readUInt8(4) !== 2) {
return null;
}
if (elf.readUInt8(5) !== 1) {
return null;
}
const offset = elf.readUInt32LE(32);
const size = elf.readUInt16LE(54);
const count = elf.readUInt16LE(56);
for (let i = 0; i < count; i++) {
const headerOffset = offset + i * size;
const type = elf.readUInt32LE(headerOffset);
if (type === 3) {
const fileOffset = elf.readUInt32LE(headerOffset + 8);
const fileSize = elf.readUInt32LE(headerOffset + 32);
return elf.subarray(fileOffset, fileOffset + fileSize).toString().replace(/\0.*$/g, "");
}
}
return null;
};
module.exports = {
interpreterPath
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/detect-libc/2.1.2/a1e36129e998f9971b8906296c04a9314f612077e4f1e2a4342793f735c2fb37/node_modules/detect-libc/lib/detect-libc.js
var require_detect_libc = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/detect-libc/2.1.2/a1e36129e998f9971b8906296c04a9314f612077e4f1e2a4342793f735c2fb37/node_modules/detect-libc/lib/detect-libc.js"(exports, module) {
"use strict";
var childProcess = __require("child_process");
var { isLinux, getReport } = require_process();
var { LDD_PATH, SELF_PATH, readFile: readFile2, readFileSync: readFileSync2 } = require_filesystem();
var { interpreterPath } = require_elf();
var cachedFamilyInterpreter;
var cachedFamilyFilesystem;
var cachedVersionFilesystem;
var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
var commandOut = "";
var safeCommand = () => {
if (!commandOut) {
return new Promise((resolve) => {
childProcess.exec(command, (err, out) => {
commandOut = err ? " " : out;
resolve(commandOut);
});
});
}
return commandOut;
};
var safeCommandSync = () => {
if (!commandOut) {
try {
commandOut = childProcess.execSync(command, { encoding: "utf8" });
} catch (_err) {
commandOut = " ";
}
}
return commandOut;
};
var GLIBC = "glibc";
var RE_GLIBC_VERSION = /LIBC[a-z0-9 \-).]*?(\d+\.\d+)/i;
var MUSL = "musl";
var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
var familyFromReport = () => {
const report = getReport();
if (report.header && report.header.glibcVersionRuntime) {
return GLIBC;
}
if (Array.isArray(report.sharedObjects)) {
if (report.sharedObjects.some(isFileMusl)) {
return MUSL;
}
}
return null;
};
var familyFromCommand = (out) => {
const [getconf, ldd1] = out.split(/[\r\n]+/);
if (getconf && getconf.includes(GLIBC)) {
return GLIBC;
}
if (ldd1 && ldd1.includes(MUSL)) {
return MUSL;
}
return null;
};
var familyFromInterpreterPath = (path31) => {
if (path31) {
if (path31.includes("/ld-musl-")) {
return MUSL;
} else if (path31.includes("/ld-linux-")) {
return GLIBC;
}
}
return null;
};
var getFamilyFromLddContent = (content) => {
content = content.toString();
if (content.includes("musl")) {
return MUSL;
}
if (content.includes("GNU C Library")) {
return GLIBC;
}
return null;
};
var familyFromFilesystem = async () => {
if (cachedFamilyFilesystem !== void 0) {
return cachedFamilyFilesystem;
}
cachedFamilyFilesystem = null;
try {
const lddContent = await readFile2(LDD_PATH);
cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
} catch (e) {
}
return cachedFamilyFilesystem;
};
var familyFromFilesystemSync = () => {
if (cachedFamilyFilesystem !== void 0) {
return cachedFamilyFilesystem;
}
cachedFamilyFilesystem = null;
try {
const lddContent = readFileSync2(LDD_PATH);
cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
} catch (e) {
}
return cachedFamilyFilesystem;
};
var familyFromInterpreter = async () => {
if (cachedFamilyInterpreter !== void 0) {
return cachedFamilyInterpreter;
}
cachedFamilyInterpreter = null;
try {
const selfContent = await readFile2(SELF_PATH);
const path31 = interpreterPath(selfContent);
cachedFamilyInterpreter = familyFromInterpreterPath(path31);
} catch (e) {
}
return cachedFamilyInterpreter;
};
var familyFromInterpreterSync = () => {
if (cachedFamilyInterpreter !== void 0) {
return cachedFamilyInterpreter;
}
cachedFamilyInterpreter = null;
try {
const selfContent = readFileSync2(SELF_PATH);
const path31 = interpreterPath(selfContent);
cachedFamilyInterpreter = familyFromInterpreterPath(path31);
} catch (e) {
}
return cachedFamilyInterpreter;
};
var family = async () => {
let family2 = null;
if (isLinux()) {
family2 = await familyFromInterpreter();
if (!family2) {
family2 = await familyFromFilesystem();
if (!family2) {
family2 = familyFromReport();
}
if (!family2) {
const out = await safeCommand();
family2 = familyFromCommand(out);
}
}
}
return family2;
};
var familySync = () => {
let family2 = null;
if (isLinux()) {
family2 = familyFromInterpreterSync();
if (!family2) {
family2 = familyFromFilesystemSync();
if (!family2) {
family2 = familyFromReport();
}
if (!family2) {
const out = safeCommandSync();
family2 = familyFromCommand(out);
}
}
}
return family2;
};
var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
var isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
var versionFromFilesystem = async () => {
if (cachedVersionFilesystem !== void 0) {
return cachedVersionFilesystem;
}
cachedVersionFilesystem = null;
try {
const lddContent = await readFile2(LDD_PATH);
const versionMatch = lddContent.match(RE_GLIBC_VERSION);
if (versionMatch) {
cachedVersionFilesystem = versionMatch[1];
}
} catch (e) {
}
return cachedVersionFilesystem;
};
var versionFromFilesystemSync = () => {
if (cachedVersionFilesystem !== void 0) {
return cachedVersionFilesystem;
}
cachedVersionFilesystem = null;
try {
const lddContent = readFileSync2(LDD_PATH);
const versionMatch = lddContent.match(RE_GLIBC_VERSION);
if (versionMatch) {
cachedVersionFilesystem = versionMatch[1];
}
} catch (e) {
}
return cachedVersionFilesystem;
};
var versionFromReport = () => {
const report = getReport();
if (report.header && report.header.glibcVersionRuntime) {
return report.header.glibcVersionRuntime;
}
return null;
};
var versionSuffix = (s) => s.trim().split(/\s+/)[1];
var versionFromCommand = (out) => {
const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
if (getconf && getconf.includes(GLIBC)) {
return versionSuffix(getconf);
}
if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
return versionSuffix(ldd2);
}
return null;
};
var version = async () => {
let version2 = null;
if (isLinux()) {
version2 = await versionFromFilesystem();
if (!version2) {
version2 = versionFromReport();
}
if (!version2) {
const out = await safeCommand();
version2 = versionFromCommand(out);
}
}
return version2;
};
var versionSync = () => {
let version2 = null;
if (isLinux()) {
version2 = versionFromFilesystemSync();
if (!version2) {
version2 = versionFromReport();
}
if (!version2) {
const out = safeCommandSync();
version2 = versionFromCommand(out);
}
}
return version2;
};
module.exports = {
GLIBC,
MUSL,
family,
familySync,
isNonGlibcLinux,
isNonGlibcLinuxSync,
version,
versionSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/node-gyp-build-optional-packages/5.2.2/e2d2fc28f4d0eaa7fac1904123db86f87839f4cdd1ffc0e2b124adc9c1d9f616/node_modules/node-gyp-build-optional-packages/node-gyp-build.js
var require_node_gyp_build = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/node-gyp-build-optional-packages/5.2.2/e2d2fc28f4d0eaa7fac1904123db86f87839f4cdd1ffc0e2b124adc9c1d9f616/node_modules/node-gyp-build-optional-packages/node-gyp-build.js"(exports, module) {
var fs30 = __require("fs");
var path31 = __require("path");
var url = __require("url");
var os2 = __require("os");
var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
var vars = process.config && process.config.variables || {};
var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
var versions = process.versions;
var abi = versions.modules;
if (versions.deno || process.isBun) {
abi = "unsupported";
}
var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
var arch = process.env.npm_config_arch || os2.arch();
var platform = process.env.npm_config_platform || os2.platform();
var libc = process.env.LIBC || (isMusl(platform) ? "musl" : "glibc");
var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
var uv = (versions.uv || "").split(".")[0];
module.exports = load;
function load(dir) {
return runtimeRequire(load.resolve(dir));
}
load.resolve = load.path = function(dir) {
dir = path31.resolve(dir || ".");
var packageName = "";
var packageNameError;
try {
packageName = runtimeRequire(path31.join(dir, "package.json")).name;
var varName = packageName.toUpperCase().replace(/-/g, "_");
if (process.env[varName + "_PREBUILD"]) dir = process.env[varName + "_PREBUILD"];
} catch (err) {
packageNameError = err;
}
if (!prebuildsOnly) {
var release = getFirst(path31.join(dir, "build/Release"), matchBuild);
if (release) return release;
var debug = getFirst(path31.join(dir, "build/Debug"), matchBuild);
if (debug) return debug;
}
var prebuild = resolve(dir);
if (prebuild) return prebuild;
var nearby = resolve(path31.dirname(process.execPath));
if (nearby) return nearby;
var platformPackage = (packageName[0] == "@" ? "" : "@" + packageName + "/") + packageName + "-" + platform + "-" + arch;
var packageResolutionError;
try {
var prebuildPackage = path31.dirname(__require("module").createRequire(url.pathToFileURL(path31.join(dir, "package.json"))).resolve(platformPackage));
return resolveFile(prebuildPackage);
} catch (error) {
packageResolutionError = error;
}
var target2 = [
"platform=" + platform,
"arch=" + arch,
"runtime=" + runtime,
"abi=" + abi,
"uv=" + uv,
armv ? "armv=" + armv : "",
"libc=" + libc,
"node=" + process.versions.node,
process.versions.electron ? "electron=" + process.versions.electron : "",
typeof __webpack_require__ === "function" ? "webpack=true" : ""
// eslint-disable-line
].filter(Boolean).join(" ");
let errMessage = "No native build was found for " + target2 + "\n attempted loading from: " + dir + " and package: " + platformPackage + "\n";
if (packageNameError) {
errMessage += "Error finding package.json: " + packageNameError.message + "\n";
}
if (packageResolutionError) {
errMessage += "Error resolving package: " + packageResolutionError.message + "\n";
}
throw new Error(errMessage);
function resolve(dir2) {
var tuples = readdirSync(path31.join(dir2, "prebuilds")).map(parseTuple);
var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
if (!tuple) return;
return resolveFile(path31.join(dir2, "prebuilds", tuple.name));
}
function resolveFile(prebuilds) {
var parsed = readdirSync(prebuilds).map(parseTags);
var candidates = parsed.filter(matchTags(runtime, abi));
var winner = candidates.sort(compareTags(runtime))[0];
if (winner) return path31.join(prebuilds, winner.file);
}
};
function readdirSync(dir) {
try {
return fs30.readdirSync(dir);
} catch (err) {
return [];
}
}
function getFirst(dir, filter) {
var files = readdirSync(dir).filter(filter);
return files[0] && path31.join(dir, files[0]);
}
function matchBuild(name) {
return /\.node$/.test(name);
}
function parseTuple(name) {
var arr = name.split("-");
if (arr.length !== 2) return;
var platform2 = arr[0];
var architectures = arr[1].split("+");
if (!platform2) return;
if (!architectures.length) return;
if (!architectures.every(Boolean)) return;
return { name, platform: platform2, architectures };
}
function matchTuple(platform2, arch2) {
return function(tuple) {
if (tuple == null) return false;
if (tuple.platform !== platform2) return false;
return tuple.architectures.includes(arch2);
};
}
function compareTuples(a, b) {
return a.architectures.length - b.architectures.length;
}
function parseTags(file) {
var arr = file.split(".");
var extension = arr.pop();
var tags = { file, specificity: 0 };
if (extension !== "node") return;
for (var i = 0; i < arr.length; i++) {
var tag = arr[i];
if (tag === "node" || tag === "electron" || tag === "node-webkit") {
tags.runtime = tag;
} else if (tag === "napi") {
tags.napi = true;
} else if (tag.slice(0, 3) === "abi") {
tags.abi = tag.slice(3);
} else if (tag.slice(0, 2) === "uv") {
tags.uv = tag.slice(2);
} else if (tag.slice(0, 4) === "armv") {
tags.armv = tag.slice(4);
} else if (tag === "glibc" || tag === "musl") {
tags.libc = tag;
} else {
continue;
}
tags.specificity++;
}
return tags;
}
function matchTags(runtime2, abi2) {
return function(tags) {
if (tags == null) return false;
if (tags.runtime !== runtime2 && !runtimeAgnostic(tags)) return false;
if (tags.abi !== abi2 && !tags.napi) return false;
if (tags.uv && tags.uv !== uv) return false;
if (tags.armv && tags.armv !== armv) return false;
if (tags.libc && tags.libc !== libc) return false;
return true;
};
}
function runtimeAgnostic(tags) {
return tags.runtime === "node" && tags.napi;
}
function compareTags(runtime2) {
return function(a, b) {
if (a.runtime !== b.runtime) {
return a.runtime === runtime2 ? -1 : 1;
} else if (a.abi !== b.abi) {
return a.abi ? -1 : 1;
} else if (a.specificity !== b.specificity) {
return a.specificity > b.specificity ? -1 : 1;
} else {
return 0;
}
};
}
function isNwjs() {
return !!(process.versions && process.versions.nw);
}
function isElectron() {
if (process.versions && process.versions.electron) return true;
if (process.env.ELECTRON_RUN_AS_NODE) return true;
return typeof window !== "undefined" && window.process && window.process.type === "renderer";
}
function isMusl(platform2) {
if (platform2 !== "linux") return false;
const { familySync, MUSL } = require_detect_libc();
return familySync() === MUSL;
}
load.parseTags = parseTags;
load.matchTags = matchTags;
load.compareTags = compareTags;
load.parseTuple = parseTuple;
load.matchTuple = matchTuple;
load.compareTuples = compareTuples;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/node-gyp-build-optional-packages/5.2.2/e2d2fc28f4d0eaa7fac1904123db86f87839f4cdd1ffc0e2b124adc9c1d9f616/node_modules/node-gyp-build-optional-packages/index.js
var require_node_gyp_build_optional_packages = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/node-gyp-build-optional-packages/5.2.2/e2d2fc28f4d0eaa7fac1904123db86f87839f4cdd1ffc0e2b124adc9c1d9f616/node_modules/node-gyp-build-optional-packages/index.js"(exports, module) {
var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
if (typeof runtimeRequire.addon === "function") {
module.exports = runtimeRequire.addon.bind(runtimeRequire);
} else {
module.exports = require_node_gyp_build();
}
}
});
// ../../../../../setup-pnpm/store/v11/links/@/msgpackr-extract/3.0.4/5f2fa3b3518dffb11d9500f22a2d0750c582db5a973c2486eb1a697b6439d322/node_modules/msgpackr-extract/index.js
var require_msgpackr_extract = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/msgpackr-extract/3.0.4/5f2fa3b3518dffb11d9500f22a2d0750c582db5a973c2486eb1a697b6439d322/node_modules/msgpackr-extract/index.js"(exports, module) {
module.exports = require_node_gyp_build_optional_packages()(__dirname);
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/fs/index.js
var require_fs2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/fs/index.js"(exports) {
"use strict";
var u = require_universalify().fromCallback;
var fs30 = require_graceful_fs();
var api = [
"access",
"appendFile",
"chmod",
"chown",
"close",
"copyFile",
"cp",
"fchmod",
"fchown",
"fdatasync",
"fstat",
"fsync",
"ftruncate",
"futimes",
"glob",
"lchmod",
"lchown",
"lutimes",
"link",
"lstat",
"mkdir",
"mkdtemp",
"open",
"opendir",
"readdir",
"readFile",
"readlink",
"realpath",
"rename",
"rm",
"rmdir",
"stat",
"statfs",
"symlink",
"truncate",
"unlink",
"utimes",
"writeFile"
].filter((key) => {
return typeof fs30[key] === "function";
});
Object.assign(exports, fs30);
api.forEach((method) => {
exports[method] = u(fs30[method]);
});
exports.exists = function(filename, callback) {
if (typeof callback === "function") {
return fs30.exists(filename, callback);
}
return new Promise((resolve) => {
return fs30.exists(filename, resolve);
});
};
exports.read = function(fd, buffer, offset, length, position3, callback) {
if (typeof callback === "function") {
return fs30.read(fd, buffer, offset, length, position3, callback);
}
return new Promise((resolve, reject) => {
fs30.read(fd, buffer, offset, length, position3, (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 fs30.write(fd, buffer, ...args);
}
return new Promise((resolve, reject) => {
fs30.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 fs30.readv(fd, buffers, ...args);
}
return new Promise((resolve, reject) => {
fs30.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 fs30.writev(fd, buffers, ...args);
}
return new Promise((resolve, reject) => {
fs30.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
if (err) return reject(err);
resolve({ bytesWritten, buffers: buffers2 });
});
});
};
if (typeof fs30.realpath.native === "function") {
exports.realpath.native = u(fs30.realpath.native);
} else {
process.emitWarning(
"fs.realpath.native is not a function. Is fs being monkey-patched?",
"Warning",
"fs-extra-WARN0003"
);
}
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/mkdirs/utils.js
var require_utils3 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module) {
"use strict";
var path31 = __require("path");
module.exports.checkPath = function checkPath(pth) {
if (process.platform === "win32") {
const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path31.parse(pth).root, ""));
if (pathHasInvalidWinCharacters) {
const error = new Error(`Path contains invalid characters: ${pth}`);
error.code = "EINVAL";
throw error;
}
}
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/mkdirs/make-dir.js
var require_make_dir2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module) {
"use strict";
var fs30 = require_fs2();
var { checkPath } = require_utils3();
var getMode = (options) => {
const defaults = { mode: 511 };
if (typeof options === "number") return options;
return { ...defaults, ...options }.mode;
};
module.exports.makeDir = async (dir, options) => {
checkPath(dir);
return fs30.mkdir(dir, {
mode: getMode(options),
recursive: true
});
};
module.exports.makeDirSync = (dir, options) => {
checkPath(dir);
return fs30.mkdirSync(dir, {
mode: getMode(options),
recursive: true
});
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/mkdirs/index.js
var require_mkdirs2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/mkdirs/index.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var { makeDir: _makeDir, makeDirSync } = require_make_dir2();
var makeDir = u(_makeDir);
module.exports = {
mkdirs: makeDir,
mkdirsSync: makeDirSync,
// alias
mkdirp: makeDir,
mkdirpSync: makeDirSync,
ensureDir: makeDir,
ensureDirSync: makeDirSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/path-exists/index.js
var require_path_exists2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/path-exists/index.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var fs30 = require_fs2();
function pathExists(path31) {
return fs30.access(path31).then(() => true).catch(() => false);
}
module.exports = {
pathExists: u(pathExists),
pathExistsSync: fs30.existsSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/util/utimes.js
var require_utimes2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/util/utimes.js"(exports, module) {
"use strict";
var fs30 = require_fs2();
var u = require_universalify().fromPromise;
async function utimesMillis(path31, atime, mtime) {
const fd = await fs30.open(path31, "r+");
let error = null;
try {
await fs30.futimes(fd, atime, mtime);
} catch (futimesErr) {
error = futimesErr;
} finally {
try {
await fs30.close(fd);
} catch (closeErr) {
if (!error) error = closeErr;
}
}
if (error) {
throw error;
}
}
function utimesMillisSync(path31, atime, mtime) {
const fd = fs30.openSync(path31, "r+");
let error = null;
try {
fs30.futimesSync(fd, atime, mtime);
} catch (futimesErr) {
error = futimesErr;
} finally {
try {
fs30.closeSync(fd);
} catch (closeErr) {
if (!error) error = closeErr;
}
}
if (error) {
throw error;
}
}
module.exports = {
utimesMillis: u(utimesMillis),
utimesMillisSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/util/stat.js
var require_stat2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/util/stat.js"(exports, module) {
"use strict";
var fs30 = require_fs2();
var path31 = __require("path");
var u = require_universalify().fromPromise;
function getStats(src2, dest, opts2) {
const statFunc = opts2.dereference ? (file) => fs30.stat(file, { bigint: true }) : (file) => fs30.lstat(file, { bigint: true });
return Promise.all([
statFunc(src2),
statFunc(dest).catch((err) => {
if (err.code === "ENOENT") return null;
throw err;
})
]).then(([srcStat, destStat]) => ({ srcStat, destStat }));
}
function getStatsSync(src2, dest, opts2) {
let destStat;
const statFunc = opts2.dereference ? (file) => fs30.statSync(file, { bigint: true }) : (file) => fs30.lstatSync(file, { bigint: true });
const srcStat = statFunc(src2);
try {
destStat = statFunc(dest);
} catch (err) {
if (err.code === "ENOENT") return { srcStat, destStat: null };
throw err;
}
return { srcStat, destStat };
}
async function checkPaths(src2, dest, funcName, opts2) {
const { srcStat, destStat } = await getStats(src2, dest, opts2);
if (destStat) {
if (areIdentical(srcStat, destStat)) {
const srcBaseName = path31.basename(src2);
const destBaseName = path31.basename(dest);
if (funcName === "move" && srcBaseName !== destBaseName && isCosmeticRename(srcBaseName, destBaseName)) {
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 '${src2}'.`);
}
if (!srcStat.isDirectory() && destStat.isDirectory()) {
throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src2}'.`);
}
}
if (srcStat.isDirectory() && isSrcSubdir(src2, dest)) {
throw new Error(errMsg(src2, dest, funcName));
}
return { srcStat, destStat };
}
function checkPathsSync(src2, dest, funcName, opts2) {
const { srcStat, destStat } = getStatsSync(src2, dest, opts2);
if (destStat) {
if (areIdentical(srcStat, destStat)) {
const srcBaseName = path31.basename(src2);
const destBaseName = path31.basename(dest);
if (funcName === "move" && srcBaseName !== destBaseName && isCosmeticRename(srcBaseName, destBaseName)) {
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 '${src2}'.`);
}
if (!srcStat.isDirectory() && destStat.isDirectory()) {
throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src2}'.`);
}
}
if (srcStat.isDirectory() && isSrcSubdir(src2, dest)) {
throw new Error(errMsg(src2, dest, funcName));
}
return { srcStat, destStat };
}
function isCosmeticRename(srcBaseName, destBaseName) {
return srcBaseName.toLowerCase().normalize("NFC") === destBaseName.toLowerCase().normalize("NFC");
}
async function checkParentPaths(src2, srcStat, dest, funcName) {
const srcParent = path31.resolve(path31.dirname(src2));
const destParent = path31.resolve(path31.dirname(dest));
if (destParent === srcParent || destParent === path31.parse(destParent).root) return;
let destStat;
try {
destStat = await fs30.stat(destParent, { bigint: true });
} catch (err) {
if (err.code === "ENOENT") return checkParentPaths(src2, srcStat, destParent, funcName);
throw err;
}
if (areIdentical(srcStat, destStat)) {
throw new Error(errMsg(src2, dest, funcName));
}
return checkParentPaths(src2, srcStat, destParent, funcName);
}
function checkParentPathsSync(src2, srcStat, dest, funcName) {
const srcParent = path31.resolve(path31.dirname(src2));
const destParent = path31.resolve(path31.dirname(dest));
if (destParent === srcParent || destParent === path31.parse(destParent).root) return;
let destStat;
try {
destStat = fs30.statSync(destParent, { bigint: true });
} catch (err) {
if (err.code === "ENOENT") return checkParentPathsSync(src2, srcStat, destParent, funcName);
throw err;
}
if (areIdentical(srcStat, destStat)) {
throw new Error(errMsg(src2, dest, funcName));
}
return checkParentPathsSync(src2, srcStat, destParent, funcName);
}
function areIdentical(srcStat, destStat) {
return destStat.ino !== void 0 && destStat.dev !== void 0 && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
}
function isSrcSubdir(src2, dest) {
const srcArr = path31.resolve(src2).split(path31.sep).filter((i) => i);
const destArr = path31.resolve(dest).split(path31.sep).filter((i) => i);
return srcArr.every((cur, i) => destArr[i] === cur);
}
function errMsg(src2, dest, funcName) {
return `Cannot ${funcName} '${src2}' to a subdirectory of itself, '${dest}'.`;
}
module.exports = {
// checkPaths
checkPaths: u(checkPaths),
checkPathsSync,
// checkParent
checkParentPaths: u(checkParentPaths),
checkParentPathsSync,
// Misc
isSrcSubdir,
areIdentical
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/util/async.js
var require_async2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/util/async.js"(exports, module) {
"use strict";
async function asyncIteratorConcurrentProcess(iterator, fn) {
const promises = [];
for await (const item of iterator) {
promises.push(
fn(item).then(
() => null,
(err) => err ?? new Error("unknown error")
)
);
}
await Promise.all(
promises.map(
(promise) => promise.then((possibleErr) => {
if (possibleErr !== null) throw possibleErr;
})
)
);
}
module.exports = {
asyncIteratorConcurrentProcess
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/copy/copy.js
var require_copy3 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/copy/copy.js"(exports, module) {
"use strict";
var fs30 = require_fs2();
var path31 = __require("path");
var { mkdirs } = require_mkdirs2();
var { pathExists } = require_path_exists2();
var { utimesMillis } = require_utimes2();
var stat = require_stat2();
var { asyncIteratorConcurrentProcess } = require_async2();
async function copy2(src2, dest, opts2 = {}) {
if (typeof opts2 === "function") {
opts2 = { filter: 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"
);
}
const { srcStat, destStat } = await stat.checkPaths(src2, dest, "copy", opts2);
await stat.checkParentPaths(src2, srcStat, dest, "copy");
const include = await runFilter(src2, dest, opts2);
if (!include) return;
const destParent = path31.dirname(dest);
const dirExists = await pathExists(destParent);
if (!dirExists) {
await mkdirs(destParent);
}
await getStatsAndPerformCopy(destStat, src2, dest, opts2);
}
async function runFilter(src2, dest, opts2) {
if (!opts2.filter) return true;
return opts2.filter(src2, dest);
}
async function getStatsAndPerformCopy(destStat, src2, dest, opts2) {
const statFn = opts2.dereference ? fs30.stat : fs30.lstat;
const srcStat = await statFn(src2);
if (srcStat.isDirectory()) return onDir(srcStat, destStat, src2, dest, opts2);
if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src2, dest, opts2);
if (srcStat.isSymbolicLink()) return onLink(destStat, src2, dest, opts2);
if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src2}`);
if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src2}`);
throw new Error(`Unknown file: ${src2}`);
}
async function onFile(srcStat, destStat, src2, dest, opts2) {
if (!destStat) return copyFile(srcStat, src2, dest, opts2);
if (opts2.overwrite) {
await fs30.unlink(dest);
return copyFile(srcStat, src2, dest, opts2);
}
if (opts2.errorOnExist) {
throw new Error(`'${dest}' already exists`);
}
}
async function copyFile(srcStat, src2, dest, opts2) {
await fs30.copyFile(src2, dest);
if (opts2.preserveTimestamps) {
if (fileIsNotWritable(srcStat.mode)) {
await makeFileWritable(dest, srcStat.mode);
}
const updatedSrcStat = await fs30.stat(src2);
await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
}
return fs30.chmod(dest, srcStat.mode);
}
function fileIsNotWritable(srcMode) {
return (srcMode & 128) === 0;
}
function makeFileWritable(dest, srcMode) {
return fs30.chmod(dest, srcMode | 128);
}
async function onDir(srcStat, destStat, src2, dest, opts2) {
if (!destStat) {
await fs30.mkdir(dest);
}
await asyncIteratorConcurrentProcess(await fs30.opendir(src2), async (item) => {
const srcItem = path31.join(src2, item.name);
const destItem = path31.join(dest, item.name);
const include = await runFilter(srcItem, destItem, opts2);
if (include) {
const { destStat: destStat2 } = await stat.checkPaths(srcItem, destItem, "copy", opts2);
await getStatsAndPerformCopy(destStat2, srcItem, destItem, opts2);
}
});
if (!destStat) {
await fs30.chmod(dest, srcStat.mode);
}
}
async function onLink(destStat, src2, dest, opts2) {
let resolvedSrc = await fs30.readlink(src2);
if (opts2.dereference) {
resolvedSrc = path31.resolve(process.cwd(), resolvedSrc);
}
if (!destStat) {
return fs30.symlink(resolvedSrc, dest);
}
let resolvedDest = null;
try {
resolvedDest = await fs30.readlink(dest);
} catch (e) {
if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs30.symlink(resolvedSrc, dest);
throw e;
}
if (opts2.dereference) {
resolvedDest = path31.resolve(process.cwd(), resolvedDest);
}
if (resolvedSrc !== 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}'.`);
}
}
await fs30.unlink(dest);
return fs30.symlink(resolvedSrc, dest);
}
module.exports = copy2;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/copy/copy-sync.js
var require_copy_sync2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) {
"use strict";
var fs30 = require_graceful_fs();
var path31 = __require("path");
var mkdirsSync = require_mkdirs2().mkdirsSync;
var utimesMillisSync = require_utimes2().utimesMillisSync;
var stat = require_stat2();
function copySync2(src2, 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(src2, dest, "copy", opts2);
stat.checkParentPathsSync(src2, srcStat, dest, "copy");
if (opts2.filter && !opts2.filter(src2, dest)) return;
const destParent = path31.dirname(dest);
if (!fs30.existsSync(destParent)) mkdirsSync(destParent);
return getStats(destStat, src2, dest, opts2);
}
function getStats(destStat, src2, dest, opts2) {
const statSync = opts2.dereference ? fs30.statSync : fs30.lstatSync;
const srcStat = statSync(src2);
if (srcStat.isDirectory()) return onDir(srcStat, destStat, src2, dest, opts2);
else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src2, dest, opts2);
else if (srcStat.isSymbolicLink()) return onLink(destStat, src2, dest, opts2);
else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src2}`);
else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src2}`);
throw new Error(`Unknown file: ${src2}`);
}
function onFile(srcStat, destStat, src2, dest, opts2) {
if (!destStat) return copyFile(srcStat, src2, dest, opts2);
return mayCopyFile(srcStat, src2, dest, opts2);
}
function mayCopyFile(srcStat, src2, dest, opts2) {
if (opts2.overwrite) {
fs30.unlinkSync(dest);
return copyFile(srcStat, src2, dest, opts2);
} else if (opts2.errorOnExist) {
throw new Error(`'${dest}' already exists`);
}
}
function copyFile(srcStat, src2, dest, opts2) {
fs30.copyFileSync(src2, dest);
if (opts2.preserveTimestamps) handleTimestamps(srcStat.mode, src2, dest);
return setDestMode(dest, srcStat.mode);
}
function handleTimestamps(srcMode, src2, dest) {
if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode);
return setDestTimestamps(src2, dest);
}
function fileIsNotWritable(srcMode) {
return (srcMode & 128) === 0;
}
function makeFileWritable(dest, srcMode) {
return setDestMode(dest, srcMode | 128);
}
function setDestMode(dest, srcMode) {
return fs30.chmodSync(dest, srcMode);
}
function setDestTimestamps(src2, dest) {
const updatedSrcStat = fs30.statSync(src2);
return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
}
function onDir(srcStat, destStat, src2, dest, opts2) {
if (!destStat) return mkDirAndCopy(srcStat.mode, src2, dest, opts2);
return copyDir(src2, dest, opts2);
}
function mkDirAndCopy(srcMode, src2, dest, opts2) {
fs30.mkdirSync(dest);
copyDir(src2, dest, opts2);
return setDestMode(dest, srcMode);
}
function copyDir(src2, dest, opts2) {
const dir = fs30.opendirSync(src2);
try {
let dirent;
while ((dirent = dir.readSync()) !== null) {
copyDirItem(dirent.name, src2, dest, opts2);
}
} finally {
dir.closeSync();
}
}
function copyDirItem(item, src2, dest, opts2) {
const srcItem = path31.join(src2, item);
const destItem = path31.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, src2, dest, opts2) {
let resolvedSrc = fs30.readlinkSync(src2);
if (opts2.dereference) {
resolvedSrc = path31.resolve(process.cwd(), resolvedSrc);
}
if (!destStat) {
return fs30.symlinkSync(resolvedSrc, dest);
} else {
let resolvedDest;
try {
resolvedDest = fs30.readlinkSync(dest);
} catch (err) {
if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs30.symlinkSync(resolvedSrc, dest);
throw err;
}
if (opts2.dereference) {
resolvedDest = path31.resolve(process.cwd(), resolvedDest);
}
if (resolvedSrc !== 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) {
fs30.unlinkSync(dest);
return fs30.symlinkSync(resolvedSrc, dest);
}
module.exports = copySync2;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/copy/index.js
var require_copy4 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/copy/index.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
module.exports = {
copy: u(require_copy3()),
copySync: require_copy_sync2()
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/remove/index.js
var require_remove2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/remove/index.js"(exports, module) {
"use strict";
var fs30 = require_graceful_fs();
var u = require_universalify().fromCallback;
function remove(path31, callback) {
fs30.rm(path31, { recursive: true, force: true }, callback);
}
function removeSync(path31) {
fs30.rmSync(path31, { recursive: true, force: true });
}
module.exports = {
remove: u(remove),
removeSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/empty/index.js
var require_empty2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/empty/index.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var fs30 = require_fs2();
var path31 = __require("path");
var mkdir = require_mkdirs2();
var remove = require_remove2();
var emptyDir = u(async function emptyDir2(dir) {
let items;
try {
items = await fs30.readdir(dir);
} catch (err) {
if (err.code !== "ENOENT") throw err;
return mkdir.mkdirs(dir);
}
return Promise.all(items.map((item) => remove.remove(path31.join(dir, item))));
});
function emptyDirSync(dir) {
let items;
try {
items = fs30.readdirSync(dir);
} catch (err) {
if (err.code !== "ENOENT") throw err;
return mkdir.mkdirsSync(dir);
}
items.forEach((item) => {
item = path31.join(dir, item);
remove.removeSync(item);
});
}
module.exports = {
emptyDirSync,
emptydirSync: emptyDirSync,
emptyDir,
emptydir: emptyDir
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/ensure/file.js
var require_file2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/ensure/file.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var path31 = __require("path");
var fs30 = require_fs2();
var mkdir = require_mkdirs2();
async function createFile(file) {
let stats;
try {
stats = await fs30.stat(file);
} catch {
}
if (stats && stats.isFile()) return;
const dir = path31.dirname(file);
let dirStats = null;
try {
dirStats = await fs30.stat(dir);
} catch (err) {
if (err.code === "ENOENT") {
await mkdir.mkdirs(dir);
await fs30.writeFile(file, "");
return;
} else {
throw err;
}
}
if (dirStats.isDirectory()) {
await fs30.writeFile(file, "");
} else {
await fs30.readdir(dir);
}
}
function createFileSync(file) {
let stats;
try {
stats = fs30.statSync(file);
} catch {
}
if (stats && stats.isFile()) return;
const dir = path31.dirname(file);
try {
if (!fs30.statSync(dir).isDirectory()) {
fs30.readdirSync(dir);
}
} catch (err) {
if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
else throw err;
}
fs30.writeFileSync(file, "");
}
module.exports = {
createFile: u(createFile),
createFileSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/ensure/link.js
var require_link2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/ensure/link.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var path31 = __require("path");
var fs30 = require_fs2();
var mkdir = require_mkdirs2();
var { pathExists } = require_path_exists2();
var { areIdentical } = require_stat2();
async function createLink(srcpath, dstpath) {
let dstStat;
try {
dstStat = await fs30.lstat(dstpath, { bigint: true });
} catch {
}
let srcStat;
try {
srcStat = await fs30.lstat(srcpath, { bigint: true });
} catch (err) {
err.message = err.message.replace("lstat", "ensureLink");
throw err;
}
if (dstStat && areIdentical(srcStat, dstStat)) return;
const dir = path31.dirname(dstpath);
const dirExists = await pathExists(dir);
if (!dirExists) {
await mkdir.mkdirs(dir);
}
await fs30.link(srcpath, dstpath);
}
function createLinkSync(srcpath, dstpath) {
let dstStat;
try {
dstStat = fs30.lstatSync(dstpath, { bigint: true });
} catch {
}
try {
const srcStat = fs30.lstatSync(srcpath, { bigint: true });
if (dstStat && areIdentical(srcStat, dstStat)) return;
} catch (err) {
err.message = err.message.replace("lstat", "ensureLink");
throw err;
}
const dir = path31.dirname(dstpath);
const dirExists = fs30.existsSync(dir);
if (dirExists) return fs30.linkSync(srcpath, dstpath);
mkdir.mkdirsSync(dir);
return fs30.linkSync(srcpath, dstpath);
}
module.exports = {
createLink: u(createLink),
createLinkSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/ensure/symlink-paths.js
var require_symlink_paths2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module) {
"use strict";
var path31 = __require("path");
var fs30 = require_fs2();
var { pathExists } = require_path_exists2();
var u = require_universalify().fromPromise;
async function symlinkPaths(srcpath, dstpath) {
if (path31.isAbsolute(srcpath)) {
try {
await fs30.lstat(srcpath);
} catch (err) {
err.message = err.message.replace("lstat", "ensureSymlink");
throw err;
}
return {
toCwd: srcpath,
toDst: srcpath
};
}
const dstdir = path31.dirname(dstpath);
const relativeToDst = path31.join(dstdir, srcpath);
const exists = await pathExists(relativeToDst);
if (exists) {
return {
toCwd: relativeToDst,
toDst: srcpath
};
}
try {
await fs30.lstat(srcpath);
} catch (err) {
err.message = err.message.replace("lstat", "ensureSymlink");
throw err;
}
return {
toCwd: srcpath,
toDst: path31.relative(dstdir, srcpath)
};
}
function symlinkPathsSync(srcpath, dstpath) {
if (path31.isAbsolute(srcpath)) {
const exists2 = fs30.existsSync(srcpath);
if (!exists2) throw new Error("absolute srcpath does not exist");
return {
toCwd: srcpath,
toDst: srcpath
};
}
const dstdir = path31.dirname(dstpath);
const relativeToDst = path31.join(dstdir, srcpath);
const exists = fs30.existsSync(relativeToDst);
if (exists) {
return {
toCwd: relativeToDst,
toDst: srcpath
};
}
const srcExists = fs30.existsSync(srcpath);
if (!srcExists) throw new Error("relative srcpath does not exist");
return {
toCwd: srcpath,
toDst: path31.relative(dstdir, srcpath)
};
}
module.exports = {
symlinkPaths: u(symlinkPaths),
symlinkPathsSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/ensure/symlink-type.js
var require_symlink_type2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module) {
"use strict";
var fs30 = require_fs2();
var u = require_universalify().fromPromise;
async function symlinkType(srcpath, type) {
if (type) return type;
let stats;
try {
stats = await fs30.lstat(srcpath);
} catch {
return "file";
}
return stats && stats.isDirectory() ? "dir" : "file";
}
function symlinkTypeSync(srcpath, type) {
if (type) return type;
let stats;
try {
stats = fs30.lstatSync(srcpath);
} catch {
return "file";
}
return stats && stats.isDirectory() ? "dir" : "file";
}
module.exports = {
symlinkType: u(symlinkType),
symlinkTypeSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/ensure/symlink.js
var require_symlink2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/ensure/symlink.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var path31 = __require("path");
var fs30 = require_fs2();
var { mkdirs, mkdirsSync } = require_mkdirs2();
var { symlinkPaths, symlinkPathsSync } = require_symlink_paths2();
var { symlinkType, symlinkTypeSync } = require_symlink_type2();
var { pathExists } = require_path_exists2();
var { areIdentical } = require_stat2();
async function createSymlink(srcpath, dstpath, type) {
let stats;
try {
stats = await fs30.lstat(dstpath);
} catch {
}
if (stats && stats.isSymbolicLink()) {
let srcStat;
if (path31.isAbsolute(srcpath)) {
srcStat = await fs30.stat(srcpath, { bigint: true });
} else {
const dstdir = path31.dirname(dstpath);
const relativeToDst = path31.join(dstdir, srcpath);
try {
srcStat = await fs30.stat(relativeToDst, { bigint: true });
} catch {
srcStat = await fs30.stat(srcpath, { bigint: true });
}
}
let dstStat;
try {
dstStat = await fs30.stat(dstpath, { bigint: true });
} catch (err) {
if (err.code !== "ENOENT") throw err;
}
if (dstStat && areIdentical(srcStat, dstStat)) return;
}
const relative = await symlinkPaths(srcpath, dstpath);
srcpath = relative.toDst;
const toType = await symlinkType(relative.toCwd, type);
const dir = path31.dirname(dstpath);
if (!await pathExists(dir)) {
await mkdirs(dir);
}
return fs30.symlink(srcpath, dstpath, toType);
}
function createSymlinkSync2(srcpath, dstpath, type) {
let stats;
try {
stats = fs30.lstatSync(dstpath);
} catch {
}
if (stats && stats.isSymbolicLink()) {
let srcStat;
if (path31.isAbsolute(srcpath)) {
srcStat = fs30.statSync(srcpath, { bigint: true });
} else {
const dstdir = path31.dirname(dstpath);
const relativeToDst = path31.join(dstdir, srcpath);
try {
srcStat = fs30.statSync(relativeToDst, { bigint: true });
} catch {
srcStat = fs30.statSync(srcpath, { bigint: true });
}
}
let dstStat;
try {
dstStat = fs30.statSync(dstpath, { bigint: true });
} catch (err) {
if (err.code !== "ENOENT") throw err;
}
if (dstStat && areIdentical(srcStat, dstStat)) return;
}
const relative = symlinkPathsSync(srcpath, dstpath);
srcpath = relative.toDst;
type = symlinkTypeSync(relative.toCwd, type);
const dir = path31.dirname(dstpath);
const exists = fs30.existsSync(dir);
if (exists) return fs30.symlinkSync(srcpath, dstpath, type);
mkdirsSync(dir);
return fs30.symlinkSync(srcpath, dstpath, type);
}
module.exports = {
createSymlink: u(createSymlink),
createSymlinkSync: createSymlinkSync2
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/ensure/index.js
var require_ensure2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/ensure/index.js"(exports, module) {
"use strict";
var { createFile, createFileSync } = require_file2();
var { createLink, createLinkSync } = require_link2();
var { createSymlink, createSymlinkSync: createSymlinkSync2 } = require_symlink2();
module.exports = {
// file
createFile,
createFileSync,
ensureFile: createFile,
ensureFileSync: createFileSync,
// link
createLink,
createLinkSync,
ensureLink: createLink,
ensureLinkSync: createLinkSync,
// symlink
createSymlink,
createSymlinkSync: createSymlinkSync2,
ensureSymlink: createSymlink,
ensureSymlinkSync: createSymlinkSync2
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/json/jsonfile.js
var require_jsonfile3 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/json/jsonfile.js"(exports, module) {
"use strict";
var jsonFile = require_jsonfile();
module.exports = {
// jsonfile exports
readJson: jsonFile.readFile,
readJsonSync: jsonFile.readFileSync,
writeJson: jsonFile.writeFile,
writeJsonSync: jsonFile.writeFileSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/output-file/index.js
var require_output_file2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/output-file/index.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var fs30 = require_fs2();
var path31 = __require("path");
var mkdir = require_mkdirs2();
var pathExists = require_path_exists2().pathExists;
async function outputFile(file, data, encoding = "utf-8") {
const dir = path31.dirname(file);
if (!await pathExists(dir)) {
await mkdir.mkdirs(dir);
}
return fs30.writeFile(file, data, encoding);
}
function outputFileSync(file, ...args) {
const dir = path31.dirname(file);
if (!fs30.existsSync(dir)) {
mkdir.mkdirsSync(dir);
}
fs30.writeFileSync(file, ...args);
}
module.exports = {
outputFile: u(outputFile),
outputFileSync
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/json/output-json.js
var require_output_json2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/json/output-json.js"(exports, module) {
"use strict";
var { stringify } = require_utils2();
var { outputFile } = require_output_file2();
async function outputJson(file, data, options = {}) {
const str = stringify(data, options);
await outputFile(file, str, options);
}
module.exports = outputJson;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/json/output-json-sync.js
var require_output_json_sync2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/json/output-json-sync.js"(exports, module) {
"use strict";
var { stringify } = require_utils2();
var { outputFileSync } = require_output_file2();
function outputJsonSync(file, data, options) {
const str = stringify(data, options);
outputFileSync(file, str, options);
}
module.exports = outputJsonSync;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/json/index.js
var require_json2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/json/index.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
var jsonFile = require_jsonfile3();
jsonFile.outputJson = u(require_output_json2());
jsonFile.outputJsonSync = require_output_json_sync2();
jsonFile.outputJSON = jsonFile.outputJson;
jsonFile.outputJSONSync = jsonFile.outputJsonSync;
jsonFile.writeJSON = jsonFile.writeJson;
jsonFile.writeJSONSync = jsonFile.writeJsonSync;
jsonFile.readJSON = jsonFile.readJson;
jsonFile.readJSONSync = jsonFile.readJsonSync;
module.exports = jsonFile;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/move/move.js
var require_move3 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/move/move.js"(exports, module) {
"use strict";
var fs30 = require_fs2();
var path31 = __require("path");
var { copy: copy2 } = require_copy4();
var { remove } = require_remove2();
var { mkdirp } = require_mkdirs2();
var { pathExists } = require_path_exists2();
var stat = require_stat2();
async function move(src2, dest, opts2 = {}) {
const overwrite = opts2.overwrite || opts2.clobber || false;
const { srcStat, isChangingCase = false } = await stat.checkPaths(src2, dest, "move", opts2);
await stat.checkParentPaths(src2, srcStat, dest, "move");
const destParent = path31.dirname(dest);
const parsedParentPath = path31.parse(destParent);
if (parsedParentPath.root !== destParent) {
await mkdirp(destParent);
}
return doRename(src2, dest, overwrite, isChangingCase);
}
async function doRename(src2, dest, overwrite, isChangingCase) {
if (!isChangingCase) {
if (overwrite) {
await remove(dest);
} else if (await pathExists(dest)) {
throw new Error("dest already exists.");
}
}
try {
await fs30.rename(src2, dest);
} catch (err) {
if (err.code !== "EXDEV") {
throw err;
}
await moveAcrossDevice(src2, dest, overwrite);
}
}
async function moveAcrossDevice(src2, dest, overwrite) {
const opts2 = {
overwrite,
errorOnExist: true,
preserveTimestamps: true
};
await copy2(src2, dest, opts2);
return remove(src2);
}
module.exports = move;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/move/move-sync.js
var require_move_sync2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/move/move-sync.js"(exports, module) {
"use strict";
var fs30 = require_graceful_fs();
var path31 = __require("path");
var copySync2 = require_copy4().copySync;
var removeSync = require_remove2().removeSync;
var mkdirpSync = require_mkdirs2().mkdirpSync;
var stat = require_stat2();
function moveSync(src2, dest, opts2) {
opts2 = opts2 || {};
const overwrite = opts2.overwrite || opts2.clobber || false;
const { srcStat, isChangingCase = false } = stat.checkPathsSync(src2, dest, "move", opts2);
stat.checkParentPathsSync(src2, srcStat, dest, "move");
if (!isParentRoot(dest)) mkdirpSync(path31.dirname(dest));
return doRename(src2, dest, overwrite, isChangingCase);
}
function isParentRoot(dest) {
const parent = path31.dirname(dest);
const parsedPath = path31.parse(parent);
return parsedPath.root === parent;
}
function doRename(src2, dest, overwrite, isChangingCase) {
if (isChangingCase) return rename(src2, dest, overwrite);
if (overwrite) {
removeSync(dest);
return rename(src2, dest, overwrite);
}
if (fs30.existsSync(dest)) throw new Error("dest already exists.");
return rename(src2, dest, overwrite);
}
function rename(src2, dest, overwrite) {
try {
fs30.renameSync(src2, dest);
} catch (err) {
if (err.code !== "EXDEV") throw err;
return moveAcrossDevice(src2, dest, overwrite);
}
}
function moveAcrossDevice(src2, dest, overwrite) {
const opts2 = {
overwrite,
errorOnExist: true,
preserveTimestamps: true
};
copySync2(src2, dest, opts2);
return removeSync(src2);
}
module.exports = moveSync;
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/move/index.js
var require_move4 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/move/index.js"(exports, module) {
"use strict";
var u = require_universalify().fromPromise;
module.exports = {
move: u(require_move3()),
moveSync: require_move_sync2()
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/index.js
var require_lib5 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/fs-extra/11.4.1/bf276894486fae379ebf7a9c563bd39c312837555973484a9a8f0c6d4c934f3e/node_modules/fs-extra/lib/index.js"(exports, module) {
"use strict";
module.exports = {
// Export promiseified graceful-fs:
...require_fs2(),
// Export extra methods:
...require_copy4(),
...require_empty2(),
...require_ensure2(),
...require_json2(),
...require_mkdirs2(),
...require_move4(),
...require_output_file2(),
...require_path_exists2(),
...require_remove2()
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/truncate-utf8-bytes/1.0.2/a125ab6f857e769c1c35dafd31e6b108b9a2517e088148da14ad32169c2567ee/node_modules/truncate-utf8-bytes/lib/truncate.js
var require_truncate2 = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/truncate-utf8-bytes/1.0.2/a125ab6f857e769c1c35dafd31e6b108b9a2517e088148da14ad32169c2567ee/node_modules/truncate-utf8-bytes/lib/truncate.js"(exports, module) {
"use strict";
function isHighSurrogate(codePoint) {
return codePoint >= 55296 && codePoint <= 56319;
}
function isLowSurrogate(codePoint) {
return codePoint >= 56320 && codePoint <= 57343;
}
module.exports = function truncate(getLength, string, byteLength) {
if (typeof string !== "string") {
throw new Error("Input must be string");
}
var charLength = string.length;
var curByteLength = 0;
var codePoint;
var segment;
for (var i = 0; i < charLength; i += 1) {
codePoint = string.charCodeAt(i);
segment = string[i];
if (isHighSurrogate(codePoint) && isLowSurrogate(string.charCodeAt(i + 1))) {
i += 1;
segment += string[i];
}
curByteLength += getLength(segment);
if (curByteLength === byteLength) {
return string.slice(0, i + 1);
} else if (curByteLength > byteLength) {
return string.slice(0, i - segment.length + 1);
}
}
return string;
};
}
});
// ../../../../../setup-pnpm/store/v11/links/@/truncate-utf8-bytes/1.0.2/a125ab6f857e769c1c35dafd31e6b108b9a2517e088148da14ad32169c2567ee/node_modules/truncate-utf8-bytes/index.js
var require_truncate_utf8_bytes = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/truncate-utf8-bytes/1.0.2/a125ab6f857e769c1c35dafd31e6b108b9a2517e088148da14ad32169c2567ee/node_modules/truncate-utf8-bytes/index.js"(exports, module) {
"use strict";
var truncate = require_truncate2();
var getLength = Buffer.byteLength.bind(Buffer);
module.exports = truncate.bind(null, getLength);
}
});
// ../../../../../setup-pnpm/store/v11/links/@/sanitize-filename/1.6.4/5f553bde92425a76e0b51eddf2a9a22faa7626146298aecdcafaf8de748aa2e6/node_modules/sanitize-filename/index.js
var require_sanitize_filename = __commonJS({
"../../../../../setup-pnpm/store/v11/links/@/sanitize-filename/1.6.4/5f553bde92425a76e0b51eddf2a9a22faa7626146298aecdcafaf8de748aa2e6/node_modules/sanitize-filename/index.js"(exports, module) {
"use strict";
var truncate = require_truncate_utf8_bytes();
var illegalRe = /[\/\?<>\\:\*\|"]/g;
var controlRe = /[\x00-\x1f\x80-\x9f]/g;
var reservedRe = /^\.+$/;
var windowsReservedRe = /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/i;
function replaceTrailingDotsAndSpaces(str, replacement) {
var end = str.length;
while (end > 0 && (str[end - 1] === "." || str[end - 1] === " ")) end--;
return end < str.length ? str.slice(0, end) + replacement : str;
}
function sanitize(input, replacement) {
if (typeof input !== "string") {
throw new Error("Input must be string");
}
var sanitized = input.replace(illegalRe, replacement).replace(controlRe, replacement).replace(reservedRe, replacement).replace(windowsReservedRe, replacement);
sanitized = replaceTrailingDotsAndSpaces(sanitized, replacement);
return truncate(sanitized, 255);
}
module.exports = function(input, options) {
var replacement = options && options.replacement || "";
var output = sanitize(input, replacement);
if (replacement === "") {
return output;
}
return sanitize(output, "");
};
}
});
// ../worker/lib/start.js
import fs29 from "node:fs";
import path30 from "node:path";
import { parentPort } from "node:worker_threads";
// ../fs/hard-link-dir/lib/index.js
import assert from "node:assert";
import fs2 from "node:fs";
import path2 from "node:path";
// ../core/error/lib/index.js
import util from "node:util";
// ../core/constants/lib/index.js
var LOCKFILE_MAJOR_VERSION = "9";
var LOCKFILE_VERSION = `${LOCKFILE_MAJOR_VERSION}.0`;
var ENGINE_NAME = `${process.platform};${process.arch};node${process.version.split(".")[0].substring(1)}`;
var BUILTIN_REGISTRIES_BY_PREFIX = Object.freeze({
gh: "https://npm.pkg.github.com/",
npmjs: "https://registry.npmjs.org/"
});
// ../core/error/lib/index.js
var PnpmError = class extends Error {
code;
hint;
attempts;
prefix;
pkgsStack;
constructor(code, message, opts2) {
super(message, { cause: opts2?.cause });
this.code = code.startsWith("ERR_PNPM_") ? code : `ERR_PNPM_${code}`;
this.hint = opts2?.hint;
this.attempts = opts2?.attempts;
}
};
function isError(value) {
return util.types.isNativeError(value) || value instanceof Error;
}
// ../fs/graceful-fs/lib/index.js
import fs from "node:fs";
import os from "node:os";
import { promisify } from "node:util";
var import_graceful_fs = __toESM(require_graceful_fs(), 1);
var FILE_LOCK_RETRY_BUDGET_MS = 6e4;
var PERMISSION_DENIED_RETRY_BUDGET_MS = 1e3;
var FILE_LOCK_RETRY_BACKOFF_CAP_MS = 100;
var fileLockRetrySleepBuffer = new Int32Array(new SharedArrayBuffer(4));
var lib_default = {
chmod: promisify(import_graceful_fs.default.chmod),
copyFile: promisify(import_graceful_fs.default.copyFile),
copyFileSync: withEagainRetry(import_graceful_fs.default.copyFileSync),
createReadStream: import_graceful_fs.default.createReadStream,
link: promisify(import_graceful_fs.default.link),
linkSync: withEagainRetry(import_graceful_fs.default.linkSync),
mkdir: promisify(import_graceful_fs.default.mkdir),
mkdirSync: withEagainRetry(import_graceful_fs.default.mkdirSync),
renameSync: withEagainRetry(import_graceful_fs.default.renameSync),
readFile: promisify(import_graceful_fs.default.readFile),
readFileSync: import_graceful_fs.default.readFileSync,
readdirSync: import_graceful_fs.default.readdirSync,
stat: promisify(import_graceful_fs.default.stat),
statSync: import_graceful_fs.default.statSync,
unlink: promisify(import_graceful_fs.default.unlink),
unlinkSync: import_graceful_fs.default.unlinkSync,
writeFile: promisify(import_graceful_fs.default.writeFile),
writeFileSync: withEagainRetry(import_graceful_fs.default.writeFileSync)
};
function withEagainRetry(fn, maxRetries = 15) {
return (...args) => {
let attempts = 0;
while (attempts <= maxRetries) {
const outcome = tryCallWithEagain(fn, args, attempts, maxRetries);
if (outcome.success)
return outcome.value;
attempts = outcome.attempts;
}
throw new Error("Unreachable");
};
}
function tryCallWithEagain(fn, args, attempts, maxRetries) {
try {
return { success: true, value: fn(...args) };
} catch (err) {
if (!isEagainError(err) || attempts >= maxRetries)
throw err;
const nextAttempts = attempts + 1;
waitEagainBackoff(nextAttempts);
return { success: false, attempts: nextAttempts };
}
}
function isEagainError(err) {
return isError(err) && "code" in err && err.code === "EAGAIN";
}
function waitEagainBackoff(attempts) {
const delay = Math.min(Math.pow(2, attempts), 300);
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delay);
}
function renameFileWithRetry(src2, dest) {
withFileLockRetry(() => {
fs.renameSync(src2, dest);
});
}
function lstatWithRetry(target2) {
return withFileLockRetry(() => fs.lstatSync(target2));
}
function unlinkWithRetry(target2) {
withFileLockRetry(() => {
fs.unlinkSync(target2);
});
}
function withFileLockRetry(operation) {
const retry = createFileLockRetry();
for (; ; ) {
try {
return operation();
} catch (err) {
const delayMs = retry.delayBeforeNextAttempt(err);
if (delayMs > 0)
Atomics.wait(fileLockRetrySleepBuffer, 0, 0, delayMs);
retry.checkBudgetAfterDelay(err);
}
}
}
function createFileLockRetry() {
const startedAt = Date.now();
let backoffMs = 0;
let budgetMs = FILE_LOCK_RETRY_BUDGET_MS;
return {
delayBeforeNextAttempt(err) {
if (!isTransientFileLockError(err))
throw err;
if (err.code === "EPERM" || err.code === "EACCES")
budgetMs = Math.min(budgetMs, PERMISSION_DENIED_RETRY_BUDGET_MS);
const remainingMs = budgetMs - (Date.now() - startedAt);
if (remainingMs <= 0)
throw err;
return Math.min(backoffMs, remainingMs);
},
checkBudgetAfterDelay(err) {
if (Date.now() - startedAt >= budgetMs)
throw err;
backoffMs = Math.min(backoffMs + 10, FILE_LOCK_RETRY_BACKOFF_CAP_MS);
}
};
}
function isTransientFileLockError(err) {
return (process.platform === "win32" || isWsl()) && isError(err) && "code" in err && (err.code === "EPERM" || err.code === "EACCES" || err.code === "EBUSY");
}
function isWsl() {
return process.platform === "linux" && os.release().toLowerCase().includes("microsoft");
}
// ../core/logger/lib/logger.js
var import_bole = __toESM(require_bole(), 1);
import_bole.default.setFastTime();
var logger = (0, import_bole.default)("pnpm");
var globalLogger = (0, import_bole.default)("pnpm:global");
function globalWarn(message) {
globalLogger.warn(message);
}
function globalInfo(message) {
globalLogger.info(message);
}
// ../core/logger/lib/streamParser.js
var import_bole2 = __toESM(require_bole(), 1);
// ../core/logger/lib/ndjsonParse.js
var import_split2 = __toESM(require_split2(), 1);
var opts = { strict: true };
function parse() {
function parseRow(row) {
try {
if (row)
return JSON.parse(row);
} catch (_e) {
if (opts.strict) {
this.emit("error", new Error(`Could not parse row "${row.length > 50 ? `${row.slice(0, 50)}...` : row}"`));
}
}
}
return (0, import_split2.default)(parseRow, opts);
}
// ../core/logger/lib/streamParser.js
var streamParser = createStreamParser();
function createStreamParser() {
const sp = parse();
import_bole2.default.output([
{
level: "debug",
stream: sp
}
]);
return sp;
}
// ../core/logger/lib/writeToConsole.js
var import_bole3 = __toESM(require_bole(), 1);
// ../../../../../setup-pnpm/store/v11/links/@/path-temp/3.0.0/8b4b1aa7fd55674c92bd1b76de62ec746ab9b416377d8b2ecb6a51c4d56db367/node_modules/path-temp/index.js
import path from "node:path";
// ../../../../../setup-pnpm/store/v11/links/@/crypto-random-string/4.0.0/62825d7a2c34eedb81d0d583bb2f53f6aba7872f7f7458f24e1bf78c432f86ed/node_modules/crypto-random-string/index.js
import { promisify as promisify2 } from "util";
import crypto from "crypto";
var randomBytesAsync = promisify2(crypto.randomBytes);
var urlSafeCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~".split("");
var numericCharacters = "0123456789".split("");
var distinguishableCharacters = "CDEHKMPRTUWXY012458".split("");
var asciiPrintableCharacters = "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~".split("");
var alphanumericCharacters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".split("");
var generateForCustomCharacters = (length, characters) => {
const characterCount = characters.length;
const maxValidSelector = Math.floor(65536 / characterCount) * characterCount - 1;
const entropyLength = 2 * Math.ceil(1.1 * length);
let string = "";
let stringLength = 0;
while (stringLength < length) {
const entropy = crypto.randomBytes(entropyLength);
let entropyPosition = 0;
while (entropyPosition < entropyLength && stringLength < length) {
const entropyValue = entropy.readUInt16LE(entropyPosition);
entropyPosition += 2;
if (entropyValue > maxValidSelector) {
continue;
}
string += characters[entropyValue % characterCount];
stringLength++;
}
}
return string;
};
var generateForCustomCharactersAsync = async (length, characters) => {
const characterCount = characters.length;
const maxValidSelector = Math.floor(65536 / characterCount) * characterCount - 1;
const entropyLength = 2 * Math.ceil(1.1 * length);
let string = "";
let stringLength = 0;
while (stringLength < length) {
const entropy = await randomBytesAsync(entropyLength);
let entropyPosition = 0;
while (entropyPosition < entropyLength && stringLength < length) {
const entropyValue = entropy.readUInt16LE(entropyPosition);
entropyPosition += 2;
if (entropyValue > maxValidSelector) {
continue;
}
string += characters[entropyValue % characterCount];
stringLength++;
}
}
return string;
};
var generateRandomBytes = (byteLength, type, length) => crypto.randomBytes(byteLength).toString(type).slice(0, length);
var generateRandomBytesAsync = async (byteLength, type, length) => {
const buffer = await randomBytesAsync(byteLength);
return buffer.toString(type).slice(0, length);
};
var allowedTypes = /* @__PURE__ */ new Set([
void 0,
"hex",
"base64",
"url-safe",
"numeric",
"distinguishable",
"ascii-printable",
"alphanumeric"
]);
var createGenerator = (generateForCustomCharacters2, generateRandomBytes2) => ({ length, type, characters }) => {
if (!(length >= 0 && Number.isFinite(length))) {
throw new TypeError("Expected a `length` to be a non-negative finite number");
}
if (type !== void 0 && characters !== void 0) {
throw new TypeError("Expected either `type` or `characters`");
}
if (characters !== void 0 && typeof characters !== "string") {
throw new TypeError("Expected `characters` to be string");
}
if (!allowedTypes.has(type)) {
throw new TypeError(`Unknown type: ${type}`);
}
if (type === void 0 && characters === void 0) {
type = "hex";
}
if (type === "hex" || type === void 0 && characters === void 0) {
return generateRandomBytes2(Math.ceil(length * 0.5), "hex", length);
}
if (type === "base64") {
return generateRandomBytes2(Math.ceil(length * 0.75), "base64", length);
}
if (type === "url-safe") {
return generateForCustomCharacters2(length, urlSafeCharacters);
}
if (type === "numeric") {
return generateForCustomCharacters2(length, numericCharacters);
}
if (type === "distinguishable") {
return generateForCustomCharacters2(length, distinguishableCharacters);
}
if (type === "ascii-printable") {
return generateForCustomCharacters2(length, asciiPrintableCharacters);
}
if (type === "alphanumeric") {
return generateForCustomCharacters2(length, alphanumericCharacters);
}
if (characters.length === 0) {
throw new TypeError("Expected `characters` string length to be greater than or equal to 1");
}
if (characters.length > 65536) {
throw new TypeError("Expected `characters` string length to be less or equal to 65536");
}
return generateForCustomCharacters2(length, characters.split(""));
};
var cryptoRandomString = createGenerator(generateForCustomCharacters, generateRandomBytes);
cryptoRandomString.async = createGenerator(generateForCustomCharactersAsync, generateRandomBytesAsync);
// ../../../../../setup-pnpm/store/v11/links/@/path-temp/3.0.0/8b4b1aa7fd55674c92bd1b76de62ec746ab9b416377d8b2ecb6a51c4d56db367/node_modules/path-temp/index.js
import { threadId } from "node:worker_threads";
function fastPathTemp(file) {
return path.join(path.dirname(file), `${path.basename(file)}_tmp_${process.pid}_${threadId}`);
}
// ../fs/hard-link-dir/lib/index.js
function hardLinkDir(src2, destDirs) {
const targetDirs = destDirs.filter((destDir) => path2.relative(destDir, src2) !== "");
if (targetDirs.length === 0)
return;
for (const targetDir of targetDirs) {
lib_default.mkdirSync(targetDir, { recursive: true });
}
_hardLinkDir(src2, targetDirs, true);
}
function _hardLinkDir(src2, destDirs, isRoot) {
const files = readSourceFiles(src2, destDirs, isRoot);
if (!files)
return;
for (const file of files) {
if (file === "node_modules")
continue;
const srcFile = path2.join(src2, file);
const srcStats = fs2.lstatSync(srcFile, { bigint: true });
if (srcStats.isDirectory()) {
hardLinkSubdir(srcFile, file, destDirs);
} else {
hardLinkFileEntry(srcFile, file, destDirs, srcStats);
}
}
}
function readSourceFiles(src2, destDirs, isRoot) {
try {
return fs2.readdirSync(src2);
} catch (err) {
if (!isRoot || !(isError(err) && "code" in err && err.code === "ENOENT"))
throw err;
globalWarn(`Source directory not found when creating hardLinks for: ${src2}. Creating destinations as empty: ${destDirs.join(", ")}`);
return null;
}
}
function hardLinkSubdir(srcFile, file, destDirs) {
const destSubdirs = destDirs.map((destDir) => {
const destSubdir = path2.join(destDir, file);
clearMismatchedDirent(destSubdir, true);
try {
lib_default.mkdirSync(destSubdir, { recursive: true });
} catch (err) {
if (!(isError(err) && "code" in err && err.code === "EEXIST"))
throw err;
}
return destSubdir;
});
_hardLinkDir(srcFile, destSubdirs);
}
function hardLinkFileEntry(srcFile, file, destDirs, srcStats) {
for (const destDir of destDirs) {
const destFile = path2.join(destDir, file);
try {
linkOrCopyFile(srcFile, destFile, srcStats);
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOENT") {
continue;
}
throw err;
}
}
}
function linkOrCopyFile(srcFile, destFile, srcStats) {
try {
linkOrCopy(srcFile, destFile);
return;
} catch (err) {
assert(isError(err));
if ("code" in err && err.code === "ENOENT") {
lib_default.mkdirSync(path2.dirname(destFile), { recursive: true });
linkOrCopy(srcFile, destFile);
return;
}
if (!("code" in err && err.code === "EEXIST")) {
throw err;
}
}
if (isSameFile(destFile, srcStats))
return;
replaceFile(srcFile, destFile);
}
function isSameFile(destFile, srcStats) {
let destStats;
try {
destStats = fs2.lstatSync(destFile, { bigint: true });
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOENT")
return false;
throw err;
}
return destStats.ino !== 0n && destStats.dev !== 0n && destStats.ino === srcStats.ino && destStats.dev === srcStats.dev;
}
function replaceFile(srcFile, destFile) {
const tempFile = fastPathTemp(destFile);
fs2.rmSync(tempFile, { recursive: true, force: true });
try {
linkOrCopy(srcFile, tempFile);
clearMismatchedDirent(destFile, false);
renameFileWithRetry(tempFile, destFile);
} catch (err) {
try {
fs2.unlinkSync(tempFile);
} catch {
}
throw err;
}
}
function clearMismatchedDirent(destPath, wantDirectory) {
let stats;
try {
stats = fs2.lstatSync(destPath);
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOENT")
return;
throw err;
}
if (stats.isDirectory() === wantDirectory)
return;
fs2.rmSync(destPath, { recursive: true, force: true });
}
function linkOrCopy(srcFile, destFile) {
try {
lib_default.linkSync(srcFile, destFile);
} catch (err) {
if (isError(err) && "code" in err && (err.code === "EXDEV" || err.code === "ENOENT")) {
lib_default.copyFileSync(srcFile, destFile);
} else {
throw err;
}
}
}
// ../core/core-loggers/lib/contextLogger.js
var contextLogger = logger("context");
// ../core/core-loggers/lib/deprecationLogger.js
var deprecationLogger = logger("deprecation");
// ../core/core-loggers/lib/executionTimeLogger.js
var executionTimeLogger = logger("execution-time");
// ../core/core-loggers/lib/fetchingProgressLogger.js
var fetchingProgressLogger = logger("fetching-progress");
// ../core/core-loggers/lib/hookLogger.js
var hookLogger = logger("hook");
// ../core/core-loggers/lib/ignoredScriptsLogger.js
var ignoredScriptsLogger = logger("ignored-scripts");
// ../core/core-loggers/lib/installCheckLogger.js
var installCheckLogger = logger("install-check");
// ../core/core-loggers/lib/installingConfigDeps.js
var installingConfigDepsLogger = logger("installing-config-deps");
// ../core/core-loggers/lib/lifecycleLogger.js
var lifecycleLogger = logger("lifecycle");
// ../core/core-loggers/lib/linkLogger.js
var linkLogger = logger("link");
// ../core/core-loggers/lib/lockfileVerificationLogger.js
var lockfileVerificationLogger = logger("lockfile-verification");
// ../core/core-loggers/lib/packageImportMethodLogger.js
var packageImportMethodLogger = logger("package-import-method");
// ../core/core-loggers/lib/packageManifestLogger.js
var packageManifestLogger = logger("package-manifest");
// ../core/core-loggers/lib/peerDependencyIssues.js
var peerDependencyIssuesLogger = logger("peer-dependency-issues");
// ../core/core-loggers/lib/progressLogger.js
var progressLogger = logger("progress");
// ../core/core-loggers/lib/promptLogger.js
var promptLogger = logger("prompt");
// ../core/core-loggers/lib/removalLogger.js
var removalLogger = logger("removal");
// ../core/core-loggers/lib/requestRetryLogger.js
var requestRetryLogger = logger("request-retry");
// ../core/core-loggers/lib/rootLogger.js
var rootLogger = logger("root");
// ../core/core-loggers/lib/scopeLogger.js
var scopeLogger = logger("scope");
// ../core/core-loggers/lib/skippedOptionalDependencyLogger.js
var skippedOptionalDependencyLogger = logger("skipped-optional-dependency");
// ../core/core-loggers/lib/stageLogger.js
var stageLogger = logger("stage");
// ../core/core-loggers/lib/statsLogger.js
var statsLogger = logger("stats");
// ../core/core-loggers/lib/summaryLogger.js
var summaryLogger = logger("summary");
// ../core/core-loggers/lib/updateCheckLogger.js
var updateCheckLogger = logger("update-check");
// ../../../../../setup-pnpm/store/v11/links/@/better-path-resolve/2.0.0/e066f8a0a157777f698ec4707dc0026edc830ea8827eeb29a3d32906ea207d48/node_modules/better-path-resolve/index.js
var import_is_windows = __toESM(require_is_windows(), 1);
import path3 from "node:path";
var betterPathResolve = (0, import_is_windows.default)() ? winResolve : path3.resolve;
function winResolve(p) {
if (arguments.length === 0) return path3.resolve();
if (typeof p !== "string") {
return path3.resolve(p);
}
if (p[1] === ":") {
const cc = p[0].charCodeAt();
if (cc < 65 || cc > 90) {
p = `${p[0].toUpperCase()}${p.substr(1)}`;
}
}
if (p.endsWith(":")) {
return p;
}
return path3.resolve(p);
}
// ../../../../../setup-pnpm/store/v11/links/@/symlink-dir/10.0.3/4d43271197febf0032f6310ea36ada870bf89dea8eadbcea81d00275dc8fe840/node_modules/symlink-dir/dist/index.js
import { promises as fs5, symlinkSync, mkdirSync, readlinkSync, unlinkSync } from "fs";
import { types } from "util";
import pathLib from "path";
// ../../../../../setup-pnpm/store/v11/links/@/rename-overwrite/7.0.1/87428b418e43a94bf7c7f463bfc62ae5e0dc2e0a72cb36b94d07cf207fc3347b/node_modules/rename-overwrite/index.js
var import_fs_extra = __toESM(require_lib(), 1);
import crypto2 from "node:crypto";
import fs4 from "node:fs";
import path4 from "node:path";
// ../../../../../setup-pnpm/store/v11/links/@zkochan/rimraf/4.0.0/e7aeecc18d1d120ecda04415cbe146a0ad1e4d158a9823e79bfdce5ee3173719/node_modules/@zkochan/rimraf/index.js
import fs3 from "node:fs";
function rimrafSync(p) {
try {
fs3.rmSync(p, { recursive: true, force: true, maxRetries: 3 });
} catch (err) {
if (err.code === "ENOENT") return;
throw err;
}
}
// ../../../../../setup-pnpm/store/v11/links/@/rename-overwrite/7.0.1/87428b418e43a94bf7c7f463bfc62ae5e0dc2e0a72cb36b94d07cf207fc3347b/node_modules/rename-overwrite/index.js
var { copySync, copy } = import_fs_extra.default;
function renameOverwriteSync(oldPath, newPath, retry = 0) {
try {
fs4.renameSync(oldPath, newPath);
} catch (err) {
retry++;
if (retry > 3) throw err;
switch (err.code) {
// Windows Antivirus issues
case "EPERM":
case "EACCESS":
case "EBUSY": {
try {
rimrafSync(newPath);
} catch {
}
const start = Date.now();
let backoff = 0;
let lastError = err;
while (Date.now() - start < 6e4 && (lastError.code === "EPERM" || lastError.code === "EACCESS" || lastError.code === "EBUSY")) {
const waitUntil = Date.now() + backoff;
while (waitUntil > Date.now()) {
}
try {
fs4.renameSync(oldPath, newPath);
return;
} catch (err2) {
lastError = err2;
}
if (backoff < 100) {
backoff += 10;
}
}
throw lastError;
}
case "ENOTEMPTY":
case "EEXIST":
case "ENOTDIR":
try {
swapRenameSync(oldPath, newPath);
} catch {
rimrafSync(newPath);
fs4.renameSync(oldPath, newPath);
}
break;
case "ENOENT":
fs4.mkdirSync(path4.dirname(newPath), { recursive: true });
renameOverwriteSync(oldPath, newPath, retry);
return;
// Crossing filesystem boundaries so rename is not available
case "EXDEV":
try {
rimrafSync(newPath);
} catch (rimrafErr) {
if (rimrafErr.code !== "ENOENT") {
throw rimrafErr;
}
}
copySync(oldPath, newPath);
rimrafSync(oldPath);
break;
default:
throw err;
}
}
}
function tempPath(p) {
return `${p}_${process.pid.toString(16)}_${crypto2.randomBytes(4).toString("hex")}`;
}
function swapRenameSync(oldPath, newPath) {
const temp = tempPath(newPath);
fs4.renameSync(newPath, temp);
try {
fs4.renameSync(oldPath, newPath);
} catch (err) {
try {
fs4.renameSync(temp, newPath);
} catch {
}
throw err;
}
try {
rimrafSync(temp);
} catch {
}
}
// ../../../../../setup-pnpm/store/v11/links/@/symlink-dir/10.0.3/4d43271197febf0032f6310ea36ada870bf89dea8eadbcea81d00275dc8fe840/node_modules/symlink-dir/dist/index.js
var IS_WINDOWS = process.platform === "win32" || /^(msys|cygwin)$/.test(process.env.OSTYPE);
function resolveSrcOnWinJunction(src2) {
return `${src2}\\`;
}
function resolveSrcOnTrueSymlink(src2, dest) {
return pathLib.relative(pathLib.dirname(dest), src2);
}
function symlinkDirSync(target2, path31, opts2) {
path31 = betterPathResolve(path31);
target2 = betterPathResolve(target2);
if (target2 === path31)
throw new Error(`Symlink path is the same as the target path (${target2})`);
return forceSymlinkSync(target2, path31, opts2);
}
function isExistingSymlinkUpToDate(wantedTarget, path31, linkString) {
const existingTarget = pathLib.isAbsolute(linkString) ? linkString : pathLib.join(pathLib.dirname(path31), linkString);
return pathLib.relative(wantedTarget, existingTarget) === "";
}
var createSymlinkAsync;
var createSymlinkSync;
if (IS_WINDOWS) {
createSymlinkAsync = async (target2, path31) => {
try {
await createTrueSymlinkAsync(target2, path31);
createSymlinkSync = createTrueSymlinkSync;
createSymlinkAsync = createTrueSymlinkAsync;
} catch (err) {
if (err.code === "EPERM") {
await createJunctionAsync(target2, path31);
createSymlinkSync = createJunctionSync;
createSymlinkAsync = createJunctionAsync;
} else {
throw err;
}
}
};
createSymlinkSync = (target2, path31) => {
try {
createTrueSymlinkSync(target2, path31);
createSymlinkSync = createTrueSymlinkSync;
createSymlinkAsync = createTrueSymlinkAsync;
} catch (err) {
if (err.code === "EPERM") {
createJunctionSync(target2, path31);
createSymlinkSync = createJunctionSync;
createSymlinkAsync = createJunctionAsync;
} else {
throw err;
}
}
};
} else {
createSymlinkAsync = createTrueSymlinkAsync;
createSymlinkSync = createTrueSymlinkSync;
}
function createTrueSymlinkAsync(target2, path31) {
return fs5.symlink(resolveSrcOnTrueSymlink(target2, path31), path31, "dir");
}
function createTrueSymlinkSync(target2, path31) {
symlinkSync(resolveSrcOnTrueSymlink(target2, path31), path31, "dir");
}
function createJunctionAsync(target2, path31) {
return fs5.symlink(resolveSrcOnWinJunction(target2), path31, "junction");
}
function createJunctionSync(target2, path31) {
symlinkSync(resolveSrcOnWinJunction(target2), path31, "junction");
}
var TRANSIENT_REFUSAL_CODES = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
var PERMISSION_REFUSAL_CODES = /* @__PURE__ */ new Set(["EPERM", "EACCES"]);
var REFUSAL_BUDGET_MS = 6e4;
var PERMISSION_REFUSAL_BUDGET_MS = 1e3;
var MAX_BACKOFF_MS = 100;
function refusalCode(err) {
if (!IS_WINDOWS || !types.isNativeError(err) || !("code" in err))
return void 0;
const code = err.code;
return TRANSIENT_REFUSAL_CODES.has(code) ? code : void 0;
}
function budgetFor(code) {
return PERMISSION_REFUSAL_CODES.has(code) ? PERMISSION_REFUSAL_BUDGET_MS : REFUSAL_BUDGET_MS;
}
function readlinkSyncWaitingOutARefusal(path31) {
const started = Date.now();
let deadline = Number.POSITIVE_INFINITY;
let backoff = 0;
while (true) {
try {
return readlinkSync(path31);
} catch (err) {
const code = refusalCode(err);
if (code == null)
throw err;
deadline = Math.min(deadline, started + budgetFor(code));
if (Date.now() >= deadline)
throw err;
sleepSync(backoff);
backoff = Math.min(backoff + 10, MAX_BACKOFF_MS);
}
}
}
function sleepSync(ms) {
if (ms === 0)
return;
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
}
function forceSymlinkSync(target2, path31, opts2) {
let initialErr;
try {
if (opts2?.noJunction === true) {
createTrueSymlinkSync(target2, path31);
} else {
createSymlinkSync(target2, path31);
}
return { reused: false };
} catch (err) {
initialErr = err;
switch (err.code) {
case "ENOENT":
try {
mkdirSync(pathLib.dirname(path31), { recursive: true });
} catch (mkdirError) {
mkdirError.message = `Error while trying to symlink "${target2}" to "${path31}". The error happened while trying to create the parent directory for the symlink target. Details: ${mkdirError}`;
throw mkdirError;
}
forceSymlinkSync(target2, path31, opts2);
return { reused: false };
case "EEXIST":
case "EISDIR":
break;
default:
throw err;
}
}
let linkString;
try {
linkString = readlinkSyncWaitingOutARefusal(path31);
} catch (err) {
if (opts2?.overwrite === false) {
throw initialErr;
}
const parentDir = pathLib.dirname(path31);
let warn;
if (opts2?.renameTried) {
unlinkSync(path31);
warn = `Symlink wanted name was occupied by directory or file. Old entity removed: "${parentDir}${pathLib.sep}{${pathLib.basename(path31)}".`;
} else {
const ignore = `.ignored_${pathLib.basename(path31)}`;
try {
renameOverwriteSync(path31, pathLib.join(parentDir, ignore));
} catch (error) {
if (!types.isNativeError(error) || !("code" in error) || error.code !== "ENOENT") {
throw error;
}
if (opts2?.vanishedRetried)
throw initialErr;
return forceSymlinkSync(target2, path31, { ...opts2, vanishedRetried: true });
}
warn = `Symlink wanted name was occupied by directory or file. Old entity moved: "${parentDir}${pathLib.sep}{${pathLib.basename(path31)} => ${ignore}".`;
}
return {
...forceSymlinkSync(target2, path31, { ...opts2, renameTried: true }),
warn
};
}
if (isExistingSymlinkUpToDate(target2, path31, linkString)) {
return { reused: true };
}
if (opts2?.overwrite === false) {
throw initialErr;
}
try {
unlinkSync(path31);
} catch (error) {
if (!types.isNativeError(error) || !("code" in error) || error.code !== "ENOENT") {
throw error;
}
}
return forceSymlinkSync(target2, path31, opts2);
}
// ../fs/symlink-dependency/lib/safeJoinModulesDir.js
import path5 from "node:path";
var import_validate_npm_package_name = __toESM(require_lib2(), 1);
function safeJoinModulesDir(modulesDir, alias) {
if (!(0, import_validate_npm_package_name.default)(alias).validForOldPackages) {
throw invalidDependencyNameError(modulesDir, alias);
}
const link = path5.join(modulesDir, alias);
const resolvedDir = path5.resolve(modulesDir);
const resolvedLink = path5.resolve(link);
if (resolvedLink === resolvedDir || !resolvedLink.startsWith(resolvedDir + path5.sep)) {
throw invalidDependencyNameError(modulesDir, alias, resolvedLink);
}
return link;
}
function invalidDependencyNameError(modulesDir, alias, resolvedLink) {
const detail = resolvedLink ? ` (it resolves to ${resolvedLink})` : "";
const error = new Error(`Refusing to place a dependency under ${modulesDir} with the invalid alias ${JSON.stringify(alias)}${detail}`);
error.code = "ERR_PNPM_INVALID_DEPENDENCY_NAME";
return error;
}
// ../fs/symlink-dependency/lib/index.js
function symlinkDependencySync(dependencyRealLocation, destModulesDir, importAs) {
const link = safeJoinModulesDir(destModulesDir, importAs);
linkLogger.debug({ target: dependencyRealLocation, link });
return symlinkDirSync(dependencyRealLocation, link);
}
// ../store/cafs/lib/index.js
import crypto5 from "node:crypto";
// ../store/cafs/lib/addFilesFromDir.js
import fs7, {} from "node:fs";
import path8 from "node:path";
// ../../../../../setup-pnpm/store/v11/links/@/is-subdir/2.0.1/930a5285b376d962304fd10a15f6382f59e4b31eb7c98b5f184535f0320114ee/node_modules/is-subdir/index.js
import path6 from "node:path";
function isSubdir(parentDir, subdir) {
const rParent = resolveWithTrailingSep(parentDir);
const rDir = resolveWithTrailingSep(subdir);
return rDir.startsWith(rParent);
}
function resolveWithTrailingSep(dir) {
const resolved = betterPathResolve(dir);
return resolved.endsWith(path6.sep) ? resolved : `${resolved}${path6.sep}`;
}
// ../../../../../setup-pnpm/store/v11/links/@/strip-bom/5.0.0/c5abc9f591760d7581de2026bc6da7f255db82a0b75d02fcc6cebf460005b3e6/node_modules/strip-bom/index.js
function stripBom(string) {
if (typeof string !== "string") {
throw new TypeError(`Expected a string, got ${typeof string}`);
}
if (string.charCodeAt(0) === 65279) {
return string.slice(1);
}
return string;
}
// ../store/cafs/lib/parseJson.js
function parseJsonBufferSync(buffer) {
return JSON.parse(stripBom(buffer.toString()));
}
// ../store/cafs/lib/symlinks.js
import fs6 from "node:fs";
import path7 from "node:path";
var SYMLINK_MODE = 40960;
var FILE_TYPE_MASK = 61440;
function isSymlinkMode(mode) {
return (mode & FILE_TYPE_MASK) === SYMLINK_MODE;
}
function normalizeSymlinkTarget(linkPath, target2) {
const linkSegments = linkPath.split("/");
if (!isRecordableLinkPath(linkSegments) || !hasRecordableTargetForm(target2)) {
return void 0;
}
const segments = target2.split("/").filter((segment) => segment !== "" && segment !== ".");
let parents = 0;
while (parents < segments.length && segments[parents] === "..")
parents++;
const names = segments.slice(parents);
if (names.length === 0 || names.some((name) => name === ".." || isName(name, "node_modules")))
return void 0;
if (parents > linkSegments.length - 1)
return void 0;
return segments.join("/");
}
function isRecordableLinkPath(linkSegments) {
return linkSegments.every(isPlainName) && !isName(linkSegments[0], "node_modules") && !(linkSegments.length === 1 && isName(linkSegments[0], "package.json"));
}
function hasRecordableTargetForm(target2) {
return target2 !== "" && !target2.startsWith("/") && !target2.includes("\\") && !target2.includes("\0") && path7.win32.parse(target2).root === "";
}
function isPlainName(segment) {
return segment !== "" && segment !== "." && segment !== ".." && !segment.includes("\\") && !segment.includes("\0");
}
function isName(segment, reservedName) {
return segment.toLowerCase() === reservedName;
}
function createSideEffectsFilesMapBuilder() {
const addedFiles = /* @__PURE__ */ new Map();
const addedSymlinks = /* @__PURE__ */ new Map();
let restorable = true;
return { add, finish };
function add(relativePath, mode, storePath) {
if (!isSymlinkMode(mode)) {
addedFiles.set(relativePath, storePath);
return;
}
const target2 = restorable ? readRecordedSymlinkTarget(relativePath, storePath) : void 0;
if (target2 == null) {
restorable = false;
return;
}
addedSymlinks.set(relativePath, target2);
}
function finish(deleted, baseFiles) {
if (!restorable)
return void 0;
const filesMap = { added: addedFiles, deleted };
if (addedSymlinks.size === 0)
return filesMap;
if (process.platform === "win32")
return void 0;
const deletedSet = new Set(deleted);
const restored = [...addedFiles.keys(), ...addedSymlinks.keys()];
for (const baseFile of baseFiles) {
if (!deletedSet.has(baseFile))
restored.push(baseFile);
}
if (writesBelowASymlink(addedSymlinks, restored))
return void 0;
filesMap.symlinks = addedSymlinks;
return filesMap;
}
}
function writesBelowASymlink(symlinks, restored) {
return restored.some((relativePath) => {
for (let slash = relativePath.lastIndexOf("/"); slash > 0; slash = relativePath.lastIndexOf("/", slash - 1)) {
if (symlinks.has(relativePath.slice(0, slash)))
return true;
}
return false;
});
}
function readRecordedSymlinkTarget(linkPath, filePath) {
let target2;
try {
target2 = fs6.readFileSync(filePath, "utf8");
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOENT")
return void 0;
throw err;
}
return normalizeSymlinkTarget(linkPath, target2) === target2 ? target2 : void 0;
}
// ../store/cafs/lib/addFilesFromDir.js
function addFilesFromDir(addBuffer, dirname, opts2 = {}) {
const resolvedRoot = fs7.realpathSync(dirname);
const { files, hasUnrecordedSymlinks, symlinks } = opts2.files ? statListedFiles(dirname, resolvedRoot, opts2.files) : findFilesInDir(dirname, resolvedRoot, opts2);
const filesIndex = /* @__PURE__ */ new Map();
const manifest = addFilesToIndex({ addBuffer, filesIndex, files, readManifest: opts2.readManifest });
addSymlinksToIndex(addBuffer, filesIndex, symlinks);
return { manifest, filesIndex, hasUnrecordedSymlinks };
}
function statListedFiles(dirname, resolvedRoot, listedFiles) {
const files = [];
let hasUnrecordedSymlinks = false;
for (const file of listedFiles) {
const absolutePath = path8.join(dirname, file);
const result = getStatIfContained(absolutePath, resolvedRoot);
hasUnrecordedSymlinks ||= result.isSymbolicLink;
const { stat } = result;
if (!stat) {
continue;
}
files.push({
absolutePath,
relativePath: file,
stat
});
}
return { files, hasUnrecordedSymlinks, symlinks: [] };
}
function addFilesToIndex({ addBuffer, filesIndex, files, readManifest }) {
let manifest;
for (const { absolutePath, relativePath, stat } of files) {
const buffer = lib_default.readFileSync(absolutePath);
if (readManifest && relativePath === "package.json") {
manifest = parseJsonBufferSync(buffer);
}
const mode = stat.mode & 511;
filesIndex.set(relativePath, {
mode,
size: stat.size,
...addBuffer(buffer, mode)
});
}
return manifest;
}
function addSymlinksToIndex(addBuffer, filesIndex, symlinks) {
for (const { relativePath, target: target2 } of symlinks) {
const buffer = Buffer.from(target2, "utf8");
filesIndex.set(relativePath, {
mode: SYMLINK_MODE,
size: buffer.length,
...addBuffer(buffer, SYMLINK_MODE)
});
}
}
function getStatIfContained(absolutePath, rootDir) {
let lstat;
try {
lstat = fs7.lstatSync(absolutePath);
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOENT") {
return { isSymbolicLink: false, stat: null };
}
throw err;
}
if (lstat.isSymbolicLink()) {
return {
isSymbolicLink: true,
stat: getSymlinkStatIfContained(absolutePath, rootDir)?.stat ?? null
};
}
let realPath;
try {
realPath = fs7.realpathSync(absolutePath);
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOENT") {
return { isSymbolicLink: false, stat: null };
}
throw err;
}
if (!isSubdir(rootDir, realPath)) {
return { isSymbolicLink: false, stat: null };
}
return { isSymbolicLink: false, stat: lstat };
}
function getSymlinkStatIfContained(absolutePath, rootDir) {
let realPath;
try {
realPath = fs7.realpathSync(absolutePath);
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOENT") {
return null;
}
throw err;
}
if (!isSubdir(rootDir, realPath)) {
return null;
}
return { stat: fs7.statSync(realPath), realPath };
}
function findFilesInDir(dir, rootDir, opts2) {
const ctx = {
filesList: [],
includeNodeModules: opts2.includeNodeModules ?? false,
hasUnrecordedSymlinks: false,
recordSymlinks: opts2.recordSymlinks ?? false,
rootDir,
symlinks: [],
visited: /* @__PURE__ */ new Set([rootDir])
};
findFiles(ctx, dir, "", rootDir);
return { files: ctx.filesList, hasUnrecordedSymlinks: ctx.hasUnrecordedSymlinks, symlinks: ctx.symlinks };
}
function findFiles(ctx, dir, relativeDir, currentRealPath) {
const dirents = fs7.readdirSync(dir, { withFileTypes: true });
for (const dirent of dirents) {
const entry = toDirEntry(ctx, { dir, relativeDir, name: dirent.name });
if (dirent.isSymbolicLink()) {
const symlinkedDir = collectSymlink(ctx, entry);
if (symlinkedDir) {
descendIntoDir(ctx, entry, symlinkedDir);
}
} else if (dirent.isDirectory()) {
descendIntoDir(ctx, entry, path8.join(currentRealPath, dirent.name));
} else {
collectFile(ctx, entry);
}
}
}
function toDirEntry(ctx, { dir, relativeDir, name }) {
return {
absolutePath: path8.join(dir, name),
isExcludedNodeModules: relativeDir === "" && name === "node_modules" && !ctx.includeNodeModules,
relativePath: `${relativeDir}${relativeDir ? "/" : ""}${name}`
};
}
function collectSymlink(ctx, entry) {
if (entry.isExcludedNodeModules) {
return void 0;
}
if (ctx.recordSymlinks && recordSymlink(ctx, entry)) {
return void 0;
}
ctx.hasUnrecordedSymlinks = true;
const res = getSymlinkStatIfContained(entry.absolutePath, ctx.rootDir);
if (!res) {
return void 0;
}
if (res.stat.isDirectory()) {
return res.realPath;
}
ctx.filesList.push({
relativePath: entry.relativePath,
absolutePath: entry.absolutePath,
stat: res.stat
});
return void 0;
}
function recordSymlink(ctx, entry) {
const target2 = normalizeSymlinkTarget(entry.relativePath, fs7.readlinkSync(entry.absolutePath));
if (target2 == null) {
return false;
}
ctx.symlinks.push({ relativePath: entry.relativePath, target: target2 });
return true;
}
function descendIntoDir(ctx, entry, realDir) {
if (ctx.visited.has(realDir) || entry.isExcludedNodeModules) {
return;
}
ctx.visited.add(realDir);
findFiles(ctx, entry.absolutePath, entry.relativePath, realDir);
ctx.visited.delete(realDir);
}
function collectFile(ctx, entry) {
let stat;
try {
stat = fs7.statSync(entry.absolutePath);
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOENT") {
return;
}
throw err;
}
ctx.filesList.push({
relativePath: entry.relativePath,
absolutePath: entry.absolutePath,
stat
});
}
// ../store/cafs/lib/addFilesFromTarball.js
import { createReadStream, promises as fs13 } from "node:fs";
import { createGunzip, gunzipSync } from "node:zlib";
var import_is_gzip = __toESM(require_is_gzip(), 1);
var import_seek_bzip2 = __toESM(require_lib3(), 1);
// ../store/cafs/lib/bzip2.js
var import_seek_bzip = __toESM(require_lib3(), 1);
import fs8 from "node:fs";
var CHUNK_SIZE = 128 * 1024;
function decodeBzip2(input, parser) {
let chunk = Buffer.allocUnsafe(CHUNK_SIZE);
let written = 0;
import_seek_bzip.default.decode(createInputStream(input), {
writeByte: (byte) => {
chunk[written++] = byte;
if (written === chunk.length) {
parser.push(chunk);
chunk = Buffer.allocUnsafe(CHUNK_SIZE);
written = 0;
}
}
});
if (written > 0)
parser.push(chunk.subarray(0, written));
parser.end();
}
function openBzip2Input(filename) {
const descriptor = fs8.openSync(filename, "r");
const chunk = Buffer.allocUnsafe(CHUNK_SIZE);
let available = 0;
let offset = 0;
return {
input: {
readByte: () => {
if (offset === available) {
available = fs8.readSync(descriptor, chunk);
offset = 0;
}
return offset < available ? chunk[offset++] : -1;
}
},
close: () => fs8.closeSync(descriptor)
};
}
function createInputStream(input) {
const stream = "readByte" in input ? input : createBufferInput(input);
return {
readByte: stream.readByte,
read: (buffer, offset, length) => {
let read2 = 0;
while (read2 < length) {
const byte = stream.readByte();
if (byte < 0)
break;
buffer[offset + read2++] = byte;
}
return read2 === 0 ? -1 : read2;
}
};
}
function createBufferInput(input) {
let offset = 0;
return { readByte: () => offset < input.length ? input[offset++] : -1 };
}
// ../store/cafs/lib/createTarballFileWriter.js
import crypto4 from "node:crypto";
import fs12 from "node:fs";
import path13 from "node:path";
// ../store/file-mode/lib/index.js
import fs9 from "node:fs";
import path9 from "node:path";
function unixCreationMode(parentMode, mode) {
if (parentMode == null || isPrivateMode(mode))
return { openMode: mode, grantMode: void 0 };
const executable = mode != null && (mode & 73) !== 0;
const wanted = inheritedFileMode(parentMode, executable);
return { openMode: wanted, grantMode: wanted };
}
function isPrivateMode(mode) {
return mode != null && (mode & 63) === 0;
}
function inheritedFileMode(parentMode, executable) {
let mode = parentMode & 436;
if (executable) {
if ((parentMode & 64) !== 0)
mode |= 64;
if ((parentMode & 8) !== 0)
mode |= 8;
if ((parentMode & 1) !== 0)
mode |= 1;
}
return mode | 384;
}
function readDirMode(dir) {
try {
return fs9.statSync(dir).mode;
} catch (err) {
if (isUnchangeable(err) || isMissing(err))
return void 0;
throw err;
}
}
function grantModeBits(fd, wanted) {
try {
const current = fs9.fstatSync(fd).mode & 511;
const merged = current | wanted & 511;
if (merged !== current)
fs9.fchmodSync(fd, merged);
} catch (err) {
if (!isUnchangeable(err))
throw err;
}
}
function mkdirInheritingMode(dir) {
if (process.platform === "win32" || directoryExists(dir)) {
lib_default.mkdirSync(dir, { recursive: true });
return;
}
const template = nearestExistingAncestor(dir);
lib_default.mkdirSync(dir, { recursive: true });
if (template != null)
grantInheritedDirMode(dir, template);
}
function directoryExists(dir) {
try {
return fs9.statSync(dir).isDirectory();
} catch (err) {
if (isMissing(err))
return false;
throw err;
}
}
function nearestExistingAncestor(dir) {
let current = dir;
for (; ; ) {
const isDir = isAccessibleDirectory(current);
if (isDir === void 0)
return void 0;
if (isDir)
return current;
const parent = path9.dirname(current);
if (parent === current)
return void 0;
current = parent;
}
}
function isAccessibleDirectory(dir) {
try {
return fs9.statSync(dir).isDirectory();
} catch (err) {
if (isUnchangeable(err))
return void 0;
if (isMissing(err))
return false;
throw err;
}
}
function grantInheritedDirMode(dir, template) {
const templateMode = readDirMode(template);
if (templateMode == null)
return;
const extra = inheritedDirBits(templateMode);
if (extra === 0)
return;
let current = dir;
while (current !== template) {
const parent = path9.dirname(current);
if (parent === current)
break;
addDirModeBits(current, extra);
current = parent;
}
}
function inheritedDirBits(templateMode) {
if ((templateMode & (16 | 1024)) === 0)
return 0;
return templateMode & (56 | 1024);
}
function addDirModeBits(dir, extra) {
let fd;
try {
fd = fs9.openSync(dir, fs9.constants.O_RDONLY | fs9.constants.O_DIRECTORY | fs9.constants.O_NOFOLLOW);
} catch (err) {
if (errorCode(err) === "EACCES") {
addUnreadableDirModeBits(dir, extra);
return;
}
if (isUnchangeable(err) || errorCode(err) === "ENOENT")
return;
throw err;
}
try {
const mode = fs9.fstatSync(fd).mode & 4095;
const merged = mode | extra;
if (merged !== mode)
fs9.fchmodSync(fd, merged);
} catch (err) {
if (!isUnchangeable(err))
throw err;
} finally {
fs9.closeSync(fd);
}
}
function addUnreadableDirModeBits(dir, extra) {
try {
if (process.platform === "darwin") {
addModeBitsThroughHandle(dir, extra, DARWIN_SEARCH_HANDLE);
} else if (process.platform === "linux") {
addModeBitsThroughHandle(dir, extra, LINUX_PATH_HANDLE);
}
} catch (err) {
if (!isUnchangeable(err) && errorCode(err) !== "ENOENT")
throw err;
}
}
var DARWIN_O_EXEC = 1073741824;
var DARWIN_SEARCH_HANDLE = {
flags: DARWIN_O_EXEC | fs9.constants.O_DIRECTORY | fs9.constants.O_NOFOLLOW,
chmod: (fd, mode) => {
fs9.fchmodSync(fd, mode);
}
};
var LINUX_O_PATH = 2097152;
var LINUX_PATH_HANDLE = {
flags: LINUX_O_PATH | fs9.constants.O_DIRECTORY | fs9.constants.O_NOFOLLOW,
chmod: (fd, mode) => {
fs9.chmodSync(`/proc/self/fd/${fd}`, mode);
}
};
function addModeBitsThroughHandle(dir, extra, handle) {
const fd = fs9.openSync(dir, handle.flags);
try {
const stat = fs9.fstatSync(fd);
if (!stat.isDirectory() || stat.uid !== process.geteuid?.())
return;
const merged = stat.mode & 4095 | extra;
if (merged !== (stat.mode & 4095))
handle.chmod(fd, merged);
} finally {
fs9.closeSync(fd);
}
}
function isUnchangeable(err) {
const code = errorCode(err);
return code === "EPERM" || code === "EACCES" || code === "EROFS";
}
function isMissing(err) {
const code = errorCode(err);
return code === "ENOENT" || code === "ENOTDIR";
}
function errorCode(err) {
if (typeof err === "object" && err != null && "code" in err) {
const code = err.code;
return typeof code === "string" ? code : void 0;
}
return void 0;
}
// ../store/cafs/lib/checkPkgFilesIntegrity.js
import crypto3 from "node:crypto";
import fs10 from "node:fs";
// ../store/cafs/lib/getFilePathInCafs.js
import path10 from "node:path";
var SEP = path10.sep;
var modeIsExecutable = (mode) => (mode & 73) !== 0;
function getFilePathByModeInCafs(storeDir, hexDigest, mode) {
const fileType = modeIsExecutable(mode) ? "exec" : "nonexec";
return `${storeDir}${SEP}${contentPathFromHex(fileType, hexDigest)}`;
}
function contentPathFromHex(fileType, hex) {
const contentPath = `files${SEP}${hex.slice(0, 2)}${SEP}${hex.slice(2)}`;
switch (fileType) {
case "exec":
return `${contentPath}-exec`;
case "nonexec":
return contentPath;
}
}
// ../store/cafs/lib/checkPkgFilesIntegrity.js
var CHUNK_SIZE2 = 64 * 1024;
var GUARDED_OPEN = (fs10.constants.O_NOFOLLOW ?? 0) | (fs10.constants.O_NONBLOCK ?? 0);
var verifiedFileIntegrity = { files: 0, ms: 0 };
function takeVerifiedFileIntegrity() {
const taken = verifiedFileIntegrity;
verifiedFileIntegrity = { files: 0, ms: 0 };
return taken;
}
function checkPkgFilesIntegrity(storeDir, pkgIndex) {
const verifiedFilesCache = /* @__PURE__ */ new Set();
const _checkFilesIntegrity = checkFilesIntegrity.bind(null, verifiedFilesCache, storeDir, pkgIndex.algo);
const filesMap = /* @__PURE__ */ new Map();
if (!_checkFilesIntegrity(pkgIndex.files, (f, _fstat, filename) => filesMap.set(f, filename))) {
return { passed: false, filesMap };
}
const sideEffectsMaps = pkgIndex.sideEffects ? verifySideEffectsMaps(pkgIndex.sideEffects, pkgIndex.files, _checkFilesIntegrity) : /* @__PURE__ */ new Map();
return createPassedVerifyResult(pkgIndex, filesMap, sideEffectsMaps);
}
function verifySideEffectsMaps(sideEffects, pkgFiles, checkFiles) {
const sideEffectsMaps = /* @__PURE__ */ new Map();
for (const [sideEffectName, diff] of sideEffects) {
if (diff.added) {
const sideEffectsMap = verifyAddedSideEffects(diff.added, diff.deleted, { pkgFiles, checkFiles });
if (sideEffectsMap)
sideEffectsMaps.set(sideEffectName, sideEffectsMap);
} else if (diff.deleted) {
sideEffectsMaps.set(sideEffectName, { deleted: diff.deleted });
}
}
return sideEffectsMaps;
}
function verifyAddedSideEffects(added, deleted, { pkgFiles, checkFiles }) {
const builder = createSideEffectsFilesMapBuilder();
if (!checkFiles(added, (f, fstat, filename) => builder.add(f, fstat.mode, filename))) {
return void 0;
}
return builder.finish(deleted, pkgFiles.keys());
}
function buildFileMapsFromIndex(storeDir, pkgIndex) {
const filesMap = /* @__PURE__ */ new Map();
for (const [relativePath, fstat] of pkgIndex.files) {
const filename = getFilePathByModeInCafs(storeDir, fstat.digest, fstat.mode);
filesMap.set(relativePath, filename);
}
const sideEffectsMaps = pkgIndex.sideEffects ? buildSideEffectsMaps(storeDir, pkgIndex.sideEffects, pkgIndex.files) : /* @__PURE__ */ new Map();
return createPassedVerifyResult(pkgIndex, filesMap, sideEffectsMaps);
}
function buildSideEffectsMaps(storeDir, sideEffects, pkgFiles) {
const sideEffectsMaps = /* @__PURE__ */ new Map();
for (const [sideEffectName, diff] of sideEffects) {
if (diff.added) {
const sideEffectsMap = buildAddedSideEffectsMap(storeDir, { added: diff.added, deleted: diff.deleted }, pkgFiles);
if (sideEffectsMap)
sideEffectsMaps.set(sideEffectName, sideEffectsMap);
} else {
sideEffectsMaps.set(sideEffectName, diff.deleted ? { deleted: diff.deleted } : {});
}
}
return sideEffectsMaps;
}
function buildAddedSideEffectsMap(storeDir, diff, pkgFiles) {
const builder = createSideEffectsFilesMapBuilder();
for (const [relativePath, fstat] of diff.added) {
builder.add(relativePath, fstat.mode, getFilePathByModeInCafs(storeDir, fstat.digest, fstat.mode));
}
return builder.finish(diff.deleted, pkgFiles.keys());
}
function createPassedVerifyResult(pkgIndex, filesMap, sideEffectsMaps) {
return {
passed: true,
filesMap,
sideEffectsMaps: sideEffectsMaps.size > 0 ? sideEffectsMaps : void 0,
sideEffectsDiffs: sideEffectsMaps.size > 0 ? matchingSideEffects(pkgIndex.sideEffects, sideEffectsMaps) : void 0,
remoteSideEffectsQuarantine: pkgIndex.remoteSideEffectsQuarantine
};
}
function matchingSideEffects(sideEffects, sideEffectsMaps) {
if (sideEffects == null)
return void 0;
return new Map(Array.from(sideEffects).filter(([cacheKey]) => sideEffectsMaps.has(cacheKey)));
}
function checkFilesIntegrity(verifiedFilesCache, storeDir, algo, files, record) {
let allVerified = true;
for (const [relativePath, fstat] of files) {
if (!fstat.digest) {
throw new PnpmError("MISSING_CONTENT_DIGEST", `Content digest is missing for ${relativePath}`);
}
const filename = getFilePathByModeInCafs(storeDir, fstat.digest, fstat.mode);
record(relativePath, fstat, filename);
if (verifiedFilesCache.has(filename))
continue;
const passed = verifyFile(filename, fstat, algo);
if (passed) {
verifiedFilesCache.add(filename);
} else {
allVerified = false;
}
}
return allVerified;
}
function verifyFile(filename, fstat, algorithm) {
const currentFile = checkFile(filename, fstat.checkedAt);
if (currentFile == null)
return false;
if (currentFile.isModified) {
if (currentFile.size !== fstat.size) {
scrubDirectoryAtCafsPath(filename);
return false;
}
const passed = tallyVerifyFileIntegrity(filename, { digest: fstat.digest, algorithm });
if (!passed) {
scrubDirectoryAtCafsPath(filename);
}
return passed;
}
return true;
}
var scrubCounter = 0;
function scrubDirectoryAtCafsPath(filename) {
let stats;
try {
stats = fs10.lstatSync(filename);
} catch {
return;
}
if (!stats.isDirectory())
return;
const scrubName = `${filename}.pnpm-scrub-${process.pid}-${scrubCounter++}`;
try {
fs10.renameSync(filename, scrubName);
} catch {
return;
}
try {
if (fs10.lstatSync(scrubName).isDirectory()) {
rimrafSync(scrubName);
} else {
fs10.renameSync(scrubName, filename);
}
} catch {
}
}
function tallyVerifyFileIntegrity(filename, integrity) {
const startedAt = performance.now();
const data = readFileForIntegrity(filename);
if (data == null)
return false;
const passed = hashMatches(data, integrity);
if (passed == null)
return false;
verifiedFileIntegrity.files++;
verifiedFileIntegrity.ms += performance.now() - startedAt;
return passed;
}
function verifyFileIntegrity(filename, integrity) {
const data = readFileForIntegrity(filename);
if (data == null)
return false;
return hashMatches(data, integrity) ?? false;
}
async function verifyFileIntegrityAsync(filename, integrity) {
let hasher;
try {
hasher = crypto3.createHash(integrity.algorithm);
} catch {
return false;
}
let handle;
try {
handle = await fs10.promises.open(filename, fs10.constants.O_RDONLY | GUARDED_OPEN);
} catch {
return false;
}
try {
if (!(await handle.stat()).isFile())
return false;
const stream = handle.createReadStream({ highWaterMark: CHUNK_SIZE2, autoClose: false });
for await (const chunk of stream) {
hasher.update(chunk);
}
} finally {
await handle.close();
}
return hasher.digest("hex") === integrity.digest;
}
function readFileForIntegrity(filename) {
try {
return withFileLockRetry(() => lib_default.readFileSync(filename));
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOENT") {
return null;
}
throw err;
}
}
function hashMatches(data, integrity) {
try {
return crypto3.hash(integrity.algorithm, data, "hex") === integrity.digest;
} catch {
return null;
}
}
function checkFile(filename, checkedAt) {
try {
const { mtimeMs, size } = withFileLockRetry(() => fs10.statSync(filename));
return {
isModified: mtimeMs - (checkedAt ?? 0) > 100,
size
};
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOENT")
return null;
throw err;
}
}
// ../store/cafs/lib/writeBufferToCafs.js
import fs11 from "node:fs";
import path12 from "node:path";
import workerThreads from "node:worker_threads";
// ../store/cafs/lib/writeFile.js
import nodeFs from "node:fs";
import path11 from "node:path";
var dirModes = /* @__PURE__ */ new Map();
function writeFile(fileDest, buffer, mode) {
makeDirForFile(fileDest);
writeCreatedFile(fileDest, buffer, { mode, exclusive: false });
}
function writeFileExclusive(fileDest, buffer, mode) {
makeDirForFile(fileDest);
writeCreatedFile(fileDest, buffer, { mode, exclusive: true });
}
function writeCreatedFile(fileDest, buffer, { mode, exclusive }) {
const creation = unixCreationMode(dirModes.get(path11.dirname(fileDest)), mode);
if (creation.grantMode == null) {
lib_default.writeFileSync(fileDest, buffer, exclusive ? { mode: creation.openMode, flag: "wx" } : { mode: creation.openMode });
return;
}
const fd = nodeFs.openSync(fileDest, exclusive ? "wx" : "w", creation.openMode);
try {
grantModeBits(fd, creation.grantMode);
lib_default.writeFileSync(fd, buffer);
} finally {
nodeFs.closeSync(fd);
}
}
function makeDirForFile(fileDest) {
const dir = path11.dirname(fileDest);
if (dirModes.has(dir))
return;
mkdirInheritingMode(dir);
dirModes.set(dir, process.platform === "win32" ? void 0 : readDirMode(dir));
}
// ../store/cafs/lib/writeBufferToCafs.js
function writeBufferToCafs(locker, storeDir, buffer, fileDest, mode, integrity) {
fileDest = path12.join(storeDir, fileDest);
if (locker.has(fileDest)) {
return {
checkedAt: locker.get(fileDest),
filePath: fileDest
};
}
const checkedAt = writeOrCheck(fileDest, buffer, mode, integrity);
locker.set(fileDest, checkedAt);
return {
checkedAt,
filePath: fileDest
};
}
function writeOrCheck(fileDest, buffer, mode, integrity) {
const existingFile = withFileLockRetry(() => fs11.statSync(fileDest, { throwIfNoEntry: false }));
if (existingFile) {
return checkOrRepairExistingFile(fileDest, buffer, mode, integrity);
}
try {
writeFileExclusive(fileDest, buffer, mode);
} catch (err) {
if (isError(err) && "code" in err && err.code === "EEXIST") {
return checkConcurrentlyCreatedFile(fileDest, buffer, mode, integrity);
}
throw err;
}
return Date.now();
}
function checkOrRepairExistingFile(fileDest, buffer, mode, integrity) {
if (verifyFileIntegrity(fileDest, integrity)) {
return Date.now();
}
if (overwriteFileInPlace(fileDest, buffer, integrity)) {
return Date.now();
}
return writeFileAtomic(fileDest, buffer, mode);
}
function checkConcurrentlyCreatedFile(fileDest, buffer, mode, integrity) {
if (verifyFileIntegrity(fileDest, integrity)) {
return Date.now();
}
return writeFileAtomic(fileDest, buffer, mode);
}
function writeFileAtomic(fileDest, buffer, mode) {
const temp = pathTemp(fileDest);
writeFile(temp, buffer, mode);
optimisticRenameOverwrite(temp, fileDest);
return Date.now();
}
var IN_PLACE_OPEN = fs11.constants.O_WRONLY | (fs11.constants.O_NOFOLLOW ?? 0) | (fs11.constants.O_NONBLOCK ?? 0);
function overwriteFileInPlace(fileDest, buffer, integrity) {
const fd = openStoreFileForRepair(fileDest);
if (fd == null)
return false;
try {
fs11.ftruncateSync(fd, 0);
fs11.writeFileSync(fd, buffer);
} catch {
return false;
} finally {
closeQuietly(fd);
}
return verifyFileIntegrity(fileDest, integrity);
}
function openStoreFileForRepair(fileDest) {
const stats = withFileLockRetry(() => fs11.lstatSync(fileDest, { bigint: true, throwIfNoEntry: false }));
if (!stats?.isFile() || (Number(stats.mode) & 146) === 0)
return null;
return openSameFile(fileDest, stats);
}
function openSameFile(fileDest, stats) {
let fd;
try {
fd = withFileLockRetry(() => fs11.openSync(fileDest, IN_PLACE_OPEN));
} catch {
return null;
}
let fdStats;
try {
fdStats = fs11.fstatSync(fd, { bigint: true });
} catch {
closeQuietly(fd);
return null;
}
if (!fdStats.isFile() || fdStats.dev !== stats.dev || fdStats.ino !== stats.ino) {
closeQuietly(fd);
return null;
}
return fd;
}
function closeQuietly(fd) {
try {
fs11.closeSync(fd);
} catch {
}
}
function optimisticRenameOverwrite(temp, fileDest) {
try {
renameOverwriteSync(temp, fileDest);
} catch (err) {
if (!(isError(err) && "code" in err && err.code === "ENOENT") || !fs11.existsSync(fileDest))
throw err;
}
}
function pathTemp(file) {
const basename = removeSuffix(path12.basename(file));
return path12.join(path12.dirname(file), `${basename}${process.pid}${workerThreads.threadId}`);
}
function removeSuffix(filePath) {
const dashPosition = filePath.indexOf("-");
if (dashPosition === -1)
return filePath;
const withoutSuffix = filePath.substring(0, dashPosition);
if (filePath.substring(dashPosition) === "-exec") {
return `${withoutSuffix}x`;
}
return withoutSuffix;
}
// ../store/cafs/lib/createTarballFileWriter.js
function createTarballFileWriterFactory(storeDir) {
const state = { sequence: 0 };
const descriptors = /* @__PURE__ */ new Set();
const pending = [];
return {
create: (mode, onFile) => {
if (state.temporaryDirectory == null) {
mkdirInheritingMode(storeDir);
state.temporaryDirectory = fs12.mkdtempSync(path13.join(storeDir, "tarball-"));
}
const filename = path13.join(state.temporaryDirectory, String(state.sequence++));
const descriptor = fs12.openSync(filename, "wx", 384);
descriptors.add(descriptor);
const hash = crypto4.createHash("sha512");
return {
write: (chunk) => {
hash.update(chunk);
writeChunk(descriptor, chunk);
},
end: () => {
fs12.closeSync(descriptor);
descriptors.delete(descriptor);
const digest = hash.digest("hex");
const filePath = getFilePathByModeInCafs(storeDir, digest, mode);
pending.push({ filename, filePath, mode, digest });
onFile({ digest, filePath, checkedAt: Date.now() });
}
};
},
publish: async () => {
for (const file of pending) {
await reuseOrPublishFile(file);
}
},
cleanup: () => {
for (const descriptor of descriptors)
fs12.closeSync(descriptor);
descriptors.clear();
if (state.temporaryDirectory)
fs12.rmSync(state.temporaryDirectory, { recursive: true, force: true });
}
};
}
function writeChunk(descriptor, chunk) {
let written = 0;
while (written < chunk.length)
written += fs12.writeSync(descriptor, chunk, written, chunk.length - written);
}
async function reuseOrPublishFile(file) {
const integrity = { algorithm: "sha512", digest: file.digest };
if (await verifyFileIntegrityAsync(file.filePath, integrity))
return;
if (await repairFileInPlace(file.filename, file.filePath, integrity))
return;
publishFile(file.filename, file.filePath, file.mode);
}
async function repairFileInPlace(filename, filePath, integrity) {
const descriptor = openStoreFileForRepair(filePath);
if (descriptor == null)
return false;
try {
fs12.ftruncateSync(descriptor, 0);
for await (const chunk of fs12.createReadStream(filename))
writeChunk(descriptor, chunk);
} catch {
return false;
} finally {
closeQuietly(descriptor);
}
return verifyFileIntegrityAsync(filePath, integrity);
}
function publishFile(filename, filePath, mode) {
const directory = path13.dirname(filePath);
mkdirInheritingMode(directory);
if (process.platform !== "win32") {
const creation = unixCreationMode(readDirMode(directory), modeIsExecutable(mode) ? 493 : void 0);
fs12.chmodSync(filename, creation.openMode ?? 438 & ~process.umask());
if (creation.grantMode != null) {
const descriptor = fs12.openSync(filename, "r+");
try {
grantModeBits(descriptor, creation.grantMode);
} finally {
fs12.closeSync(descriptor);
}
}
}
optimisticRenameOverwrite(filename, filePath);
}
// ../store/cafs/lib/parseTarball.js
import path14 from "node:path";
// ../store/cafs/lib/assertBufferedTarballEntry.js
import { inspect } from "node:util";
function assertBufferedTarballEntry(entry, maxBufferedEntrySize) {
if (maxBufferedEntrySize == null || entry.size <= maxBufferedEntrySize)
return;
throw new PnpmError("TARBALL_ENTRY_TOO_LARGE", `Tarball entry ${inspect(entry.fileName, { colors: false })} requires buffering ${entry.size} bytes, exceeding the ${maxBufferedEntrySize}-byte limit`);
}
// ../store/cafs/lib/assertUnpackedSize.js
function assertUnpackedSize(unpackedSize, maxTarballUnpackedSize) {
if (maxTarballUnpackedSize == null || unpackedSize <= maxTarballUnpackedSize)
return;
throw new PnpmError("TARBALL_TOO_LARGE", `The archive is larger than pnpm accepts: its files total more than ${maxTarballUnpackedSize} bytes`, {
hint: "If the package is legitimately this large, raise the maxTarballUnpackedSize setting."
});
}
// ../store/cafs/lib/parseOctal.js
var SPACE = " ".charCodeAt(0);
function parseOctal(buffer, offset, length) {
const val = buffer.subarray(offset, offset + length);
offset = 0;
while (offset < val.length && val[offset] === SPACE)
offset++;
const end = clamp(indexOf(val, SPACE, offset, val.length), val.length, val.length);
while (offset < end && val[offset] === 0)
offset++;
if (end === offset)
return 0;
return parseInt(val.subarray(offset, end).toString(), 8);
}
function indexOf(block, num, offset, end) {
for (; offset < end; offset++) {
if (block[offset] === num)
return offset;
}
return end;
}
function clamp(index, len, defaultValue) {
if (typeof index !== "number")
return defaultValue;
index = ~~index;
if (index >= len)
return len;
if (index >= 0)
return index;
index += len;
if (index >= 0)
return index;
return 0;
}
// ../store/cafs/lib/parseTarball.js
var ZERO = "0".charCodeAt(0);
var FILE_TYPE_HARD_LINK = "1".charCodeAt(0);
var FILE_TYPE_SYMLINK = "2".charCodeAt(0);
var FILE_TYPE_DIRECTORY = "5".charCodeAt(0);
var NEWLINE = "\n".charCodeAt(0);
var SLASH = "/".charCodeAt(0);
var BACKSLASH = "\\".charCodeAt(0);
var FILE_TYPE_PAX_HEADER = "x".charCodeAt(0);
var FILE_TYPE_PAX_GLOBAL_HEADER = "g".charCodeAt(0);
var FILE_TYPE_LONGLINK = "L".charCodeAt(0);
var BLOCK_SIZE = 512;
var MODE_OFFSET = 100;
var FILE_SIZE_OFFSET = 124;
var CHECKSUM_OFFSET = 148;
var FILE_TYPE_OFFSET = 156;
var PREFIX_OFFSET = 345;
function createTarballParser(onFile, createFileWriter, { maxBufferedEntrySize, maxTarballUnpackedSize } = {}) {
const state = {
onFile,
createFileWriter,
maxBufferedEntrySize,
maxTarballUnpackedSize,
unpackedSize: 0,
writer: void 0,
chunks: [],
chunkOffset: 0,
available: 0,
consumed: 0,
finished: false,
entry: void 0,
content: void 0,
bytesToSkip: 0,
longLinkPath: "",
paxHeaderPath: "",
paxHeaderFileSize: void 0
};
return {
push: (chunk) => pushChunk(state, chunk),
end: () => assertArchiveFinished(state)
};
}
function pushChunk(state, chunk) {
if (state.finished || chunk.length === 0)
return;
state.chunks.push(chunk);
state.available += chunk.length;
drain(state);
}
function assertArchiveFinished(state) {
if (!state.finished) {
throw new Error(`Unexpected end of TAR archive at offset ${state.consumed + state.available}`);
}
}
function drain(state) {
while (!state.finished) {
if (!drainStep(state))
return;
}
}
function drainStep(state) {
if (state.bytesToSkip > 0)
return skipBytes(state);
if (state.entry != null)
return consumeEntryContent(state, state.entry);
return consumeHeader(state);
}
function skipBytes(state) {
const skipped = Math.min(state.bytesToSkip, state.available);
discard(state, skipped);
state.bytesToSkip -= skipped;
return state.bytesToSkip === 0;
}
function consumeEntryContent(state, entry) {
if (state.writer) {
if (!consumeStreamedContent(state))
return false;
} else {
const entryContent = readContent(state, entry.size);
if (entryContent == null)
return false;
handleEntryContent(state, entry, entryContent);
}
state.bytesToSkip = paddingOf(entry.size);
state.entry = void 0;
return true;
}
function consumeStreamedContent(state) {
const writer = state.writer;
while (state.available > 0 && writer.remaining > 0) {
const chunk = state.chunks[0];
const size = Math.min(chunk.length - state.chunkOffset, writer.remaining);
writer.sink.write(chunk.subarray(state.chunkOffset, state.chunkOffset + size));
discard(state, size);
writer.remaining -= size;
}
if (writer.remaining > 0)
return false;
writer.sink.end();
state.writer = void 0;
return true;
}
function isRegularFile(fileType) {
return fileType === 0 || fileType === ZERO || fileType === FILE_TYPE_HARD_LINK;
}
function startEntryWriter(state, entry) {
if (!isRegularFile(entry.fileType))
return;
const sink = state.createFileWriter?.(entry.fileName, entry.mode, entry.size);
if (sink)
state.writer = { sink, remaining: entry.size };
}
function consumeHeader(state) {
if (state.available === 0)
return false;
if (state.chunks[0][state.chunkOffset] === 0) {
state.finished = true;
state.chunks.length = 0;
state.available = 0;
return false;
}
if (state.available < BLOCK_SIZE)
return false;
const headerOffset = state.consumed;
const header = take(state, BLOCK_SIZE);
const nextEntry = parseHeader(state, header, headerOffset);
if (entryHasContent(nextEntry.fileType)) {
state.entry = nextEntry;
if (isRegularFile(nextEntry.fileType)) {
state.unpackedSize += nextEntry.size;
assertUnpackedSize(state.unpackedSize, state.maxTarballUnpackedSize);
}
startEntryWriter(state, nextEntry);
if (!state.writer)
assertBufferedTarballEntry(nextEntry, state.maxBufferedEntrySize);
} else {
state.bytesToSkip = nextEntry.size + paddingOf(nextEntry.size);
}
return true;
}
function readContent(state, size) {
if (state.content == null) {
if (state.available >= size)
return take(state, size);
state.content = { parts: [], received: 0 };
}
const { content } = state;
while (state.available > 0 && content.received < size) {
const chunk = state.chunks[0];
const length = Math.min(chunk.length - state.chunkOffset, size - content.received);
content.parts.push(chunk.subarray(state.chunkOffset, state.chunkOffset + length));
content.received += length;
discard(state, length);
}
if (content.received < size)
return void 0;
state.content = void 0;
return Buffer.concat(content.parts, size);
}
function take(state, size) {
if (size === 0)
return Buffer.alloc(0);
const chunk = state.chunks[0];
if (chunk.length - state.chunkOffset >= size) {
const view2 = chunk.subarray(state.chunkOffset, state.chunkOffset + size);
discard(state, size);
return view2;
}
const buffer = Buffer.allocUnsafe(size);
let filled = 0;
while (filled < size) {
const current = state.chunks[0];
const length = Math.min(current.length - state.chunkOffset, size - filled);
current.copy(buffer, filled, state.chunkOffset, state.chunkOffset + length);
filled += length;
discard(state, length);
}
return buffer;
}
function discard(state, size) {
state.chunkOffset += size;
state.available -= size;
state.consumed += size;
while (state.chunks.length > 0 && state.chunkOffset >= state.chunks[0].length) {
state.chunkOffset -= state.chunks[0].length;
state.chunks.shift();
}
}
function handleEntryContent(state, { fileType, fileName, mode }, entryContent) {
switch (fileType) {
case FILE_TYPE_PAX_HEADER:
parsePaxHeader(state, entryContent, false);
break;
case FILE_TYPE_PAX_GLOBAL_HEADER:
parsePaxHeader(state, entryContent, true);
break;
case FILE_TYPE_LONGLINK:
state.longLinkPath = parseLongLinkPath(entryContent);
break;
default:
state.onFile(fileName, mode, entryContent);
}
}
function parseLongLinkPath(entryContent) {
const longLinkPath = entryContent.toString("utf8").replace(/\0.*/, "");
const slashIndex = longLinkPath.indexOf("/");
return slashIndex >= 0 ? longLinkPath.slice(slashIndex + 1) : longLinkPath;
}
function parseHeader(state, header, headerOffset) {
const fileType = header[FILE_TYPE_OFFSET];
const fileSize = takeEntryFileSize(state, header);
verifyHeaderChecksum(header, headerOffset);
if (!Number.isSafeInteger(fileSize) || fileSize < 0) {
throw new Error(`Invalid file size for TAR header at offset ${headerOffset}`);
}
const fileName = normalizeTraversal(takeEntryFileName(state, header));
switch (fileType) {
case 0:
case ZERO:
case FILE_TYPE_HARD_LINK:
return {
fileType,
fileName: fileName.replaceAll("//", "/"),
// The file mode is an octal number encoded as UTF-8. It is terminated by a NUL or space. Maximum length 8 characters.
mode: parseOctal(header, MODE_OFFSET, 8),
size: fileSize
};
case FILE_TYPE_DIRECTORY:
case FILE_TYPE_SYMLINK:
case FILE_TYPE_PAX_HEADER:
case FILE_TYPE_PAX_GLOBAL_HEADER:
case FILE_TYPE_LONGLINK:
return { fileType, fileName, mode: 0, size: fileSize };
default:
throw new Error(`Unsupported file type ${fileType} for file ${fileName}.`);
}
}
function takeEntryFileSize(state, header) {
if (state.paxHeaderFileSize !== void 0) {
const fileSize = state.paxHeaderFileSize;
state.paxHeaderFileSize = void 0;
return fileSize;
}
return parseOctal(header, FILE_SIZE_OFFSET, 12);
}
function verifyHeaderChecksum(header, headerOffset) {
const expectedCheckSum = parseOctal(header, CHECKSUM_OFFSET, 8);
const actualCheckSum = checkSum(header);
if (expectedCheckSum !== actualCheckSum) {
throw new Error(`Invalid checksum for TAR header at offset ${headerOffset}. Expected ${expectedCheckSum}, got ${actualCheckSum}`);
}
}
function takeEntryFileName(state, header) {
if (state.longLinkPath) {
const fileName = state.longLinkPath;
state.longLinkPath = "";
return fileName;
}
if (state.paxHeaderPath) {
const fileName = state.paxHeaderPath;
state.paxHeaderPath = "";
return fileName;
}
return parseHeaderPath(header);
}
function normalizeTraversal(fileName) {
if (fileName.includes("./") || fileName.includes(".\\")) {
return path14.posix.join("/", fileName.replaceAll("\\", "/")).slice(1);
}
return fileName;
}
function parsePaxHeader(state, buffer, global2) {
let cursor = 0;
while (cursor < buffer.length) {
const { record, lineEnd } = readPaxRecord(buffer, cursor);
cursor = lineEnd;
applyPaxRecord(state, record, global2);
}
}
function readPaxRecord(buffer, lineStart) {
const end = buffer.length;
let cursor = lineStart;
while (cursor < end && buffer[cursor] !== SPACE) {
cursor++;
}
if (cursor >= end) {
throw new Error("Invalid PAX record format: missing space delimiter");
}
const strLen = buffer.toString("utf-8", lineStart, cursor);
const len = parseInt(strLen, 10);
if (isNaN(len) || len <= 0 || lineStart + len > end || lineStart + len <= cursor) {
throw new Error(`Invalid length in PAX record: ${strLen}`);
}
cursor++;
const lineEnd = lineStart + len;
if (buffer[lineEnd - 1] !== NEWLINE) {
throw new Error("Invalid PAX record format: missing newline terminator");
}
return { record: buffer.toString("utf-8", cursor, lineEnd - 1), lineEnd };
}
function applyPaxRecord(state, record, global2) {
const equalSign = record.indexOf("=");
const keyword = record.slice(0, equalSign);
if (keyword === "path") {
const slashIndex = record.indexOf("/", equalSign + 1);
if (global2) {
throw new Error(`Unexpected global PAX path: ${record}`);
}
state.paxHeaderPath = record.slice(slashIndex >= 0 ? slashIndex + 1 : equalSign + 1);
} else if (keyword === "size") {
state.paxHeaderFileSize = parsePaxSize(record, equalSign, global2);
}
}
function parsePaxSize(record, equalSign, global2) {
const size = parseInt(record.slice(equalSign + 1), 10);
if (isNaN(size) || size < 0 || !Number.isSafeInteger(size)) {
throw new Error(`Invalid size in PAX record: ${record}`);
}
if (global2) {
throw new Error(`Unexpected global PAX file size: ${record}`);
}
return size;
}
function entryHasContent(fileType) {
return fileType !== FILE_TYPE_DIRECTORY && fileType !== FILE_TYPE_SYMLINK;
}
function paddingOf(size) {
return (BLOCK_SIZE - size % BLOCK_SIZE) % BLOCK_SIZE;
}
function parseHeaderPath(header) {
const trimState = { pathTrimmed: false };
let prefix = parseString(header, PREFIX_OFFSET, 155, trimState);
if (prefix && !trimState.pathTrimmed) {
trimState.pathTrimmed = true;
prefix = "";
}
const fileName = parseString(header, 0, MODE_OFFSET, trimState);
return prefix ? `${prefix}/${fileName}` : fileName;
}
function parseString(buffer, offset, length, trimState) {
let end = offset;
const max = length + offset;
for (let char = buffer[end]; char !== 0 && end !== max; char = buffer[++end]) {
if (!trimState.pathTrimmed && (char === SLASH || char === BACKSLASH)) {
trimState.pathTrimmed = true;
offset = end + 1;
}
}
return buffer.toString("utf8", offset, end);
}
function checkSum(header) {
let sum = 256;
let offset = 0;
for (; offset < CHECKSUM_OFFSET; offset++) {
sum += header[offset];
}
for (offset = FILE_TYPE_OFFSET; offset < BLOCK_SIZE; offset++) {
sum += header[offset];
}
return sum;
}
// ../store/cafs/lib/addFilesFromTarball.js
var GUNZIP_CHUNK_SIZE = 128 * 1024;
var MAX_IN_MEMORY_TARBALL_SIZE = 64 * 1024 * 1024;
function addFilesFromTarball(addBufferToCafs2, tarballBuffer, readManifest, ignore) {
return addFilesFromTarContent(addBufferToCafs2, decompressTarball(tarballBuffer), { readManifest, ignore });
}
async function addFilesFromTarballBounded(addBufferToCafs2, tarballBuffer, opts2) {
const { readManifest, ignore, storeDir, maxTarballUnpackedSize } = opts2;
if (isBzip2(tarballBuffer))
return addFilesFromBzip2(addBufferToCafs2, tarballBuffer, opts2);
const tarContent = (0, import_is_gzip.default)(tarballBuffer) ? gunzipUpTo(tarballBuffer, MAX_IN_MEMORY_TARBALL_SIZE) : decompressTarball(tarballBuffer);
if (tarContent != null) {
return addFilesFromTarContent(addBufferToCafs2, tarContent, { readManifest, ignore, maxTarballUnpackedSize });
}
const writers = createTarballFileWriterFactory(storeDir);
const filesIndexBuilder = createFilesIndexBuilder(addBufferToCafs2, { readManifest, ignore, writers });
const parser = createTarballParser(filesIndexBuilder.addFile, filesIndexBuilder.createFileWriter, { maxBufferedEntrySize: MAX_IN_MEMORY_TARBALL_SIZE, maxTarballUnpackedSize });
const gunzip = createGunzip({ chunkSize: GUNZIP_CHUNK_SIZE });
gunzip.end(tarballBuffer);
try {
for await (const chunk of gunzip)
parser.push(chunk);
parser.end();
await writers.publish();
return filesIndexBuilder.result();
} finally {
gunzip.destroy();
writers.cleanup();
}
}
async function addFilesFromTarballFile(addBufferToCafs2, tarballFile, { readManifest, ignore, storeDir, maxTarballUnpackedSize }) {
const handle = await fs13.open(tarballFile, "r");
const prefix = Buffer.alloc(3);
try {
await handle.read(prefix, 0, prefix.length, 0);
} finally {
await handle.close();
}
if (isBzip2(prefix)) {
const source2 = openBzip2Input(tarballFile);
try {
return await addFilesFromBzip2(addBufferToCafs2, source2.input, { readManifest, ignore, storeDir, maxTarballUnpackedSize });
} finally {
source2.close();
}
}
const source = createReadStream(tarballFile);
const stream = (0, import_is_gzip.default)(prefix) ? source.pipe(createGunzip({ chunkSize: GUNZIP_CHUNK_SIZE })) : source;
source.on("error", (error) => {
stream.destroy(error);
});
const writers = createTarballFileWriterFactory(storeDir);
const filesIndexBuilder = createFilesIndexBuilder(addBufferToCafs2, { readManifest, ignore, writers });
const parser = createTarballParser(filesIndexBuilder.addFile, filesIndexBuilder.createFileWriter, { maxBufferedEntrySize: MAX_IN_MEMORY_TARBALL_SIZE, maxTarballUnpackedSize });
try {
for await (const chunk of stream)
parser.push(chunk);
parser.end();
await writers.publish();
return filesIndexBuilder.result();
} finally {
source.destroy();
stream.destroy();
writers.cleanup();
}
}
async function addFilesFromBzip2(addBufferToCafs2, input, { readManifest, ignore, storeDir, maxTarballUnpackedSize }) {
const writers = createTarballFileWriterFactory(storeDir);
const filesIndexBuilder = createFilesIndexBuilder(addBufferToCafs2, { readManifest, ignore, writers });
const parser = createTarballParser(filesIndexBuilder.addFile, filesIndexBuilder.createFileWriter, { maxBufferedEntrySize: MAX_IN_MEMORY_TARBALL_SIZE, maxTarballUnpackedSize });
try {
decodeBzip2(input, parser);
await writers.publish();
return filesIndexBuilder.result();
} finally {
writers.cleanup();
}
}
function addFilesFromTarContent(addBufferToCafs2, tarContent, { readManifest, ignore, maxTarballUnpackedSize }) {
const files = /* @__PURE__ */ new Map();
const parser = createTarballParser((relativePath, mode, content) => {
files.set(relativePath, { mode, content });
}, void 0, { maxTarballUnpackedSize });
parser.push(tarContent);
parser.end();
const filesIndexBuilder = createFilesIndexBuilder(addBufferToCafs2, { readManifest, ignore });
for (const [relativePath, { mode, content }] of files) {
filesIndexBuilder.addFile(relativePath, mode, content);
}
return filesIndexBuilder.result();
}
function createFilesIndexBuilder(addBufferToCafs2, { readManifest, ignore, writers }) {
const filesIndex = /* @__PURE__ */ new Map();
let manifestBuffer;
return {
createFileWriter: (relativePath, mode, size) => createEntryWriter({ writers, filesIndex, readManifest, ignore }, { relativePath, mode, size }),
addFile: (relativePath, mode, content) => {
if (ignore?.(relativePath))
return;
if (readManifest && relativePath === "package.json") {
manifestBuffer = content;
}
filesIndex.set(relativePath, {
mode,
size: content.length,
...addBufferToCafs2(content, mode)
});
},
result: () => ({
filesIndex,
manifest: manifestBuffer ? parseJsonBufferSync(manifestBuffer) : void 0
})
};
}
function createEntryWriter(opts2, entry) {
if (opts2.ignore?.(entry.relativePath))
return { write: () => {
}, end: () => {
} };
if (!opts2.writers || entry.size <= MAX_IN_MEMORY_TARBALL_SIZE)
return void 0;
if (opts2.readManifest && entry.relativePath === "package.json")
return void 0;
return opts2.writers.create(entry.mode, (file) => {
opts2.filesIndex.set(entry.relativePath, { mode: entry.mode, size: entry.size, ...file });
});
}
function gunzipUpTo(tarballBuffer, maxSize) {
if (readGzipTrailerSize(tarballBuffer) > maxSize)
return void 0;
try {
return gunzipSync(tarballBuffer, { chunkSize: GUNZIP_CHUNK_SIZE, maxOutputLength: maxSize });
} catch (err) {
if (isError(err) && "code" in err && err.code === "ERR_BUFFER_TOO_LARGE") {
return void 0;
}
throw err;
}
}
function readGzipTrailerSize(buffer) {
if (buffer.length < 4)
return 0;
const end = buffer.length;
return (buffer[end - 4] | buffer[end - 3] << 8 | buffer[end - 2] << 16 | buffer[end - 1] << 24) >>> 0;
}
function decompressTarball(tarballBuffer) {
if ((0, import_is_gzip.default)(tarballBuffer)) {
return gunzipSync(tarballBuffer, { chunkSize: GUNZIP_CHUNK_SIZE });
}
if (isBzip2(tarballBuffer)) {
return import_seek_bzip2.default.decode(tarballBuffer);
}
return Buffer.isBuffer(tarballBuffer) ? tarballBuffer : Buffer.from(tarballBuffer);
}
function isBzip2(buffer) {
return buffer.length >= 3 && buffer[0] === 66 && buffer[1] === 90 && buffer[2] === 104;
}
// ../store/cafs/lib/normalizeBundledManifest.js
var import_semver = __toESM(require_semver2(), 1);
var BUNDLED_MANIFEST_FIELDS = [
"bin",
"bundledDependencies",
"bundleDependencies",
"cpu",
"dependencies",
"devDependencies",
"directories",
"engines",
"gypfile",
"libc",
"name",
"optionalDependencies",
"os",
"peerDependencies",
"peerDependenciesMeta"
];
var LIFECYCLE_SCRIPTS = ["preinstall", "install", "postinstall"];
function normalizeBundledManifest(manifest) {
const result = pickBundledFields(manifest);
const scripts = manifest.scripts ? pickLifecycleScripts(manifest.scripts) : void 0;
if (!result && !scripts)
return void 0;
return {
version: import_semver.default.clean(manifest.version ?? "0.0.0", { loose: true }) ?? manifest.version,
...result,
...scripts ? { scripts } : {}
};
}
function pickBundledFields(manifest) {
let result;
for (const key of BUNDLED_MANIFEST_FIELDS) {
if (manifest[key] != null) {
if (!result)
result = {};
result[key] = manifest[key];
}
}
return result;
}
function pickLifecycleScripts(manifestScripts) {
let scripts;
for (const key of LIFECYCLE_SCRIPTS) {
if (manifestScripts[key]) {
if (!scripts)
scripts = {};
scripts[key] = manifestScripts[key];
}
}
return scripts;
}
// ../core/types/lib/misc.js
var DEPENDENCIES_FIELDS = [
"optionalDependencies",
"dependencies",
"devDependencies"
];
var DEPENDENCIES_OR_PEER_FIELDS = [
...DEPENDENCIES_FIELDS,
"peerDependencies"
];
// ../store/cafs/lib/index.js
var HASH_ALGORITHM = "sha512";
function createCafs(storeDir, { ignoreFile, cafsLocker: cafsLocker2 } = {}) {
const _writeBufferToCafs = writeBufferToCafs.bind(null, cafsLocker2 ?? /* @__PURE__ */ new Map(), storeDir);
const addBuffer = addBufferToCafs.bind(null, _writeBufferToCafs);
return {
addFilesFromDir: addFilesFromDir.bind(null, addBuffer),
addFilesFromTarball: (tarballBuffer, readManifest, callIgnore) => addFilesFromTarball(addBuffer, tarballBuffer, readManifest, combineIgnore(ignoreFile, callIgnore)),
addFilesFromTarballBounded: async (tarballBuffer, { readManifest, ignore: callIgnore, maxTarballUnpackedSize } = {}) => addFilesFromTarballBounded(addBuffer, tarballBuffer, { readManifest, ignore: combineIgnore(ignoreFile, callIgnore), storeDir, maxTarballUnpackedSize }),
addFilesFromTarballFile: async (tarballFile, { readManifest, ignore: callIgnore, maxTarballUnpackedSize } = {}) => addFilesFromTarballFile(addBuffer, tarballFile, { readManifest, ignore: combineIgnore(ignoreFile, callIgnore), storeDir, maxTarballUnpackedSize }),
addFile: addBuffer,
getFilePathByModeInCafs: getFilePathByModeInCafs.bind(null, storeDir)
};
}
function combineIgnore(storeIgnore, callIgnore) {
if (!storeIgnore)
return callIgnore;
if (!callIgnore)
return storeIgnore;
return (filename) => storeIgnore(filename) || callIgnore(filename);
}
function addBufferToCafs(writeBufferToCafs2, buffer, mode) {
const digest = crypto5.hash(HASH_ALGORITHM, buffer, "hex");
const isExecutable = modeIsExecutable(mode);
const fileDest = contentPathFromHex(isExecutable ? "exec" : "nonexec", digest);
const { checkedAt, filePath } = writeBufferToCafs2(buffer, fileDest, isExecutable ? 493 : void 0, { digest, algorithm: HASH_ALGORITHM });
return { checkedAt, filePath, digest };
}
// ../worker/lib/addToStore.js
import { createHash } from "node:crypto";
import { createReadStream as createReadStream2 } from "node:fs";
// ../../../../../setup-pnpm/store/v11/links/@/load-json-file/7.0.1/dbd04cc64095fbd5cd55a7af38baeafcf5d82cb8d99f88d07cf0902ad6b5e65b/node_modules/load-json-file/index.js
import { readFileSync, promises as fs14 } from "node:fs";
var { readFile } = fs14;
// ../pkg-manifest/reader/lib/index.js
var import_normalize_package_data = __toESM(require_normalize(), 1);
// ../building/pkg-requires-build/lib/index.js
function pkgRequiresBuild(manifest, filesIndex) {
return manifest != null && manifestHasBuildScripts(manifest) || filesIncludeInstallScripts(filesIndex, manifest?.gypfile === false);
}
function manifestHasBuildScripts(manifest) {
return manifest.scripts != null && (Boolean(manifest.scripts.preinstall) || Boolean(manifest.scripts.install) || Boolean(manifest.scripts.postinstall));
}
function storedRequiresBuildNeedsManifestCheck(manifest, filesIndex) {
if (manifest != null && ("gypfile" in manifest || manifestHasBuildScripts(manifest)))
return false;
const hasBindingGyp = filesIndex instanceof Map ? filesIndex.has("binding.gyp") : Object.hasOwn(filesIndex, "binding.gyp");
if (!hasBindingGyp)
return false;
const keys = filesIndex instanceof Map ? filesIndex.keys() : Object.keys(filesIndex);
for (const filename of keys) {
if (isHooksEntry(filename))
return false;
}
return true;
}
function filesIncludeInstallScripts(filesIndex, gypBuildOptedOut) {
const keys = filesIndex instanceof Map ? filesIndex.keys() : Object.keys(filesIndex);
for (const filename of keys) {
if (filename === "binding.gyp" && !gypBuildOptedOut) {
return true;
}
if (isHooksEntry(filename)) {
return true;
}
}
return false;
}
function isHooksEntry(filename) {
return filename.match(/^\.hooks[\\/]/) != null;
}
// ../crypto/integrity/lib/index.js
var INTEGRITY_REGEX = /^([^-]+)-([a-z0-9+/=]+)$/i;
function parseIntegrity(integrity) {
const match = integrity.match(INTEGRITY_REGEX);
if (!match) {
throw new PnpmError("INVALID_INTEGRITY", `Invalid integrity format: expected "algo-base64hash", got "${integrity}"`);
}
const hexDigest = Buffer.from(match[2], "base64").toString("hex");
if (hexDigest.length === 0) {
throw new PnpmError("INVALID_INTEGRITY", "Invalid integrity: base64 hash decoded to empty digest");
}
return { algorithm: match[1], hexDigest };
}
function formatIntegrity(algorithm, hexDigest) {
return `${algorithm}-${Buffer.from(hexDigest, "hex").toString("base64")}`;
}
// ../store/index/lib/index.js
import fs17 from "node:fs";
import { createRequire as createRequire2 } from "node:module";
import path17 from "node:path";
import { pathToFileURL } from "node:url";
// ../../../../../setup-pnpm/store/v11/links/@/msgpackr/2.1.2/10be0e7cf51bd8e9aa3c1cc8013b24686f3b6cfdadd438a3065f8116f71f3aad/node_modules/msgpackr/unpack.js
var decoder;
try {
decoder = new TextDecoder();
} catch (error) {
}
var src;
var srcEnd;
var position = 0;
var EMPTY_ARRAY = [];
var EXTRACTION_FAILED = [];
var strings = EMPTY_ARRAY;
var stringPosition = 0;
var currentUnpackr = {};
var currentStructures;
var srcString;
var srcStringStart = 0;
var srcStringEnd = 0;
var bundledStrings;
var referenceMap;
var currentExtensions = [];
var dataView;
var arrayAllocationBudget;
var defaultOptions = {
useRecords: false,
mapsAsObjects: true
};
var C1Type = class {
};
var C1 = new C1Type();
C1.name = "MessagePack 0xC1";
var sequentialMode = false;
var inlineObjectReadThreshold = 2;
var Unpackr = class _Unpackr {
constructor(options) {
if (options) {
if (options.useRecords === false && options.mapsAsObjects === void 0)
options.mapsAsObjects = true;
if (options.sequential && options.trusted !== false) {
options.trusted = true;
if (!options.structures && options.useRecords != false) {
options.structures = [];
if (!options.maxSharedStructures)
options.maxSharedStructures = 0;
}
}
if (options.structures)
options.structures.sharedLength = options.structures.length;
else if (options.getStructures) {
(options.structures = []).uninitialized = true;
options.structures.sharedLength = 0;
}
if (options.int64AsNumber) {
options.int64AsType = "number";
}
}
Object.assign(this, options);
}
unpack(source, options) {
if (src) {
return saveState(() => {
clearSource();
try {
return this ? this.unpack(source, options) : _Unpackr.prototype.unpack.call(defaultOptions, source, options);
} catch (error) {
if (error && typeof error == "object")
nestedUnpackErrors.add(error);
throw error;
}
});
}
if (!source.buffer && source.constructor === ArrayBuffer)
source = typeof Buffer !== "undefined" ? Buffer.from(source) : new Uint8Array(source);
if (typeof options === "object") {
srcEnd = options.end || source.length;
position = options.start || 0;
} else {
position = 0;
srcEnd = options > -1 ? options : source.length;
}
stringPosition = 0;
srcStringEnd = 0;
srcString = null;
strings = EMPTY_ARRAY;
bundledStrings = null;
src = source;
try {
dataView = source.dataView || (source.dataView = new DataView(source.buffer, source.byteOffset, source.byteLength));
} catch (error) {
src = null;
if (source instanceof Uint8Array)
throw error;
throw new Error("Source must be a Uint8Array or Buffer but was a " + (source && typeof source == "object" ? source.constructor.name : typeof source));
}
if (this instanceof _Unpackr) {
currentUnpackr = this;
if (this.structures) {
currentStructures = this.structures;
return checkedRead(options);
} else if (!currentStructures || currentStructures.length > 0) {
currentStructures = [];
}
} else {
currentUnpackr = defaultOptions;
if (!currentStructures || currentStructures.length > 0)
currentStructures = [];
}
return checkedRead(options);
}
unpackMultiple(source, forEach) {
let values, lastPosition = 0;
try {
sequentialMode = true;
let size = source.length;
let value = this ? this.unpack(source, size) : defaultUnpackr.unpack(source, size);
if (forEach) {
if (forEach(value, lastPosition, position) === false) return;
while (position < size) {
lastPosition = position;
if (forEach(checkedRead(), lastPosition, position) === false) {
return;
}
}
} else {
values = [value];
while (position < size) {
lastPosition = position;
values.push(checkedRead());
}
return values;
}
} catch (error) {
error.lastPosition = lastPosition;
error.values = values;
throw error;
} finally {
sequentialMode = false;
clearSource();
}
}
_mergeStructures(loadedStructures, existingStructures) {
if (this._onLoadedStructures)
loadedStructures = this._onLoadedStructures(loadedStructures);
loadedStructures = loadedStructures || [];
if (Object.isFrozen(loadedStructures))
loadedStructures = loadedStructures.map((structure) => structure.slice(0));
for (let i = 0, l = loadedStructures.length; i < l; i++) {
let structure = loadedStructures[i];
if (structure) {
structure.isShared = true;
if (i >= 32)
structure.highByte = i - 32 >> 5;
}
}
loadedStructures.sharedLength = loadedStructures.length;
for (let id in existingStructures || []) {
if (id >= 0) {
let structure = loadedStructures[id];
let existing = existingStructures[id];
if (existing) {
if (structure)
(loadedStructures.restoreStructures || (loadedStructures.restoreStructures = []))[id] = structure;
loadedStructures[id] = existing;
}
}
}
return this.structures = loadedStructures;
}
decode(source, options) {
return this.unpack(source, options);
}
};
var nestedUnpackErrors = /* @__PURE__ */ new WeakSet();
function checkedRead(options) {
try {
if (!currentUnpackr.trusted && !sequentialMode) {
let sharedLength = currentStructures.sharedLength || 0;
if (sharedLength < currentStructures.length)
currentStructures.length = sharedLength;
}
let result;
arrayAllocationBudget = srcEnd - position;
if (currentUnpackr._readStruct && src[position] < 64 && src[position] >= 32) {
result = currentUnpackr._readStruct(src, position, srcEnd);
src = null;
if (!(options && options.lazy) && result)
result = result.toJSON();
position = srcEnd;
} else
result = read();
if (bundledStrings) {
position = bundledStrings.postBundlePosition;
bundledStrings = null;
}
if (sequentialMode)
currentStructures.restoreStructures = null;
if (position == srcEnd) {
if (currentStructures && currentStructures.restoreStructures)
restoreStructures();
currentStructures = null;
src = null;
if (referenceMap)
referenceMap = null;
} else if (position > srcEnd) {
throw new Error("Unexpected end of MessagePack data");
} else if (!sequentialMode) {
let jsonView;
try {
jsonView = JSON.stringify(result, (_, value) => typeof value === "bigint" ? `${value}n` : value).slice(0, 100);
} catch (error) {
jsonView = "(JSON view not available " + error + ")";
}
throw new Error("Data read, but end of buffer not reached " + jsonView);
}
return result;
} catch (error) {
if (currentStructures && currentStructures.restoreStructures)
restoreStructures();
clearSource();
classifyIncomplete(error);
throw error;
}
}
function classifyIncomplete(error) {
if (!error || typeof error != "object")
return;
if (position > srcEnd) {
error.incomplete = true;
} else if (nestedUnpackErrors.has(error)) {
if (error.incomplete)
error.incomplete = false;
} else if (error instanceof RangeError && position + 8 > srcEnd || typeof error.message == "string" && error.message.startsWith("Unexpected end of buffer")) {
error.incomplete = true;
}
}
function restoreStructures() {
for (let id in currentStructures.restoreStructures) {
currentStructures[id] = currentStructures.restoreStructures[id];
}
currentStructures.restoreStructures = null;
}
function read() {
let token = src[position++];
if (token < 160) {
if (token < 128) {
if (token < 64)
return token;
else {
let structure = currentStructures[token & 63] || currentUnpackr.getStructures && loadStructures()[token & 63];
if (structure) {
if (!structure.read) {
structure.read = createStructureReader(structure, token & 63);
}
return structure.read();
} else
return token;
}
} else if (token < 144) {
token -= 128;
if (currentUnpackr.mapsAsObjects) {
let object = {};
for (let i = 0; i < token; i++) {
let key = readKey();
if (key === "__proto__")
key = "__proto_";
object[key] = read();
}
return object;
} else {
let map = /* @__PURE__ */ new Map();
for (let i = 0; i < token; i++) {
map.set(read(), read());
}
return map;
}
} else {
token -= 144;
let array = new Array(token);
for (let i = 0; i < token; i++) {
array[i] = read();
}
if (currentUnpackr.freezeData)
return Object.freeze(array);
return array;
}
} else if (token < 192) {
let length = token - 160;
if (srcStringEnd >= position) {
return srcString.slice(position - srcStringStart, (position += length) - srcStringStart);
}
if (srcStringEnd == 0 && srcEnd < 140) {
let string = length < 16 ? shortStringInJS(length) : longStringInJS(length);
if (string != null)
return string;
}
return readFixedString(length);
} else {
let value;
switch (token) {
case 192:
return null;
case 193:
if (bundledStrings) {
value = read();
if (value > 0)
return bundledStrings[1].slice(bundledStrings.position1, bundledStrings.position1 += value);
else
return bundledStrings[0].slice(bundledStrings.position0, bundledStrings.position0 -= value);
}
return C1;
// "never-used", return special object to denote that
case 194:
return false;
case 195:
return true;
case 196:
value = src[position++];
if (value === void 0)
throw new Error("Unexpected end of buffer");
return readBin(value);
case 197:
value = dataView.getUint16(position);
position += 2;
if (value > srcEnd - position) throw endOfMessagePackError(position + value);
return readBin(value);
case 198:
value = dataView.getUint32(position);
position += 4;
if (value > srcEnd - position) throw endOfMessagePackError(position + value);
return readBin(value);
case 199:
return readExt(src[position++]);
case 200:
value = dataView.getUint16(position);
position += 2;
return readExt(value);
case 201:
value = dataView.getUint32(position);
position += 4;
return readExt(value);
case 202:
value = dataView.getFloat32(position);
if (currentUnpackr.useFloat32 > 2) {
let multiplier = mult10[(src[position] & 127) << 1 | src[position + 1] >> 7];
position += 4;
return (multiplier * value + (value > 0 ? 0.5 : -0.5) >> 0) / multiplier;
}
position += 4;
return value;
case 203:
value = dataView.getFloat64(position);
position += 8;
return value;
// uint handlers
case 204:
return src[position++];
case 205:
value = dataView.getUint16(position);
position += 2;
return value;
case 206:
value = dataView.getUint32(position);
position += 4;
return value;
case 207:
if (currentUnpackr.int64AsType === "number") {
value = dataView.getUint32(position) * 4294967296;
value += dataView.getUint32(position + 4);
} else if (currentUnpackr.int64AsType === "string") {
value = dataView.getBigUint64(position).toString();
} else if (currentUnpackr.int64AsType === "auto") {
value = dataView.getBigUint64(position);
if (value <= BigInt(2) << BigInt(52)) value = Number(value);
} else
value = dataView.getBigUint64(position);
position += 8;
return value;
// int handlers
case 208:
return dataView.getInt8(position++);
case 209:
value = dataView.getInt16(position);
position += 2;
return value;
case 210:
value = dataView.getInt32(position);
position += 4;
return value;
case 211:
if (currentUnpackr.int64AsType === "number") {
value = dataView.getInt32(position) * 4294967296;
value += dataView.getUint32(position + 4);
} else if (currentUnpackr.int64AsType === "string") {
value = dataView.getBigInt64(position).toString();
} else if (currentUnpackr.int64AsType === "auto") {
value = dataView.getBigInt64(position);
if (value >= BigInt(-2) << BigInt(52) && value <= BigInt(2) << BigInt(52)) value = Number(value);
} else
value = dataView.getBigInt64(position);
position += 8;
return value;
case 212:
value = src[position++];
if (value == 114) {
return recordDefinition(src[position++] & 63);
} else {
let extension = currentExtensions[value];
if (extension) {
if (extension.read) {
position++;
return extension.read(read());
} else if (extension.noBuffer) {
position++;
return extension();
} else {
if (position >= srcEnd) throw endOfMessagePackError();
return extension(src.subarray(position, ++position));
}
} else
throw new Error("Unknown extension " + value);
}
case 213:
value = src[position];
if (value == 114) {
position++;
return recordDefinition(src[position++] & 63, src[position++]);
} else
return readExt(2);
case 214:
return readExt(4);
case 215:
return readExt(8);
case 216:
return readExt(16);
case 217:
value = src[position++];
if (srcStringEnd >= position) {
return srcString.slice(position - srcStringStart, (position += value) - srcStringStart);
}
return readString8(value);
case 218:
value = dataView.getUint16(position);
position += 2;
if (value > srcEnd - position) throw endOfMessagePackError(position + value);
if (srcStringEnd >= position) {
return srcString.slice(position - srcStringStart, (position += value) - srcStringStart);
}
return readString16(value);
case 219:
value = dataView.getUint32(position);
position += 4;
if (value > srcEnd - position) throw endOfMessagePackError(position + value);
if (srcStringEnd >= position) {
return srcString.slice(position - srcStringStart, (position += value) - srcStringStart);
}
return readString32(value);
case 220:
value = dataView.getUint16(position);
position += 2;
return readArray(value);
case 221:
value = dataView.getUint32(position);
position += 4;
return readArray(value);
case 222:
value = dataView.getUint16(position);
position += 2;
return readMap(value);
case 223:
value = dataView.getUint32(position);
position += 4;
return readMap(value);
default:
if (token >= 224)
return token - 256;
if (token === void 0) throw endOfMessagePackError();
throw new Error("Unknown MessagePack token " + token);
}
}
}
var validName = /^[a-zA-Z_$][a-zA-Z\d_$]*$/;
function createStructureReader(structure, firstId) {
function readObject() {
if (readObject.count++ > inlineObjectReadThreshold) {
let optimizedReadObject;
try {
optimizedReadObject = structure.read = new Function("r", "return function(){return " + (currentUnpackr.freezeData ? "Object.freeze" : "") + "({" + structure.map((key) => key === "__proto__" ? "__proto_:r()" : validName.test(key) ? key + ":r()" : "[" + JSON.stringify(key) + "]:r()").join(",") + "})}")(read);
} catch (error) {
inlineObjectReadThreshold = Infinity;
return readObject();
}
structure.read0 = optimizedReadObject;
if (structure.highByte === 0)
structure.read = createSecondByteReader(firstId, structure.read);
return optimizedReadObject();
}
let object = {};
for (let i = 0, l = structure.length; i < l; i++) {
let key = structure[i];
if (key === "__proto__")
key = "__proto_";
object[key] = read();
}
if (currentUnpackr.freezeData)
return Object.freeze(object);
return object;
}
readObject.count = 0;
structure.read0 = readObject;
if (structure.highByte === 0) {
return createSecondByteReader(firstId, readObject);
}
return readObject;
}
var createSecondByteReader = (firstId, read0) => {
return function() {
let highByte = src[position++];
if (highByte === 0)
return read0();
let id = firstId < 32 ? -(firstId + (highByte << 5)) : firstId + (highByte << 5);
let structure = currentStructures[id] || loadStructures()[id];
if (!structure) {
throw new Error("Record id is not defined for " + id);
}
if (!structure.read)
structure.read = createStructureReader(structure, firstId);
return structure.read();
};
};
function loadStructures() {
let loadedStructures = saveState(() => {
src = null;
return currentUnpackr.getStructures();
});
return currentStructures = currentUnpackr._mergeStructures(loadedStructures, currentStructures);
}
var readFixedString = readStringJS;
var readString8 = readStringJS;
var readString16 = readStringJS;
var readString32 = readStringJS;
var isNativeAccelerationEnabled = false;
function setExtractor(extractStrings) {
isNativeAccelerationEnabled = true;
readFixedString = readString(1);
readString8 = readString(2);
readString16 = readString(3);
readString32 = readString(5);
function tryExtractStrings(start, end, buffer) {
try {
return extractStrings(start, end, buffer);
} catch (error) {
return EXTRACTION_FAILED;
}
}
function readString(headerLength) {
return function readString2(length) {
let string = strings[stringPosition++];
if (string == null) {
if (bundledStrings || strings === EXTRACTION_FAILED)
return readStringJS(length);
let byteOffset = src.byteOffset;
let extraction = tryExtractStrings(position - headerLength + byteOffset, srcEnd + byteOffset, src.buffer);
if (extraction === EXTRACTION_FAILED) {
strings = EXTRACTION_FAILED;
return readStringJS(length);
}
if (typeof extraction == "string") {
string = extraction;
strings = EMPTY_ARRAY;
} else {
strings = extraction;
stringPosition = 1;
srcStringEnd = 1;
string = strings[0];
if (string === void 0)
throw new Error("Unexpected end of buffer");
}
}
let srcStringLength = string.length;
if (srcStringLength <= length) {
position += length;
return string;
}
srcString = string;
srcStringStart = position;
srcStringEnd = position + srcStringLength;
position += length;
return string.slice(0, length);
};
}
}
function readStringJS(length) {
let result;
if (length < 16) {
if (result = shortStringInJS(length))
return result;
}
if (length > 64 && decoder)
return decoder.decode(src.subarray(position, position += length));
const end = position + length;
const units = [];
result = "";
while (position < end) {
const byte1 = src[position++];
if ((byte1 & 128) === 0) {
units.push(byte1);
} else if ((byte1 & 224) === 192) {
if (byte1 < 194 || position >= end || (src[position] & 192) !== 128) {
units.push(65533);
} else {
const byte2 = src[position++] & 63;
units.push((byte1 & 31) << 6 | byte2);
}
} else if ((byte1 & 240) === 224) {
const byte2 = position < end ? src[position] : 0;
if (position >= end || (byte2 & 192) !== 128 || byte1 === 224 && byte2 < 160 || byte1 === 237 && byte2 >= 160) {
units.push(65533);
} else {
position++;
if (position >= end || (src[position] & 192) !== 128) {
units.push(65533);
} else {
const byte3 = src[position++] & 63;
units.push((byte1 & 31) << 12 | (byte2 & 63) << 6 | byte3);
}
}
} else if ((byte1 & 248) === 240) {
const byte2 = position < end ? src[position] : 0;
if (byte1 > 244 || position >= end || (byte2 & 192) !== 128 || byte1 === 240 && byte2 < 144 || byte1 === 244 && byte2 >= 144) {
units.push(65533);
} else {
position++;
if (position >= end || (src[position] & 192) !== 128) {
units.push(65533);
} else {
const byte3 = src[position++] & 63;
if (position >= end || (src[position] & 192) !== 128) {
units.push(65533);
} else {
const byte4 = src[position++] & 63;
let unit = (byte1 & 7) << 18 | (byte2 & 63) << 12 | byte3 << 6 | byte4;
unit -= 65536;
units.push(unit >>> 10 & 1023 | 55296);
units.push(56320 | unit & 1023);
}
}
}
} else {
units.push(65533);
}
if (units.length >= 4096) {
result += fromCharCode.apply(String, units);
units.length = 0;
}
}
if (units.length > 0) {
result += fromCharCode.apply(String, units);
}
return result;
}
function endOfMessagePackError(end) {
let error = new Error("Unexpected end of MessagePack data");
error.incomplete = true;
if (end > srcEnd && position <= srcEnd)
error.missingBytes = end - srcEnd;
return error;
}
function readArray(length) {
if (length > srcEnd - position || (arrayAllocationBudget -= length) < 0) throw endOfMessagePackError(position + length);
let array = new Array(length);
for (let i = 0; i < length; i++) {
array[i] = read();
}
if (currentUnpackr.freezeData)
return Object.freeze(array);
return array;
}
function readMap(length) {
if (length > (srcEnd - position) / 2) throw endOfMessagePackError(position + 2 * length);
if (currentUnpackr.mapsAsObjects) {
let object = {};
for (let i = 0; i < length; i++) {
let key = readKey();
if (key === "__proto__")
key = "__proto_";
object[key] = read();
}
return object;
} else {
let map = /* @__PURE__ */ new Map();
for (let i = 0; i < length; i++) {
map.set(read(), read());
}
return map;
}
}
var fromCharCode = String.fromCharCode;
function longStringInJS(length) {
let start = position;
let bytes = new Array(length);
for (let i = 0; i < length; i++) {
const byte = src[position++];
if ((byte & 128) > 0) {
position = start;
return;
}
bytes[i] = byte;
}
return fromCharCode.apply(String, bytes);
}
function shortStringInJS(length) {
if (length < 4) {
if (length < 2) {
if (length === 0)
return "";
else {
let a = src[position++];
if ((a & 128) > 1) {
position -= 1;
return;
}
return fromCharCode(a);
}
} else {
let a = src[position++];
let b = src[position++];
if ((a & 128) > 0 || (b & 128) > 0) {
position -= 2;
return;
}
if (length < 3)
return fromCharCode(a, b);
let c = src[position++];
if ((c & 128) > 0) {
position -= 3;
return;
}
return fromCharCode(a, b, c);
}
} else {
let a = src[position++];
let b = src[position++];
let c = src[position++];
let d = src[position++];
if ((a & 128) > 0 || (b & 128) > 0 || (c & 128) > 0 || (d & 128) > 0) {
position -= 4;
return;
}
if (length < 6) {
if (length === 4)
return fromCharCode(a, b, c, d);
else {
let e = src[position++];
if ((e & 128) > 0) {
position -= 5;
return;
}
return fromCharCode(a, b, c, d, e);
}
} else if (length < 8) {
let e = src[position++];
let f = src[position++];
if ((e & 128) > 0 || (f & 128) > 0) {
position -= 6;
return;
}
if (length < 7)
return fromCharCode(a, b, c, d, e, f);
let g = src[position++];
if ((g & 128) > 0) {
position -= 7;
return;
}
return fromCharCode(a, b, c, d, e, f, g);
} else {
let e = src[position++];
let f = src[position++];
let g = src[position++];
let h = src[position++];
if ((e & 128) > 0 || (f & 128) > 0 || (g & 128) > 0 || (h & 128) > 0) {
position -= 8;
return;
}
if (length < 10) {
if (length === 8)
return fromCharCode(a, b, c, d, e, f, g, h);
else {
let i = src[position++];
if ((i & 128) > 0) {
position -= 9;
return;
}
return fromCharCode(a, b, c, d, e, f, g, h, i);
}
} else if (length < 12) {
let i = src[position++];
let j = src[position++];
if ((i & 128) > 0 || (j & 128) > 0) {
position -= 10;
return;
}
if (length < 11)
return fromCharCode(a, b, c, d, e, f, g, h, i, j);
let k = src[position++];
if ((k & 128) > 0) {
position -= 11;
return;
}
return fromCharCode(a, b, c, d, e, f, g, h, i, j, k);
} else {
let i = src[position++];
let j = src[position++];
let k = src[position++];
let l = src[position++];
if ((i & 128) > 0 || (j & 128) > 0 || (k & 128) > 0 || (l & 128) > 0) {
position -= 12;
return;
}
if (length < 14) {
if (length === 12)
return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l);
else {
let m = src[position++];
if ((m & 128) > 0) {
position -= 13;
return;
}
return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m);
}
} else {
let m = src[position++];
let n = src[position++];
if ((m & 128) > 0 || (n & 128) > 0) {
position -= 14;
return;
}
if (length < 15)
return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
let o = src[position++];
if ((o & 128) > 0) {
position -= 15;
return;
}
return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
}
}
}
}
}
function readOnlyJSString() {
let token = src[position++];
let length;
if (token < 192) {
length = token - 160;
} else {
switch (token) {
case 217:
length = src[position++];
break;
case 218:
length = dataView.getUint16(position);
position += 2;
break;
case 219:
length = dataView.getUint32(position);
position += 4;
break;
default:
throw new Error("Expected string");
}
}
return readStringJS(length);
}
function readBin(length) {
return currentUnpackr.copyBuffers ? (
// specifically use the copying slice (not the node one)
Uint8Array.prototype.slice.call(src, position, position += length)
) : src.subarray(position, position += length);
}
function readExt(length) {
if (length >= srcEnd - position) throw endOfMessagePackError(position + 1 + length);
let type = src[position++];
if (currentExtensions[type]) {
let end;
return currentExtensions[type](src.subarray(position, end = position += length), (readPosition) => {
position = readPosition;
try {
return read();
} finally {
position = end;
}
});
} else
throw new Error("Unknown extension type " + type);
}
var keyCache = new Array(4096);
function readKey() {
let length = src[position++];
if (length >= 160 && length < 192) {
length = length - 160;
if (srcStringEnd >= position)
return srcString.slice(position - srcStringStart, (position += length) - srcStringStart);
else if (!(srcStringEnd == 0 && srcEnd < 180))
return readFixedString(length);
} else {
position--;
return asSafeString(read());
}
if (length > srcEnd - position) throw endOfMessagePackError(position + length);
let key = (length << 5 ^ (length > 1 ? dataView.getUint16(position) : length > 0 ? src[position] : 0)) & 4095;
let entry = keyCache[key];
let checkPosition = position;
let end = position + length - 3;
let chunk;
let i = 0;
if (entry && entry.bytes == length) {
while (checkPosition < end) {
chunk = dataView.getUint32(checkPosition);
if (chunk != entry[i++]) {
checkPosition = 1879048192;
break;
}
checkPosition += 4;
}
end += 3;
while (checkPosition < end) {
chunk = src[checkPosition++];
if (chunk != entry[i++]) {
checkPosition = 1879048192;
break;
}
}
if (checkPosition === end) {
position = checkPosition;
return entry.string;
}
end -= 3;
checkPosition = position;
}
entry = [];
keyCache[key] = entry;
entry.bytes = length;
while (checkPosition < end) {
chunk = dataView.getUint32(checkPosition);
entry.push(chunk);
checkPosition += 4;
}
end += 3;
while (checkPosition < end) {
chunk = src[checkPosition++];
entry.push(chunk);
}
let string = length < 16 ? shortStringInJS(length) : longStringInJS(length);
if (string != null)
return entry.string = string;
return entry.string = readFixedString(length);
}
function asSafeString(property) {
if (typeof property === "string") return property;
if (typeof property === "number" || typeof property === "boolean" || typeof property === "bigint") return property.toString();
if (property == null) return property + "";
if (currentUnpackr.allowArraysInMapKeys && Array.isArray(property) && property.flat().every((item) => ["string", "number", "boolean", "bigint"].includes(typeof item))) {
return property.flat().toString();
}
throw new Error(`Invalid property type for record: ${typeof property}. A MessagePack map with non-string keys can be decoded as a Map with mapsAsObjects: false`);
}
var recordDefinition = (id, highByte) => {
let structure = read().map(asSafeString);
let firstByte = id;
if (highByte !== void 0) {
id = id < 32 ? -((highByte << 5) + id) : (highByte << 5) + id;
structure.highByte = highByte;
}
let existingStructure = currentStructures[id];
if (existingStructure && (existingStructure.isShared || sequentialMode)) {
(currentStructures.restoreStructures || (currentStructures.restoreStructures = []))[id] = existingStructure;
}
currentStructures[id] = structure;
structure.read = createStructureReader(structure, firstByte);
return (structure.read0 || structure.read)();
};
currentExtensions[0] = () => {
};
currentExtensions[0].noBuffer = true;
currentExtensions[66] = (data) => {
let headLength = data.byteLength % 8 || 8;
let head = BigInt(data[0] & 128 ? data[0] - 256 : data[0]);
for (let i = 1; i < headLength; i++) {
head <<= BigInt(8);
head += BigInt(data[i]);
}
if (data.byteLength !== headLength) {
let view2 = new DataView(data.buffer, data.byteOffset, data.byteLength);
let decode2 = (start, end) => {
let length = end - start;
if (length <= 40) {
let out = view2.getBigUint64(start);
for (let i = start + 8; i < end; i += 8) {
out <<= BigInt(64);
out |= view2.getBigUint64(i);
}
return out;
}
let middle = start + (length >> 4 << 3);
let left = decode2(start, middle);
let right = decode2(middle, end);
return left << BigInt((end - middle) * 8) | right;
};
head = head << BigInt((view2.byteLength - headLength) * 8) | decode2(headLength, view2.byteLength);
}
return head;
};
var errors = {
Error,
EvalError,
RangeError,
ReferenceError,
SyntaxError,
TypeError,
URIError,
AggregateError: typeof AggregateError === "function" ? AggregateError : null
};
currentExtensions[101] = () => {
let data = read();
if (!errors[data[0]]) {
let error = Error(data[1], { cause: data[2] });
error.name = data[0];
return error;
}
return errors[data[0]](data[1], { cause: data[2] });
};
currentExtensions[105] = (data) => {
if (currentUnpackr.structuredClone === false) throw new Error("Structured clone extension is disabled");
let id = dataView.getUint32(position - 4);
if (!referenceMap)
referenceMap = /* @__PURE__ */ new Map();
let token = src[position];
let target2;
if (token >= 144 && token < 160 || token == 220 || token == 221)
target2 = [];
else if (token >= 128 && token < 144 || token == 222 || token == 223)
target2 = /* @__PURE__ */ new Map();
else if ((token >= 199 && token <= 201 || token >= 212 && token <= 216) && src[position + 1] === 115)
target2 = /* @__PURE__ */ new Set();
else
target2 = {};
let refEntry = { target: target2 };
referenceMap.set(id, refEntry);
let targetProperties = read();
if (!refEntry.used) {
return refEntry.target = targetProperties;
} else {
Object.assign(target2, targetProperties);
}
if (target2 instanceof Map)
for (let [k, v] of targetProperties.entries()) target2.set(k, v);
if (target2 instanceof Set)
for (let i of Array.from(targetProperties)) target2.add(i);
return target2;
};
currentExtensions[112] = (data) => {
if (currentUnpackr.structuredClone === false) throw new Error("Structured clone extension is disabled");
let id = dataView.getUint32(position - 4);
let refEntry = referenceMap.get(id);
refEntry.used = true;
return refEntry.target;
};
currentExtensions[115] = () => new Set(read());
var typedArrays = ["Int8", "Uint8", "Uint8Clamped", "Int16", "Uint16", "Int32", "Uint32", "Float32", "Float64", "BigInt64", "BigUint64"].map((type) => type + "Array");
var glbl = typeof globalThis === "object" ? globalThis : window;
currentExtensions[116] = (data) => {
let typeCode = data[0];
let buffer = Uint8Array.prototype.slice.call(data, 1).buffer;
let typedArrayName = typedArrays[typeCode];
if (!typedArrayName) {
if (typeCode === 16) return buffer;
if (typeCode === 17) return new DataView(buffer);
throw new Error("Could not find typed array for code " + typeCode);
}
return new glbl[typedArrayName](buffer);
};
currentExtensions[120] = () => {
let data = read();
return new RegExp(data[0], data[1]);
};
var TEMP_BUNDLE = [];
currentExtensions[98] = (data) => {
let dataSize = (data[0] << 24) + (data[1] << 16) + (data[2] << 8) + data[3];
let dataPosition = position;
position += dataSize - data.length;
bundledStrings = TEMP_BUNDLE;
bundledStrings = [readOnlyJSString(), readOnlyJSString()];
bundledStrings.position0 = 0;
bundledStrings.position1 = 0;
bundledStrings.postBundlePosition = position;
position = dataPosition;
return read();
};
currentExtensions[255] = (data) => {
if (data.length == 4)
return new Date((data[0] * 16777216 + (data[1] << 16) + (data[2] << 8) + data[3]) * 1e3);
else if (data.length == 8)
return new Date(
((data[0] << 22) + (data[1] << 14) + (data[2] << 6) + (data[3] >> 2)) / 1e6 + ((data[3] & 3) * 4294967296 + data[4] * 16777216 + (data[5] << 16) + (data[6] << 8) + data[7]) * 1e3
);
else if (data.length == 12)
return new Date(
((data[0] << 24) + (data[1] << 16) + (data[2] << 8) + data[3]) / 1e6 + ((data[4] & 128 ? -281474976710656 : 0) + data[6] * 1099511627776 + data[7] * 4294967296 + data[8] * 16777216 + (data[9] << 16) + (data[10] << 8) + data[11]) * 1e3
);
else
return /* @__PURE__ */ new Date("invalid");
};
function saveState(callback) {
if (currentUnpackr && currentUnpackr._onSaveState)
currentUnpackr._onSaveState();
let savedSrcEnd = srcEnd;
let savedPosition = position;
let savedStringPosition = stringPosition;
let savedSrcStringStart = srcStringStart;
let savedSrcStringEnd = srcStringEnd;
let savedSrcString = srcString;
let savedStrings = strings;
let savedReferenceMap = referenceMap;
let savedBundledStrings = bundledStrings;
let savedArrayAllocationBudget = arrayAllocationBudget;
let savedSrc = new Uint8Array(src.slice(0, srcEnd));
let savedStructures = currentStructures;
let savedStructuresContents = currentStructures.slice(0, currentStructures.length);
let savedPackr = currentUnpackr;
let savedSequentialMode = sequentialMode;
try {
return callback();
} finally {
srcEnd = savedSrcEnd;
position = savedPosition;
stringPosition = savedStringPosition;
srcStringStart = savedSrcStringStart;
srcStringEnd = savedSrcStringEnd;
srcString = savedSrcString;
strings = savedStrings;
referenceMap = savedReferenceMap;
bundledStrings = savedBundledStrings;
arrayAllocationBudget = savedArrayAllocationBudget;
src = savedSrc;
sequentialMode = savedSequentialMode;
currentStructures = savedStructures;
currentStructures.splice(0, currentStructures.length, ...savedStructuresContents);
currentUnpackr = savedPackr;
dataView = new DataView(src.buffer, src.byteOffset, src.byteLength);
}
}
function clearSource() {
src = null;
referenceMap = null;
currentStructures = null;
}
var mult10 = new Array(147);
for (let i = 0; i < 256; i++) {
mult10[i] = +("1e" + Math.floor(45.15 - i * 0.30103));
}
var defaultUnpackr = new Unpackr({ useRecords: false });
var unpack = defaultUnpackr.unpack;
var unpackMultiple = defaultUnpackr.unpackMultiple;
var decode = defaultUnpackr.unpack;
var FLOAT32_OPTIONS = {
NEVER: 0,
ALWAYS: 1,
DECIMAL_ROUND: 3,
DECIMAL_FIT: 4
};
var f32Array = new Float32Array(1);
var u8Array = new Uint8Array(f32Array.buffer, 0, 4);
Unpackr.SUPPORTS_STRUCT_HOOKS = true;
// ../../../../../setup-pnpm/store/v11/links/@/msgpackr/2.1.2/10be0e7cf51bd8e9aa3c1cc8013b24686f3b6cfdadd438a3065f8116f71f3aad/node_modules/msgpackr/pack.js
var textEncoder;
try {
textEncoder = new TextEncoder();
} catch (error) {
}
var extensions;
var extensionClasses;
var hasNodeBuffer = typeof Buffer !== "undefined";
var ByteArrayAllocate = hasNodeBuffer ? function(length) {
return Buffer.allocUnsafeSlow(length);
} : Uint8Array;
var ByteArray = hasNodeBuffer ? Buffer : Uint8Array;
var MAX_BUFFER_SIZE = hasNodeBuffer ? 4294967296 : 2144337920;
var target;
var keysTarget;
var targetView;
var position2 = 0;
var safeEnd;
var bundledStrings2 = null;
var packing = false;
var MAX_BUNDLE_SIZE = 21760;
var hasNonLatin = /[\u0080-\uFFFF]/;
var RECORD_SYMBOL = /* @__PURE__ */ Symbol("record-id");
var Packr = class extends Unpackr {
constructor(options) {
super(options);
this.offset = 0;
let typeBuffer;
let start;
let hasSharedUpdate;
let structures;
let referenceMap2;
let encodeUtf8 = ByteArray.prototype.utf8Write ? function(string, position3) {
return target.utf8Write(string, position3, target.byteLength - position3);
} : textEncoder && textEncoder.encodeInto ? function(string, position3) {
return textEncoder.encodeInto(string, target.subarray(position3)).written;
} : false;
let packr2 = this;
if (!options)
options = {};
let isSequential = options && options.sequential;
let hasSharedStructures = options.structures || options.saveStructures;
let maxSharedStructures = options.maxSharedStructures;
if (maxSharedStructures == null)
maxSharedStructures = hasSharedStructures ? 32 : 0;
if (maxSharedStructures > 8160)
throw new Error("Maximum maxSharedStructure is 8160");
if (options.structuredClone && options.moreTypes == void 0) {
this.moreTypes = true;
}
let maxOwnStructures = options.maxOwnStructures;
if (maxOwnStructures == null)
maxOwnStructures = hasSharedStructures ? 32 : 64;
if (!this.structures && options.useRecords != false)
this.structures = [];
let useTwoByteRecords = maxSharedStructures > 32 || maxOwnStructures + maxSharedStructures > 64;
let sharedLimitId = maxSharedStructures + 64;
let maxStructureId = maxSharedStructures + maxOwnStructures + 64;
if (maxStructureId > 8256) {
throw new Error("Maximum maxSharedStructure + maxOwnStructure is 8192");
}
let recordIdsToRemove = [];
let transitionsCount = 0;
let serializationsSinceTransitionRebuild = 0;
let instancePacking = false;
let reentrantDepth = 0;
let pendingNestedStructures = null;
this.pack = this.encode = function(value, encodeOptions) {
if (packing) {
return saveState2(value, encodeOptions);
}
if (!target) {
target = new ByteArrayAllocate(8192);
targetView = target.dataView || (target.dataView = new DataView(target.buffer, 0, 8192));
position2 = 0;
}
safeEnd = target.length - 10;
if (safeEnd - position2 < 2048) {
target = new ByteArrayAllocate(target.length);
targetView = target.dataView || (target.dataView = new DataView(target.buffer, 0, target.length));
safeEnd = target.length - 10;
position2 = 0;
} else
position2 = position2 + 7 & 2147483640;
start = position2;
if (encodeOptions & RESERVE_START_SPACE) position2 += encodeOptions & 255;
referenceMap2 = packr2.structuredClone ? /* @__PURE__ */ new Map() : null;
if (packr2.bundleStrings && typeof value !== "string") {
bundledStrings2 = [];
bundledStrings2.size = Infinity;
} else
bundledStrings2 = null;
structures = packr2.structures;
if (structures) {
if (structures.uninitialized)
structures = packr2._mergeStructures(packr2.getStructures());
let sharedLength = structures.sharedLength || 0;
if (sharedLength > maxSharedStructures) {
throw new Error("Shared structures is larger than maximum shared structures, try increasing maxSharedStructures to " + structures.sharedLength);
}
if (!structures.transitions) {
rebuildTransitions(reentrantDepth && packr2.saveStructures ? Math.min(sharedLength, packr2.lastNamedStructuresLength || 0) : sharedLength);
if (!reentrantDepth)
packr2.lastNamedStructuresLength = sharedLength;
}
if (!isSequential || !(structures.nextId >= sharedLength + 64)) {
structures.nextId = sharedLength + 64;
}
}
if (hasSharedUpdate)
hasSharedUpdate = false;
if (!reentrantDepth && pendingNestedStructures)
pendingNestedStructures = null;
let encodingError;
packing = true;
instancePacking = true;
try {
if (packr2._writeStruct && !(reentrantDepth && packr2.saveStructures) && value && typeof value === "object") {
if (value.constructor === Object) writeStruct(value);
else if (value.constructor !== Map && !Array.isArray(value) && !extensionClasses.some((extClass) => value instanceof extClass)) {
writeStruct(packr2.useToJSON !== false && value.toJSON ? value.toJSON() : value);
} else pack2(value);
} else
pack2(value);
let lastBundle = bundledStrings2;
if (bundledStrings2)
writeBundles(start, pack2, 0);
if (referenceMap2 && referenceMap2.idsToInsert) {
let idsToInsert = referenceMap2.idsToInsert.sort((a, b) => a.offset > b.offset ? 1 : -1);
let i = idsToInsert.length;
let incrementPosition = -1;
while (lastBundle && i > 0) {
let insertionPoint = idsToInsert[--i].offset + start;
if (insertionPoint < lastBundle.stringsPosition + start && incrementPosition === -1)
incrementPosition = 0;
if (insertionPoint > lastBundle.position + start) {
if (incrementPosition >= 0)
incrementPosition += 6;
} else {
if (incrementPosition >= 0) {
targetView.setUint32(
lastBundle.position + start,
targetView.getUint32(lastBundle.position + start) + incrementPosition
);
incrementPosition = -1;
}
lastBundle = lastBundle.previous;
i++;
}
}
if (incrementPosition >= 0 && lastBundle) {
targetView.setUint32(
lastBundle.position + start,
targetView.getUint32(lastBundle.position + start) + incrementPosition
);
}
position2 += idsToInsert.length * 6;
if (position2 > safeEnd)
makeRoom(position2);
packr2.offset = position2;
let serialized = insertIds(target.subarray(start, position2), idsToInsert);
referenceMap2 = null;
return serialized;
}
packr2.offset = position2;
if (encodeOptions & REUSE_BUFFER_MODE) {
target.start = start;
target.end = position2;
return target;
}
return target.subarray(start, position2);
} catch (error) {
encodingError = error;
throw error;
} finally {
instancePacking = false;
if (structures) {
resetStructures();
if (pendingNestedStructures && !reentrantDepth) {
let toPromote = pendingNestedStructures;
pendingNestedStructures = null;
if (!encodingError && packr2.saveStructures) {
let sharedLength = structures.sharedLength || 0;
if (!structures.transitions)
rebuildTransitions(sharedLength);
for (let i = 0, l = toPromote.length; i < l && sharedLength < maxSharedStructures; i++) {
let keys = toPromote[i];
let nextTransition, transition = structures.transitions;
for (let j = 0, kl = keys.length; j < kl; j++) {
let key = keys[j];
nextTransition = transition[key];
if (!nextTransition)
nextTransition = transition[key] = /* @__PURE__ */ Object.create(null);
transition = nextTransition;
}
if (!transition[RECORD_SYMBOL]) {
let recordId = sharedLength + 64;
keys.highByte = recordId >= 96 && useTwoByteRecords ? recordId - 96 >> 5 : -1;
keys.isShared = true;
transition[RECORD_SYMBOL] = recordId;
transition.__keys__ = keys;
structures[sharedLength++] = keys;
structures.sharedLength = sharedLength;
hasSharedUpdate = true;
}
}
if (!isSequential || !(structures.nextId >= sharedLength + 64))
structures.nextId = sharedLength + 64;
}
}
if (hasSharedUpdate && !reentrantDepth && packr2.saveStructures) {
let sharedLength = structures.sharedLength || 0;
let returnBuffer = target.subarray(start, position2);
if (!encodingError) {
let saveSucceeded = false;
try {
let newSharedData = (packr2._prepareStructures || prepareStructures)(structures, packr2);
if (packr2.saveStructures(newSharedData, newSharedData.isCompatible) === false) {
structures.uninitialized = true;
saveSucceeded = true;
packing = false;
return packr2.pack(value, encodeOptions);
}
saveSucceeded = true;
} finally {
packing = false;
if (!saveSucceeded) {
structures = packr2.structures;
if (packr2.getStructures)
structures.uninitialized = true;
structures.length = structures.sharedLength = packr2.lastNamedStructuresLength || 0;
structures.transitions = null;
}
}
packr2.lastNamedStructuresLength = sharedLength;
if (target.length > 1073741824) target = null;
return returnBuffer;
}
if (packr2.getStructures)
structures.uninitialized = true;
structures.length = structures.sharedLength = packr2.lastNamedStructuresLength || 0;
structures.transitions = null;
}
}
packing = false;
if (target.length > 1073741824) target = null;
if (encodeOptions & RESET_BUFFER_MODE)
position2 = start;
}
};
const rebuildTransitions = (sharedLength) => {
structures.transitions = /* @__PURE__ */ Object.create(null);
for (let i = 0; i < sharedLength; i++) {
let keys = structures[i];
if (!keys)
continue;
let nextTransition, transition = structures.transitions;
for (let j = 0, l = keys.length; j < l; j++) {
let key = keys[j];
nextTransition = transition[key];
if (!nextTransition) {
nextTransition = transition[key] = /* @__PURE__ */ Object.create(null);
}
transition = nextTransition;
}
transition[RECORD_SYMBOL] = i + 64;
}
};
const saveState2 = (value, encodeOptions) => {
let savedTarget = target;
let savedTargetView = targetView;
let savedPosition = position2;
let savedSafeEnd = safeEnd;
let savedBundledStrings = bundledStrings2;
let savedStart = start;
let savedReferenceMap = referenceMap2;
let savedHasSharedUpdate = hasSharedUpdate;
let wasInstancePacking = instancePacking;
let savedStructures, savedTransitions, savedNextId, savedNextOwnId, savedRecordIdsToRemove, savedRecordIds, savedOwnStructures, savedSharedLength, savedLastNamedLength, savedUnsavedShared, savedTransitionsCount, savedPendingNestedLen;
let nestedSucceeded = false;
if (wasInstancePacking) {
savedPendingNestedLen = pendingNestedStructures ? pendingNestedStructures.length : 0;
reentrantDepth++;
}
try {
if (wasInstancePacking && structures) {
savedStructures = structures;
savedTransitions = structures.transitions;
savedNextId = structures.nextId;
savedNextOwnId = structures.nextOwnId;
savedLastNamedLength = packr2.lastNamedStructuresLength;
savedSharedLength = structures.sharedLength || 0;
savedOwnStructures = structures.slice(savedSharedLength);
savedRecordIdsToRemove = recordIdsToRemove;
savedRecordIds = [];
for (let i = 0, l = recordIdsToRemove.length; i < l; i++) {
let transition = recordIdsToRemove[i];
let recordId = transition[RECORD_SYMBOL];
savedRecordIds[i] = recordId;
transition[RECORD_SYMBOL] = 0;
if (recordId >= savedSharedLength + 64 && transition.__keys__)
savedOwnStructures[recordId - savedSharedLength - 64] = transition.__keys__;
}
recordIdsToRemove = [];
if (savedHasSharedUpdate && packr2.saveStructures && savedTransitions) {
savedUnsavedShared = [];
for (let i = savedLastNamedLength || 0; i < savedSharedLength; i++) {
let keys = structures[i];
if (!keys)
continue;
let transition = savedTransitions;
for (let j = 0, l = keys.length; j < l && transition; j++) {
transition = transition[keys[j]];
}
if (transition && transition[RECORD_SYMBOL] === i + 64) {
savedUnsavedShared.push(transition, i + 64, transition.__keys__);
transition[RECORD_SYMBOL] = 0;
transition.__keys__ = null;
}
}
}
structures.length = savedSharedLength;
structures.nextId = savedSharedLength + 64;
structures.nextOwnId = void 0;
savedTransitionsCount = transitionsCount;
transitionsCount = 0;
}
target = null;
packing = false;
instancePacking = false;
let result = packr2.pack(value, encodeOptions);
nestedSucceeded = true;
return result;
} finally {
if (!nestedSucceeded && wasInstancePacking && pendingNestedStructures)
pendingNestedStructures.length = savedPendingNestedLen;
packing = true;
instancePacking = wasInstancePacking;
target = savedTarget;
targetView = savedTargetView;
position2 = savedPosition;
safeEnd = savedSafeEnd;
bundledStrings2 = savedBundledStrings;
start = savedStart;
referenceMap2 = savedReferenceMap;
if (wasInstancePacking) {
reentrantDepth--;
hasSharedUpdate = savedHasSharedUpdate || hasSharedUpdate;
structures = packr2.structures;
if (structures && savedOwnStructures) {
if (recordIdsToRemove !== savedRecordIdsToRemove) {
for (let i = 0, l = recordIdsToRemove.length; i < l; i++) {
recordIdsToRemove[i][RECORD_SYMBOL] = 0;
}
}
let currentSharedLength = structures.sharedLength || 0;
if (structures !== savedStructures) {
if (savedHasSharedUpdate || savedOwnStructures.length > 0) {
for (let i = 0; i < savedSharedLength; i++) {
if (savedStructures[i] !== void 0)
structures[i] = savedStructures[i];
}
currentSharedLength = structures.sharedLength = structures.length = savedSharedLength;
packr2.lastNamedStructuresLength = savedLastNamedLength;
} else if (!reentrantDepth && !hasSharedUpdate) {
packr2.lastNamedStructuresLength = currentSharedLength;
}
}
structures.length = Math.max(currentSharedLength, savedSharedLength + savedOwnStructures.length);
for (let i = Math.max(0, currentSharedLength - savedSharedLength), l = savedOwnStructures.length; i < l; i++) {
if (savedOwnStructures[i] !== void 0)
structures[savedSharedLength + i] = savedOwnStructures[i];
}
if (structures.transitions !== savedTransitions || structures !== savedStructures) {
if (structures === savedStructures && !structures.transitions && currentSharedLength === savedSharedLength) {
structures.transitions = savedTransitions;
} else {
rebuildTransitions(reentrantDepth && packr2.saveStructures ? Math.min(currentSharedLength, packr2.lastNamedStructuresLength || 0) : currentSharedLength);
savedUnsavedShared = null;
savedRecordIdsToRemove = [];
savedRecordIds = [];
for (let i = Math.max(0, currentSharedLength - savedSharedLength), l = savedOwnStructures.length; i < l; i++) {
let keys = savedOwnStructures[i];
if (!keys)
continue;
let nextTransition, transition = structures.transitions;
for (let j = 0, kl = keys.length; j < kl; j++) {
let key = keys[j];
nextTransition = transition[key];
if (!nextTransition)
nextTransition = transition[key] = /* @__PURE__ */ Object.create(null);
transition = nextTransition;
}
if (!transition[RECORD_SYMBOL]) {
savedRecordIdsToRemove.push(transition);
savedRecordIds.push(savedSharedLength + i + 64);
}
}
}
}
if (savedUnsavedShared) {
for (let i = 0, l = savedUnsavedShared.length; i < l; i += 3) {
savedUnsavedShared[i][RECORD_SYMBOL] = savedUnsavedShared[i + 1];
savedUnsavedShared[i].__keys__ = savedUnsavedShared[i + 2];
}
}
recordIdsToRemove = savedRecordIdsToRemove;
for (let i = 0, l = savedRecordIds.length; i < l; i++) {
if (!recordIdsToRemove[i][RECORD_SYMBOL])
recordIdsToRemove[i][RECORD_SYMBOL] = savedRecordIds[i];
}
structures.nextId = !(savedNextId >= currentSharedLength + 64) ? currentSharedLength + 64 : savedNextId;
structures.nextOwnId = savedNextOwnId;
if (savedTransitionsCount !== void 0)
transitionsCount += savedTransitionsCount;
}
} else {
hasSharedUpdate = savedHasSharedUpdate;
}
}
};
const resetStructures = () => {
if (serializationsSinceTransitionRebuild < 10)
serializationsSinceTransitionRebuild++;
let sharedLength = structures.sharedLength || 0;
if (structures.length > sharedLength && !isSequential)
structures.length = sharedLength;
if (transitionsCount > 1e4 && !reentrantDepth) {
structures.transitions = null;
serializationsSinceTransitionRebuild = 0;
transitionsCount = 0;
if (recordIdsToRemove.length > 0)
recordIdsToRemove = [];
} else if (recordIdsToRemove.length > 0 && !isSequential) {
for (let i = 0, l = recordIdsToRemove.length; i < l; i++) {
recordIdsToRemove[i][RECORD_SYMBOL] = 0;
}
recordIdsToRemove = [];
}
};
const packArray = (value) => {
var length = value.length;
if (length < 16) {
target[position2++] = 144 | length;
} else if (length < 65536) {
target[position2++] = 220;
target[position2++] = length >> 8;
target[position2++] = length & 255;
} else {
target[position2++] = 221;
targetView.setUint32(position2, length);
position2 += 4;
}
for (let i = 0; i < length; i++) {
pack2(value[i]);
}
};
const pack2 = (value) => {
if (position2 > safeEnd)
target = makeRoom(position2);
var type = typeof value;
var length;
if (type === "string") {
let strLength = value.length;
if (bundledStrings2 && strLength >= 4 && strLength < 4096) {
if ((bundledStrings2.size += strLength) > MAX_BUNDLE_SIZE) {
let extStart;
let maxBytes2 = (bundledStrings2[0] ? bundledStrings2[0].length * 3 + bundledStrings2[1].length : 0) + 10;
if (position2 + maxBytes2 > safeEnd)
target = makeRoom(position2 + maxBytes2);
let lastBundle;
if (bundledStrings2.position) {
lastBundle = bundledStrings2;
target[position2] = 200;
position2 += 3;
target[position2++] = 98;
extStart = position2 - start;
position2 += 4;
writeBundles(start, pack2, 0);
targetView.setUint16(extStart + start - 3, position2 - start - extStart);
} else {
target[position2++] = 214;
target[position2++] = 98;
extStart = position2 - start;
position2 += 4;
}
bundledStrings2 = ["", ""];
bundledStrings2.previous = lastBundle;
bundledStrings2.size = 0;
bundledStrings2.position = extStart;
}
let twoByte = hasNonLatin.test(value);
bundledStrings2[twoByte ? 0 : 1] += value;
target[position2++] = 193;
pack2(twoByte ? -strLength : strLength);
return;
}
let headerSize;
if (strLength < 32) {
headerSize = 1;
} else if (strLength < 256) {
headerSize = 2;
} else if (strLength < 65536) {
headerSize = 3;
} else {
headerSize = 5;
}
let maxBytes = strLength * 3;
if (position2 + maxBytes > safeEnd)
target = makeRoom(position2 + maxBytes);
if (strLength < 64 || !encodeUtf8) {
let i, c1, c2, strPosition = position2 + headerSize;
for (i = 0; i < strLength; i++) {
c1 = value.charCodeAt(i);
if (c1 < 128) {
target[strPosition++] = c1;
} else if (c1 < 2048) {
target[strPosition++] = c1 >> 6 | 192;
target[strPosition++] = c1 & 63 | 128;
} else if ((c1 & 64512) === 55296 && ((c2 = value.charCodeAt(i + 1)) & 64512) === 56320) {
c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
i++;
target[strPosition++] = c1 >> 18 | 240;
target[strPosition++] = c1 >> 12 & 63 | 128;
target[strPosition++] = c1 >> 6 & 63 | 128;
target[strPosition++] = c1 & 63 | 128;
} else {
target[strPosition++] = c1 >> 12 | 224;
target[strPosition++] = c1 >> 6 & 63 | 128;
target[strPosition++] = c1 & 63 | 128;
}
}
length = strPosition - position2 - headerSize;
} else {
length = encodeUtf8(value, position2 + headerSize);
}
if (length < 32) {
target[position2++] = 160 | length;
} else if (length < 256) {
if (headerSize < 2) {
target.copyWithin(position2 + 2, position2 + 1, position2 + 1 + length);
}
target[position2++] = 217;
target[position2++] = length;
} else if (length < 65536) {
if (headerSize < 3) {
target.copyWithin(position2 + 3, position2 + 2, position2 + 2 + length);
}
target[position2++] = 218;
target[position2++] = length >> 8;
target[position2++] = length & 255;
} else {
if (headerSize < 5) {
target.copyWithin(position2 + 5, position2 + 3, position2 + 3 + length);
}
target[position2++] = 219;
targetView.setUint32(position2, length);
position2 += 4;
}
position2 += length;
} else if (type === "number") {
if (value >>> 0 === value) {
if (value < 32 || value < 128 && this.useRecords === false || value < 64 && !this._writeStruct) {
target[position2++] = value;
} else if (value < 256) {
target[position2++] = 204;
target[position2++] = value;
} else if (value < 65536) {
target[position2++] = 205;
target[position2++] = value >> 8;
target[position2++] = value & 255;
} else {
target[position2++] = 206;
targetView.setUint32(position2, value);
position2 += 4;
}
} else if (value >> 0 === value) {
if (value >= -32) {
target[position2++] = 256 + value;
} else if (value >= -128) {
target[position2++] = 208;
target[position2++] = value + 256;
} else if (value >= -32768) {
target[position2++] = 209;
targetView.setInt16(position2, value);
position2 += 2;
} else {
target[position2++] = 210;
targetView.setInt32(position2, value);
position2 += 4;
}
} else {
let useFloat32;
if ((useFloat32 = this.useFloat32) > 0 && value < 4294967296 && value >= -2147483648) {
target[position2++] = 202;
targetView.setFloat32(position2, value);
let xShifted;
if (useFloat32 < 4 || // this checks for rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
(xShifted = value * mult10[(target[position2] & 127) << 1 | target[position2 + 1] >> 7]) >> 0 === xShifted) {
position2 += 4;
return;
} else
position2--;
}
target[position2++] = 203;
targetView.setFloat64(position2, value);
position2 += 8;
}
} else if (type === "object" || type === "function") {
if (!value)
target[position2++] = 192;
else {
if (referenceMap2) {
let referee = referenceMap2.get(value);
if (referee) {
if (!referee.id) {
let idsToInsert = referenceMap2.idsToInsert || (referenceMap2.idsToInsert = []);
referee.id = idsToInsert.push(referee);
}
target[position2++] = 214;
target[position2++] = 112;
targetView.setUint32(position2, referee.id);
position2 += 4;
return;
} else
referenceMap2.set(value, { offset: position2 - start });
}
let constructor = value.constructor;
if (constructor === Object) {
writeObject(value);
} else if (constructor === Array) {
packArray(value);
} else if (constructor === Map) {
if (this.mapAsEmptyObject) target[position2++] = 128;
else {
length = value.size;
if (length < 16) {
target[position2++] = 128 | length;
} else if (length < 65536) {
target[position2++] = 222;
target[position2++] = length >> 8;
target[position2++] = length & 255;
} else {
target[position2++] = 223;
targetView.setUint32(position2, length);
position2 += 4;
}
for (let [key, entryValue] of value) {
pack2(key);
pack2(entryValue);
}
}
} else {
for (let i = 0, l = extensions.length; i < l; i++) {
let extensionClass = extensionClasses[i];
if (value instanceof extensionClass) {
if (value.constructor !== extensionClass && packr2.useToJSON !== false && value.toJSON !== void 0 && value.toJSON !== dateToJSON && value.toJSON !== bufferToJSON) {
break;
}
let extension = extensions[i];
if (extension.write) {
if (extension.type) {
target[position2++] = 212;
target[position2++] = extension.type;
target[position2++] = 0;
}
let writeResult = extension.write.call(this, value);
if (writeResult === value) {
if (Array.isArray(value)) {
packArray(value);
} else {
writeObject(value);
}
} else {
pack2(writeResult);
}
return;
}
let currentTarget = target;
let currentTargetView = targetView;
let currentPosition = position2;
let currentBundledStrings = bundledStrings2;
target = null;
let result;
try {
result = extension.pack.call(this, value, (size) => {
target = currentTarget;
currentTarget = null;
position2 += size;
if (position2 > safeEnd)
makeRoom(position2);
return {
target,
targetView,
position: position2 - size
};
}, pack2);
} finally {
if (currentTarget) {
target = currentTarget;
targetView = currentTargetView;
position2 = currentPosition;
bundledStrings2 = currentBundledStrings;
safeEnd = target.length - 10;
}
}
if (result) {
if (result.length + position2 > safeEnd)
makeRoom(result.length + position2);
position2 = writeExtensionData(result, target, position2, extension.type);
}
return;
}
}
if (Array.isArray(value)) {
packArray(value);
} else {
if (packr2.useToJSON !== false && value.toJSON) {
const json = value.toJSON();
if (json !== value)
return pack2(json);
}
if (type === "function")
return pack2(this.writeFunction && this.writeFunction(value));
writeObject(value);
}
}
}
} else if (type === "boolean") {
target[position2++] = value ? 195 : 194;
} else if (type === "bigint") {
if (value < 9223372036854776e3 && value >= -9223372036854776e3) {
target[position2++] = 211;
targetView.setBigInt64(position2, value);
} else if (value < 18446744073709552e3 && value > 0) {
target[position2++] = 207;
targetView.setBigUint64(position2, value);
} else {
if (this.largeBigIntToFloat) {
target[position2++] = 203;
targetView.setFloat64(position2, Number(value));
} else if (this.largeBigIntToString) {
return pack2(value.toString());
} else if (this.useBigIntExtension || this.moreTypes) {
let empty = value < 0 ? BigInt(-1) : BigInt(0);
let array;
if (value >> BigInt(65536) === empty) {
let mask = BigInt(18446744073709552e3) - BigInt(1);
let chunks = [];
while (true) {
chunks.push(value & mask);
if (value >> BigInt(63) === empty) break;
value >>= BigInt(64);
}
array = new Uint8Array(new BigUint64Array(chunks).buffer);
array.reverse();
} else {
let invert = value < 0;
let string = (invert ? ~value : value).toString(16);
if (string.length % 2) {
string = "0" + string;
} else if (parseInt(string.charAt(0), 16) >= 8) {
string = "00" + string;
}
if (hasNodeBuffer) {
array = Buffer.from(string, "hex");
} else {
array = new Uint8Array(string.length / 2);
for (let i = 0; i < array.length; i++) {
array[i] = parseInt(string.slice(i * 2, i * 2 + 2), 16);
}
}
if (invert) {
for (let i = 0; i < array.length; i++) array[i] = ~array[i];
}
}
if (array.length + position2 > safeEnd)
makeRoom(array.length + position2);
position2 = writeExtensionData(array, target, position2, 66);
return;
} else {
throw new RangeError(value + " was too large to fit in MessagePack 64-bit integer format, use useBigIntExtension, or set largeBigIntToFloat to convert to float-64, or set largeBigIntToString to convert to string");
}
}
position2 += 8;
} else if (type === "undefined") {
if (this.encodeUndefinedAsNil)
target[position2++] = 192;
else {
target[position2++] = 212;
target[position2++] = 0;
target[position2++] = 0;
}
} else {
throw new Error("Unknown type: " + type);
}
};
const writePlainObject = this.variableMapSize || this.coercibleKeyAsNumber || this.skipValues ? (object) => {
let keys;
if (this.skipValues) {
keys = [];
for (let key2 in object) {
if ((typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key2)) && !this.skipValues.includes(object[key2]))
keys.push(key2);
}
} else {
keys = Object.keys(object);
}
let length = keys.length;
if (length < 16) {
target[position2++] = 128 | length;
} else if (length < 65536) {
target[position2++] = 222;
target[position2++] = length >> 8;
target[position2++] = length & 255;
} else {
target[position2++] = 223;
targetView.setUint32(position2, length);
position2 += 4;
}
let key;
if (this.coercibleKeyAsNumber) {
for (let i = 0; i < length; i++) {
key = keys[i];
let num = Number(key);
pack2(isNaN(num) ? key : num);
pack2(object[key]);
}
} else {
for (let i = 0; i < length; i++) {
pack2(key = keys[i]);
pack2(object[key]);
}
}
} : (object) => {
target[position2++] = 222;
let objectOffset = position2 - start;
position2 += 2;
let size = 0;
for (let key in object) {
if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) {
pack2(key);
pack2(object[key]);
size++;
}
}
if (size > 65535) {
throw new Error('Object is too large to serialize with fast 16-bit map size, use the "variableMapSize" option to serialize this object');
}
target[objectOffset++ + start] = size >> 8;
target[objectOffset + start] = size & 255;
};
const writeRecord = this.useRecords === false ? writePlainObject : options.progressiveRecords && !useTwoByteRecords && maxOwnStructures > 0 ? (
// this is about 2% faster for highly stable structures, since it only requires one for-in loop (but much more expensive when new structure needs to be written)
(object) => {
let nextTransition, transition = structures.transitions || (structures.transitions = /* @__PURE__ */ Object.create(null));
let objectOffset = position2++ - start;
let wroteKeys;
for (let key in object) {
if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) {
nextTransition = transition[key];
if (nextTransition)
transition = nextTransition;
else {
let keys = Object.keys(object);
let lastTransition = transition;
transition = structures.transitions;
let newTransitions = 0;
for (let i = 0, l = keys.length; i < l; i++) {
let key2 = keys[i];
nextTransition = transition[key2];
if (!nextTransition) {
nextTransition = transition[key2] = /* @__PURE__ */ Object.create(null);
newTransitions++;
}
transition = nextTransition;
}
if (objectOffset + start + 1 == position2) {
position2--;
newRecord(transition, keys, newTransitions);
} else
insertNewRecord(transition, keys, objectOffset, newTransitions);
wroteKeys = true;
transition = lastTransition[key];
}
pack2(object[key]);
}
}
if (!wroteKeys) {
let recordId = transition[RECORD_SYMBOL];
if (recordId)
target[objectOffset + start] = recordId;
else
insertNewRecord(transition, Object.keys(object), objectOffset, 0);
}
}
) : (object) => {
let nextTransition, transition = structures.transitions || (structures.transitions = /* @__PURE__ */ Object.create(null));
let newTransitions = 0;
for (let key in object) if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) {
nextTransition = transition[key];
if (!nextTransition) {
nextTransition = transition[key] = /* @__PURE__ */ Object.create(null);
newTransitions++;
}
transition = nextTransition;
}
let recordId = transition[RECORD_SYMBOL];
if (recordId) {
if (recordId >= 96 && useTwoByteRecords) {
target[position2++] = ((recordId -= 96) & 31) + 96;
target[position2++] = recordId >> 5;
} else
target[position2++] = recordId;
} else if (newRecord(transition, transition.__keys__ || Object.keys(object), newTransitions) === false) {
return writePlainObject(object);
}
for (let key in object)
if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) {
pack2(object[key]);
}
};
const checkUseRecords = typeof this.useRecords == "function" && this.useRecords;
const writeObject = checkUseRecords ? (object) => {
checkUseRecords(object) ? writeRecord(object) : writePlainObject(object);
} : writeRecord;
const writeStruct = (object) => {
let newPosition = packr2._writeStruct(object, target, start, position2, structures, makeRoom, (value, newPosition2, notifySharedUpdate) => {
if (notifySharedUpdate)
return hasSharedUpdate = true;
position2 = newPosition2;
let startTarget = target;
pack2(value);
resetStructures();
if (startTarget !== target) {
return { position: position2, targetView, target };
}
return position2;
});
if (newPosition === 0)
return writeObject(object);
position2 = newPosition;
};
const makeRoom = (end) => {
let newSize;
if (end > 16777216) {
if (end - start > MAX_BUFFER_SIZE)
throw new Error("Packed buffer would be larger than maximum buffer size");
newSize = Math.min(
MAX_BUFFER_SIZE,
Math.round(Math.max((end - start) * (end > 67108864 ? 1.25 : 2), 4194304) / 4096) * 4096
);
} else
newSize = (Math.max(end - start << 2, target.length - 1) >> 12) + 1 << 12;
let newBuffer = new ByteArrayAllocate(newSize);
targetView = newBuffer.dataView || (newBuffer.dataView = new DataView(newBuffer.buffer, 0, newSize));
end = Math.min(end, target.length);
if (target.copy)
target.copy(newBuffer, 0, start, end);
else
newBuffer.set(target.slice(start, end));
position2 -= start;
start = 0;
safeEnd = newBuffer.length - 10;
return target = newBuffer;
};
const newRecord = (transition, keys, newTransitions) => {
let recordId = structures.nextId;
if (!recordId)
recordId = 64;
if (recordId < sharedLimitId && (reentrantDepth && this.saveStructures || this.shouldShareStructure && !this.shouldShareStructure(keys))) {
if (reentrantDepth && this.saveStructures && !(this.shouldShareStructure && !this.shouldShareStructure(keys)))
(pendingNestedStructures || (pendingNestedStructures = [])).push(keys);
if (!maxOwnStructures)
return false;
recordId = structures.nextOwnId;
if (!(recordId < maxStructureId))
recordId = sharedLimitId;
structures.nextOwnId = recordId + 1;
} else {
if (recordId >= maxStructureId) {
if (!maxOwnStructures)
return false;
recordId = sharedLimitId;
}
structures.nextId = recordId + 1;
}
let highByte = keys.highByte = recordId >= 96 && useTwoByteRecords ? recordId - 96 >> 5 : -1;
transition[RECORD_SYMBOL] = recordId;
transition.__keys__ = keys;
structures[recordId - 64] = keys;
if (recordId < sharedLimitId) {
keys.isShared = true;
structures.sharedLength = recordId - 63;
hasSharedUpdate = true;
if (highByte >= 0) {
target[position2++] = (recordId & 31) + 96;
target[position2++] = highByte;
} else {
target[position2++] = recordId;
}
} else {
if (highByte >= 0) {
target[position2++] = 213;
target[position2++] = 114;
target[position2++] = (recordId & 31) + 96;
target[position2++] = highByte;
} else {
target[position2++] = 212;
target[position2++] = 114;
target[position2++] = recordId;
}
if (newTransitions)
transitionsCount += serializationsSinceTransitionRebuild * newTransitions;
if (recordIdsToRemove.length >= maxOwnStructures)
recordIdsToRemove.shift()[RECORD_SYMBOL] = 0;
recordIdsToRemove.push(transition);
pack2(keys);
}
};
const insertNewRecord = (transition, keys, insertionOffset, newTransitions) => {
let mainTarget = target;
let mainPosition = position2;
let mainSafeEnd = safeEnd;
let mainStart = start;
target = keysTarget;
position2 = 0;
start = 0;
if (!target)
keysTarget = target = new ByteArrayAllocate(8192);
safeEnd = target.length - 10;
newRecord(transition, keys, newTransitions);
keysTarget = target;
let keysPosition = position2;
target = mainTarget;
position2 = mainPosition;
safeEnd = mainSafeEnd;
start = mainStart;
if (keysPosition > 1) {
let newEnd = position2 + keysPosition - 1;
if (newEnd > safeEnd)
makeRoom(newEnd);
let insertionPosition = insertionOffset + start;
target.copyWithin(insertionPosition + keysPosition, insertionPosition + 1, position2);
target.set(keysTarget.slice(0, keysPosition), insertionPosition);
position2 = newEnd;
} else {
target[insertionOffset + start] = keysTarget[0];
}
};
}
useBuffer(buffer) {
target = buffer;
target.dataView || (target.dataView = new DataView(target.buffer, target.byteOffset, target.byteLength));
targetView = target.dataView;
position2 = 0;
}
set position(value) {
position2 = value;
}
get position() {
return position2;
}
clearSharedData() {
if (this.structures) {
this.structures = [];
this.lastNamedStructuresLength = 0;
}
if (this.typedStructs)
this.typedStructs = [];
}
};
var dateToJSON = Date.prototype.toJSON;
var bufferToJSON = typeof Buffer !== "undefined" ? Buffer.prototype.toJSON : dateToJSON;
extensionClasses = [Date, Set, Error, RegExp, ArrayBuffer, Object.getPrototypeOf(Uint8Array.prototype).constructor, DataView, C1Type];
extensions = [{
pack(date, allocateForWrite, pack2) {
let seconds = date.getTime() / 1e3;
if ((this.useTimestamp32 || date.getMilliseconds() === 0) && seconds >= 0 && seconds < 4294967296) {
let { target: target2, targetView: targetView2, position: position3 } = allocateForWrite(6);
target2[position3++] = 214;
target2[position3++] = 255;
targetView2.setUint32(position3, seconds);
} else if (seconds > 0 && seconds < 4294967296) {
let { target: target2, targetView: targetView2, position: position3 } = allocateForWrite(10);
target2[position3++] = 215;
target2[position3++] = 255;
targetView2.setUint32(position3, date.getMilliseconds() * 4e6 + (seconds / 1e3 / 4294967296 >> 0));
targetView2.setUint32(position3 + 4, seconds);
} else if (isNaN(seconds)) {
if (this.onInvalidDate) {
allocateForWrite(0);
return pack2(this.onInvalidDate());
}
let { target: target2, targetView: targetView2, position: position3 } = allocateForWrite(3);
target2[position3++] = 212;
target2[position3++] = 255;
target2[position3++] = 255;
} else {
let { target: target2, targetView: targetView2, position: position3 } = allocateForWrite(15);
target2[position3++] = 199;
target2[position3++] = 12;
target2[position3++] = 255;
targetView2.setUint32(position3, date.getMilliseconds() * 1e6);
targetView2.setBigInt64(position3 + 4, BigInt(Math.floor(seconds)));
}
}
}, {
pack(set, allocateForWrite, pack2) {
if (this.setAsEmptyObject) {
allocateForWrite(0);
return pack2({});
}
let array = Array.from(set);
let { target: target2, position: position3 } = allocateForWrite(this.moreTypes ? 3 : 0);
if (this.moreTypes) {
target2[position3++] = 212;
target2[position3++] = 115;
target2[position3++] = 0;
}
pack2(array);
}
}, {
pack(error, allocateForWrite, pack2) {
let { target: target2, position: position3 } = allocateForWrite(this.moreTypes ? 3 : 0);
if (this.moreTypes) {
target2[position3++] = 212;
target2[position3++] = 101;
target2[position3++] = 0;
}
pack2([error.name, error.message, error.cause]);
}
}, {
pack(regex, allocateForWrite, pack2) {
let { target: target2, position: position3 } = allocateForWrite(this.moreTypes ? 3 : 0);
if (this.moreTypes) {
target2[position3++] = 212;
target2[position3++] = 120;
target2[position3++] = 0;
}
pack2([regex.source, regex.flags]);
}
}, {
pack(arrayBuffer, allocateForWrite) {
if (this.moreTypes)
writeExtBuffer(arrayBuffer, 16, allocateForWrite);
else
writeBuffer(hasNodeBuffer ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
}
}, {
pack(typedArray, allocateForWrite) {
let constructor = typedArray.constructor;
if (constructor !== ByteArray && this.moreTypes)
writeExtBuffer(typedArray, typedArrays.indexOf(constructor.name), allocateForWrite);
else
writeBuffer(typedArray, allocateForWrite);
}
}, {
pack(arrayBuffer, allocateForWrite) {
if (this.moreTypes)
writeExtBuffer(arrayBuffer, 17, allocateForWrite);
else
writeBuffer(hasNodeBuffer ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
}
}, {
pack(c1, allocateForWrite) {
let { target: target2, position: position3 } = allocateForWrite(1);
target2[position3] = 193;
}
}];
function writeExtBuffer(typedArray, type, allocateForWrite, encode2) {
let length = typedArray.byteLength;
if (length + 1 < 256) {
var { target: target2, position: position3 } = allocateForWrite(4 + length);
target2[position3++] = 199;
target2[position3++] = length + 1;
} else if (length + 1 < 65536) {
var { target: target2, position: position3 } = allocateForWrite(5 + length);
target2[position3++] = 200;
target2[position3++] = length + 1 >> 8;
target2[position3++] = length + 1 & 255;
} else {
var { target: target2, position: position3, targetView: targetView2 } = allocateForWrite(7 + length);
target2[position3++] = 201;
targetView2.setUint32(position3, length + 1);
position3 += 4;
}
target2[position3++] = 116;
target2[position3++] = type;
if (!typedArray.buffer) typedArray = new Uint8Array(typedArray);
target2.set(new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength), position3);
}
function writeBuffer(buffer, allocateForWrite) {
let length = buffer.byteLength;
var target2, position3;
if (length < 256) {
var { target: target2, position: position3 } = allocateForWrite(length + 2);
target2[position3++] = 196;
target2[position3++] = length;
} else if (length < 65536) {
var { target: target2, position: position3 } = allocateForWrite(length + 3);
target2[position3++] = 197;
target2[position3++] = length >> 8;
target2[position3++] = length & 255;
} else {
var { target: target2, position: position3, targetView: targetView2 } = allocateForWrite(length + 5);
target2[position3++] = 198;
targetView2.setUint32(position3, length);
position3 += 4;
}
target2.set(buffer, position3);
}
function writeExtensionData(result, target2, position3, type) {
let length = result.length;
switch (length) {
case 1:
target2[position3++] = 212;
break;
case 2:
target2[position3++] = 213;
break;
case 4:
target2[position3++] = 214;
break;
case 8:
target2[position3++] = 215;
break;
case 16:
target2[position3++] = 216;
break;
default:
if (length < 256) {
target2[position3++] = 199;
target2[position3++] = length;
} else if (length < 65536) {
target2[position3++] = 200;
target2[position3++] = length >> 8;
target2[position3++] = length & 255;
} else {
target2[position3++] = 201;
target2[position3++] = length >> 24;
target2[position3++] = length >> 16 & 255;
target2[position3++] = length >> 8 & 255;
target2[position3++] = length & 255;
}
}
target2[position3++] = type;
target2.set(result, position3);
position3 += length;
return position3;
}
function insertIds(serialized, idsToInsert) {
let nextId;
let distanceToMove = idsToInsert.length * 6;
let lastEnd = serialized.length - distanceToMove;
while (nextId = idsToInsert.pop()) {
let offset = nextId.offset;
let id = nextId.id;
serialized.copyWithin(offset + distanceToMove, offset, lastEnd);
distanceToMove -= 6;
let position3 = offset + distanceToMove;
serialized[position3++] = 214;
serialized[position3++] = 105;
serialized[position3++] = id >> 24;
serialized[position3++] = id >> 16 & 255;
serialized[position3++] = id >> 8 & 255;
serialized[position3++] = id & 255;
lastEnd = offset;
}
return serialized;
}
function writeBundles(start, pack2, incrementPosition) {
if (bundledStrings2.length > 0) {
targetView.setUint32(bundledStrings2.position + start, position2 + incrementPosition - bundledStrings2.position - start);
bundledStrings2.stringsPosition = position2 - start;
let writeStrings = bundledStrings2;
bundledStrings2 = null;
pack2(writeStrings[0]);
pack2(writeStrings[1]);
}
}
function prepareStructures(structures, packr2) {
structures.isCompatible = (existingStructures) => {
let compatible = !existingStructures || (packr2.lastNamedStructuresLength || 0) === existingStructures.length;
if (!compatible)
packr2._mergeStructures(existingStructures);
return compatible;
};
return structures;
}
Packr.SUPPORTS_STRUCT_HOOKS = true;
var defaultPackr = new Packr({ useRecords: false });
var pack = defaultPackr.pack;
var encode = defaultPackr.pack;
var { NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT } = FLOAT32_OPTIONS;
var REUSE_BUFFER_MODE = 512;
var RESET_BUFFER_MODE = 1024;
var RESERVE_START_SPACE = 2048;
// ../../../../../setup-pnpm/store/v11/links/@/msgpackr/2.1.2/10be0e7cf51bd8e9aa3c1cc8013b24686f3b6cfdadd438a3065f8116f71f3aad/node_modules/msgpackr/node-index.js
import { createRequire } from "module";
var nativeAccelerationDisabled = process.env.MSGPACKR_NATIVE_ACCELERATION_DISABLED !== void 0 && process.env.MSGPACKR_NATIVE_ACCELERATION_DISABLED.toLowerCase() === "true";
if (!nativeAccelerationDisabled) {
let extractor;
try {
if (typeof __require == "function")
extractor = require_msgpackr_extract();
else
extractor = createRequire(import.meta.url)("msgpackr-extract");
if (extractor)
setExtractor(extractor.extractStrings);
} catch (error) {
}
}
// ../store/index/lib/fallbackDatabase.js
import { randomInt } from "node:crypto";
import fs15 from "node:fs";
import path15 from "node:path";
import { threadId as threadId2 } from "node:worker_threads";
var fallbackPackr = new Packr({
useRecords: false,
moreTypes: true
});
var sleepBuffer = new Int32Array(new SharedArrayBuffer(4));
var fallbackDatabases = /* @__PURE__ */ new WeakSet();
var FALLBACK_INDEX_FILE = "index.fallback";
function adaptStoreDatabase(db, storeDir) {
if (typeof db.prepare !== "function") {
closeSqliteQuietly(db);
return createFallbackDatabase(storeDir);
}
if (typeof db.exec !== "function") {
const prepare = db.prepare.bind(db);
const exec = (sql) => {
const stmt = prepare(sql);
if (typeof stmt?.run !== "function") {
throw new TypeError("DatabaseSync statement run is not a function");
}
stmt.run();
};
try {
db.exec = exec;
} catch {
closeSqliteQuietly(db);
return createFallbackDatabase(storeDir);
}
}
return db;
}
function createFallbackDatabase(storeDir) {
const state = {
dataPath: path15.join(storeDir, FALLBACK_INDEX_FILE),
rows: /* @__PURE__ */ new Map(),
revision: -1,
tx: null
};
const db = {
exec(sql) {
prepareFallbackStatement(state, sql).run();
},
prepare(sql) {
return prepareFallbackStatement(state, sql);
},
close() {
state.tx = null;
}
};
fallbackDatabases.add(db);
return db;
}
var NO_OP_SQL_PREFIXES = ["pragma ", "vacuum", "create table"];
var FALLBACK_STATEMENTS = [
{
matches: (normalizedSql) => NO_OP_SQL_PREFIXES.some((prefix) => normalizedSql.startsWith(prefix)),
createHandlers: () => ({})
},
{
matches: sqlStartsWith("begin"),
createHandlers: (state) => ({ run: () => runAndReportNoChanges(() => begin(state)) })
},
{
matches: sqlEquals("commit"),
createHandlers: (state) => ({ run: () => runAndReportNoChanges(() => commit(state)) })
},
{
matches: sqlEquals("rollback"),
createHandlers: (state) => ({ run: () => runAndReportNoChanges(() => rollback(state)) })
},
{
matches: sqlStartsWith("select data from package_index where key"),
createHandlers: (state) => ({
get: (key) => {
const data = view(state).get(String(key));
return data == null ? void 0 : { data };
}
})
},
{
matches: sqlStartsWith("select 1 from package_index where key"),
createHandlers: (state) => ({
get: (key) => view(state).has(String(key)) ? { 1: 1 } : void 0
})
},
{
matches: sqlStartsWith("select key, data from package_index"),
createHandlers: (state) => ({
iterate: () => iterateEntries(view(state))
})
},
{
matches: sqlStartsWith("select key from package_index"),
createHandlers: (state) => ({
iterate: () => iterateKeys(view(state))
})
},
{
matches: sqlStartsWith("insert or replace into package_index"),
createHandlers: (state) => ({
run: (key, data) => {
const bytes = copyBytes(data);
mutate(state, (map) => {
map.set(String(key), bytes);
});
return done(1);
}
})
},
{
matches: sqlStartsWith("delete from package_index where key"),
createHandlers: (state) => ({
run: (key) => {
let changes = 0;
mutate(state, (map) => {
changes = map.delete(String(key)) ? 1 : 0;
});
return done(changes);
}
})
}
];
function prepareFallbackStatement(state, sql) {
const normalized = normalizeSql(sql);
const definition = FALLBACK_STATEMENTS.find(({ matches }) => matches(normalized));
if (definition == null) {
throw new Error(`The store index fallback cannot run this SQL: ${sql}`);
}
return statement(definition.createHandlers(state));
}
function sqlStartsWith(prefix) {
return (normalizedSql) => normalizedSql.startsWith(prefix);
}
function sqlEquals(expected) {
return (normalizedSql) => normalizedSql === expected;
}
function runAndReportNoChanges(action) {
action();
return done(0);
}
function begin(state) {
if (state.tx != null) {
throw new Error("Cannot begin a store index fallback transaction while one is open");
}
reloadIfStale(state);
state.tx = new Map(state.rows);
}
function commit(state) {
if (state.tx == null) {
throw new Error("Cannot commit a store index fallback transaction when none is open");
}
const committed = state.tx;
const previous = state.rows;
state.tx = null;
state.rows = committed;
try {
writeThrough(state);
} catch (err) {
state.rows = previous;
state.revision = -1;
reloadIfStale(state);
throw err;
}
}
function rollback(state) {
state.tx = null;
}
function view(state) {
if (state.tx != null)
return state.tx;
reloadIfStale(state);
return state.rows;
}
function mutate(state, apply) {
if (state.tx != null) {
apply(state.tx);
return;
}
reloadIfStale(state);
const previous = state.rows;
const nextRows = new Map(state.rows);
apply(nextRows);
state.rows = nextRows;
try {
writeThrough(state);
} catch (err) {
state.rows = previous;
throw err;
}
}
function reloadIfStale(state) {
if (state.tx != null)
return;
const snapshot = readSnapshot(state);
if (snapshot.generation === state.revision)
return;
state.rows = snapshot.rows;
state.revision = snapshot.generation;
}
function readSnapshot(state) {
for (let attempt = 0; attempt < 20; attempt++) {
const snapshot = tryReadSnapshot(state);
if (snapshot != null)
return snapshot;
sleepSync2(1);
}
throw new PnpmError("STORE_INDEX_FALLBACK_CORRUPT", `Could not read the store index fallback file at ${state.dataPath}`);
}
function tryReadSnapshot(state) {
const generation = readGeneration(state.dataPath);
if (generation === void 0)
return void 0;
if (generation === state.revision) {
return { generation, rows: state.rows };
}
if (generation === 0) {
return { generation: 0, rows: /* @__PURE__ */ new Map() };
}
const packed = readFallbackFile(state.dataPath);
if (packed == null) {
return { generation: 0, rows: /* @__PURE__ */ new Map() };
}
if (packed.length < 4 || packed.readUInt32BE(0) !== generation)
return void 0;
const decodedRows = decodeRows(packed.subarray(4));
if (decodedRows == null)
return void 0;
return { generation, rows: decodedRows };
}
function readFallbackFile(dataPath) {
try {
return fs15.readFileSync(dataPath);
} catch (err) {
if (!isEnoent(err))
throw err;
return void 0;
}
}
function writeThrough(state) {
const next = nextGeneration(state.revision);
const body = fallbackPackr.pack([...state.rows.entries()]);
const payload = new Uint8Array(4 + body.length);
new DataView(payload.buffer, payload.byteOffset, payload.byteLength).setUint32(0, next);
payload.set(body, 4);
const tmp = `${state.dataPath}.${process.pid}.${threadId2}.tmp`;
try {
fs15.writeFileSync(tmp, payload);
renameFileWithRetry(tmp, state.dataPath);
} catch (err) {
try {
fs15.rmSync(tmp, { force: true });
} catch {
}
throw err;
}
state.revision = next;
}
function isFallbackDatabase(db) {
return fallbackDatabases.has(db);
}
function isMissingSqliteMethod(err) {
return typeof err === "object" && err != null && "message" in err && typeof err.message === "string" && err.message.includes("is not a function");
}
function closeSqliteQuietly(db) {
try {
db.close?.();
} catch {
}
}
function statement(handlers) {
return {
get: handlers.get ?? (() => void 0),
run: handlers.run ?? (() => done(0)),
iterate: handlers.iterate ?? function* () {
}
};
}
function done(changes) {
return { changes, lastInsertRowid: 0 };
}
function normalizeSql(sql) {
return sql.replace(/\s+/g, " ").trim().toLowerCase();
}
function copyBytes(data) {
if (data instanceof Uint8Array)
return new Uint8Array(data);
throw new Error("Store index fallback expected a byte buffer");
}
function* iterateEntries(map) {
for (const [key, data] of [...map.entries()]) {
yield { key, data };
}
}
function* iterateKeys(map) {
for (const key of [...map.keys()]) {
yield { key };
}
}
function decodeRows(body) {
let decoded;
try {
decoded = fallbackPackr.unpack(body);
} catch {
return void 0;
}
if (!Array.isArray(decoded))
return void 0;
const rows = /* @__PURE__ */ new Map();
for (const entry of decoded) {
if (!Array.isArray(entry) || typeof entry[0] !== "string" || !(entry[1] instanceof Uint8Array)) {
return void 0;
}
rows.set(entry[0], entry[1]);
}
return rows;
}
function nextGeneration(current) {
let next;
do {
next = randomInt(1, 2 ** 32);
} while (next === current);
return next;
}
function readGeneration(dataPath) {
let fd;
try {
fd = fs15.openSync(dataPath, "r");
} catch (err) {
if (isEnoent(err))
return 0;
throw err;
}
try {
const buf = Buffer.alloc(4);
const n = fs15.readSync(fd, buf, 0, 4, 0);
if (n < 4)
return void 0;
return buf.readUInt32BE(0) || void 0;
} finally {
fs15.closeSync(fd);
}
}
function isEnoent(err) {
return typeof err === "object" && err != null && "code" in err && err.code === "ENOENT";
}
function sleepSync2(ms) {
Atomics.wait(sleepBuffer, 0, 0, ms);
}
// ../store/index/lib/rootMtime.js
import fs16 from "node:fs";
import path16 from "node:path";
var roots = /* @__PURE__ */ new Map();
function acquireRootMtime(storeDir) {
const root = realpathOrResolve(storeDir);
let state = roots.get(root);
if (state == null) {
state = { connections: 0, snapshot: takeSnapshot(root) };
roots.set(root, state);
}
state.connections++;
return root;
}
function releaseRootMtime(root) {
const state = roots.get(root);
if (state == null)
return;
state.connections--;
if (state.connections > 0)
return;
roots.delete(root);
if (state.snapshot == null)
return;
const current = takeSnapshot(root);
if (current == null || current.entries !== state.snapshot.entries || current.mtimeMs === state.snapshot.mtimeMs)
return;
try {
fs16.utimesSync(root, fs16.statSync(root).atime, state.snapshot.mtimeMs / 1e3);
} catch {
}
}
function realpathOrResolve(storeDir) {
try {
return fs16.realpathSync(storeDir);
} catch {
return path16.resolve(storeDir);
}
}
function takeSnapshot(storeDir) {
try {
return {
mtimeMs: fs16.statSync(storeDir).mtimeMs,
entries: fs16.readdirSync(storeDir).sort().join("\0")
};
} catch {
return void 0;
}
}
// ../store/index/lib/index.js
var FROZEN_STORE_WRITE_MESSAGE = "Cannot write to the package store because frozenStore is enabled (the store is opened read-only). This indicates the store is missing content the install needs.";
var req = createRequire2(import.meta.url);
var { DatabaseSync } = req("node:sqlite");
var packr = new Packr({
useRecords: true,
moreTypes: true
});
var SQLITE_BUSY = 5;
var RETRY_DELAY_MS = 50;
var MAX_RETRIES = 100;
function sqliteRetry(fn) {
for (let attempt = 0; ; attempt++) {
try {
return fn();
} catch (err) {
if (isSqliteBusy(err) && attempt < MAX_RETRIES) {
sleepSync3(RETRY_DELAY_MS);
continue;
}
throw err;
}
}
}
function isSqliteBusy(err) {
const errcode = err?.errcode;
return typeof errcode === "number" && (errcode & 255) === SQLITE_BUSY;
}
var sleepBuffer2 = new Int32Array(new SharedArrayBuffer(4));
function sleepSync3(ms) {
Atomics.wait(sleepBuffer2, 0, 0, ms);
}
function packForStorage(data) {
return packr.pack(data);
}
function storeIndexKey(integrity, pkgId) {
return `${integrity} ${pkgId}`;
}
var openInstances = /* @__PURE__ */ new Set();
var StoreIndex = class {
db;
closed = false;
pendingWrites = [];
flushScheduled = false;
stmtGet;
stmtSet;
stmtDel;
stmtHas;
stmtAll;
stmtKeys;
exitHandler;
mtimeRoot;
constructor(storeDir) {
if (this.createsSidecars)
this.mtimeRoot = acquireRootMtime(storeDir);
try {
this.openDatabase(storeDir);
this.prepareStatements();
} catch (err) {
if (this.db != null)
closeSqliteQuietly(this.db);
if (this.mtimeRoot != null)
releaseRootMtime(this.mtimeRoot);
throw err;
}
this.exitHandler = () => this.close();
const currentMax = process.getMaxListeners();
if (currentMax !== 0 && currentMax < openInstances.size + 11) {
process.setMaxListeners(Math.max(currentMax + 10, openInstances.size + 11));
}
process.on("exit", this.exitHandler);
openInstances.add(this);
}
/** Whether the connection creates WAL sidecars. Overridden by {@link ImmutableStoreIndex}. */
get createsSidecars() {
return true;
}
/** Open the SQLite connection. Overridden by {@link ReadOnlyStoreIndex}. */
openDatabase(storeDir) {
mkdirInheritingMode(storeDir);
if (process.platform !== "win32")
createIndexWithInheritedMode(storeDir);
this.db = adaptStoreDatabase(this.openConnection(storeDir), storeDir);
try {
this.configureDatabase();
} catch (err) {
if (isFallbackDatabase(this.db) || !isMissingSqliteMethod(err))
throw err;
closeSqliteQuietly(this.db);
this.db = createFallbackDatabase(storeDir);
this.configureDatabase();
}
}
/** Open the host SQLite connection before missing methods are adapted. */
openConnection(storeDir) {
return new DatabaseSync(`${storeDir}/index.db`);
}
configureDatabase() {
this.db.exec("PRAGMA busy_timeout=5000");
sqliteRetry(() => {
this.db.exec("PRAGMA journal_mode=WAL");
this.db.exec("PRAGMA synchronous=NORMAL");
this.db.exec("PRAGMA mmap_size=536870912");
this.db.exec("PRAGMA cache_size=-32000");
this.db.exec("PRAGMA temp_store=MEMORY");
this.db.exec("PRAGMA wal_autocheckpoint=10000");
this.db.exec(`
CREATE TABLE IF NOT EXISTS package_index (
key TEXT PRIMARY KEY,
data BLOB NOT NULL
) WITHOUT ROWID
`);
});
}
/** Prepare the prepared statements. Overridden by {@link ReadOnlyStoreIndex} to skip the write statements. */
prepareStatements() {
this.stmtGet = this.db.prepare("SELECT data FROM package_index WHERE key = ?");
this.stmtSet = this.db.prepare("INSERT OR REPLACE INTO package_index (key, data) VALUES (?, ?)");
this.stmtDel = this.db.prepare("DELETE FROM package_index WHERE key = ?");
this.stmtHas = this.db.prepare("SELECT 1 FROM package_index WHERE key = ?");
this.stmtAll = this.db.prepare("SELECT key, data FROM package_index");
this.stmtKeys = this.db.prepare("SELECT key FROM package_index");
}
get(key) {
const row = sqliteRetry(() => this.stmtGet.get(key));
if (row) {
return packr.unpack(row.data);
}
return void 0;
}
/**
* Get the raw msgpack-encoded buffer for a key without decoding.
*/
getRaw(key) {
const row = sqliteRetry(() => this.stmtGet.get(key));
return row?.data;
}
set(key, data) {
const buffer = packr.pack(data);
sqliteRetry(() => {
this.stmtSet.run(key, buffer);
});
}
update(key, updateValue) {
this.flush();
return sqliteRetry(() => {
this.db.exec("BEGIN IMMEDIATE");
try {
const row = this.stmtGet.get(key);
if (row == null) {
this.db.exec("COMMIT");
return false;
}
this.stmtSet.run(key, packr.pack(updateValue(packr.unpack(row.data))));
this.db.exec("COMMIT");
return true;
} catch (updateError) {
try {
this.db.exec("ROLLBACK");
} catch (rollbackError) {
throw new AggregateError([updateError, rollbackError], `Failed to roll back store index update for ${key}`, { cause: rollbackError });
}
throw updateError;
}
});
}
delete(key) {
let result;
sqliteRetry(() => {
result = this.stmtDel.run(key);
});
return result.changes > 0;
}
has(key) {
return sqliteRetry(() => this.stmtHas.get(key)) != null;
}
/**
* Iterate over all index entries.
* Yields [key, data] pairs where key is `integrity\tpkgId`.
*/
*entries() {
for (const row of this.stmtAll.iterate()) {
yield [row.key, packr.unpack(row.data)];
}
}
/**
* Iterate over all index keys without decoding values.
* Much faster than entries() when only keys are needed.
*/
*keys() {
for (const row of this.stmtKeys.iterate()) {
yield row.key;
}
}
/**
* Queue pre-packed writes to be flushed on the next tick.
* Used by the fetch phase for throughput.
*/
queueWrites(writes) {
for (const write of writes) {
this.pendingWrites.push(write);
}
if (!this.flushScheduled) {
this.flushScheduled = true;
process.nextTick(() => this.flush());
}
}
/**
* Flush all pending queued writes immediately.
*/
flush() {
this.flushScheduled = false;
if (this.pendingWrites.length === 0)
return;
this.setRawMany(this.pendingWrites);
this.pendingWrites = [];
}
inTransaction(action) {
sqliteRetry(() => {
this.db.exec("BEGIN IMMEDIATE");
let committed = false;
try {
action();
this.db.exec("COMMIT");
committed = true;
} finally {
this.rollbackIfUncommitted(committed);
}
});
}
rollbackIfUncommitted(committed) {
if (committed)
return;
try {
this.db.exec("ROLLBACK");
} catch {
}
}
/**
* Write multiple pre-packed entries in a single transaction.
* The buffers must already be msgpack-encoded.
*/
setRawMany(entries) {
if (this.closed || entries.length === 0)
return;
if (entries.length === 1) {
sqliteRetry(() => {
this.stmtSet.run(entries[0].key, entries[0].buffer);
});
return;
}
this.inTransaction(() => {
for (const { key, buffer } of entries) {
this.stmtSet.run(key, buffer);
}
});
}
/**
* Delete multiple index entries in a single transaction,
* then VACUUM to reclaim disk space.
*/
deleteMany(keys) {
if (keys.length === 0)
return;
if (keys.length === 1) {
this.delete(keys[0]);
this.db.exec("VACUUM");
return;
}
this.inTransaction(() => {
for (const key of keys) {
this.stmtDel.run(key);
}
});
this.db.exec("VACUUM");
}
checkpoint() {
this.flush();
sqliteRetry(() => {
this.db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
});
}
close() {
if (this.closed)
return;
this.flush();
this.closed = true;
openInstances.delete(this);
process.removeListener("exit", this.exitHandler);
this.optimizeBeforeClose();
try {
this.db.close();
} catch {
}
if (this.mtimeRoot != null)
releaseRootMtime(this.mtimeRoot);
}
/** Run `PRAGMA optimize` before closing. Overridden by {@link ReadOnlyStoreIndex} to skip database writes. */
optimizeBeforeClose() {
try {
this.db.exec("PRAGMA optimize");
} catch {
}
}
};
var ReadOnlyStoreIndex = class extends StoreIndex {
openDatabase(storeDir) {
this.db = this.openConnection(storeDir);
this.db.prepare("PRAGMA busy_timeout=5000").run();
}
openConnection(storeDir) {
return new DatabaseSync(`${storeDir}/index.db`, { readOnly: true });
}
prepareStatements() {
this.stmtGet = this.db.prepare("SELECT data FROM package_index WHERE key = ?");
this.stmtHas = this.db.prepare("SELECT 1 FROM package_index WHERE key = ?");
this.stmtAll = this.db.prepare("SELECT key, data FROM package_index");
this.stmtKeys = this.db.prepare("SELECT key FROM package_index");
}
optimizeBeforeClose() {
}
set(_key, _data) {
this.throwReadOnly();
}
delete(_key) {
this.throwReadOnly();
}
update(_key, _updateValue) {
this.throwReadOnly();
}
queueWrites(_writes) {
this.throwReadOnly();
}
setRawMany(_entries) {
this.throwReadOnly();
}
deleteMany(_keys) {
this.throwReadOnly();
}
checkpoint() {
this.throwReadOnly();
}
throwReadOnly() {
throw new PnpmError("STORE_READ_ONLY", "Cannot write to the package store because its index is opened read-only.");
}
};
var ImmutableStoreIndex = class extends ReadOnlyStoreIndex {
get createsSidecars() {
return false;
}
openDatabase(storeDir) {
if (!nodeSupportsImmutableSqliteUri()) {
throw new PnpmError("FROZEN_STORE_UNSUPPORTED_NODE", `frozenStore opens the store index read-only via a SQLite "immutable" URI, which requires Node.js >=22.15.0, >=23.11.0, or >=24.0.0, but the current version is ${process.versions.node}. Upgrade Node.js, or run without frozenStore.`);
}
this.db = new DatabaseSync(immutableSqliteUri(`${storeDir}/index.db`));
}
throwReadOnly() {
throw new PnpmError("FROZEN_STORE_WRITE", FROZEN_STORE_WRITE_MESSAGE);
}
};
function immutableSqliteUri(dbPath) {
const url = pathToFileURL(dbPath);
url.searchParams.set("immutable", "1");
return url.href;
}
function nodeSupportsImmutableSqliteUri() {
const [major, minor] = process.versions.node.split(".", 2).map(Number);
if (major < 22)
return false;
if (major === 22)
return minor >= 15;
if (major === 23)
return minor >= 11;
return true;
}
function createIndexWithInheritedMode(storeDir) {
const dbPath = path17.join(storeDir, "index.db");
const creation = unixCreationMode(readDirMode(storeDir), void 0);
let fd;
try {
fd = fs17.openSync(dbPath, "wx", creation.openMode);
} catch (err) {
if (isError(err) && "code" in err && err.code === "EEXIST")
return;
throw new PnpmError("STORE_DIR_STORE_INDEX_CREATE_FILE", `Failed to create index.db at ${dbPath}: ${isError(err) ? err.message : String(err)}`, { cause: err });
}
try {
if (creation.grantMode != null)
grantModeBits(fd, creation.grantMode);
} catch (err) {
fs17.closeSync(fd);
fs17.rmSync(dbPath, { force: true });
throw err;
}
fs17.closeSync(fd);
}
// ../worker/lib/hashBuffer.js
import crypto6 from "node:crypto";
function hashBuffer(algorithm, buffer) {
return crypto6.createHash(algorithm).update(buffer).digest("hex");
}
// ../store/create-cafs-store/lib/index.js
import { promises as fs27 } from "node:fs";
import path29 from "node:path";
// ../fs/indexed-pkg-importer/lib/index.js
import assert2 from "node:assert";
import { chmodSync, constants, existsSync } from "node:fs";
import path28 from "node:path";
// ../fs/indexed-pkg-importer/lib/fileMode.js
import path18 from "node:path";
var BASE_FILE_MODE = 438;
var EXEC_FILE_MODE = 493;
var CAFS_EXEC_SUFFIX = "-exec";
var CAFS_DIGEST_MIN_LENGTH = 40;
var umask;
function storeEntryModeForSource(src2) {
if (process.platform === "win32" || !isCafsFile(src2))
return void 0;
umask ??= process.umask();
return (src2.endsWith(CAFS_EXEC_SUFFIX) ? EXEC_FILE_MODE : BASE_FILE_MODE) & ~umask & 511;
}
function fileModeForImport(sourceMode, storeMode) {
if (process.platform === "win32")
return void 0;
return storeMode ?? Number(sourceMode & 511n);
}
function isLinkableStoreMode(mode, storeMode) {
const groupOtherWrite = 18;
return ((mode ^ storeMode) & 511 & ~groupOtherWrite) === 0 && (mode & ~storeMode & 2) === 0;
}
function isCafsFile(src2) {
const nameSep = src2.lastIndexOf(path18.sep);
if (nameSep < 0)
return false;
const shardSep = src2.lastIndexOf(path18.sep, nameSep - 1);
if (shardSep < 0 || nameSep - shardSep - 1 !== 2 || !isLowerHex(src2, shardSep + 1, nameSep))
return false;
const filesSep = src2.lastIndexOf(path18.sep, shardSep - 1);
if (filesSep < 0 || shardSep - filesSep - 1 !== "files".length || !src2.startsWith("files", filesSep + 1))
return false;
const digestEnd = src2.endsWith(CAFS_EXEC_SUFFIX) ? src2.length - CAFS_EXEC_SUFFIX.length : src2.length;
return digestEnd - nameSep - 1 >= CAFS_DIGEST_MIN_LENGTH && isLowerHex(src2, nameSep + 1, digestEnd);
}
function isLowerHex(value, from, to) {
for (let index = from; index < to; index++) {
const code = value.charCodeAt(index);
if (!(code >= 48 && code <= 57 || code >= 97 && code <= 102))
return false;
}
return true;
}
// ../fs/indexed-pkg-importer/lib/hardlinkedDirMatches.js
import fs18, {} from "node:fs";
import path19 from "node:path";
function hardlinkedDirMatches(dir, files, keepModulesDir) {
if (files.size === 0)
return false;
const directories = expectedDirectories(files);
if (!directories)
return false;
try {
const rootStat = fs18.lstatSync(dir);
if (!rootStat.isDirectory() || rootStat.isSymbolicLink())
return false;
return treeMatches(dir, { files, directories, keepModulesDir });
} catch {
return false;
}
}
function expectedDirectories(files) {
const directories = /* @__PURE__ */ new Set();
for (const relative of files.keys()) {
if (!isReusableFilePath(relative))
return void 0;
for (let parent = path19.posix.dirname(relative); parent !== "."; parent = path19.posix.dirname(parent))
directories.add(parent);
}
return directories;
}
function isReusableFilePath(relative) {
if (relative === "node_modules" || relative.startsWith("node_modules/"))
return false;
if (path19.isAbsolute(relative) || relative.includes("\\"))
return false;
return relative.split("/").every((part) => part !== "" && part !== "." && part !== "..");
}
function treeMatches(root, expected) {
const pending = [""];
let matched = 0;
for (let relative = pending.pop(); relative !== void 0; relative = pending.pop()) {
const count = matchingFilesInDirectory(root, relative, { expected, pending });
if (count === void 0)
return false;
matched += count;
}
return matched === expected.files.size;
}
function matchingFilesInDirectory(root, relative, { expected, pending }) {
let matched = 0;
for (const entry of fs18.readdirSync(path19.join(root, relative), { withFileTypes: true })) {
const entryPath = relative ? `${relative}/${entry.name}` : entry.name;
const kind = matchingEntryKind(path19.join(root, entryPath), entryPath, expected);
if (!kind)
return void 0;
if (kind === "directory")
pending.push(entryPath);
if (kind === "file")
matched++;
}
return matched;
}
function matchingEntryKind(targetPath, relative, expected) {
const target2 = fs18.lstatSync(targetPath, { bigint: true });
if (target2.isSymbolicLink())
return void 0;
if (target2.isDirectory()) {
if (expected.keepModulesDir && relative === "node_modules")
return "preserved";
return expected.directories.has(relative) ? "directory" : void 0;
}
const source = expected.files.get(relative);
return source && filesHaveSameIdentity(target2, fs18.lstatSync(source, { bigint: true })) ? "file" : void 0;
}
function filesHaveSameIdentity(target2, source) {
return target2.isFile() && source.isFile() && target2.ino !== 0n && target2.dev !== 0n && target2.ino === source.ino && target2.dev === source.dev;
}
// ../fs/indexed-pkg-importer/lib/importIndexedDir.js
import fs26 from "node:fs";
import path26 from "node:path";
// ../text/sanitize/lib/index.js
var CONTROL_AND_FORMAT_CHARACTERS = /[\u0000-\u001F\u007F-\u009F\u00AD\u0600-\u0605\u061C\u06DD\u070F\u0890\u0891\u08E2\u180E\u200B-\u200F\u2028\u2029\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF\uFFF9-\uFFFB\u{110BD}\u{110CD}\u{13430}-\u{1343F}\u{1BCA0}-\u{1BCA3}\u{1D173}-\u{1D17A}\u{E0001}\u{E0020}-\u{E007F}]/gu;
function sanitizeInline(text) {
return text.replace(CONTROL_AND_FORMAT_CHARACTERS, "");
}
// ../../../../../setup-pnpm/store/v11/links/@/make-empty-dir/4.0.0/3607722a2f7d328bdf182e4db3290941113e732fd2d785b1a5837ab89bb24489/node_modules/make-empty-dir/index.js
import fs19 from "node:fs";
import path20 from "node:path";
function makeEmptyDirSync(dir, opts2) {
if (opts2 && opts2.recursive) {
fs19.mkdirSync(path20.dirname(dir), { recursive: true });
}
try {
fs19.mkdirSync(dir);
return "created";
} catch (err) {
if (err.code === "EEXIST") {
removeContentsOfDirSync(dir);
return "emptied";
}
throw err;
}
}
function removeContentsOfDirSync(dir) {
const items = fs19.readdirSync(dir);
for (const item of items) {
rimrafSync(path20.join(dir, item));
}
}
// ../fs/indexed-pkg-importer/lib/copyInternalSymlink.js
import fs20 from "node:fs";
import path21 from "node:path";
function internalSymlinkTarget(src2) {
const target2 = fs20.readlinkSync(src2);
return path21.isAbsolute(target2) ? path21.relative(realpathOrSelf(path21.dirname(src2)), realpathOrSelf(target2)) : target2;
}
function copyInternalSymlink(src2, dest, links) {
const target2 = internalSymlinkTarget(src2);
const resolved = path21.resolve(path21.dirname(dest), target2);
if (escapesDir(links.writtenDir, resolved))
return false;
if (!links.imported.has(path21.relative(links.writtenDir, resolved).split(path21.sep).join("/"))) {
return isDirectory(src2);
}
if (process.platform !== "win32") {
fs20.symlinkSync(target2, dest);
return true;
}
return copyInternalSymlinkWindows({ dest, links, resolved, src: src2, target: target2 });
}
function copyInternalSymlinkWindows(opts2) {
const { dest, links, resolved, src: src2, target: target2 } = opts2;
const isDir = isDirectory(src2);
try {
fs20.symlinkSync(target2, dest, isDir ? "dir" : "file");
return true;
} catch (err) {
if (!isError(err) || !("code" in err) || err.code !== "EPERM")
throw err;
if (!isDir)
return false;
fs20.symlinkSync(path21.join(links.finalDir, path21.relative(links.writtenDir, resolved)), dest, "junction");
return true;
}
}
function realpathOrSelf(file) {
try {
return fs20.realpathSync(file);
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOENT")
return file;
throw err;
}
}
function isDirectory(file) {
try {
return fs20.statSync(file).isDirectory();
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOENT")
return false;
throw err;
}
}
function escapesDir(rootDir, targetPath) {
const rel = path21.relative(rootDir, targetPath);
return rel === ".." || rel.startsWith(`..${path21.sep}`) || path21.isAbsolute(rel);
}
// ../fs/indexed-pkg-importer/lib/dirUtils.js
import fs21 from "node:fs";
import path22 from "node:path";
function clearDirentBlockingDir(newDir, relativeDir) {
let dir = newDir;
for (const segment of relativeDir.split(/[\\/]/)) {
dir = path22.join(dir, segment);
if (!clearDirentSegment(dir))
return;
}
}
function clearDirentSegment(dir) {
let stats;
try {
stats = lstatWithRetry(dir);
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOENT")
return false;
throw err;
}
if (stats.isDirectory())
return true;
try {
unlinkWithRetry(dir);
} catch (err) {
if (!dirFitsAt(dir))
throw err;
}
return false;
}
function dirFitsAt(dir) {
try {
return lstatWithRetry(dir).isDirectory();
} catch (err) {
return isError(err) && "code" in err && err.code === "ENOENT";
}
}
function clearDirBlockingFile(dest) {
let stats;
try {
stats = lstatWithRetry(dest);
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOENT")
return;
throw err;
}
if (stats.isDirectory()) {
rimrafSync(dest);
}
}
function makeFileMapDirs(newDir, filenames, opts2) {
const allDirs = /* @__PURE__ */ new Set();
for (const relativePath of filenames.keys()) {
const dir = path22.dirname(relativePath);
if (dir === ".")
continue;
allDirs.add(dir);
}
for (const dir of Array.from(allDirs).sort((d1, d2) => d1.length - d2.length)) {
if (opts2?.clearBlockers) {
clearDirentBlockingDir(newDir, dir);
}
fs21.mkdirSync(path22.join(newDir, dir), { recursive: true });
}
}
// ../fs/indexed-pkg-importer/lib/fileMapUtils.js
import fs22 from "node:fs";
import path23 from "node:path";
var import_fs_extra2 = __toESM(require_lib5(), 1);
var import_sanitize_filename = __toESM(require_sanitize_filename(), 1);
function getUniqueFileMap(fileMap) {
const lowercaseFiles = /* @__PURE__ */ new Map();
const conflictingFileNames = /* @__PURE__ */ new Map();
const uniqueFileMap = /* @__PURE__ */ new Map();
for (const filename of Array.from(fileMap.keys()).sort()) {
const lowercaseFilename = filename.toLowerCase();
if (lowercaseFiles.has(lowercaseFilename)) {
conflictingFileNames.set(filename, lowercaseFiles.get(lowercaseFilename));
continue;
}
lowercaseFiles.set(lowercaseFilename, filename);
uniqueFileMap.set(filename, fileMap.get(filename));
}
return {
conflictingFileNames,
uniqueFileMap
};
}
function sanitizeFilenames(filenames) {
const sanitizedFilenames = /* @__PURE__ */ new Map();
const invalidFilenames = [];
for (const [filename, src2] of filenames) {
const sanitizedFilename = filename.split("/").map((f) => (0, import_sanitize_filename.default)(f)).join("/");
if (sanitizedFilename !== filename) {
invalidFilenames.push(filename);
}
sanitizedFilenames.set(sanitizedFilename, src2);
}
return { sanitizedFilenames, invalidFilenames };
}
function moveOrMergeModulesDirs(src2, dest) {
try {
renameEvenAcrossDevices(src2, dest);
} catch (err) {
switch (isError(err) && "code" in err && err.code) {
case "ENOENT":
return;
case "ENOTEMPTY":
case "EPERM":
mergeModulesDirs(src2, dest);
return;
default:
throw err;
}
}
}
function renameEvenAcrossDevices(src2, dest) {
try {
lib_default.renameSync(src2, dest);
} catch (err) {
if (!(isError(err) && "code" in err && err.code === "EXDEV"))
throw err;
import_fs_extra2.default.copySync(src2, dest);
}
}
function mergeModulesDirs(src2, dest) {
const srcFiles = fs22.readdirSync(src2);
const destFiles = new Set(fs22.readdirSync(dest));
const filesToMove = srcFiles.filter((file) => !destFiles.has(file));
for (const file of filesToMove) {
renameEvenAcrossDevices(path23.join(src2, file), path23.join(dest, file));
}
}
// ../fs/indexed-pkg-importer/lib/overwriteDir.js
import fs23 from "node:fs";
import path24 from "node:path";
function overwriteDirSync(stage, newDir) {
try {
fs23.renameSync(stage, newDir);
} catch (err) {
if (!isError(err) || !("code" in err))
throw err;
switch (err.code) {
case "ENOENT":
fs23.statSync(stage);
fs23.mkdirSync(path24.dirname(newDir), { recursive: true });
overwriteDirSync(stage, newDir);
return;
case "EXDEV":
copyStageAcrossDevicesSync(stage, newDir);
return;
case "ENOTEMPTY":
case "EEXIST":
case "ENOTDIR":
case "EPERM":
case "EACCES":
case "EBUSY":
swapDirSync(stage, newDir);
return;
default:
throw err;
}
}
}
function copyStageAcrossDevicesSync(stage, newDir) {
fs23.mkdirSync(path24.dirname(newDir), { recursive: true });
const localStage = `${fastPathTemp(newDir)}_stage_${swapCounter++}`;
try {
fs23.cpSync(stage, localStage, { recursive: true, verbatimSymlinks: true });
swapDirSync(localStage, newDir);
} finally {
removeQuietly(localStage);
}
removeQuietly(stage);
}
function swapDirSync(stage, newDir) {
const aside = moveExistingTargetAside(newDir);
try {
fs23.renameSync(stage, newDir);
} catch (err) {
if (aside != null) {
restoreOrRemoveAside(aside, newDir);
}
throw err;
}
if (aside != null) {
removeQuietly(aside);
}
}
var swapCounter = 0;
function moveExistingTargetAside(newDir) {
const aside = `${fastPathTemp(newDir)}_swap_${swapCounter++}`;
try {
fs23.renameSync(newDir, aside);
return aside;
} catch (err) {
return backupAndRemoveTargetAfterFailedDisplace(newDir, aside, err);
}
}
function backupAndRemoveTargetAfterFailedDisplace(newDir, aside, err) {
if (!isError(err) || !("code" in err))
throw err;
switch (err.code) {
case "ENOENT":
return void 0;
// Windows refuses to rename a directory a process runs from; copy a
// backup to `aside` before removing `newDir` in place so a failed
// stage rename can still restore the previous package.
case "EPERM":
case "EACCES":
case "EBUSY":
try {
fs23.cpSync(newDir, aside, { recursive: true, verbatimSymlinks: true });
rimrafSync(newDir);
return aside;
} catch (fallbackErr) {
removeQuietly(aside);
throw fallbackErr;
}
default:
throw err;
}
}
function restoreOrRemoveAside(aside, newDir) {
try {
if (!fs23.existsSync(newDir)) {
fs23.renameSync(aside, newDir);
return;
}
} catch {
}
if (fs23.existsSync(newDir)) {
removeQuietly(aside);
}
}
function removeQuietly(target2) {
try {
rimrafSync(target2);
} catch {
}
}
// ../fs/indexed-pkg-importer/lib/repairIndexedDir.js
import fs25 from "node:fs";
import path25 from "node:path";
// ../fs/indexed-pkg-importer/lib/filesHaveEqualContents.js
import fs24 from "node:fs";
var FILE_COMPARE_BUFFER_SIZE = 64 * 1024;
function filesHaveEqualContents(left, right) {
const leftBuffer = Buffer.allocUnsafe(FILE_COMPARE_BUFFER_SIZE);
const rightBuffer = Buffer.allocUnsafe(FILE_COMPARE_BUFFER_SIZE);
const leftFd = fs24.openSync(left, "r");
try {
const rightFd = fs24.openSync(right, "r");
try {
return compareOpenFiles(leftFd, rightFd, leftBuffer, rightBuffer);
} finally {
fs24.closeSync(rightFd);
}
} finally {
fs24.closeSync(leftFd);
}
}
function compareOpenFiles(leftFd, rightFd, leftBuffer, rightBuffer) {
for (; ; ) {
const leftBytes = fs24.readSync(leftFd, leftBuffer, 0, leftBuffer.length, null);
const rightBytes = fs24.readSync(rightFd, rightBuffer, 0, rightBuffer.length, null);
if (leftBytes !== rightBytes)
return false;
if (leftBytes === 0)
return true;
if (!leftBuffer.subarray(0, leftBytes).equals(rightBuffer.subarray(0, rightBytes)))
return false;
}
}
// ../fs/indexed-pkg-importer/lib/repairIndexedDir.js
function repairIndexedDir({ importer, newDir, filenames, opts: opts2 }) {
makeFileMapDirs(newDir, filenames, { clearBlockers: true });
let packageJsonSrc;
for (const [relativePath, src2] of filenames) {
if (relativePath === "package.json") {
packageJsonSrc = src2;
continue;
}
replaceFileIfDifferent(importer.importFile, src2, path25.join(newDir, relativePath));
}
for (const [relativePath, target2] of opts2.symlinks ?? []) {
const dir = path25.posix.dirname(relativePath);
if (dir !== ".")
clearDirentBlockingDir(newDir, dir);
replaceSymlinkIfDifferent(target2, path25.join(newDir, relativePath));
}
if (packageJsonSrc !== void 0) {
replaceFileIfDifferent(importer.importFile, packageJsonSrc, path25.join(newDir, "package.json"));
}
}
function replaceFileIfDifferent(importFile, src2, dest) {
if (mismatchReason(dest, src2) === void 0)
return;
const tmp = fastPathTemp(dest);
try {
importFile(src2, tmp);
} catch (err) {
try {
fs25.unlinkSync(tmp);
} catch {
}
throw err;
}
try {
clearDirBlockingFile(dest);
renameFileWithRetry(tmp, dest);
} catch (err) {
try {
fs25.unlinkSync(tmp);
} catch {
}
if (mismatchReason(dest, src2) === void 0)
return;
throw err;
}
}
function replaceSymlinkIfDifferent(target2, dest) {
if (symlinkMatches(dest, target2))
return;
fs25.mkdirSync(path25.dirname(dest), { recursive: true });
const tmp = fastPathTemp(dest);
fs25.symlinkSync(target2, tmp);
try {
clearDirBlockingFile(dest);
renameFileWithRetry(tmp, dest);
} catch (err) {
try {
fs25.unlinkSync(tmp);
} catch {
}
if (symlinkMatches(dest, target2))
return;
throw err;
}
}
function allFilesMatch(dir, filenames) {
const markerSrc = filenames.get("package.json");
if (markerSrc !== void 0 && !fileMatches(dir, "package.json", markerSrc))
return false;
for (const [relativePath, src2] of filenames) {
if (relativePath === "package.json")
continue;
if (!fileMatches(dir, relativePath, src2))
return false;
}
return true;
}
function allSymlinksMatch(dir, symlinks) {
for (const [relativePath, target2] of symlinks ?? []) {
if (!symlinkMatches(path25.join(dir, relativePath), target2)) {
globalInfo(`Re-importing "${dir}" because symlink "${relativePath}" does not point to "${target2}"`);
return false;
}
}
return true;
}
function allImportedEntriesMatchExactly({ dir, filenames, symlinks, keepModulesDir }) {
if (!allFilesMatch(dir, filenames) || !allSymlinksMatch(dir, symlinks))
return false;
const expectedEntries = collectExpectedEntries(filenames, symlinks, keepModulesDir);
const actualEntries = /* @__PURE__ */ new Set();
try {
collectDirectoryEntries({ root: dir, directory: dir, entries: actualEntries, preserveNodeModules: keepModulesDir });
} catch {
return false;
}
return actualEntries.size === expectedEntries.size && [...expectedEntries].every((entry) => actualEntries.has(entry));
}
function collectExpectedEntries(filenames, symlinks, preserveNodeModules) {
const entries = /* @__PURE__ */ new Set();
for (const entry of [...filenames.keys(), ...symlinks?.keys() ?? []]) {
if (preserveNodeModules && (entry === "node_modules" || entry.startsWith("node_modules/")))
continue;
entries.add(entry);
for (let parent = path25.posix.dirname(entry); parent !== "." && parent !== "/"; parent = path25.posix.dirname(parent)) {
entries.add(parent);
}
}
return entries;
}
function collectDirectoryEntries({ root, directory, entries, preserveNodeModules }) {
for (const dirent of fs25.readdirSync(directory, { withFileTypes: true })) {
const entryPath = path25.join(directory, dirent.name);
if (dirent.isDirectory()) {
if (preserveNodeModules && directory === root && dirent.name === "node_modules")
continue;
entries.add(path25.relative(root, entryPath).split(path25.sep).join("/"));
collectDirectoryEntries({ root, directory: entryPath, entries, preserveNodeModules });
} else {
entries.add(path25.relative(root, entryPath).split(path25.sep).join("/"));
}
}
}
function symlinkMatches(dest, target2) {
try {
return fs25.readlinkSync(dest) === target2;
} catch {
return false;
}
}
function fileMatches(dir, relativePath, src2) {
const reason = mismatchReason(path25.join(dir, relativePath), src2);
if (reason === void 0)
return true;
globalInfo(`Re-importing "${dir}" because file "${relativePath}" ${reason}`);
return false;
}
function mismatchReason(target2, src2) {
try {
const targetStat = fs25.lstatSync(target2, { bigint: true });
if (!targetStat.isFile())
return "is not a regular file";
const srcStat = lib_default.statSync(src2, { bigint: true });
const storeMode = storeEntryModeForSource(src2);
const expectedMode = fileModeForImport(srcStat.mode, storeMode);
const sameIdentity = filesHaveSameIdentity(targetStat, srcStat);
if (expectedMode !== void 0 && (targetStat.mode & 511n) !== BigInt(expectedMode) && (!sameIdentity || storeMode === void 0 || !isLinkableStoreMode(Number(targetStat.mode), expectedMode)))
return "has a different mode";
if (sameIdentity)
return void 0;
if (targetStat.size !== srcStat.size)
return "has a different size";
if (!filesHaveEqualContents(target2, src2))
return "has different content";
return void 0;
} catch {
return "is missing or unreadable";
}
}
// ../fs/indexed-pkg-importer/lib/importIndexedDir.js
var filenameConflictsLogger = logger("_filename-conflicts");
var concurrentImportSettleSleep = new Int32Array(new SharedArrayBuffer(4));
var CONCURRENT_IMPORT_SETTLE_ATTEMPTS = 5;
var CONCURRENT_IMPORT_SETTLE_DELAY_MS = 20;
function importIndexedDir(importer, newDir, filenames, opts2) {
const dirImport = { importer, newDir, filenames, opts: opts2 };
if (opts2.safeToSkip && opts2.resolvedFrom !== "local-dir") {
importIntoSharedDir(dirImport);
return;
}
if (!opts2.keepModulesDir && tryExclusiveImport(importer, newDir, filenames, {
links: symlinkDirs(opts2, filenames, { writtenDir: newDir, finalDir: newDir }),
symlinks: opts2.symlinks
})) {
return;
}
importWithStaging(dirImport);
}
function importWithStaging(dirImport) {
const { importer, newDir, filenames, opts: opts2 } = dirImport;
const stage = fastPathTemp(newDir);
try {
makeEmptyDirSync(stage, { recursive: true });
tryImportIndexedDir({ importFile: importer.importFile, importFileAtomic: importer.importFile }, stage, filenames, {
links: symlinkDirs(opts2, filenames, { writtenDir: stage, finalDir: newDir }),
symlinks: opts2.symlinks
});
if (opts2.keepModulesDir) {
moveOrMergeModulesDirs(path26.join(newDir, "node_modules"), path26.join(stage, "node_modules"));
}
} catch (err) {
cleanStageDir(stage);
if (retryWithFixedFileMap(err, dirImport))
return;
throw err;
}
commitStagedDir(stage, dirImport);
}
function commitStagedDir(stage, { newDir, filenames, opts: opts2 }) {
const keepModulesDir = opts2.keepModulesDir === true;
const entries = { dir: newDir, filenames, symlinks: opts2.symlinks, keepModulesDir };
try {
let attempt = 0;
withFileLockRetry(() => {
if (attempt++ > 0 && allImportedEntriesMatchExactly(entries)) {
acceptExistingImport(stage, newDir, keepModulesDir);
return;
}
overwriteDirSync(stage, newDir);
});
} catch (renameErr) {
if (destinationHoldsThisImport(entries)) {
acceptExistingImport(stage, newDir, keepModulesDir);
return;
}
cleanStageDir(stage);
throw renameErr;
}
}
function acceptExistingImport(stage, newDir, keepModulesDir) {
if (keepModulesDir) {
moveOrMergeModulesDirs(path26.join(stage, "node_modules"), path26.join(newDir, "node_modules"));
}
cleanStageDir(stage);
}
function destinationHoldsThisImport(entries) {
for (let attempt = 1; ; attempt++) {
if (allImportedEntriesMatchExactly(entries))
return true;
if (attempt === CONCURRENT_IMPORT_SETTLE_ATTEMPTS)
return false;
Atomics.wait(concurrentImportSettleSleep, 0, 0, CONCURRENT_IMPORT_SETTLE_DELAY_MS);
}
}
function cleanStageDir(stage) {
try {
rimrafSync(stage);
} catch {
}
}
function tryExclusiveMkdir(newDir) {
fs26.mkdirSync(path26.dirname(newDir), { recursive: true });
try {
fs26.mkdirSync(newDir);
return true;
} catch (err) {
if (isError(err) && "code" in err && err.code === "EEXIST")
return false;
throw err;
}
}
function tryDirectSharedImport(dirImport) {
const { importer, newDir, filenames, opts: opts2 } = dirImport;
if (!tryExclusiveMkdir(newDir))
return false;
try {
tryImportIndexedDir(importer, newDir, filenames, { symlinks: opts2.symlinks });
return true;
} catch (err) {
return retryWithFixedFileMap(err, dirImport);
}
}
function importIntoSharedDir(dirImport) {
if (tryDirectSharedImport(dirImport))
return;
const { newDir, filenames, opts: opts2 } = dirImport;
if (allFilesMatch(newDir, filenames) && allSymlinksMatch(newDir, opts2.symlinks))
return;
try {
repairIndexedDir(dirImport);
} catch (err) {
if (retryWithFixedFileMap(err, dirImport))
return;
throw err;
}
}
function retryWithFixedFileMap(err, dirImport) {
const { importer, newDir, filenames, opts: opts2 } = dirImport;
if (!isError(err) || !("code" in err))
return false;
if (err.code === "EEXIST") {
const { uniqueFileMap, conflictingFileNames } = getUniqueFileMap(filenames);
if (conflictingFileNames.size === 0)
return false;
filenameConflictsLogger.debug({
conflicts: Object.fromEntries(conflictingFileNames),
writingTo: newDir
});
globalWarn(`Not all files were linked to "${path26.relative(process.cwd(), newDir)}". Some of the files have equal names in different case, which is an issue on case-insensitive filesystems. The conflicting file names are: ${JSON.stringify(Object.fromEntries(conflictingFileNames))}`);
importIndexedDir(importer, newDir, uniqueFileMap, opts2);
return true;
}
if (err.code === "ENOENT") {
return retryWithSanitizedFilenames(dirImport);
}
return false;
}
function tryExclusiveImport(importer, newDir, filenames, entries) {
if (!tryExclusiveMkdir(newDir))
return false;
const createdStat = safeLstat(newDir);
try {
tryImportIndexedDir(importer, newDir, filenames, entries);
return true;
} catch {
if (sameCreatedDirectory(newDir, createdStat)) {
try {
rimrafSync(newDir);
} catch {
}
}
return false;
}
}
function safeLstat(dir) {
try {
return fs26.lstatSync(dir, { bigint: true });
} catch {
return void 0;
}
}
function sameCreatedDirectory(dir, createdStat) {
if (createdStat == null)
return false;
const currentStat = safeLstat(dir);
if (currentStat == null || !currentStat.isDirectory())
return false;
return currentStat.dev === createdStat.dev && currentStat.ino === createdStat.ino && currentStat.birthtimeNs === createdStat.birthtimeNs && !fs26.existsSync(path26.join(dir, "package.json"));
}
function retryWithSanitizedFilenames({ importer, newDir, filenames, opts: opts2 }) {
const { sanitizedFilenames, invalidFilenames } = sanitizeFilenames(filenames);
if (invalidFilenames.length === 0)
return false;
globalWarn(`The package linked to "${sanitizeInline(path26.relative(process.cwd(), newDir))}" had files with invalid names: ${invalidFilenames.map((filename) => sanitizeInline(filename)).join(", ")}. They were renamed.`);
importIndexedDir(importer, newDir, sanitizedFilenames, opts2);
return true;
}
function tryImportIndexedDir({ importFile, importFileAtomic }, newDir, filenames, { links, symlinks } = {}) {
makeFileMapDirs(newDir, filenames);
let packageJsonSrc;
for (const [relativePath, src2] of filenames) {
if (relativePath === "package.json") {
packageJsonSrc = src2;
continue;
}
importEntry(importFile, src2, path26.join(newDir, relativePath), links);
}
for (const [relativePath, target2] of symlinks ?? []) {
const dest = path26.join(newDir, relativePath);
fs26.mkdirSync(path26.dirname(dest), { recursive: true });
fs26.symlinkSync(target2, dest);
}
if (packageJsonSrc !== void 0) {
importEntry(importFileAtomic, packageJsonSrc, path26.join(newDir, "package.json"), links);
}
}
function symlinkDirs(opts2, filenames, dirs) {
if (opts2.resolvedFrom !== "local-dir")
return void 0;
const imported = /* @__PURE__ */ new Set([""]);
for (const relativePath of filenames.keys()) {
for (let entry = relativePath; entry !== "" && !imported.has(entry); entry = path26.posix.dirname(entry).replace(/^\.$/, "")) {
imported.add(entry);
}
}
return { ...dirs, imported };
}
function importEntry(importFile, src2, dest, links) {
if (links != null && fs26.lstatSync(src2).isSymbolicLink() && copyInternalSymlink(src2, dest, links))
return;
importFile(src2, dest);
}
// ../fs/indexed-pkg-importer/lib/removeQuarantine.js
import { execFileSync } from "node:child_process";
import path27 from "node:path";
var QUARANTINE_ATTR = "com.apple.quarantine";
var NATIVE_BINARY_EXTENSIONS = /* @__PURE__ */ new Set([".node", ".dylib", ".so"]);
var MAX_ARG_BYTES = 1e5;
function isNativeBinary(filePath) {
return NATIVE_BINARY_EXTENSIONS.has(path27.extname(filePath).toLowerCase());
}
function removeQuarantine(filePaths) {
if (process.platform !== "darwin")
return;
for (const chunk of chunkByArgSize(filePaths)) {
removeQuarantineFromChunk(chunk);
}
}
function removeQuarantineFromChunk(filePaths) {
try {
execFileSync("/usr/bin/xattr", ["-d", QUARANTINE_ATTR, ...filePaths], {
stdio: ["ignore", "ignore", "pipe"]
});
} catch (err) {
const realErrors = getStderr(err).split("\n").filter((line) => line.trim() !== "" && !line.includes("No such xattr") && !line.includes("No such file"));
if (realErrors.length > 0) {
globalWarn(`Failed to remove the macOS quarantine attribute:
${realErrors.join("\n")}`);
}
}
}
function chunkByArgSize(filePaths) {
const chunks = [];
let chunk = [];
let chunkBytes = 0;
for (const filePath of filePaths) {
const bytes = Buffer.byteLength(filePath) + 1;
if (chunk.length > 0 && chunkBytes + bytes > MAX_ARG_BYTES) {
chunks.push(chunk);
chunk = [];
chunkBytes = 0;
}
chunk.push(filePath);
chunkBytes += bytes;
}
if (chunk.length > 0)
chunks.push(chunk);
return chunks;
}
function getStderr(err) {
if (typeof err === "object" && err !== null && "stderr" in err) {
const stderr = err.stderr;
if (stderr != null)
return stderr.toString();
}
return isError(err) ? err.message : String(err);
}
// ../fs/indexed-pkg-importer/lib/index.js
function createIndexedPkgImporter(packageImportMethod, opts2) {
const importPackage2 = createImportPackage(packageImportMethod, opts2);
return importPackage2;
}
function createImportPackage(packageImportMethod, opts2) {
const disableLogging = opts2?.disableLogging;
switch (packageImportMethod ?? "auto") {
case "clone":
if (!disableLogging)
packageImportMethodLogger.debug({ method: "clone" });
return createClonePkg();
case "hardlink":
if (!disableLogging)
packageImportMethodLogger.debug({ method: "hardlink" });
return hardlinkPkg.bind(null, linkOrCopy2);
case "auto": {
return createAutoImporter(opts2);
}
case "clone-or-copy":
return createCloneOrCopyImporter(opts2);
case "copy":
if (!disableLogging)
packageImportMethodLogger.debug({ method: "copy" });
return copyPkg;
default:
throw new Error(`Unknown package import method ${packageImportMethod}`);
}
}
function probeCloneAndSwitch(to, opts2, createOpts) {
if (process.platform === "win32")
return void 0;
try {
if (!tryClonePkg(to, opts2))
return void 0;
if (!createOpts?.disableLogging)
packageImportMethodLogger.debug({ method: "clone" });
return "clone";
} catch {
return void 0;
}
}
function handleHardlinkProbeError(err, to, opts2, createOpts) {
assert2(isError(err));
if (err.message.startsWith("EXDEV: cross-device link not permitted")) {
globalWarn(err.message);
globalInfo("Falling back to copying packages from store");
if (!createOpts?.disableLogging)
packageImportMethodLogger.debug({ method: "copy" });
return { nextAuto: copyPkg, result: copyPkg(to, opts2) };
}
if (!createOpts?.disableLogging)
packageImportMethodLogger.debug({ method: "hardlink" });
const nextAuto = hardlinkPkg.bind(null, linkOrCopy2);
return { nextAuto, result: nextAuto(to, opts2) };
}
function createAutoImporter(createOpts) {
let auto = initialAuto;
return (to, opts2) => auto(to, opts2);
function initialAuto(to, opts2) {
if (probeCloneAndSwitch(to, opts2, createOpts)) {
auto = createClonePkg();
return "clone";
}
try {
if (!hardlinkPkg(linkOrThrowOnLinkFailure, to, opts2))
return void 0;
if (!createOpts?.disableLogging)
packageImportMethodLogger.debug({ method: "hardlink" });
auto = hardlinkPkg.bind(null, linkOrCopy2);
return "hardlink";
} catch (err) {
const { nextAuto, result } = handleHardlinkProbeError(err, to, opts2, createOpts);
auto = nextAuto;
return result;
}
}
}
function createCloneOrCopyImporter(createOpts) {
let auto = initialAuto;
return (to, opts2) => auto(to, opts2);
function initialAuto(to, opts2) {
try {
if (!tryClonePkg(to, opts2))
return void 0;
if (!createOpts?.disableLogging)
packageImportMethodLogger.debug({ method: "clone" });
auto = createClonePkg();
return "clone";
} catch {
}
if (!createOpts?.disableLogging)
packageImportMethodLogger.debug({ method: "copy" });
auto = copyPkg;
return auto(to, opts2);
}
}
function alignedClone(clone) {
return (src2, dest) => {
clone(src2, dest);
alignStoreFileMode(src2, dest);
};
}
function tryClonePkg(to, opts2) {
if (shouldImportPkg(to, opts2)) {
const clone = alignedClone(createCloneFunction());
importIndexedDir({ importFile: clone, importFileAtomic: clone }, to, opts2.filesMap, opts2);
removeQuarantineFromNativeBinaries(to, opts2);
return "clone";
}
return void 0;
}
function withCloneFallback(clone, fallback) {
return (src2, dest) => {
try {
clone(src2, dest);
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOTSUP") {
fallback(src2, dest);
return;
}
throw err;
}
};
}
function createClonePkg() {
const clone = alignedClone(createCloneFunction());
const importer = {
importFile: withCloneFallback(clone, resilientCopyFileSync),
importFileAtomic: withCloneFallback(clone, atomicCopyFileSync)
};
return (to, opts2) => {
if (shouldImportPkg(to, opts2)) {
importIndexedDir(importer, to, opts2.filesMap, opts2);
removeQuarantineFromNativeBinaries(to, opts2);
return "clone";
}
return void 0;
};
}
function shouldImportPkg(to, opts2) {
if (opts2.resolvedFrom === "local-dir" && opts2.sourceExists === false) {
return targetHasNothingToLose(to);
}
return opts2.resolvedFrom !== "store" || opts2.force || !pkgExistsAtTargetDir(to, opts2.filesMap);
}
function pkgExistsAtTargetDir(targetDir, filesMap) {
return existsSync(path28.join(targetDir, pickFileFromFilesMap(filesMap)));
}
function pickFileFromFilesMap(filesMap) {
if (filesMap.has("package.json")) {
return "package.json";
}
if (filesMap.size === 0) {
throw new Error("pickFileFromFilesMap cannot pick a file from an empty FilesMap");
}
return filesMap.keys().next().value;
}
var _cloneFunction;
function createNativeReflinkClone() {
const { reflinkFileSync } = __require("@reflink/reflink");
return (fr, to) => {
try {
reflinkFileSync(fr, to);
} catch (err) {
if (!isError(err) || !("code" in err) || err.code !== "EEXIST")
throw err;
}
};
}
function createPosixReflinkClone() {
return (src2, dest) => {
try {
lib_default.copyFileSync(src2, dest, constants.COPYFILE_FICLONE_FORCE);
} catch (err) {
if (!(isError(err) && "code" in err && err.code === "EEXIST"))
throw err;
}
};
}
function createCloneFunction() {
if (_cloneFunction)
return _cloneFunction;
if (process.platform === "darwin" || process.platform === "win32") {
_cloneFunction = createNativeReflinkClone();
} else {
_cloneFunction = createPosixReflinkClone();
}
return _cloneFunction;
}
function hardlinkPkg(importFile, to, opts2) {
if (missingSourceHasSomethingToPreserve(to, opts2))
return void 0;
if (opts2.force || shouldRelinkPkg(to, opts2)) {
const reuseHardlinks = !opts2.force && opts2.resolvedFrom === "local-dir" && !opts2.symlinks?.size && hardlinkedDirMatches(to, opts2.filesMap, opts2.keepModulesDir ?? false);
if (!reuseHardlinks) {
importIndexedDir({ importFile, importFileAtomic: importFile }, to, opts2.filesMap, opts2);
}
removeQuarantineFromNativeBinaries(to, opts2);
return "hardlink";
}
return void 0;
}
function shouldRelinkPkg(to, opts2) {
if (opts2.disableRelinkLocalDirDeps && opts2.resolvedFrom === "local-dir") {
return targetHasNothingToLose(to);
}
if (opts2.resolvedFrom === "local-dir" && opts2.sourceExists === false) {
return targetHasNothingToLose(to);
}
return opts2.resolvedFrom !== "store" || !pkgLinkedToStore(opts2.filesMap, to);
}
function missingSourceHasSomethingToPreserve(to, opts2) {
return opts2.resolvedFrom === "local-dir" && opts2.sourceExists === false && !targetHasNothingToLose(to);
}
function targetHasNothingToLose(to) {
try {
const files = lib_default.readdirSync(to);
return files.length === 0 || files.length === 1 && files[0] === "node_modules";
} catch {
return true;
}
}
function alignStoreFileMode(src2, dest) {
const mode = storeEntryModeForSource(src2);
if (mode === void 0)
return;
chmodSync(dest, mode);
}
function storeModeDiffers(existingPath) {
const storeMode = storeEntryModeForSource(existingPath);
return storeMode !== void 0 && !isLinkableStoreMode(lib_default.statSync(existingPath).mode, storeMode);
}
function linkOrCopy2(existingPath, newPath) {
if (storeModeDiffers(existingPath)) {
resilientCopyFileSync(existingPath, newPath);
return;
}
try {
lib_default.linkSync(existingPath, newPath);
} catch (err) {
if (isError(err) && "code" in err && err.code === "EEXIST")
return;
resilientCopyFileSync(existingPath, newPath);
}
}
function linkOrThrowOnLinkFailure(existingPath, newPath) {
if (storeModeDiffers(existingPath)) {
resilientCopyFileSync(existingPath, newPath);
return;
}
lib_default.linkSync(existingPath, newPath);
}
function resilientCopyFileSync(src2, dest) {
try {
lib_default.copyFileSync(src2, dest);
alignStoreFileMode(src2, dest);
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOTSUP") {
const storeMode = storeEntryModeForSource(src2);
const srcMode = storeMode ?? lib_default.statSync(src2).mode;
lib_default.writeFileSync(dest, lib_default.readFileSync(src2), { mode: srcMode });
} else {
throw err;
}
}
}
function pkgLinkedToStore(filesMap, linkedPkgDir) {
const filename = pickFileFromFilesMap(filesMap);
const linkedFile = path28.join(linkedPkgDir, filename);
let stats0;
try {
stats0 = lib_default.statSync(linkedFile);
} catch (err) {
if (isError(err) && "code" in err && err.code === "ENOENT")
return false;
}
const stats1 = lib_default.statSync(filesMap.get(filename));
if (stats0.ino === stats1.ino)
return true;
globalInfo(`Relinking ${linkedPkgDir} from the store`);
return false;
}
function copyPkg(to, opts2) {
if (shouldImportPkg(to, opts2)) {
importIndexedDir({ importFile: resilientCopyFileSync, importFileAtomic: atomicCopyFileSync }, to, opts2.filesMap, opts2);
removeQuarantineFromNativeBinaries(to, opts2);
return "copy";
}
return void 0;
}
function atomicCopyFileSync(src2, dest) {
const tmp = fastPathTemp(dest);
try {
resilientCopyFileSync(src2, tmp);
} catch (err) {
try {
lib_default.unlinkSync(tmp);
} catch {
}
throw err;
}
renameOverwriteSync(tmp, dest);
}
function removeQuarantineFromNativeBinaries(to, opts2) {
if (process.platform !== "darwin" || opts2.resolvedFrom !== "store")
return;
const nativeBinaries = [];
for (const file of opts2.filesMap.keys()) {
if (isNativeBinary(file)) {
nativeBinaries.push(path28.join(to, file));
}
}
removeQuarantine(nativeBinaries);
}
// ../../../../../setup-pnpm/store/v11/links/@/mimic-function/5.0.1/42ffd44e2cba19e8e133b2bdc7d5939811fa14bc8061d1a5739a299c53ffa2b6/node_modules/mimic-function/index.js
var copyProperty = (to, from, property, ignoreNonConfigurable) => {
if (property === "length" || property === "prototype") {
return;
}
if (property === "arguments" || property === "caller") {
return;
}
const toDescriptor = Object.getOwnPropertyDescriptor(to, property);
const fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) {
return;
}
Object.defineProperty(to, property, fromDescriptor);
};
var canCopyProperty = function(toDescriptor, fromDescriptor) {
return toDescriptor === void 0 || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value);
};
var changePrototype = (to, from) => {
const fromPrototype = Object.getPrototypeOf(from);
if (fromPrototype === Object.getPrototypeOf(to)) {
return;
}
Object.setPrototypeOf(to, fromPrototype);
};
var wrappedToString = (withName, fromBody) => `/* Wrapped ${withName}*/
${fromBody}`;
var toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, "toString");
var toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, "name");
var changeToString = (to, from, name) => {
const withName = name === "" ? "" : `with ${name.trim()}() `;
const newToString = wrappedToString.bind(null, withName, from.toString());
Object.defineProperty(newToString, "name", toStringName);
const { writable, enumerable, configurable } = toStringDescriptor;
Object.defineProperty(to, "toString", { value: newToString, writable, enumerable, configurable });
};
function mimicFunction(to, from, { ignoreNonConfigurable = false } = {}) {
const { name } = to;
for (const property of Reflect.ownKeys(from)) {
copyProperty(to, from, property, ignoreNonConfigurable);
}
changePrototype(to, from);
changeToString(to, from, name);
return to;
}
// ../../../../../setup-pnpm/store/v11/links/@/memoize/11.0.0/1da59602ab45e19a3ba2c86ed324b17bdd4d6b8ab4664663e3c8557861e28a28/node_modules/memoize/distribution/index.js
var maxTimeoutValue = 2147483647;
var cacheStore = /* @__PURE__ */ new WeakMap();
var cacheTimerStore = /* @__PURE__ */ new WeakMap();
var cacheKeyStore = /* @__PURE__ */ new WeakMap();
function getValidCacheItem(cache, key) {
const item = cache.get(key);
if (!item) {
return void 0;
}
if (item.maxAge <= Date.now()) {
cache.delete(key);
return void 0;
}
return item;
}
function validateMaxAge(value, source) {
if (value === Number.POSITIVE_INFINITY) {
return;
}
if (!Number.isFinite(value)) {
if (source === "`maxAge` option") {
throw new TypeError("The `maxAge` option must be a finite number, `0`, or `Infinity`.");
}
throw new TypeError("The `maxAge` function must return a finite number, `0`, or `Infinity`.");
}
if (value > maxTimeoutValue) {
if (source === "`maxAge` option") {
throw new TypeError(`The \`maxAge\` option cannot exceed ${maxTimeoutValue}.`);
}
throw new TypeError(`The \`maxAge\` function result cannot exceed ${maxTimeoutValue}.`);
}
}
function memoize(function_, { cacheKey, cache = /* @__PURE__ */ new Map(), maxAge } = {}) {
if (typeof maxAge === "number") {
validateMaxAge(maxAge, "`maxAge` option");
if (maxAge <= 0) {
return function_;
}
}
const memoized = function(...arguments_) {
const key = cacheKey ? cacheKey(arguments_) : arguments_[0];
const cacheItem = getValidCacheItem(cache, key);
if (cacheItem) {
return cacheItem.data;
}
const result = function_.apply(this, arguments_);
const computedMaxAge = typeof maxAge === "function" ? maxAge(...arguments_) : maxAge;
if (computedMaxAge !== void 0 && computedMaxAge !== Number.POSITIVE_INFINITY) {
validateMaxAge(computedMaxAge, "`maxAge` function result");
if (computedMaxAge <= 0) {
return result;
}
}
cache.set(key, {
data: result,
maxAge: computedMaxAge === void 0 || computedMaxAge === Number.POSITIVE_INFINITY ? Number.POSITIVE_INFINITY : Date.now() + computedMaxAge
});
if (computedMaxAge !== void 0 && computedMaxAge !== Number.POSITIVE_INFINITY) {
const timer = setTimeout(() => {
cache.delete(key);
cacheTimerStore.get(memoized)?.delete(timer);
}, computedMaxAge);
timer.unref?.();
const timers = cacheTimerStore.get(memoized) ?? /* @__PURE__ */ new Set();
timers.add(timer);
cacheTimerStore.set(memoized, timers);
}
return result;
};
mimicFunction(memoized, function_, {
ignoreNonConfigurable: true
});
cacheStore.set(memoized, cache);
cacheKeyStore.set(memoized, cacheKey ?? ((arguments_) => arguments_[0]));
return memoized;
}
// ../store/create-cafs-store/lib/index.js
function createPackageImporter(opts2) {
const cachedImporterCreator = opts2.importIndexedPackage ? () => opts2.importIndexedPackage : memoize(createIndexedPkgImporter);
const packageImportMethod = opts2.packageImportMethod;
const gfm = getFlatMap.bind(null, opts2.storeDir);
return (to, opts3) => {
const { filesMap, isBuilt, symlinks } = gfm(opts3.filesResponse, opts3.sideEffectsCacheKey);
const pkgImportMethod = needsPrivateFiles(opts3.filesResponse, !isBuilt && opts3.requiresBuild === true) ? packageImportMethod === "copy" ? "copy" : "clone-or-copy" : packageImportMethod && packageImportMethod !== "auto" ? packageImportMethod : opts3.filesResponse.packageImportMethod ?? packageImportMethod;
const impPkg = cachedImporterCreator(pkgImportMethod);
const importMethod = impPkg(to, {
disableRelinkLocalDirDeps: opts3.disableRelinkLocalDirDeps,
filesMap,
resolvedFrom: opts3.filesResponse.resolvedFrom,
force: opts3.force,
keepModulesDir: Boolean(opts3.keepModulesDir),
safeToSkip: opts3.safeToSkip,
sourceExists: opts3.filesResponse.sourceExists,
symlinks
});
return { importMethod, isBuilt };
};
}
function needsPrivateFiles(filesResponse, willBeBuilt) {
return willBeBuilt || filesResponse.resolvedFrom === "local-dir" && filesResponse.packageImportMethod === "clone-or-copy";
}
function getFlatMap(storeDir, filesResponse, targetEngine) {
if (targetEngine && filesResponse.sideEffectsMaps?.has(targetEngine)) {
const sideEffectMap = filesResponse.sideEffectsMaps.get(targetEngine);
const filesMap = applySideEffectsDiffWithMaps(filesResponse.filesMap, sideEffectMap);
return {
filesMap,
isBuilt: true,
symlinks: sideEffectMap.symlinks
};
}
return {
filesMap: filesResponse.filesMap,
isBuilt: false
};
}
function applySideEffectsDiffWithMaps(baseFiles, { added, deleted, symlinks }) {
const filesWithSideEffects = /* @__PURE__ */ new Map();
if (added) {
for (const [name, filePath] of added.entries()) {
filesWithSideEffects.set(name, filePath);
}
}
for (const [fileName, filePath] of baseFiles) {
if (!deleted?.includes(fileName) && !filesWithSideEffects.has(fileName) && !symlinks?.has(fileName)) {
filesWithSideEffects.set(fileName, filePath);
}
}
return filesWithSideEffects;
}
function createCafsStore(storeDir, opts2) {
const baseTempDir = path29.join(storeDir, "tmp");
const importPackage2 = createPackageImporter({
importIndexedPackage: opts2?.importPackage,
packageImportMethod: opts2?.packageImportMethod,
storeDir
});
return {
...createCafs(storeDir, opts2),
storeDir,
importPackage: importPackage2,
tempDir: async () => {
await fs27.mkdir(baseTempDir, { recursive: true });
return fs27.mkdtemp(path29.join(baseTempDir, "_tmp_"));
}
};
}
// ../worker/lib/storeCaches.js
var cafsCache = /* @__PURE__ */ new Map();
var cafsStoreCache = /* @__PURE__ */ new Map();
var cafsLocker = /* @__PURE__ */ new Map();
var storeIndexCache = /* @__PURE__ */ new Map();
function getStoreIndex(storeDir, frozen = false) {
const cacheKey = frozen ? `${storeDir}\0frozen` : storeDir;
if (!storeIndexCache.has(cacheKey)) {
storeIndexCache.set(cacheKey, frozen ? new ImmutableStoreIndex(storeDir) : new StoreIndex(storeDir));
}
return storeIndexCache.get(cacheKey);
}
function closeStoreIndexes() {
for (const idx of storeIndexCache.values()) {
idx.close();
}
storeIndexCache.clear();
}
function getCafs(storeDir) {
if (!cafsCache.has(storeDir)) {
cafsCache.set(storeDir, createCafs(storeDir));
}
return cafsCache.get(storeDir);
}
function getCafsStore({ storeDir, packageImportMethod }) {
const cacheKey = JSON.stringify({ storeDir, packageImportMethod });
if (!cafsStoreCache.has(cacheKey)) {
cafsStoreCache.set(cacheKey, createCafsStore(storeDir, { packageImportMethod, cafsLocker }));
}
return cafsStoreCache.get(cacheKey);
}
// ../worker/lib/addToStore.js
async function addTarballToStore({ buffer, tarballFile, storeDir, integrity, filesIndexFile, pkgId, appendManifest, ignoreFilePattern, maxTarballUnpackedSize }) {
if (buffer == null && tarballFile == null)
throw new Error("Tarball extraction has no source");
const calculatedIntegrity = tarballFile != null ? await hashTarballFile(tarballFile, integrity) : void 0;
const integrityFailure = checkIntegrity({ buffer, integrity, calculatedIntegrity });
if (integrityFailure)
return integrityFailure;
const cafs = getCafs(storeDir);
const ignore = ignoreFilePattern ? makeIgnoreFromPattern(ignoreFilePattern) : void 0;
const addedFiles = tarballFile != null ? await cafs.addFilesFromTarballFile(tarballFile, { readManifest: true, ignore, maxTarballUnpackedSize }) : await cafs.addFilesFromTarballBounded(buffer, { readManifest: true, ignore, maxTarballUnpackedSize });
const added = describeAddedPkgFiles(cafs, addedFiles, appendManifest);
const requiresBuild = pkgRequiresBuild(added.bundledManifest, added.filesIntegrity);
const pkgFilesIndex = {
requiresBuild,
manifest: added.bundledManifest,
algo: HASH_ALGORITHM,
files: added.filesIntegrity
};
const packedFilesIndex = packToShared(pkgFilesIndex);
const indexWrites = [{ key: filesIndexFile, buffer: packedFilesIndex }];
if (!integrity) {
integrity = calculatedIntegrity ?? calcIntegrity(buffer);
if (pkgId) {
indexWrites.push({ key: storeIndexKey(integrity, pkgId), buffer: packedFilesIndex });
}
}
return {
status: "success",
value: {
filesMap: added.filesMap,
manifest: added.bundledManifest,
requiresBuild,
integrity
},
indexWrites
};
}
function checkIntegrity(opts2) {
if (!opts2.integrity)
return void 0;
return opts2.calculatedIntegrity != null ? compareTarballIntegrity(opts2.calculatedIntegrity, opts2.integrity) : checkTarballIntegrity(opts2.buffer, opts2.integrity);
}
async function hashTarballFile(tarballFile, integrity) {
const algorithm = integrity ? parseIntegrity(integrity).algorithm : "sha512";
const hash = createHash(algorithm);
for await (const chunk of createReadStream2(tarballFile))
hash.update(chunk);
return formatIntegrity(algorithm, hash.digest("hex"));
}
function checkTarballIntegrity(buffer, integrity) {
const { algorithm } = parseIntegrity(integrity);
return compareTarballIntegrity(formatIntegrity(algorithm, hashBuffer(algorithm, buffer)), integrity);
}
function compareTarballIntegrity(found, expected) {
const { algorithm, hexDigest } = parseIntegrity(expected);
if (parseIntegrity(found).hexDigest === hexDigest)
return void 0;
return {
status: "error",
error: {
type: "integrity_validation_failed",
algorithm,
expected,
found
}
};
}
function calcIntegrity(buffer) {
const calculatedHash = hashBuffer("sha512", buffer);
return formatIntegrity("sha512", calculatedHash);
}
function makeIgnoreFromPattern(pattern) {
let regex;
try {
regex = new RegExp(pattern);
} catch (err) {
const detail = isError(err) ? `: ${err.message}` : "";
throw new PnpmError("INVALID_IGNORE_FILE_PATTERN", `Invalid ignoreFilePattern regex${detail}: ${pattern}`);
}
return (filename) => regex.test(filename);
}
function packToShared(data) {
const packed = packForStorage(data);
const shared = new SharedArrayBuffer(packed.byteLength);
const view2 = new Uint8Array(shared);
view2.set(packed);
return view2;
}
function addFilesFromDir2(message) {
const { dir, files, includeNodeModules, sideEffectsCacheKey, storeDir } = message;
const cafs = getCafs(storeDir);
const addResult = cafs.addFilesFromDir(dir, {
files,
includeNodeModules,
readManifest: true,
// A side-effects entry never reaches Windows with a symlink in it:
// creating one there needs a privilege most users lack.
recordSymlinks: sideEffectsCacheKey != null && process.platform !== "win32"
});
const added = describeAddedPkgFiles(cafs, addResult, message.appendManifest);
if (sideEffectsCacheKey) {
return addSideEffectsToFilesIndex(message, sideEffectsCacheKey, { ...added, hasUnrecordedSymlinks: addResult.hasUnrecordedSymlinks });
}
const requiresBuild = pkgRequiresBuild(added.bundledManifest, added.filesIntegrity);
const pkgFilesIndex = {
requiresBuild,
requiresPrepare: message.requiresPrepare,
manifest: added.bundledManifest,
algo: HASH_ALGORITHM,
files: added.filesIntegrity
};
return {
status: "success",
value: {
filesMap: added.filesMap,
manifest: added.bundledManifest,
requiresBuild,
requiresPrepare: message.requiresPrepare,
sideEffects: void 0
},
indexWrites: [{ key: message.filesIndexFile, buffer: packToShared(pkgFilesIndex) }]
};
}
function addSideEffectsToFilesIndex({ filesIndexFile, storeDir }, sideEffectsCacheKey, added) {
const { filesMap, manifest, bundledManifest } = added;
const existingFilesIndex = getStoreIndex(storeDir).get(filesIndexFile);
if (!existingFilesIndex) {
return {
status: "success",
value: {
filesMap,
manifest: bundledManifest,
requiresBuild: pkgRequiresBuild(manifest, filesMap)
}
};
}
if (added.hasUnrecordedSymlinks) {
return {
status: "success",
value: {
filesMap,
manifest: bundledManifest,
requiresBuild: existingFilesIndex.requiresBuild ?? pkgRequiresBuild(manifest, filesMap)
},
indexWrites: removeSideEffectsEntry(existingFilesIndex, filesIndexFile, sideEffectsCacheKey)
};
}
const sideEffects = recordSideEffects(existingFilesIndex, sideEffectsCacheKey, added.filesIntegrity);
return {
status: "success",
value: {
filesMap,
manifest: bundledManifest,
requiresBuild: existingFilesIndex.requiresBuild ?? pkgRequiresBuild(manifest, filesMap),
requiresPrepare: existingFilesIndex.requiresPrepare,
sideEffects
},
indexWrites: [{ key: filesIndexFile, buffer: packToShared(existingFilesIndex) }]
};
}
function removeSideEffectsEntry(existingFilesIndex, filesIndexFile, sideEffectsCacheKey) {
if (!existingFilesIndex.sideEffects?.delete(sideEffectsCacheKey))
return void 0;
if (existingFilesIndex.sideEffects.size === 0) {
existingFilesIndex.sideEffects = void 0;
}
return [{ key: filesIndexFile, buffer: packToShared(existingFilesIndex) }];
}
function recordSideEffects(existingFilesIndex, sideEffectsCacheKey, filesIntegrity) {
if (!existingFilesIndex.sideEffects) {
existingFilesIndex.sideEffects = /* @__PURE__ */ new Map();
}
if (existingFilesIndex.algo !== HASH_ALGORITHM) {
throw new PnpmError("ALGO_MISMATCH", `Algorithm mismatch: package index uses "${existingFilesIndex.algo}" but side effects were computed with "${HASH_ALGORITHM}"`);
}
const sideEffects = calculateDiff(existingFilesIndex.files, filesIntegrity);
existingFilesIndex.sideEffects.set(sideEffectsCacheKey, sideEffects);
return sideEffects;
}
function describeAddedPkgFiles(cafs, { filesIndex, manifest }, appendManifest) {
if (appendManifest && manifest == null) {
manifest = appendManifest;
addManifestToCafs(cafs, filesIndex, appendManifest);
} else if (!filesIndex.has("package.json")) {
addPlaceholderPackageJsonToCafs(cafs, filesIndex);
}
const { filesIntegrity, filesMap } = processFilesIndex(filesIndex);
const bundledManifest = manifest != null ? normalizeBundledManifest(manifest) : void 0;
return { filesIntegrity, filesMap, manifest, bundledManifest };
}
function addManifestToCafs(cafs, filesIndex, manifest) {
const fileBuffer = Buffer.from(JSON.stringify(manifest, null, 2), "utf8");
const mode = 420;
filesIndex.set("package.json", {
mode,
size: fileBuffer.length,
...cafs.addFile(fileBuffer, mode)
});
}
var PLACEHOLDER_PACKAGE_JSON = Buffer.from(JSON.stringify({ _pnpmPlaceholder: "This file was generated by pnpm. The original package did not contain a package.json." }), "utf8");
function addPlaceholderPackageJsonToCafs(cafs, filesIndex) {
const mode = 420;
filesIndex.set("package.json", {
mode,
size: PLACEHOLDER_PACKAGE_JSON.length,
...cafs.addFile(PLACEHOLDER_PACKAGE_JSON, mode)
});
}
function calculateDiff(baseFiles, sideEffectsFiles) {
const deleted = [];
const added = /* @__PURE__ */ new Map();
const allFiles = /* @__PURE__ */ new Set([...baseFiles.keys(), ...sideEffectsFiles.keys()]);
for (const file of allFiles) {
if (!sideEffectsFiles.has(file)) {
deleted.push(file);
} else if (!baseFiles.has(file) || baseFiles.get(file).digest !== sideEffectsFiles.get(file).digest || // On Windows, the mode read back from disk does not preserve the mode stored from the tarball.
process.platform !== "win32" && baseFiles.get(file).mode !== sideEffectsFiles.get(file).mode) {
added.set(file, sideEffectsFiles.get(file));
}
}
const diff = {};
if (deleted.length > 0) {
diff.deleted = deleted;
}
if (added.size > 0) {
diff.added = added;
}
return diff;
}
function processFilesIndex(filesIndex) {
const filesIntegrity = /* @__PURE__ */ new Map();
const filesMap = /* @__PURE__ */ new Map();
for (const [relativePath, { checkedAt, filePath, digest, mode, size }] of filesIndex) {
filesIntegrity.set(relativePath, {
checkedAt,
digest,
mode,
size
});
filesMap.set(relativePath, filePath);
}
return { filesIntegrity, filesMap };
}
// ../worker/lib/readFromStore.js
import fs28 from "node:fs";
// ../worker/lib/equalOrSemverEqual.js
var import_semver2 = __toESM(require_semver2(), 1);
function equalOrSemverEqual(version1, version2) {
if (version1 === version2)
return true;
try {
return import_semver2.default.eq(version1, version2, { loose: true });
} catch {
return false;
}
}
// ../worker/lib/readFromStore.js
function readPkgFromStoreIndex(message) {
const { storeDir, filesIndexFile, verifyStoreIntegrity, expectedPkg, strictStorePkgContentCheck, frozenStore } = message;
const pkgFilesIndex = getStoreIndex(storeDir, frozenStore).get(filesIndexFile);
if (!pkgFilesIndex) {
return {
status: "success",
verifiedFileIntegrity: takeVerifiedFileIntegrity(),
value: {
verified: false,
pkgFilesIndex: null
}
};
}
const warnings = checkStoredPkgMatchesExpected(pkgFilesIndex.manifest, { expectedPkg, strictStorePkgContentCheck });
const verifyResult = verifyStoreIntegrity ? checkPkgFilesIntegrity(storeDir, pkgFilesIndex) : buildFileMapsFromIndex(storeDir, pkgFilesIndex);
const bundledManifest = pkgFilesIndex.manifest;
const requiresBuild = resolveRequiresBuild(pkgFilesIndex.requiresBuild, bundledManifest, verifyResult.filesMap);
return {
status: "success",
warnings,
// Store verification happens here, in the worker, but the
// install reports it from the main thread. Hand this worker's
// share back with the answer it belongs to.
verifiedFileIntegrity: takeVerifiedFileIntegrity(),
value: {
verified: verifyResult.passed,
bundledManifest,
files: {
filesMap: verifyResult.filesMap,
sideEffectsMaps: verifyResult.sideEffectsMaps,
sideEffectsDiffs: verifyResult.sideEffectsDiffs,
remoteSideEffectsQuarantine: verifyResult.remoteSideEffectsQuarantine,
resolvedFrom: "store",
requiresBuild,
requiresPrepare: pkgFilesIndex.requiresPrepare
}
}
};
}
function checkStoredPkgMatchesExpected(manifest, opts2) {
const { expectedPkg } = opts2;
if (!expectedPkg || !isStoredPkgMismatch(manifest, expectedPkg))
return [];
const msg = "Package name or version mismatch found while reading from the store.";
const hint = `This means that either the lockfile is broken or the package metadata (name and version) inside the package's package.json file doesn't match the metadata in the registry. Expected package: ${expectedPkg.name}@${expectedPkg.version}. Actual package in the store: ${manifest?.name}@${manifest?.version}.`;
if (opts2.strictStorePkgContentCheck ?? true) {
throw new PnpmError("UNEXPECTED_PKG_CONTENT_IN_STORE", msg, {
hint: `${hint}
If you want to ignore this issue, set strictStorePkgContentCheck to false in your configuration`
});
}
return [`${msg} ${hint}`];
}
function isStoredPkgMismatch(manifest, expectedPkg) {
const nameMismatch = manifest?.name != null && expectedPkg.name != null && manifest.name.toLowerCase() !== expectedPkg.name.toLowerCase();
if (nameMismatch)
return true;
return manifest?.version != null && expectedPkg.version != null && !equalOrSemverEqual(manifest.version, expectedPkg.version);
}
function resolveRequiresBuild(stored, bundledManifest, filesMap) {
if (stored == null)
return pkgRequiresBuild(bundledManifest, filesMap);
if (!stored || !storedRequiresBuildNeedsManifestCheck(bundledManifest, filesMap))
return stored;
const manifest = readManifestFromCafs(filesMap);
return manifest == null ? stored : pkgRequiresBuild(manifest, filesMap);
}
function readManifestFromCafs(filesMap) {
const manifestPath = filesMap.get("package.json");
if (manifestPath == null)
return void 0;
try {
return parseJsonBufferSync(fs28.readFileSync(manifestPath));
} catch (err) {
if (err instanceof SyntaxError || isError(err) && "code" in err && err.code === "ENOENT") {
return void 0;
}
throw err;
}
}
// ../worker/lib/start.js
function startWorker() {
process.on("uncaughtException", (err) => {
console.error(err);
});
parentPort.on("message", handleMessage);
}
async function handleMessage(message) {
if (message === false) {
stopWorker();
}
try {
parentPort.postMessage(await processMessage(message));
} catch (e) {
parentPort.postMessage({
status: "error",
// Drained here too: a request that hashed and then threw would
// otherwise leave its share in this worker, to be handed to
// whichever install asks next.
verifiedFileIntegrity: takeVerifiedFileIntegrity(),
error: {
code: e.code,
message: e.message ?? e.toString(),
hint: e.hint
}
});
}
}
function stopWorker() {
parentPort.off("message", handleMessage);
closeStoreIndexes();
process.exit(0);
}
async function processMessage(message) {
switch (message.type) {
case "extract":
return addTarballToStore(message);
case "link":
return importPackage(message);
case "add-dir":
return addFilesFromDir2(message);
case "init-store":
return initStore(message);
case "readPkgFromCafs":
return readPkgFromStoreIndex(message);
case "symlinkAllModules":
return symlinkAllModules(message);
case "hardLinkDir":
hardLinkDir(message.src, message.destDirs);
return { status: "success" };
}
}
function initStore({ storeDir }) {
fs29.mkdirSync(storeDir, { recursive: true });
const hexChars = "0123456789abcdef".split("");
const filesDirPath = path30.join(storeDir, "files");
try {
fs29.mkdirSync(filesDirPath);
} catch {
}
for (const hex1 of hexChars) {
for (const hex2 of hexChars) {
try {
fs29.mkdirSync(path30.join(filesDirPath, `${hex1}${hex2}`));
} catch {
}
}
}
return { status: "success" };
}
function importPackage({ storeDir, packageImportMethod, filesResponse, sideEffectsCacheKey, targetDir, requiresBuild, force, keepModulesDir, disableRelinkLocalDirDeps, safeToSkip }) {
const cafsStore = getCafsStore({ storeDir, packageImportMethod });
const { importMethod, isBuilt } = cafsStore.importPackage(targetDir, {
filesResponse,
force,
disableRelinkLocalDirDeps,
requiresBuild,
sideEffectsCacheKey,
keepModulesDir,
safeToSkip
});
return { status: "success", value: { isBuilt, importMethod } };
}
function symlinkAllModules(opts2) {
for (const dep of opts2.deps) {
for (const [alias, pkgDir] of Object.entries(dep.children)) {
if (alias !== dep.name) {
symlinkDependencySync(pkgDir, dep.modules, alias);
}
}
}
return { status: "success" };
}
// ../worker/lib/worker.js
startWorker();
/*! Bundled license information:
is-windows/index.js:
(*!
* is-windows <https://github.com/jonschlinkert/is-windows>
*
* Copyright © 2015-2018, Jon Schlinkert.
* Released under the MIT License.
*)
*/