vite-plugin-lxr
Version:
Vite plugin for developing LeanIX Custom Reports
1,527 lines (1,515 loc) • 1.02 MB
JavaScript
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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __require = /* @__PURE__ */ ((x2) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x2, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x2)(function(x2) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x2 + '" 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 name2 in all)
__defProp(target, name2, { get: all[name2], enumerable: true });
};
var __copyProps = (to, from, except, desc2) => {
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: !(desc2 = __getOwnPropDesc(from, key)) || desc2.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
));
// ../../node_modules/ms/index.js
var require_ms = __commonJS({
"../../node_modules/ms/index.js"(exports, module) {
"use strict";
var s2 = 1e3;
var m2 = s2 * 60;
var h2 = m2 * 60;
var d = h2 * 24;
var w = d * 7;
var y = d * 365.25;
module.exports = function(val, options) {
options = options || {};
var type = typeof val;
if (type === "string" && val.length > 0) {
return parse6(val);
} else if (type === "number" && isFinite(val)) {
return options.long ? fmtLong(val) : fmtShort(val);
}
throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
};
function parse6(str) {
str = String(str);
if (str.length > 100) {
return;
}
var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
if (!match) {
return;
}
var n = parseFloat(match[1]);
var type = (match[2] || "ms").toLowerCase();
switch (type) {
case "years":
case "year":
case "yrs":
case "yr":
case "y":
return n * y;
case "weeks":
case "week":
case "w":
return n * w;
case "days":
case "day":
case "d":
return n * d;
case "hours":
case "hour":
case "hrs":
case "hr":
case "h":
return n * h2;
case "minutes":
case "minute":
case "mins":
case "min":
case "m":
return n * m2;
case "seconds":
case "second":
case "secs":
case "sec":
case "s":
return n * s2;
case "milliseconds":
case "millisecond":
case "msecs":
case "msec":
case "ms":
return n;
default:
return void 0;
}
}
__name(parse6, "parse");
function fmtShort(ms) {
var msAbs = Math.abs(ms);
if (msAbs >= d) {
return Math.round(ms / d) + "d";
}
if (msAbs >= h2) {
return Math.round(ms / h2) + "h";
}
if (msAbs >= m2) {
return Math.round(ms / m2) + "m";
}
if (msAbs >= s2) {
return Math.round(ms / s2) + "s";
}
return ms + "ms";
}
__name(fmtShort, "fmtShort");
function fmtLong(ms) {
var msAbs = Math.abs(ms);
if (msAbs >= d) {
return plural(ms, msAbs, d, "day");
}
if (msAbs >= h2) {
return plural(ms, msAbs, h2, "hour");
}
if (msAbs >= m2) {
return plural(ms, msAbs, m2, "minute");
}
if (msAbs >= s2) {
return plural(ms, msAbs, s2, "second");
}
return ms + " ms";
}
__name(fmtLong, "fmtLong");
function plural(ms, msAbs, n, name2) {
var isPlural = msAbs >= n * 1.5;
return Math.round(ms / n) + " " + name2 + (isPlural ? "s" : "");
}
__name(plural, "plural");
}
});
// ../../node_modules/debug/src/common.js
var require_common = __commonJS({
"../../node_modules/debug/src/common.js"(exports, module) {
"use strict";
function setup(env) {
createDebug.debug = createDebug;
createDebug.default = createDebug;
createDebug.coerce = coerce;
createDebug.disable = disable;
createDebug.enable = enable;
createDebug.enabled = enabled;
createDebug.humanize = require_ms();
createDebug.destroy = destroy;
Object.keys(env).forEach((key) => {
createDebug[key] = env[key];
});
createDebug.names = [];
createDebug.skips = [];
createDebug.formatters = {};
function selectColor(namespace) {
let hash2 = 0;
for (let i2 = 0; i2 < namespace.length; i2++) {
hash2 = (hash2 << 5) - hash2 + namespace.charCodeAt(i2);
hash2 |= 0;
}
return createDebug.colors[Math.abs(hash2) % createDebug.colors.length];
}
__name(selectColor, "selectColor");
createDebug.selectColor = selectColor;
function createDebug(namespace) {
let prevTime;
let enableOverride = null;
let namespacesCache;
let enabledCache;
function debug(...args) {
if (!debug.enabled) {
return;
}
const self2 = debug;
const curr = Number(/* @__PURE__ */ new Date());
const ms = curr - (prevTime || curr);
self2.diff = ms;
self2.prev = prevTime;
self2.curr = curr;
prevTime = curr;
args[0] = createDebug.coerce(args[0]);
if (typeof args[0] !== "string") {
args.unshift("%O");
}
let index = 0;
args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
if (match === "%%") {
return "%";
}
index++;
const formatter = createDebug.formatters[format];
if (typeof formatter === "function") {
const val = args[index];
match = formatter.call(self2, val);
args.splice(index, 1);
index--;
}
return match;
});
createDebug.formatArgs.call(self2, args);
const logFn = self2.log || createDebug.log;
logFn.apply(self2, args);
}
__name(debug, "debug");
debug.namespace = namespace;
debug.useColors = createDebug.useColors();
debug.color = createDebug.selectColor(namespace);
debug.extend = extend2;
debug.destroy = createDebug.destroy;
Object.defineProperty(debug, "enabled", {
enumerable: true,
configurable: false,
get: /* @__PURE__ */ __name(() => {
if (enableOverride !== null) {
return enableOverride;
}
if (namespacesCache !== createDebug.namespaces) {
namespacesCache = createDebug.namespaces;
enabledCache = createDebug.enabled(namespace);
}
return enabledCache;
}, "get"),
set: /* @__PURE__ */ __name((v) => {
enableOverride = v;
}, "set")
});
if (typeof createDebug.init === "function") {
createDebug.init(debug);
}
return debug;
}
__name(createDebug, "createDebug");
function extend2(namespace, delimiter) {
const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
newDebug.log = this.log;
return newDebug;
}
__name(extend2, "extend");
function enable(namespaces) {
createDebug.save(namespaces);
createDebug.namespaces = namespaces;
createDebug.names = [];
createDebug.skips = [];
const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
for (const ns of split) {
if (ns[0] === "-") {
createDebug.skips.push(ns.slice(1));
} else {
createDebug.names.push(ns);
}
}
}
__name(enable, "enable");
function matchesTemplate(search, template) {
let searchIndex = 0;
let templateIndex = 0;
let starIndex = -1;
let matchIndex = 0;
while (searchIndex < search.length) {
if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
if (template[templateIndex] === "*") {
starIndex = templateIndex;
matchIndex = searchIndex;
templateIndex++;
} else {
searchIndex++;
templateIndex++;
}
} else if (starIndex !== -1) {
templateIndex = starIndex + 1;
matchIndex++;
searchIndex = matchIndex;
} else {
return false;
}
}
while (templateIndex < template.length && template[templateIndex] === "*") {
templateIndex++;
}
return templateIndex === template.length;
}
__name(matchesTemplate, "matchesTemplate");
function disable() {
const namespaces = [
...createDebug.names,
...createDebug.skips.map((namespace) => "-" + namespace)
].join(",");
createDebug.enable("");
return namespaces;
}
__name(disable, "disable");
function enabled(name2) {
for (const skip of createDebug.skips) {
if (matchesTemplate(name2, skip)) {
return false;
}
}
for (const ns of createDebug.names) {
if (matchesTemplate(name2, ns)) {
return true;
}
}
return false;
}
__name(enabled, "enabled");
function coerce(val) {
if (val instanceof Error) {
return val.stack || val.message;
}
return val;
}
__name(coerce, "coerce");
function destroy() {
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
}
__name(destroy, "destroy");
createDebug.enable(createDebug.load());
return createDebug;
}
__name(setup, "setup");
module.exports = setup;
}
});
// ../../node_modules/debug/src/browser.js
var require_browser = __commonJS({
"../../node_modules/debug/src/browser.js"(exports, module) {
"use strict";
exports.formatArgs = formatArgs;
exports.save = save;
exports.load = load;
exports.useColors = useColors;
exports.storage = localstorage();
exports.destroy = /* @__PURE__ */ (() => {
let warned = false;
return () => {
if (!warned) {
warned = true;
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
}
};
})();
exports.colors = [
"#0000CC",
"#0000FF",
"#0033CC",
"#0033FF",
"#0066CC",
"#0066FF",
"#0099CC",
"#0099FF",
"#00CC00",
"#00CC33",
"#00CC66",
"#00CC99",
"#00CCCC",
"#00CCFF",
"#3300CC",
"#3300FF",
"#3333CC",
"#3333FF",
"#3366CC",
"#3366FF",
"#3399CC",
"#3399FF",
"#33CC00",
"#33CC33",
"#33CC66",
"#33CC99",
"#33CCCC",
"#33CCFF",
"#6600CC",
"#6600FF",
"#6633CC",
"#6633FF",
"#66CC00",
"#66CC33",
"#9900CC",
"#9900FF",
"#9933CC",
"#9933FF",
"#99CC00",
"#99CC33",
"#CC0000",
"#CC0033",
"#CC0066",
"#CC0099",
"#CC00CC",
"#CC00FF",
"#CC3300",
"#CC3333",
"#CC3366",
"#CC3399",
"#CC33CC",
"#CC33FF",
"#CC6600",
"#CC6633",
"#CC9900",
"#CC9933",
"#CCCC00",
"#CCCC33",
"#FF0000",
"#FF0033",
"#FF0066",
"#FF0099",
"#FF00CC",
"#FF00FF",
"#FF3300",
"#FF3333",
"#FF3366",
"#FF3399",
"#FF33CC",
"#FF33FF",
"#FF6600",
"#FF6633",
"#FF9900",
"#FF9933",
"#FFCC00",
"#FFCC33"
];
function useColors() {
if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
return true;
}
if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
return false;
}
let m2;
return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
typeof navigator !== "undefined" && navigator.userAgent && (m2 = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m2[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
}
__name(useColors, "useColors");
function formatArgs(args) {
args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
if (!this.useColors) {
return;
}
const c = "color: " + this.color;
args.splice(1, 0, c, "color: inherit");
let index = 0;
let lastC = 0;
args[0].replace(/%[a-zA-Z%]/g, (match) => {
if (match === "%%") {
return;
}
index++;
if (match === "%c") {
lastC = index;
}
});
args.splice(lastC, 0, c);
}
__name(formatArgs, "formatArgs");
exports.log = console.debug || console.log || (() => {
});
function save(namespaces) {
try {
if (namespaces) {
exports.storage.setItem("debug", namespaces);
} else {
exports.storage.removeItem("debug");
}
} catch (error46) {
}
}
__name(save, "save");
function load() {
let r2;
try {
r2 = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
} catch (error46) {
}
if (!r2 && typeof process !== "undefined" && "env" in process) {
r2 = process.env.DEBUG;
}
return r2;
}
__name(load, "load");
function localstorage() {
try {
return localStorage;
} catch (error46) {
}
}
__name(localstorage, "localstorage");
module.exports = require_common()(exports);
var { formatters } = module.exports;
formatters.j = function(v) {
try {
return JSON.stringify(v);
} catch (error46) {
return "[UnexpectedJSONParseError]: " + error46.message;
}
};
}
});
// ../../node_modules/has-flag/index.js
var require_has_flag = __commonJS({
"../../node_modules/has-flag/index.js"(exports, module) {
"use strict";
module.exports = (flag, argv = process.argv) => {
const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
const position = argv.indexOf(prefix + flag);
const terminatorPosition = argv.indexOf("--");
return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
};
}
});
// ../../node_modules/supports-color/index.js
var require_supports_color = __commonJS({
"../../node_modules/supports-color/index.js"(exports, module) {
"use strict";
var os = __require("os");
var tty = __require("tty");
var hasFlag = require_has_flag();
var { env } = process;
var forceColor;
if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
forceColor = 0;
} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
forceColor = 1;
}
if ("FORCE_COLOR" in env) {
if (env.FORCE_COLOR === "true") {
forceColor = 1;
} else if (env.FORCE_COLOR === "false") {
forceColor = 0;
} else {
forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
}
}
function translateLevel(level) {
if (level === 0) {
return false;
}
return {
level,
hasBasic: true,
has256: level >= 2,
has16m: level >= 3
};
}
__name(translateLevel, "translateLevel");
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 version2 = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
switch (env.TERM_PROGRAM) {
case "iTerm.app":
return version2 >= 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;
}
__name(supportsColor, "supportsColor");
function getSupportLevel(stream) {
const level = supportsColor(stream, stream && stream.isTTY);
return translateLevel(level);
}
__name(getSupportLevel, "getSupportLevel");
module.exports = {
supportsColor: getSupportLevel,
stdout: translateLevel(supportsColor(true, tty.isatty(1))),
stderr: translateLevel(supportsColor(true, tty.isatty(2)))
};
}
});
// ../../node_modules/debug/src/node.js
var require_node = __commonJS({
"../../node_modules/debug/src/node.js"(exports, module) {
"use strict";
var tty = __require("tty");
var util = __require("util");
exports.init = init;
exports.log = log;
exports.formatArgs = formatArgs;
exports.save = save;
exports.load = load;
exports.useColors = useColors;
exports.destroy = util.deprecate(() => {
}, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
exports.colors = [
6,
2,
3,
4,
5,
1
];
try {
const supportsColor = require_supports_color();
if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
exports.colors = [
20,
21,
26,
27,
32,
33,
38,
39,
40,
41,
42,
43,
44,
45,
56,
57,
62,
63,
68,
69,
74,
75,
76,
77,
78,
79,
80,
81,
92,
93,
98,
99,
112,
113,
128,
129,
134,
135,
148,
149,
160,
161,
162,
163,
164,
165,
166,
167,
168,
169,
170,
171,
172,
173,
178,
179,
184,
185,
196,
197,
198,
199,
200,
201,
202,
203,
204,
205,
206,
207,
208,
209,
214,
215,
220,
221
];
}
} catch (error46) {
}
exports.inspectOpts = Object.keys(process.env).filter((key) => {
return /^debug_/i.test(key);
}).reduce((obj, key) => {
const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
return k.toUpperCase();
});
let val = process.env[key];
if (/^(yes|on|true|enabled)$/i.test(val)) {
val = true;
} else if (/^(no|off|false|disabled)$/i.test(val)) {
val = false;
} else if (val === "null") {
val = null;
} else {
val = Number(val);
}
obj[prop] = val;
return obj;
}, {});
function useColors() {
return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
}
__name(useColors, "useColors");
function formatArgs(args) {
const { namespace: name2, useColors: useColors2 } = this;
if (useColors2) {
const c = this.color;
const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
const prefix = ` ${colorCode};1m${name2} \x1B[0m`;
args[0] = prefix + args[0].split("\n").join("\n" + prefix);
args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
} else {
args[0] = getDate() + name2 + " " + args[0];
}
}
__name(formatArgs, "formatArgs");
function getDate() {
if (exports.inspectOpts.hideDate) {
return "";
}
return (/* @__PURE__ */ new Date()).toISOString() + " ";
}
__name(getDate, "getDate");
function log(...args) {
return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + "\n");
}
__name(log, "log");
function save(namespaces) {
if (namespaces) {
process.env.DEBUG = namespaces;
} else {
delete process.env.DEBUG;
}
}
__name(save, "save");
function load() {
return process.env.DEBUG;
}
__name(load, "load");
function init(debug) {
debug.inspectOpts = {};
const keys = Object.keys(exports.inspectOpts);
for (let i2 = 0; i2 < keys.length; i2++) {
debug.inspectOpts[keys[i2]] = exports.inspectOpts[keys[i2]];
}
}
__name(init, "init");
module.exports = require_common()(exports);
var { formatters } = module.exports;
formatters.o = function(v) {
this.inspectOpts.colors = this.useColors;
return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
};
formatters.O = function(v) {
this.inspectOpts.colors = this.useColors;
return util.inspect(v, this.inspectOpts);
};
}
});
// ../../node_modules/debug/src/index.js
var require_src = __commonJS({
"../../node_modules/debug/src/index.js"(exports, module) {
"use strict";
if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
module.exports = require_browser();
} else {
module.exports = require_node();
}
}
});
// ../../node_modules/agent-base/dist/helpers.js
var require_helpers = __commonJS({
"../../node_modules/agent-base/dist/helpers.js"(exports) {
"use strict";
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
if (k2 === void 0) k2 = k;
var desc2 = Object.getOwnPropertyDescriptor(m2, k);
if (!desc2 || ("get" in desc2 ? !m2.__esModule : desc2.writable || desc2.configurable)) {
desc2 = {
enumerable: true,
get: /* @__PURE__ */ __name(function() {
return m2[k];
}, "get")
};
}
Object.defineProperty(o, k2, desc2);
} : function(o, m2, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m2[k];
});
var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
Object.defineProperty(o, "default", {
enumerable: true,
value: v
});
} : function(o, v) {
o["default"] = v;
});
var __importStar = exports && exports.__importStar || function(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) {
for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
}
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.req = exports.json = exports.toBuffer = void 0;
var http3 = __importStar(__require("http"));
var https2 = __importStar(__require("https"));
async function toBuffer(stream) {
let length = 0;
const chunks = [];
for await (const chunk of stream) {
length += chunk.length;
chunks.push(chunk);
}
return Buffer.concat(chunks, length);
}
__name(toBuffer, "toBuffer");
exports.toBuffer = toBuffer;
async function json2(stream) {
const buf = await toBuffer(stream);
const str = buf.toString("utf8");
try {
return JSON.parse(str);
} catch (_err) {
const err = _err;
err.message += ` (input: ${str})`;
throw err;
}
}
__name(json2, "json");
exports.json = json2;
function req(url2, opts = {}) {
const href = typeof url2 === "string" ? url2 : url2.href;
const req1 = (href.startsWith("https:") ? https2 : http3).request(url2, opts);
const promise2 = new Promise((resolve2, reject) => {
req1.once("response", resolve2).once("error", reject).end();
});
req1.then = promise2.then.bind(promise2);
return req1;
}
__name(req, "req");
exports.req = req;
}
});
// ../../node_modules/agent-base/dist/index.js
var require_dist = __commonJS({
"../../node_modules/agent-base/dist/index.js"(exports) {
"use strict";
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
if (k2 === void 0) k2 = k;
var desc2 = Object.getOwnPropertyDescriptor(m2, k);
if (!desc2 || ("get" in desc2 ? !m2.__esModule : desc2.writable || desc2.configurable)) {
desc2 = {
enumerable: true,
get: /* @__PURE__ */ __name(function() {
return m2[k];
}, "get")
};
}
Object.defineProperty(o, k2, desc2);
} : function(o, m2, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m2[k];
});
var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
Object.defineProperty(o, "default", {
enumerable: true,
value: v
});
} : function(o, v) {
o["default"] = v;
});
var __importStar = exports && exports.__importStar || function(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) {
for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
}
__setModuleDefault(result, mod);
return result;
};
var __exportStar = exports && exports.__exportStar || function(m2, exports1) {
for (var p in m2) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports1, p)) __createBinding(exports1, m2, p);
};
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.Agent = void 0;
var net = __importStar(__require("net"));
var http3 = __importStar(__require("http"));
var https_1 = __require("https");
__exportStar(require_helpers(), exports);
var INTERNAL = Symbol("AgentBaseInternalState");
var Agent = class Agent extends http3.Agent {
static {
__name(this, "Agent");
}
constructor(opts) {
super(opts);
this[INTERNAL] = {};
}
/**
* Determine whether this is an `http` or `https` request.
*/
isSecureEndpoint(options) {
if (options) {
if (typeof options.secureEndpoint === "boolean") {
return options.secureEndpoint;
}
if (typeof options.protocol === "string") {
return options.protocol === "https:";
}
}
const { stack } = new Error();
if (typeof stack !== "string") return false;
return stack.split("\n").some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
}
// In order to support async signatures in `connect()` and Node's native
// connection pooling in `http.Agent`, the array of sockets for each origin
// has to be updated synchronously. This is so the length of the array is
// accurate when `addRequest()` is next called. We achieve this by creating a
// fake socket and adding it to `sockets[origin]` and incrementing
// `totalSocketCount`.
incrementSockets(name2) {
if (this.maxSockets === Infinity && this.maxTotalSockets === Infinity) {
return null;
}
if (!this.sockets[name2]) {
this.sockets[name2] = [];
}
const fakeSocket = new net.Socket({
writable: false
});
this.sockets[name2].push(fakeSocket);
this.totalSocketCount++;
return fakeSocket;
}
decrementSockets(name2, socket) {
if (!this.sockets[name2] || socket === null) {
return;
}
const sockets = this.sockets[name2];
const index = sockets.indexOf(socket);
if (index !== -1) {
sockets.splice(index, 1);
this.totalSocketCount--;
if (sockets.length === 0) {
delete this.sockets[name2];
}
}
}
// In order to properly update the socket pool, we need to call `getName()` on
// the core `https.Agent` if it is a secureEndpoint.
getName(options) {
const secureEndpoint = this.isSecureEndpoint(options);
if (secureEndpoint) {
return https_1.Agent.prototype.getName.call(this, options);
}
return super.getName(options);
}
createSocket(req, options, cb) {
const connectOpts = {
...options,
secureEndpoint: this.isSecureEndpoint(options)
};
const name2 = this.getName(connectOpts);
const fakeSocket = this.incrementSockets(name2);
Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
this.decrementSockets(name2, fakeSocket);
if (socket instanceof http3.Agent) {
try {
return socket.addRequest(req, connectOpts);
} catch (err) {
return cb(err);
}
}
this[INTERNAL].currentSocket = socket;
super.createSocket(req, options, cb);
}, (err) => {
this.decrementSockets(name2, fakeSocket);
cb(err);
});
}
createConnection() {
const socket = this[INTERNAL].currentSocket;
this[INTERNAL].currentSocket = void 0;
if (!socket) {
throw new Error("No socket was returned in the `connect()` function");
}
return socket;
}
get defaultPort() {
return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80);
}
set defaultPort(v) {
if (this[INTERNAL]) {
this[INTERNAL].defaultPort = v;
}
}
get protocol() {
return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:");
}
set protocol(v) {
if (this[INTERNAL]) {
this[INTERNAL].protocol = v;
}
}
};
exports.Agent = Agent;
}
});
// ../../node_modules/https-proxy-agent/dist/parse-proxy-response.js
var require_parse_proxy_response = __commonJS({
"../../node_modules/https-proxy-agent/dist/parse-proxy-response.js"(exports) {
"use strict";
var __importDefault = exports && exports.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : {
"default": mod
};
};
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.parseProxyResponse = void 0;
var debug_1 = __importDefault(require_src());
var debug = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
function parseProxyResponse(socket) {
return new Promise((resolve2, reject) => {
let buffersLength = 0;
const buffers = [];
function read() {
const b = socket.read();
if (b) ondata(b);
else socket.once("readable", read);
}
__name(read, "read");
function cleanup() {
socket.removeListener("end", onend);
socket.removeListener("error", onerror);
socket.removeListener("readable", read);
}
__name(cleanup, "cleanup");
function onend() {
cleanup();
debug("onend");
reject(new Error("Proxy connection ended before receiving CONNECT response"));
}
__name(onend, "onend");
function onerror(err) {
cleanup();
debug("onerror %o", err);
reject(err);
}
__name(onerror, "onerror");
function ondata(b) {
buffers.push(b);
buffersLength += b.length;
const buffered = Buffer.concat(buffers, buffersLength);
const endOfHeaders = buffered.indexOf("\r\n\r\n");
if (endOfHeaders === -1) {
debug("have not received end of HTTP headers yet...");
read();
return;
}
const headerParts = buffered.slice(0, endOfHeaders).toString("ascii").split("\r\n");
const firstLine = headerParts.shift();
if (!firstLine) {
socket.destroy();
return reject(new Error("No header received from proxy CONNECT response"));
}
const firstLineParts = firstLine.split(" ");
const statusCode = +firstLineParts[1];
const statusText = firstLineParts.slice(2).join(" ");
const headers = {};
for (const header of headerParts) {
if (!header) continue;
const firstColon = header.indexOf(":");
if (firstColon === -1) {
socket.destroy();
return reject(new Error(`Invalid header from proxy CONNECT response: "${header}"`));
}
const key = header.slice(0, firstColon).toLowerCase();
const value = header.slice(firstColon + 1).trimStart();
const current = headers[key];
if (typeof current === "string") {
headers[key] = [
current,
value
];
} else if (Array.isArray(current)) {
current.push(value);
} else {
headers[key] = value;
}
}
debug("got proxy server response: %o %o", firstLine, headers);
cleanup();
resolve2({
connect: {
statusCode,
statusText,
headers
},
buffered
});
}
__name(ondata, "ondata");
socket.on("error", onerror);
socket.on("end", onend);
read();
});
}
__name(parseProxyResponse, "parseProxyResponse");
exports.parseProxyResponse = parseProxyResponse;
}
});
// ../../node_modules/https-proxy-agent/dist/index.js
var require_dist2 = __commonJS({
"../../node_modules/https-proxy-agent/dist/index.js"(exports) {
"use strict";
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
if (k2 === void 0) k2 = k;
var desc2 = Object.getOwnPropertyDescriptor(m2, k);
if (!desc2 || ("get" in desc2 ? !m2.__esModule : desc2.writable || desc2.configurable)) {
desc2 = {
enumerable: true,
get: /* @__PURE__ */ __name(function() {
return m2[k];
}, "get")
};
}
Object.defineProperty(o, k2, desc2);
} : function(o, m2, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m2[k];
});
var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
Object.defineProperty(o, "default", {
enumerable: true,
value: v
});
} : function(o, v) {
o["default"] = v;
});
var __importStar = exports && exports.__importStar || function(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) {
for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
}
__setModuleDefault(result, mod);
return result;
};
var __importDefault = exports && exports.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : {
"default": mod
};
};
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.HttpsProxyAgent = void 0;
var net = __importStar(__require("net"));
var tls = __importStar(__require("tls"));
var assert_1 = __importDefault(__require("assert"));
var debug_1 = __importDefault(require_src());
var agent_base_1 = require_dist();
var url_1 = __require("url");
var parse_proxy_response_1 = require_parse_proxy_response();
var debug = (0, debug_1.default)("https-proxy-agent");
var setServernameFromNonIpHost = /* @__PURE__ */ __name((options) => {
if (options.servername === void 0 && options.host && !net.isIP(options.host)) {
return {
...options,
servername: options.host
};
}
return options;
}, "setServernameFromNonIpHost");
var HttpsProxyAgent2 = class HttpsProxyAgent extends agent_base_1.Agent {
static {
__name(this, "HttpsProxyAgent");
}
constructor(proxy, opts) {
super(opts);
this.options = {
path: void 0
};
this.proxy = typeof proxy === "string" ? new url_1.URL(proxy) : proxy;
this.proxyHeaders = opts?.headers ?? {};
debug("Creating new HttpsProxyAgent instance: %o", this.proxy.href);
const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
this.connectOpts = {
// Attempt to negotiate http/1.1 for proxy servers that support http/2
ALPNProtocols: [
"http/1.1"
],
...opts ? omit2(opts, "headers") : null,
host,
port
};
}
/**
* Called when the node-core HTTP client library is creating a
* new HTTP request.
*/
async connect(req, opts) {
const { proxy } = this;
if (!opts.host) {
throw new TypeError('No "host" provided');
}
let socket;
if (proxy.protocol === "https:") {
debug("Creating `tls.Socket`: %o", this.connectOpts);
socket = tls.connect(setServernameFromNonIpHost(this.connectOpts));
} else {
debug("Creating `net.Socket`: %o", this.connectOpts);
socket = net.connect(this.connectOpts);
}
const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : {
...this.proxyHeaders
};
const host = net.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r
`;
if (proxy.username || proxy.password) {
const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
}
headers.Host = `${host}:${opts.port}`;
if (!headers["Proxy-Connection"]) {
headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
}
for (const name2 of Object.keys(headers)) {
payload += `${name2}: ${headers[name2]}\r
`;
}
const proxyResponsePromise = (0, parse_proxy_response_1.parseProxyResponse)(socket);
socket.write(`${payload}\r
`);
const { connect, buffered } = await proxyResponsePromise;
req.emit("proxyConnect", connect);
this.emit("proxyConnect", connect, req);
if (connect.statusCode === 200) {
req.once("socket", resume);
if (opts.secureEndpoint) {
debug("Upgrading socket connection to TLS");
return tls.connect({
...omit2(setServernameFromNonIpHost(opts), "host", "path", "port"),
socket
});
}
return socket;
}
socket.destroy();
const fakeSocket = new net.Socket({
writable: false
});
fakeSocket.readable = true;
req.once("socket", (s2) => {
debug("Replaying proxy buffer for failed request");
(0, assert_1.default)(s2.listenerCount("data") > 0);
s2.push(buffered);
s2.push(null);
});
return fakeSocket;
}
};
HttpsProxyAgent2.protocols = [
"http",
"https"
];
exports.HttpsProxyAgent = HttpsProxyAgent2;
function resume(socket) {
socket.resume();
}
__name(resume, "resume");
function omit2(obj, ...keys) {
const ret = {};
let key;
for (key in obj) {
if (!keys.includes(key)) {
ret[key] = obj[key];
}
}
return ret;
}
__name(omit2, "omit");
}
});
// ../../node_modules/web-streams-polyfill/dist/ponyfill.es2018.js
var require_ponyfill_es2018 = __commonJS({
"../../node_modules/web-streams-polyfill/dist/ponyfill.es2018.js"(exports, module) {
"use strict";
(function(global1, factory) {
typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define([
"exports"
], factory) : (global1 = typeof globalThis !== "undefined" ? globalThis : global1 || self, factory(global1.WebStreamsPolyfill = {}));
})(exports, function(exports1) {
"use strict";
function noop4() {
return void 0;
}
__name(noop4, "noop");
function typeIsObject(x2) {
return typeof x2 === "object" && x2 !== null || typeof x2 === "function";
}
__name(typeIsObject, "typeIsObject");
const rethrowAssertionErrorRejection = noop4;
function setFunctionName(fn, name2) {
try {
Object.defineProperty(fn, "name", {
value: name2,
configurable: true
});
} catch (_a2) {
}
}
__name(setFunctionName, "setFunctionName");
const originalPromise = Promise;
const originalPromiseThen = Promise.prototype.then;
const originalPromiseReject = Promise.reject.bind(originalPromise);
function newPromise(executor) {
return new originalPromise(executor);
}
__name(newPromise, "newPromise");
function promiseResolvedWith(value) {
return newPromise((resolve2) => resolve2(value));
}
__name(promiseResolvedWith, "promiseResolvedWith");
function promiseRejectedWith(reason) {
return originalPromiseReject(reason);
}
__name(promiseRejectedWith, "promiseRejectedWith");
function PerformPromiseThen(promise2, onFulfilled, onRejected) {
return originalPromiseThen.call(promise2, onFulfilled, onRejected);
}
__name(PerformPromiseThen, "PerformPromiseThen");
function uponPromise(promise2, onFulfilled, onRejected) {
PerformPromiseThen(PerformPromiseThen(promise2, onFulfilled, onRejected), void 0, rethrowAssertionErrorRejection);
}
__name(uponPromise, "uponPromise");
function uponFulfillment(promise2, onFulfilled) {
uponPromise(promise2, onFulfilled);
}
__name(uponFulfillment, "uponFulfillment");
function uponRejection(promise2, onRejected) {
uponPromise(promise2, void 0, onRejected);
}
__name(uponRejection, "uponRejection");
function transformPromiseWith(promise2, fulfillmentHandler, rejectionHandler) {
return PerformPromiseThen(promise2, fulfillmentHandler, rejectionHandler);
}
__name(transformPromiseWith, "transformPromiseWith");
function setPromiseIsHandledToTrue(promise2) {
PerformPromiseThen(promise2, void 0, rethrowAssertionErrorRejection);
}
__name(setPromiseIsHandledToTrue, "setPromiseIsHandledToTrue");
let _queueMicrotask = /* @__PURE__ */ __name((callback) => {
if (typeof queueMicrotask === "function") {
_queueMicrotask = queueMicrotask;
} else {
const resolvedPromise = promiseResolvedWith(void 0);
_queueMicrotask = /* @__PURE__ */ __name((cb) => PerformPromiseThen(resolvedPromise, cb), "_queueMicrotask");
}
return _queueMicrotask(callback);
}, "_queueMicrotask");
function reflectCall(F2, V, args) {
if (typeof F2 !== "function") {
throw new TypeError("Argument is not a function");
}
return Function.prototype.apply.call(F2, V, args);
}
__name(reflectCall, "reflectCall");
function promiseCall(F2, V, args) {
try {
return promiseResolvedWith(reflectCall(F2, V, args));
} catch (value) {
return promiseRejectedWith(value);
}
}
__name(promiseCall, "promiseCall");
const QUEUE_MAX_ARRAY_SIZE = 16384;
let SimpleQueue = class SimpleQueue {
static {
__name(this, "SimpleQueue");
}
constructor() {
this._cursor = 0;
this._size = 0;
this._front = {
_elements: [],
_next: void 0
};
this._back = this._front;
this._cursor = 0;
this._size = 0;
}
get length() {
return this._size;
}
// For exception safety, this method is structured in order:
// 1. Read state
// 2. Calculate required state mutations
// 3. Perform state mutations
push(element) {
const oldBack = this._back;
let newBack = oldBack;
if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) {
newBack = {
_elements: [],
_next: void 0
};
}
oldBack._elements.push(element);
if (newBack !== oldBack) {
this._back = newBack;
oldBack._next = newBack;
}
++this._size;
}
// Like push(), shift() follows the read -> calculate -> mutate pattern for
// exception safety.
shift() {
const oldFront = this._front;
let newFront = oldFront;
const oldCursor = this._cursor;
let newCursor = oldCursor + 1;
const elements = oldFront._elements;
const element = elements[oldCursor];
if (newCursor === QUEUE_MAX_ARRAY_SIZE) {
newFront = oldFront._next;
newCursor = 0;
}
--this._size;
this._cursor = newCursor;
if (oldFront !== newFront) {
this._front = newFront;
}
elements[oldCursor] = void 0;
return elemen