jspm
Version:
Import Map Package Manager
1,366 lines (1,356 loc) • 6.05 MB
JavaScript
import $__util from 'node:util';
import $__buffer from 'node:buffer';
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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
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 new Error('Dynamic require of "' + x + '" is not supported');
});
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// 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(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __publicField = (obj, key, value) => {
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
return value;
};
var __accessCheck = (obj, member, msg) => {
if (!member.has(obj))
throw TypeError("Cannot " + msg);
};
var __privateGet = (obj, member, getter) => {
__accessCheck(obj, member, "read from private field");
return getter ? getter.call(obj) : member.get(obj);
};
var __privateAdd = (obj, member, value) => {
if (member.has(obj))
throw TypeError("Cannot add the same private member more than once");
member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
};
var __privateSet = (obj, member, value, setter) => {
__accessCheck(obj, member, "write to private field");
setter ? setter.call(obj, value) : member.set(obj, value);
return value;
};
var __privateMethod = (obj, member, method) => {
__accessCheck(obj, member, "access private method");
return method;
};
// src/logger.ts
import { createWriteStream } from "node:fs";
import os from "os";
import c2 from "picocolors";
function log(type, message) {
_log && _log(type, message);
}
function withType(type) {
return (message) => log(type, message);
}
function createLogger() {
let resolveQueue;
let queuePromise = new Promise((resolve5) => resolveQueue = resolve5);
let queue = [];
const logStream = async function* () {
while (true) {
while (queue.length)
yield queue.shift();
await queuePromise;
}
};
function log2(type, message) {
if (queue.length) {
queue.push({ type, message });
} else {
queue = [{ type, message }];
const _resolveQueue = resolveQueue;
queuePromise = new Promise((resolve5) => resolveQueue = resolve5);
_resolveQueue();
}
}
return { log: log2, logStream };
}
var logEnabled, logToStdout, _log, _logStream;
var init_logger = __esm({
"src/logger.ts"() {
logEnabled = !!process.env.JSPM_CLI_LOG;
logToStdout = process.env.JSPM_CLI_LOG === "1";
if (logEnabled) {
({ log: _log, logStream: _logStream } = createLogger());
try {
let logPath;
let logFileStream = null;
if (logToStdout) {
console.log(c2.red(`Debug logging enabled - outputting to stdout`));
} else {
if (process.env.JSPM_CLI_LOG === "true" || process.env.JSPM_CLI_LOG?.toLowerCase() === "true") {
logPath = `${os.tmpdir()}/jspm-${new Date().toISOString().slice(0, 19)}.log`;
} else {
logPath = process.env.JSPM_CLI_LOG;
}
logFileStream = createWriteStream(logPath, {
flags: "a",
encoding: "utf8",
mode: 438
});
console.log(c2.red(`Debug logging enabled - writing to ${logPath}`));
}
(async () => {
if (logFileStream) {
logFileStream.write(`JSPM CLI Log started at ${new Date().toISOString()}
`);
}
for await (const { type, message } of _logStream()) {
const time = new Date().toISOString().slice(11, 23);
const formattedMessage = `${time} ${type}: ${message}
`;
if (logToStdout) {
const prefix = c2.bold(`${time} ${type}:`);
console.log(`${prefix} ${message}`);
} else if (logFileStream) {
logFileStream.write(formattedMessage);
}
}
})();
} catch (e) {
console.error(c2.red(`Failed to create debug logger: ${e.message}`));
}
}
}
});
// ../node_modules/sver/sver.js
var require_sver = __commonJS({
"../node_modules/sver/sver.js"(exports) {
"use strict";
var shortSemverRegEx = /^([~\^])?(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?$/;
var semverRegEx = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([\da-z-]+(?:\.[\da-z-]+)*))?(\+[\da-z-]+)?$/i;
exports.semverRegEx = semverRegEx;
exports.shortSemverRegEx = shortSemverRegEx;
var MAJOR = Symbol("major");
var MINOR = Symbol("minor");
var PATCH = Symbol("patch");
var PRE = Symbol("pre");
var BUILD = Symbol("build");
var TAG = Symbol("tag");
var numRegEx = /^\d+$/;
var Semver = class {
constructor(version3) {
let semver = version3.match(semverRegEx);
if (!semver) {
this[TAG] = version3;
return;
}
this[MAJOR] = parseInt(semver[1], 10);
this[MINOR] = parseInt(semver[2], 10);
this[PATCH] = parseInt(semver[3], 10);
this[PRE] = semver[4] && semver[4].split(".");
this[BUILD] = semver[5];
}
get major() {
return this[MAJOR];
}
get minor() {
return this[MINOR];
}
get patch() {
return this[PATCH];
}
get pre() {
return this[PRE];
}
get build() {
return this[BUILD];
}
get tag() {
return this[TAG];
}
gt(version3) {
return Semver.compare(this, version3) === 1;
}
lt(version3) {
return Semver.compare(this, version3) === -1;
}
eq(version3) {
if (!(version3 instanceof Semver))
version3 = new Semver(version3);
if (this[TAG] && version3[TAG])
return this[TAG] === version3[TAG];
if (this[TAG] || version3[TAG])
return false;
if (this[MAJOR] !== version3[MAJOR])
return false;
if (this[MINOR] !== version3[MINOR])
return false;
if (this[PATCH] !== version3[PATCH])
return false;
if (this[PRE] === void 0 && version3[PRE] === void 0)
return true;
if (this[PRE] === void 0 || version3[PRE] === void 0)
return false;
if (this[PRE].length !== version3[PRE].length)
return false;
for (let i = 0; i < this[PRE].length; i++) {
if (this[PRE][i] !== version3[PRE][i])
return false;
}
return this[BUILD] === version3[BUILD];
}
matches(range, unstable = false) {
if (!(range instanceof SemverRange2))
range = new SemverRange2(range);
return range.has(this, unstable);
}
toString() {
if (this[TAG])
return this[TAG];
return this[MAJOR] + "." + this[MINOR] + "." + this[PATCH] + (this[PRE] ? "-" + this[PRE].join(".") : "") + (this[BUILD] ? this[BUILD] : "");
}
toJSON() {
return this.toString();
}
static isValid(version3) {
let semver = version3.match(semverRegEx);
return semver && semver[2] !== void 0 && semver[3] !== void 0;
}
static compare(v1, v2) {
if (!(v1 instanceof Semver))
v1 = new Semver(v1);
if (!(v2 instanceof Semver))
v2 = new Semver(v2);
if (v1[TAG] && v2[TAG])
return 0;
if (v1[TAG])
return -1;
if (v2[TAG])
return 1;
if (v1[MAJOR] !== v2[MAJOR])
return v1[MAJOR] > v2[MAJOR] ? 1 : -1;
if (v1[MINOR] !== v2[MINOR])
return v1[MINOR] > v2[MINOR] ? 1 : -1;
if (v1[PATCH] !== v2[PATCH])
return v1[PATCH] > v2[PATCH] ? 1 : -1;
if (!v1[PRE] && !v2[PRE])
return 0;
if (!v1[PRE])
return 1;
if (!v2[PRE])
return -1;
return prereleaseCompare(v1[PRE], v2[PRE]);
}
};
exports.Semver = Semver;
function prereleaseCompare(v1Pre, v2Pre) {
for (let i = 0, l = Math.min(v1Pre.length, v2Pre.length); i < l; i++) {
if (v1Pre[i] !== v2Pre[i]) {
let isNum1 = v1Pre[i].match(numRegEx);
let isNum2 = v2Pre[i].match(numRegEx);
if (isNum1 && !isNum2)
return -1;
if (isNum2 && !isNum1)
return 1;
if (isNum1 && isNum2)
return parseInt(v1Pre[i], 10) > parseInt(v2Pre[i], 10) ? 1 : -1;
else
return v1Pre[i] > v2Pre[i] ? 1 : -1;
}
}
if (v1Pre.length === v2Pre.length)
return 0;
return v1Pre.length > v2Pre.length ? 1 : -1;
}
var WILDCARD_RANGE = 0;
var MAJOR_RANGE = 1;
var STABLE_RANGE = 2;
var EXACT_RANGE = 3;
var LOWER_BOUND = 4;
var UPPER_BOUND = 5;
var INTERSECTION_RANGE = 6;
var UNION_RANGE = 7;
var TYPE = Symbol("type");
var VERSION = Symbol("version");
var RANGE_SET = Symbol("rangeSet");
var BOUND_INCLUSIVE = Symbol("boundInclusive");
var comparatorRegEx = /^(>=|<=|>|<|=)\s*(.+)$/;
var partialRegEx = /^(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:-([\da-z-]+(?:\.[\da-z-]+)*))?(\+[\da-z-]+)?)?)?$/i;
function effectiveVersion(range) {
if (range[VERSION])
return range[VERSION];
if (range[RANGE_SET] && range[RANGE_SET].length > 0)
return effectiveVersion(range[RANGE_SET][0]);
return null;
}
function effectiveUpperBound(range) {
let type = range[TYPE];
if (type === WILDCARD_RANGE || type === LOWER_BOUND)
return null;
if (type === MAJOR_RANGE)
return new Semver(range[VERSION][MAJOR] + 1 + ".0.0");
if (type === STABLE_RANGE)
return new Semver(range[VERSION][MAJOR] + "." + (range[VERSION][MINOR] + 1) + ".0");
if (type === EXACT_RANGE || type === UPPER_BOUND)
return range[VERSION];
if (type === INTERSECTION_RANGE) {
let min = null;
for (let r of range[RANGE_SET]) {
let ub = effectiveUpperBound(r);
if (ub !== null && (min === null || Semver.compare(ub, min) < 0))
min = ub;
}
return min;
}
if (type === UNION_RANGE) {
let max = null;
for (let r of range[RANGE_SET]) {
let ub = effectiveUpperBound(r);
if (ub === null)
return null;
if (max === null || Semver.compare(ub, max) > 0)
max = ub;
}
return max;
}
return range[VERSION] || null;
}
function createUpperBoundFromHyphen(verStr) {
let fullVer = verStr.match(semverRegEx);
if (fullVer) {
return new SemverRange2("<=" + verStr);
}
let partialMatch = verStr.match(partialRegEx);
if (partialMatch) {
let major = parseInt(partialMatch[1], 10);
let hasMinor = partialMatch[2] !== void 0;
let minor = hasMinor ? parseInt(partialMatch[2], 10) : void 0;
if (hasMinor) {
return new SemverRange2("<" + major + "." + (minor + 1) + ".0");
} else {
return new SemverRange2("<" + (major + 1) + ".0.0");
}
}
return new SemverRange2("<=" + verStr);
}
var SemverRange2 = class {
constructor(versionRange) {
versionRange = versionRange.trim();
versionRange = versionRange.replace(/(>=|<=|>|<|=)\s+/g, "$1");
if (versionRange.includes("||")) {
let parts = versionRange.split("||").map((p) => p.trim()).filter(Boolean);
if (parts.length >= 2) {
this[TYPE] = UNION_RANGE;
this[RANGE_SET] = parts.map((p) => new SemverRange2(p));
return;
}
if (parts.length === 1)
versionRange = parts[0];
else {
this[TYPE] = WILDCARD_RANGE;
return;
}
}
let hyphenMatch = versionRange.match(/^(\S+)\s+-\s+(\S+)$/);
if (hyphenMatch) {
this[TYPE] = INTERSECTION_RANGE;
this[RANGE_SET] = [
new SemverRange2(">=" + hyphenMatch[1]),
createUpperBoundFromHyphen(hyphenMatch[2])
];
return;
}
let tokens = versionRange.split(/\s+/);
if (tokens.length > 1) {
this[TYPE] = INTERSECTION_RANGE;
this[RANGE_SET] = tokens.map((t) => new SemverRange2(t));
return;
}
versionRange = versionRange.replace(/\.[xX*]/g, "");
if (/^[xX*]$/.test(versionRange) || versionRange === "") {
versionRange = "*";
}
if (versionRange === "*" || versionRange === "") {
this[TYPE] = WILDCARD_RANGE;
return;
}
let shortSemver = versionRange.match(shortSemverRegEx);
if (shortSemver) {
if (shortSemver[1])
versionRange = versionRange.substr(1);
if (shortSemver[3] === void 0) {
this[VERSION] = new Semver(versionRange + ".0.0");
this[TYPE] = MAJOR_RANGE;
} else {
this[VERSION] = new Semver(versionRange + ".0");
if (shortSemver[1] === "^" && shortSemver[2] !== "0")
this[TYPE] = MAJOR_RANGE;
else
this[TYPE] = STABLE_RANGE;
}
this[VERSION][PRE] = this[VERSION][PRE] || [];
return;
}
if (versionRange.startsWith("^^")) {
this[VERSION] = new Semver(versionRange.substr(2));
this[TYPE] = MAJOR_RANGE;
} else if (versionRange[0] === "^") {
this[VERSION] = new Semver(versionRange.substr(1));
if (this[VERSION][MAJOR] === 0) {
if (this[VERSION][MINOR] === 0)
this[TYPE] = EXACT_RANGE;
else
this[TYPE] = STABLE_RANGE;
} else {
this[TYPE] = MAJOR_RANGE;
}
} else if (versionRange[0] === "~") {
this[VERSION] = new Semver(versionRange.substr(1));
this[TYPE] = STABLE_RANGE;
} else if (comparatorRegEx.test(versionRange)) {
let match2 = versionRange.match(comparatorRegEx);
this._parseComparator(match2[1], match2[2].trim());
return;
} else {
this[VERSION] = new Semver(versionRange);
this[TYPE] = EXACT_RANGE;
}
if (this[VERSION] && this[VERSION][TAG] && this[TYPE] !== EXACT_RANGE)
this[TYPE] = EXACT_RANGE;
}
_parseComparator(op, verStr) {
if (op === "=") {
let fullVer = verStr.match(semverRegEx);
if (fullVer) {
this[VERSION] = new Semver(verStr);
this[TYPE] = EXACT_RANGE;
} else {
let temp = new SemverRange2(verStr);
this[TYPE] = temp[TYPE];
this[VERSION] = temp[VERSION];
if (temp[RANGE_SET])
this[RANGE_SET] = temp[RANGE_SET];
if (temp[BOUND_INCLUSIVE] !== void 0)
this[BOUND_INCLUSIVE] = temp[BOUND_INCLUSIVE];
}
return;
}
let isLower = op === ">=" || op === ">";
let isInclusive = op === ">=" || op === "<=";
let partialMatch = verStr.match(partialRegEx);
if (!partialMatch) {
this[VERSION] = new Semver(op + verStr);
this[TYPE] = EXACT_RANGE;
return;
}
let major = parseInt(partialMatch[1], 10);
let hasMinor = partialMatch[2] !== void 0;
let minor = hasMinor ? parseInt(partialMatch[2], 10) : void 0;
let hasPatch = partialMatch[3] !== void 0;
if (hasPatch) {
this[VERSION] = new Semver(verStr);
this[TYPE] = isLower ? LOWER_BOUND : UPPER_BOUND;
this[BOUND_INCLUSIVE] = isInclusive;
} else if (hasMinor) {
if (isLower) {
if (isInclusive) {
this[VERSION] = new Semver(major + "." + minor + ".0");
} else {
this[VERSION] = new Semver(major + "." + (minor + 1) + ".0");
}
this[TYPE] = LOWER_BOUND;
this[BOUND_INCLUSIVE] = true;
} else {
if (isInclusive) {
this[VERSION] = new Semver(major + "." + (minor + 1) + ".0");
} else {
this[VERSION] = new Semver(major + "." + minor + ".0");
}
this[TYPE] = UPPER_BOUND;
this[BOUND_INCLUSIVE] = false;
}
} else {
if (isLower) {
if (isInclusive) {
this[VERSION] = new Semver(major + ".0.0");
} else {
this[VERSION] = new Semver(major + 1 + ".0.0");
}
this[TYPE] = LOWER_BOUND;
this[BOUND_INCLUSIVE] = true;
} else {
if (isInclusive) {
this[VERSION] = new Semver(major + 1 + ".0.0");
} else {
this[VERSION] = new Semver(major + ".0.0");
}
this[TYPE] = UPPER_BOUND;
this[BOUND_INCLUSIVE] = false;
}
}
}
_testBound(version3) {
if (version3[TAG])
return false;
let cmp = Semver.compare(version3, this[VERSION]);
if (this[TYPE] === LOWER_BOUND)
return this[BOUND_INCLUSIVE] ? cmp >= 0 : cmp > 0;
if (this[TYPE] === UPPER_BOUND)
return this[BOUND_INCLUSIVE] ? cmp <= 0 : cmp < 0;
return false;
}
get isExact() {
return this[TYPE] === EXACT_RANGE;
}
get isExactSemver() {
return this[TYPE] === EXACT_RANGE && this.version[TAG] === void 0;
}
get isExactTag() {
return this[TYPE] === EXACT_RANGE && this.version[TAG] !== void 0;
}
get isStable() {
return this[TYPE] === STABLE_RANGE;
}
get isMajor() {
return this[TYPE] === MAJOR_RANGE;
}
get isWildcard() {
return this[TYPE] === WILDCARD_RANGE;
}
get isLowerBound() {
return this[TYPE] === LOWER_BOUND;
}
get isUpperBound() {
return this[TYPE] === UPPER_BOUND;
}
get isIntersection() {
return this[TYPE] === INTERSECTION_RANGE;
}
get isUnion() {
return this[TYPE] === UNION_RANGE;
}
get type() {
switch (this[TYPE]) {
case WILDCARD_RANGE:
return "wildcard";
case MAJOR_RANGE:
return "major";
case STABLE_RANGE:
return "stable";
case EXACT_RANGE:
return "exact";
case LOWER_BOUND:
return "lower_bound";
case UPPER_BOUND:
return "upper_bound";
case INTERSECTION_RANGE:
return "intersection";
case UNION_RANGE:
return "union";
}
}
get version() {
return this[VERSION];
}
get rangeSet() {
return this[RANGE_SET];
}
get boundInclusive() {
return this[BOUND_INCLUSIVE];
}
gt(range) {
return SemverRange2.compare(this, range) === 1;
}
lt(range) {
return SemverRange2.compare(this, range) === -1;
}
eq(range) {
return SemverRange2.compare(this, range) === 0;
}
has(version3, unstable = false) {
if (!(version3 instanceof Semver))
version3 = new Semver(version3);
if (this[TYPE] === WILDCARD_RANGE)
return unstable || !version3[PRE] && !version3[TAG];
if (this[TYPE] === EXACT_RANGE)
return this[VERSION].eq(version3);
if (this[TYPE] === MAJOR_RANGE || this[TYPE] === STABLE_RANGE) {
if (version3[TAG])
return false;
if (this[VERSION][MAJOR] !== version3[MAJOR])
return false;
if (this[TYPE] === MAJOR_RANGE ? this[VERSION][MINOR] > version3[MINOR] : this[VERSION][MINOR] !== version3[MINOR])
return false;
if ((this[TYPE] === MAJOR_RANGE ? this[VERSION][MINOR] === version3[MINOR] : true) && this[VERSION][PATCH] > version3[PATCH])
return false;
if (version3[PRE] === void 0 || version3[PRE].length === 0)
return true;
if (this[VERSION][PRE] === void 0 || this[VERSION][PRE].length === 0)
return unstable;
if (unstable === false && (this[VERSION][MINOR] !== version3[MINOR] || this[VERSION][PATCH] !== version3[PATCH]))
return false;
return prereleaseCompare(this[VERSION][PRE], version3[PRE]) !== 1;
}
if (this[TYPE] === LOWER_BOUND || this[TYPE] === UPPER_BOUND) {
if (version3[TAG])
return false;
if (!unstable && version3[PRE] && version3[PRE].length) {
if (!this[VERSION][PRE] || !this[VERSION][PRE].length || this[VERSION][MAJOR] !== version3[MAJOR] || this[VERSION][MINOR] !== version3[MINOR] || this[VERSION][PATCH] !== version3[PATCH])
return false;
}
return this._testBound(version3);
}
if (this[TYPE] === INTERSECTION_RANGE) {
if (version3[TAG]) {
return this[RANGE_SET].every((r) => r.has(version3, unstable));
}
if (!unstable && version3[PRE] && version3[PRE].length) {
let hasTupleMatch = this[RANGE_SET].some((r) => {
let v = r[VERSION];
return v && v[PRE] && v[PRE].length && v[MAJOR] === version3[MAJOR] && v[MINOR] === version3[MINOR] && v[PATCH] === version3[PATCH];
});
if (!hasTupleMatch)
return false;
}
return this[RANGE_SET].every((r) => {
if (r[TYPE] === LOWER_BOUND || r[TYPE] === UPPER_BOUND)
return r._testBound(version3);
return r.has(version3, !unstable ? true : unstable);
});
}
if (this[TYPE] === UNION_RANGE) {
return this[RANGE_SET].some((r) => r.has(version3, unstable));
}
return false;
}
contains(range) {
if (!(range instanceof SemverRange2))
range = new SemverRange2(range);
if (this[TYPE] === WILDCARD_RANGE)
return true;
if (range[TYPE] === WILDCARD_RANGE)
return false;
if (this[TYPE] === UNION_RANGE)
return this[RANGE_SET].some((r) => r.contains(range));
if (range[TYPE] === UNION_RANGE)
return range[RANGE_SET].every((r) => this.contains(r));
if (range[TYPE] === INTERSECTION_RANGE)
return range[RANGE_SET].some((r) => this.contains(r));
if (this[TYPE] === INTERSECTION_RANGE)
return this[RANGE_SET].every((r) => r.contains(range));
if (this[TYPE] <= EXACT_RANGE && range[TYPE] <= EXACT_RANGE)
return range[TYPE] >= this[TYPE] && this.has(range[VERSION], true);
if ((this[TYPE] === LOWER_BOUND || this[TYPE] === UPPER_BOUND) && range[TYPE] === EXACT_RANGE)
return this.has(range[VERSION], true);
return false;
}
intersect(range) {
if (!(range instanceof SemverRange2))
range = new SemverRange2(range);
if (this[TYPE] === WILDCARD_RANGE && range[TYPE] === WILDCARD_RANGE)
return this;
if (this[TYPE] === WILDCARD_RANGE)
return range;
if (range[TYPE] === WILDCARD_RANGE)
return this;
if (this[TYPE] === EXACT_RANGE)
return range.has(this[VERSION], true) ? this : void 0;
if (range[TYPE] === EXACT_RANGE)
return this.has(range[VERSION], true) ? range : void 0;
if (this[TYPE] === UNION_RANGE) {
let results = this[RANGE_SET].map((r) => r.intersect(range)).filter(Boolean);
if (results.length === 0)
return void 0;
if (results.length === 1)
return results[0];
let union = Object.create(SemverRange2.prototype);
union[TYPE] = UNION_RANGE;
union[RANGE_SET] = results;
return union;
}
if (range[TYPE] === UNION_RANGE)
return range.intersect(this);
if (this[TYPE] === INTERSECTION_RANGE && range[TYPE] === INTERSECTION_RANGE) {
let result2 = Object.create(SemverRange2.prototype);
result2[TYPE] = INTERSECTION_RANGE;
result2[RANGE_SET] = [...this[RANGE_SET], ...range[RANGE_SET]];
return result2;
}
if (this[TYPE] === INTERSECTION_RANGE) {
let result2 = Object.create(SemverRange2.prototype);
result2[TYPE] = INTERSECTION_RANGE;
result2[RANGE_SET] = [...this[RANGE_SET], range];
return result2;
}
if (range[TYPE] === INTERSECTION_RANGE)
return range.intersect(this);
if (this[TYPE] <= EXACT_RANGE && range[TYPE] <= EXACT_RANGE) {
let higherRange, lowerRange, polarity;
if (range[VERSION].gt(this[VERSION])) {
higherRange = range;
lowerRange = this;
polarity = true;
} else {
higherRange = this;
lowerRange = range;
polarity = false;
}
if (!lowerRange.has(higherRange[VERSION], true))
return;
if (lowerRange[TYPE] === MAJOR_RANGE)
return polarity ? range : this;
let intersection = new SemverRange2(higherRange[VERSION].toString());
intersection[TYPE] = STABLE_RANGE;
return intersection;
}
let result = Object.create(SemverRange2.prototype);
result[TYPE] = INTERSECTION_RANGE;
result[RANGE_SET] = [this, range];
return result;
}
bestMatch(versions, unstable = false) {
let maxSemver;
versions.forEach((version3) => {
if (!(version3 instanceof Semver))
version3 = new Semver(version3);
if (!this.has(version3, unstable))
return;
if (!maxSemver)
maxSemver = version3;
else if (Semver.compare(version3, maxSemver) === 1)
maxSemver = version3;
});
return maxSemver;
}
toString() {
let version3 = this[VERSION];
switch (this[TYPE]) {
case WILDCARD_RANGE:
return "*";
case MAJOR_RANGE:
if (version3[MAJOR] === 0 && version3[MINOR] === 0 && version3[PATCH] === 0)
return "0";
if (version3[PRE] && version3[PRE].length === 0 && version3[PATCH] === 0)
return "^" + version3[MAJOR] + "." + version3[MINOR];
return "^" + version3.toString();
case STABLE_RANGE:
if (version3[PRE] && version3[PRE].length === 0 && version3[PATCH] === 0 || version3[MAJOR] === 0 && version3[MINOR] === 0)
return version3[MAJOR] + "." + version3[MINOR];
return "~" + version3.toString();
case EXACT_RANGE:
return version3.toString();
case LOWER_BOUND:
return (this[BOUND_INCLUSIVE] ? ">=" : ">") + version3.toString();
case UPPER_BOUND:
return (this[BOUND_INCLUSIVE] ? "<=" : "<") + version3.toString();
case INTERSECTION_RANGE:
return this[RANGE_SET].map((r) => r.toString()).join(" ");
case UNION_RANGE:
return this[RANGE_SET].map((r) => r.toString()).join(" || ");
}
}
toJSON() {
return this.toString();
}
static match(range, version3, unstable = false) {
if (!(version3 instanceof Semver))
version3 = new Semver(version3);
return version3.matches(range, unstable);
}
static isValid(range) {
let semverRange = new SemverRange2(range);
if (semverRange[TYPE] === EXACT_RANGE)
return semverRange[VERSION][TAG] === void 0;
return true;
}
static compare(r1, r2) {
if (!(r1 instanceof SemverRange2))
r1 = new SemverRange2(r1);
if (!(r2 instanceof SemverRange2))
r2 = new SemverRange2(r2);
if (r1[TYPE] === WILDCARD_RANGE && r2[TYPE] === WILDCARD_RANGE)
return 0;
if (r1[TYPE] === WILDCARD_RANGE)
return 1;
if (r2[TYPE] === WILDCARD_RANGE)
return -1;
let u1 = effectiveUpperBound(r1);
let u2 = effectiveUpperBound(r2);
if (u1 === null && u2 === null) {
let v12 = effectiveVersion(r1);
let v22 = effectiveVersion(r2);
if (v12 && v22)
return Semver.compare(v12, v22);
return 0;
}
if (u1 === null)
return 1;
if (u2 === null)
return -1;
let cmp = Semver.compare(u1, u2);
if (cmp !== 0)
return cmp;
let v1 = effectiveVersion(r1);
let v2 = effectiveVersion(r2);
if (v1 && v2) {
cmp = Semver.compare(v1, v2);
if (cmp !== 0)
return cmp;
}
if (r1[TYPE] === r2[TYPE])
return 0;
return r1[TYPE] > r2[TYPE] ? 1 : -1;
}
};
exports.SemverRange = SemverRange2;
}
});
// ../node_modules/balanced-match/index.js
var require_balanced_match = __commonJS({
"../node_modules/balanced-match/index.js"(exports, module) {
"use strict";
module.exports = balanced;
function balanced(a, b, str) {
if (a instanceof RegExp)
a = maybeMatch(a, str);
if (b instanceof RegExp)
b = maybeMatch(b, str);
var r = range(a, b, str);
return r && {
start: r[0],
end: r[1],
pre: str.slice(0, r[0]),
body: str.slice(r[0] + a.length, r[1]),
post: str.slice(r[1] + b.length)
};
}
function maybeMatch(reg, str) {
var m = str.match(reg);
return m ? m[0] : null;
}
balanced.range = range;
function range(a, b, str) {
var begs, beg, left, right, result;
var ai = str.indexOf(a);
var bi = str.indexOf(b, ai + 1);
var i = ai;
if (ai >= 0 && bi > 0) {
if (a === b) {
return [ai, bi];
}
begs = [];
left = str.length;
while (i >= 0 && !result) {
if (i == ai) {
begs.push(i);
ai = str.indexOf(a, i + 1);
} else if (begs.length == 1) {
result = [begs.pop(), bi];
} else {
beg = begs.pop();
if (beg < left) {
left = beg;
right = bi;
}
bi = str.indexOf(b, i + 1);
}
i = ai < bi && ai >= 0 ? ai : bi;
}
if (begs.length) {
result = [left, right];
}
}
return result;
}
}
});
// node_modules/brace-expansion/index.js
var require_brace_expansion = __commonJS({
"node_modules/brace-expansion/index.js"(exports, module) {
var balanced = require_balanced_match();
module.exports = expandTop;
var escSlash = "\0SLASH" + Math.random() + "\0";
var escOpen = "\0OPEN" + Math.random() + "\0";
var escClose = "\0CLOSE" + Math.random() + "\0";
var escComma = "\0COMMA" + Math.random() + "\0";
var escPeriod = "\0PERIOD" + Math.random() + "\0";
function numeric(str) {
return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
}
function escapeBraces(str) {
return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
}
function unescapeBraces(str) {
return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
}
function parseCommaParts(str) {
if (!str)
return [""];
var parts = [];
var m = balanced("{", "}", str);
if (!m)
return str.split(",");
var pre = m.pre;
var body = m.body;
var post = m.post;
var p = pre.split(",");
p[p.length - 1] += "{" + body + "}";
var postParts = parseCommaParts(post);
if (post.length) {
p[p.length - 1] += postParts.shift();
p.push.apply(p, postParts);
}
parts.push.apply(parts, p);
return parts;
}
function expandTop(str) {
if (!str)
return [];
if (str.substr(0, 2) === "{}") {
str = "\\{\\}" + str.substr(2);
}
return expand2(escapeBraces(str), true).map(unescapeBraces);
}
function embrace(str) {
return "{" + str + "}";
}
function isPadded(el) {
return /^-?0\d/.test(el);
}
function lte(i, y) {
return i <= y;
}
function gte(i, y) {
return i >= y;
}
function expand2(str, isTop) {
var expansions = [];
var m = balanced("{", "}", str);
if (!m)
return [str];
var pre = m.pre;
var post = m.post.length ? expand2(m.post, false) : [""];
if (/\$$/.test(m.pre)) {
for (var k = 0; k < post.length; k++) {
var expansion = pre + "{" + m.body + "}" + post[k];
expansions.push(expansion);
}
} else {
var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
var isSequence = isNumericSequence || isAlphaSequence;
var isOptions = m.body.indexOf(",") >= 0;
if (!isSequence && !isOptions) {
if (m.post.match(/,.*\}/)) {
str = m.pre + "{" + m.body + escClose + m.post;
return expand2(str);
}
return [str];
}
var n2;
if (isSequence) {
n2 = m.body.split(/\.\./);
} else {
n2 = parseCommaParts(m.body);
if (n2.length === 1) {
n2 = expand2(n2[0], false).map(embrace);
if (n2.length === 1) {
return post.map(function(p) {
return m.pre + n2[0] + p;
});
}
}
}
var N;
if (isSequence) {
var x = numeric(n2[0]);
var y = numeric(n2[1]);
var width = Math.max(n2[0].length, n2[1].length);
var incr = n2.length == 3 ? Math.abs(numeric(n2[2])) : 1;
var test = lte;
var reverse = y < x;
if (reverse) {
incr *= -1;
test = gte;
}
var pad = n2.some(isPadded);
N = [];
for (var i = x; test(i, y); i += incr) {
var c17;
if (isAlphaSequence) {
c17 = String.fromCharCode(i);
if (c17 === "\\")
c17 = "";
} else {
c17 = String(i);
if (pad) {
var need = width - c17.length;
if (need > 0) {
var z = new Array(need + 1).join("0");
if (i < 0)
c17 = "-" + z + c17.slice(1);
else
c17 = z + c17;
}
}
}
N.push(c17);
}
} else {
N = [];
for (var j = 0; j < n2.length; j++) {
N.push.apply(N, expand2(n2[j], false));
}
}
for (var j = 0; j < N.length; j++) {
for (var k = 0; k < post.length; k++) {
var expansion = pre + N[j] + post[k];
if (!isTop || isSequence || expansion)
expansions.push(expansion);
}
}
}
return expansions;
}
}
});
// node_modules/minimatch/dist/esm/assert-valid-pattern.js
var MAX_PATTERN_LENGTH, assertValidPattern;
var init_assert_valid_pattern = __esm({
"node_modules/minimatch/dist/esm/assert-valid-pattern.js"() {
MAX_PATTERN_LENGTH = 1024 * 64;
assertValidPattern = (pattern) => {
if (typeof pattern !== "string") {
throw new TypeError("invalid pattern");
}
if (pattern.length > MAX_PATTERN_LENGTH) {
throw new TypeError("pattern is too long");
}
};
}
});
// node_modules/minimatch/dist/esm/brace-expressions.js
var posixClasses, braceEscape, regexpEscape, rangesToString, parseClass;
var init_brace_expressions = __esm({
"node_modules/minimatch/dist/esm/brace-expressions.js"() {
posixClasses = {
"[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
"[:alpha:]": ["\\p{L}\\p{Nl}", true],
"[:ascii:]": ["\\x00-\\x7f", false],
"[:blank:]": ["\\p{Zs}\\t", true],
"[:cntrl:]": ["\\p{Cc}", true],
"[:digit:]": ["\\p{Nd}", true],
"[:graph:]": ["\\p{Z}\\p{C}", true, true],
"[:lower:]": ["\\p{Ll}", true],
"[:print:]": ["\\p{C}", true],
"[:punct:]": ["\\p{P}", true],
"[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
"[:upper:]": ["\\p{Lu}", true],
"[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
"[:xdigit:]": ["A-Fa-f0-9", false]
};
braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
rangesToString = (ranges) => ranges.join("");
parseClass = (glob, position) => {
const pos = position;
if (glob.charAt(pos) !== "[") {
throw new Error("not in a brace expression");
}
const ranges = [];
const negs = [];
let i = pos + 1;
let sawStart = false;
let uflag = false;
let escaping = false;
let negate = false;
let endPos = pos;
let rangeStart = "";
WHILE:
while (i < glob.length) {
const c17 = glob.charAt(i);
if ((c17 === "!" || c17 === "^") && i === pos + 1) {
negate = true;
i++;
continue;
}
if (c17 === "]" && sawStart && !escaping) {
endPos = i + 1;
break;
}
sawStart = true;
if (c17 === "\\") {
if (!escaping) {
escaping = true;
i++;
continue;
}
}
if (c17 === "[" && !escaping) {
for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
if (glob.startsWith(cls, i)) {
if (rangeStart) {
return ["$.", false, glob.length - pos, true];
}
i += cls.length;
if (neg)
negs.push(unip);
else
ranges.push(unip);
uflag = uflag || u;
continue WHILE;
}
}
}
escaping = false;
if (rangeStart) {
if (c17 > rangeStart) {
ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c17));
} else if (c17 === rangeStart) {
ranges.push(braceEscape(c17));
}
rangeStart = "";
i++;
continue;
}
if (glob.startsWith("-]", i + 1)) {
ranges.push(braceEscape(c17 + "-"));
i += 2;
continue;
}
if (glob.startsWith("-", i + 1)) {
rangeStart = c17;
i += 2;
continue;
}
ranges.push(braceEscape(c17));
i++;
}
if (endPos < i) {
return ["", false, 0, false];
}
if (!ranges.length && !negs.length) {
return ["$.", false, glob.length - pos, true];
}
if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) {
const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
return [regexpEscape(r), false, endPos - pos, false];
}
const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
return [comb, uflag, endPos - pos, true];
};
}
});
// node_modules/minimatch/dist/esm/unescape.js
var unescape2;
var init_unescape = __esm({
"node_modules/minimatch/dist/esm/unescape.js"() {
unescape2 = (s, { windowsPathsNoEscape = false } = {}) => {
return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
};
}
});
// node_modules/minimatch/dist/esm/ast.js
var types, isExtglobType, startNoTraversal, startNoDot, addPatternStart, justDots, reSpecials, regExpEscape, qmark, star, starNoEmpty, _root, _hasMagic, _uflag, _parts, _parent, _parentIndex, _negs, _filledNegs, _options, _toString, _emptyExt, _fillNegs, fillNegs_fn, _parseAST, parseAST_fn, _partsToRegExp, partsToRegExp_fn, _parseGlob, parseGlob_fn, _AST, AST;
var init_ast = __esm({
"node_modules/minimatch/dist/esm/ast.js"() {
init_brace_expressions();
init_unescape();
types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
isExtglobType = (c17) => types.has(c17);
startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
startNoDot = "(?!\\.)";
addPatternStart = /* @__PURE__ */ new Set(["[", "."]);
justDots = /* @__PURE__ */ new Set(["..", "."]);
reSpecials = new Set("().*{}+?[]^$\\!");
regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
qmark = "[^/]";
star = qmark + "*?";
starNoEmpty = qmark + "+?";
_AST = class {
constructor(type, parent, options = {}) {
__privateAdd(this, _fillNegs);
__privateAdd(this, _partsToRegExp);
__publicField(this, "type");
__privateAdd(this, _root, void 0);
__privateAdd(this, _hasMagic, void 0);
__privateAdd(this, _uflag, false);
__privateAdd(this, _parts, []);
__privateAdd(this, _parent, void 0);
__privateAdd(this, _parentIndex, void 0);
__privateAdd(this, _negs, void 0);
__privateAdd(this, _filledNegs, false);
__privateAdd(this, _options, void 0);
__privateAdd(this, _toString, void 0);
// set to true if it's an extglob with no children
// (which really means one child of '')
__privateAdd(this, _emptyExt, false);
this.type = type;
if (type)
__privateSet(this, _hasMagic, true);
__privateSet(this, _parent, parent);
__privateSet(this, _root, __privateGet(this, _parent) ? __privateGet(__privateGet(this, _parent), _root) : this);
__privateSet(this, _options, __privateGet(this, _root) === this ? options : __privateGet(__privateGet(this, _root), _options));
__privateSet(this, _negs, __privateGet(this, _root) === this ? [] : __privateGet(__privateGet(this, _root), _negs));
if (type === "!" && !__privateGet(__privateGet(this, _root), _filledNegs))
__privateGet(this, _negs).push(this);
__privateSet(this, _parentIndex, __privateGet(this, _parent) ? __privateGet(__privateGet(this, _parent), _parts).length : 0);
}
get hasMagic() {
if (__privateGet(this, _hasMagic) !== void 0)
return __privateGet(this, _hasMagic);
for (const p of __privateGet(this, _parts)) {
if (typeof p === "string")
continue;
if (p.type || p.hasMagic)
return __privateSet(this, _hasMagic, true);
}
return __privateGet(this, _hasMagic);
}
// reconstructs the pattern
toString() {
if (__privateGet(this, _toString) !== void 0)
return __privateGet(this, _toString);
if (!this.type) {
return __privateSet(this, _toString, __privateGet(this, _parts).map((p) => String(p)).join(""));
} else {
return __privateSet(this, _toString, this.type + "(" + __privateGet(this, _parts).map((p) => String(p)).join("|") + ")");
}
}
push(...parts) {
for (const p of parts) {
if (p === "")
continue;
if (typeof p !== "string" && !(p instanceof _AST && __privateGet(p, _parent) === this)) {
throw new Error("invalid part: " + p);
}
__privateGet(this, _parts).push(p);
}
}
toJSON() {
const ret = this.type === null ? __privateGet(this, _parts).slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...__privateGet(this, _parts).map((p) => p.toJSON())];
if (this.isStart() && !this.type)
ret.unshift([]);
if (this.isEnd() && (this === __privateGet(this, _root) || __privateGet(__privateGet(this, _root), _filledNegs) && __privateGet(this, _parent)?.type === "!")) {
ret.push({});
}
return ret;
}
isStart() {
if (__privateGet(this, _root) === this)
return true;
if (!__privateGet(this, _parent)?.isStart())
return false;
if (__privateGet(this, _parentIndex) === 0)
return true;
const p = __privateGet(this, _parent);
for (let i = 0; i < __privateGet(this, _parentIndex); i++) {
const pp2 = __privateGet(p, _parts)[i];
if (!(pp2 instanceof _AST && pp2.type === "!")) {
return false;
}
}
return true;
}
isEnd() {
if (__privateGet(this, _root) === this)
return true;
if (__privateGet(this, _parent)?.type === "!")
return true;
if (!__privateGet(this, _parent)?.isEnd())
return false;
if (!this.type)
return __privateGet(this, _parent)?.isEnd();
const pl = __privateGet(this, _parent) ? __privateGet(__privateGet(this, _parent), _parts).length : 0;
return __privateGet(this, _parentIndex) === pl - 1;
}
copyIn(part) {
if (typeof part === "string")
this.push(part);
else
this.push(part.clone(this));
}
clone(parent) {
const c17 = new _AST(this.type, parent);
for (const p of __privateGet(this, _parts)) {
c17.copyIn(p);
}
return c17;
}
static fromGlob(pattern, options = {}) {
var _a;
const ast = new _AST(null, void 0, options);
__privateMethod(_a = _AST, _parseAST, parseAST_fn).call(_a, pattern, ast, 0, options);
return ast;
}
// returns the regular expression if there's magic, or the unescaped
// string if not.
toMMPattern() {
if (this !== __privateGet(this, _root))
return __privateGet(this, _root).toMMPattern();
const glob = this.toString();
const [re, body, hasMagic, uflag] = this.toRegExpSource();
const anyMagic = hasMagic || __privateGet(this, _hasMagic) || __privateGet(this, _options).nocase && !__privateGet(this, _options).nocaseMagicOnly && glob.toUpperCase() !== glob.toLowerCase();
if (!anyMagic) {
return body;
}
const flags = (__privateGet(this, _options).nocase ? "i" : "") + (uflag ? "u" : "");
return Object.assign(new RegExp(`^${re}$`, flags), {
_src: re,
_glob: glob
});
}
get options() {
return __privateGet(this, _options);
}
// returns the string match, the regexp source, whether there's magic
// in the regexp (so a regular expression is required) and whether or
// not the uflag is needed for the regular expression (for posix classes)
// TODO: instead of injecting the start/end at this point, just return
// the BODY of the regexp, along with the start/end portions suitable
// for binding the start/end in either a joined full-path makeRe context
// (where we bind to (^|/), or a standalone matchPart context (where
// we bind to ^, and not /). Otherwise slashes get duped!
//
// In part-matching mode, the start is:
// - if not isStart: nothing
// - if traversal possible, but not allowed: ^(?!\.\.?$)
// - if dots allowed or not possible: ^
// - if dots possible and not allowed: ^(?!\.)
// end is:
// - if not isEnd(): nothing
// - else: $
//
// In full-path matching mode, we put the slash at the START of the
// pattern, so start is:
// - if first pattern: same as part-matching mode
// - if not isStart(): nothing
// - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
// - if dots allowed or not possible: /