430 lines
15 KiB
JavaScript
430 lines
15 KiB
JavaScript
"use strict";
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
var chunk_M5T7GI2R_exports = {};
|
|
__export(chunk_M5T7GI2R_exports, {
|
|
link: () => link2
|
|
});
|
|
module.exports = __toCommonJS(chunk_M5T7GI2R_exports);
|
|
var import_chunk_YVXCXD3A = require("./chunk-YVXCXD3A.js");
|
|
var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");
|
|
var import_node_process = __toESM(require("node:process"));
|
|
var require_has_flag = (0, import_chunk_2ESYSVXG.__commonJS)({
|
|
"../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js"(exports, module2) {
|
|
"use strict";
|
|
module2.exports = (flag, argv = process.argv) => {
|
|
const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
|
|
const position = argv.indexOf(prefix + flag);
|
|
const terminatorPosition = argv.indexOf("--");
|
|
return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
|
|
};
|
|
}
|
|
});
|
|
var require_supports_color = (0, import_chunk_2ESYSVXG.__commonJS)({
|
|
"../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports, module2) {
|
|
"use strict";
|
|
var os = (0, import_chunk_2ESYSVXG.__require)("os");
|
|
var tty = (0, import_chunk_2ESYSVXG.__require)("tty");
|
|
var hasFlag = require_has_flag();
|
|
var { env } = process;
|
|
var forceColor;
|
|
if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
|
|
forceColor = 0;
|
|
} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
|
|
forceColor = 1;
|
|
}
|
|
if ("FORCE_COLOR" in env) {
|
|
if (env.FORCE_COLOR === "true") {
|
|
forceColor = 1;
|
|
} else if (env.FORCE_COLOR === "false") {
|
|
forceColor = 0;
|
|
} else {
|
|
forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
|
|
}
|
|
}
|
|
function translateLevel(level) {
|
|
if (level === 0) {
|
|
return false;
|
|
}
|
|
return {
|
|
level,
|
|
hasBasic: true,
|
|
has256: level >= 2,
|
|
has16m: level >= 3
|
|
};
|
|
}
|
|
function supportsColor(haveStream, streamIsTTY) {
|
|
if (forceColor === 0) {
|
|
return 0;
|
|
}
|
|
if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
|
|
return 3;
|
|
}
|
|
if (hasFlag("color=256")) {
|
|
return 2;
|
|
}
|
|
if (haveStream && !streamIsTTY && forceColor === void 0) {
|
|
return 0;
|
|
}
|
|
const min = forceColor || 0;
|
|
if (env.TERM === "dumb") {
|
|
return min;
|
|
}
|
|
if (process.platform === "win32") {
|
|
const osRelease = os.release().split(".");
|
|
if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
|
|
return Number(osRelease[2]) >= 14931 ? 3 : 2;
|
|
}
|
|
return 1;
|
|
}
|
|
if ("CI" in env) {
|
|
if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
|
|
return 1;
|
|
}
|
|
return min;
|
|
}
|
|
if ("TEAMCITY_VERSION" in env) {
|
|
return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
|
|
}
|
|
if (env.COLORTERM === "truecolor") {
|
|
return 3;
|
|
}
|
|
if ("TERM_PROGRAM" in env) {
|
|
const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
|
|
switch (env.TERM_PROGRAM) {
|
|
case "iTerm.app":
|
|
return version >= 3 ? 3 : 2;
|
|
case "Apple_Terminal":
|
|
return 2;
|
|
}
|
|
}
|
|
if (/-256(color)?$/i.test(env.TERM)) {
|
|
return 2;
|
|
}
|
|
if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
|
|
return 1;
|
|
}
|
|
if ("COLORTERM" in env) {
|
|
return 1;
|
|
}
|
|
return min;
|
|
}
|
|
function getSupportLevel(stream) {
|
|
const level = supportsColor(stream, stream && stream.isTTY);
|
|
return translateLevel(level);
|
|
}
|
|
module2.exports = {
|
|
supportsColor: getSupportLevel,
|
|
stdout: translateLevel(supportsColor(true, tty.isatty(1))),
|
|
stderr: translateLevel(supportsColor(true, tty.isatty(2)))
|
|
};
|
|
}
|
|
});
|
|
var require_supports_hyperlinks = (0, import_chunk_2ESYSVXG.__commonJS)({
|
|
"../../node_modules/.pnpm/supports-hyperlinks@3.2.0/node_modules/supports-hyperlinks/index.js"(exports, module2) {
|
|
"use strict";
|
|
var supportsColor = require_supports_color();
|
|
var hasFlag = require_has_flag();
|
|
function parseVersion(versionString) {
|
|
if (/^\d{3,4}$/.test(versionString)) {
|
|
const m = /(\d{1,2})(\d{2})/.exec(versionString) || [];
|
|
return {
|
|
major: 0,
|
|
minor: parseInt(m[1], 10),
|
|
patch: parseInt(m[2], 10)
|
|
};
|
|
}
|
|
const versions = (versionString || "").split(".").map((n) => parseInt(n, 10));
|
|
return {
|
|
major: versions[0],
|
|
minor: versions[1],
|
|
patch: versions[2]
|
|
};
|
|
}
|
|
function supportsHyperlink(stream) {
|
|
const {
|
|
CI,
|
|
FORCE_HYPERLINK,
|
|
NETLIFY,
|
|
TEAMCITY_VERSION,
|
|
TERM_PROGRAM,
|
|
TERM_PROGRAM_VERSION,
|
|
VTE_VERSION,
|
|
TERM
|
|
} = process.env;
|
|
if (FORCE_HYPERLINK) {
|
|
return !(FORCE_HYPERLINK.length > 0 && parseInt(FORCE_HYPERLINK, 10) === 0);
|
|
}
|
|
if (hasFlag("no-hyperlink") || hasFlag("no-hyperlinks") || hasFlag("hyperlink=false") || hasFlag("hyperlink=never")) {
|
|
return false;
|
|
}
|
|
if (hasFlag("hyperlink=true") || hasFlag("hyperlink=always")) {
|
|
return true;
|
|
}
|
|
if (NETLIFY) {
|
|
return true;
|
|
}
|
|
if (!supportsColor.supportsColor(stream)) {
|
|
return false;
|
|
}
|
|
if (stream && !stream.isTTY) {
|
|
return false;
|
|
}
|
|
if ("WT_SESSION" in process.env) {
|
|
return true;
|
|
}
|
|
if (process.platform === "win32") {
|
|
return false;
|
|
}
|
|
if (CI) {
|
|
return false;
|
|
}
|
|
if (TEAMCITY_VERSION) {
|
|
return false;
|
|
}
|
|
if (TERM_PROGRAM) {
|
|
const version = parseVersion(TERM_PROGRAM_VERSION || "");
|
|
switch (TERM_PROGRAM) {
|
|
case "iTerm.app":
|
|
if (version.major === 3) {
|
|
return version.minor >= 1;
|
|
}
|
|
return version.major > 3;
|
|
case "WezTerm":
|
|
return version.major >= 20200620;
|
|
case "vscode":
|
|
return version.major > 1 || version.major === 1 && version.minor >= 72;
|
|
case "ghostty":
|
|
return true;
|
|
}
|
|
}
|
|
if (VTE_VERSION) {
|
|
if (VTE_VERSION === "0.50.0") {
|
|
return false;
|
|
}
|
|
const version = parseVersion(VTE_VERSION);
|
|
return version.major > 0 || version.minor >= 50;
|
|
}
|
|
switch (TERM) {
|
|
case "alacritty":
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
module2.exports = {
|
|
supportsHyperlink,
|
|
stdout: supportsHyperlink(process.stdout),
|
|
stderr: supportsHyperlink(process.stderr)
|
|
};
|
|
}
|
|
});
|
|
var base_exports = {};
|
|
(0, import_chunk_2ESYSVXG.__export)(base_exports, {
|
|
beep: () => beep,
|
|
clearScreen: () => clearScreen,
|
|
clearTerminal: () => clearTerminal,
|
|
cursorBackward: () => cursorBackward,
|
|
cursorDown: () => cursorDown,
|
|
cursorForward: () => cursorForward,
|
|
cursorGetPosition: () => cursorGetPosition,
|
|
cursorHide: () => cursorHide,
|
|
cursorLeft: () => cursorLeft,
|
|
cursorMove: () => cursorMove,
|
|
cursorNextLine: () => cursorNextLine,
|
|
cursorPrevLine: () => cursorPrevLine,
|
|
cursorRestorePosition: () => cursorRestorePosition,
|
|
cursorSavePosition: () => cursorSavePosition,
|
|
cursorShow: () => cursorShow,
|
|
cursorTo: () => cursorTo,
|
|
cursorUp: () => cursorUp,
|
|
enterAlternativeScreen: () => enterAlternativeScreen,
|
|
eraseDown: () => eraseDown,
|
|
eraseEndLine: () => eraseEndLine,
|
|
eraseLine: () => eraseLine,
|
|
eraseLines: () => eraseLines,
|
|
eraseScreen: () => eraseScreen,
|
|
eraseStartLine: () => eraseStartLine,
|
|
eraseUp: () => eraseUp,
|
|
exitAlternativeScreen: () => exitAlternativeScreen,
|
|
iTerm: () => iTerm,
|
|
image: () => image,
|
|
link: () => link,
|
|
scrollDown: () => scrollDown,
|
|
scrollUp: () => scrollUp
|
|
});
|
|
var isBrowser = globalThis.window?.document !== void 0;
|
|
var isNode = globalThis.process?.versions?.node !== void 0;
|
|
var isBun = globalThis.process?.versions?.bun !== void 0;
|
|
var isDeno = globalThis.Deno?.version?.deno !== void 0;
|
|
var isElectron = globalThis.process?.versions?.electron !== void 0;
|
|
var isJsDom = globalThis.navigator?.userAgent?.includes("jsdom") === true;
|
|
var isWebWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
|
|
var isDedicatedWorker = typeof DedicatedWorkerGlobalScope !== "undefined" && globalThis instanceof DedicatedWorkerGlobalScope;
|
|
var isSharedWorker = typeof SharedWorkerGlobalScope !== "undefined" && globalThis instanceof SharedWorkerGlobalScope;
|
|
var isServiceWorker = typeof ServiceWorkerGlobalScope !== "undefined" && globalThis instanceof ServiceWorkerGlobalScope;
|
|
var platform = globalThis.navigator?.userAgentData?.platform;
|
|
var isMacOs = platform === "macOS" || globalThis.navigator?.platform === "MacIntel" || globalThis.navigator?.userAgent?.includes(" Mac ") === true || globalThis.process?.platform === "darwin";
|
|
var isWindows = platform === "Windows" || globalThis.navigator?.platform === "Win32" || globalThis.process?.platform === "win32";
|
|
var isLinux = platform === "Linux" || globalThis.navigator?.platform?.startsWith("Linux") === true || globalThis.navigator?.userAgent?.includes(" Linux ") === true || globalThis.process?.platform === "linux";
|
|
var isIos = platform === "iOS" || globalThis.navigator?.platform === "MacIntel" && globalThis.navigator?.maxTouchPoints > 1 || /iPad|iPhone|iPod/.test(globalThis.navigator?.platform);
|
|
var isAndroid = platform === "Android" || globalThis.navigator?.platform === "Android" || globalThis.navigator?.userAgent?.includes(" Android ") === true || globalThis.process?.platform === "android";
|
|
var ESC = "\x1B[";
|
|
var OSC = "\x1B]";
|
|
var BEL = "\x07";
|
|
var SEP = ";";
|
|
var isTerminalApp = !isBrowser && import_node_process.default.env.TERM_PROGRAM === "Apple_Terminal";
|
|
var isWindows2 = !isBrowser && import_node_process.default.platform === "win32";
|
|
var cwdFunction = isBrowser ? () => {
|
|
throw new Error("`process.cwd()` only works in Node.js, not the browser.");
|
|
} : import_node_process.default.cwd;
|
|
var cursorTo = (x, y) => {
|
|
if (typeof x !== "number") {
|
|
throw new TypeError("The `x` argument is required");
|
|
}
|
|
if (typeof y !== "number") {
|
|
return ESC + (x + 1) + "G";
|
|
}
|
|
return ESC + (y + 1) + SEP + (x + 1) + "H";
|
|
};
|
|
var cursorMove = (x, y) => {
|
|
if (typeof x !== "number") {
|
|
throw new TypeError("The `x` argument is required");
|
|
}
|
|
let returnValue = "";
|
|
if (x < 0) {
|
|
returnValue += ESC + -x + "D";
|
|
} else if (x > 0) {
|
|
returnValue += ESC + x + "C";
|
|
}
|
|
if (y < 0) {
|
|
returnValue += ESC + -y + "A";
|
|
} else if (y > 0) {
|
|
returnValue += ESC + y + "B";
|
|
}
|
|
return returnValue;
|
|
};
|
|
var cursorUp = (count = 1) => ESC + count + "A";
|
|
var cursorDown = (count = 1) => ESC + count + "B";
|
|
var cursorForward = (count = 1) => ESC + count + "C";
|
|
var cursorBackward = (count = 1) => ESC + count + "D";
|
|
var cursorLeft = ESC + "G";
|
|
var cursorSavePosition = isTerminalApp ? "\x1B7" : ESC + "s";
|
|
var cursorRestorePosition = isTerminalApp ? "\x1B8" : ESC + "u";
|
|
var cursorGetPosition = ESC + "6n";
|
|
var cursorNextLine = ESC + "E";
|
|
var cursorPrevLine = ESC + "F";
|
|
var cursorHide = ESC + "?25l";
|
|
var cursorShow = ESC + "?25h";
|
|
var eraseLines = (count) => {
|
|
let clear = "";
|
|
for (let i = 0; i < count; i++) {
|
|
clear += eraseLine + (i < count - 1 ? cursorUp() : "");
|
|
}
|
|
if (count) {
|
|
clear += cursorLeft;
|
|
}
|
|
return clear;
|
|
};
|
|
var eraseEndLine = ESC + "K";
|
|
var eraseStartLine = ESC + "1K";
|
|
var eraseLine = ESC + "2K";
|
|
var eraseDown = ESC + "J";
|
|
var eraseUp = ESC + "1J";
|
|
var eraseScreen = ESC + "2J";
|
|
var scrollUp = ESC + "S";
|
|
var scrollDown = ESC + "T";
|
|
var clearScreen = "\x1Bc";
|
|
var clearTerminal = isWindows2 ? `${eraseScreen}${ESC}0f` : `${eraseScreen}${ESC}3J${ESC}H`;
|
|
var enterAlternativeScreen = ESC + "?1049h";
|
|
var exitAlternativeScreen = ESC + "?1049l";
|
|
var beep = BEL;
|
|
var link = (text, url) => [
|
|
OSC,
|
|
"8",
|
|
SEP,
|
|
SEP,
|
|
url,
|
|
BEL,
|
|
text,
|
|
OSC,
|
|
"8",
|
|
SEP,
|
|
SEP,
|
|
BEL
|
|
].join("");
|
|
var image = (data, options = {}) => {
|
|
let returnValue = `${OSC}1337;File=inline=1`;
|
|
if (options.width) {
|
|
returnValue += `;width=${options.width}`;
|
|
}
|
|
if (options.height) {
|
|
returnValue += `;height=${options.height}`;
|
|
}
|
|
if (options.preserveAspectRatio === false) {
|
|
returnValue += ";preserveAspectRatio=0";
|
|
}
|
|
return returnValue + ":" + Buffer.from(data).toString("base64") + BEL;
|
|
};
|
|
var iTerm = {
|
|
setCwd: (cwd = cwdFunction()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
|
|
annotation(message, options = {}) {
|
|
let returnValue = `${OSC}1337;`;
|
|
const hasX = options.x !== void 0;
|
|
const hasY = options.y !== void 0;
|
|
if ((hasX || hasY) && !(hasX && hasY && options.length !== void 0)) {
|
|
throw new Error("`x`, `y` and `length` must be defined when `x` or `y` is defined");
|
|
}
|
|
message = message.replaceAll("|", "");
|
|
returnValue += options.isHidden ? "AddHiddenAnnotation=" : "AddAnnotation=";
|
|
if (options.length > 0) {
|
|
returnValue += (hasX ? [message, options.length, options.x, options.y] : [options.length, message]).join("|");
|
|
} else {
|
|
returnValue += message;
|
|
}
|
|
return returnValue + BEL;
|
|
}
|
|
};
|
|
var import_supports_hyperlinks = (0, import_chunk_2ESYSVXG.__toESM)(require_supports_hyperlinks(), 1);
|
|
function terminalLink(text, url, { target = "stdout", ...options } = {}) {
|
|
if (!import_supports_hyperlinks.default[target]) {
|
|
if (options.fallback === false) {
|
|
return text;
|
|
}
|
|
return typeof options.fallback === "function" ? options.fallback(text, url) : `${text} (\u200B${url}\u200B)`;
|
|
}
|
|
return base_exports.link(text, url);
|
|
}
|
|
terminalLink.isSupported = import_supports_hyperlinks.default.stdout;
|
|
terminalLink.stderr = (text, url, options = {}) => terminalLink(text, url, { target: "stderr", ...options });
|
|
terminalLink.stderr.isSupported = import_supports_hyperlinks.default.stderr;
|
|
function link2(url) {
|
|
return terminalLink(url, url, {
|
|
fallback: import_chunk_YVXCXD3A.underline
|
|
});
|
|
}
|